use dashu_base::ParseError;
use dashu_int::{IBig, UBig, Word};
mod helper_macros;
#[test]
fn test_ubig_format() {
assert_eq!(format!("{}", UBig::from(u8::MAX)), "255");
assert_eq!(format!("{}", UBig::from(u16::MAX)), "65535");
assert_eq!(format!("{}", UBig::from(u32::MAX)), "4294967295");
assert_eq!(format!("{}", UBig::from(u64::MAX)), "18446744073709551615");
assert_eq!(format!("{}", UBig::from(u128::MAX)), "340282366920938463463374607431768211455");
assert_eq!(format!("{:b}", ubig!(0)), "0");
assert_eq!(format!("{:b}", ubig!(100)), "1100100");
assert_eq!(format!("{:#b}", ubig!(100)), "0b1100100");
assert_eq!(format!("{:+b}", ubig!(100)), "+1100100");
assert_eq!(format!("{:+#b}", ubig!(100)), "+0b1100100");
assert_eq!(format!("{:10b}", ubig!(100)), " 1100100");
assert_eq!(format!("{:=<10b}", ubig!(100)), "1100100===");
assert_eq!(format!("{:=>10b}", ubig!(100)), "===1100100");
assert_eq!(format!("{:=^10b}", ubig!(100)), "=1100100==");
assert_eq!(format!("{:=^+10b}", ubig!(100)), "=+1100100=");
assert_eq!(format!("{:+010b}", ubig!(100)), "+001100100");
assert_eq!(format!("{:+#010b}", ubig!(100)), "+0b1100100");
assert_eq!(format!("{:+#01b}", ubig!(100)), "+0b1100100");
assert_eq!(format!("{:o}", ubig!(100)), "144");
assert_eq!(format!("{:#o}", ubig!(100)), "0o144");
assert_eq!(format!("{:x}", ubig!(3000)), "bb8");
assert_eq!(format!("{:#x}", ubig!(3000)), "0xbb8");
assert_eq!(format!("{:X}", ubig!(3000)), "BB8");
assert_eq!(format!("{:#X}", ubig!(3000)), "0xBB8");
assert_eq!(format!("{:#10X}", ubig!(3000)), " 0xBB8");
assert_eq!(format!("{}", ubig!(123)), "123");
assert_eq!(format!("{:?}", ubig!(123)), "123");
assert_eq!(format!("{:=>5}", ubig!(123)), "==123");
let a = UBig::from_be_bytes(&[
0x05, 0xee, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89,
0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67,
0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
]);
assert_eq!(
format!("{:x}", a),
"5ee0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
);
assert_eq!(
format!("{:X}", a),
"5EE0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
);
assert_eq!(
format!("{:^100X}", a),
" 5EE0123456789ABCDEF\
0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF "
);
assert_eq!(
format!("{:o}", a),
"1367001106425474232571573600443212636115274675700221505317046\
53633674011064254742325715736004432126361152746757"
);
assert_eq!(
format!("{:>120o}", a),
" 1367001106425474232571573600443212636115274675700221505317046\
53633674011064254742325715736004432126361152746757"
);
assert_eq!(
format!("{:>120}", a),
" 32424378138036567091203300829444432818122896389983\
04588119616982843278155375835513236887964094287343"
);
}
#[test]
fn test_ubig_in_radix() {
assert_eq!(format!("{}", ubig!(0).in_radix(2)), "0");
assert_eq!(format!("{}", ubig!(100).in_radix(4)), "1210");
assert_eq!(format!("{}", ubig!(3000).in_radix(16)), "bb8");
assert_eq!(format!("{:+010}", ubig!(3000).in_radix(16)), "+000000bb8");
assert_eq!(format!("{:+#010}", ubig!(3000).in_radix(16)), "+000000BB8");
assert_eq!(format!("{}", ubig!(1294).in_radix(36)), "zy");
assert_eq!(format!("{:#010}", ubig!(1294).in_radix(36)), "00000000ZY");
assert_eq!(ubig!(0xffffffff).in_radix(3).to_string(), "102002022201221111210");
assert_eq!(
ubig!(0xffffffffffffffff).in_radix(3).to_string(),
"11112220022122120101211020120210210211220"
);
let a = UBig::from_le_bytes(&[0xff; 50]);
assert_eq!(
a.in_radix(32).to_string(),
"vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv"
);
assert_eq!(ubig!(123456789).to_string(), "123456789");
assert_eq!(
ubig!(123456789000000000000000000000000000000000123789749847509837450987340589273405)
.to_string(),
"123456789000000000000000000000000000000000123789749847509837450987340589273405"
);
assert_eq!(ubig!(0x83c0d7401f0188462502c2e5f7035386b1c341d307e5fbe8200756201607769a706134cfab1).to_string(),
"1048383517376714931597372965085953822045235087388094946568022880798260489887669110556129969");
assert_eq!(
ubig!(1048383517376714931597372965085953822045235087388094946568022880798260489887669110556129969).in_radix(16).to_string(),
"83c0d7401f0188462502c2e5f7035386b1c341d307e5fbe8200756201607769a706134cfab1");
}
#[test]
fn test_ibig_format() {
assert_eq!(format!("{}", ibig!(-123)), "-123");
assert_eq!(format!("{:?}", ibig!(-123)), "-123");
assert_eq!(format!("{:=>10}", ibig!(-123)), "======-123");
assert_eq!(format!("{:b}", ibig!(0)), "0");
assert_eq!(format!("{:b}", ibig!(100)), "1100100");
assert_eq!(format!("{:b}", ibig!(-100)), "-1100100");
assert_eq!(format!("{:#b}", ibig!(100)), "0b1100100");
assert_eq!(format!("{:#b}", ibig!(-100)), "-0b1100100");
assert_eq!(format!("{:+b}", ibig!(100)), "+1100100");
assert_eq!(format!("{:+b}", ibig!(-100)), "-1100100");
assert_eq!(format!("{:+#b}", ibig!(100)), "+0b1100100");
assert_eq!(format!("{:+#b}", ibig!(-100)), "-0b1100100");
assert_eq!(format!("{:10b}", ibig!(100)), " 1100100");
assert_eq!(format!("{:10b}", ibig!(-100)), " -1100100");
assert_eq!(format!("{:=<10b}", ibig!(100)), "1100100===");
assert_eq!(format!("{:=<10b}", ibig!(-100)), "-1100100==");
assert_eq!(format!("{:=>10b}", ibig!(100)), "===1100100");
assert_eq!(format!("{:=>10b}", ibig!(-100)), "==-1100100");
assert_eq!(format!("{:=^10b}", ibig!(100)), "=1100100==");
assert_eq!(format!("{:=^10b}", ibig!(-100)), "=-1100100=");
assert_eq!(format!("{:=^+10b}", ibig!(100)), "=+1100100=");
assert_eq!(format!("{:=^+10b}", ibig!(-100)), "=-1100100=");
assert_eq!(format!("{:+010b}", ibig!(100)), "+001100100");
assert_eq!(format!("{:+010b}", ibig!(-100)), "-001100100");
assert_eq!(format!("{:+#010b}", ibig!(100)), "+0b1100100");
assert_eq!(format!("{:+#010b}", ibig!(-100)), "-0b1100100");
assert_eq!(format!("{:+#01b}", ibig!(100)), "+0b1100100");
assert_eq!(format!("{:+#01b}", ibig!(-100)), "-0b1100100");
assert_eq!(format!("{:o}", ibig!(100)), "144");
assert_eq!(format!("{:o}", ibig!(-100)), "-144");
assert_eq!(format!("{:#o}", ibig!(100)), "0o144");
assert_eq!(format!("{:#o}", ibig!(-100)), "-0o144");
assert_eq!(format!("{:x}", ibig!(3000)), "bb8");
assert_eq!(format!("{:x}", ibig!(-3000)), "-bb8");
assert_eq!(format!("{:#x}", ibig!(3000)), "0xbb8");
assert_eq!(format!("{:#x}", ibig!(-3000)), "-0xbb8");
assert_eq!(format!("{:X}", ibig!(3000)), "BB8");
assert_eq!(format!("{:X}", ibig!(-3000)), "-BB8");
assert_eq!(format!("{:#X}", ibig!(3000)), "0xBB8");
assert_eq!(format!("{:#X}", ibig!(-3000)), "-0xBB8");
assert_eq!(format!("{:#10X}", ibig!(3000)), " 0xBB8");
assert_eq!(format!("{:#10X}", ibig!(-3000)), " -0xBB8");
}
#[test]
fn test_ibig_in_radix() {
assert_eq!(format!("{}", ibig!(0).in_radix(2)), "0");
assert_eq!(format!("{}", ibig!(100).in_radix(4)), "1210");
assert_eq!(format!("{}", ibig!(-100).in_radix(4)), "-1210");
assert_eq!(format!("{}", ibig!(3000).in_radix(16)), "bb8");
assert_eq!(format!("{}", ibig!(-3000).in_radix(16)), "-bb8");
assert_eq!(format!("{:+010}", ibig!(3000).in_radix(16)), "+000000bb8");
assert_eq!(format!("{:+010}", ibig!(-3000).in_radix(16)), "-000000bb8");
assert_eq!(format!("{:#010}", ibig!(3000).in_radix(16)), "0000000BB8");
assert_eq!(format!("{:#010}", ibig!(-3000).in_radix(16)), "-000000BB8");
assert_eq!(format!("{:#010}", ibig!(-3000).in_radix(10)), "-000003000");
assert_eq!(ibig!(0).in_radix(16).to_string(), "0");
assert_eq!(ibig!(100).in_radix(4).to_string(), "1210");
assert_eq!(ibig!(-100).in_radix(4).to_string(), "-1210");
assert_eq!(ibig!(3000).in_radix(16).to_string(), "bb8");
assert_eq!(ibig!(-3000).in_radix(16).to_string(), "-bb8");
assert_eq!(ibig!(3000).in_radix(32).to_string(), "2to");
assert_eq!(ibig!(-3000).in_radix(32).to_string(), "-2to");
assert_eq!(ibig!(-1234).to_string(), "-1234");
}
#[test]
fn test_ubig_from_str_radix() {
assert_eq!(UBig::from_str_radix("", 2).unwrap_err(), ParseError::NoDigits);
assert_eq!(UBig::from_str_radix("+", 2).unwrap_err(), ParseError::NoDigits);
assert_eq!(UBig::from_str_radix("012", 2).unwrap_err(), ParseError::InvalidDigit);
assert_eq!(
UBig::from_str_radix("ffffffffffffffffffffffffffffffffffffffffffffffg", 16).unwrap_err(),
ParseError::InvalidDigit
);
assert_eq!(
UBig::from_str_radix("ffff_ffff_ffff_ffff_ffff_ffff_ffff_fffg", 16).unwrap_err(),
ParseError::InvalidDigit
);
assert_eq!(UBig::from_str_radix("-0", 2).unwrap_err(), ParseError::InvalidDigit);
assert_eq!(UBig::from_str_radix("+0", 2).unwrap(), ubig!(0));
assert_eq!(UBig::from_str_radix("0", 2).unwrap(), ubig!(0));
assert_eq!(UBig::from_str_radix("0000000000000", 2).unwrap(), ubig!(0));
assert_eq!(UBig::from_str_radix("000_000_000_000_0", 2).unwrap(), ubig!(0));
assert_eq!(UBig::from_str_radix("1010110", 2).unwrap(), ubig!(0b1010110));
assert_eq!(UBig::from_str_radix("0101_0110", 2).unwrap(), ubig!(0b1010110));
assert_eq!(UBig::from_str_radix("f1Ee", 16).unwrap(), ubig!(0xf1ee));
assert_eq!(UBig::from_str_radix("f1_Ee", 16).unwrap(), ubig!(0xf1ee));
assert_eq!(UBig::from_str_radix("Pp", 32).unwrap(), ubig!(825));
assert_eq!(UBig::from_str_radix("P_p", 32).unwrap(), ubig!(825));
assert_eq!(UBig::from_str_radix("12345", 10), Ok(ubig!(12345)));
assert_eq!(UBig::from_str_radix("1_23_45", 10), Ok(ubig!(12345)));
assert_eq!(UBig::from_str_radix("abzz", 36), Ok(ubig!(482111)));
assert_eq!(UBig::from_str_radix("ab_zz", 36), Ok(ubig!(482111)));
assert_eq!(
UBig::from_str_radix(
"1538958592398779500320098585338768070858734861441260196946465951498852935601537907018559511",
10
),
UBig::from_str_radix(
"c167bcc5802bf76f345a9f2a738d9d3b75ea4560a9be33c330216cbd15efc15d872a781f017",
16));
assert_eq!(
UBig::from_str_radix(
"15389_58592_39877_95003_20098_58533_87680_70858_73486_14412_60196_94646_59514_98852_93560",
10
),
UBig::from_str_radix(
"571a_1aad_3444_d2c7_ce28_eacd_2285_2faa_03fe_3956_505c_f11e_cd48_6b7b_5f43_f8",
16));
{
let x: UBig = "1234".parse().unwrap();
assert_eq!(x, ubig!(1234));
}
{
let x: UBig = "0000000000000000001234".parse().unwrap();
assert_eq!(x, ubig!(1234));
}
}
#[test]
fn test_ibig_from_str_radix() {
assert_eq!(IBig::from_str_radix("", 2).unwrap_err(), ParseError::NoDigits);
assert_eq!(IBig::from_str_radix("+", 2).unwrap_err(), ParseError::NoDigits);
assert_eq!(IBig::from_str_radix("-", 2).unwrap_err(), ParseError::NoDigits);
assert_eq!(IBig::from_str_radix("-+5", 2).unwrap_err(), ParseError::InvalidDigit);
assert_eq!(IBig::from_str_radix("-012", 2).unwrap_err(), ParseError::InvalidDigit);
assert_eq!(IBig::from_str_radix("0", 2).unwrap(), ibig!(0));
assert_eq!(IBig::from_str_radix("+0", 2).unwrap(), ibig!(0));
assert_eq!(IBig::from_str_radix("-0", 2).unwrap(), ibig!(0));
assert_eq!(IBig::from_str_radix("1010110", 2).unwrap(), ibig!(0b1010110));
assert_eq!(IBig::from_str_radix("-1010110", 2).unwrap(), ibig!(-0b1010110));
{
let x: IBig = "-1234".parse().unwrap();
assert_eq!(x, ibig!(-1234));
}
}
#[test]
fn test_radix_round_trip() {
assert_eq!(
UBig::from_str_radix("abCCcaacacbbcbabcbacbacbabcabcbabcabbc1000", 16)
.unwrap()
.in_radix(16)
.to_string(),
"abcccaacacbbcbabcbacbacbabcabcbabcabbc1000"
);
assert_eq!(
UBig::from_str_radix("12341235234512341345356745634563563563457356356354645634563456", 8)
.unwrap()
.in_radix(16)
.to_string(),
"a70a75394a70b95dde5ce5cee77397bb9dcecd2e72e72e"
);
let x: UBig = "1287912837409187345908734509873240897234".parse().unwrap();
assert_eq!(x.to_string(), "1287912837409187345908734509873240897234");
for i in 0..1000 {
let x = ubig!(10).pow(i);
let y: UBig = x.to_string().parse().unwrap();
assert_eq!(x, y);
let y: UBig = (&x - ubig!(1)).to_string().parse().unwrap();
assert_eq!(&x - ubig!(1), y);
}
for i in 0..100 {
let x: UBig = ubig!(1) << (64 * i);
let y: UBig = x.to_string().parse().unwrap();
assert_eq!(x, y);
let y: UBig = (&x - ubig!(1)).to_string().parse().unwrap();
assert_eq!(&x - ubig!(1), y);
}
assert_eq!(
IBig::from_str_radix("-abCCcaacacbbcbabcbacbacbabcabcbabcabbc1000", 16)
.unwrap()
.in_radix(16)
.to_string(),
"-abcccaacacbbcbabcbacbacbabcabcbabcabbc1000"
);
}
#[test]
fn test_from_str_radix_with_radix_prefix() {
assert_eq!(UBig::from_str_with_radix_prefix("17").unwrap(), (UBig::from(17u8), 10));
assert_eq!(UBig::from_str_with_radix_prefix("+17").unwrap(), (UBig::from(17u8), 10));
assert_eq!(UBig::from_str_with_radix_prefix("0b101").unwrap(), (UBig::from(0b101u8), 2));
assert_eq!(UBig::from_str_with_radix_prefix("+0b101").unwrap(), (UBig::from(0b101u8), 2));
assert_eq!(UBig::from_str_with_radix_prefix("0o177").unwrap(), (UBig::from(0o177u8), 8));
assert_eq!(UBig::from_str_with_radix_prefix("+0o177").unwrap(), (UBig::from(0o177u8), 8));
assert_eq!(UBig::from_str_with_radix_prefix("0x1eE").unwrap(), (UBig::from(0x1eeu16), 16));
assert_eq!(UBig::from_str_with_radix_prefix("+0x1eE").unwrap(), (UBig::from(0x1eeu16), 16));
assert_eq!(IBig::from_str_with_radix_prefix("17").unwrap(), (IBig::from(17), 10));
assert_eq!(IBig::from_str_with_radix_prefix("+17").unwrap(), (IBig::from(17), 10));
assert_eq!(IBig::from_str_with_radix_prefix("-17").unwrap(), (IBig::from(-17), 10));
assert_eq!(IBig::from_str_with_radix_prefix("0b101").unwrap(), (IBig::from(0b101), 2));
assert_eq!(IBig::from_str_with_radix_prefix("+0b101").unwrap(), (IBig::from(0b101), 2));
assert_eq!(IBig::from_str_with_radix_prefix("-0b101").unwrap(), (IBig::from(-0b101), 2));
assert_eq!(IBig::from_str_with_radix_prefix("0o177").unwrap(), (IBig::from(0o177), 8));
assert_eq!(IBig::from_str_with_radix_prefix("+0o177").unwrap(), (IBig::from(0o177), 8));
assert_eq!(IBig::from_str_with_radix_prefix("-0o177").unwrap(), (IBig::from(-0o177), 8));
assert_eq!(IBig::from_str_with_radix_prefix("0x1eE").unwrap(), (IBig::from(0x1ee), 16));
assert_eq!(IBig::from_str_with_radix_prefix("+0x1eE").unwrap(), (IBig::from(0x1ee), 16));
assert_eq!(IBig::from_str_with_radix_prefix("-0x1eE").unwrap(), (IBig::from(-0x1ee), 16));
assert_eq!(UBig::from_str_with_radix_prefix("").unwrap_err(), ParseError::NoDigits);
assert_eq!(UBig::from_str_with_radix_prefix("+").unwrap_err(), ParseError::NoDigits);
assert_eq!(UBig::from_str_with_radix_prefix("0b102").unwrap_err(), ParseError::InvalidDigit);
assert_eq!(IBig::from_str_with_radix_prefix("").unwrap_err(), ParseError::NoDigits);
assert_eq!(IBig::from_str_with_radix_prefix("+").unwrap_err(), ParseError::NoDigits);
assert_eq!(IBig::from_str_with_radix_prefix("-").unwrap_err(), ParseError::NoDigits);
assert_eq!(IBig::from_str_with_radix_prefix("0x1fg").unwrap_err(), ParseError::InvalidDigit);
}
#[test]
fn test_display_errors() {
assert_eq!(ParseError::NoDigits.to_string(), "no digits");
assert_eq!(ParseError::InvalidDigit.to_string(), "invalid digit");
}
#[test]
fn test_macros() {
assert_eq!(ubig!(17), UBig::from(17u32));
assert_eq!(ubig!(0b101), UBig::from(0b101u32));
assert_eq!(ubig!(0o177), UBig::from(0o177u32));
assert_eq!(
format!("{:x}", ubig!(0x1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),
"1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
);
assert_eq!(ubig!(100 base 32), UBig::from(1024u32));
assert_eq!(
format!("{}", ubig!(ppppppppppppppppppp base 32).in_radix(32)),
"ppppppppppppppppppp"
);
assert_eq!(ibig!(17), IBig::from(17i32));
assert_eq!(ibig!(-17), IBig::from(-17i32));
assert_eq!(ibig!(0b101), IBig::from(0b101i32));
assert_eq!(ibig!(-0b101), IBig::from(-0b101i32));
assert_eq!(ibig!(0o177), IBig::from(0o177i32));
assert_eq!(ibig!(-0o177), IBig::from(-0o177i32));
assert_eq!(ibig!(0x1ff), IBig::from(0x1ffi32));
assert_eq!(ibig!(-0x1ff), IBig::from(-0x1ffi32));
assert_eq!(
format!("{:x}", ibig!(-0x1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),
"-1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
);
assert_eq!(ibig!(100 base 32), IBig::from(1024i32));
assert_eq!(ibig!(-100 base 32), IBig::from(-1024i32));
assert_eq!(
format!("{}", ibig!(ppppppppppppppppppp base 32).in_radix(32)),
"ppppppppppppppppppp"
);
assert_eq!(
format!("{}", ibig!(-ppppppppppppppppppp base 32).in_radix(32)),
"-ppppppppppppppppppp"
);
}
#[test]
fn test_ubig_debug() {
assert_eq!(format!("{:?}", ubig!(0)), "0");
assert_eq!(format!("{:#?}", ubig!(0)), "0 (0 digits, 0 bits)");
assert_eq!(format!("{:?}", ubig!(100)), "100");
assert_eq!(format!("{:#?}", ubig!(100)), "100 (3 digits, 7 bits)");
assert_eq!(format!("{:?}", ubig!(12345678)), "12345678");
assert_eq!(format!("{:#?}", ubig!(12345678)), "12345678 (8 digits, 24 bits)");
assert_eq!(format!("{:?}", (ubig!(1) << 31) - 1u8), "2147483647");
assert_eq!(format!("{:#?}", (ubig!(1) << 31) - 1u8), "2147483647 (10 digits, 31 bits)");
if Word::BITS == 64 {
assert_eq!(format!("{:?}", ubig!(1) << 128), "3402823669209384634..3374607431768211456");
assert_eq!(
format!("{:#?}", ubig!(1) << 128),
"3402823669209384634..3374607431768211456 (39 digits, 129 bits)"
);
assert_eq!(
format!("{:?}", (ubig!(1) << 129) - 1u8),
"6805647338418769269..6749214863536422911"
);
assert_eq!(
format!("{:#?}", (ubig!(1) << 129) - 1u8),
"6805647338418769269..6749214863536422911 (39 digits, 129 bits)"
);
assert_eq!(
format!("{:?}", (ubig!(1) << 200) - 1u8),
"1606938044258990275..2993782792835301375"
);
assert_eq!(
format!("{:#?}", (ubig!(1) << 200) - 1u8),
"1606938044258990275..2993782792835301375 (61 digits, 200 bits)"
);
assert_eq!(
format!("{:?}", (ubig!(1) << 2000) - 1u8),
"1148130695274254524..3762184851149029375"
);
assert_eq!(
format!("{:#?}", (ubig!(1) << 2000) - 1u8),
"1148130695274254524..3762184851149029375 (603 digits, 2000 bits)"
);
}
}
#[test]
fn test_ibig_debug() {
assert_eq!(format!("{:?}", ibig!(-0)), "0");
assert_eq!(format!("{:#?}", ibig!(-0)), "0 (0 digits, 0 bits)");
assert_eq!(format!("{:?}", ibig!(-100)), "-100");
assert_eq!(format!("{:+?}", ibig!(100)), "+100");
assert_eq!(format!("{:#?}", ibig!(-100)), "-100 (3 digits, 7 bits)");
assert_eq!(format!("{:+#?}", ibig!(100)), "+100 (3 digits, 7 bits)");
if Word::BITS == 64 {
assert_eq!(format!("{:?}", ibig!(-1) << 128), "-3402823669209384634..3374607431768211456");
assert_eq!(
format!("{:#?}", ibig!(-1) << 128),
"-3402823669209384634..3374607431768211456 (39 digits, 129 bits)"
);
assert_eq!(
format!("{:?}", (ibig!(-1) << 200) + 1),
"-1606938044258990275..2993782792835301375"
);
assert_eq!(
format!("{:#?}", (ibig!(-1) << 200) + 1),
"-1606938044258990275..2993782792835301375 (61 digits, 200 bits)"
);
}
}