solana_bytes_reader/
lib.rs

1pub mod reader;
2pub mod traits;
3pub mod utils;
4#[cfg(feature = "bytemuck")]
5pub mod pod;
6pub mod prelude;
7
8pub use prelude::*;
9
10
11#[cfg(test)]
12mod tests {
13    use super::*;
14    
15    #[test]
16    fn test_read_primitive() -> Result<(), Box<dyn std::error::Error>> {
17        let int: u16 = u16::MAX;
18        assert_eq!(int, read_u16_slice(&int.to_le_bytes(), 0)?);
19        Ok(())
20    }
21
22    #[test]
23    fn test_reader() -> Result<(), Box<dyn std::error::Error>> {
24        let expected_first: u8 = 101;
25        let expected_second: u16 = 2134;
26        let expected_third: &[u8] = &[1; 10];
27
28        let bytes: &mut [u8] = &mut [0; 13];
29        bytes[0] = expected_first;
30        bytes[1..3].copy_from_slice(&expected_second.to_le_bytes());
31        bytes[3..13].copy_from_slice(expected_third);
32
33        let mut reader: Reader = Reader::new(bytes);
34        let first: u8 = reader.read_u8()?;        
35        println!("peek into second value: {}", reader.peek_u16()?);
36        let second: u16 = reader.read_u16()?;
37        let third: [u8; 10] = reader.read_bytes()?;
38
39        assert_eq!(expected_first, first);
40        assert_eq!(expected_second, second);
41        assert_eq!(expected_third, third);
42
43        assert_eq!(reader.remaining(), 0);
44
45        Ok(())
46    }
47
48    #[test]
49    fn test_read_pod() -> Result<(), Box<dyn std::error::Error>> {
50        #[derive(Debug, Clone, Copy, PartialEq)]
51        #[repr(C)]
52        struct Foo {
53            arr: [u32; 4],
54            val: u8,
55            _pad: [u8; 3]
56        }
57
58        unsafe impl bytemuck::Zeroable for Foo {}
59        unsafe impl bytemuck::Pod for Foo {}
60
61        let expected_foo = Foo {
62            arr: [101; 4],
63            val: 101,
64            _pad: [0; 3]
65        };
66        
67        let ptr: *const u8 = &expected_foo as *const Foo as *const u8;
68        let foo_bytes: &[u8] = unsafe {
69            std::slice::from_raw_parts(ptr, std::mem::size_of::<Foo>())
70        };
71
72        let foo = read_pod_slice::<Foo>(foo_bytes, 0)?;
73
74        assert_eq!(expected_foo, foo);        
75
76        Ok(())
77    }
78}