1use crate::{Decode, DecodeError, Encode};
2
3impl Encode for i32 {
4 fn encode(&self, buf: &mut Vec<u8>) {
5 buf.extend_from_slice(&self.to_be_bytes());
6 }
7}
8
9impl Decode for i32 {
10 fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
11 if buf.len() < 4 {
12 return Err(DecodeError::UnexpectedEof);
13 }
14
15 let (bytes, rest) = buf.split_at(4);
16 *buf = rest;
17
18 let mut array = [0u8; 4];
19 array.copy_from_slice(bytes);
20 Ok(i32::from_be_bytes(array))
21 }
22}
23
24impl Encode for u8 {
25 fn encode(&self, buf: &mut Vec<u8>) {
26 buf.push(*self);
27 }
28}
29
30impl Decode for u8 {
31 fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
32 if buf.is_empty() {
33 return Err(DecodeError::UnexpectedEof);
34 }
35
36 let value = buf[0];
37 *buf = &buf[1..];
38 Ok(value)
39 }
40}
41
42impl Encode for i8 {
43 fn encode(&self, buf: &mut Vec<u8>) {
44 buf.push(*self as u8);
45 }
46}
47
48impl Decode for i8 {
49 fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
50 if buf.is_empty() {
51 return Err(DecodeError::UnexpectedEof);
52 }
53
54 let value = buf[0] as i8;
55 *buf = &buf[1..];
56 Ok(value)
57 }
58}
59
60impl Encode for i64 {
61 fn encode(&self, buf: &mut Vec<u8>) {
62 buf.extend_from_slice(&self.to_be_bytes());
63 }
64}
65
66impl Decode for i64 {
67 fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
68 if buf.len() < 8 {
69 return Err(DecodeError::UnexpectedEof);
70 }
71
72 let (bytes, rest) = buf.split_at(8);
73 *buf = rest;
74
75 let mut array = [0u8; 8];
76 array.copy_from_slice(bytes);
77 Ok(i64::from_be_bytes(array))
78 }
79}
80
81impl Encode for u64 {
82 fn encode(&self, buf: &mut Vec<u8>) {
83 buf.extend_from_slice(&self.to_be_bytes());
84 }
85}
86
87impl Decode for u64 {
88 fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
89 if buf.len() < 8 {
90 return Err(DecodeError::UnexpectedEof);
91 }
92
93 let (bytes, rest) = buf.split_at(8);
94 *buf = rest;
95
96 let mut array = [0u8; 8];
97 array.copy_from_slice(bytes);
98 Ok(u64::from_be_bytes(array))
99 }
100}
101
102impl Encode for u32 {
103 fn encode(&self, buf: &mut Vec<u8>) {
104 buf.extend_from_slice(&self.to_be_bytes());
105 }
106}
107
108impl Decode for u32 {
109 fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
110 if buf.len() < 4 {
111 return Err(DecodeError::UnexpectedEof);
112 }
113
114 let (bytes, rest) = buf.split_at(4);
115 *buf = rest;
116
117 let mut array = [0u8; 4];
118 array.copy_from_slice(bytes);
119 Ok(u32::from_be_bytes(array))
120 }
121}
122
123impl Encode for u16 {
124 fn encode(&self, buf: &mut Vec<u8>) {
125 buf.extend_from_slice(&self.to_be_bytes());
126 }
127}
128
129impl Decode for u16 {
130 fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
131 if buf.len() < 2 {
132 return Err(DecodeError::UnexpectedEof);
133 }
134
135 let (bytes, rest) = buf.split_at(2);
136 *buf = rest;
137
138 let mut array = [0u8; 2];
139 array.copy_from_slice(bytes);
140 Ok(u16::from_be_bytes(array))
141 }
142}
143
144impl Encode for i16 {
145 fn encode(&self, buf: &mut Vec<u8>) {
146 buf.extend_from_slice(&self.to_be_bytes());
147 }
148}
149
150impl Decode for i16 {
151 fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError> {
152 if buf.len() < 2 {
153 return Err(DecodeError::UnexpectedEof);
154 }
155
156 let (bytes, rest) = buf.split_at(2);
157 *buf = rest;
158
159 let mut array = [0u8; 2];
160 array.copy_from_slice(bytes);
161 Ok(i16::from_be_bytes(array))
162 }
163}
164
165#[cfg(test)]
166mod tests {
167 use super::*;
168
169 #[test]
170 fn test_i32_big_endian() {
171 let value = 12345i32;
172 let mut buf = Vec::new();
173 value.encode(&mut buf);
174 assert_eq!(buf.len(), 4);
175
176 let mut slice = buf.as_slice();
177 let decoded = i32::decode(&mut slice).unwrap();
178 assert_eq!(decoded, value);
179 }
180
181 #[test]
182 fn test_u8_single_byte() {
183 let value = 255u8;
184 let mut buf = Vec::new();
185 value.encode(&mut buf);
186 assert_eq!(buf, vec![255]);
187
188 let mut slice = buf.as_slice();
189 let decoded = u8::decode(&mut slice).unwrap();
190 assert_eq!(decoded, value);
191 }
192
193 #[test]
194 fn test_u64_roundtrip() {
195 let value = 9223372036854775807u64;
196 let mut buf = Vec::new();
197 value.encode(&mut buf);
198
199 let mut slice = buf.as_slice();
200 let decoded = u64::decode(&mut slice).unwrap();
201 assert_eq!(decoded, value);
202 }
203
204 #[test]
205 fn test_i64_big_endian() {
206 let value = -123456i64;
207 let mut buf = Vec::new();
208 value.encode(&mut buf);
209
210 let mut slice = buf.as_slice();
211 let decoded = i64::decode(&mut slice).unwrap();
212 assert_eq!(decoded, value);
213 }
214
215 #[test]
216 fn test_u32_roundtrip() {
217 let value = 4294967295u32;
218 let mut buf = Vec::new();
219 value.encode(&mut buf);
220
221 let mut slice = buf.as_slice();
222 let decoded = u32::decode(&mut slice).unwrap();
223 assert_eq!(decoded, value);
224 }
225
226 #[test]
227 fn test_i32_exact_bytes() {
228 let value: i32 = 0x12345678;
229 let mut buf = Vec::new();
230 value.encode(&mut buf);
231
232 assert_eq!(buf, vec![0x12, 0x34, 0x56, 0x78]);
233 }
234
235 #[test]
236 fn test_i32_zero() {
237 let mut buf = Vec::new();
238 (0i32).encode(&mut buf);
239 assert_eq!(buf, vec![0x00, 0x00, 0x00, 0x00]);
240 }
241
242 #[test]
243 fn test_i32_negative_one() {
244 let mut buf = Vec::new();
245 (-1i32).encode(&mut buf);
246 assert_eq!(buf, vec![0xFF, 0xFF, 0xFF, 0xFF]);
247 }
248
249 #[test]
250 fn test_i32_max() {
251 let mut buf = Vec::new();
252 (i32::MAX).encode(&mut buf);
253 assert_eq!(buf, vec![0x7F, 0xFF, 0xFF, 0xFF]);
254 }
255
256 #[test]
257 fn test_i32_min() {
258 let mut buf = Vec::new();
259 (i32::MIN).encode(&mut buf);
260 assert_eq!(buf, vec![0x80, 0x00, 0x00, 0x00]);
261 }
262
263 #[test]
264 fn test_u8_exact_bytes() {
265 let values = [0u8, 1, 127, 128, 255];
266 for value in &values {
267 let mut buf = Vec::new();
268 value.encode(&mut buf);
269 assert_eq!(buf, vec![*value]);
270 }
271 }
272
273 #[test]
274 fn test_i8_single_byte() {
275 let value = 42i8;
276 let mut buf = Vec::new();
277 value.encode(&mut buf);
278 assert_eq!(buf.len(), 1);
279
280 let mut slice = buf.as_slice();
281 let decoded = i8::decode(&mut slice).unwrap();
282 assert_eq!(decoded, value);
283 }
284
285 #[test]
286 fn test_i8_negative() {
287 let value = -1i8;
288 let mut buf = Vec::new();
289 value.encode(&mut buf);
290 assert_eq!(buf, vec![0xFF]);
291
292 let mut slice = buf.as_slice();
293 let decoded = i8::decode(&mut slice).unwrap();
294 assert_eq!(decoded, value);
295 }
296
297 #[test]
298 fn test_i8_zero() {
299 let value = 0i8;
300 let mut buf = Vec::new();
301 value.encode(&mut buf);
302 assert_eq!(buf, vec![0x00]);
303
304 let mut slice = buf.as_slice();
305 let decoded = i8::decode(&mut slice).unwrap();
306 assert_eq!(decoded, value);
307 }
308
309 #[test]
310 fn test_i8_max() {
311 let value = i8::MAX;
312 let mut buf = Vec::new();
313 value.encode(&mut buf);
314 assert_eq!(buf, vec![0x7F]);
315
316 let mut slice = buf.as_slice();
317 let decoded = i8::decode(&mut slice).unwrap();
318 assert_eq!(decoded, value);
319 }
320
321 #[test]
322 fn test_i8_min() {
323 let value = i8::MIN;
324 let mut buf = Vec::new();
325 value.encode(&mut buf);
326 assert_eq!(buf, vec![0x80]);
327
328 let mut slice = buf.as_slice();
329 let decoded = i8::decode(&mut slice).unwrap();
330 assert_eq!(decoded, value);
331 }
332
333 #[test]
334 fn test_i8_roundtrip() {
335 let values = [0i8, 1, -1, 127, -128, 42, -42];
336 for value in &values {
337 let mut buf = Vec::new();
338 value.encode(&mut buf);
339
340 let mut slice = buf.as_slice();
341 let decoded = i8::decode(&mut slice).unwrap();
342 assert_eq!(decoded, *value);
343 }
344 }
345
346 #[test]
347 fn test_i8_eof() {
348 let buf = Vec::new();
349 let mut slice = buf.as_slice();
350 let result = i8::decode(&mut slice);
351 assert!(result.is_err());
352 }
353
354 #[test]
355 fn test_i64_exact_bytes() {
356 let value: i64 = 0x0102030405060708;
357 let mut buf = Vec::new();
358 value.encode(&mut buf);
359 assert_eq!(buf, vec![0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
360 }
361
362 #[test]
363 fn test_i64_negative_one() {
364 let mut buf = Vec::new();
365 (-1i64).encode(&mut buf);
366 assert_eq!(buf, vec![0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
367 }
368
369 #[test]
370 fn test_i64_max() {
371 let mut buf = Vec::new();
372 (i64::MAX).encode(&mut buf);
373 assert_eq!(buf, vec![0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
374 }
375
376 #[test]
377 fn test_i64_min() {
378 let mut buf = Vec::new();
379 (i64::MIN).encode(&mut buf);
380 assert_eq!(buf, vec![0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
381 }
382
383 #[test]
384 fn test_u32_exact_bytes() {
385 let value: u32 = 0xAABBCCDD;
386 let mut buf = Vec::new();
387 value.encode(&mut buf);
388 assert_eq!(buf, vec![0xAA, 0xBB, 0xCC, 0xDD]);
389 }
390
391 #[test]
392 fn test_u32_zero() {
393 let mut buf = Vec::new();
394 (0u32).encode(&mut buf);
395 assert_eq!(buf, vec![0x00, 0x00, 0x00, 0x00]);
396 }
397
398 #[test]
399 fn test_u32_max() {
400 let mut buf = Vec::new();
401 (u32::MAX).encode(&mut buf);
402 assert_eq!(buf, vec![0xFF, 0xFF, 0xFF, 0xFF]);
403 }
404
405 #[test]
406 fn test_u64_exact_bytes() {
407 let value: u64 = 0x0102030405060708;
408 let mut buf = Vec::new();
409 value.encode(&mut buf);
410 assert_eq!(buf, vec![0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
411 }
412
413 #[test]
414 fn test_u64_zero() {
415 let mut buf = Vec::new();
416 (0u64).encode(&mut buf);
417 assert_eq!(buf, vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
418 }
419
420 #[test]
421 fn test_u64_max() {
422 let mut buf = Vec::new();
423 (u64::MAX).encode(&mut buf);
424 assert_eq!(buf, vec![0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
425 }
426
427 #[test]
428 fn test_u16_roundtrip() {
429 let value = 12345u16;
430 let mut buf = Vec::new();
431 value.encode(&mut buf);
432 assert_eq!(buf.len(), 2);
433
434 let mut slice = buf.as_slice();
435 let decoded = u16::decode(&mut slice).unwrap();
436 assert_eq!(decoded, value);
437 }
438
439 #[test]
440 fn test_u16_exact_bytes() {
441 let value = 0x1234u16;
442 let mut buf = Vec::new();
443 value.encode(&mut buf);
444 assert_eq!(buf, vec![0x12, 0x34]);
445 }
446
447 #[test]
448 fn test_u16_zero() {
449 let mut buf = Vec::new();
450 (0u16).encode(&mut buf);
451 assert_eq!(buf, vec![0x00, 0x00]);
452 }
453
454 #[test]
455 fn test_u16_max() {
456 let mut buf = Vec::new();
457 (u16::MAX).encode(&mut buf);
458 assert_eq!(buf, vec![0xFF, 0xFF]);
459 }
460
461 #[test]
462 fn test_i16_positive_roundtrip() {
463 let value = 1234i16;
464 let mut buf = Vec::new();
465 value.encode(&mut buf);
466 assert_eq!(buf.len(), 2);
467
468 let mut slice = buf.as_slice();
469 let decoded = i16::decode(&mut slice).unwrap();
470 assert_eq!(decoded, value);
471 }
472
473 #[test]
474 fn test_i16_negative_roundtrip() {
475 let value = -1234i16;
476 let mut buf = Vec::new();
477 value.encode(&mut buf);
478 assert_eq!(buf.len(), 2);
479
480 let mut slice = buf.as_slice();
481 let decoded = i16::decode(&mut slice).unwrap();
482 assert_eq!(decoded, value);
483 }
484
485 #[test]
486 fn test_i16_zero() {
487 let mut buf = Vec::new();
488 (0i16).encode(&mut buf);
489 assert_eq!(buf, vec![0x00, 0x00]);
490 }
491
492 #[test]
493 fn test_i16_max() {
494 let mut buf = Vec::new();
495 (i16::MAX).encode(&mut buf);
496 assert_eq!(buf, vec![0x7F, 0xFF]);
497
498 let mut slice = buf.as_slice();
499 let decoded = i16::decode(&mut slice).unwrap();
500 assert_eq!(decoded, i16::MAX);
501 }
502
503 #[test]
504 fn test_i16_min() {
505 let mut buf = Vec::new();
506 (i16::MIN).encode(&mut buf);
507 assert_eq!(buf, vec![0x80, 0x00]);
508
509 let mut slice = buf.as_slice();
510 let decoded = i16::decode(&mut slice).unwrap();
511 assert_eq!(decoded, i16::MIN);
512 }
513
514 #[test]
515 fn test_i16_exact_bytes() {
516 let value = 0x1234i16;
517 let mut buf = Vec::new();
518 value.encode(&mut buf);
519 assert_eq!(buf, vec![0x12, 0x34]);
520 }
521}