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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

#![allow(missing_docs)]

use std::collections::BTreeMap;
use wolfcose::{
    from_slice, to_vec, ByteStr, CborDeserializer, CborSerialize, CborSerializer, CborValue, Error,
};

#[test]
fn serializer_helper_methods_and_overflows_are_covered() {
    let encoded = to_vec(&[1u8, 2, 3]).unwrap();
    let mut deserializer = CborDeserializer::new(&encoded);
    assert_eq!(deserializer.array_values::<u8>().unwrap(), vec![1, 2, 3]);

    let encoded = to_vec(&BTreeMap::from([
        ("a".to_owned(), 1u8),
        ("b".to_owned(), 2u8),
    ]))
    .unwrap();
    let mut deserializer = CborDeserializer::new(&encoded);
    let entries = deserializer.map_values::<String, u8>().unwrap();
    assert_eq!(entries.len(), 2);

    let encoded = to_vec(&ByteStr(b"bytes")).unwrap();
    let mut deserializer = CborDeserializer::new(&encoded);
    assert_eq!(deserializer.borrowed_bytes().unwrap(), b"bytes");
    let encoded = to_vec("text").unwrap();
    let mut deserializer = CborDeserializer::new(&encoded);
    assert_eq!(deserializer.borrowed_str().unwrap(), "text");

    assert_eq!(ByteStr(b"x").as_bytes(), b"x");
    assert_eq!(from_slice::<()>(&to_vec(&()).unwrap()).unwrap(), ());
    assert_eq!(from_slice::<usize>(&to_vec(&3usize).unwrap()).unwrap(), 3);
    assert_eq!(from_slice::<isize>(&to_vec(&-3isize).unwrap()).unwrap(), -3);
    assert_eq!(
        from_slice::<u8>(&to_vec(&1000u64).unwrap()),
        Err(Error::CborOverflow)
    );
    assert_eq!(
        from_slice::<i8>(&to_vec(&1000i64).unwrap()),
        Err(Error::CborOverflow)
    );
    assert_eq!(
        from_slice::<[u8; 2]>(&to_vec(&[1u8, 2, 3]).unwrap()),
        Err(Error::CborMalformed)
    );
    assert_eq!(
        from_slice::<(u8, u8, u8, u8, u8, u8)>(&to_vec(&(1u8, 2u8, 3u8, 4u8, 5u8, 6u8)).unwrap())
            .unwrap(),
        (1, 2, 3, 4, 5, 6)
    );
    assert_eq!(
        from_slice::<(u8,)>(&to_vec(&(9u8,)).unwrap()).unwrap(),
        (9,)
    );
    assert_eq!(
        from_slice::<(u8, u8)>(&to_vec(&(9u8,)).unwrap()),
        Err(Error::CborMalformed)
    );

    struct Big;
    impl CborSerialize for Big {
        fn serialize(&self, serializer: &mut CborSerializer<'_>) -> wolfcose::Result<()> {
            serializer.str(&"x".repeat(300))
        }
    }
    assert_eq!(
        from_slice::<String>(&to_vec(&Big).unwrap()).unwrap().len(),
        300
    );

    struct Bad;
    impl CborSerialize for Bad {
        fn serialize(&self, _serializer: &mut CborSerializer<'_>) -> wolfcose::Result<()> {
            Err(Error::InvalidArgument)
        }
    }
    assert_eq!(to_vec(&Bad), Err(Error::InvalidArgument));
}

#[test]
fn serializer_and_type_metadata_cover_remaining_variants() {
    let mut map = BTreeMap::new();
    map.insert("a".to_owned(), 1u8);
    map.insert("b".to_owned(), 2u8);
    let decoded: BTreeMap<String, u8> = from_slice(&to_vec(&map).unwrap()).unwrap();
    assert_eq!(decoded, map);

    let values = [
        CborValue::Null,
        CborValue::Bool(true),
        CborValue::Bool(false),
        CborValue::Bytes(vec![1, 2]),
        CborValue::Tag(99, Box::new(CborValue::Text("tagged".to_owned()))),
    ];
    for value in values {
        assert_eq!(
            from_slice::<CborValue>(&to_vec(&value).unwrap()).unwrap(),
            value
        );
    }

    let encoded_bytes = to_vec(&ByteStr(b"borrowed")).unwrap();
    let bytes: &[u8] = from_slice(&encoded_bytes).unwrap();
    assert_eq!(bytes, b"borrowed");
}