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