Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/tests/byte.rs

30.7 KiB, 14 runs

created by r1870400018:497, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1use oxedyne_fe2o3_jdat::{
2 prelude::*,
3 test_binary_encode_decode_byte_tuple,
4 usr::{
5 UsrKinds,
6 UsrKindId,
7 },
8};
9
10use oxedyne_fe2o3_core::{
11 prelude::*,
12 rand::Rand,
13 test::test_it,
14};
15
16use oxedyne_fe2o3_num::{
17 prelude::*,
18 BigDecimal,
19 BigInt,
20};
21
22use std::collections::BTreeMap;
23
24pub fn test_binary_encdec_func(filter: &'static str) -> Outcome<()> {
25
26 res!(test_it(filter, &["Binary omnibus", "all", "omnibus"], || {
27
28 let ukid = UsrKindId::new(5, Some("my_type"), Some(Kind::U8));
29 let mut ukids = UsrKinds::new(BTreeMap::new(), BTreeMap::new());
30 res!(ukids.add(ukid.clone()));
31
32 // Vec of tuples to be encoded then decoded with various codec settings, and the kind
33 // expected from decoding with encoding KindScope::Nothing (as in JSON).
34 let dats: Vec<Dat> = vec![
35 dat!(()), // 1
36 dat!(true), // 2
37 dat!(false), // 3
38 dat!(None::<u8>), // 4
39 dat!(0u8), // 5
40 dat!(0u16), // 6
41 dat!(0u32), // 7
42 dat!(0u64), // 8
43 dat!(0u128), // 9
44 dat!(0i8), // 10
45 dat!(0i16), // 11
46 dat!(0i32), // 12
47 dat!(0i64), // 13
48 dat!(0i128), // 14
49 dat!(u8::MAX), // 15
50 dat!(u16::MAX), // 16
51 dat!(u32::MAX), // 17
52 dat!(u64::MAX), // 18
53 dat!(u128::MAX), // 19
54 dat!(i8::MIN), // 20
55 dat!(i16::MIN), // 21
56 dat!(i32::MIN), // 22
57 dat!(i64::MIN), // 23
58 dat!(i128::MIN), // 24
59 dat!(i8::MAX), // 25
60 dat!(i16::MAX), // 26
61 dat!(i32::MAX), // 27
62 dat!(i64::MAX), // 28
63 dat!(i128::MAX), // 29
64 dat!(0.0f32), // 30
65 dat!(f32::MIN), // 31
66 dat!(f32::MAX), // 32
67 dat!(0.0f64), // 33
68 dat!(f64::MIN), // 34
69 dat!(f64::MAX), // 35
70 dat!(res!(aint!(fmt!("{}0", u128::MAX)))), // 36
71 dat!(res!(aint!(fmt!("{}0", u128::MIN)))), // 37
72 dat!(res!(adec!(fmt!("{:e}0", f64::MAX)))), // 38
73 dat!(res!(adec!(fmt!("{:e}0", f64::MIN)))), // 39
74 Dat::C64(u32::MAX as u64), // 40
75 dat!("hello"), // 41
76 res!(Dat::try_from((ukid.clone(), Some(best_dat!(42))))), // 42
77 dat!(Box::new(best_dat!(-42))), // 43
78 dat!(Some(best_dat!(-256))), // 44
79 ];
80 let mut count: usize = 1;
81 let total = dats.len();
82
83 for (i, d1) in dats.iter().enumerate() {
84 let mut buf = Vec::new();
85 buf = res!(d1.to_bytes(buf));
86 let (d2, n) = res!(Dat::from_bytes(&buf));
87 test!("Encoded, decoded {:?} using {} bytes", d1, n);
88
89 if *d1 != d2 {
90 return Err(err!(
91 "Omnibus test {} of {} using dat #{}: The daticle {:?} was \
92 encoded to {:?} then decoded to {:?}.",
93 count, total, i+1, d1, buf, d2; Test, Mismatch));
94 }
95
96 test!("Omnibus test {} of {} successfully completed.", count, total);
97 count += 1;
98 }
99 test!("{} tests run", count - 1);
100 Ok(())
101 }));
102
103 res!(test_it(filter, &["Binary encdec bool true", "all", "unit", "bool"], || {
104 let v1 = Dat::Bool(true);
105 let mut buf = Vec::new();
106 buf = res!(v1.to_bytes(buf));
107 let (v2, n) = res!(Dat::from_bytes(&buf));
108 req!(n, 1);
109 req!(v1, v2);
110 req!(v1.byte_len(), Some(n));
111 Ok(())
112 }));
113
114 res!(test_it(filter, &["Binary encdec bool false", "all", "unit", "bool"], || {
115 let v1 = Dat::Bool(false);
116 let mut buf = Vec::new();
117 buf = res!(v1.to_bytes(buf));
118 let (v2, n) = res!(Dat::from_bytes(&buf));
119 req!(n, 1);
120 req!(v1, v2);
121 req!(v1.byte_len(), Some(n));
122 Ok(())
123 }));
124
125 res!(test_it(filter, &["Binary encdec u8 rand loop", "all", "unit", "u8", "u8"], || {
126 for i in 0..100_000 {
127 let v1 = Dat::U8(Rand::rand_u32() as u8);
128 let mut buf = Vec::new();
129 buf = res!(v1.to_bytes(buf));
130 let (v2, n) = res!(Dat::from_bytes(&buf));
131 req!(n, 2, "Completed {} successful comparisons", i);
132 req!(v1, v2, "Completed {} successful comparisons", i);
133 req!(v1.byte_len(), Some(n));
134 }
135 Ok(())
136 }));
137
138 res!(test_it(filter, &["Binary encdec u16 rand loop", "all", "unit", "u16"], || {
139 for i in 0..100_000 {
140 let v1 = Dat::U16(Rand::rand_u32() as u16);
141 let mut buf = Vec::new();
142 buf = res!(v1.to_bytes(buf));
143 let (v2, n) = res!(Dat::from_bytes(&buf));
144 req!(n, 3, "Completed {} successful comparisons", i);
145 req!(v1, v2, "Completed {} successful comparisons", i);
146 req!(v1.byte_len(), Some(n));
147 }
148 Ok(())
149 }));
150
151 res!(test_it(filter, &["Binary encdec u32 rand loop", "all", "unit", "u32"], || {
152 for i in 0..100_000 {
153 let v1 = Dat::U32(Rand::rand_u32());
154 let mut buf = Vec::new();
155 buf = res!(v1.to_bytes(buf));
156 let (v2, n) = res!(Dat::from_bytes(&buf));
157 req!(n, 5, "Completed {} successful comparisons", i);
158 req!(v1, v2, "Completed {} successful comparisons", i);
159 req!(v1.byte_len(), Some(n));
160 }
161 Ok(())
162 }));
163
164 res!(test_it(filter, &["Binary encdec u64 rand loop", "all", "unit", "u64"], || {
165 for i in 0..100_000 {
166 let v1 = Dat::U64(Rand::rand_u64());
167 let mut buf = Vec::new();
168 buf = res!(v1.to_bytes(buf));
169 let (v2, n) = res!(Dat::from_bytes(&buf));
170 req!(n, 9, "Completed {} successful comparisons", i);
171 req!(v1, v2, "Completed {} successful comparisons", i);
172 req!(v1.byte_len(), Some(n));
173 }
174 Ok(())
175 }));
176
177 res!(test_it(filter, &["Binary encdec u128 rand loop", "all", "unit", "u128"], || {
178 for i in 0..100_000 {
179 let v1 = Dat::U128(Rand::rand_u128());
180 let mut buf = Vec::new();
181 buf = res!(v1.to_bytes(buf));
182 let (v2, n) = res!(Dat::from_bytes(&buf));
183 req!(n, 17, "Completed {} successful comparisons", i);
184 req!(v1, v2, "Completed {} successful comparisons", i);
185 req!(v1.byte_len(), Some(n));
186 }
187 Ok(())
188 }));
189
190 res!(test_it(filter, &["Binary encdec i8 rand loop", "all", "unit", "i8"], || {
191 for i in 0..100_000 {
192 let v1 = Dat::I8(Rand::rand_u32() as i8);
193 let mut buf = Vec::new();
194 buf = res!(v1.to_bytes(buf));
195 let (v2, n) = res!(Dat::from_bytes(&buf));
196 req!(n, 2, "Completed {} successful comparisons", i);
197 req!(v1, v2, "Completed {} successful comparisons", i);
198 req!(v1.byte_len(), Some(n));
199 }
200 Ok(())
201 }));
202
203 res!(test_it(filter, &["Binary encdec i16 rand loop", "all", "unit", "i16"], || {
204 for i in 0..100_000 {
205 let v1 = Dat::I16(Rand::rand_u32() as i16);
206 let mut buf = Vec::new();
207 buf = res!(v1.to_bytes(buf));
208 let (v2, n) = res!(Dat::from_bytes(&buf));
209 req!(n, 3, "Completed {} successful comparisons", i);
210 req!(v1, v2, "Completed {} successful comparisons", i);
211 req!(v1.byte_len(), Some(n));
212 }
213 Ok(())
214 }));
215
216 res!(test_it(filter, &["Binary encdec i32 rand loop", "all", "unit", "i32"], || {
217 for i in 0..100_000 {
218 let v1 = Dat::I32(Rand::rand_u32() as i32);
219 let mut buf = Vec::new();
220 buf = res!(v1.to_bytes(buf));
221 let (v2, n) = res!(Dat::from_bytes(&buf));
222 req!(n, 5, "Completed {} successful comparisons", i);
223 req!(v1, v2, "Completed {} successful comparisons", i);
224 req!(v1.byte_len(), Some(n));
225 }
226 Ok(())
227 }));
228
229 res!(test_it(filter, &["Binary encdec i64 rand loop", "all", "unit", "i64"], || {
230 for i in 0..100_000 {
231 let v1 = Dat::I64(Rand::rand_u64() as i64);
232 let mut buf = Vec::new();
233 buf = res!(v1.to_bytes(buf));
234 let (v2, n) = res!(Dat::from_bytes(&buf));
235 req!(n, 9, "Completed {} successful comparisons", i);
236 req!(v1, v2, "Completed {} successful comparisons", i);
237 req!(v1.byte_len(), Some(n));
238 }
239 Ok(())
240 }));
241
242 res!(test_it(filter, &["Binary encdec i128 rand loop", "all", "unit", "i128"], || {
243 for i in 0..100_000 {
244 let v1 = Dat::I128(Rand::rand_u128() as i128);
245 let mut buf = Vec::new();
246 buf = res!(v1.to_bytes(buf));
247 let (v2, n) = res!(Dat::from_bytes(&buf));
248 req!(n, 17, "Completed {} successful comparisons", i);
249 req!(v1, v2, "Completed {} successful comparisons", i);
250 req!(v1.byte_len(), Some(n));
251 }
252 Ok(())
253 }));
254
255 res!(test_it(filter, &["Binary encdec f32 rand loop", "all", "unit", "f32"], || {
256 for i in 0..100_000 {
257 let b = Rand::rand_u32().to_be_bytes();
258 let v1 = Dat::from(f32::from_be_bytes(b));
259 let mut buf = Vec::new();
260 buf = res!(v1.to_bytes(buf));
261 let (v2, n) = res!(Dat::from_bytes(&buf));
262 req!(n, 5, "Completed {} successful comparisons", i);
263 req!(v1, v2, "Completed {} successful comparisons", i);
264 req!(v1.byte_len(), Some(n));
265 }
266 Ok(())
267 }));
268
269 res!(test_it(filter, &["Binary encdec f64 rand loop", "all", "unit", "f64"], || {
270 for i in 0..100_000 {
271 let b = Rand::rand_u64().to_be_bytes();
272 let v1 = Dat::from(f64::from_be_bytes(b));
273 let mut buf = Vec::new();
274 buf = res!(v1.to_bytes(buf));
275 let (v2, n) = res!(Dat::from_bytes(&buf));
276 req!(n, 9, "Completed {} successful comparisons", i);
277 req!(v1, v2, "Completed {} successful comparisons", i);
278 req!(v1.byte_len(), Some(n));
279 }
280 Ok(())
281 }));
282
283 res!(test_it(filter, &["Binary encdec BU8 vec", "all", "unit", "bu8"], || {
284 let v1 = Dat::BU8(vec![0x72, 0x75, 0x73, 0x74]);
285 let mut buf = Vec::new();
286 buf = res!(v1.to_bytes(buf));
287 let (v2, n) = res!(Dat::from_bytes(&buf));
288 req!(n, 1 + 1 + 4);
289 req!(v1, v2);
290 req!(v1.byte_len(), Some(n));
291 Ok(())
292 }));
293
294 res!(test_it(filter, &["Binary encdec BU16 vec", "all", "unit", "bu16"], || {
295 let v1 = Dat::BU16(vec![0x72, 0x75, 0x73, 0x74]);
296 let mut buf = Vec::new();
297 buf = res!(v1.to_bytes(buf));
298 let (v2, n) = res!(Dat::from_bytes(&buf));
299 req!(n, 1 + 2 + 4);
300 req!(v1, v2);
301 req!(v1.byte_len(), Some(n));
302 Ok(())
303 }));
304
305 res!(test_it(filter, &["Binary encdec BU32 vec", "all", "unit", "bu32"], || {
306 let v1 = Dat::BU32(vec![0x72, 0x75, 0x73, 0x74]);
307 let mut buf = Vec::new();
308 buf = res!(v1.to_bytes(buf));
309 let (v2, n) = res!(Dat::from_bytes(&buf));
310 req!(n, 1 + 4 + 4);
311 req!(v1, v2);
312 req!(v1.byte_len(), Some(n));
313 Ok(())
314 }));
315
316 res!(test_it(filter, &["Binary encdec BU64 vec", "all", "unit", "bu64"], || {
317 let v1 = Dat::BU64(vec![0x72, 0x75, 0x73, 0x74]);
318 let mut buf = Vec::new();
319 buf = res!(v1.to_bytes(buf));
320 let (v2, n) = res!(Dat::from_bytes(&buf));
321 req!(n, 1 + 8 + 4);
322 req!(v1, v2);
323 req!(v1.byte_len(), Some(n));
324 Ok(())
325 }));
326
327 res!(test_it(filter, &["Binary encdec BC64 vec", "all", "unit", "bc64"], || {
328 let v1 = Dat::BC64(vec![0x72, 0x75, 0x73, 0x74]);
329 let mut buf = Vec::new();
330 buf = res!(v1.to_bytes(buf));
331 let (v2, n) = res!(Dat::from_bytes(&buf));
332 req!(n, 1 + 2 + 4);
333 req!(v1, v2);
334 req!(v1.byte_len(), Some(n));
335 Ok(())
336 }));
337
338 res!(test_it(filter, &["Binary encdec Tup5u64 array", "all", "unit", "tuple", "u64"], || {
339 let v1 = Dat::Tup5u64([0x72, 0x75, 0x73, 0x74, 0x75]);
340 let mut buf = Vec::new();
341 buf = res!(v1.to_bytes(buf));
342 let (v2, n) = res!(Dat::from_bytes(&buf));
343 req!(n, 1 + 5 * 8);
344 req!(v1, v2);
345 req!(v1.byte_len(), Some(n));
346 Ok(())
347 }));
348
349 res!(test_it(filter, &["Binary encdec u8 2-tuple", "all", "unit", "tuple", "u8"], || {
350 test_binary_encode_decode_byte_tuple! { [42u8; 2] }
351 Ok(())
352 }));
353
354 res!(test_it(filter, &["Binary encdec u8 3-tuple", "all", "unit", "tuple", "u8"], || {
355 test_binary_encode_decode_byte_tuple! { [42u8; 3] }
356 Ok(())
357 }));
358
359 res!(test_it(filter, &["Binary encdec u8 4-tuple", "all", "unit", "tuple", "u8"], || {
360 test_binary_encode_decode_byte_tuple! { [42u8; 4] }
361 Ok(())
362 }));
363
364 res!(test_it(filter, &["Binary encdec u8 5-tuple", "all", "unit", "tuple", "u8"], || {
365 test_binary_encode_decode_byte_tuple! { [42u8; 5] }
366 Ok(())
367 }));
368
369 res!(test_it(filter, &["Binary encdec u8 6-tuple", "all", "unit", "tuple", "u8"], || {
370 test_binary_encode_decode_byte_tuple! { [42u8; 6] }
371 Ok(())
372 }));
373
374 res!(test_it(filter, &["Binary encdec u8 7-tuple", "all", "unit", "tuple", "u8"], || {
375 test_binary_encode_decode_byte_tuple! { [42u8; 7] }
376 Ok(())
377 }));
378
379 res!(test_it(filter, &["Binary encdec u8 8-tuple", "all", "unit", "tuple", "u8"], || {
380 test_binary_encode_decode_byte_tuple! { [42u8; 8] }
381 Ok(())
382 }));
383
384 res!(test_it(filter, &["Binary encdec u8 9-tuple", "all", "unit", "tuple", "u8"], || {
385 test_binary_encode_decode_byte_tuple! { [42u8; 9] }
386 Ok(())
387 }));
388
389 res!(test_it(filter, &["Binary encdec u8 10-tuple", "all", "unit", "tuple", "u8"], || {
390 test_binary_encode_decode_byte_tuple! { [42u8; 10] }
391 Ok(())
392 }));
393
394 res!(test_it(filter, &["Binary encdec u8 16-tuple", "all", "unit", "tuple", "u8"], || {
395 test_binary_encode_decode_byte_tuple! { [42u8; 16] }
396 Ok(())
397 }));
398
399 res!(test_it(filter, &["Binary encdec u8 32-tuple", "all", "unit", "tuple", "u8"], || {
400 test_binary_encode_decode_byte_tuple! { [42u8; 32] }
401 Ok(())
402 }));
403
404 res!(test_it(filter, &["Binary encdec u16 2-tuple", "all", "unit", "tuple", "u16"], || {
405 test_binary_encode_decode_byte_tuple! { [42u16; 2] }
406 Ok(())
407 }));
408
409 res!(test_it(filter, &["Binary encdec u16 3-tuple", "all", "unit", "tuple", "u16"], || {
410 test_binary_encode_decode_byte_tuple! { [42u16; 3] }
411 Ok(())
412 }));
413
414 res!(test_it(filter, &["Binary encdec u16 4-tuple", "all", "unit", "tuple", "u16"], || {
415 test_binary_encode_decode_byte_tuple! { [42u16; 4] }
416 Ok(())
417 }));
418
419 res!(test_it(filter, &["Binary encdec u16 5-tuple", "all", "unit", "tuple", "u16"], || {
420 test_binary_encode_decode_byte_tuple! { [42u16; 5] }
421 Ok(())
422 }));
423
424 res!(test_it(filter, &["Binary encdec u16 6-tuple", "all", "unit", "tuple", "u16"], || {
425 test_binary_encode_decode_byte_tuple! { [42u16; 6] }
426 Ok(())
427 }));
428
429 res!(test_it(filter, &["Binary encdec u16 7-tuple", "all", "unit", "tuple", "u16"], || {
430 test_binary_encode_decode_byte_tuple! { [42u16; 7] }
431 Ok(())
432 }));
433
434 res!(test_it(filter, &["Binary encdec u16 8-tuple", "all", "unit", "tuple", "u16"], || {
435 test_binary_encode_decode_byte_tuple! { [42u16; 8] }
436 Ok(())
437 }));
438
439 res!(test_it(filter, &["Binary encdec u16 9-tuple", "all", "unit", "tuple", "u16"], || {
440 test_binary_encode_decode_byte_tuple! { [42u16; 9] }
441 Ok(())
442 }));
443
444 res!(test_it(filter, &["Binary encdec u16 10-tuple", "all", "unit", "tuple", "u16"], || {
445 test_binary_encode_decode_byte_tuple! { [42u16; 10] }
446 Ok(())
447 }));
448
449 res!(test_it(filter, &["Binary encdec u32 2-tuple", "all", "unit", "tuple", "u32"], || {
450 test_binary_encode_decode_byte_tuple! { [42u32; 2] }
451 Ok(())
452 }));
453
454 res!(test_it(filter, &["Binary encdec u32 3-tuple", "all", "unit", "tuple", "u32"], || {
455 test_binary_encode_decode_byte_tuple! { [42u32; 3] }
456 Ok(())
457 }));
458
459 res!(test_it(filter, &["Binary encdec u32 4-tuple", "all", "unit", "tuple", "u32"], || {
460 test_binary_encode_decode_byte_tuple! { [42u32; 4] }
461 Ok(())
462 }));
463
464 res!(test_it(filter, &["Binary encdec u32 5-tuple", "all", "unit", "tuple", "u32"], || {
465 test_binary_encode_decode_byte_tuple! { [42u32; 5] }
466 Ok(())
467 }));
468
469 res!(test_it(filter, &["Binary encdec u32 6-tuple", "all", "unit", "tuple", "u32"], || {
470 test_binary_encode_decode_byte_tuple! { [42u32; 6] }
471 Ok(())
472 }));
473
474 res!(test_it(filter, &["Binary encdec u32 7-tuple", "all", "unit", "tuple", "u32"], || {
475 test_binary_encode_decode_byte_tuple! { [42u32; 7] }
476 Ok(())
477 }));
478
479 res!(test_it(filter, &["Binary encdec u32 8-tuple", "all", "unit", "tuple", "u32"], || {
480 test_binary_encode_decode_byte_tuple! { [42u32; 8] }
481 Ok(())
482 }));
483
484 res!(test_it(filter, &["Binary encdec u32 9-tuple", "all", "unit", "tuple", "u32"], || {
485 test_binary_encode_decode_byte_tuple! { [42u32; 9] }
486 Ok(())
487 }));
488
489 res!(test_it(filter, &["Binary encdec u32 10-tuple", "all", "unit", "tuple", "u32"], || {
490 test_binary_encode_decode_byte_tuple! { [42u32; 10] }
491 Ok(())
492 }));
493
494 res!(test_it(filter, &["Binary encdec u64 2-tuple", "all", "unit", "tuple", "u64"], || {
495 test_binary_encode_decode_byte_tuple! { [42u64; 2] }
496 Ok(())
497 }));
498
499 res!(test_it(filter, &["Binary encdec u64 3-tuple", "all", "unit", "tuple", "u64"], || {
500 test_binary_encode_decode_byte_tuple! { [42u64; 3] }
501 Ok(())
502 }));
503
504 res!(test_it(filter, &["Binary encdec u64 4-tuple", "all", "unit", "tuple", "u64"], || {
505 test_binary_encode_decode_byte_tuple! { [42u64; 4] }
506 Ok(())
507 }));
508
509 res!(test_it(filter, &["Binary encdec u64 5-tuple", "all", "unit", "tuple", "u64"], || {
510 test_binary_encode_decode_byte_tuple! { [42u64; 5] }
511 Ok(())
512 }));
513
514 res!(test_it(filter, &["Binary encdec u64 6-tuple", "all", "unit", "tuple", "u64"], || {
515 test_binary_encode_decode_byte_tuple! { [42u64; 6] }
516 Ok(())
517 }));
518
519 res!(test_it(filter, &["Binary encdec u64 7-tuple", "all", "unit", "tuple", "u64"], || {
520 test_binary_encode_decode_byte_tuple! { [42u64; 7] }
521 Ok(())
522 }));
523
524 res!(test_it(filter, &["Binary encdec u64 8-tuple", "all", "unit", "tuple", "u64"], || {
525 test_binary_encode_decode_byte_tuple! { [42u64; 8] }
526 Ok(())
527 }));
528
529 res!(test_it(filter, &["Binary encdec u64 9-tuple", "all", "unit", "tuple", "u64"], || {
530 test_binary_encode_decode_byte_tuple! { [42u64; 9] }
531 Ok(())
532 }));
533
534 res!(test_it(filter, &["Binary encdec u64 10-tuple", "all", "unit", "tuple", "u64"], || {
535 test_binary_encode_decode_byte_tuple! { [42u64; 10] }
536 Ok(())
537 }));
538
539 res!(test_it(filter, &["Binary encdec string", "all", "unit", "str"], || {
540 let v1 = Dat::from("hello world");
541 let mut buf = Vec::new();
542 buf = res!(v1.to_bytes(buf));
543 let (v2, n) = res!(Dat::from_bytes(&buf));
544 req!(n, 1 + 2 + 11);
545 req!(v1, v2);
546 req!(v1.byte_len(), Some(n));
547 Ok(())
548 }));
549
550 res!(test_it(filter, &["Binary encdec aint 01", "all", "unit", "aint"], || {
551 if let Some(bigint) = BigInt::parse_bytes(b"0", 10) {
552 let v1 = Dat::from(bigint);
553 let mut buf = Vec::new();
554 buf = res!(v1.to_bytes(buf));
555 let (v2, _) = res!(Dat::from_bytes(&buf));
556 req!(v1, v2);
557 } else {
558 return Err(err!("Problem generating BigInt."; Integer));
559 }
560 Ok(())
561 }));
562
563 res!(test_it(filter, &["Binary encdec aint 02", "all", "unit", "aint"], || {
564 if let Some(bigint) = BigInt::parse_bytes(b"12345678901234567890123456789", 10) {
565 let v1 = Dat::from(bigint);
566 let mut buf = Vec::new();
567 buf = res!(v1.to_bytes(buf));
568 let (v2, _) = res!(Dat::from_bytes(&buf));
569 req!(v1, v2);
570 } else {
571 return Err(err!("Problem generating BigInt."; Integer));
572 }
573 Ok(())
574 }));
575
576 res!(test_it(filter, &["Binary encdec adec", "all", "unit", "adec"], || {
577 let bigdec = res!(BigDecimal::from_str(&"-123.45678901234567890123456789"));
578 let v1 = Dat::from(bigdec);
579 let mut buf = Vec::new();
580 buf = res!(v1.to_bytes(buf));
581 let (v2, _) = res!(Dat::from_bytes(&buf));
582 req!(v1, v2);
583 Ok(())
584 }));
585
586 res!(test_it(filter, &["Binary encdec list", "all", "unit", "list"], || {
587 let v1 = Dat::from(vec![
588 dat!("hello"),
589 dat!("world"),
590 dat!(42),
591 ]);
592 let mut buf = Vec::new();
593 buf = res!(v1.to_bytes(buf));
594 let (v2, _n) = res!(Dat::from_bytes(&buf));
595 req!(v1, v2);
596 Ok(())
597 }));
598
599 res!(test_it(filter, &["Binary encdec list len 2", "all", "unit", "list"], || {
600 let v1 = Dat::from([
601 dat!("one"),
602 dat!("two"),
603 ]);
604 let mut buf = Vec::new();
605 buf = res!(v1.to_bytes(buf));
606 let (v2, _n) = res!(Dat::from_bytes(&buf));
607 req!(v1, v2);
608 Ok(())
609 }));
610
611 res!(test_it(filter, &["Binary encdec list len 3", "all", "unit", "list"], || {
612 let v1 = Dat::from([
613 dat!("one"),
614 dat!("two"),
615 dat!("three"),
616 ]);
617 let mut buf = Vec::new();
618 buf = res!(v1.to_bytes(buf));
619 let (v2, _n) = res!(Dat::from_bytes(&buf));
620 req!(v1, v2);
621 Ok(())
622 }));
623
624 res!(test_it(filter, &["Binary encdec list len 4", "all", "unit", "list"], || {
625 let v1 = Dat::from([
626 dat!("one"),
627 dat!("two"),
628 dat!("three"),
629 dat!("four"),
630 ]);
631 let mut buf = Vec::new();
632 buf = res!(v1.to_bytes(buf));
633 let (v2, _n) = res!(Dat::from_bytes(&buf));
634 req!(v1, v2);
635 Ok(())
636 }));
637
638 res!(test_it(filter, &["Binary encdec list len 5", "all", "unit", "list"], || {
639 let v1 = Dat::from([
640 dat!("one"),
641 dat!("two"),
642 dat!("three"),
643 dat!("four"),
644 dat!("five"),
645 ]);
646 let mut buf = Vec::new();
647 buf = res!(v1.to_bytes(buf));
648 let (v2, _n) = res!(Dat::from_bytes(&buf));
649 req!(v1, v2);
650 Ok(())
651 }));
652
653 res!(test_it(filter, &["Binary encdec list len 6", "all", "unit", "list"], || {
654 let v1 = Dat::from([
655 dat!("one"),
656 dat!("two"),
657 dat!("three"),
658 dat!("four"),
659 dat!("five"),
660 dat!("six"),
661 ]);
662 let mut buf = Vec::new();
663 buf = res!(v1.to_bytes(buf));
664 let (v2, _n) = res!(Dat::from_bytes(&buf));
665 req!(v1, v2);
666 Ok(())
667 }));
668
669 res!(test_it(filter, &["Binary encdec list len 7", "all", "unit", "list"], || {
670 let v1 = Dat::from([
671 dat!("one"),
672 dat!("two"),
673 dat!("three"),
674 dat!("four"),
675 dat!("five"),
676 dat!("six"),
677 dat!("seven"),
678 ]);
679 let mut buf = Vec::new();
680 buf = res!(v1.to_bytes(buf));
681 let (v2, _n) = res!(Dat::from_bytes(&buf));
682 req!(v1, v2);
683 Ok(())
684 }));
685
686 res!(test_it(filter, &["Binary encdec list len 8", "all", "unit", "list"], || {
687 let v1 = Dat::from([
688 dat!("one"),
689 dat!("two"),
690 dat!("three"),
691 dat!("four"),
692 dat!("five"),
693 dat!("six"),
694 dat!("seven"),
695 dat!("eight"),
696 ]);
697 let mut buf = Vec::new();
698 buf = res!(v1.to_bytes(buf));
699 let (v2, _n) = res!(Dat::from_bytes(&buf));
700 req!(v1, v2);
701 Ok(())
702 }));
703
704 res!(test_it(filter, &["Binary encdec list len 9", "all", "unit", "list"], || {
705 let v1 = Dat::from([
706 dat!("one"),
707 dat!("two"),
708 dat!("three"),
709 dat!("four"),
710 dat!("five"),
711 dat!("six"),
712 dat!("seven"),
713 dat!("eight"),
714 dat!("nine"),
715 ]);
716 let mut buf = Vec::new();
717 buf = res!(v1.to_bytes(buf));
718 let (v2, _n) = res!(Dat::from_bytes(&buf));
719 req!(v1, v2);
720 Ok(())
721 }));
722
723 res!(test_it(filter, &["Binary encdec list len 10", "all", "unit", "list"], || {
724 let v1 = Dat::from([
725 dat!("one"),
726 dat!("two"),
727 dat!("three"),
728 dat!("four"),
729 dat!("five"),
730 dat!("six"),
731 dat!("seven"),
732 dat!("eight"),
733 dat!("nine"),
734 dat!("ten"),
735 ]);
736 let mut buf = Vec::new();
737 buf = res!(v1.to_bytes(buf));
738 let (v2, _n) = res!(Dat::from_bytes(&buf));
739 req!(v1, v2);
740 Ok(())
741 }));
742
743 res!(test_it(filter, &["Binary encdec vek", "all", "unit", "vek"], || {
744 let v1 = res!(Dat::try_vek_from(vec![
745 dat!("hello"),
746 dat!("world"),
747 ]));
748 let mut buf = Vec::new();
749 buf = res!(v1.to_bytes(buf));
750 let (v2, _n) = res!(Dat::from_bytes(&buf));
751 req!(v1, v2);
752 Ok(())
753 }));
754
755 res!(test_it(filter, &["Binary encdec ordmap", "all", "unit", "ordmap"], || {
756 let v1 = omapdat!{
757 "Meaning of life" => 42u8,
758 "key" => "value",
759 };
760 let mut buf = Vec::new();
761 buf = res!(v1.to_bytes(buf));
762 let (v2, n) = res!(Dat::from_bytes(&buf));
763 req!(n, 37);
764 req!(v1, v2);
765 Ok(())
766 }));
767
768 res!(test_it(filter, &["Binary encdec map", "all", "unit", "map"], || {
769 let v1 = mapdat!{
770 "Meaning of life" => 42u8,
771 "key" => "value",
772 };
773 let mut buf = Vec::new();
774 buf = res!(v1.to_bytes(buf));
775 let (v2, n) = res!(Dat::from_bytes(&buf));
776 req!(n, 37);
777 req!(v1, v2);
778 Ok(())
779 }));
780
781 res!(test_it(filter, &["Binary encdec usr", "all", "unit", "usr"], || {
782 let ukid = UsrKindId::new(5, Some("my_type"), Some(Kind::Str));
783 let v0 = dat!("hello world");
784 let v1 = Dat::Usr(ukid, Some(Box::new(v0.clone())));
785 let mut buf = Vec::new();
786 buf = res!(v1.to_bytes(buf));
787 let (v2, n) = res!(Dat::from_bytes(&buf));
788 req!(n, 1 + 2 + 1 + 1 + 2 + 11);
789 req!(v1, v2);
790 Ok(())
791 }));
792
793 res!(test_it(filter, &["Binary encdec box", "all", "unit", "box"], || {
794 let v0 = dat!("hello world");
795 let v1 = Dat::Box(Box::new(v0.clone()));
796 let mut buf = Vec::new();
797 buf = res!(v1.to_bytes(buf));
798 let (v2, n) = res!(Dat::from_bytes(&buf));
799 req!(n, 1 + 1 + 2 + 11);
800 req!(v1, v2);
801 Ok(())
802 }));
803
804 res!(test_it(filter, &["Binary encdec opt 01", "all", "unit", "opt"], || {
805 let v = dat!("hello world");
806 let v0 = dat!(Some(v.clone()));
807 let v1 = Dat::Opt(Box::new(Some(v)));
808 req!(v0, v1);
809 let mut buf = Vec::new();
810 buf = res!(v1.to_bytes(buf));
811 let (v2, n) = res!(Dat::from_bytes(&buf));
812 req!(n, 1 + 1 + 2 + 11);
813 req!(v1, v2);
814 Ok(())
815 }));
816
817 res!(test_it(filter, &["Binary encdec opt 02", "all", "unit", "opt"], || {
818 let v1 = Dat::Opt(Box::new(None));
819 let mut buf = Vec::new();
820 buf = res!(v1.to_bytes(buf));
821 let (v2, n) = res!(Dat::from_bytes(&buf));
822 req!(n, 1);
823 req!(v1, v2);
824 Ok(())
825 }));
826
827 res!(test_it(filter, &["Binary encdec c64", "all", "unit", "c64"], || {
828 for i in 0..100_000 {
829 //let mask = 0x_00_00_00_00_00_00_FF_FF;
830 let mask = 0x_FF_FF_FF_FF_FF_FF_FF_FF;
831 let v1 = Dat::C64(Rand::rand_u64() & mask);
832 let mut buf = Vec::new();
833 buf = res!(v1.to_bytes(buf));
834 let (v2, _n) = res!(Dat::from_bytes(&buf));
835 req!(v1, v2, "Completed {} successful comparisons", i);
836 }
837 Ok(())
838 }));
839
840 res!(test_it(filter, &["Binary count 000", "all", "unit", "count"], || {
841 let mut buf = std::io::Cursor::new(Vec::new());
842 let c = res!(Dat::count_bytes(&mut buf));
843 req!(c, 0);
844 Ok(())
845 }));
846
847 res!(test_it(filter, &["Binary count 010", "all", "unit", "count"], || {
848 let d = dat!("hello this is a test");
849 let mut buf = std::io::Cursor::new(Vec::new());
850 buf = std::io::Cursor::new(res!(d.to_bytes(buf.into_inner())));
851 let c1 = buf.get_ref().len();
852 let c2 = res!(Dat::count_bytes(&mut buf));
853 req!(c1, c2);
854 Ok(())
855 }));
856
857 res!(test_it(filter, &["Binary count 020", "all", "unit", "count"], || {
858 let d1 = dat!("hello this is a test");
859 let d2 = dat!("another test");
860 let mut buf = std::io::Cursor::new(Vec::new());
861 buf = std::io::Cursor::new(res!(d1.to_bytes(buf.into_inner())));
862 let c1 = buf.get_ref().len();
863 buf = std::io::Cursor::new(res!(d2.to_bytes(buf.into_inner())));
864 let c2 = buf.get_ref().len() - c1;
865 let c3 = res!(Dat::count_bytes(&mut buf));
866 req!(c1, c3);
867 let c3 = res!(Dat::count_bytes(&mut buf));
868 req!(c2, c3);
869 Ok(())
870 }));
871
872 res!(test_it(filter, &["Binary wrap bytes 00", "all", "unit", "wrap"], || {
873 let mut byts = vec![1,2,3,4,5,6,7,8,9];
874 let expected = Dat::BC64(byts.clone());
875 byts = res!(Dat::wrap_bytes_c64(byts));
876 let (result, _) = res!(Dat::from_bytes(&byts));
877 req!(result, expected);
878 Ok(())
879 }));
880
881 res!(test_it(filter, &["Binary wrap bytes 01", "all", "unit", "wrap"], || {
882 let mut byts = vec![1,2,3,4,5,6,7,8,9];
883 let expected = Dat::BU8(byts.clone());
884 byts = res!(Dat::wrap_bytes_var(byts));
885 let (result, _) = res!(Dat::from_bytes(&byts));
886 req!(result, expected);
887 Ok(())
888 }));
889
890 res!(test_it(filter, &["Binary wrap bytes 02", "all", "unit", "wrap"], || {
891 let mut byts = vec![42; 300];
892 let expected = Dat::BU16(byts.clone());
893 byts = res!(Dat::wrap_bytes_var(byts));
894 let (result, _) = res!(Dat::from_bytes(&byts));
895 req!(result, expected);
896 Ok(())
897 }));
898
899 Ok(())
900}