packed_encoder/
lib.rs

1pub mod decoder;
2pub mod encoder;
3
4#[test]
5fn test_encode_numbers_little() {
6    let to_encode_numbers = &[
7        encoder::EncodeType::Int8(-10),
8        encoder::EncodeType::Int16(-2212),
9        encoder::EncodeType::Int32(-2123453),
10        encoder::EncodeType::Int64(-23334232333),
11        encoder::EncodeType::Int128(-456784564567848),
12        encoder::EncodeType::Uint8(122),
13        encoder::EncodeType::Int16(2212),
14        encoder::EncodeType::Int32(2123453),
15        encoder::EncodeType::Int64(23334232333),
16        encoder::EncodeType::Uint128(456784564567848),
17    ];
18
19    let decoded_expected_numbers = &[
20        decoder::DecodedData::Int8(-10),
21        decoder::DecodedData::Int16(-2212),
22        decoder::DecodedData::Int32(-2123453),
23        decoder::DecodedData::Int64(-23334232333),
24        decoder::DecodedData::Int128(-456784564567848),
25        decoder::DecodedData::Uint8(122),
26        decoder::DecodedData::Int16(2212),
27        decoder::DecodedData::Int32(2123453),
28        decoder::DecodedData::Int64(23334232333),
29        decoder::DecodedData::Uint128(456784564567848),
30    ];
31
32    let decoded_expected_types = &[
33        decoder::DecodeType::Int8,
34        decoder::DecodeType::Int16,
35        decoder::DecodeType::Int32,
36        decoder::DecodeType::Int64,
37        decoder::DecodeType::Int128,
38        decoder::DecodeType::Uint8,
39        decoder::DecodeType::Int16,
40        decoder::DecodeType::Int32,
41        decoder::DecodeType::Int64,
42        decoder::DecodeType::Uint128,
43    ];
44
45    // test numbers
46    let encoded_data_result =
47        encoder::encode_packed(to_encode_numbers, encoder::EncodeOrder::Little);
48
49    assert_eq!(encoded_data_result.is_ok(), true);
50
51    // verify the length
52    let encoded_data = encoded_data_result.unwrap();
53    assert_eq!(encoded_data.len(), 31 * 2);
54
55    // decode
56    let decoded_data_result = decoder::decode_packed(
57        decoded_expected_types,
58        &encoded_data,
59        decoder::DecodeOrder::Little,
60    );
61
62    assert_eq!(decoded_data_result.is_ok(), true);
63
64    // verify the result
65    let decoded_data = decoded_data_result.unwrap();
66    for (idx, entry) in decoded_data.iter().enumerate() {
67        assert_eq!(*entry == decoded_expected_numbers[idx], true);
68    }
69}
70
71#[test]
72fn test_encode_numbers_big() {
73    let to_encode_numbers = &[
74        encoder::EncodeType::Int8(-10),
75        encoder::EncodeType::Int16(-2212),
76        encoder::EncodeType::Int32(-2123453),
77        encoder::EncodeType::Int64(-23334232333),
78        encoder::EncodeType::Int128(-456784564567848),
79        encoder::EncodeType::Uint8(122),
80        encoder::EncodeType::Int16(2212),
81        encoder::EncodeType::Int32(2123453),
82        encoder::EncodeType::Int64(23334232333),
83        encoder::EncodeType::Uint128(456784564567848),
84    ];
85
86    let decoded_expected_numbers = &[
87        decoder::DecodedData::Int8(-10),
88        decoder::DecodedData::Int16(-2212),
89        decoder::DecodedData::Int32(-2123453),
90        decoder::DecodedData::Int64(-23334232333),
91        decoder::DecodedData::Int128(-456784564567848),
92        decoder::DecodedData::Uint8(122),
93        decoder::DecodedData::Int16(2212),
94        decoder::DecodedData::Int32(2123453),
95        decoder::DecodedData::Int64(23334232333),
96        decoder::DecodedData::Uint128(456784564567848),
97    ];
98
99    let decoded_expected_types = &[
100        decoder::DecodeType::Int8,
101        decoder::DecodeType::Int16,
102        decoder::DecodeType::Int32,
103        decoder::DecodeType::Int64,
104        decoder::DecodeType::Int128,
105        decoder::DecodeType::Uint8,
106        decoder::DecodeType::Int16,
107        decoder::DecodeType::Int32,
108        decoder::DecodeType::Int64,
109        decoder::DecodeType::Uint128,
110    ];
111
112    // test numbers
113    let encoded_data_result = encoder::encode_packed(to_encode_numbers, encoder::EncodeOrder::Big);
114
115    assert_eq!(encoded_data_result.is_ok(), true);
116
117    // verify the length
118    let encoded_data = encoded_data_result.unwrap();
119    assert_eq!(encoded_data.len(), 31 * 2);
120
121    // decode
122    let decoded_data_result = decoder::decode_packed(
123        decoded_expected_types,
124        &encoded_data,
125        decoder::DecodeOrder::Big,
126    );
127
128    assert_eq!(decoded_data_result.is_ok(), true);
129
130    // verify the result
131    let decoded_data = decoded_data_result.unwrap();
132    for (idx, entry) in decoded_data.iter().enumerate() {
133        assert_eq!(*entry == decoded_expected_numbers[idx], true);
134    }
135}
136
137#[test]
138fn test_strings_and_bytes() {
139    let to_encode_data = &[
140        encoder::EncodeType::Str("hello".to_string()),
141        encoder::EncodeType::Bytes(vec![0, 1, 2, 3, 4]),
142        encoder::EncodeType::Bytes(vec![0, 10, 20, 30]),
143        encoder::EncodeType::Str("world!!".to_string()),
144    ];
145
146    let expected_decoded_data = &[
147        decoder::DecodedData::Str("hello".to_string()),
148        decoder::DecodedData::Bytes(vec![0, 1, 2, 3, 4]),
149        decoder::DecodedData::Bytes(vec![0, 10, 20, 30]),
150        decoder::DecodedData::Str("world!!".to_string()),
151    ];
152
153    let decoded_data_types = &[
154        decoder::DecodeType::Str(5),
155        decoder::DecodeType::Bytes(5),
156        decoder::DecodeType::Bytes(4),
157        decoder::DecodeType::Str(7),
158    ];
159
160    let encoded_result = encoder::encode_packed(to_encode_data, encoder::EncodeOrder::Little);
161
162    assert_eq!(encoded_result.is_ok(), true);
163    let encoded_data = encoded_result.unwrap();
164
165    assert_eq!(encoded_data.len(), 21);
166
167    // decode data back
168    let decoded_result = decoder::decode_packed(
169        decoded_data_types,
170        &encoded_data,
171        decoder::DecodeOrder::Little,
172    );
173    assert_eq!(decoded_result.is_ok(), true);
174
175    let decoded_data = decoded_result.unwrap();
176
177    for (idx, element) in decoded_data.iter().enumerate() {
178        assert_eq!(*element == expected_decoded_data[idx], true);
179    }
180}
181
182#[test]
183fn encode_decode_mixed() {
184    let to_encode = &[
185        encoder::EncodeType::Int128(-234984564544),
186        encoder::EncodeType::Str("this-is-good".to_owned()),
187        encoder::EncodeType::Uint64(837477899),
188        encoder::EncodeType::Int8(10),
189        encoder::EncodeType::Bytes(vec![0xff, 0xab, 0x12, 0x33]),
190    ];
191
192    let encoded_result = encoder::encode_packed(to_encode, encoder::EncodeOrder::Little);
193    assert_eq!(encoded_result.is_ok(), true);
194
195    let encoded_data = encoded_result.unwrap();
196
197    let to_decode = &[
198        decoder::DecodeType::Int128,
199        decoder::DecodeType::Str(12),
200        decoder::DecodeType::Uint64,
201        decoder::DecodeType::Int8,
202        decoder::DecodeType::Bytes(4),
203    ];
204
205    let expected_decoded_data = &[
206        decoder::DecodedData::Int128(-234984564544),
207        decoder::DecodedData::Str("this-is-good".to_owned()),
208        decoder::DecodedData::Uint64(837477899),
209        decoder::DecodedData::Int8(10),
210        decoder::DecodedData::Bytes(vec![0xff, 0xab, 0x12, 0x33]),
211    ];
212
213    let decoded_result =
214        decoder::decode_packed(to_decode, &encoded_data, decoder::DecodeOrder::Little);
215    assert_eq!(decoded_result.is_ok(), true);
216
217    let decoded_data = decoded_result.unwrap();
218
219    for (idx, element) in decoded_data.iter().enumerate() {
220        assert_eq!(*element == expected_decoded_data[idx], true);
221    }
222}
223
224#[test]
225fn test_struct_interoperability() {
226    #[repr(C, packed)]
227    struct Sample {
228        pub x: u8,
229        pub y: [u8; 5],
230        pub z: i64,
231        pub a: [char; 5],
232    }
233
234    let to_encode = &[
235        encoder::EncodeType::Uint8(100),
236        encoder::EncodeType::Bytes(vec![0, 1, 2, 3, 4]),
237        encoder::EncodeType::Int64(256),
238        encoder::EncodeType::Str("hello".to_owned()),
239    ];
240
241    let encode_result = encoder::encode_packed(to_encode, encoder::EncodeOrder::Little);
242    assert_eq!(encode_result.is_ok(), true);
243
244    let encoded_data = encode_result.unwrap();
245
246    unsafe {
247        let sample: *const Sample = encoded_data.as_ptr() as *const Sample;
248        assert_eq!((*sample).x == 100, true);
249        assert_eq!((*sample).y == [0, 1, 2, 3, 4], true);
250        assert_eq!((*sample).z == 256, true);
251    }
252}
packed_encoder/lib.rs

packed_encoder/
lib.rs
