// Copyright © 2024 Mikhail Hogrefe // // This file is part of Malachite. // // Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU // Lesser General Public License (LGPL) as published by the Free Software Foundation; either version // 3 of the License, or (at your option) any later version. See . use itertools::repeat_n; use malachite_base::num::arithmetic::traits::{SaturatingSubAssign, UnsignedAbs}; use malachite_base::num::basic::integers::PrimitiveInt; use malachite_base::num::basic::signeds::PrimitiveSigned; use malachite_base::num::basic::unsigneds::PrimitiveUnsigned; use malachite_base::num::conversion::string::to_string::{ digit_to_display_byte_lower, digit_to_display_byte_upper, BaseFmtWrapper, }; use malachite_base::num::conversion::traits::WrappingFrom; use malachite_base::strings::{ string_is_subset, ToBinaryString, ToLowerHexString, ToOctalString, ToUpperHexString, }; use malachite_base::test_util::generators::{ signed_gen, signed_gen_var_2, signed_unsigned_pair_gen_var_5, signed_unsigned_pair_gen_var_6, signed_unsigned_unsigned_triple_gen_var_3, unsigned_gen, unsigned_gen_var_7, unsigned_gen_var_8, unsigned_pair_gen_var_2, unsigned_pair_gen_var_8, unsigned_pair_gen_var_9, unsigned_triple_gen_var_6, }; use malachite_base::test_util::num::conversion::string::to_string::{ to_string_base_signed_naive, to_string_base_unsigned_naive, }; use std::cmp::max; use std::fmt::{Debug, Display}; use std::panic::catch_unwind; fn test_padding_unsigned(s: &str, s_padded: &str, width: usize) { assert!(s_padded.ends_with(&s)); assert!(s_padded.len() >= width); assert_eq!(s.len() >= width, s == s_padded); if s.len() < width { let diff = s_padded.len() - s.len(); assert!(s_padded[..diff].chars().all(|c| c == '0')); assert_eq!(&s_padded[diff..], s); } } fn test_padding_signed(mut s: &str, mut s_padded: &str, mut width: usize) { assert!(s_padded.len() >= width); assert_eq!(s.len() >= width, s == s_padded); let negative = s.starts_with('-'); assert_eq!(s_padded.starts_with('-'), negative); if negative { s = &s[1..]; s_padded = &s_padded[1..]; width.saturating_sub_assign(1); } test_padding_unsigned(s, s_padded, width); } #[test] fn test_digit_to_display_byte_lower() { let test_ok = |x, y| { assert_eq!(digit_to_display_byte_lower(x).unwrap(), y); }; test_ok(0, b'0'); test_ok(1, b'1'); test_ok(2, b'2'); test_ok(3, b'3'); test_ok(4, b'4'); test_ok(5, b'5'); test_ok(6, b'6'); test_ok(7, b'7'); test_ok(8, b'8'); test_ok(9, b'9'); test_ok(10, b'a'); test_ok(11, b'b'); test_ok(12, b'c'); test_ok(33, b'x'); test_ok(34, b'y'); test_ok(35, b'z'); let test_err = |x| { assert!(digit_to_display_byte_lower(x).is_none()); }; test_err(36); test_err(100); } #[test] fn digit_to_display_byte_lower_properties() { unsigned_gen().test_properties(|b| { assert_eq!(digit_to_display_byte_lower(b).is_some(), b < 36); }); unsigned_gen_var_7().test_properties(|b| { let display_byte = digit_to_display_byte_lower(b).unwrap(); assert!(display_byte.is_ascii_digit() || display_byte.is_ascii_lowercase()); let display_byte_upper = digit_to_display_byte_upper(b).unwrap(); assert_eq!(display_byte == display_byte_upper, b < 10); assert_eq!( char::from(display_byte).to_ascii_uppercase(), char::from(display_byte_upper) ); }); } #[test] fn test_digit_to_display_byte_upper() { let test_ok = |x, y| { assert_eq!(digit_to_display_byte_upper(x).unwrap(), y); }; test_ok(0, b'0'); test_ok(1, b'1'); test_ok(2, b'2'); test_ok(3, b'3'); test_ok(4, b'4'); test_ok(5, b'5'); test_ok(6, b'6'); test_ok(7, b'7'); test_ok(8, b'8'); test_ok(9, b'9'); test_ok(10, b'A'); test_ok(11, b'B'); test_ok(12, b'C'); test_ok(33, b'X'); test_ok(34, b'Y'); test_ok(35, b'Z'); let test_err = |x| { assert!(digit_to_display_byte_upper(x).is_none()); }; test_err(36); test_err(100); } #[test] fn digit_to_display_byte_upper_properties() { unsigned_gen().test_properties(|b| { assert_eq!( digit_to_display_byte_upper(b).is_some(), (0..36).contains(&b) ); }); unsigned_gen_var_7().test_properties(|b| { let display_byte = digit_to_display_byte_upper(b).unwrap(); assert!(display_byte.is_ascii_digit() || display_byte.is_ascii_uppercase()); let display_byte_lower = digit_to_display_byte_lower(b).unwrap(); assert_eq!(display_byte == display_byte_lower, b < 10); assert_eq!( char::from(display_byte).to_ascii_lowercase(), char::from(display_byte_lower) ); }); } #[test] pub fn test_to_string_base() { fn test_u(x: T, base: u8, out: &str) where BaseFmtWrapper: Debug + Display, u8: WrappingFrom, { assert_eq!(x.to_string_base(base), out); assert_eq!(to_string_base_unsigned_naive(x, base), out); assert_eq!(format!("{}", BaseFmtWrapper::new(x, base)), out); assert_eq!(format!("{:?}", BaseFmtWrapper::new(x, base)), out); assert_eq!(format!("{:00}", BaseFmtWrapper::new(x, base)), out); assert_eq!(format!("{:00?}", BaseFmtWrapper::new(x, base)), out); } test_u::(0, 2, "0"); test_u::(0, 3, "0"); test_u::(0, 10, "0"); test_u::(0, 16, "0"); test_u::(0, 17, "0"); test_u::(2, 3, "2"); test_u::(2, 10, "2"); test_u::(2, 16, "2"); test_u::(2, 17, "2"); test_u::(123, 8, "173"); test_u::(1000000, 10, "1000000"); test_u::(1000000, 20, "65000"); test_u::(1000000, 36, "lfls"); test_u::(1000, 2, "1111101000"); test_u::(1000, 3, "1101001"); test_u::(1000, 4, "33220"); test_u::(1000, 10, "1000"); test_u::(1000, 20, "2a0"); test_u::(1000, 36, "rs"); fn test_u_width(x: T, base: u8, width: usize, out: &str) where BaseFmtWrapper: Debug + Display, u8: WrappingFrom, { let s = x.to_string_base(base); assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, base), width = width), out ); assert_eq!( format!("{:0width$?}", BaseFmtWrapper::new(x, base), width = width), out ); test_padding_unsigned(&s, out, width); } test_u_width::(0, 2, 0, "0"); test_u_width::(0, 2, 1, "0"); test_u_width::(0, 2, 2, "00"); test_u_width::(0, 2, 5, "00000"); test_u_width::(1000000, 36, 0, "lfls"); test_u_width::(1000000, 36, 1, "lfls"); test_u_width::(1000000, 36, 2, "lfls"); test_u_width::(1000000, 36, 3, "lfls"); test_u_width::(1000000, 36, 4, "lfls"); test_u_width::(1000000, 36, 5, "0lfls"); test_u_width::(1000000, 36, 6, "00lfls"); fn test_i(x: T, base: u8, out: &str) where BaseFmtWrapper: Debug + Display, u8: WrappingFrom<::Output>, ::Output: PrimitiveUnsigned, { assert_eq!(x.to_string_base(base), out); assert_eq!(to_string_base_signed_naive(x, base), out); assert_eq!(format!("{}", BaseFmtWrapper::new(x, base)), out); assert_eq!(format!("{:?}", BaseFmtWrapper::new(x, base)), out); assert_eq!(format!("{:00}", BaseFmtWrapper::new(x, base)), out); assert_eq!(format!("{:00?}", BaseFmtWrapper::new(x, base)), out); } test_i::(0, 2, "0"); test_i::(0, 3, "0"); test_i::(0, 10, "0"); test_i::(0, 16, "0"); test_i::(0, 17, "0"); test_i::(2, 3, "2"); test_i::(2, 10, "2"); test_i::(2, 16, "2"); test_i::(2, 17, "2"); test_i::(123, 8, "173"); test_i::(1000000, 10, "1000000"); test_i::(1000000, 20, "65000"); test_i::(1000000, 36, "lfls"); test_i::(1000, 2, "1111101000"); test_i::(1000, 3, "1101001"); test_i::(1000, 4, "33220"); test_i::(1000, 10, "1000"); test_i::(1000, 20, "2a0"); test_i::(1000, 36, "rs"); test_i::(-2, 3, "-2"); test_i::(-2, 10, "-2"); test_i::(-2, 16, "-2"); test_i::(-2, 17, "-2"); test_i::(-123, 8, "-173"); test_i::(-1000000, 10, "-1000000"); test_i::(-1000000, 20, "-65000"); test_i::(-1000000, 36, "-lfls"); test_i::(-1000, 2, "-1111101000"); test_i::(-1000, 3, "-1101001"); test_i::(-1000, 4, "-33220"); test_i::(-1000, 10, "-1000"); test_i::(-1000, 20, "-2a0"); test_i::(-1000, 36, "-rs"); fn test_i_width(x: T, base: u8, width: usize, out: &str) where BaseFmtWrapper: Debug + Display, u8: WrappingFrom, { let s = x.to_string_base(base); assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, base), width = width), out ); assert_eq!( format!("{:0width$?}", BaseFmtWrapper::new(x, base), width = width), out ); test_padding_signed(&s, out, width); } test_i_width::(0, 2, 0, "0"); test_i_width::(0, 2, 1, "0"); test_i_width::(0, 2, 2, "00"); test_i_width::(0, 2, 5, "00000"); test_i_width::(1000000, 36, 0, "lfls"); test_i_width::(1000000, 36, 1, "lfls"); test_i_width::(1000000, 36, 2, "lfls"); test_i_width::(1000000, 36, 3, "lfls"); test_i_width::(1000000, 36, 4, "lfls"); test_i_width::(1000000, 36, 5, "0lfls"); test_i_width::(1000000, 36, 6, "00lfls"); test_i_width::(-1000000, 36, 0, "-lfls"); test_i_width::(-1000000, 36, 1, "-lfls"); test_i_width::(-1000000, 36, 2, "-lfls"); test_i_width::(-1000000, 36, 3, "-lfls"); test_i_width::(-1000000, 36, 4, "-lfls"); test_i_width::(-1000000, 36, 5, "-lfls"); test_i_width::(-1000000, 36, 6, "-0lfls"); } fn to_string_base_fail_helper() { assert_panic!(T::exact_from(100).to_string_base(0)); assert_panic!(T::exact_from(100).to_string_base(1)); assert_panic!(T::exact_from(100).to_string_base(37)); assert_panic!(T::exact_from(100).to_string_base(100)); } #[test] fn to_string_base_fail() { apply_fn_to_primitive_ints!(to_string_base_fail_helper); } fn to_string_base_helper_unsigned() where BaseFmtWrapper: Debug + Display, u8: WrappingFrom, { unsigned_pair_gen_var_8::().test_properties(|(x, base)| { let s = x.to_string_base(base); assert_eq!(to_string_base_unsigned_naive(x, base), s); assert_eq!(format!("{}", BaseFmtWrapper::new(x, base)), s); assert_eq!(format!("{:?}", BaseFmtWrapper::new(x, base)), s); assert_eq!(format!("{:00}", BaseFmtWrapper::new(x, base)), s); assert_eq!(format!("{:00?}", BaseFmtWrapper::new(x, base)), s); assert_eq!(x.to_string_base_upper(base), s.to_uppercase()); assert_eq!(T::from_string_base(base, &s).unwrap(), x); assert!(string_is_subset(&s, "0123456789abcdefghijklmnopqrstuvwxyz")); if x != T::ZERO { assert!(!s.starts_with('0')); } }); unsigned_gen::().test_properties(|x| { assert_eq!(x.to_string_base(10), x.to_string()); assert_eq!(x.to_string_base(2), x.to_binary_string()); assert_eq!(x.to_string_base(8), x.to_octal_string()); assert_eq!(x.to_string_base(16), x.to_lower_hex_string()); }); unsigned_gen_var_8().test_properties(|base| { assert_eq!(T::ZERO.to_string_base(base), "0"); assert_eq!(T::ONE.to_string_base(base), "1"); assert_eq!(T::exact_from(base).to_string_base(base), "10"); }); unsigned_triple_gen_var_6::().test_properties(|(x, base, width)| { let fx = BaseFmtWrapper::new(x, base); let s = x.to_string_base(base); let s_padded = format!("{fx:0width$}"); assert_eq!(format!("{fx:0width$?}"), s_padded); assert_eq!(T::from_string_base(base, &s).unwrap(), x); assert!(string_is_subset( &s_padded, "0123456789abcdefghijklmnopqrstuvwxyz" )); test_padding_unsigned(&s, &s_padded, width); }); unsigned_pair_gen_var_2::().test_properties(|(x, width)| { assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, 10), width = width), format!("{x:0width$}") ); assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, 2), width = width), format!("{x:0width$b}") ); assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, 8), width = width), format!("{x:0width$o}") ); assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, 16), width = width), format!("{x:0width$x}") ); }); unsigned_pair_gen_var_9::().test_properties(|(width, base)| { let s = format!( "{:0width$}", BaseFmtWrapper::new(T::ZERO, base), width = width ); assert_eq!(repeat_n('0', max(1, width)).collect::(), s); }); } fn to_string_base_helper_signed() where BaseFmtWrapper: Debug + Display, u8: WrappingFrom<::Output>, ::Output: PrimitiveUnsigned, { signed_unsigned_pair_gen_var_5::().test_properties(|(x, base)| { let s = x.to_string_base(base); assert_eq!(to_string_base_signed_naive(x, base), s); assert_eq!(format!("{}", BaseFmtWrapper::new(x, base)), s); assert_eq!(format!("{:?}", BaseFmtWrapper::new(x, base)), s); assert_eq!(format!("{:00}", BaseFmtWrapper::new(x, base)), s); assert_eq!(format!("{:00?}", BaseFmtWrapper::new(x, base)), s); assert_eq!(x.to_string_base_upper(base), s.to_uppercase()); assert_eq!(T::from_string_base(base, &s).unwrap(), x); assert!(string_is_subset( &s, "-0123456789abcdefghijklmnopqrstuvwxyz" )); assert_eq!(x < T::ZERO, s.starts_with('-')); assert!(!s.starts_with("-0")); if x != T::ZERO { assert!(!s.starts_with('0')); } }); signed_gen::().test_properties(|x| { assert_eq!(x.to_string_base(10), x.to_string()); }); signed_gen_var_2::().test_properties(|x| { assert_eq!(x.to_string_base(2), x.to_binary_string()); assert_eq!(x.to_string_base(8), x.to_octal_string()); assert_eq!(x.to_string_base(16), x.to_lower_hex_string()); }); unsigned_gen_var_8().test_properties(|base| { assert_eq!(T::ZERO.to_string_base(base), "0"); assert_eq!(T::ONE.to_string_base(base), "1"); assert_eq!(T::NEGATIVE_ONE.to_string_base(base), "-1"); assert_eq!(T::exact_from(base).to_string_base(base), "10"); }); signed_unsigned_unsigned_triple_gen_var_3::().test_properties( |(x, base, width)| { let fx = BaseFmtWrapper::new(x, base); let s = x.to_string_base(base); let s_padded = format!("{fx:0width$}"); assert!(s_padded.len() >= width); assert_eq!(s.len() >= width, s == s_padded); assert_eq!(format!("{fx:0width$?}"), s_padded); assert_eq!(T::from_string_base(base, &s).unwrap(), x); assert!(string_is_subset( &s_padded, "-0123456789abcdefghijklmnopqrstuvwxyz" )); test_padding_signed(&s, &s_padded, width); }, ); signed_unsigned_pair_gen_var_6::().test_properties(|(x, width)| { assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, 10), width = width), format!("{x:0width$}") ); assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, 2), width = width), format!("{x:0width$b}") ); assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, 8), width = width), format!("{x:0width$o}") ); assert_eq!( format!("{:0width$}", BaseFmtWrapper::new(x, 16), width = width), format!("{x:0width$x}") ); }); unsigned_pair_gen_var_9::().test_properties(|(width, base)| { let s = format!( "{:0width$}", BaseFmtWrapper::new(T::ZERO, base), width = width ); assert_eq!(repeat_n('0', max(1, width)).collect::(), s); }); } #[test] fn to_string_base_properties() { apply_fn_to_unsigneds!(to_string_base_helper_unsigned); apply_fn_to_signeds!(to_string_base_helper_signed); } #[test] pub fn test_to_string_base_upper() { fn test_u(x: T, base: u8, out: &str) where BaseFmtWrapper: Debug + Display, { assert_eq!(x.to_string_base_upper(base), out); assert_eq!(format!("{:#}", BaseFmtWrapper::new(x, base)), out); assert_eq!(format!("{:#?}", BaseFmtWrapper::new(x, base)), out); } test_u::(0, 2, "0"); test_u::(0, 3, "0"); test_u::(0, 10, "0"); test_u::(0, 16, "0"); test_u::(0, 17, "0"); test_u::(2, 3, "2"); test_u::(2, 10, "2"); test_u::(2, 16, "2"); test_u::(2, 17, "2"); test_u::(123, 8, "173"); test_u::(1000000, 10, "1000000"); test_u::(1000000, 20, "65000"); test_u::(1000000, 36, "LFLS"); test_u::(1000, 2, "1111101000"); test_u::(1000, 3, "1101001"); test_u::(1000, 4, "33220"); test_u::(1000, 10, "1000"); test_u::(1000, 20, "2A0"); test_u::(1000, 36, "RS"); fn test_u_width(x: T, base: u8, width: usize, out: &str) where BaseFmtWrapper: Debug + Display, u8: WrappingFrom, { let s = x.to_string_base_upper(base); assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, base), width = width), out ); assert_eq!( format!("{:#0width$?}", BaseFmtWrapper::new(x, base), width = width), out ); test_padding_unsigned(&s, out, width); } test_u_width::(0, 2, 0, "0"); test_u_width::(0, 2, 1, "0"); test_u_width::(0, 2, 2, "00"); test_u_width::(0, 2, 5, "00000"); test_u_width::(1000000, 36, 0, "LFLS"); test_u_width::(1000000, 36, 1, "LFLS"); test_u_width::(1000000, 36, 2, "LFLS"); test_u_width::(1000000, 36, 3, "LFLS"); test_u_width::(1000000, 36, 4, "LFLS"); test_u_width::(1000000, 36, 5, "0LFLS"); test_u_width::(1000000, 36, 6, "00LFLS"); fn test_i(x: T, base: u8, out: &str) where BaseFmtWrapper: Debug + Display, { assert_eq!(x.to_string_base_upper(base), out); assert_eq!(format!("{:#}", BaseFmtWrapper::new(x, base)), out); assert_eq!(format!("{:#?}", BaseFmtWrapper::new(x, base)), out); } test_i::(0, 2, "0"); test_i::(0, 3, "0"); test_i::(0, 10, "0"); test_i::(0, 16, "0"); test_i::(0, 17, "0"); test_i::(2, 3, "2"); test_i::(2, 10, "2"); test_i::(2, 16, "2"); test_i::(2, 17, "2"); test_i::(123, 8, "173"); test_i::(1000000, 10, "1000000"); test_i::(1000000, 20, "65000"); test_i::(1000000, 36, "LFLS"); test_i::(1000, 2, "1111101000"); test_i::(1000, 3, "1101001"); test_i::(1000, 4, "33220"); test_i::(1000, 10, "1000"); test_i::(1000, 20, "2A0"); test_i::(1000, 36, "RS"); test_i::(-2, 3, "-2"); test_i::(-2, 10, "-2"); test_i::(-2, 16, "-2"); test_i::(-2, 17, "-2"); test_i::(-123, 8, "-173"); test_i::(-1000000, 10, "-1000000"); test_i::(-1000000, 20, "-65000"); test_i::(-1000000, 36, "-LFLS"); test_i::(-1000, 2, "-1111101000"); test_i::(-1000, 3, "-1101001"); test_i::(-1000, 4, "-33220"); test_i::(-1000, 10, "-1000"); test_i::(-1000, 20, "-2A0"); test_i::(-1000, 36, "-RS"); fn test_i_width(x: T, base: u8, width: usize, out: &str) where BaseFmtWrapper: Debug + Display, u8: WrappingFrom, { let s = x.to_string_base_upper(base); assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, base), width = width), out ); assert_eq!( format!("{:#0width$?}", BaseFmtWrapper::new(x, base), width = width), out ); test_padding_signed(&s, out, width); } test_i_width::(0, 2, 0, "0"); test_i_width::(0, 2, 1, "0"); test_i_width::(0, 2, 2, "00"); test_i_width::(0, 2, 5, "00000"); test_i_width::(1000000, 36, 0, "LFLS"); test_i_width::(1000000, 36, 1, "LFLS"); test_i_width::(1000000, 36, 2, "LFLS"); test_i_width::(1000000, 36, 3, "LFLS"); test_i_width::(1000000, 36, 4, "LFLS"); test_i_width::(1000000, 36, 5, "0LFLS"); test_i_width::(1000000, 36, 6, "00LFLS"); test_i_width::(-1000000, 36, 0, "-LFLS"); test_i_width::(-1000000, 36, 1, "-LFLS"); test_i_width::(-1000000, 36, 2, "-LFLS"); test_i_width::(-1000000, 36, 3, "-LFLS"); test_i_width::(-1000000, 36, 4, "-LFLS"); test_i_width::(-1000000, 36, 5, "-LFLS"); test_i_width::(-1000000, 36, 6, "-0LFLS"); } fn to_string_base_upper_fail_helper() { assert_panic!(T::exact_from(100).to_string_base_upper(0)); assert_panic!(T::exact_from(100).to_string_base_upper(1)); assert_panic!(T::exact_from(100).to_string_base_upper(37)); assert_panic!(T::exact_from(100).to_string_base_upper(100)); } #[test] fn to_string_base_upper_fail() { apply_fn_to_primitive_ints!(to_string_base_upper_fail_helper); } fn to_string_base_upper_helper_unsigned() where BaseFmtWrapper: Debug + Display, { unsigned_pair_gen_var_8::().test_properties(|(x, base)| { let s = x.to_string_base_upper(base); assert_eq!(format!("{:#}", BaseFmtWrapper::new(x, base)), s); assert_eq!(format!("{:#?}", BaseFmtWrapper::new(x, base)), s); assert_eq!(format!("{:#00}", BaseFmtWrapper::new(x, base)), s); assert_eq!(x.to_string_base(base), s.to_lowercase()); assert_eq!(T::from_string_base(base, &s).unwrap(), x); assert!(string_is_subset(&s, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ")); if x != T::ZERO { assert!(!s.starts_with('0')); } }); unsigned_gen::().test_properties(|x| { assert_eq!(x.to_string_base_upper(10), x.to_string()); assert_eq!(x.to_string_base_upper(2), x.to_binary_string()); assert_eq!(x.to_string_base_upper(8), x.to_octal_string()); assert_eq!(x.to_string_base_upper(16), x.to_upper_hex_string()); }); unsigned_gen_var_8().test_properties(|base| { assert_eq!(T::ZERO.to_string_base_upper(base), "0"); assert_eq!(T::ONE.to_string_base_upper(base), "1"); assert_eq!(T::exact_from(base).to_string_base_upper(base), "10"); }); unsigned_triple_gen_var_6::().test_properties(|(x, base, width)| { let fx = BaseFmtWrapper::new(x, base); let s = x.to_string_base_upper(base); let s_padded = format!("{fx:#0width$}"); assert_eq!(format!("{fx:#0width$?}"), s_padded); assert_eq!(T::from_string_base(base, &s).unwrap(), x); assert!(string_is_subset( &s_padded, "01234567890123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" )); test_padding_unsigned(&s, &s_padded, width); }); unsigned_pair_gen_var_2::().test_properties(|(x, width)| { assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, 10), width = width), format!("{x:0width$}") ); assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, 2), width = width), format!("{x:0width$b}") ); assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, 8), width = width), format!("{x:0width$o}") ); assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, 16), width = width), format!("{x:0width$X}") ); }); unsigned_pair_gen_var_9::().test_properties(|(width, base)| { let s = format!( "{:#0width$}", BaseFmtWrapper::new(T::ZERO, base), width = width ); assert_eq!(repeat_n('0', max(1, width)).collect::(), s); }); } fn to_string_base_upper_helper_signed() where BaseFmtWrapper: Debug + Display, { signed_unsigned_pair_gen_var_5::().test_properties(|(x, base)| { let s = x.to_string_base_upper(base); assert_eq!(format!("{:#}", BaseFmtWrapper::new(x, base)), s); assert_eq!(format!("{:#?}", BaseFmtWrapper::new(x, base)), s); assert_eq!(x.to_string_base(base), s.to_lowercase()); assert_eq!(T::from_string_base(base, &s).unwrap(), x); assert!(string_is_subset( &s, "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" )); assert_eq!(x < T::ZERO, s.starts_with('-')); assert!(!s.starts_with("-0")); if x != T::ZERO { assert!(!s.starts_with('0')); } }); signed_gen::().test_properties(|x| { assert_eq!(x.to_string_base_upper(10), x.to_string()); }); signed_gen_var_2::().test_properties(|x| { assert_eq!(x.to_string_base_upper(2), x.to_binary_string()); assert_eq!(x.to_string_base_upper(8), x.to_octal_string()); assert_eq!(x.to_string_base_upper(16), x.to_upper_hex_string()); }); unsigned_gen_var_8().test_properties(|base| { assert_eq!(T::ZERO.to_string_base_upper(base), "0"); assert_eq!(T::ONE.to_string_base_upper(base), "1"); assert_eq!(T::NEGATIVE_ONE.to_string_base_upper(base), "-1"); assert_eq!(T::exact_from(base).to_string_base_upper(base), "10"); }); signed_unsigned_unsigned_triple_gen_var_3::().test_properties( |(x, base, width)| { let fx = BaseFmtWrapper::new(x, base); let s = x.to_string_base_upper(base); let s_padded = format!("{fx:#0width$}"); assert!(s_padded.len() >= width); assert_eq!(s.len() >= width, s == s_padded); assert_eq!(format!("{fx:#0width$?}"), s_padded); assert_eq!(T::from_string_base(base, &s).unwrap(), x); assert!(string_is_subset( &s_padded, "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" )); test_padding_signed(&s, &s_padded, width); }, ); signed_unsigned_pair_gen_var_6::().test_properties(|(x, width)| { assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, 10), width = width), format!("{x:0width$}") ); assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, 2), width = width), format!("{x:0width$b}") ); assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, 8), width = width), format!("{x:0width$o}") ); assert_eq!( format!("{:#0width$}", BaseFmtWrapper::new(x, 16), width = width), format!("{x:0width$X}") ); }); unsigned_pair_gen_var_9::().test_properties(|(width, base)| { let s = format!( "{:#0width$}", BaseFmtWrapper::new(T::ZERO, base), width = width ); assert_eq!(repeat_n('0', max(1, width)).collect::(), s); }); } #[test] fn to_string_base_upper_properties() { apply_fn_to_unsigneds!(to_string_base_upper_helper_unsigned); apply_fn_to_signeds!(to_string_base_upper_helper_signed); }