• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 use num_bigint::Sign::Plus;
2 use num_bigint::{BigInt, ToBigInt};
3 use num_bigint::{BigUint, ToBigUint};
4 use num_integer::Integer;
5 
6 use std::cmp::Ordering::{Equal, Greater, Less};
7 use std::collections::hash_map::RandomState;
8 use std::hash::{BuildHasher, Hash, Hasher};
9 use std::iter::repeat;
10 use std::str::FromStr;
11 use std::{f32, f64};
12 
13 use num_traits::{
14     pow, CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, Euclid, FromBytes, FromPrimitive, Num,
15     One, Pow, ToBytes, ToPrimitive, Zero,
16 };
17 
18 mod consts;
19 use crate::consts::*;
20 
21 #[macro_use]
22 mod macros;
23 
24 #[test]
test_from_bytes_be()25 fn test_from_bytes_be() {
26     fn check(s: &str, result: &str) {
27         let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
28         assert_eq!(BigUint::from_bytes_be(s.as_bytes()), b);
29         assert_eq!(<BigUint as FromBytes>::from_be_bytes(s.as_bytes()), b);
30     }
31     check("A", "65");
32     check("AA", "16705");
33     check("AB", "16706");
34     check("Hello world!", "22405534230753963835153736737");
35     assert_eq!(BigUint::from_bytes_be(&[]), BigUint::zero());
36 }
37 
38 #[test]
test_to_bytes_be()39 fn test_to_bytes_be() {
40     fn check(s: &str, result: &str) {
41         let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
42         assert_eq!(b.to_bytes_be(), s.as_bytes());
43         assert_eq!(<BigUint as ToBytes>::to_be_bytes(&b), s.as_bytes());
44     }
45     check("A", "65");
46     check("AA", "16705");
47     check("AB", "16706");
48     check("Hello world!", "22405534230753963835153736737");
49     let b: BigUint = Zero::zero();
50     assert_eq!(b.to_bytes_be(), [0]);
51 
52     // Test with leading/trailing zero bytes and a full BigDigit of value 0
53     let b = BigUint::from_str_radix("00010000000000000200", 16).unwrap();
54     assert_eq!(b.to_bytes_be(), [1, 0, 0, 0, 0, 0, 0, 2, 0]);
55 }
56 
57 #[test]
test_from_bytes_le()58 fn test_from_bytes_le() {
59     fn check(s: &str, result: &str) {
60         let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
61         assert_eq!(BigUint::from_bytes_le(s.as_bytes()), b);
62         assert_eq!(<BigUint as FromBytes>::from_le_bytes(s.as_bytes()), b);
63     }
64     check("A", "65");
65     check("AA", "16705");
66     check("BA", "16706");
67     check("!dlrow olleH", "22405534230753963835153736737");
68     assert_eq!(BigUint::from_bytes_le(&[]), BigUint::zero());
69 }
70 
71 #[test]
test_to_bytes_le()72 fn test_to_bytes_le() {
73     fn check(s: &str, result: &str) {
74         let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
75         assert_eq!(b.to_bytes_le(), s.as_bytes());
76         assert_eq!(<BigUint as ToBytes>::to_le_bytes(&b), s.as_bytes());
77     }
78     check("A", "65");
79     check("AA", "16705");
80     check("BA", "16706");
81     check("!dlrow olleH", "22405534230753963835153736737");
82     let b: BigUint = Zero::zero();
83     assert_eq!(b.to_bytes_le(), [0]);
84 
85     // Test with leading/trailing zero bytes and a full BigDigit of value 0
86     let b = BigUint::from_str_radix("00010000000000000200", 16).unwrap();
87     assert_eq!(b.to_bytes_le(), [0, 2, 0, 0, 0, 0, 0, 0, 1]);
88 }
89 
90 #[test]
test_cmp()91 fn test_cmp() {
92     let data: [&[_]; 7] = [&[], &[1], &[2], &[!0], &[0, 1], &[2, 1], &[1, 1, 1]];
93     let data: Vec<BigUint> = data.iter().map(|v| BigUint::from_slice(*v)).collect();
94     for (i, ni) in data.iter().enumerate() {
95         for (j0, nj) in data[i..].iter().enumerate() {
96             let j = j0 + i;
97             if i == j {
98                 assert_eq!(ni.cmp(nj), Equal);
99                 assert_eq!(nj.cmp(ni), Equal);
100                 assert_eq!(ni, nj);
101                 assert!(!(ni != nj));
102                 assert!(ni <= nj);
103                 assert!(ni >= nj);
104                 assert!(!(ni < nj));
105                 assert!(!(ni > nj));
106             } else {
107                 assert_eq!(ni.cmp(nj), Less);
108                 assert_eq!(nj.cmp(ni), Greater);
109 
110                 assert!(!(ni == nj));
111                 assert!(ni != nj);
112 
113                 assert!(ni <= nj);
114                 assert!(!(ni >= nj));
115                 assert!(ni < nj);
116                 assert!(!(ni > nj));
117 
118                 assert!(!(nj <= ni));
119                 assert!(nj >= ni);
120                 assert!(!(nj < ni));
121                 assert!(nj > ni);
122             }
123         }
124     }
125 }
126 
hash<T: Hash>(x: &T) -> u64127 fn hash<T: Hash>(x: &T) -> u64 {
128     let mut hasher = <RandomState as BuildHasher>::Hasher::new();
129     x.hash(&mut hasher);
130     hasher.finish()
131 }
132 
133 #[test]
test_hash()134 fn test_hash() {
135     use crate::hash;
136 
137     let a = BigUint::new(vec![]);
138     let b = BigUint::new(vec![0]);
139     let c = BigUint::new(vec![1]);
140     let d = BigUint::new(vec![1, 0, 0, 0, 0, 0]);
141     let e = BigUint::new(vec![0, 0, 0, 0, 0, 1]);
142     assert!(hash(&a) == hash(&b));
143     assert!(hash(&b) != hash(&c));
144     assert!(hash(&c) == hash(&d));
145     assert!(hash(&d) != hash(&e));
146 }
147 
148 // LEFT, RIGHT, AND, OR, XOR
149 const BIT_TESTS: &[(&[u32], &[u32], &[u32], &[u32], &[u32])] = &[
150     (&[], &[], &[], &[], &[]),
151     (&[1, 0, 1], &[1, 1], &[1], &[1, 1, 1], &[0, 1, 1]),
152     (&[1, 0, 1], &[0, 1, 1], &[0, 0, 1], &[1, 1, 1], &[1, 1]),
153     (
154         &[268, 482, 17],
155         &[964, 54],
156         &[260, 34],
157         &[972, 502, 17],
158         &[712, 468, 17],
159     ),
160 ];
161 
162 #[test]
test_bitand()163 fn test_bitand() {
164     for elm in BIT_TESTS {
165         let (a_vec, b_vec, c_vec, _, _) = *elm;
166         let a = BigUint::from_slice(a_vec);
167         let b = BigUint::from_slice(b_vec);
168         let c = BigUint::from_slice(c_vec);
169 
170         assert_op!(a & b == c);
171         assert_op!(b & a == c);
172         assert_assign_op!(a &= b == c);
173         assert_assign_op!(b &= a == c);
174     }
175 }
176 
177 #[test]
test_bitor()178 fn test_bitor() {
179     for elm in BIT_TESTS {
180         let (a_vec, b_vec, _, c_vec, _) = *elm;
181         let a = BigUint::from_slice(a_vec);
182         let b = BigUint::from_slice(b_vec);
183         let c = BigUint::from_slice(c_vec);
184 
185         assert_op!(a | b == c);
186         assert_op!(b | a == c);
187         assert_assign_op!(a |= b == c);
188         assert_assign_op!(b |= a == c);
189     }
190 }
191 
192 #[test]
test_bitxor()193 fn test_bitxor() {
194     for elm in BIT_TESTS {
195         let (a_vec, b_vec, _, _, c_vec) = *elm;
196         let a = BigUint::from_slice(a_vec);
197         let b = BigUint::from_slice(b_vec);
198         let c = BigUint::from_slice(c_vec);
199 
200         assert_op!(a ^ b == c);
201         assert_op!(b ^ a == c);
202         assert_op!(a ^ c == b);
203         assert_op!(c ^ a == b);
204         assert_op!(b ^ c == a);
205         assert_op!(c ^ b == a);
206         assert_assign_op!(a ^= b == c);
207         assert_assign_op!(b ^= a == c);
208         assert_assign_op!(a ^= c == b);
209         assert_assign_op!(c ^= a == b);
210         assert_assign_op!(b ^= c == a);
211         assert_assign_op!(c ^= b == a);
212     }
213 }
214 
215 #[test]
test_shl()216 fn test_shl() {
217     fn check(s: &str, shift: usize, ans: &str) {
218         let opt_biguint = BigUint::from_str_radix(s, 16).ok();
219         let mut bu_assign = opt_biguint.unwrap();
220         let bu = (bu_assign.clone() << shift).to_str_radix(16);
221         assert_eq!(bu, ans);
222         bu_assign <<= shift;
223         assert_eq!(bu_assign.to_str_radix(16), ans);
224     }
225 
226     check("0", 3, "0");
227     check("1", 3, "8");
228 
229     check(
230         "1\
231          0000\
232          0000\
233          0000\
234          0001\
235          0000\
236          0000\
237          0000\
238          0001",
239         3,
240         "8\
241          0000\
242          0000\
243          0000\
244          0008\
245          0000\
246          0000\
247          0000\
248          0008",
249     );
250     check(
251         "1\
252          0000\
253          0001\
254          0000\
255          0001",
256         2,
257         "4\
258          0000\
259          0004\
260          0000\
261          0004",
262     );
263     check(
264         "1\
265          0001\
266          0001",
267         1,
268         "2\
269          0002\
270          0002",
271     );
272 
273     check(
274         "\
275          4000\
276          0000\
277          0000\
278          0000",
279         3,
280         "2\
281          0000\
282          0000\
283          0000\
284          0000",
285     );
286     check(
287         "4000\
288          0000",
289         2,
290         "1\
291          0000\
292          0000",
293     );
294     check(
295         "4000",
296         2,
297         "1\
298          0000",
299     );
300 
301     check(
302         "4000\
303          0000\
304          0000\
305          0000",
306         67,
307         "2\
308          0000\
309          0000\
310          0000\
311          0000\
312          0000\
313          0000\
314          0000\
315          0000",
316     );
317     check(
318         "4000\
319          0000",
320         35,
321         "2\
322          0000\
323          0000\
324          0000\
325          0000",
326     );
327     check(
328         "4000",
329         19,
330         "2\
331          0000\
332          0000",
333     );
334 
335     check(
336         "fedc\
337          ba98\
338          7654\
339          3210\
340          fedc\
341          ba98\
342          7654\
343          3210",
344         4,
345         "f\
346          edcb\
347          a987\
348          6543\
349          210f\
350          edcb\
351          a987\
352          6543\
353          2100",
354     );
355     check(
356         "88887777666655554444333322221111",
357         16,
358         "888877776666555544443333222211110000",
359     );
360 }
361 
362 #[test]
test_shr()363 fn test_shr() {
364     fn check(s: &str, shift: usize, ans: &str) {
365         let opt_biguint = BigUint::from_str_radix(s, 16).ok();
366         let mut bu_assign = opt_biguint.unwrap();
367         let bu = (bu_assign.clone() >> shift).to_str_radix(16);
368         assert_eq!(bu, ans);
369         bu_assign >>= shift;
370         assert_eq!(bu_assign.to_str_radix(16), ans);
371     }
372 
373     check("0", 3, "0");
374     check("f", 3, "1");
375 
376     check(
377         "1\
378          0000\
379          0000\
380          0000\
381          0001\
382          0000\
383          0000\
384          0000\
385          0001",
386         3,
387         "2000\
388          0000\
389          0000\
390          0000\
391          2000\
392          0000\
393          0000\
394          0000",
395     );
396     check(
397         "1\
398          0000\
399          0001\
400          0000\
401          0001",
402         2,
403         "4000\
404          0000\
405          4000\
406          0000",
407     );
408     check(
409         "1\
410          0001\
411          0001",
412         1,
413         "8000\
414          8000",
415     );
416 
417     check(
418         "2\
419          0000\
420          0000\
421          0000\
422          0001\
423          0000\
424          0000\
425          0000\
426          0001",
427         67,
428         "4000\
429          0000\
430          0000\
431          0000",
432     );
433     check(
434         "2\
435          0000\
436          0001\
437          0000\
438          0001",
439         35,
440         "4000\
441          0000",
442     );
443     check(
444         "2\
445          0001\
446          0001",
447         19,
448         "4000",
449     );
450 
451     check(
452         "1\
453          0000\
454          0000\
455          0000\
456          0000",
457         1,
458         "8000\
459          0000\
460          0000\
461          0000",
462     );
463     check(
464         "1\
465          0000\
466          0000",
467         1,
468         "8000\
469          0000",
470     );
471     check(
472         "1\
473          0000",
474         1,
475         "8000",
476     );
477     check(
478         "f\
479          edcb\
480          a987\
481          6543\
482          210f\
483          edcb\
484          a987\
485          6543\
486          2100",
487         4,
488         "fedc\
489          ba98\
490          7654\
491          3210\
492          fedc\
493          ba98\
494          7654\
495          3210",
496     );
497 
498     check(
499         "888877776666555544443333222211110000",
500         16,
501         "88887777666655554444333322221111",
502     );
503 }
504 
505 // `DoubleBigDigit` size dependent
506 #[test]
test_convert_i64()507 fn test_convert_i64() {
508     fn check(b1: BigUint, i: i64) {
509         let b2: BigUint = FromPrimitive::from_i64(i).unwrap();
510         assert_eq!(b1, b2);
511         assert_eq!(b1.to_i64().unwrap(), i);
512     }
513 
514     check(Zero::zero(), 0);
515     check(One::one(), 1);
516     check(i64::MAX.to_biguint().unwrap(), i64::MAX);
517 
518     check(BigUint::new(vec![]), 0);
519     check(BigUint::new(vec![1]), 1);
520     check(BigUint::new(vec![N1]), (1 << 32) - 1);
521     check(BigUint::new(vec![0, 1]), 1 << 32);
522     check(BigUint::new(vec![N1, N1 >> 1]), i64::MAX);
523 
524     assert_eq!(i64::MIN.to_biguint(), None);
525     assert_eq!(BigUint::new(vec![N1, N1]).to_i64(), None);
526     assert_eq!(BigUint::new(vec![0, 0, 1]).to_i64(), None);
527     assert_eq!(BigUint::new(vec![N1, N1, N1]).to_i64(), None);
528 }
529 
530 #[test]
test_convert_i128()531 fn test_convert_i128() {
532     fn check(b1: BigUint, i: i128) {
533         let b2: BigUint = FromPrimitive::from_i128(i).unwrap();
534         assert_eq!(b1, b2);
535         assert_eq!(b1.to_i128().unwrap(), i);
536     }
537 
538     check(Zero::zero(), 0);
539     check(One::one(), 1);
540     check(i128::MAX.to_biguint().unwrap(), i128::MAX);
541 
542     check(BigUint::new(vec![]), 0);
543     check(BigUint::new(vec![1]), 1);
544     check(BigUint::new(vec![N1]), (1 << 32) - 1);
545     check(BigUint::new(vec![0, 1]), 1 << 32);
546     check(BigUint::new(vec![N1, N1, N1, N1 >> 1]), i128::MAX);
547 
548     assert_eq!(i128::MIN.to_biguint(), None);
549     assert_eq!(BigUint::new(vec![N1, N1, N1, N1]).to_i128(), None);
550     assert_eq!(BigUint::new(vec![0, 0, 0, 0, 1]).to_i128(), None);
551     assert_eq!(BigUint::new(vec![N1, N1, N1, N1, N1]).to_i128(), None);
552 }
553 
554 // `DoubleBigDigit` size dependent
555 #[test]
test_convert_u64()556 fn test_convert_u64() {
557     fn check(b1: BigUint, u: u64) {
558         let b2: BigUint = FromPrimitive::from_u64(u).unwrap();
559         assert_eq!(b1, b2);
560         assert_eq!(b1.to_u64().unwrap(), u);
561     }
562 
563     check(Zero::zero(), 0);
564     check(One::one(), 1);
565     check(u64::MIN.to_biguint().unwrap(), u64::MIN);
566     check(u64::MAX.to_biguint().unwrap(), u64::MAX);
567 
568     check(BigUint::new(vec![]), 0);
569     check(BigUint::new(vec![1]), 1);
570     check(BigUint::new(vec![N1]), (1 << 32) - 1);
571     check(BigUint::new(vec![0, 1]), 1 << 32);
572     check(BigUint::new(vec![N1, N1]), u64::MAX);
573 
574     assert_eq!(BigUint::new(vec![0, 0, 1]).to_u64(), None);
575     assert_eq!(BigUint::new(vec![N1, N1, N1]).to_u64(), None);
576 }
577 
578 #[test]
test_convert_u128()579 fn test_convert_u128() {
580     fn check(b1: BigUint, u: u128) {
581         let b2: BigUint = FromPrimitive::from_u128(u).unwrap();
582         assert_eq!(b1, b2);
583         assert_eq!(b1.to_u128().unwrap(), u);
584     }
585 
586     check(Zero::zero(), 0);
587     check(One::one(), 1);
588     check(u128::MIN.to_biguint().unwrap(), u128::MIN);
589     check(u128::MAX.to_biguint().unwrap(), u128::MAX);
590 
591     check(BigUint::new(vec![]), 0);
592     check(BigUint::new(vec![1]), 1);
593     check(BigUint::new(vec![N1]), (1 << 32) - 1);
594     check(BigUint::new(vec![0, 1]), 1 << 32);
595     check(BigUint::new(vec![N1, N1, N1, N1]), u128::MAX);
596 
597     assert_eq!(BigUint::new(vec![0, 0, 0, 0, 1]).to_u128(), None);
598     assert_eq!(BigUint::new(vec![N1, N1, N1, N1, N1]).to_u128(), None);
599 }
600 
601 #[test]
602 #[allow(clippy::float_cmp)]
test_convert_f32()603 fn test_convert_f32() {
604     fn check(b1: &BigUint, f: f32) {
605         let b2 = BigUint::from_f32(f).unwrap();
606         assert_eq!(b1, &b2);
607         assert_eq!(b1.to_f32().unwrap(), f);
608     }
609 
610     check(&BigUint::zero(), 0.0);
611     check(&BigUint::one(), 1.0);
612     check(&BigUint::from(u16::MAX), pow(2.0_f32, 16) - 1.0);
613     check(&BigUint::from(1u64 << 32), pow(2.0_f32, 32));
614     check(&BigUint::from_slice(&[0, 0, 1]), pow(2.0_f32, 64));
615     check(
616         &((BigUint::one() << 100) + (BigUint::one() << 123)),
617         pow(2.0_f32, 100) + pow(2.0_f32, 123),
618     );
619     check(&(BigUint::one() << 127), pow(2.0_f32, 127));
620     check(&(BigUint::from((1u64 << 24) - 1) << (128 - 24)), f32::MAX);
621 
622     // keeping all 24 digits with the bits at different offsets to the BigDigits
623     let x: u32 = 0b00000000101111011111011011011101;
624     let mut f = x as f32;
625     let mut b = BigUint::from(x);
626     for _ in 0..64 {
627         check(&b, f);
628         f *= 2.0;
629         b <<= 1;
630     }
631 
632     // this number when rounded to f64 then f32 isn't the same as when rounded straight to f32
633     let n: u64 = 0b0000000000111111111111111111111111011111111111111111111111111111;
634     assert!((n as f64) as f32 != n as f32);
635     assert_eq!(BigUint::from(n).to_f32(), Some(n as f32));
636 
637     // test rounding up with the bits at different offsets to the BigDigits
638     let mut f = ((1u64 << 25) - 1) as f32;
639     let mut b = BigUint::from(1u64 << 25);
640     for _ in 0..64 {
641         assert_eq!(b.to_f32(), Some(f));
642         f *= 2.0;
643         b <<= 1;
644     }
645 
646     // test correct ties-to-even rounding
647     let weird: i128 = (1i128 << 100) + (1i128 << (100 - f32::MANTISSA_DIGITS));
648     assert_ne!(weird as f32, (weird + 1) as f32);
649 
650     assert_eq!(BigInt::from(weird).to_f32(), Some(weird as f32));
651     assert_eq!(BigInt::from(weird + 1).to_f32(), Some((weird + 1) as f32));
652 
653     // rounding
654     assert_eq!(BigUint::from_f32(-1.0), None);
655     assert_eq!(BigUint::from_f32(-0.99999), Some(BigUint::zero()));
656     assert_eq!(BigUint::from_f32(-0.5), Some(BigUint::zero()));
657     assert_eq!(BigUint::from_f32(-0.0), Some(BigUint::zero()));
658     assert_eq!(
659         BigUint::from_f32(f32::MIN_POSITIVE / 2.0),
660         Some(BigUint::zero())
661     );
662     assert_eq!(BigUint::from_f32(f32::MIN_POSITIVE), Some(BigUint::zero()));
663     assert_eq!(BigUint::from_f32(0.5), Some(BigUint::zero()));
664     assert_eq!(BigUint::from_f32(0.99999), Some(BigUint::zero()));
665     assert_eq!(BigUint::from_f32(f32::consts::E), Some(BigUint::from(2u32)));
666     assert_eq!(
667         BigUint::from_f32(f32::consts::PI),
668         Some(BigUint::from(3u32))
669     );
670 
671     // special float values
672     assert_eq!(BigUint::from_f32(f32::NAN), None);
673     assert_eq!(BigUint::from_f32(f32::INFINITY), None);
674     assert_eq!(BigUint::from_f32(f32::NEG_INFINITY), None);
675     assert_eq!(BigUint::from_f32(f32::MIN), None);
676 
677     // largest BigUint that will round to a finite f32 value
678     let big_num = (BigUint::one() << 128u8) - 1u8 - (BigUint::one() << (128u8 - 25));
679     assert_eq!(big_num.to_f32(), Some(f32::MAX));
680     assert_eq!((big_num + 1u8).to_f32(), Some(f32::INFINITY));
681 
682     assert_eq!(
683         ((BigUint::one() << 128u8) - 1u8).to_f32(),
684         Some(f32::INFINITY)
685     );
686     assert_eq!((BigUint::one() << 128u8).to_f32(), Some(f32::INFINITY));
687 }
688 
689 #[test]
690 #[allow(clippy::float_cmp)]
test_convert_f64()691 fn test_convert_f64() {
692     fn check(b1: &BigUint, f: f64) {
693         let b2 = BigUint::from_f64(f).unwrap();
694         assert_eq!(b1, &b2);
695         assert_eq!(b1.to_f64().unwrap(), f);
696     }
697 
698     check(&BigUint::zero(), 0.0);
699     check(&BigUint::one(), 1.0);
700     check(&BigUint::from(u32::MAX), pow(2.0_f64, 32) - 1.0);
701     check(&BigUint::from(1u64 << 32), pow(2.0_f64, 32));
702     check(&BigUint::from_slice(&[0, 0, 1]), pow(2.0_f64, 64));
703     check(
704         &((BigUint::one() << 100) + (BigUint::one() << 152)),
705         pow(2.0_f64, 100) + pow(2.0_f64, 152),
706     );
707     check(&(BigUint::one() << 1023), pow(2.0_f64, 1023));
708     check(&(BigUint::from((1u64 << 53) - 1) << (1024 - 53)), f64::MAX);
709 
710     // keeping all 53 digits with the bits at different offsets to the BigDigits
711     let x: u64 = 0b0000000000011110111110110111111101110111101111011111011011011101;
712     let mut f = x as f64;
713     let mut b = BigUint::from(x);
714     for _ in 0..128 {
715         check(&b, f);
716         f *= 2.0;
717         b <<= 1;
718     }
719 
720     // test rounding up with the bits at different offsets to the BigDigits
721     let mut f = ((1u64 << 54) - 1) as f64;
722     let mut b = BigUint::from(1u64 << 54);
723     for _ in 0..128 {
724         assert_eq!(b.to_f64(), Some(f));
725         f *= 2.0;
726         b <<= 1;
727     }
728 
729     // test correct ties-to-even rounding
730     let weird: i128 = (1i128 << 100) + (1i128 << (100 - f64::MANTISSA_DIGITS));
731     assert_ne!(weird as f64, (weird + 1) as f64);
732 
733     assert_eq!(BigInt::from(weird).to_f64(), Some(weird as f64));
734     assert_eq!(BigInt::from(weird + 1).to_f64(), Some((weird + 1) as f64));
735 
736     // rounding
737     assert_eq!(BigUint::from_f64(-1.0), None);
738     assert_eq!(BigUint::from_f64(-0.99999), Some(BigUint::zero()));
739     assert_eq!(BigUint::from_f64(-0.5), Some(BigUint::zero()));
740     assert_eq!(BigUint::from_f64(-0.0), Some(BigUint::zero()));
741     assert_eq!(
742         BigUint::from_f64(f64::MIN_POSITIVE / 2.0),
743         Some(BigUint::zero())
744     );
745     assert_eq!(BigUint::from_f64(f64::MIN_POSITIVE), Some(BigUint::zero()));
746     assert_eq!(BigUint::from_f64(0.5), Some(BigUint::zero()));
747     assert_eq!(BigUint::from_f64(0.99999), Some(BigUint::zero()));
748     assert_eq!(BigUint::from_f64(f64::consts::E), Some(BigUint::from(2u32)));
749     assert_eq!(
750         BigUint::from_f64(f64::consts::PI),
751         Some(BigUint::from(3u32))
752     );
753 
754     // special float values
755     assert_eq!(BigUint::from_f64(f64::NAN), None);
756     assert_eq!(BigUint::from_f64(f64::INFINITY), None);
757     assert_eq!(BigUint::from_f64(f64::NEG_INFINITY), None);
758     assert_eq!(BigUint::from_f64(f64::MIN), None);
759 
760     // largest BigUint that will round to a finite f64 value
761     let big_num = (BigUint::one() << 1024u16) - 1u8 - (BigUint::one() << (1024u16 - 54));
762     assert_eq!(big_num.to_f64(), Some(f64::MAX));
763     assert_eq!((big_num + 1u8).to_f64(), Some(f64::INFINITY));
764 
765     assert_eq!(
766         ((BigUint::one() << 1024u16) - 1u8).to_f64(),
767         Some(f64::INFINITY)
768     );
769     assert_eq!((BigUint::one() << 1024u16).to_f64(), Some(f64::INFINITY));
770 }
771 
772 #[test]
test_convert_to_bigint()773 fn test_convert_to_bigint() {
774     fn check(n: BigUint, ans: BigInt) {
775         assert_eq!(n.to_bigint().unwrap(), ans);
776         assert_eq!(n.to_bigint().unwrap().to_biguint().unwrap(), n);
777     }
778     check(Zero::zero(), Zero::zero());
779     check(
780         BigUint::new(vec![1, 2, 3]),
781         BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3])),
782     );
783 }
784 
785 #[test]
test_convert_from_uint()786 fn test_convert_from_uint() {
787     macro_rules! check {
788         ($ty:ident, $max:expr) => {
789             assert_eq!(BigUint::from($ty::zero()), BigUint::zero());
790             assert_eq!(BigUint::from($ty::one()), BigUint::one());
791             assert_eq!(BigUint::from($ty::MAX - $ty::one()), $max - BigUint::one());
792             assert_eq!(BigUint::from($ty::MAX), $max);
793         };
794     }
795 
796     check!(u8, BigUint::from_slice(&[u8::MAX as u32]));
797     check!(u16, BigUint::from_slice(&[u16::MAX as u32]));
798     check!(u32, BigUint::from_slice(&[u32::MAX]));
799     check!(u64, BigUint::from_slice(&[u32::MAX, u32::MAX]));
800     check!(
801         u128,
802         BigUint::from_slice(&[u32::MAX, u32::MAX, u32::MAX, u32::MAX])
803     );
804     check!(usize, BigUint::from(usize::MAX as u64));
805 }
806 
807 #[test]
test_add()808 fn test_add() {
809     for elm in SUM_TRIPLES.iter() {
810         let (a_vec, b_vec, c_vec) = *elm;
811         let a = BigUint::from_slice(a_vec);
812         let b = BigUint::from_slice(b_vec);
813         let c = BigUint::from_slice(c_vec);
814 
815         assert_op!(a + b == c);
816         assert_op!(b + a == c);
817         assert_assign_op!(a += b == c);
818         assert_assign_op!(b += a == c);
819     }
820 }
821 
822 #[test]
test_sub()823 fn test_sub() {
824     for elm in SUM_TRIPLES.iter() {
825         let (a_vec, b_vec, c_vec) = *elm;
826         let a = BigUint::from_slice(a_vec);
827         let b = BigUint::from_slice(b_vec);
828         let c = BigUint::from_slice(c_vec);
829 
830         assert_op!(c - a == b);
831         assert_op!(c - b == a);
832         assert_assign_op!(c -= a == b);
833         assert_assign_op!(c -= b == a);
834     }
835 }
836 
837 #[test]
838 #[should_panic]
test_sub_fail_on_underflow()839 fn test_sub_fail_on_underflow() {
840     let (a, b): (BigUint, BigUint) = (Zero::zero(), One::one());
841     let _ = a - b;
842 }
843 
844 #[test]
test_mul()845 fn test_mul() {
846     for elm in MUL_TRIPLES.iter() {
847         let (a_vec, b_vec, c_vec) = *elm;
848         let a = BigUint::from_slice(a_vec);
849         let b = BigUint::from_slice(b_vec);
850         let c = BigUint::from_slice(c_vec);
851 
852         assert_op!(a * b == c);
853         assert_op!(b * a == c);
854         assert_assign_op!(a *= b == c);
855         assert_assign_op!(b *= a == c);
856     }
857 
858     for elm in DIV_REM_QUADRUPLES.iter() {
859         let (a_vec, b_vec, c_vec, d_vec) = *elm;
860         let a = BigUint::from_slice(a_vec);
861         let b = BigUint::from_slice(b_vec);
862         let c = BigUint::from_slice(c_vec);
863         let d = BigUint::from_slice(d_vec);
864 
865         assert!(a == &b * &c + &d);
866         assert!(a == &c * &b + &d);
867     }
868 }
869 
870 #[test]
test_div_rem()871 fn test_div_rem() {
872     for elm in MUL_TRIPLES.iter() {
873         let (a_vec, b_vec, c_vec) = *elm;
874         let a = BigUint::from_slice(a_vec);
875         let b = BigUint::from_slice(b_vec);
876         let c = BigUint::from_slice(c_vec);
877 
878         if !a.is_zero() {
879             assert_op!(c / a == b);
880             assert_op!(c % a == BigUint::zero());
881             assert_assign_op!(c /= a == b);
882             assert_assign_op!(c %= a == BigUint::zero());
883             assert_eq!(c.div_rem(&a), (b.clone(), BigUint::zero()));
884         }
885         if !b.is_zero() {
886             assert_op!(c / b == a);
887             assert_op!(c % b == BigUint::zero());
888             assert_assign_op!(c /= b == a);
889             assert_assign_op!(c %= b == BigUint::zero());
890             assert_eq!(c.div_rem(&b), (a.clone(), BigUint::zero()));
891         }
892     }
893 
894     for elm in DIV_REM_QUADRUPLES.iter() {
895         let (a_vec, b_vec, c_vec, d_vec) = *elm;
896         let a = BigUint::from_slice(a_vec);
897         let b = BigUint::from_slice(b_vec);
898         let c = BigUint::from_slice(c_vec);
899         let d = BigUint::from_slice(d_vec);
900 
901         if !b.is_zero() {
902             assert_op!(a / b == c);
903             assert_op!(a % b == d);
904             assert_assign_op!(a /= b == c);
905             assert_assign_op!(a %= b == d);
906             assert!(a.div_rem(&b) == (c, d));
907         }
908     }
909 }
910 
911 #[test]
test_div_rem_big_multiple()912 fn test_div_rem_big_multiple() {
913     let a = BigUint::from(3u32).pow(100u32);
914     let a2 = &a * &a;
915 
916     let (div, rem) = a2.div_rem(&a);
917     assert_eq!(div, a);
918     assert!(rem.is_zero());
919 
920     let (div, rem) = (&a2 - 1u32).div_rem(&a);
921     assert_eq!(div, &a - 1u32);
922     assert_eq!(rem, &a - 1u32);
923 }
924 
925 #[test]
test_div_ceil()926 fn test_div_ceil() {
927     fn check(a: &BigUint, b: &BigUint, d: &BigUint, m: &BigUint) {
928         if m.is_zero() {
929             assert_eq!(a.div_ceil(b), *d);
930         } else {
931             assert_eq!(a.div_ceil(b), d + 1u32);
932         }
933     }
934 
935     for elm in MUL_TRIPLES.iter() {
936         let (a_vec, b_vec, c_vec) = *elm;
937         let a = BigUint::from_slice(a_vec);
938         let b = BigUint::from_slice(b_vec);
939         let c = BigUint::from_slice(c_vec);
940 
941         if !a.is_zero() {
942             check(&c, &a, &b, &Zero::zero());
943         }
944         if !b.is_zero() {
945             check(&c, &b, &a, &Zero::zero());
946         }
947     }
948 
949     for elm in DIV_REM_QUADRUPLES.iter() {
950         let (a_vec, b_vec, c_vec, d_vec) = *elm;
951         let a = BigUint::from_slice(a_vec);
952         let b = BigUint::from_slice(b_vec);
953         let c = BigUint::from_slice(c_vec);
954         let d = BigUint::from_slice(d_vec);
955 
956         if !b.is_zero() {
957             check(&a, &b, &c, &d);
958         }
959     }
960 }
961 
962 #[test]
test_div_rem_euclid()963 fn test_div_rem_euclid() {
964     fn check(a: &BigUint, b: &BigUint, d: &BigUint, m: &BigUint) {
965         assert_eq!(a.div_euclid(b), *d);
966         assert_eq!(a.rem_euclid(b), *m);
967     }
968 
969     for elm in MUL_TRIPLES.iter() {
970         let (a_vec, b_vec, c_vec) = *elm;
971         let a = BigUint::from_slice(a_vec);
972         let b = BigUint::from_slice(b_vec);
973         let c = BigUint::from_slice(c_vec);
974 
975         if !a.is_zero() {
976             check(&c, &a, &b, &Zero::zero());
977         }
978         if !b.is_zero() {
979             check(&c, &b, &a, &Zero::zero());
980         }
981     }
982 
983     for elm in DIV_REM_QUADRUPLES.iter() {
984         let (a_vec, b_vec, c_vec, d_vec) = *elm;
985         let a = BigUint::from_slice(a_vec);
986         let b = BigUint::from_slice(b_vec);
987         let c = BigUint::from_slice(c_vec);
988         let d = BigUint::from_slice(d_vec);
989 
990         if !b.is_zero() {
991             check(&a, &b, &c, &d);
992         }
993     }
994 }
995 
996 #[test]
test_checked_add()997 fn test_checked_add() {
998     for elm in SUM_TRIPLES.iter() {
999         let (a_vec, b_vec, c_vec) = *elm;
1000         let a = BigUint::from_slice(a_vec);
1001         let b = BigUint::from_slice(b_vec);
1002         let c = BigUint::from_slice(c_vec);
1003 
1004         assert!(a.checked_add(&b).unwrap() == c);
1005         assert!(b.checked_add(&a).unwrap() == c);
1006     }
1007 }
1008 
1009 #[test]
test_checked_sub()1010 fn test_checked_sub() {
1011     for elm in SUM_TRIPLES.iter() {
1012         let (a_vec, b_vec, c_vec) = *elm;
1013         let a = BigUint::from_slice(a_vec);
1014         let b = BigUint::from_slice(b_vec);
1015         let c = BigUint::from_slice(c_vec);
1016 
1017         assert!(c.checked_sub(&a).unwrap() == b);
1018         assert!(c.checked_sub(&b).unwrap() == a);
1019 
1020         if a > c {
1021             assert!(a.checked_sub(&c).is_none());
1022         }
1023         if b > c {
1024             assert!(b.checked_sub(&c).is_none());
1025         }
1026     }
1027 }
1028 
1029 #[test]
test_checked_mul()1030 fn test_checked_mul() {
1031     for elm in MUL_TRIPLES.iter() {
1032         let (a_vec, b_vec, c_vec) = *elm;
1033         let a = BigUint::from_slice(a_vec);
1034         let b = BigUint::from_slice(b_vec);
1035         let c = BigUint::from_slice(c_vec);
1036 
1037         assert!(a.checked_mul(&b).unwrap() == c);
1038         assert!(b.checked_mul(&a).unwrap() == c);
1039     }
1040 
1041     for elm in DIV_REM_QUADRUPLES.iter() {
1042         let (a_vec, b_vec, c_vec, d_vec) = *elm;
1043         let a = BigUint::from_slice(a_vec);
1044         let b = BigUint::from_slice(b_vec);
1045         let c = BigUint::from_slice(c_vec);
1046         let d = BigUint::from_slice(d_vec);
1047 
1048         assert!(a == b.checked_mul(&c).unwrap() + &d);
1049         assert!(a == c.checked_mul(&b).unwrap() + &d);
1050     }
1051 }
1052 
1053 #[test]
test_mul_overflow()1054 fn test_mul_overflow() {
1055     // Test for issue #187 - overflow due to mac3 incorrectly sizing temporary
1056     let s = "5311379928167670986895882065524686273295931177270319231994441382\
1057              0040355986085224273916250223263671004753755210595137000079652876\
1058              0829212940754539968588340162273730474622005920097370111";
1059     let a: BigUint = s.parse().unwrap();
1060     let b = a.clone();
1061     let _ = a.checked_mul(&b);
1062 }
1063 
1064 #[test]
test_mul_overflow_2()1065 fn test_mul_overflow_2() {
1066     // Try a bunch of sizes that are right on the edge of multiplication length
1067     // overflow, where (x * x).data.len() == 2 * x.data.len() + 1.
1068     for i in 1u8..20 {
1069         let bits = 1u32 << i;
1070         let x = (BigUint::one() << bits) - 1u32;
1071         let x2 = (BigUint::one() << (2 * bits)) - &x - &x - 1u32;
1072         assert_eq!(&x * &x, x2);
1073     }
1074 }
1075 
1076 #[test]
test_checked_div()1077 fn test_checked_div() {
1078     for elm in MUL_TRIPLES.iter() {
1079         let (a_vec, b_vec, c_vec) = *elm;
1080         let a = BigUint::from_slice(a_vec);
1081         let b = BigUint::from_slice(b_vec);
1082         let c = BigUint::from_slice(c_vec);
1083 
1084         if !a.is_zero() {
1085             assert!(c.checked_div(&a).unwrap() == b);
1086         }
1087         if !b.is_zero() {
1088             assert!(c.checked_div(&b).unwrap() == a);
1089         }
1090 
1091         assert!(c.checked_div(&Zero::zero()).is_none());
1092     }
1093 }
1094 
1095 #[test]
test_gcd()1096 fn test_gcd() {
1097     fn check(a: usize, b: usize, c: usize) {
1098         let big_a: BigUint = FromPrimitive::from_usize(a).unwrap();
1099         let big_b: BigUint = FromPrimitive::from_usize(b).unwrap();
1100         let big_c: BigUint = FromPrimitive::from_usize(c).unwrap();
1101 
1102         assert_eq!(big_a.gcd(&big_b), big_c);
1103         assert_eq!(big_a.gcd_lcm(&big_b).0, big_c);
1104     }
1105 
1106     check(10, 2, 2);
1107     check(10, 3, 1);
1108     check(0, 3, 3);
1109     check(3, 3, 3);
1110     check(56, 42, 14);
1111 }
1112 
1113 #[test]
test_lcm()1114 fn test_lcm() {
1115     fn check(a: usize, b: usize, c: usize) {
1116         let big_a: BigUint = FromPrimitive::from_usize(a).unwrap();
1117         let big_b: BigUint = FromPrimitive::from_usize(b).unwrap();
1118         let big_c: BigUint = FromPrimitive::from_usize(c).unwrap();
1119 
1120         assert_eq!(big_a.lcm(&big_b), big_c);
1121         assert_eq!(big_a.gcd_lcm(&big_b).1, big_c);
1122     }
1123 
1124     check(0, 0, 0);
1125     check(1, 0, 0);
1126     check(0, 1, 0);
1127     check(1, 1, 1);
1128     check(8, 9, 72);
1129     check(11, 5, 55);
1130     check(99, 17, 1683);
1131 }
1132 
1133 #[test]
test_is_multiple_of()1134 fn test_is_multiple_of() {
1135     assert!(BigUint::from(0u32).is_multiple_of(&BigUint::from(0u32)));
1136     assert!(BigUint::from(6u32).is_multiple_of(&BigUint::from(6u32)));
1137     assert!(BigUint::from(6u32).is_multiple_of(&BigUint::from(3u32)));
1138     assert!(BigUint::from(6u32).is_multiple_of(&BigUint::from(1u32)));
1139 
1140     assert!(!BigUint::from(42u32).is_multiple_of(&BigUint::from(5u32)));
1141     assert!(!BigUint::from(5u32).is_multiple_of(&BigUint::from(3u32)));
1142     assert!(!BigUint::from(42u32).is_multiple_of(&BigUint::from(0u32)));
1143 }
1144 
1145 #[test]
test_next_multiple_of()1146 fn test_next_multiple_of() {
1147     assert_eq!(
1148         BigUint::from(16u32).next_multiple_of(&BigUint::from(8u32)),
1149         BigUint::from(16u32)
1150     );
1151     assert_eq!(
1152         BigUint::from(23u32).next_multiple_of(&BigUint::from(8u32)),
1153         BigUint::from(24u32)
1154     );
1155 }
1156 
1157 #[test]
test_prev_multiple_of()1158 fn test_prev_multiple_of() {
1159     assert_eq!(
1160         BigUint::from(16u32).prev_multiple_of(&BigUint::from(8u32)),
1161         BigUint::from(16u32)
1162     );
1163     assert_eq!(
1164         BigUint::from(23u32).prev_multiple_of(&BigUint::from(8u32)),
1165         BigUint::from(16u32)
1166     );
1167 }
1168 
1169 #[test]
test_is_even()1170 fn test_is_even() {
1171     let one: BigUint = FromStr::from_str("1").unwrap();
1172     let two: BigUint = FromStr::from_str("2").unwrap();
1173     let thousand: BigUint = FromStr::from_str("1000").unwrap();
1174     let big: BigUint = FromStr::from_str("1000000000000000000000").unwrap();
1175     let bigger: BigUint = FromStr::from_str("1000000000000000000001").unwrap();
1176     assert!(one.is_odd());
1177     assert!(two.is_even());
1178     assert!(thousand.is_even());
1179     assert!(big.is_even());
1180     assert!(bigger.is_odd());
1181     assert!((&one << 64u8).is_even());
1182     assert!(((&one << 64u8) + one).is_odd());
1183 }
1184 
to_str_pairs() -> Vec<(BigUint, Vec<(u32, String)>)>1185 fn to_str_pairs() -> Vec<(BigUint, Vec<(u32, String)>)> {
1186     let bits = 32;
1187     vec![
1188         (
1189             Zero::zero(),
1190             vec![(2, "0".to_string()), (3, "0".to_string())],
1191         ),
1192         (
1193             BigUint::from_slice(&[0xff]),
1194             vec![
1195                 (2, "11111111".to_string()),
1196                 (3, "100110".to_string()),
1197                 (4, "3333".to_string()),
1198                 (5, "2010".to_string()),
1199                 (6, "1103".to_string()),
1200                 (7, "513".to_string()),
1201                 (8, "377".to_string()),
1202                 (9, "313".to_string()),
1203                 (10, "255".to_string()),
1204                 (11, "212".to_string()),
1205                 (12, "193".to_string()),
1206                 (13, "168".to_string()),
1207                 (14, "143".to_string()),
1208                 (15, "120".to_string()),
1209                 (16, "ff".to_string()),
1210             ],
1211         ),
1212         (
1213             BigUint::from_slice(&[0xfff]),
1214             vec![
1215                 (2, "111111111111".to_string()),
1216                 (4, "333333".to_string()),
1217                 (16, "fff".to_string()),
1218             ],
1219         ),
1220         (
1221             BigUint::from_slice(&[1, 2]),
1222             vec![
1223                 (
1224                     2,
1225                     format!("10{}1", repeat("0").take(bits - 1).collect::<String>()),
1226                 ),
1227                 (
1228                     4,
1229                     format!("2{}1", repeat("0").take(bits / 2 - 1).collect::<String>()),
1230                 ),
1231                 (
1232                     10,
1233                     match bits {
1234                         64 => "36893488147419103233".to_string(),
1235                         32 => "8589934593".to_string(),
1236                         16 => "131073".to_string(),
1237                         _ => panic!(),
1238                     },
1239                 ),
1240                 (
1241                     16,
1242                     format!("2{}1", repeat("0").take(bits / 4 - 1).collect::<String>()),
1243                 ),
1244             ],
1245         ),
1246         (
1247             BigUint::from_slice(&[1, 2, 3]),
1248             vec![
1249                 (
1250                     2,
1251                     format!(
1252                         "11{}10{}1",
1253                         repeat("0").take(bits - 2).collect::<String>(),
1254                         repeat("0").take(bits - 1).collect::<String>()
1255                     ),
1256                 ),
1257                 (
1258                     4,
1259                     format!(
1260                         "3{}2{}1",
1261                         repeat("0").take(bits / 2 - 1).collect::<String>(),
1262                         repeat("0").take(bits / 2 - 1).collect::<String>()
1263                     ),
1264                 ),
1265                 (
1266                     8,
1267                     match bits {
1268                         64 => "14000000000000000000004000000000000000000001".to_string(),
1269                         32 => "6000000000100000000001".to_string(),
1270                         16 => "140000400001".to_string(),
1271                         _ => panic!(),
1272                     },
1273                 ),
1274                 (
1275                     10,
1276                     match bits {
1277                         64 => "1020847100762815390427017310442723737601".to_string(),
1278                         32 => "55340232229718589441".to_string(),
1279                         16 => "12885032961".to_string(),
1280                         _ => panic!(),
1281                     },
1282                 ),
1283                 (
1284                     16,
1285                     format!(
1286                         "3{}2{}1",
1287                         repeat("0").take(bits / 4 - 1).collect::<String>(),
1288                         repeat("0").take(bits / 4 - 1).collect::<String>()
1289                     ),
1290                 ),
1291             ],
1292         ),
1293     ]
1294 }
1295 
1296 #[test]
test_to_str_radix()1297 fn test_to_str_radix() {
1298     let r = to_str_pairs();
1299     for num_pair in r.iter() {
1300         let &(ref n, ref rs) = num_pair;
1301         for str_pair in rs.iter() {
1302             let &(ref radix, ref str) = str_pair;
1303             assert_eq!(n.to_str_radix(*radix), *str);
1304         }
1305     }
1306 }
1307 
1308 #[test]
test_from_and_to_radix()1309 fn test_from_and_to_radix() {
1310     const GROUND_TRUTH: &[(&[u8], u32, &[u8])] = &[
1311         (b"0", 42, &[0]),
1312         (
1313             b"ffffeeffbb",
1314             2,
1315             &[
1316                 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
1317                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1318             ],
1319         ),
1320         (
1321             b"ffffeeffbb",
1322             3,
1323             &[
1324                 2, 2, 1, 1, 2, 1, 1, 2, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 1, 0, 0, 2, 2, 0, 1,
1325             ],
1326         ),
1327         (
1328             b"ffffeeffbb",
1329             4,
1330             &[3, 2, 3, 2, 3, 3, 3, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3],
1331         ),
1332         (
1333             b"ffffeeffbb",
1334             5,
1335             &[0, 4, 3, 3, 1, 4, 2, 4, 1, 4, 4, 2, 3, 0, 0, 1, 2, 1],
1336         ),
1337         (
1338             b"ffffeeffbb",
1339             6,
1340             &[5, 5, 4, 5, 5, 0, 0, 1, 2, 5, 3, 0, 1, 0, 2, 2],
1341         ),
1342         (
1343             b"ffffeeffbb",
1344             7,
1345             &[4, 2, 3, 6, 0, 1, 6, 1, 6, 2, 0, 3, 2, 4, 1],
1346         ),
1347         (
1348             b"ffffeeffbb",
1349             8,
1350             &[3, 7, 6, 7, 7, 5, 3, 7, 7, 7, 7, 7, 7, 1],
1351         ),
1352         (b"ffffeeffbb", 9, &[8, 4, 5, 7, 0, 0, 3, 2, 0, 3, 0, 8, 3]),
1353         (b"ffffeeffbb", 10, &[5, 9, 5, 3, 1, 5, 0, 1, 5, 9, 9, 0, 1]),
1354         (b"ffffeeffbb", 11, &[10, 7, 6, 5, 2, 0, 3, 3, 3, 4, 9, 3]),
1355         (b"ffffeeffbb", 12, &[11, 8, 5, 10, 1, 10, 3, 1, 1, 9, 5, 1]),
1356         (b"ffffeeffbb", 13, &[0, 5, 7, 4, 6, 5, 6, 11, 8, 12, 7]),
1357         (b"ffffeeffbb", 14, &[11, 4, 4, 11, 8, 4, 6, 0, 3, 11, 3]),
1358         (b"ffffeeffbb", 15, &[5, 11, 13, 2, 1, 10, 2, 0, 9, 13, 1]),
1359         (b"ffffeeffbb", 16, &[11, 11, 15, 15, 14, 14, 15, 15, 15, 15]),
1360         (b"ffffeeffbb", 17, &[0, 2, 14, 12, 2, 14, 8, 10, 4, 9]),
1361         (b"ffffeeffbb", 18, &[17, 15, 5, 13, 10, 16, 16, 13, 9, 5]),
1362         (b"ffffeeffbb", 19, &[14, 13, 2, 8, 9, 0, 1, 14, 7, 3]),
1363         (b"ffffeeffbb", 20, &[15, 19, 3, 14, 0, 17, 19, 18, 2, 2]),
1364         (b"ffffeeffbb", 21, &[11, 5, 4, 13, 5, 18, 9, 1, 8, 1]),
1365         (b"ffffeeffbb", 22, &[21, 3, 7, 21, 15, 12, 17, 0, 20]),
1366         (b"ffffeeffbb", 23, &[21, 21, 6, 9, 10, 7, 21, 0, 14]),
1367         (b"ffffeeffbb", 24, &[11, 10, 19, 14, 22, 11, 17, 23, 9]),
1368         (b"ffffeeffbb", 25, &[20, 18, 21, 22, 21, 14, 3, 5, 7]),
1369         (b"ffffeeffbb", 26, &[13, 15, 24, 11, 17, 6, 23, 6, 5]),
1370         (b"ffffeeffbb", 27, &[17, 16, 7, 0, 21, 0, 3, 24, 3]),
1371         (b"ffffeeffbb", 28, &[11, 16, 11, 15, 14, 18, 13, 25, 2]),
1372         (b"ffffeeffbb", 29, &[6, 8, 7, 19, 14, 13, 21, 5, 2]),
1373         (b"ffffeeffbb", 30, &[5, 13, 18, 11, 10, 7, 8, 20, 1]),
1374         (b"ffffeeffbb", 31, &[22, 26, 15, 19, 8, 27, 29, 8, 1]),
1375         (b"ffffeeffbb", 32, &[27, 29, 31, 29, 30, 31, 31, 31]),
1376         (b"ffffeeffbb", 33, &[32, 20, 27, 12, 1, 12, 26, 25]),
1377         (b"ffffeeffbb", 34, &[17, 9, 16, 33, 13, 25, 31, 20]),
1378         (b"ffffeeffbb", 35, &[25, 32, 2, 25, 11, 4, 3, 17]),
1379         (b"ffffeeffbb", 36, &[35, 34, 5, 6, 32, 3, 1, 14]),
1380         (b"ffffeeffbb", 37, &[16, 21, 18, 4, 33, 19, 21, 11]),
1381         (b"ffffeeffbb", 38, &[33, 25, 19, 29, 20, 6, 23, 9]),
1382         (b"ffffeeffbb", 39, &[26, 27, 29, 23, 16, 18, 0, 8]),
1383         (b"ffffeeffbb", 40, &[35, 39, 30, 11, 16, 17, 28, 6]),
1384         (b"ffffeeffbb", 41, &[36, 30, 9, 18, 12, 19, 26, 5]),
1385         (b"ffffeeffbb", 42, &[11, 34, 37, 27, 1, 13, 32, 4]),
1386         (b"ffffeeffbb", 43, &[3, 24, 11, 2, 10, 40, 1, 4]),
1387         (b"ffffeeffbb", 44, &[43, 12, 40, 32, 3, 23, 19, 3]),
1388         (b"ffffeeffbb", 45, &[35, 38, 44, 18, 22, 18, 42, 2]),
1389         (b"ffffeeffbb", 46, &[21, 45, 18, 41, 17, 2, 24, 2]),
1390         (b"ffffeeffbb", 47, &[37, 37, 11, 12, 6, 0, 8, 2]),
1391         (b"ffffeeffbb", 48, &[11, 41, 40, 43, 5, 43, 41, 1]),
1392         (b"ffffeeffbb", 49, &[18, 45, 7, 13, 20, 21, 30, 1]),
1393         (b"ffffeeffbb", 50, &[45, 21, 5, 34, 21, 18, 20, 1]),
1394         (b"ffffeeffbb", 51, &[17, 6, 26, 22, 38, 24, 11, 1]),
1395         (b"ffffeeffbb", 52, &[39, 33, 38, 30, 46, 31, 3, 1]),
1396         (b"ffffeeffbb", 53, &[31, 7, 44, 23, 9, 32, 49]),
1397         (b"ffffeeffbb", 54, &[17, 35, 8, 37, 31, 18, 44]),
1398         (b"ffffeeffbb", 55, &[10, 52, 9, 48, 36, 39, 39]),
1399         (b"ffffeeffbb", 56, &[11, 50, 51, 22, 25, 36, 35]),
1400         (b"ffffeeffbb", 57, &[14, 55, 12, 43, 20, 3, 32]),
1401         (b"ffffeeffbb", 58, &[35, 18, 45, 56, 9, 51, 28]),
1402         (b"ffffeeffbb", 59, &[51, 28, 20, 26, 55, 3, 26]),
1403         (b"ffffeeffbb", 60, &[35, 6, 27, 46, 58, 33, 23]),
1404         (b"ffffeeffbb", 61, &[58, 7, 6, 54, 49, 20, 21]),
1405         (b"ffffeeffbb", 62, &[53, 59, 3, 14, 10, 22, 19]),
1406         (b"ffffeeffbb", 63, &[53, 50, 23, 4, 56, 36, 17]),
1407         (b"ffffeeffbb", 64, &[59, 62, 47, 59, 63, 63, 15]),
1408         (b"ffffeeffbb", 65, &[0, 53, 39, 4, 40, 37, 14]),
1409         (b"ffffeeffbb", 66, &[65, 59, 39, 1, 64, 19, 13]),
1410         (b"ffffeeffbb", 67, &[35, 14, 19, 16, 25, 10, 12]),
1411         (b"ffffeeffbb", 68, &[51, 38, 63, 50, 15, 8, 11]),
1412         (b"ffffeeffbb", 69, &[44, 45, 18, 58, 68, 12, 10]),
1413         (b"ffffeeffbb", 70, &[25, 51, 0, 60, 13, 24, 9]),
1414         (b"ffffeeffbb", 71, &[54, 30, 9, 65, 28, 41, 8]),
1415         (b"ffffeeffbb", 72, &[35, 35, 55, 54, 17, 64, 7]),
1416         (b"ffffeeffbb", 73, &[34, 4, 48, 40, 27, 19, 7]),
1417         (b"ffffeeffbb", 74, &[53, 47, 4, 56, 36, 51, 6]),
1418         (b"ffffeeffbb", 75, &[20, 56, 10, 72, 24, 13, 6]),
1419         (b"ffffeeffbb", 76, &[71, 31, 52, 60, 48, 53, 5]),
1420         (b"ffffeeffbb", 77, &[32, 73, 14, 63, 15, 21, 5]),
1421         (b"ffffeeffbb", 78, &[65, 13, 17, 32, 64, 68, 4]),
1422         (b"ffffeeffbb", 79, &[37, 56, 2, 56, 25, 41, 4]),
1423         (b"ffffeeffbb", 80, &[75, 59, 37, 41, 43, 15, 4]),
1424         (b"ffffeeffbb", 81, &[44, 68, 0, 21, 27, 72, 3]),
1425         (b"ffffeeffbb", 82, &[77, 35, 2, 74, 46, 50, 3]),
1426         (b"ffffeeffbb", 83, &[52, 51, 19, 76, 10, 30, 3]),
1427         (b"ffffeeffbb", 84, &[11, 80, 19, 19, 76, 10, 3]),
1428         (b"ffffeeffbb", 85, &[0, 82, 20, 14, 68, 77, 2]),
1429         (b"ffffeeffbb", 86, &[3, 12, 78, 37, 62, 61, 2]),
1430         (b"ffffeeffbb", 87, &[35, 12, 20, 8, 52, 46, 2]),
1431         (b"ffffeeffbb", 88, &[43, 6, 54, 42, 30, 32, 2]),
1432         (b"ffffeeffbb", 89, &[49, 52, 85, 21, 80, 18, 2]),
1433         (b"ffffeeffbb", 90, &[35, 64, 78, 24, 18, 6, 2]),
1434         (b"ffffeeffbb", 91, &[39, 17, 83, 63, 17, 85, 1]),
1435         (b"ffffeeffbb", 92, &[67, 22, 85, 79, 75, 74, 1]),
1436         (b"ffffeeffbb", 93, &[53, 60, 39, 29, 4, 65, 1]),
1437         (b"ffffeeffbb", 94, &[37, 89, 2, 72, 76, 55, 1]),
1438         (b"ffffeeffbb", 95, &[90, 74, 89, 9, 9, 47, 1]),
1439         (b"ffffeeffbb", 96, &[59, 20, 46, 35, 81, 38, 1]),
1440         (b"ffffeeffbb", 97, &[94, 87, 60, 71, 3, 31, 1]),
1441         (b"ffffeeffbb", 98, &[67, 22, 63, 50, 62, 23, 1]),
1442         (b"ffffeeffbb", 99, &[98, 6, 69, 12, 61, 16, 1]),
1443         (b"ffffeeffbb", 100, &[95, 35, 51, 10, 95, 9, 1]),
1444         (b"ffffeeffbb", 101, &[87, 27, 7, 8, 62, 3, 1]),
1445         (b"ffffeeffbb", 102, &[17, 3, 32, 79, 59, 99]),
1446         (b"ffffeeffbb", 103, &[30, 22, 90, 0, 87, 94]),
1447         (b"ffffeeffbb", 104, &[91, 68, 87, 68, 38, 90]),
1448         (b"ffffeeffbb", 105, &[95, 80, 54, 73, 15, 86]),
1449         (b"ffffeeffbb", 106, &[31, 30, 24, 16, 17, 82]),
1450         (b"ffffeeffbb", 107, &[51, 50, 10, 12, 42, 78]),
1451         (b"ffffeeffbb", 108, &[71, 71, 96, 78, 89, 74]),
1452         (b"ffffeeffbb", 109, &[33, 18, 93, 22, 50, 71]),
1453         (b"ffffeeffbb", 110, &[65, 53, 57, 88, 29, 68]),
1454         (b"ffffeeffbb", 111, &[53, 93, 67, 90, 27, 65]),
1455         (b"ffffeeffbb", 112, &[11, 109, 96, 65, 43, 62]),
1456         (b"ffffeeffbb", 113, &[27, 23, 106, 56, 76, 59]),
1457         (b"ffffeeffbb", 114, &[71, 84, 31, 112, 11, 57]),
1458         (b"ffffeeffbb", 115, &[90, 22, 1, 56, 76, 54]),
1459         (b"ffffeeffbb", 116, &[35, 38, 98, 57, 40, 52]),
1460         (b"ffffeeffbb", 117, &[26, 113, 115, 62, 17, 50]),
1461         (b"ffffeeffbb", 118, &[51, 14, 5, 18, 7, 48]),
1462         (b"ffffeeffbb", 119, &[102, 31, 110, 108, 8, 46]),
1463         (b"ffffeeffbb", 120, &[35, 93, 96, 50, 22, 44]),
1464         (b"ffffeeffbb", 121, &[87, 61, 2, 36, 47, 42]),
1465         (b"ffffeeffbb", 122, &[119, 64, 1, 22, 83, 40]),
1466         (b"ffffeeffbb", 123, &[77, 119, 32, 90, 6, 39]),
1467         (b"ffffeeffbb", 124, &[115, 122, 31, 79, 62, 37]),
1468         (b"ffffeeffbb", 125, &[95, 108, 47, 74, 3, 36]),
1469         (b"ffffeeffbb", 126, &[53, 25, 116, 39, 78, 34]),
1470         (b"ffffeeffbb", 127, &[22, 23, 125, 67, 35, 33]),
1471         (b"ffffeeffbb", 128, &[59, 127, 59, 127, 127, 31]),
1472         (b"ffffeeffbb", 129, &[89, 36, 1, 59, 100, 30]),
1473         (b"ffffeeffbb", 130, &[65, 91, 123, 89, 79, 29]),
1474         (b"ffffeeffbb", 131, &[58, 72, 39, 63, 65, 28]),
1475         (b"ffffeeffbb", 132, &[131, 62, 92, 82, 57, 27]),
1476         (b"ffffeeffbb", 133, &[109, 31, 51, 123, 55, 26]),
1477         (b"ffffeeffbb", 134, &[35, 74, 21, 27, 60, 25]),
1478         (b"ffffeeffbb", 135, &[125, 132, 49, 37, 70, 24]),
1479         (b"ffffeeffbb", 136, &[51, 121, 117, 133, 85, 23]),
1480         (b"ffffeeffbb", 137, &[113, 60, 135, 22, 107, 22]),
1481         (b"ffffeeffbb", 138, &[113, 91, 73, 93, 133, 21]),
1482         (b"ffffeeffbb", 139, &[114, 75, 102, 51, 26, 21]),
1483         (b"ffffeeffbb", 140, &[95, 25, 35, 16, 62, 20]),
1484         (b"ffffeeffbb", 141, &[131, 137, 16, 110, 102, 19]),
1485         (b"ffffeeffbb", 142, &[125, 121, 108, 34, 6, 19]),
1486         (b"ffffeeffbb", 143, &[65, 78, 138, 55, 55, 18]),
1487         (b"ffffeeffbb", 144, &[107, 125, 121, 15, 109, 17]),
1488         (b"ffffeeffbb", 145, &[35, 13, 122, 42, 22, 17]),
1489         (b"ffffeeffbb", 146, &[107, 38, 103, 123, 83, 16]),
1490         (b"ffffeeffbb", 147, &[116, 96, 71, 98, 2, 16]),
1491         (b"ffffeeffbb", 148, &[127, 23, 75, 99, 71, 15]),
1492         (b"ffffeeffbb", 149, &[136, 110, 53, 114, 144, 14]),
1493         (b"ffffeeffbb", 150, &[95, 140, 133, 130, 71, 14]),
1494         (b"ffffeeffbb", 151, &[15, 50, 29, 137, 0, 14]),
1495         (b"ffffeeffbb", 152, &[147, 15, 89, 121, 83, 13]),
1496         (b"ffffeeffbb", 153, &[17, 87, 93, 72, 17, 13]),
1497         (b"ffffeeffbb", 154, &[109, 113, 3, 133, 106, 12]),
1498         (b"ffffeeffbb", 155, &[115, 141, 120, 139, 44, 12]),
1499         (b"ffffeeffbb", 156, &[143, 45, 4, 82, 140, 11]),
1500         (b"ffffeeffbb", 157, &[149, 92, 15, 106, 82, 11]),
1501         (b"ffffeeffbb", 158, &[37, 107, 79, 46, 26, 11]),
1502         (b"ffffeeffbb", 159, &[137, 37, 146, 51, 130, 10]),
1503         (b"ffffeeffbb", 160, &[155, 69, 29, 115, 77, 10]),
1504         (b"ffffeeffbb", 161, &[67, 98, 46, 68, 26, 10]),
1505         (b"ffffeeffbb", 162, &[125, 155, 60, 63, 138, 9]),
1506         (b"ffffeeffbb", 163, &[96, 43, 118, 93, 90, 9]),
1507         (b"ffffeeffbb", 164, &[159, 99, 123, 152, 43, 9]),
1508         (b"ffffeeffbb", 165, &[65, 17, 1, 69, 163, 8]),
1509         (b"ffffeeffbb", 166, &[135, 108, 25, 165, 119, 8]),
1510         (b"ffffeeffbb", 167, &[165, 116, 164, 103, 77, 8]),
1511         (b"ffffeeffbb", 168, &[11, 166, 67, 44, 36, 8]),
1512         (b"ffffeeffbb", 169, &[65, 59, 71, 149, 164, 7]),
1513         (b"ffffeeffbb", 170, &[85, 83, 26, 76, 126, 7]),
1514         (b"ffffeeffbb", 171, &[71, 132, 140, 157, 88, 7]),
1515         (b"ffffeeffbb", 172, &[3, 6, 127, 47, 52, 7]),
1516         (b"ffffeeffbb", 173, &[122, 66, 53, 83, 16, 7]),
1517         (b"ffffeeffbb", 174, &[35, 6, 5, 88, 155, 6]),
1518         (b"ffffeeffbb", 175, &[95, 20, 84, 56, 122, 6]),
1519         (b"ffffeeffbb", 176, &[43, 91, 57, 159, 89, 6]),
1520         (b"ffffeeffbb", 177, &[110, 127, 54, 40, 58, 6]),
1521         (b"ffffeeffbb", 178, &[49, 115, 43, 47, 27, 6]),
1522         (b"ffffeeffbb", 179, &[130, 91, 4, 178, 175, 5]),
1523         (b"ffffeeffbb", 180, &[35, 122, 109, 70, 147, 5]),
1524         (b"ffffeeffbb", 181, &[94, 94, 4, 79, 119, 5]),
1525         (b"ffffeeffbb", 182, &[39, 54, 66, 19, 92, 5]),
1526         (b"ffffeeffbb", 183, &[119, 2, 143, 69, 65, 5]),
1527         (b"ffffeeffbb", 184, &[67, 57, 90, 44, 39, 5]),
1528         (b"ffffeeffbb", 185, &[90, 63, 141, 123, 13, 5]),
1529         (b"ffffeeffbb", 186, &[53, 123, 172, 119, 174, 4]),
1530         (b"ffffeeffbb", 187, &[153, 21, 68, 28, 151, 4]),
1531         (b"ffffeeffbb", 188, &[131, 138, 94, 32, 128, 4]),
1532         (b"ffffeeffbb", 189, &[179, 121, 156, 130, 105, 4]),
1533         (b"ffffeeffbb", 190, &[185, 179, 164, 131, 83, 4]),
1534         (b"ffffeeffbb", 191, &[118, 123, 37, 31, 62, 4]),
1535         (b"ffffeeffbb", 192, &[59, 106, 83, 16, 41, 4]),
1536         (b"ffffeeffbb", 193, &[57, 37, 47, 86, 20, 4]),
1537         (b"ffffeeffbb", 194, &[191, 140, 63, 45, 0, 4]),
1538         (b"ffffeeffbb", 195, &[65, 169, 83, 84, 175, 3]),
1539         (b"ffffeeffbb", 196, &[67, 158, 64, 6, 157, 3]),
1540         (b"ffffeeffbb", 197, &[121, 26, 167, 3, 139, 3]),
1541         (b"ffffeeffbb", 198, &[197, 151, 165, 75, 121, 3]),
1542         (b"ffffeeffbb", 199, &[55, 175, 36, 22, 104, 3]),
1543         (b"ffffeeffbb", 200, &[195, 167, 162, 38, 87, 3]),
1544         (b"ffffeeffbb", 201, &[35, 27, 136, 124, 70, 3]),
1545         (b"ffffeeffbb", 202, &[87, 64, 153, 76, 54, 3]),
1546         (b"ffffeeffbb", 203, &[151, 191, 14, 94, 38, 3]),
1547         (b"ffffeeffbb", 204, &[119, 103, 135, 175, 22, 3]),
1548         (b"ffffeeffbb", 205, &[200, 79, 123, 115, 7, 3]),
1549         (b"ffffeeffbb", 206, &[133, 165, 202, 115, 198, 2]),
1550         (b"ffffeeffbb", 207, &[44, 153, 193, 175, 184, 2]),
1551         (b"ffffeeffbb", 208, &[91, 190, 125, 86, 171, 2]),
1552         (b"ffffeeffbb", 209, &[109, 151, 34, 53, 158, 2]),
1553         (b"ffffeeffbb", 210, &[95, 40, 171, 74, 145, 2]),
1554         (b"ffffeeffbb", 211, &[84, 195, 162, 150, 132, 2]),
1555         (b"ffffeeffbb", 212, &[31, 15, 59, 68, 120, 2]),
1556         (b"ffffeeffbb", 213, &[125, 57, 127, 36, 108, 2]),
1557         (b"ffffeeffbb", 214, &[51, 132, 2, 55, 96, 2]),
1558         (b"ffffeeffbb", 215, &[175, 133, 177, 122, 84, 2]),
1559         (b"ffffeeffbb", 216, &[179, 35, 78, 23, 73, 2]),
1560         (b"ffffeeffbb", 217, &[53, 101, 208, 186, 61, 2]),
1561         (b"ffffeeffbb", 218, &[33, 9, 214, 179, 50, 2]),
1562         (b"ffffeeffbb", 219, &[107, 147, 175, 217, 39, 2]),
1563         (b"ffffeeffbb", 220, &[175, 81, 179, 79, 29, 2]),
1564         (b"ffffeeffbb", 221, &[0, 76, 95, 204, 18, 2]),
1565         (b"ffffeeffbb", 222, &[53, 213, 16, 150, 8, 2]),
1566         (b"ffffeeffbb", 223, &[158, 161, 42, 136, 221, 1]),
1567         (b"ffffeeffbb", 224, &[123, 54, 52, 162, 212, 1]),
1568         (b"ffffeeffbb", 225, &[170, 43, 151, 2, 204, 1]),
1569         (b"ffffeeffbb", 226, &[27, 68, 224, 105, 195, 1]),
1570         (b"ffffeeffbb", 227, &[45, 69, 157, 20, 187, 1]),
1571         (b"ffffeeffbb", 228, &[71, 213, 64, 199, 178, 1]),
1572         (b"ffffeeffbb", 229, &[129, 203, 66, 186, 170, 1]),
1573         (b"ffffeeffbb", 230, &[205, 183, 57, 208, 162, 1]),
1574         (b"ffffeeffbb", 231, &[32, 50, 164, 33, 155, 1]),
1575         (b"ffffeeffbb", 232, &[35, 135, 53, 123, 147, 1]),
1576         (b"ffffeeffbb", 233, &[209, 47, 89, 13, 140, 1]),
1577         (b"ffffeeffbb", 234, &[143, 56, 175, 168, 132, 1]),
1578         (b"ffffeeffbb", 235, &[225, 157, 216, 121, 125, 1]),
1579         (b"ffffeeffbb", 236, &[51, 66, 119, 105, 118, 1]),
1580         (b"ffffeeffbb", 237, &[116, 150, 26, 119, 111, 1]),
1581         (b"ffffeeffbb", 238, &[221, 15, 87, 162, 104, 1]),
1582         (b"ffffeeffbb", 239, &[234, 155, 214, 234, 97, 1]),
1583         (b"ffffeeffbb", 240, &[155, 46, 84, 96, 91, 1]),
1584         (b"ffffeeffbb", 241, &[187, 48, 90, 225, 84, 1]),
1585         (b"ffffeeffbb", 242, &[87, 212, 151, 140, 78, 1]),
1586         (b"ffffeeffbb", 243, &[206, 22, 189, 81, 72, 1]),
1587         (b"ffffeeffbb", 244, &[119, 93, 122, 48, 66, 1]),
1588         (b"ffffeeffbb", 245, &[165, 224, 117, 40, 60, 1]),
1589         (b"ffffeeffbb", 246, &[77, 121, 100, 57, 54, 1]),
1590         (b"ffffeeffbb", 247, &[52, 128, 242, 98, 48, 1]),
1591         (b"ffffeeffbb", 248, &[115, 247, 224, 164, 42, 1]),
1592         (b"ffffeeffbb", 249, &[218, 127, 223, 5, 37, 1]),
1593         (b"ffffeeffbb", 250, &[95, 54, 168, 118, 31, 1]),
1594         (b"ffffeeffbb", 251, &[121, 204, 240, 3, 26, 1]),
1595         (b"ffffeeffbb", 252, &[179, 138, 123, 162, 20, 1]),
1596         (b"ffffeeffbb", 253, &[21, 50, 1, 91, 15, 1]),
1597         (b"ffffeeffbb", 254, &[149, 11, 63, 40, 10, 1]),
1598         (b"ffffeeffbb", 255, &[170, 225, 247, 9, 5, 1]),
1599         (b"ffffeeffbb", 256, &[187, 255, 238, 255, 255]),
1600     ];
1601 
1602     for &(bigint, radix, inbaseradix_le) in GROUND_TRUTH.iter() {
1603         let bigint = BigUint::parse_bytes(bigint, 16).unwrap();
1604         // to_radix_le
1605         assert_eq!(bigint.to_radix_le(radix), inbaseradix_le);
1606         // to_radix_be
1607         let mut inbase_be = bigint.to_radix_be(radix);
1608         inbase_be.reverse(); // now le
1609         assert_eq!(inbase_be, inbaseradix_le);
1610         // from_radix_le
1611         assert_eq!(
1612             BigUint::from_radix_le(inbaseradix_le, radix).unwrap(),
1613             bigint
1614         );
1615         // from_radix_be
1616         let mut inbaseradix_be = Vec::from(inbaseradix_le);
1617         inbaseradix_be.reverse();
1618         assert_eq!(
1619             BigUint::from_radix_be(&inbaseradix_be, radix).unwrap(),
1620             bigint
1621         );
1622     }
1623 
1624     assert!(BigUint::from_radix_le(&[10, 100, 10], 50).is_none());
1625     assert_eq!(BigUint::from_radix_le(&[], 2), Some(BigUint::zero()));
1626     assert_eq!(BigUint::from_radix_be(&[], 2), Some(BigUint::zero()));
1627 }
1628 
1629 #[test]
test_from_str_radix()1630 fn test_from_str_radix() {
1631     let r = to_str_pairs();
1632     for num_pair in r.iter() {
1633         let &(ref n, ref rs) = num_pair;
1634         for str_pair in rs.iter() {
1635             let &(ref radix, ref str) = str_pair;
1636             assert_eq!(n, &BigUint::from_str_radix(str, *radix).unwrap());
1637         }
1638     }
1639 
1640     let zed = BigUint::from_str_radix("Z", 10).ok();
1641     assert_eq!(zed, None);
1642     let blank = BigUint::from_str_radix("_", 2).ok();
1643     assert_eq!(blank, None);
1644     let blank_one = BigUint::from_str_radix("_1", 2).ok();
1645     assert_eq!(blank_one, None);
1646     let plus_one = BigUint::from_str_radix("+1", 10).ok();
1647     assert_eq!(plus_one, Some(BigUint::from_slice(&[1])));
1648     let plus_plus_one = BigUint::from_str_radix("++1", 10).ok();
1649     assert_eq!(plus_plus_one, None);
1650     let minus_one = BigUint::from_str_radix("-1", 10).ok();
1651     assert_eq!(minus_one, None);
1652     let zero_plus_two = BigUint::from_str_radix("0+2", 10).ok();
1653     assert_eq!(zero_plus_two, None);
1654     let three = BigUint::from_str_radix("1_1", 2).ok();
1655     assert_eq!(three, Some(BigUint::from_slice(&[3])));
1656     let ff = BigUint::from_str_radix("1111_1111", 2).ok();
1657     assert_eq!(ff, Some(BigUint::from_slice(&[0xff])));
1658 }
1659 
1660 #[test]
test_all_str_radix()1661 fn test_all_str_radix() {
1662     let n = BigUint::new((0..10).collect());
1663     for radix in 2..37 {
1664         let s = n.to_str_radix(radix);
1665         let x = BigUint::from_str_radix(&s, radix);
1666         assert_eq!(x.unwrap(), n);
1667 
1668         let s = s.to_ascii_uppercase();
1669         let x = BigUint::from_str_radix(&s, radix);
1670         assert_eq!(x.unwrap(), n);
1671     }
1672 }
1673 
1674 #[test]
test_big_str()1675 fn test_big_str() {
1676     for n in 2..=20_u32 {
1677         let x: BigUint = BigUint::from(n).pow(10_000_u32);
1678         let s = x.to_string();
1679         let y: BigUint = s.parse().unwrap();
1680         assert_eq!(x, y);
1681     }
1682 }
1683 
1684 #[test]
test_lower_hex()1685 fn test_lower_hex() {
1686     let a = BigUint::parse_bytes(b"A", 16).unwrap();
1687     let hello = BigUint::parse_bytes(b"22405534230753963835153736737", 10).unwrap();
1688 
1689     assert_eq!(format!("{:x}", a), "a");
1690     assert_eq!(format!("{:x}", hello), "48656c6c6f20776f726c6421");
1691     assert_eq!(format!("{:♥>+#8x}", a), "♥♥♥♥+0xa");
1692 }
1693 
1694 #[test]
test_upper_hex()1695 fn test_upper_hex() {
1696     let a = BigUint::parse_bytes(b"A", 16).unwrap();
1697     let hello = BigUint::parse_bytes(b"22405534230753963835153736737", 10).unwrap();
1698 
1699     assert_eq!(format!("{:X}", a), "A");
1700     assert_eq!(format!("{:X}", hello), "48656C6C6F20776F726C6421");
1701     assert_eq!(format!("{:♥>+#8X}", a), "♥♥♥♥+0xA");
1702 }
1703 
1704 #[test]
test_binary()1705 fn test_binary() {
1706     let a = BigUint::parse_bytes(b"A", 16).unwrap();
1707     let hello = BigUint::parse_bytes(b"224055342307539", 10).unwrap();
1708 
1709     assert_eq!(format!("{:b}", a), "1010");
1710     assert_eq!(
1711         format!("{:b}", hello),
1712         "110010111100011011110011000101101001100011010011"
1713     );
1714     assert_eq!(format!("{:♥>+#8b}", a), "♥+0b1010");
1715 }
1716 
1717 #[test]
test_octal()1718 fn test_octal() {
1719     let a = BigUint::parse_bytes(b"A", 16).unwrap();
1720     let hello = BigUint::parse_bytes(b"22405534230753963835153736737", 10).unwrap();
1721 
1722     assert_eq!(format!("{:o}", a), "12");
1723     assert_eq!(format!("{:o}", hello), "22062554330674403566756233062041");
1724     assert_eq!(format!("{:♥>+#8o}", a), "♥♥♥+0o12");
1725 }
1726 
1727 #[test]
test_display()1728 fn test_display() {
1729     let a = BigUint::parse_bytes(b"A", 16).unwrap();
1730     let hello = BigUint::parse_bytes(b"22405534230753963835153736737", 10).unwrap();
1731 
1732     assert_eq!(format!("{}", a), "10");
1733     assert_eq!(format!("{}", hello), "22405534230753963835153736737");
1734     assert_eq!(format!("{:♥>+#8}", a), "♥♥♥♥♥+10");
1735 }
1736 
1737 #[test]
test_factor()1738 fn test_factor() {
1739     fn factor(n: usize) -> BigUint {
1740         let mut f: BigUint = One::one();
1741         for i in 2..=n {
1742             // FIXME(#5992): assignment operator overloads
1743             // f *= FromPrimitive::from_usize(i);
1744             let bu: BigUint = FromPrimitive::from_usize(i).unwrap();
1745             f *= bu;
1746         }
1747         f
1748     }
1749 
1750     fn check(n: usize, s: &str) {
1751         let n = factor(n);
1752         let ans = BigUint::from_str_radix(s, 10).unwrap();
1753         assert_eq!(n, ans);
1754     }
1755 
1756     check(3, "6");
1757     check(10, "3628800");
1758     check(20, "2432902008176640000");
1759     check(30, "265252859812191058636308480000000");
1760 }
1761 
1762 #[test]
test_bits()1763 fn test_bits() {
1764     assert_eq!(BigUint::new(vec![0, 0, 0, 0]).bits(), 0);
1765     let n: BigUint = FromPrimitive::from_usize(0).unwrap();
1766     assert_eq!(n.bits(), 0);
1767     let n: BigUint = FromPrimitive::from_usize(1).unwrap();
1768     assert_eq!(n.bits(), 1);
1769     let n: BigUint = FromPrimitive::from_usize(3).unwrap();
1770     assert_eq!(n.bits(), 2);
1771     let n: BigUint = BigUint::from_str_radix("4000000000", 16).unwrap();
1772     assert_eq!(n.bits(), 39);
1773     let one: BigUint = One::one();
1774     assert_eq!((one << 426u16).bits(), 427);
1775 }
1776 
1777 #[test]
test_iter_sum()1778 fn test_iter_sum() {
1779     let result: BigUint = FromPrimitive::from_isize(1234567).unwrap();
1780     let data: Vec<BigUint> = vec![
1781         FromPrimitive::from_u32(1000000).unwrap(),
1782         FromPrimitive::from_u32(200000).unwrap(),
1783         FromPrimitive::from_u32(30000).unwrap(),
1784         FromPrimitive::from_u32(4000).unwrap(),
1785         FromPrimitive::from_u32(500).unwrap(),
1786         FromPrimitive::from_u32(60).unwrap(),
1787         FromPrimitive::from_u32(7).unwrap(),
1788     ];
1789 
1790     assert_eq!(result, data.iter().sum::<BigUint>());
1791     assert_eq!(result, data.into_iter().sum::<BigUint>());
1792 }
1793 
1794 #[test]
test_iter_product()1795 fn test_iter_product() {
1796     let data: Vec<BigUint> = vec![
1797         FromPrimitive::from_u32(1001).unwrap(),
1798         FromPrimitive::from_u32(1002).unwrap(),
1799         FromPrimitive::from_u32(1003).unwrap(),
1800         FromPrimitive::from_u32(1004).unwrap(),
1801         FromPrimitive::from_u32(1005).unwrap(),
1802     ];
1803     let result = data.get(0).unwrap()
1804         * data.get(1).unwrap()
1805         * data.get(2).unwrap()
1806         * data.get(3).unwrap()
1807         * data.get(4).unwrap();
1808 
1809     assert_eq!(result, data.iter().product::<BigUint>());
1810     assert_eq!(result, data.into_iter().product::<BigUint>());
1811 }
1812 
1813 #[test]
test_iter_sum_generic()1814 fn test_iter_sum_generic() {
1815     let result: BigUint = FromPrimitive::from_isize(1234567).unwrap();
1816     let data = vec![1000000_u32, 200000, 30000, 4000, 500, 60, 7];
1817 
1818     assert_eq!(result, data.iter().sum::<BigUint>());
1819     assert_eq!(result, data.into_iter().sum::<BigUint>());
1820 }
1821 
1822 #[test]
test_iter_product_generic()1823 fn test_iter_product_generic() {
1824     let data = vec![1001_u32, 1002, 1003, 1004, 1005];
1825     let result = data[0].to_biguint().unwrap()
1826         * data[1].to_biguint().unwrap()
1827         * data[2].to_biguint().unwrap()
1828         * data[3].to_biguint().unwrap()
1829         * data[4].to_biguint().unwrap();
1830 
1831     assert_eq!(result, data.iter().product::<BigUint>());
1832     assert_eq!(result, data.into_iter().product::<BigUint>());
1833 }
1834 
1835 #[test]
test_pow()1836 fn test_pow() {
1837     let one = BigUint::from(1u32);
1838     let two = BigUint::from(2u32);
1839     let four = BigUint::from(4u32);
1840     let eight = BigUint::from(8u32);
1841     let tentwentyfour = BigUint::from(1024u32);
1842     let twentyfourtyeight = BigUint::from(2048u32);
1843     macro_rules! check {
1844         ($t:ty) => {
1845             assert_eq!(Pow::pow(&two, 0 as $t), one);
1846             assert_eq!(Pow::pow(&two, 1 as $t), two);
1847             assert_eq!(Pow::pow(&two, 2 as $t), four);
1848             assert_eq!(Pow::pow(&two, 3 as $t), eight);
1849             assert_eq!(Pow::pow(&two, 10 as $t), tentwentyfour);
1850             assert_eq!(Pow::pow(&two, 11 as $t), twentyfourtyeight);
1851             assert_eq!(Pow::pow(&two, &(11 as $t)), twentyfourtyeight);
1852         };
1853     }
1854     check!(u8);
1855     check!(u16);
1856     check!(u32);
1857     check!(u64);
1858     check!(u128);
1859     check!(usize);
1860 
1861     let pow_1e10000 = BigUint::from(10u32).pow(10_000_u32);
1862     let manual_1e10000 = repeat(10u32).take(10_000).product::<BigUint>();
1863     assert!(manual_1e10000 == pow_1e10000);
1864 }
1865 
1866 #[test]
test_trailing_zeros()1867 fn test_trailing_zeros() {
1868     assert!(BigUint::from(0u8).trailing_zeros().is_none());
1869     assert_eq!(BigUint::from(1u8).trailing_zeros().unwrap(), 0);
1870     assert_eq!(BigUint::from(2u8).trailing_zeros().unwrap(), 1);
1871     let x: BigUint = BigUint::one() << 128;
1872     assert_eq!(x.trailing_zeros().unwrap(), 128);
1873 }
1874 
1875 #[test]
test_trailing_ones()1876 fn test_trailing_ones() {
1877     assert_eq!(BigUint::from(0u8).trailing_ones(), 0);
1878     assert_eq!(BigUint::from(1u8).trailing_ones(), 1);
1879     assert_eq!(BigUint::from(2u8).trailing_ones(), 0);
1880     assert_eq!(BigUint::from(3u8).trailing_ones(), 2);
1881     let x: BigUint = (BigUint::from(3u8) << 128) | BigUint::from(3u8);
1882     assert_eq!(x.trailing_ones(), 2);
1883     let x: BigUint = (BigUint::one() << 128) - BigUint::one();
1884     assert_eq!(x.trailing_ones(), 128);
1885 }
1886 
1887 #[test]
test_count_ones()1888 fn test_count_ones() {
1889     assert_eq!(BigUint::from(0u8).count_ones(), 0);
1890     assert_eq!(BigUint::from(1u8).count_ones(), 1);
1891     assert_eq!(BigUint::from(2u8).count_ones(), 1);
1892     assert_eq!(BigUint::from(3u8).count_ones(), 2);
1893     let x: BigUint = (BigUint::from(3u8) << 128) | BigUint::from(3u8);
1894     assert_eq!(x.count_ones(), 4);
1895 }
1896 
1897 #[test]
test_bit()1898 fn test_bit() {
1899     assert!(!BigUint::from(0u8).bit(0));
1900     assert!(!BigUint::from(0u8).bit(100));
1901     assert!(!BigUint::from(42u8).bit(4));
1902     assert!(BigUint::from(42u8).bit(5));
1903     let x: BigUint = (BigUint::from(3u8) << 128) | BigUint::from(3u8);
1904     assert!(x.bit(129));
1905     assert!(!x.bit(130));
1906 }
1907 
1908 #[test]
test_set_bit()1909 fn test_set_bit() {
1910     let mut x = BigUint::from(3u8);
1911     x.set_bit(128, true);
1912     x.set_bit(129, true);
1913     assert_eq!(x, (BigUint::from(3u8) << 128) | BigUint::from(3u8));
1914     x.set_bit(0, false);
1915     x.set_bit(128, false);
1916     x.set_bit(130, false);
1917     assert_eq!(x, (BigUint::from(2u8) << 128) | BigUint::from(2u8));
1918     x.set_bit(129, false);
1919     x.set_bit(1, false);
1920     assert_eq!(x, BigUint::zero());
1921 }
1922