1 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
2 // Copyright by contributors to this project.
3 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
4
5 use mls_rs_codec::{MlsDecode, MlsEncode, MlsSize};
6
7 #[derive(Debug, Clone, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
8 struct TestTupleStruct(u64);
9
10 #[derive(Debug, Clone, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
11 struct TestFieldStruct {
12 item1: Option<u8>,
13 item2: u64,
14 }
15
16 #[derive(Debug, Clone, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
17 struct TestType {
18 field_a: u8,
19 field_b: Vec<u8>,
20 field_c: u16,
21 field_d: Option<Vec<u8>>,
22 field_e: u32,
23 field_f: Option<u16>,
24 field_g: Vec<TestTupleStruct>,
25 field_h: TestFieldStruct,
26 }
27
28 #[repr(u16)]
29 #[derive(Debug, Clone, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
30 enum TestEnum {
31 Case1 = 1u16,
32 Case2(TestFieldStruct) = 200u16,
33 Case3(TestTupleStruct) = 42u16,
34 }
35
36 #[derive(Debug, Clone, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
37 #[repr(u8)]
38 enum TestEnumWithoutSuffixedLiterals {
39 Case1 = 1,
40 Case2(TestFieldStruct) = 200,
41 Case3(TestTupleStruct) = 42,
42 }
43
44 #[derive(Debug, Clone, PartialEq, Eq, MlsSize, MlsEncode, MlsDecode)]
45 struct TestGeneric<T: MlsSize + MlsEncode + MlsDecode>(T);
46
47 #[test]
round_trip_struct_encode()48 fn round_trip_struct_encode() {
49 let item = TestType {
50 field_a: 42,
51 field_b: vec![1, 3, 5, 7, 9],
52 field_c: 65000,
53 field_d: Some(vec![0, 2, 4, 6, 8]),
54 field_e: 1000000,
55 field_f: None,
56 field_g: vec![
57 TestTupleStruct(100),
58 TestTupleStruct(200),
59 TestTupleStruct(300),
60 ],
61 field_h: TestFieldStruct {
62 item1: Some(42),
63 item2: 84,
64 },
65 };
66
67 let data = item.mls_encode_to_vec().unwrap();
68 let restored = TestType::mls_decode(&mut &*data).unwrap();
69
70 assert_eq!(restored, item);
71 }
72
73 #[test]
round_trip_generic_encode()74 fn round_trip_generic_encode() {
75 let item = TestGeneric(42u16);
76 let data = item.mls_encode_to_vec().unwrap();
77 let restored = TestGeneric::mls_decode(&mut &*data).unwrap();
78
79 assert_eq!(restored, item);
80 }
81
82 #[test]
round_trip_enum_encode_simple()83 fn round_trip_enum_encode_simple() {
84 let item = TestEnum::Case1;
85
86 let serialized = item.mls_encode_to_vec().unwrap();
87 let decoded = TestEnum::mls_decode(&mut &*serialized).unwrap();
88
89 assert_eq!(serialized, 1u16.mls_encode_to_vec().unwrap());
90 assert_eq!(decoded, item);
91 }
92
93 #[test]
round_trip_enum_encode_one_field()94 fn round_trip_enum_encode_one_field() {
95 let item = TestEnum::Case2(TestFieldStruct {
96 item1: None,
97 item2: 42,
98 });
99
100 let serialized = item.mls_encode_to_vec().unwrap();
101 let decoded = TestEnum::mls_decode(&mut &*serialized).unwrap();
102
103 assert_eq!(decoded, item);
104 }
105
106 #[test]
round_trip_enum_encode_one_tuple()107 fn round_trip_enum_encode_one_tuple() {
108 let item = TestEnum::Case3(TestTupleStruct(42));
109
110 let serialized = item.mls_encode_to_vec().unwrap();
111 let decoded = TestEnum::mls_decode(&mut &*serialized).unwrap();
112
113 assert_eq!(decoded, item);
114 }
115
116 #[test]
round_trip_custom_module_struct()117 fn round_trip_custom_module_struct() {
118 #[derive(Debug, PartialEq, Eq, Clone, MlsSize, MlsEncode, MlsDecode)]
119 struct TestCustomStruct {
120 #[mls_codec(with = "self::test_with")]
121 value: u8,
122 }
123
124 let item = TestCustomStruct { value: 33 };
125
126 let serialized = item.mls_encode_to_vec().unwrap();
127 assert_eq!(serialized.len(), 2);
128
129 let decoded = TestCustomStruct::mls_decode(&mut &*serialized).unwrap();
130 assert_eq!(item, decoded);
131 }
132
133 #[test]
round_trip_custom_module_enum()134 fn round_trip_custom_module_enum() {
135 #[derive(Debug, PartialEq, Eq, Clone, MlsSize, MlsEncode, MlsDecode)]
136 #[repr(u16)]
137 enum TestCustomEnum {
138 CustomCase(#[mls_codec(with = "self::test_with")] u8) = 2u16,
139 }
140
141 let item = TestCustomEnum::CustomCase(33);
142
143 let serialized = item.mls_encode_to_vec().unwrap();
144 assert_eq!(serialized.len(), 4);
145
146 let decoded = TestCustomEnum::mls_decode(&mut &*serialized).unwrap();
147 assert_eq!(item, decoded)
148 }
149
150 mod test_with {
151 use mls_rs_codec::MlsDecode;
152
mls_encoded_len(_val: &u8) -> usize153 pub fn mls_encoded_len(_val: &u8) -> usize {
154 2
155 }
156
mls_encode(val: &u8, writer: &mut Vec<u8>) -> Result<(), mls_rs_codec::Error>157 pub fn mls_encode(val: &u8, writer: &mut Vec<u8>) -> Result<(), mls_rs_codec::Error> {
158 writer.extend([*val, 42]);
159 Ok(())
160 }
161
mls_decode(reader: &mut &[u8]) -> Result<u8, mls_rs_codec::Error>162 pub fn mls_decode(reader: &mut &[u8]) -> Result<u8, mls_rs_codec::Error> {
163 Ok(<[u8; 2]>::mls_decode(reader)?[0])
164 }
165 }
166