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

#![allow(missing_docs)]

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

#[test]
fn cbor_round_trip_core_items() {
    let mut out = [0u8; 64];
    let len = {
        let mut enc = CborEncoder::new(&mut out);
        enc.encode_array_start(4).unwrap();
        enc.encode_u64(42).unwrap();
        enc.encode_i64(-7).unwrap();
        enc.encode_bstr(b"wolf").unwrap();
        enc.encode_tstr("COSE").unwrap();
        enc.len()
    };

    let mut dec = CborDecoder::new(&out[..len]);
    assert_eq!(dec.peek_type(), Some(CborMajorType::ARRAY));
    assert_eq!(dec.decode_array_start().unwrap(), 4);
    assert_eq!(dec.decode_u64().unwrap(), 42);
    assert_eq!(dec.decode_i64().unwrap(), -7);
    assert_eq!(dec.decode_bstr().unwrap(), b"wolf");
    assert_eq!(dec.decode_tstr_bytes().unwrap(), b"COSE");
}

#[test]
fn cbor_skip_nested_item() {
    let mut out = [0u8; 64];
    let len = {
        let mut enc = CborEncoder::new(&mut out);
        enc.encode_array_start(3).unwrap();
        enc.encode_u64(1).unwrap();
        enc.encode_array_start(2).unwrap();
        enc.encode_u64(2).unwrap();
        enc.encode_u64(3).unwrap();
        enc.encode_u64(4).unwrap();
        enc.len()
    };

    let mut dec = CborDecoder::new(&out[..len]);
    assert_eq!(dec.decode_array_start().unwrap(), 3);
    assert_eq!(dec.decode_u64().unwrap(), 1);
    dec.skip().unwrap();
    assert_eq!(dec.decode_u64().unwrap(), 4);
}

#[test]
fn cbor_reports_small_output_buffer() {
    let mut out = [0u8; 1];
    let mut enc = CborEncoder::new(&mut out);
    assert_eq!(enc.encode_u64(1000), Err(Error::BufferTooSmall));
}

#[test]
fn cbor_float_helpers_are_available() {
    let mut out = [0u8; 16];
    let mut enc = CborEncoder::new(&mut out);
    if cfg!(feature = "float") {
        enc.encode_f32(1.0).unwrap();
        enc.encode_f64(1.0).unwrap();
    } else {
        assert_eq!(enc.encode_f32(1.0), Err(Error::Unsupported));
        assert_eq!(enc.encode_f64(1.0), Err(Error::Unsupported));
    }
}