Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/tests/daticle.rs

47.7 KiB, 22 runs

created by r1870400018:499, 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 self,
4 FromDatMap,
5 ToDatMap,
6 daticle::{
7 IterDat,
8 IterDatValsMut,
9 },
10 usr::UsrKindId,
11};
12
13use oxedyne_fe2o3_core::{
14 prelude::*,
15 test::test_it,
16};
17use oxedyne_fe2o3_num::{
18 prelude::*,
19 BigDecimal,
20 BigInt,
21 float::{
22 Float32,
23 Float64,
24 },
25};
26
27use std::collections::BTreeMap;
28
29pub fn test_daticle_func(filter: &'static str) -> Outcome<()> {
30
31 res!(test_it(filter, &["Map 000", "all", "map"], || {
32 let d = mapdat!{
33 "key1" => "value1",
34 "key2" => "value2",
35 };
36 req!(res!(d.map_get(&dat!("key1"))).unwrap(), &dat!("value1"));
37 Ok(())
38 }));
39
40 res!(test_it(filter, &["Map 010", "all", "map"], || {
41 let d = mapdat!{
42 "key1" => "value1",
43 "key2" => "value2",
44 };
45 if let Some(Dat::Str(s)) = res!(d.map_get_type(&dat!("key1"), &[&Kind::Str])) {
46 req!(s, "value1");
47 }
48 Ok(())
49 }));
50
51 res!(test_it(filter, &["Map struct 000", "all", "map", "struct"], || {
52 // Loops over the map, but it's really best to loop over the struct fields,
53 // requiring the reflection possible in a derive macro.
54
55 #[derive(Debug, Default, PartialEq)]
56 struct S {
57 a: u32,
58 b: bool,
59 c: String,
60 }
61
62 let d = mapdat!{
63 "a" => 42u32,
64 "b" => true,
65 "c" => "hello".to_string(),
66 };
67
68 let mut s = S::default();
69
70 if let Dat::Map(map) = d {
71 for (k, v) in map.iter() {
72 if let Dat::Str(ks) = k {
73 match &**ks {
74 "a" => if let Dat::U32(n) = v { s.a = n.clone() },
75 "b" => if let Dat::Bool(b) = v { s.b = *b },
76 "c" => if let Dat::Str(t) = v { s.c = t.clone() },
77 _ => (),
78 }
79 }
80 }
81 }
82
83 let expected = S {
84 a: 42,
85 b: true,
86 c: "hello".to_string(),
87 };
88
89 req!(s, expected);
90 Ok(())
91 }));
92
93 res!(test_it(filter, &["IterDat 010", "all", "iter"], || {
94 let d = omapdat!{
95 listdat!["key11", 12u8] => 1u8,
96 "key2" => "val2",
97 3u8 => "val3",
98 };
99 let mut iter = IterDat::new(d.clone());
100 req!(iter.next(), Some(dat!("key11")));
101 req!(iter.next(), Some(dat!(12u8)));
102 req!(iter.next(), Some(dat!(1u8)));
103 req!(iter.next(), Some(dat!("key2")));
104 req!(iter.next(), Some(dat!("val2")));
105 req!(iter.next(), Some(dat!(3u8)));
106 req!(iter.next(), Some(dat!("val3")));
107 req!(iter.next(), None::<Dat>);
108 req!(iter.next(), None::<Dat>);
109 req!(iter.next(), None::<Dat>);
110 let mut iter2 = IterDat::new(d);
111 req!(iter2.next(), Some(dat!("key11")));
112 Ok(())
113 }));
114
115 res!(test_it(filter, &["IterDat 020", "all", "iter"], || {
116 let d = omapdat!{
117 "key1" => omapdat!{
118 2u8 => "val2",
119 "key3" => listdat!["val31", 32u8],
120 },
121 omapdat!{
122 "key4" => 4u8,
123 5u8 => "val5",
124 } => "val6",
125 7u8 => "val7",
126 };
127 let mut iter = IterDat::new(d);
128 req!(iter.next(), Some(dat!("key1")));
129 req!(iter.next(), Some(dat!(2u8)));
130 req!(iter.next(), Some(dat!("val2")));
131 req!(iter.next(), Some(dat!("key3")));
132 req!(iter.next(), Some(dat!("val31")));
133 req!(iter.next(), Some(dat!(32u8)));
134 req!(iter.next(), Some(dat!("key4")));
135 req!(iter.next(), Some(dat!(4u8)));
136 req!(iter.next(), Some(dat!(5u8)));
137 req!(iter.next(), Some(dat!("val5")));
138 req!(iter.next(), Some(dat!("val6")));
139 req!(iter.next(), Some(dat!(7u8)));
140 req!(iter.next(), Some(dat!("val7")));
141 req!(iter.next(), None::<Dat>);
142 req!(iter.next(), None::<Dat>);
143 req!(iter.next(), None::<Dat>);
144 Ok(())
145 }));
146
147 res!(test_it(filter, &["IterDat 030", "all", "iter"], || {
148 let mut d = omapdat!{
149 listdat!["key11", 12u8] => 1u8,
150 "key2" => "val2",
151 3u8 => 4u8,
152 };
153 {
154 let mut iter = IterDatValsMut::new(&mut d);
155 req!(iter.next(), Some(&mut dat!(1u8)));
156 req!(iter.next(), Some(&mut dat!("val2")));
157 if let Some(Dat::U8(n)) = iter.next() {
158 *n = 6;
159 }
160 }
161 let mut iter2 = IterDatValsMut::new(&mut d);
162 iter2.next();
163 iter2.next();
164 req!(iter2.next(), Some(&mut dat!(6u8)));
165 req!(iter2.next(), None::<&mut Dat>);
166 req!(iter2.next(), None::<&mut Dat>);
167 req!(iter2.next(), None::<&mut Dat>);
168 Ok(())
169 }));
170
171 res!(test_it(filter, &["Simple dat", "all", "i32"], || {
172 let d = dat!(42i32);
173 let n = res!(match d {
174 Dat::I32(n) => Ok(n),
175 _ => Err(err!("A Dat::I32 was expected, found {:?}", d; Input, Conversion, Mismatch)),
176 });
177 req!(n, 42i32);
178 Ok(())
179 }));
180
181 res!(test_it(filter, &["Derive struct from map 000", "all", "map", "struct"], || {
182
183 #[derive(Debug, Default, FromDatMap, PartialEq)]
184 struct S0 {
185 #[rename(name = "Number")]
186 a: i32,
187 b: bool,
188 s: String,
189 s2: String,
190 byts: Vec<u8>,
191 f0: Float32, // cannot use f32, f64
192 big: BigInt,
193 key0: Box<Dat>,
194 c64: Dat,
195 u64_0: u64,
196 #[optional]
197 u64_1: u64,
198 list0: Vec<Dat>,
199 map0: DaticleMap,
200 map1: Dat,
201 #[skip]
202 s1: S1,
203 }
204
205 #[derive(Debug, Default, FromDatMap, PartialEq)]
206 struct S1 {
207 x: u8,
208 y: bool,
209 }
210
211 let d0 = mapdat!{
212 "Number" => dat!(42i32),
213 "b" => dat!(true),
214 "s" => "Euler",
215 "s2" => "",
216 "byts" => vec![1u8, 2, 3, 4],
217 "f0" => -42.0f32,
218 "big" => dat!(res!(aint!("-4200000000000000000"))),
219 "key0" => Box::new(dat!(42u8)),
220 "c64" => Dat::C64(42),
221 "u64_0" => 42u64,
222 // u64_1 deliberately omitted
223 "list0" => listdat![1,2,3,4],
224 "map0" => mapdat!{
225 "x" => 2u8,
226 "y" => true,
227 },
228 "map1" => mapdat!{
229 "x" => 2u8,
230 "y" => true,
231 },
232 // s1 deliberately omitted
233 };
234
235 let s0 = S0 {
236 a: 42i32,
237 b: true,
238 s: "Euler".to_string(),
239 s2: "".to_string(),
240 byts: vec![1u8, 2, 3, 4],
241 f0: Float32(-42.0),
242 big: res!(aint!("-4200000000000000000")),
243 key0: Box::new(dat!(42u8)),
244 c64: Dat::C64(42),
245 u64_0: 42,
246 u64_1: 0,
247 list0: listdat![1,2,3,4].get_list().unwrap(),
248 map0: mapdat!{
249 "x" => 2u8,
250 "y" => true,
251 }.get_map().unwrap(),
252 map1: mapdat!{
253 "x" => 2u8,
254 "y" => true,
255 },
256 s1: S1::default(),
257 };
258
259 let s1 = S1 {
260 x: 2,
261 y: true,
262 };
263
264 if let Dat::Map(map) = d0 {
265 let s_0 = res!(S0::from_datmap(map));
266 req!(s_0, s0);
267 if let Dat::C64(c64_0) = s0.c64 {
268 req!(c64_0, 42);
269 }
270 let s_1 = res!(S1::from_datmap(s0.map0));
271 req!(s_1, s1);
272 if let Dat::Map(map) = s0.map1 {
273 let s_2 = res!(S1::from_datmap(map));
274 req!(s_2, s1);
275 }
276 }
277 Ok(())
278 }));
279
280 res!(test_it(filter, &["Derive map from struct 000", "all", "map", "struct"], || {
281
282 #[derive(Debug, Default, ToDatMap)]
283 struct S0 {
284 #[rename(name = "Number")]
285 a: i32,
286 b: bool,
287 d: Dat,
288 m: DaticleMap,
289 }
290
291 let m0 = mapdat!{
292 1 => 2,
293 3 => 4,
294 };
295
296 let s = S0 {
297 a: 42i32,
298 b: true,
299 d: Dat::Str("".to_string()),
300 m: m0.get_map().unwrap(),
301 };
302
303 let d0 = mapdat!{
304 "Number" => dat!(42i32),
305 "b" => dat!(true),
306 "d" => Dat::Str("".to_string()),
307 "m" => m0.get_map().unwrap(),
308 };
309
310 let d = S0::to_datmap(s);
311 req!(d, d0);
312 Ok(())
313 }));
314
315 // Atomic Kinds ===========================
316 // Logic
317
318 res!(test_it(filter, &["From 000", "all", "from", "empty"], || {
319 req!(Dat::from(()).kind(), Kind::Empty);
320 Ok(())
321 }));
322
323 res!(test_it(filter, &["From 001", "all", "from", "best", "empty"], || {
324 req!(Dat::best_from(()).kind(), Kind::Empty);
325 Ok(())
326 }));
327
328 res!(test_it(filter, &["From 010", "all", "from", "bool"], || {
329 req!(Dat::from(true).kind(), Kind::True);
330 Ok(())
331 }));
332
333 res!(test_it(filter, &["From 011", "all", "from", "best", "bool"], || {
334 req!(Dat::best_from(true).kind(), Kind::True);
335 Ok(())
336 }));
337
338 res!(test_it(filter, &["From 020", "all", "from", "bool"], || {
339 req!(Dat::from(false).kind(), Kind::False);
340 Ok(())
341 }));
342
343 res!(test_it(filter, &["From 021", "all", "from", "best", "bool"], || {
344 req!(Dat::best_from(false).kind(), Kind::False);
345 Ok(())
346 }));
347
348 res!(test_it(filter, &["From 025", "all", "from", "opt"], || {
349 req!(Dat::from(None::<bool>).kind(), Kind::None);
350 Ok(())
351 }));
352
353 res!(test_it(filter, &["From 026", "all", "from", "best", "opt"], || {
354 req!(Dat::best_from(None::<bool>).kind(), Kind::None);
355 Ok(())
356 }));
357 // Fixed
358
359 res!(test_it(filter, &["Explicit u8", "all", "u8"], || {
360 req!(Dat::U8(0).kind(), Kind::U8);
361 Ok(())
362 }));
363
364 res!(test_it(filter, &["From 031", "all", "from", "u8"], || {
365 req!(Dat::from(0u8).kind(), Kind::U8);
366 Ok(())
367 }));
368
369 res!(test_it(filter, &["From 032", "all", "from", "best", "u8"], || {
370 req!(Dat::best_from(0u8).kind(), Kind::U8);
371 Ok(())
372 }));
373
374 // Test min-sizing as well as From.
375
376 res!(test_it(filter, &["Explicit u16", "all", "u16"], || {
377 req!(Dat::U16(0).kind(), Kind::U16);
378 Ok(())
379 }));
380
381 res!(test_it(filter, &["From 041", "all", "from", "u16", "hex"], || {
382 req!(Dat::from(0x_00_ffu16).kind(), Kind::U16);
383 Ok(())
384 }));
385
386 res!(test_it(filter, &["From 042", "all", "from", "u16", "hex"], || {
387 req!(Dat::from(0x_01_00u16).kind(), Kind::U16);
388 Ok(())
389 }));
390
391 res!(test_it(filter, &["From 043", "all", "from", "best", "u8", "u16", "hex", "minsize"], || {
392 req!(Dat::best_from(0x_00_ffu16).kind(), Kind::U8);
393 Ok(())
394 }));
395
396 res!(test_it(filter, &["From 044", "all", "from", "best", "u16", "hex", "minsize"], || {
397 req!(Dat::best_from(0x_01_00u16).kind(), Kind::U16);
398 Ok(())
399 }));
400
401
402 res!(test_it(filter, &["Explicit u32", "all", "u32"], || {
403 req!(Dat::U32(0).kind(), Kind::U32);
404 Ok(())
405 }));
406
407 res!(test_it(filter, &["From 051", "all", "from", "u32", "hex"], || {
408 req!(Dat::from(0x_00_00_00_ffu32).kind(), Kind::U32);
409 Ok(())
410 }));
411
412 res!(test_it(filter, &["From 052", "all", "from", "u32", "hex"], || {
413 req!(Dat::from(0x_00_00_ff_ffu32).kind(), Kind::U32);
414 Ok(())
415 }));
416
417 res!(test_it(filter, &["From 053", "all", "from", "u32", "hex"], || {
418 req!(Dat::from(0x_00_01_00_00u32).kind(), Kind::U32);
419 Ok(())
420 }));
421
422 res!(test_it(filter, &["From 054", "all", "from", "best", "u8", "u32", "minsize"], || {
423 req!(Dat::best_from(0x_00_00_00_ffu32).kind(), Kind::U8);
424 Ok(())
425 }));
426
427 res!(test_it(filter, &["From 055", "all", "from", "best", "u16", "u32", "minsize"], || {
428 req!(Dat::best_from(0x_00_00_ff_ffu32).kind(), Kind::U16);
429 Ok(())
430 }));
431
432 res!(test_it(filter, &["From 056", "all", "from", "best", "u32", "minsize"], || {
433 req!(Dat::best_from(0x_00_01_00_00u32).kind(), Kind::U32);
434 Ok(())
435 }));
436
437
438 res!(test_it(filter, &["Explicit u64", "all", "u64"], || {
439 req!(Dat::U64(0).kind(), Kind::U64);
440 Ok(())
441 }));
442
443 res!(test_it(filter, &["From 061", "all", "from", "u64", "hex"], || {
444 req!(Dat::from(0x_00_00_00_00_00_00_00_ffu64).kind(), Kind::U64);
445 Ok(())
446 }));
447
448 res!(test_it(filter, &["From 062", "all", "from", "u64", "hex"], || {
449 req!(Dat::from(0x_00_00_00_00_00_00_ff_ffu64).kind(), Kind::U64);
450 Ok(())
451 }));
452
453 res!(test_it(filter, &["From 063", "all", "from", "u64", "hex"], || {
454 req!(Dat::from(0x_00_00_00_00_ff_ff_ff_ffu64).kind(), Kind::U64);
455 Ok(())
456 }));
457
458 res!(test_it(filter, &["From 064", "all", "from", "u64", "hex"], || {
459 req!(Dat::from(0x_00_00_00_01_00_00_00_00u64).kind(), Kind::U64);
460 Ok(())
461 }));
462
463 res!(test_it(filter, &["From 065", "all", "from", "best", "u8", "u64", "hex", "minsize"], || {
464 req!(Dat::best_from(0x_00_00_00_00_00_00_00_ffu64).kind(), Kind::U8);
465 Ok(())
466 }));
467
468 res!(test_it(filter, &["From 066", "all", "from", "best", "u16", "u64", "hex", "minsize"], || {
469 req!(Dat::best_from(0x_00_00_00_00_00_00_ff_ffu64).kind(), Kind::U16);
470 Ok(())
471 }));
472
473 res!(test_it(filter, &["From 067", "all", "from", "best", "u32", "u64", "hex", "minsize"], || {
474 req!(Dat::best_from(0x_00_00_00_00_ff_ff_ff_ffu64).kind(), Kind::U32);
475 Ok(())
476 }));
477
478 res!(test_it(filter, &["From 068", "all", "from", "best", "u64", "hex", "minsize"], || {
479 req!(Dat::best_from(0x_00_00_00_01_00_00_00_00u64).kind(), Kind::U64);
480 Ok(())
481 }));
482
483
484 res!(test_it(filter, &["Explicit u128", "all", "u128"], || {
485 req!(Dat::U128(0).kind(), Kind::U128);
486 Ok(())
487 }));
488
489 res!(test_it(filter, &["From 071", "all", "from", "u128", "hex"], || {
490 req!(Dat::from(0x_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00_ffu128).kind(), Kind::U128);
491 Ok(())
492 }));
493
494 res!(test_it(filter, &["From 072", "all", "from", "u128", "hex"], || {
495 req!(Dat::from(0x_00_00_00_00_00_00_00_00_00_00_00_00_00_00_ff_ffu128).kind(), Kind::U128);
496 Ok(())
497 }));
498
499 res!(test_it(filter, &["From 073", "all", "from", "u128", "hex"], || {
500 req!(Dat::from(0x_00_00_00_00_00_00_00_00_00_00_00_00_ff_ff_ff_ffu128).kind(), Kind::U128);
501 Ok(())
502 }));
503
504 res!(test_it(filter, &["From 074", "all", "from", "u128", "hex"], || {
505 req!(Dat::from(0x_00_00_00_00_00_00_00_00_ff_ff_ff_ff_ff_ff_ff_ffu128).kind(), Kind::U128);
506 Ok(())
507 }));
508
509 res!(test_it(filter, &["From 075", "all", "from", "u128", "hex"], || {
510 req!(Dat::from(0x_00_00_00_00_00_00_00_01_00_00_00_00_00_00_00_00u128).kind(), Kind::U128);
511 Ok(())
512 }));
513
514 res!(test_it(filter, &["From 076", "all", "from", "best", "u8", "u128", "hex", "minsize"], || {
515 req!(Dat::best_from(0x_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00_ffu128).kind(), Kind::U8);
516 Ok(())
517 }));
518
519 res!(test_it(filter, &["From 077", "all", "from", "best", "u16", "u128", "hex", "minsize"], || {
520 req!(Dat::best_from(0x_00_00_00_00_00_00_00_00_00_00_00_00_00_00_ff_ffu128).kind(), Kind::U16);
521 Ok(())
522 }));
523
524 res!(test_it(filter, &["From 078", "all", "from", "best", "u32", "u128", "hex", "minsize"], || {
525 req!(Dat::best_from(0x_00_00_00_00_00_00_00_00_00_00_00_00_ff_ff_ff_ffu128).kind(), Kind::U32);
526 Ok(())
527 }));
528
529 res!(test_it(filter, &["From 079", "all", "from", "best", "u64", "u128", "hex", "minsize"], || {
530 req!(Dat::best_from(0x_00_00_00_00_00_00_00_00_ff_ff_ff_ff_ff_ff_ff_ffu128).kind(), Kind::U64);
531 Ok(())
532 }));
533
534 res!(test_it(filter, &["From 080", "all", "from", "best", "u128", "hex", "minsize"], || {
535 req!(Dat::best_from(0x_00_00_00_00_00_00_00_01_00_00_00_00_00_00_00_00u128).kind(), Kind::U128);
536 Ok(())
537 }));
538
539
540 res!(test_it(filter, &["Explicit i8", "all", "i8"], || {
541 req!(Dat::I8(0).kind(), Kind::I8);
542 Ok(())
543 }));
544
545 res!(test_it(filter, &["From 086", "all", "from", "i8"], || {
546 req!(Dat::from(0i8).kind(), Kind::I8);
547 Ok(())
548 }));
549
550 res!(test_it(filter, &["From 087", "all", "from", "best", "i8"], || {
551 req!(Dat::best_from(0i8).kind(), Kind::I8);
552 Ok(())
553 }));
554
555 res!(test_it(filter, &["Explicit i16", "all", "i16"], || {
556 req!(Dat::I16(0).kind(), Kind::I16);
557 Ok(())
558 }));
559
560 res!(test_it(filter, &["From 091", "all", "from", "i16"], || {
561 req!(Dat::from(-128i16).kind(), Kind::I16);
562 Ok(())
563 }));
564
565 res!(test_it(filter, &["From 092", "all", "from", "i16"], || {
566 req!(Dat::from(127i16).kind(), Kind::I16);
567 Ok(())
568 }));
569
570 res!(test_it(filter, &["From 093", "all", "from", "best", "i8", "i16", "minsize"], || {
571 req!(Dat::best_from(-128i16).kind(), Kind::I8);
572 Ok(())
573 }));
574
575 res!(test_it(filter, &["From 094", "all", "from", "best", "u8", "i16", "minsize"], || {
576 req!(Dat::best_from(127i16).kind(), Kind::U8);
577 Ok(())
578 }));
579
580 res!(test_it(filter, &["From 095", "all", "from", "best", "i16", "i16", "minsize"], || {
581 req!(Dat::best_from(-129i16).kind(), Kind::I16);
582 Ok(())
583 }));
584
585 res!(test_it(filter, &["From 096", "all", "from", "best", "u8", "i16", "minsize"], || {
586 req!(Dat::best_from(128i16).kind(), Kind::U8);
587 Ok(())
588 }));
589
590 res!(test_it(filter, &["From 097", "all", "from", "best", "u16", "i16", "minsize"], || {
591 req!(Dat::best_from(256i16).kind(), Kind::U16);
592 Ok(())
593 }));
594
595
596 res!(test_it(filter, &["Explicit i32", "all", "i32"], || {
597 req!(Dat::I32(0).kind(), Kind::I32);
598 Ok(())
599 }));
600
601 res!(test_it(filter, &["From 101", "all", "from", "i32"], || {
602 req!(Dat::from(-128i32).kind(), Kind::I32);
603 Ok(())
604 }));
605
606 res!(test_it(filter, &["From 102", "all", "from", "i32"], || {
607 req!(Dat::from(127i32).kind(), Kind::I32);
608 Ok(())
609 }));
610
611 res!(test_it(filter, &["From 103", "all", "from", "best", "i8", "i32", "minsize"], || {
612 req!(Dat::best_from(-128i32).kind(), Kind::I8);
613 Ok(())
614 }));
615
616 res!(test_it(filter, &["From 104", "all", "from", "best", "u8", "i32", "minsize"], || {
617 req!(Dat::best_from(127i32).kind(), Kind::U8);
618 Ok(())
619 }));
620
621 res!(test_it(filter, &["From 105", "all", "from", "best", "i16", "i32", "minsize"], || {
622 req!(Dat::best_from(-32_768i32).kind(), Kind::I16);
623 Ok(())
624 }));
625
626 res!(test_it(filter, &["From 106", "all", "from", "best", "u16", "i32", "minsize"], || {
627 req!(Dat::best_from(32_767i32).kind(), Kind::U16);
628 Ok(())
629 }));
630
631 res!(test_it(filter, &["From 107", "all", "from", "best", "i32", "minsize"], || {
632 req!(Dat::best_from(-32_769i32).kind(), Kind::I32);
633 Ok(())
634 }));
635
636 res!(test_it(filter, &["From 108", "all", "from", "best", "u16", "i32", "minsize"], || {
637 req!(Dat::best_from(32_768i32).kind(), Kind::U16);
638 Ok(())
639 }));
640
641
642 res!(test_it(filter, &["Explicit i64", "all", "i64"], || {
643 req!(Dat::I64(0).kind(), Kind::I64);
644 Ok(())
645 }));
646
647 res!(test_it(filter, &["From 111", "all", "from", "i64"], || {
648 req!(Dat::from(-128i64).kind(), Kind::I64);
649 Ok(())
650 }));
651
652 res!(test_it(filter, &["From 112", "all", "from", "i64"], || {
653 req!(Dat::from(127i64).kind(), Kind::I64);
654 Ok(())
655 }));
656
657 res!(test_it(filter, &["From 113", "all", "from", "best", "i8", "i64", "minsize"], || {
658 req!(Dat::best_from(-128i64).kind(), Kind::I8);
659 Ok(())
660 }));
661
662 res!(test_it(filter, &["From 114", "all", "from", "best", "u8", "i64", "minsize"], || {
663 req!(Dat::best_from(127i64).kind(), Kind::U8);
664 Ok(())
665 }));
666
667 res!(test_it(filter, &["From 115", "all", "from", "best", "i16", "i64", "minsize"], || {
668 req!(Dat::best_from(-32_768i64).kind(), Kind::I16);
669 Ok(())
670 }));
671
672 res!(test_it(filter, &["From 116", "all", "from", "best", "u16", "i64", "minsize"], || {
673 req!(Dat::best_from(32_767i64).kind(), Kind::U16);
674 Ok(())
675 }));
676
677 res!(test_it(filter, &["From 117", "all", "from", "best", "i32", "i64", "minsize"], || {
678 req!(Dat::best_from(-2_147_483_648i64).kind(), Kind::I32);
679 Ok(())
680 }));
681
682 res!(test_it(filter, &["From 118", "all", "from", "best", "u32", "i64", "minsize"], || {
683 req!(Dat::best_from(2_147_483_647i64).kind(), Kind::U32);
684 Ok(())
685 }));
686
687 res!(test_it(filter, &["From 119", "all", "from", "best", "i64", "minsize"], || {
688 req!(Dat::best_from(-2_147_483_649i64).kind(), Kind::I64);
689 Ok(())
690 }));
691
692 res!(test_it(filter, &["From 120", "all", "from", "best", "u32", "i64", "minsize"], || {
693 req!(Dat::best_from(2_147_483_648i64).kind(), Kind::U32);
694 Ok(())
695 }));
696
697
698 res!(test_it(filter, &["Explicit i128", "all"], || {
699 req!(Dat::I128(0).kind(), Kind::I128);
700 Ok(())
701 }));
702
703 res!(test_it(filter, &["From 131", "all", "from", "i128"], || {
704 req!(Dat::from(-128i128).kind(), Kind::I128);
705 Ok(())
706 }));
707
708 res!(test_it(filter, &["From 132", "all", "from", "i128"], || {
709 req!(Dat::from(127i128).kind(), Kind::I128);
710 Ok(())
711 }));
712
713 res!(test_it(filter, &["From 133", "all", "from", "best", "i8", "i128", "minsize"], || {
714 req!(Dat::best_from(-128i128).kind(), Kind::I8);
715 Ok(())
716 }));
717
718 res!(test_it(filter, &["From 134", "all", "from", "best", "u8", "i128", "minsize"], || {
719 req!(Dat::best_from(127i128).kind(), Kind::U8);
720 Ok(())
721 }));
722
723 res!(test_it(filter, &["From 135", "all", "from", "best", "i16", "i128", "minsize"], || {
724 req!(Dat::best_from(-32_768i128).kind(), Kind::I16);
725 Ok(())
726 }));
727
728 res!(test_it(filter, &["From 136", "all", "from", "best", "u16", "i128", "minsize"], || {
729 req!(Dat::best_from(32_767i128).kind(), Kind::U16);
730 Ok(())
731 }));
732
733 res!(test_it(filter, &["From 137", "all", "from", "best", "i32", "i128", "minsize"], || {
734 req!(Dat::best_from(-2_147_483_648i128).kind(), Kind::I32);
735 Ok(())
736 }));
737
738 res!(test_it(filter, &["From 138", "all", "from", "best", "u32", "i128", "minsize"], || {
739 req!(Dat::best_from(2_147_483_647i128).kind(), Kind::U32);
740 Ok(())
741 }));
742
743 res!(test_it(filter, &["From 139", "all", "from", "best", "i64", "i128", "minsize"], || {
744 req!(Dat::best_from(-9_223_372_036_854_775_808i128).kind(), Kind::I64);
745 Ok(())
746 }));
747
748 res!(test_it(filter, &["From 140", "all", "from", "best", "u64", "i128", "minsize"], || {
749 req!(Dat::best_from(9_223_372_036_854_775_807i128).kind(), Kind::U64);
750 Ok(())
751 }));
752
753 res!(test_it(filter, &["From 141", "all", "from", "best", "i128", "minsize"], || {
754 req!(Dat::best_from(-9_223_372_036_854_775_809i128).kind(), Kind::I128);
755 Ok(())
756 }));
757
758 res!(test_it(filter, &["From 142", "all", "from", "best", "u64", "i128", "minsize"], || {
759 req!(Dat::best_from(9_223_372_036_854_775_808i128).kind(), Kind::U64);
760 Ok(())
761 }));
762
763
764 res!(test_it(filter, &["From 150", "all", "from", "usize"], || {
765 req!(
766 res!(Dat::try_from(0usize)).kind(),
767 match std::mem::size_of::<usize>() {
768 1 => Kind::U8,
769 2 => Kind::U16,
770 4 => Kind::U32,
771 8 => Kind::U64,
772 16 => Kind::U128,
773 s => return Err(err!(
774 "The usize for this machine is {}, which has not yet been \
775 mapped to a daticle kind.", s; System, Unimplemented, Bug)),
776 },
777 );
778 Ok(())
779 }));
780
781
782 res!(test_it(filter, &["From 151", "all", "from", "isize"], || {
783 req!(
784 res!(Dat::try_from(0isize)).kind(),
785 match std::mem::size_of::<isize>() {
786 1 => Kind::I8,
787 2 => Kind::I16,
788 4 => Kind::I32,
789 8 => Kind::I64,
790 16 => Kind::I128,
791 s => return Err(err!(
792 "The isize for this machine is {}, which has not yet been \
793 mapped to a daticle kind.", s; System, Unimplemented, Bug)),
794 },
795 );
796 Ok(())
797 }));
798
799
800 res!(test_it(filter, &["From 160", "all", "from", "f32"], || {
801 req!(Dat::from(Float32(0.0f32)).kind(), Kind::F32);
802 Ok(())
803 }));
804
805 res!(test_it(filter, &["From 161", "all", "from", "f32"], || {
806 req!(Dat::from(0.0f32).kind(), Kind::F32);
807 Ok(())
808 }));
809
810 res!(test_it(filter, &["From 162", "all", "from", "f64"], || {
811 req!(Dat::from(Float64(0.0f64)).kind(), Kind::F64);
812 Ok(())
813 }));
814
815 res!(test_it(filter, &["From 163", "all", "from", "f64"], || {
816 req!(Dat::from(0.0f64).kind(), Kind::F64);
817 Ok(())
818 }));
819
820 res!(test_it(filter, &["From 164", "all", "from", "best", "f32"], || {
821 req!(Dat::best_from(Float32(0.0f32)).kind(), Kind::F32);
822 Ok(())
823 }));
824
825 res!(test_it(filter, &["From 165", "all", "from", "best", "f32"], || {
826 req!(Dat::best_from(0.0f32).kind(), Kind::F32);
827 Ok(())
828 }));
829
830 res!(test_it(filter, &["From 166", "all", "from", "best", "f64"], || {
831 req!(Dat::best_from(Float64(0.0f64)).kind(), Kind::F64);
832 Ok(())
833 }));
834
835 res!(test_it(filter, &["From 167", "all", "from", "best", "f64"], || {
836 req!(Dat::best_from(0.0f64).kind(), Kind::F64);
837 Ok(())
838 }));
839
840 // Variable
841
842 res!(test_it(filter, &["From 170", "all", "from", "aint"], || {
843 req!(Dat::from(res!(BigInt::from_str("0"))).kind(), Kind::Aint);
844 Ok(())
845 }));
846
847 res!(test_it(filter, &["From 171", "all", "from", "best", "aint"], || {
848 req!(Dat::best_from(res!(BigInt::from_str("0"))).kind(), Kind::Aint);
849 Ok(())
850 }));
851
852 res!(test_it(filter, &["From 172", "all", "from", "aint"], || {
853 req!(Dat::from(res!(aint!("0"))).kind(), Kind::Aint);
854 Ok(())
855 }));
856
857 res!(test_it(filter, &["From 173", "all", "from", "aint"], || {
858 req!(Dat::from(res!(aint!(fmt!("{}0", u128::MAX)))).kind(), Kind::Aint);
859 Ok(())
860 }));
861
862 res!(test_it(filter, &["From 180", "all", "from", "adec"], || {
863 req!(Dat::from(res!(BigDecimal::from_str("0"))).kind(), Kind::Adec);
864 Ok(())
865 }));
866
867 res!(test_it(filter, &["From 181", "all", "from", "best", "adec"], || {
868 req!(Dat::best_from(res!(BigDecimal::from_str("0"))).kind(), Kind::Adec);
869 Ok(())
870 }));
871
872 res!(test_it(filter, &["From 182", "all", "from", "best", "adec"], || {
873 req!(Dat::best_from(res!(adec!("0"))).kind(), Kind::Adec);
874 Ok(())
875 }));
876
877 // No From impl for Dat::C64(_)
878
879 res!(test_it(filter, &["From 185", "all", "from", "str"], || {
880 req!(Dat::from(String::new()).kind(), Kind::Str);
881 Ok(())
882 }));
883
884 res!(test_it(filter, &["From 186", "all", "from", "best", "str"], || {
885 req!(Dat::best_from(String::new()).kind(), Kind::Str);
886 Ok(())
887 }));
888
889 res!(test_it(filter, &["From 187", "all", "from", "str"], || {
890 req!(Dat::from("").kind(), Kind::Str);
891 Ok(())
892 }));
893
894 res!(test_it(filter, &["From 188", "all", "from", "str"], || {
895 req!(Dat::best_from("").kind(), Kind::Str);
896 Ok(())
897 }));
898
899 // Molecular Kinds ========================
900 // Unitary
901
902 res!(test_it(filter, &["From 190", "all", "from", "usr"], || {
903 let ukid = UsrKindId::new(5, Some("my_type"), Some(Kind::I32));
904 let d0 = dat!(42);
905 let d1 = res!(Dat::try_from((ukid.clone(), Some(d0.clone()))));
906 req!(d1.kind(), Kind::Usr(ukid.clone()));
907 Ok(())
908 }));
909
910 res!(test_it(filter, &["From 193", "all", "from", "box"], || {
911 req!(
912 Dat::from(Box::new(0u8)).kind(),
913 Kind::Box(Some(Box::new(Kind::U8))),
914 );
915 Ok(())
916 }));
917
918 res!(test_it(filter, &["From 194", "all", "from", "best", "box"], || {
919 req!(
920 Dat::best_from(Box::new(0u8)).kind(),
921 Kind::Box(Some(Box::new(Kind::U8))),
922 );
923 Ok(())
924 }));
925
926
927 res!(test_it(filter, &["From 200", "all", "from", "opt"], || {
928 req!(
929 Dat::from(Some(0u8)).kind(),
930 Kind::Some(Some(Box::new(Kind::U8))),
931 );
932 Ok(())
933 }));
934
935 res!(test_it(filter, &["From 201", "all", "from", "best", "opt"], || {
936 req!(
937 Dat::best_from(Some(0u8)).kind(),
938 Kind::Some(Some(Box::new(Kind::U8))),
939 );
940 Ok(())
941 }));
942
943 // Heterogenous
944
945 res!(test_it(filter, &["From 214", "all", "from", "list"], || {
946 req!(Dat::from(vec![dat!(false)]).kind(), Kind::List);
947 Ok(())
948 }));
949
950 res!(test_it(filter, &["From 215", "all", "from", "best", "list"], || {
951 req!(Dat::best_from(vec![dat!(false)]).kind(), Kind::List);
952 Ok(())
953 }));
954
955
956 res!(test_it(filter, &["From 220", "all", "from", "tuple"], || {
957 req!(Dat::from([
958 dat!(0),
959 dat!(""),
960 ]).kind(), Kind::Tup2);
961 Ok(())
962 }));
963
964 res!(test_it(filter, &["From 221", "all", "from", "tuple"], || {
965 req!(Dat::from([
966 dat!(0),
967 dat!(""),
968 dat!(0),
969 ]).kind(), Kind::Tup3);
970 Ok(())
971 }));
972
973 res!(test_it(filter, &["From 222", "all", "from", "tuple"], || {
974 req!(Dat::from([
975 dat!(0),
976 dat!(""),
977 dat!(0),
978 dat!(""),
979 ]).kind(), Kind::Tup4);
980 Ok(())
981 }));
982
983 res!(test_it(filter, &["From 223", "all", "from", "tuple"], || {
984 req!(Dat::from([
985 dat!(0),
986 dat!(""),
987 dat!(0),
988 dat!(""),
989 dat!(0),
990 ]).kind(), Kind::Tup5);
991 Ok(())
992 }));
993
994 res!(test_it(filter, &["From 224", "all", "from", "tuple"], || {
995 req!(Dat::from([
996 dat!(0),
997 dat!(""),
998 dat!(0),
999 dat!(""),
1000 dat!(0),
1001 dat!(""),
1002 ]).kind(), Kind::Tup6);
1003 Ok(())
1004 }));
1005
1006 res!(test_it(filter, &["From 225", "all", "from", "tuple"], || {
1007 req!(Dat::from([
1008 dat!(0),
1009 dat!(""),
1010 dat!(0),
1011 dat!(""),
1012 dat!(0),
1013 dat!(""),
1014 dat!(0),
1015 ]).kind(), Kind::Tup7);
1016 Ok(())
1017 }));
1018
1019 res!(test_it(filter, &["From 226", "all", "from", "tuple"], || {
1020 req!(Dat::from([
1021 dat!(0),
1022 dat!(""),
1023 dat!(0),
1024 dat!(""),
1025 dat!(0),
1026 dat!(""),
1027 dat!(0),
1028 dat!(""),
1029 ]).kind(), Kind::Tup8);
1030 Ok(())
1031 }));
1032
1033 res!(test_it(filter, &["From 227", "all", "from", "tuple"], || {
1034 req!(Dat::from([
1035 dat!(0),
1036 dat!(""),
1037 dat!(0),
1038 dat!(""),
1039 dat!(0),
1040 dat!(""),
1041 dat!(0),
1042 dat!(""),
1043 dat!(0),
1044 ]).kind(), Kind::Tup9);
1045 Ok(())
1046 }));
1047
1048 res!(test_it(filter, &["From 228", "all", "from", "tuple"], || {
1049 req!(Dat::from([
1050 dat!(0),
1051 dat!(""),
1052 dat!(0),
1053 dat!(""),
1054 dat!(0),
1055 dat!(""),
1056 dat!(0),
1057 dat!(""),
1058 dat!(0),
1059 dat!(""),
1060 ]).kind(), Kind::Tup10);
1061 Ok(())
1062 }));
1063
1064 res!(test_it(filter, &["From 230", "all", "from", "best", "tuple"], || {
1065 req!(Dat::best_from([
1066 dat!(0),
1067 dat!(""),
1068 ]).kind(), Kind::Tup2);
1069 Ok(())
1070 }));
1071
1072 res!(test_it(filter, &["From 231", "all", "from", "best", "tuple"], || {
1073 req!(Dat::best_from([
1074 dat!(0),
1075 dat!(""),
1076 dat!(0),
1077 ]).kind(), Kind::Tup3);
1078 Ok(())
1079 }));
1080
1081 res!(test_it(filter, &["From 232", "all", "from", "best", "tuple"], || {
1082 req!(Dat::best_from([
1083 dat!(0),
1084 dat!(""),
1085 dat!(0),
1086 dat!(""),
1087 ]).kind(), Kind::Tup4);
1088 Ok(())
1089 }));
1090
1091 res!(test_it(filter, &["From 233", "all", "from", "best", "tuple"], || {
1092 req!(Dat::best_from([
1093 dat!(0),
1094 dat!(""),
1095 dat!(0),
1096 dat!(""),
1097 dat!(0),
1098 ]).kind(), Kind::Tup5);
1099 Ok(())
1100 }));
1101
1102 res!(test_it(filter, &["From 234", "all", "from", "best", "tuple"], || {
1103 req!(Dat::best_from([
1104 dat!(0),
1105 dat!(""),
1106 dat!(0),
1107 dat!(""),
1108 dat!(0),
1109 dat!(""),
1110 ]).kind(), Kind::Tup6);
1111 Ok(())
1112 }));
1113
1114 res!(test_it(filter, &["From 235", "all", "from", "best", "tuple"], || {
1115 req!(Dat::best_from([
1116 dat!(0),
1117 dat!(""),
1118 dat!(0),
1119 dat!(""),
1120 dat!(0),
1121 dat!(""),
1122 dat!(0),
1123 ]).kind(), Kind::Tup7);
1124 Ok(())
1125 }));
1126
1127 res!(test_it(filter, &["From 236", "all", "from", "best", "tuple"], || {
1128 req!(Dat::best_from([
1129 dat!(0),
1130 dat!(""),
1131 dat!(0),
1132 dat!(""),
1133 dat!(0),
1134 dat!(""),
1135 dat!(0),
1136 dat!(""),
1137 ]).kind(), Kind::Tup8);
1138 Ok(())
1139 }));
1140
1141 res!(test_it(filter, &["From 237", "all", "from", "best", "tuple"], || {
1142 req!(Dat::best_from([
1143 dat!(0),
1144 dat!(""),
1145 dat!(0),
1146 dat!(""),
1147 dat!(0),
1148 dat!(""),
1149 dat!(0),
1150 dat!(""),
1151 dat!(0),
1152 ]).kind(), Kind::Tup9);
1153 Ok(())
1154 }));
1155
1156 res!(test_it(filter, &["From 238", "all", "from", "best", "tuple"], || {
1157 req!(Dat::best_from([
1158 dat!(0),
1159 dat!(""),
1160 dat!(0),
1161 dat!(""),
1162 dat!(0),
1163 dat!(""),
1164 dat!(0),
1165 dat!(""),
1166 dat!(0),
1167 dat!(""),
1168 ]).kind(), Kind::Tup10);
1169 Ok(())
1170 }));
1171
1172
1173 res!(test_it(filter, &["From 240", "all", "from", "map"], || {
1174 let mut map = DaticleMap::new();
1175 map.insert(1u32.into(), dat!("first"));
1176 map.insert(dat!(2u32), dat!("second"));
1177 let d = Dat::from(map);
1178 req!(d.kind(), Kind::Map);
1179 Ok(())
1180 }));
1181
1182 // Homogenous
1183
1184 res!(test_it(filter, &["From 250", "all", "from", "vek"], || {
1185 let v = vec![
1186 dat!("hello"),
1187 dat!("world"),
1188 dat!(42),
1189 ];
1190 match Dat::try_vek_from(v.clone()) {
1191 Ok(_) => return Err(err!(
1192 "Creation of {:?} should have detected different kind in {:?}.",
1193 Kind::Vek, v; Test)),
1194 Err(e) => test!("Correctly detected error: {}", e),
1195 }
1196 Ok(())
1197 }));
1198
1199 // Variable length bytes
1200
1201 res!(test_it(filter, &["From 260", "all", "from", "bu64"], || {
1202 req!(Dat::from(vec![0u8]).kind(), Kind::BU64);
1203 Ok(())
1204 }));
1205
1206 res!(test_it(filter, &["From 261", "all", "from", "best", "bu64"], || {
1207 req!(Dat::best_from(vec![0u8]).kind(), Kind::BU64);
1208 Ok(())
1209 }));
1210
1211 res!(test_it(filter, &["From 262", "all", "from", "bu64"], || {
1212 req!(Dat::from(&vec![0u8][..]).kind(), Kind::BU64);
1213 Ok(())
1214 }));
1215
1216 res!(test_it(filter, &["From 263", "all", "from", "best", "bu64"], || {
1217 req!(Dat::best_from(&vec![0u8][..]).kind(), Kind::BU64);
1218 Ok(())
1219 }));
1220
1221 // BU8 -> BU32 and BC64 must be created manually
1222
1223 // Fixed length bytes
1224
1225 res!(test_it(filter, &["From 320", "all", "from", "tuple"], || {
1226 req!(Dat::from([0u8; 2]).kind(), Kind::B2);
1227 Ok(())
1228 }));
1229
1230 res!(test_it(filter, &["From 321", "all", "from", "tuple"], || {
1231 req!(Dat::from([0u8; 3]).kind(), Kind::B3);
1232 Ok(())
1233 }));
1234
1235 res!(test_it(filter, &["From 322", "all", "from", "tuple"], || {
1236 req!(Dat::from([0u8; 4]).kind(), Kind::B4);
1237 Ok(())
1238 }));
1239
1240 res!(test_it(filter, &["From 323", "all", "from", "tuple"], || {
1241 req!(Dat::from([0u8; 5]).kind(), Kind::B5);
1242 Ok(())
1243 }));
1244
1245 res!(test_it(filter, &["From 324", "all", "from", "tuple"], || {
1246 req!(Dat::from([0u8; 6]).kind(), Kind::B6);
1247 Ok(())
1248 }));
1249
1250 res!(test_it(filter, &["From 325", "all", "from", "tuple"], || {
1251 req!(Dat::from([0u8; 7]).kind(), Kind::B7);
1252 Ok(())
1253 }));
1254
1255 res!(test_it(filter, &["From 326", "all", "from", "tuple"], || {
1256 req!(Dat::from([0u8; 8]).kind(), Kind::B8);
1257 Ok(())
1258 }));
1259
1260 res!(test_it(filter, &["From 327", "all", "from", "tuple"], || {
1261 req!(Dat::from([0u8; 9]).kind(), Kind::B9);
1262 Ok(())
1263 }));
1264
1265 res!(test_it(filter, &["From 328", "all", "from", "tuple"], || {
1266 req!(Dat::from([0u8; 10]).kind(), Kind::B10);
1267 Ok(())
1268 }));
1269
1270 res!(test_it(filter, &["From 329", "all", "from", "tuple"], || {
1271 req!(Dat::from([0u8; 16]).kind(), Kind::B16);
1272 Ok(())
1273 }));
1274
1275 res!(test_it(filter, &["From 330", "all", "from", "tuple"], || {
1276 req!(Dat::from([0u8; 32]).kind(), Kind::B32);
1277 Ok(())
1278 }));
1279
1280 // Fixed length numbers
1281
1282 res!(test_it(filter, &["From 340", "all", "from", "tuple"], || {
1283 req!(Dat::from([0u16; 2]).kind(), Kind::Tup2u16);
1284 Ok(())
1285 }));
1286
1287 res!(test_it(filter, &["From 341", "all", "from", "tuple"], || {
1288 req!(Dat::from([0u16; 3]).kind(), Kind::Tup3u16);
1289 Ok(())
1290 }));
1291
1292 res!(test_it(filter, &["From 342", "all", "from", "tuple"], || {
1293 req!(Dat::from([0u16; 4]).kind(), Kind::Tup4u16);
1294 Ok(())
1295 }));
1296
1297 res!(test_it(filter, &["From 343", "all", "from", "tuple"], || {
1298 req!(Dat::from([0u16; 5]).kind(), Kind::Tup5u16);
1299 Ok(())
1300 }));
1301
1302 res!(test_it(filter, &["From 344", "all", "from", "tuple"], || {
1303 req!(Dat::from([0u16; 6]).kind(), Kind::Tup6u16);
1304 Ok(())
1305 }));
1306
1307 res!(test_it(filter, &["From 345", "all", "from", "tuple"], || {
1308 req!(Dat::from([0u16; 7]).kind(), Kind::Tup7u16);
1309 Ok(())
1310 }));
1311
1312 res!(test_it(filter, &["From 346", "all", "from", "tuple"], || {
1313 req!(Dat::from([0u16; 8]).kind(), Kind::Tup8u16);
1314 Ok(())
1315 }));
1316
1317 res!(test_it(filter, &["From 347", "all", "from", "tuple"], || {
1318 req!(Dat::from([0u16; 9]).kind(), Kind::Tup9u16);
1319 Ok(())
1320 }));
1321
1322 res!(test_it(filter, &["From 348", "all", "from", "tuple"], || {
1323 req!(Dat::from([0u16; 10]).kind(), Kind::Tup10u16);
1324 Ok(())
1325 }));
1326
1327
1328 res!(test_it(filter, &["From 350", "all", "from", "tuple"], || {
1329 req!(Dat::from([0u32; 2]).kind(), Kind::Tup2u32);
1330 Ok(())
1331 }));
1332
1333 res!(test_it(filter, &["From 351", "all", "from", "tuple"], || {
1334 req!(Dat::from([0u32; 3]).kind(), Kind::Tup3u32);
1335 Ok(())
1336 }));
1337
1338 res!(test_it(filter, &["From 352", "all", "from", "tuple"], || {
1339 req!(Dat::from([0u32; 4]).kind(), Kind::Tup4u32);
1340 Ok(())
1341 }));
1342
1343 res!(test_it(filter, &["From 353", "all", "from", "tuple"], || {
1344 req!(Dat::from([0u32; 5]).kind(), Kind::Tup5u32);
1345 Ok(())
1346 }));
1347
1348 res!(test_it(filter, &["From 354", "all", "from", "tuple"], || {
1349 req!(Dat::from([0u32; 6]).kind(), Kind::Tup6u32);
1350 Ok(())
1351 }));
1352
1353 res!(test_it(filter, &["From 355", "all", "from", "tuple"], || {
1354 req!(Dat::from([0u32; 7]).kind(), Kind::Tup7u32);
1355 Ok(())
1356 }));
1357
1358 res!(test_it(filter, &["From 356", "all", "from", "tuple"], || {
1359 req!(Dat::from([0u32; 8]).kind(), Kind::Tup8u32);
1360 Ok(())
1361 }));
1362
1363 res!(test_it(filter, &["From 357", "all", "from", "tuple"], || {
1364 req!(Dat::from([0u32; 9]).kind(), Kind::Tup9u32);
1365 Ok(())
1366 }));
1367
1368 res!(test_it(filter, &["From 358", "all", "from", "tuple"], || {
1369 req!(Dat::from([0u32; 10]).kind(), Kind::Tup10u32);
1370 Ok(())
1371 }));
1372
1373
1374 res!(test_it(filter, &["From 360", "all", "from", "tuple"], || {
1375 req!(Dat::from([0u64; 2]).kind(), Kind::Tup2u64);
1376 Ok(())
1377 }));
1378
1379 res!(test_it(filter, &["From 361", "all", "from", "tuple"], || {
1380 req!(Dat::from([0u64; 3]).kind(), Kind::Tup3u64);
1381 Ok(())
1382 }));
1383
1384 res!(test_it(filter, &["From 362", "all", "from", "tuple"], || {
1385 req!(Dat::from([0u64; 4]).kind(), Kind::Tup4u64);
1386 Ok(())
1387 }));
1388
1389 res!(test_it(filter, &["From 363", "all", "from", "tuple"], || {
1390 req!(Dat::from([0u64; 5]).kind(), Kind::Tup5u64);
1391 Ok(())
1392 }));
1393
1394 res!(test_it(filter, &["From 364", "all", "from", "tuple"], || {
1395 req!(Dat::from([0u64; 6]).kind(), Kind::Tup6u64);
1396 Ok(())
1397 }));
1398
1399 res!(test_it(filter, &["From 365", "all", "from", "tuple"], || {
1400 req!(Dat::from([0u64; 7]).kind(), Kind::Tup7u64);
1401 Ok(())
1402 }));
1403
1404 res!(test_it(filter, &["From 366", "all", "from", "tuple"], || {
1405 req!(Dat::from([0u64; 8]).kind(), Kind::Tup8u64);
1406 Ok(())
1407 }));
1408
1409 res!(test_it(filter, &["From 367", "all", "from", "tuple"], || {
1410 req!(Dat::from([0u64; 9]).kind(), Kind::Tup9u64);
1411 Ok(())
1412 }));
1413
1414 res!(test_it(filter, &["From 368", "all", "from", "tuple"], || {
1415 req!(Dat::from([0u64; 10]).kind(), Kind::Tup10u64);
1416 Ok(())
1417 }));
1418
1419
1420 res!(test_it(filter, &["From 420", "all", "from", "best", "tuple"], || {
1421 req!(Dat::best_from([0u8; 2]).kind(), Kind::B2);
1422 Ok(())
1423 }));
1424
1425 res!(test_it(filter, &["From 421", "all", "from", "best", "tuple"], || {
1426 req!(Dat::best_from([0u8; 3]).kind(), Kind::B3);
1427 Ok(())
1428 }));
1429
1430 res!(test_it(filter, &["From 422", "all", "from", "best", "tuple"], || {
1431 req!(Dat::best_from([0u8; 4]).kind(), Kind::B4);
1432 Ok(())
1433 }));
1434
1435 res!(test_it(filter, &["From 423", "all", "from", "best", "tuple"], || {
1436 req!(Dat::best_from([0u8; 5]).kind(), Kind::B5);
1437 Ok(())
1438 }));
1439
1440 res!(test_it(filter, &["From 424", "all", "from", "best", "tuple"], || {
1441 req!(Dat::best_from([0u8; 6]).kind(), Kind::B6);
1442 Ok(())
1443 }));
1444
1445 res!(test_it(filter, &["From 425", "all", "from", "best", "tuple"], || {
1446 req!(Dat::best_from([0u8; 7]).kind(), Kind::B7);
1447 Ok(())
1448 }));
1449
1450 res!(test_it(filter, &["From 426", "all", "from", "best", "tuple"], || {
1451 req!(Dat::best_from([0u8; 8]).kind(), Kind::B8);
1452 Ok(())
1453 }));
1454
1455 res!(test_it(filter, &["From 427", "all", "from", "best", "tuple"], || {
1456 req!(Dat::best_from([0u8; 9]).kind(), Kind::B9);
1457 Ok(())
1458 }));
1459
1460 res!(test_it(filter, &["From 428", "all", "from", "best", "tuple"], || {
1461 req!(Dat::best_from([0u8; 10]).kind(), Kind::B10);
1462 Ok(())
1463 }));
1464
1465 res!(test_it(filter, &["From 429", "all", "from", "best", "tuple"], || {
1466 req!(Dat::best_from([0u8; 16]).kind(), Kind::B16);
1467 Ok(())
1468 }));
1469
1470 res!(test_it(filter, &["From 430", "all", "from", "best", "tuple"], || {
1471 req!(Dat::best_from([0u8; 32]).kind(), Kind::B32);
1472 Ok(())
1473 }));
1474
1475
1476 res!(test_it(filter, &["From 440", "all", "from", "best", "tuple"], || {
1477 req!(Dat::best_from([0u16; 2]).kind(), Kind::Tup2u16);
1478 Ok(())
1479 }));
1480
1481 res!(test_it(filter, &["From 441", "all", "from", "best", "tuple"], || {
1482 req!(Dat::best_from([0u16; 3]).kind(), Kind::Tup3u16);
1483 Ok(())
1484 }));
1485
1486 res!(test_it(filter, &["From 442", "all", "from", "best", "tuple"], || {
1487 req!(Dat::best_from([0u16; 4]).kind(), Kind::Tup4u16);
1488 Ok(())
1489 }));
1490
1491 res!(test_it(filter, &["From 443", "all", "from", "best", "tuple"], || {
1492 req!(Dat::best_from([0u16; 5]).kind(), Kind::Tup5u16);
1493 Ok(())
1494 }));
1495
1496 res!(test_it(filter, &["From 444", "all", "from", "best", "tuple"], || {
1497 req!(Dat::best_from([0u16; 6]).kind(), Kind::Tup6u16);
1498 Ok(())
1499 }));
1500
1501 res!(test_it(filter, &["From 445", "all", "from", "best", "tuple"], || {
1502 req!(Dat::best_from([0u16; 7]).kind(), Kind::Tup7u16);
1503 Ok(())
1504 }));
1505
1506 res!(test_it(filter, &["From 446", "all", "from", "best", "tuple"], || {
1507 req!(Dat::best_from([0u16; 8]).kind(), Kind::Tup8u16);
1508 Ok(())
1509 }));
1510
1511 res!(test_it(filter, &["From 447", "all", "from", "best", "tuple"], || {
1512 req!(Dat::best_from([0u16; 9]).kind(), Kind::Tup9u16);
1513 Ok(())
1514 }));
1515
1516 res!(test_it(filter, &["From 448", "all", "from", "best", "tuple"], || {
1517 req!(Dat::best_from([0u16; 10]).kind(), Kind::Tup10u16);
1518 Ok(())
1519 }));
1520
1521
1522 res!(test_it(filter, &["From 450", "all", "from", "best", "tuple"], || {
1523 req!(Dat::best_from([0u32; 2]).kind(), Kind::Tup2u32);
1524 Ok(())
1525 }));
1526
1527 res!(test_it(filter, &["From 451", "all", "from", "best", "tuple"], || {
1528 req!(Dat::best_from([0u32; 3]).kind(), Kind::Tup3u32);
1529 Ok(())
1530 }));
1531
1532 res!(test_it(filter, &["From 452", "all", "from", "best", "tuple"], || {
1533 req!(Dat::best_from([0u32; 4]).kind(), Kind::Tup4u32);
1534 Ok(())
1535 }));
1536
1537 res!(test_it(filter, &["From 453", "all", "from", "best", "tuple"], || {
1538 req!(Dat::best_from([0u32; 5]).kind(), Kind::Tup5u32);
1539 Ok(())
1540 }));
1541
1542 res!(test_it(filter, &["From 454", "all", "from", "best", "tuple"], || {
1543 req!(Dat::best_from([0u32; 6]).kind(), Kind::Tup6u32);
1544 Ok(())
1545 }));
1546
1547 res!(test_it(filter, &["From 455", "all", "from", "best", "tuple"], || {
1548 req!(Dat::best_from([0u32; 7]).kind(), Kind::Tup7u32);
1549 Ok(())
1550 }));
1551
1552 res!(test_it(filter, &["From 456", "all", "from", "best", "tuple"], || {
1553 req!(Dat::best_from([0u32; 8]).kind(), Kind::Tup8u32);
1554 Ok(())
1555 }));
1556
1557 res!(test_it(filter, &["From 457", "all", "from", "best", "tuple"], || {
1558 req!(Dat::best_from([0u32; 9]).kind(), Kind::Tup9u32);
1559 Ok(())
1560 }));
1561
1562 res!(test_it(filter, &["From 458", "all", "from", "best", "tuple"], || {
1563 req!(Dat::best_from([0u32; 10]).kind(), Kind::Tup10u32);
1564 Ok(())
1565 }));
1566
1567
1568 res!(test_it(filter, &["From 460", "all", "from", "best", "tuple"], || {
1569 req!(Dat::best_from([0u64; 2]).kind(), Kind::Tup2u64);
1570 Ok(())
1571 }));
1572
1573 res!(test_it(filter, &["From 461", "all", "from", "best", "tuple"], || {
1574 req!(Dat::best_from([0u64; 3]).kind(), Kind::Tup3u64);
1575 Ok(())
1576 }));
1577
1578 res!(test_it(filter, &["From 462", "all", "from", "best", "tuple"], || {
1579 req!(Dat::best_from([0u64; 4]).kind(), Kind::Tup4u64);
1580 Ok(())
1581 }));
1582
1583 res!(test_it(filter, &["From 463", "all", "from", "best", "tuple"], || {
1584 req!(Dat::best_from([0u64; 5]).kind(), Kind::Tup5u64);
1585 Ok(())
1586 }));
1587
1588 res!(test_it(filter, &["From 464", "all", "from", "best", "tuple"], || {
1589 req!(Dat::best_from([0u64; 6]).kind(), Kind::Tup6u64);
1590 Ok(())
1591 }));
1592
1593 res!(test_it(filter, &["From 465", "all", "from", "best", "tuple"], || {
1594 req!(Dat::best_from([0u64; 7]).kind(), Kind::Tup7u64);
1595 Ok(())
1596 }));
1597
1598 res!(test_it(filter, &["From 466", "all", "from", "best", "tuple"], || {
1599 req!(Dat::best_from([0u64; 8]).kind(), Kind::Tup8u64);
1600 Ok(())
1601 }));
1602
1603 res!(test_it(filter, &["From 467", "all", "from", "best", "tuple"], || {
1604 req!(Dat::best_from([0u64; 9]).kind(), Kind::Tup9u64);
1605 Ok(())
1606 }));
1607
1608 res!(test_it(filter, &["From 468", "all", "from", "best", "tuple"], || {
1609 req!(Dat::best_from([0u64; 10]).kind(), Kind::Tup10u64);
1610 Ok(())
1611 }));
1612
1613 Ok(())
1614}