wolfcose 0.1.0

Safe Rust API for wolfSSL wolfCOSE.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#![allow(missing_docs)]

use wolfcose::{CborDecoder, CborEncoder, CborMajorType, Error};

#[test]
fn cbor_primitive_edge_cases_are_covered() {
    assert_eq!(CborMajorType::from_raw(99), None);
    assert_eq!(
        CborMajorType::TEXT.raw(),
        wolfcose::raw::WOLFCOSE_CBOR_TSTR as u8
    );

    let mut empty = CborDecoder::new(&[]);
    assert!(empty.is_empty());
    assert_eq!(empty.peek_type(), None);
    assert_eq!(empty.peek_initial_byte(), None);
    assert_eq!(empty.decode_head(), Err(Error::CborMalformed));

    let mut out = [0; 64];
    let len = {
        let mut encoder = CborEncoder::new(&mut out);
        assert!(encoder.is_empty());
        encoder.encode_bstr(&[]).unwrap();
        encoder.encode_tstr("").unwrap();
        encoder.encode_true().unwrap();
        encoder.encode_false().unwrap();
        encoder.encode_null().unwrap();
        encoder.len()
    };
    let mut decoder = CborDecoder::new(&out[..len]);
    let bstr = decoder.decode_head().unwrap();
    assert_eq!(bstr.major_type, CborMajorType::BYTES);
    assert_eq!(bstr.data, Some(&[][..]));
    let tstr = decoder.decode_head().unwrap();
    assert_eq!(tstr.major_type, CborMajorType::TEXT);
    assert_eq!(tstr.data, Some(&[][..]));
    assert!(decoder.decode_bool().unwrap());
    assert!(!decoder.decode_bool().unwrap());
    decoder.decode_null().unwrap();
    assert!(decoder.is_finished());

    let mut encoded = [0; 8];
    let len = {
        let mut encoder = CborEncoder::new(&mut encoded);
        encoder.encode_u64(1).unwrap();
        encoder.len()
    };
    let mut decoder = CborDecoder::new(&encoded[..len]);
    assert_eq!(decoder.decode_null(), Err(Error::CborType));
    let mut decoder = CborDecoder::new(&encoded[..len]);
    assert_eq!(decoder.decode_bool(), Err(Error::CborType));

    let mut encoded = [0; 8];
    let len = {
        let mut encoder = CborEncoder::new(&mut encoded);
        encoder.encode_null().unwrap();
        encoder.len()
    };
    let mut decoder = CborDecoder::new(&encoded[..len]);
    assert_eq!(decoder.decode_bool(), Err(Error::CborType));

    let mut encoded = [0; 8];
    let len = {
        let mut encoder = CborEncoder::new(&mut encoded);
        encoder.encode_bstr(&[]).unwrap();
        encoder.len()
    };
    let mut decoder = CborDecoder::new(&encoded[..len]);
    assert_eq!(decoder.decode_bstr().unwrap(), b"");
    let len = {
        let mut encoder = CborEncoder::new(&mut encoded);
        encoder.encode_tstr("").unwrap();
        encoder.len()
    };
    let mut decoder = CborDecoder::new(&encoded[..len]);
    assert_eq!(decoder.decode_tstr_bytes().unwrap(), b"");
}