willow_core/
serialization_tests.rs

1#[cfg(test)]
2mod tests {
3    use crate::account::SerializationHelper;
4    use pinocchio::program_error::ProgramError;
5
6    #[test]
7    fn test_i8_serialization() {
8        let mut data = [0u8; 10];
9        let mut offset = 0usize;
10        let value: i8 = -42;
11        
12        SerializationHelper::pack_i8(value, &mut data, &mut offset);
13        assert_eq!(offset, 1);
14        assert_eq!(data[0], (-42i8) as u8);
15        
16        let mut offset = 0usize;
17        let unpacked = SerializationHelper::unpack_i8(&data, &mut offset).unwrap();
18        assert_eq!(unpacked, value);
19        assert_eq!(offset, 1);
20    }
21
22    #[test]
23    fn test_i16_serialization() {
24        let mut data = [0u8; 10];
25        let mut offset = 0usize;
26        let value: i16 = -12345;
27        
28        SerializationHelper::pack_i16(value, &mut data, &mut offset);
29        assert_eq!(offset, 2);
30        
31        let mut offset = 0usize;
32        let unpacked = SerializationHelper::unpack_i16(&data, &mut offset).unwrap();
33        assert_eq!(unpacked, value);
34        assert_eq!(offset, 2);
35    }
36
37    #[test]
38    fn test_i32_serialization() {
39        let mut data = [0u8; 10];
40        let mut offset = 0usize;
41        let value: i32 = -123456789;
42        
43        SerializationHelper::pack_i32(value, &mut data, &mut offset);
44        assert_eq!(offset, 4);
45        
46        let mut offset = 0usize;
47        let unpacked = SerializationHelper::unpack_i32(&data, &mut offset).unwrap();
48        assert_eq!(unpacked, value);
49        assert_eq!(offset, 4);
50    }
51
52    #[test]
53    fn test_bool_serialization() {
54        // Test true value
55        let mut data = [0u8; 10];
56        let mut offset = 0usize;
57        let value = true;
58        
59        SerializationHelper::pack_bool(value, &mut data, &mut offset);
60        assert_eq!(offset, 1);
61        assert_eq!(data[0], 1);
62        
63        let mut offset = 0usize;
64        let unpacked = SerializationHelper::unpack_bool(&data, &mut offset).unwrap();
65        assert_eq!(unpacked, value);
66        assert_eq!(offset, 1);
67        
68        // Test false value
69        let mut data = [0u8; 10];
70        let mut offset = 0usize;
71        let value = false;
72        
73        SerializationHelper::pack_bool(value, &mut data, &mut offset);
74        assert_eq!(offset, 1);
75        assert_eq!(data[0], 0);
76        
77        let mut offset = 0usize;
78        let unpacked = SerializationHelper::unpack_bool(&data, &mut offset).unwrap();
79        assert_eq!(unpacked, value);
80        assert_eq!(offset, 1);
81    }
82
83    #[test]
84    fn test_invalid_bool_value() {
85        let data = [2u8; 10]; // Invalid bool value (should be 0 or 1)
86        let mut offset = 0usize;
87        
88        let result = SerializationHelper::unpack_bool(&data, &mut offset);
89        assert!(matches!(result, Err(ProgramError::InvalidAccountData)));
90    }
91
92    #[test]
93    fn test_string_serialization() {
94        let mut data = [0u8; 20];
95        let mut offset = 0usize;
96        let value = "hello";
97        
98        SerializationHelper::pack_string(value, &mut data, &mut offset).unwrap();
99        // 4 bytes for length + 5 bytes for "hello"
100        assert_eq!(offset, 9);
101        // Length should be 5 in little endian
102        assert_eq!(data[0..4], [5, 0, 0, 0]);
103        // String content
104        assert_eq!(data[4..9], [104, 101, 108, 108, 111]);
105        
106        let mut offset = 0usize;
107        let unpacked = SerializationHelper::unpack_string(&data, &mut offset).unwrap();
108        assert_eq!(unpacked, "hello");
109        assert_eq!(offset, 9);
110    }
111
112    #[test]
113    fn test_vec_serialization() {
114        let mut data = [0u8; 20];
115        let mut offset = 0usize;
116        let value = vec![1u8, 2, 3, 4, 5];
117        
118        SerializationHelper::pack_vec(&value, &mut data, &mut offset).unwrap();
119        // 4 bytes for length + 5 bytes for vector content
120        assert_eq!(offset, 9);
121        // Length should be 5 in little endian
122        assert_eq!(data[0..4], [5, 0, 0, 0]);
123        // Vector content
124        assert_eq!(data[4..9], [1, 2, 3, 4, 5]);
125        
126        let mut offset = 0usize;
127        let unpacked = SerializationHelper::unpack_vec(&data, &mut offset).unwrap();
128        assert_eq!(unpacked, vec![1u8, 2, 3, 4, 5]);
129        assert_eq!(offset, 9);
130    }
131
132    #[test]
133    fn test_empty_string_serialization() {
134        let mut data = [0u8; 10];
135        let mut offset = 0usize;
136        let value = "";
137        
138        SerializationHelper::pack_string(value, &mut data, &mut offset).unwrap();
139        // 4 bytes for length (0)
140        assert_eq!(offset, 4);
141        assert_eq!(data[0..4], [0, 0, 0, 0]);
142        
143        let mut offset = 0usize;
144        let unpacked = SerializationHelper::unpack_string(&data, &mut offset).unwrap();
145        assert_eq!(unpacked, "");
146        assert_eq!(offset, 4);
147    }
148
149    #[test]
150    fn test_empty_vec_serialization() {
151        let mut data = [0u8; 10];
152        let mut offset = 0usize;
153        let value: Vec<u8> = vec![];
154        
155        SerializationHelper::pack_vec(&value, &mut data, &mut offset).unwrap();
156        // 4 bytes for length (0)
157        assert_eq!(offset, 4);
158        assert_eq!(data[0..4], [0, 0, 0, 0]);
159        
160        let mut offset = 0usize;
161        let unpacked = SerializationHelper::unpack_vec(&data, &mut offset).unwrap();
162        assert_eq!(unpacked, Vec::<u8>::new());
163        assert_eq!(offset, 4);
164    }
165
166    #[test]
167    fn test_string_serialization_insufficient_space() {
168        let mut data = [0u8; 5]; // Not enough space for "hello" (needs 9 bytes)
169        let mut offset = 0usize;
170        let value = "hello";
171        
172        let result = SerializationHelper::pack_string(value, &mut data, &mut offset);
173        assert!(matches!(result, Err(ProgramError::AccountDataTooSmall)));
174    }
175
176    #[test]
177    fn test_vec_serialization_insufficient_space() {
178        let mut data = [0u8; 5]; // Not enough space for vec![1,2,3,4,5] (needs 9 bytes)
179        let mut offset = 0usize;
180        let value = vec![1u8, 2, 3, 4, 5];
181        
182        let result = SerializationHelper::pack_vec(&value, &mut data, &mut offset);
183        assert!(matches!(result, Err(ProgramError::AccountDataTooSmall)));
184    }
185
186    #[test]
187    fn test_string_serialization_invalid_utf8() {
188        let mut data = [0u8; 10];
189        data[0..4].copy_from_slice(&5u32.to_le_bytes()); // Length = 5
190        data[4..9].copy_from_slice(&[0xFF, 0xFE, 0xFD, 0xFC, 0xFB]); // Invalid UTF-8
191        
192        let mut offset = 0usize;
193        let result = SerializationHelper::unpack_string(&data, &mut offset);
194        assert!(matches!(result, Err(ProgramError::InvalidAccountData)));
195    }
196
197    #[test]
198    fn test_vec_serialization_truncated_data() {
199        let mut data = [0u8; 6]; // Only 6 bytes, but length says 10
200        data[0..4].copy_from_slice(&10u32.to_le_bytes()); // Length = 10
201        data[4..6].copy_from_slice(&[1, 2]); // Only 2 bytes of data
202        
203        let mut offset = 0usize;
204        let result = SerializationHelper::unpack_vec(&data, &mut offset);
205        assert!(matches!(result, Err(ProgramError::InvalidAccountData)));
206    }
207}
willow_core/serialization_tests.rs

willow_core/
serialization_tests.rs
