1use crate::CreatedDelta;
2use crate::{
3 number_diff_impl_option_wrapped, number_diff_impl_u8_or_i8, number_patch_impl_mut_u8_or_i8,
4 number_patch_impl_option_wrapped, number_patch_impl_u8_or_i8,
5};
6
7number_diff_impl_u8_or_i8!(u8, u8);
8number_patch_impl_u8_or_i8!(u8, u8);
9number_patch_impl_mut_u8_or_i8!(&mut u8, u8);
10
11number_diff_impl_u8_or_i8!(i8, i8);
12number_patch_impl_u8_or_i8!(i8, i8);
13number_patch_impl_mut_u8_or_i8!(&mut i8, i8);
14
15number_diff_impl_option_wrapped!(u16, u16);
16number_patch_impl_option_wrapped!(u16, Option<u16>);
17number_diff_impl_option_wrapped!(i16, i16);
18number_patch_impl_option_wrapped!(i16, Option<i16>);
19
20number_diff_impl_option_wrapped!(u32, u32);
21number_patch_impl_option_wrapped!(u32, Option<u32>);
22number_diff_impl_option_wrapped!(i32, i32);
23number_patch_impl_option_wrapped!(i32, Option<i32>);
24
25number_diff_impl_option_wrapped!(u64, u64);
26number_patch_impl_option_wrapped!(u64, Option<u64>);
27number_diff_impl_option_wrapped!(i64, i64);
28number_patch_impl_option_wrapped!(i64, Option<i64>);
29
30number_diff_impl_option_wrapped!(u128, u128);
31number_patch_impl_option_wrapped!(u128, Option<u128>);
32number_diff_impl_option_wrapped!(i128, i128);
33number_patch_impl_option_wrapped!(i128, Option<i128>);
34
35#[cfg(test)]
36mod tests_signed {
37
38 use crate::dipa_impl_tester::DipaImplTester;
39
40 #[test]
41 fn diff_patch_u8_same() {
42 DipaImplTester {
43 label: Some("Diff patch same u8"),
44 start: &mut 0u8,
45 end: &0u8,
46 expected_delta: 0,
47 expected_serialized_patch_size: 1,
48 expected_did_change: false,
49 }
50 .test();
51 }
52
53 #[test]
54 fn diff_patch_u8_different() {
55 DipaImplTester {
56 label: Some("Diff patch different u8"),
57 start: &mut 0u8,
58 end: &2u8,
59 expected_delta: 2,
60 expected_serialized_patch_size: 1,
61 expected_did_change: true,
62 }
63 .test();
64 }
65
66 #[test]
67 fn diff_patch_u16_same() {
68 DipaImplTester {
69 label: Some("Diff patch same u16"),
70 start: &mut 0u16,
71 end: &0u16,
72 expected_delta: None,
73 expected_serialized_patch_size: 1,
74 expected_did_change: false,
75 }
76 .test();
77 }
78
79 #[test]
80 fn diff_patch_u16_different() {
81 DipaImplTester {
82 label: Some("Diff patch different u16"),
83 start: &mut 0u16,
84 end: &2u16,
85 expected_delta: Some(2),
86 expected_serialized_patch_size: 2,
87 expected_did_change: true,
88 }
89 .test();
90 }
91
92 #[test]
93 fn diff_patch_32_same() {
94 DipaImplTester {
95 label: Some("Diff patch same u32"),
96 start: &mut 0u32,
97 end: &0u32,
98 expected_delta: None,
99 expected_serialized_patch_size: 1,
100 expected_did_change: false,
101 }
102 .test();
103 }
104
105 #[test]
106 fn diff_patch_32_different() {
107 DipaImplTester {
108 label: Some("Diff patch different u32s"),
109 start: &mut 0u32,
110 end: &1u32,
111 expected_delta: Some(1),
112 expected_serialized_patch_size: 2,
113 expected_did_change: true,
114 }
115 .test();
116 }
117
118 #[test]
119 fn diff_patch_64_same() {
120 DipaImplTester {
121 label: Some("Diff patch same u64"),
122 start: &mut 0u64,
123 end: &0u64,
124 expected_delta: None,
125 expected_serialized_patch_size: 1,
126 expected_did_change: false,
127 }
128 .test();
129 }
130
131 #[test]
132 fn diff_patch_64_different() {
133 DipaImplTester {
134 label: Some("Diff patch different u64s"),
135 start: &mut 0u64,
136 end: &1u64,
137 expected_delta: Some(1),
138 expected_serialized_patch_size: 2,
139 expected_did_change: true,
140 }
141 .test();
142 }
143
144 #[test]
145 fn diff_patch_128_same() {
146 DipaImplTester {
147 label: Some("Diff patch same u128"),
148 start: &mut 0u128,
149 end: &0u128,
150 expected_delta: None,
151 expected_serialized_patch_size: 1,
152 expected_did_change: false,
153 }
154 .test();
155 }
156
157 #[test]
158 fn diff_patch_128_different() {
159 DipaImplTester {
160 label: Some("Diff patch different u128s"),
161 start: &mut 0u128,
162 end: &1u128,
163 expected_delta: Some(1),
164 expected_serialized_patch_size: 2,
165 expected_did_change: true,
166 }
167 .test();
168 }
169}
170
171#[cfg(test)]
172mod tests_unsigned {
173
174 use crate::dipa_impl_tester::DipaImplTester;
175
176 #[test]
177 fn diff_patch_i8_same() {
178 DipaImplTester {
179 label: Some("Diff patch same i8"),
180 start: &mut 0i8,
181 end: &0i8,
182 expected_delta: 0,
183 expected_serialized_patch_size: 1,
184 expected_did_change: false,
185 }
186 .test();
187 }
188
189 #[test]
190 fn diff_patch_i8_different() {
191 DipaImplTester {
192 label: Some("Diff patch different i8"),
193 start: &mut 0i8,
194 end: &1i8,
195 expected_delta: 1,
196 expected_serialized_patch_size: 1,
197 expected_did_change: true,
198 }
199 .test();
200 }
201
202 #[test]
203 fn diff_patch_i16_same() {
204 DipaImplTester {
205 label: Some("Diff patch same i16"),
206 start: &mut 0i16,
207 end: &0i16,
208 expected_delta: None,
209 expected_serialized_patch_size: 1,
210 expected_did_change: false,
211 }
212 .test();
213 }
214
215 #[test]
216 fn diff_patch_i16_different() {
217 DipaImplTester {
218 label: Some("Diff patch different i16"),
219 start: &mut 0i16,
220 end: &2i16,
221 expected_delta: Some(2),
222 expected_serialized_patch_size: 2,
223 expected_did_change: true,
224 }
225 .test();
226 }
227
228 #[test]
229 fn diff_patch_32_same() {
230 DipaImplTester {
231 label: Some("Diff patch same i32"),
232 start: &mut 0i32,
233 end: &0i32,
234 expected_delta: None,
235 expected_serialized_patch_size: 1,
236 expected_did_change: false,
237 }
238 .test();
239 }
240
241 #[test]
242 fn diff_patch_32_different() {
243 DipaImplTester {
244 label: Some("Diff patch different i32s"),
245 start: &mut 0i32,
246 end: &1i32,
247 expected_delta: Some(1),
248 expected_serialized_patch_size: 2,
249 expected_did_change: true,
250 }
251 .test();
252 }
253
254 #[test]
255 fn diff_patch_64_same() {
256 DipaImplTester {
257 label: Some("Diff patch same i64"),
258 start: &mut 0i64,
259 end: &0i64,
260 expected_delta: None,
261 expected_serialized_patch_size: 1,
262 expected_did_change: false,
263 }
264 .test();
265 }
266
267 #[test]
268 fn diff_patch_64_different() {
269 DipaImplTester {
270 label: Some("Diff patch different i64s"),
271 start: &mut 0i64,
272 end: &1i64,
273 expected_delta: Some(1),
274 expected_serialized_patch_size: 2,
275 expected_did_change: true,
276 }
277 .test();
278 }
279
280 #[test]
281 fn diff_patch_128_same() {
282 DipaImplTester {
283 label: Some("Diff patch same i128"),
284 start: &mut 0i128,
285 end: &0i128,
286 expected_delta: None,
287 expected_serialized_patch_size: 1,
288 expected_did_change: false,
289 }
290 .test();
291 }
292
293 #[test]
294 fn diff_patch_128_different() {
295 DipaImplTester {
296 label: Some("Diff patch different i128s"),
297 start: &mut 0i128,
298 end: &1i128,
299 expected_delta: Some(1),
300 expected_serialized_patch_size: 2,
301 expected_did_change: true,
302 }
303 .test();
304 }
305}