rasn 0.28.3

A safe no_std ASN.1 codec framework.
Documentation 
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use rasn::prelude::*;
pub trait LeetTrait {
    type Leet: Encode + Decode + core::fmt::Debug + Clone;

    fn leet(&self) -> Self::Leet;
}

// https://github.com/librasn/rasn/issues/193
#[test]
fn test_sequence_with_generics_issue_193() {
    #[derive(AsnType, Encode, Decode, Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    #[rasn(choice, automatic_tags)]
    pub enum Messages<T: LeetTrait> {
        Content(T::Leet),
        All(()),
    }
    #[derive(AsnType, Encode, Decode, Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    #[rasn(delegate, automatic_tags)]
    pub struct Message<T: LeetTrait>(T);

    #[derive(AsnType, Encode, Decode, Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    pub struct Hello(String);

    impl LeetTrait for Hello {
        type Leet = u16;

        fn leet(&self) -> Self::Leet {
            1337
        }
    }

    let hello_message: Message<Hello> = Message(Hello("Hello".to_string()));
    let hello_selection: Messages<Hello> = Messages::Content(hello_message.0.leet());

    let encoded = rasn::oer::encode::<Messages<Hello>>(&hello_selection).unwrap();
    assert_eq!(encoded, vec![0x80, 0x05, 0x39]);
    assert_eq!(
        hello_selection,
        rasn::oer::decode::<Messages<Hello>>(&encoded).unwrap()
    )
}

// This test is just for checking that generics will compile
#[test]
fn test_sequence_with_generic_and_constraints() {
    #[allow(dead_code)]
    #[derive(AsnType, Debug, Encode, Decode, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    #[rasn(automatic_tags)]
    pub struct ConstrainedBlock<T>
    where
        T: LeetTrait,
    {
        id: Integer,
        #[rasn(size("1.."))]
        extn: SequenceOf<T>,
    }

    #[allow(dead_code)]
    #[derive(AsnType, Debug, Encode, Decode, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    #[rasn(automatic_tags)]
    #[rasn(delegate)]
    #[rasn(size("4"))]
    pub struct ConstrainedDelegateBlock<T: LeetTrait>(T);

    #[allow(dead_code)]
    #[derive(AsnType, Debug, Encode, Decode, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    #[rasn(automatic_tags)]
    #[rasn(choice)]
    enum ConstrainedBlockEnum<T: LeetTrait> {
        First(Integer),
        #[rasn(size("1.."))]
        Second(T),
        #[rasn(value("5"))]
        Third(T),
    }
}
#[test]
fn test_multi_field_tuple_structs_with_phantom_data() {
    use core::marker::PhantomData;
    // without phantom data
    #[derive(AsnType, Debug, Encode, Decode, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    #[rasn(automatic_tags)]
    #[rasn(delegate)]
    pub struct TupleStruct(u8);

    let encoded = rasn::oer::encode::<TupleStruct>(&TupleStruct(1)).unwrap();

    #[derive(AsnType, Debug, Encode, Decode, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    #[rasn(delegate, automatic_tags)]
    pub struct TupleStructWithPhantomData<T: Ord>(u8, PhantomData<T>);
    let encoded2 = rasn::oer::encode::<TupleStructWithPhantomData<u32>>(
        &TupleStructWithPhantomData(1, PhantomData),
    )
    .unwrap();

    #[derive(AsnType, Debug, Encode, Decode, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    #[rasn(automatic_tags)]
    #[rasn(delegate)]
    pub struct TupleStructWithTwoPhantomData<T: Ord>(u8, PhantomData<T>, PhantomData<T>);
    let encoded3 = rasn::oer::encode::<TupleStructWithTwoPhantomData<u32>>(
        &TupleStructWithTwoPhantomData(1, PhantomData, PhantomData),
    )
    .unwrap();

    #[derive(AsnType, Debug, Encode, Decode, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
    #[rasn(automatic_tags)]
    #[rasn(delegate)]
    pub struct TupleStructWithThreePhantomData<T: Ord>(
        u8,
        PhantomData<T>,
        PhantomData<T>,
        PhantomData<T>,
    );
    let encoded4 = rasn::oer::encode::<TupleStructWithThreePhantomData<u32>>(
        &TupleStructWithThreePhantomData(1, PhantomData, PhantomData, PhantomData),
    )
    .unwrap();
    assert_eq!(&encoded, &encoded2);
    assert_eq!(&encoded, &encoded3);
    assert_eq!(&encoded, &encoded4);
    let decoded = rasn::oer::decode::<TupleStruct>(&encoded).unwrap();
    assert_eq!(decoded, TupleStruct(1));
    let decoded2 = rasn::oer::decode::<TupleStructWithPhantomData<u32>>(&encoded2).unwrap();
    assert_eq!(decoded2, TupleStructWithPhantomData(1, PhantomData));
    let decoded3 = rasn::oer::decode::<TupleStructWithTwoPhantomData<u32>>(&encoded3).unwrap();
    assert_eq!(
        decoded3,
        TupleStructWithTwoPhantomData(1, PhantomData, PhantomData)
    );
    let decoded4 = rasn::oer::decode::<TupleStructWithThreePhantomData<u32>>(&encoded4).unwrap();
    assert_eq!(
        decoded4,
        TupleStructWithThreePhantomData(1, PhantomData, PhantomData, PhantomData)
    );
}