1 //! Low-level API generator. 2 //! 3 //! Uses either the optimized decimal algorithm, the optimized generic 4 //! algorithm, or the naive algorithm. 5 6 use crate::util::*; 7 8 /// Select the back-end. 9 #[cfg(feature = "table")] 10 use super::decimal::Decimal; 11 12 #[cfg(all(feature = "table", feature = "radix"))] 13 use super::generic::Generic; 14 15 #[cfg(not(feature = "table"))] 16 use super::naive::Naive; 17 18 // HELPERS 19 20 // Wrapper to facilitate calling a backend that writes iteratively to 21 // the end of the buffer. 22 #[cfg(any(not(feature = "table"), feature = "radix"))] 23 macro_rules! write_backwards { 24 ($value:ident, $radix:expr, $buffer:ident, $t:tt, $cb:ident) => ({ 25 // Create a temporary buffer, and copy into it. 26 // Way faster than reversing a buffer in-place. 27 // Need to ensure the buffer size is adequate for any radix, but 28 // small for the optimized decimal formatters. 29 debug_assert_radix!($radix); 30 let mut buffer: [u8; BUFFER_SIZE] = [b'0'; BUFFER_SIZE]; 31 let digits; 32 if cfg!(not(feature = "radix")) || $radix == 10 { 33 digits = &mut buffer[..$t::FORMATTED_SIZE_DECIMAL]; 34 } else { 35 digits = &mut buffer[..$t::FORMATTED_SIZE]; 36 } 37 38 // Write backwards to buffer and copy output to slice. 39 let offset = $value.$cb($radix, digits); 40 debug_assert!(offset <= digits.len()); 41 copy_to_dst($buffer, &unchecked_index!(digits[offset..])) 42 }); 43 } 44 45 #[cfg(all(feature = "table", not(feature = "radix")))] 46 pub(crate) trait Itoa: Decimal + UnsignedInteger 47 {} 48 49 #[cfg(all(feature = "table", feature = "radix"))] 50 pub(crate) trait Itoa: Decimal + Generic + UnsignedInteger 51 {} 52 53 #[cfg(not(feature = "table"))] 54 pub(crate) trait Itoa: Naive + UnsignedInteger 55 {} 56 57 macro_rules! itoa_impl { 58 ($($t:ty)*) => ($( 59 impl Itoa for $t {} 60 )*) 61 } 62 63 itoa_impl! { u8 u16 u32 u64 u128 usize } 64 65 // FORWARD 66 67 // Forward itoa arguments to an optimized backend. 68 // Preconditions: `value` must be non-negative and unsigned. 69 perftools_inline!{ 70 #[cfg(all(feature = "table", not(feature = "radix")))] 71 pub(crate) fn itoa_positive<T>(value: T, _: u32, buffer: &mut [u8]) 72 -> usize 73 where T: Itoa 74 { 75 value.decimal(buffer) 76 }} 77 78 // Forward itoa arguments to an optimized backend. 79 // Preconditions: `value` must be non-negative and unsigned. 80 perftools_inline!{ 81 #[cfg(all(feature = "table", feature = "radix"))] 82 pub(crate) fn itoa_positive<T>(value: T, radix: u32, buffer: &mut [u8]) 83 -> usize 84 where T: Itoa 85 { 86 if radix == 10 { 87 value.decimal(buffer) 88 } else { 89 write_backwards!(value, radix, buffer, T, generic) 90 } 91 }} 92 93 // Forward itoa arguments to a naive backend. 94 // Preconditions: `value` must be non-negative and unsigned. 95 perftools_inline!{ 96 #[cfg(not(feature = "table"))] 97 pub(crate) fn itoa_positive<T>(value: T, radix: u32, buffer: &mut [u8]) 98 -> usize 99 where T: Itoa 100 { 101 write_backwards!(value, radix, buffer, T, naive) 102 }} 103 104 // TO LEXICAL 105 106 // Callback for unsigned integer formatter. 107 perftools_inline!{ 108 fn unsigned<Narrow, Wide>(value: Narrow, radix: u32, buffer: &mut [u8]) 109 -> usize 110 where Narrow: UnsignedInteger, 111 Wide: Itoa 112 { 113 let value: Wide = as_cast(value); 114 itoa_positive(value, radix, buffer) 115 }} 116 117 macro_rules! unsigned_to_lexical { 118 ($narrow:ty, $wide:ty) => ( 119 to_lexical!(unsigned::<$narrow, $wide>, $narrow); 120 ); 121 } 122 123 unsigned_to_lexical!(u8, u32); 124 unsigned_to_lexical!(u16, u32); 125 unsigned_to_lexical!(u32, u32); 126 unsigned_to_lexical!(u64, u64); 127 unsigned_to_lexical!(u128, u128); 128 129 #[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))] 130 unsigned_to_lexical!(usize, u32); 131 132 #[cfg(target_pointer_width = "64")] 133 unsigned_to_lexical!(usize, u64); 134 135 // Callback for signed integer formatter. 136 perftools_inline!{ 137 fn signed<Narrow, Wide, Unsigned>(value: Narrow, radix: u32, buffer: &mut [u8]) 138 -> usize 139 where Narrow: SignedInteger, 140 Wide: SignedInteger, 141 Unsigned: Itoa 142 { 143 if value < Narrow::ZERO { 144 unchecked_index_mut!(buffer[0] = b'-'); 145 let value: Wide = as_cast(value); 146 let value: Unsigned = as_cast(value.wrapping_neg()); 147 itoa_positive(value, radix, &mut unchecked_index_mut!(buffer[1..])) + 1 148 } else { 149 let value: Unsigned = as_cast(value); 150 itoa_positive(value, radix, buffer) 151 } 152 }} 153 154 macro_rules! signed_to_lexical { 155 ($narrow:ty, $wide:ty, $unsigned:ty) => ( 156 to_lexical!(signed::<$narrow, $wide, $unsigned>, $narrow); 157 ); 158 } 159 160 signed_to_lexical!(i8, i32, u32); 161 signed_to_lexical!(i16, i32, u32); 162 signed_to_lexical!(i32, i32, u32); 163 signed_to_lexical!(i64, i64, u64); 164 signed_to_lexical!(i128, i128, u128); 165 166 #[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))] 167 signed_to_lexical!(isize, i32, u32); 168 169 #[cfg(target_pointer_width = "64")] 170 signed_to_lexical!(isize, i64, u64); 171 172 // TESTS 173 // ----- 174 175 #[cfg(test)] 176 mod tests { 177 // Shouldn't need to include atoi, should be fine with ToLexical in scope. 178 use crate::util::*; 179 use crate::util::test::*; 180 181 #[cfg(feature = "property_tests")] 182 use quickcheck::quickcheck; 183 #[cfg(all(feature = "std", feature = "property_tests"))] 184 use proptest::proptest; 185 186 // GENERIC 187 188 #[test] u8_test()189 fn u8_test() { 190 let mut buffer = new_buffer(); 191 assert_eq!(b"0", 0u8.to_lexical(&mut buffer)); 192 assert_eq!(b"1", 1u8.to_lexical(&mut buffer)); 193 assert_eq!(b"5", 5u8.to_lexical(&mut buffer)); 194 assert_eq!(b"127", 127u8.to_lexical(&mut buffer)); 195 assert_eq!(b"128", 128u8.to_lexical(&mut buffer)); 196 assert_eq!(b"255", 255u8.to_lexical(&mut buffer)); 197 assert_eq!(b"255", (-1i8 as u8).to_lexical(&mut buffer)); 198 } 199 200 #[test] i8_test()201 fn i8_test() { 202 let mut buffer = new_buffer(); 203 assert_eq!(b"0", 0i8.to_lexical(&mut buffer)); 204 assert_eq!(b"1", 1i8.to_lexical(&mut buffer)); 205 assert_eq!(b"5", 5i8.to_lexical(&mut buffer)); 206 assert_eq!(b"127", 127i8.to_lexical(&mut buffer)); 207 assert_eq!(b"-128", (128u8 as i8).to_lexical(&mut buffer)); 208 assert_eq!(b"-1", (255u8 as i8).to_lexical(&mut buffer)); 209 assert_eq!(b"-1", (-1i8).to_lexical(&mut buffer)); 210 } 211 212 #[test] u16_test()213 fn u16_test() { 214 let mut buffer = new_buffer(); 215 assert_eq!(b"0", 0u16.to_lexical(&mut buffer)); 216 assert_eq!(b"1", 1u16.to_lexical(&mut buffer)); 217 assert_eq!(b"5", 5u16.to_lexical(&mut buffer)); 218 assert_eq!(b"32767", 32767u16.to_lexical(&mut buffer)); 219 assert_eq!(b"32768", 32768u16.to_lexical(&mut buffer)); 220 assert_eq!(b"65535", 65535u16.to_lexical(&mut buffer)); 221 assert_eq!(b"65535", (-1i16 as u16).to_lexical(&mut buffer)); 222 } 223 224 #[test] i16_test()225 fn i16_test() { 226 let mut buffer = new_buffer(); 227 assert_eq!(b"0", 0i16.to_lexical(&mut buffer)); 228 assert_eq!(b"1", 1i16.to_lexical(&mut buffer)); 229 assert_eq!(b"5", 5i16.to_lexical(&mut buffer)); 230 assert_eq!(b"32767", 32767i16.to_lexical(&mut buffer)); 231 assert_eq!(b"-32768", (32768u16 as i16).to_lexical(&mut buffer)); 232 assert_eq!(b"-1", (65535u16 as i16).to_lexical(&mut buffer)); 233 assert_eq!(b"-1", (-1i16).to_lexical(&mut buffer)); 234 } 235 236 #[test] u32_test()237 fn u32_test() { 238 let mut buffer = new_buffer(); 239 assert_eq!(b"0", 0u32.to_lexical(&mut buffer)); 240 assert_eq!(b"1", 1u32.to_lexical(&mut buffer)); 241 assert_eq!(b"5", 5u32.to_lexical(&mut buffer)); 242 assert_eq!(b"2147483647", 2147483647u32.to_lexical(&mut buffer)); 243 assert_eq!(b"2147483648", 2147483648u32.to_lexical(&mut buffer)); 244 assert_eq!(b"4294967295", 4294967295u32.to_lexical(&mut buffer)); 245 assert_eq!(b"4294967295", (-1i32 as u32).to_lexical(&mut buffer)); 246 } 247 248 #[test] i32_test()249 fn i32_test() { 250 let mut buffer = new_buffer(); 251 assert_eq!(b"0", 0i32.to_lexical(&mut buffer)); 252 assert_eq!(b"1", 1i32.to_lexical(&mut buffer)); 253 assert_eq!(b"5", 5i32.to_lexical(&mut buffer)); 254 assert_eq!(b"2147483647", 2147483647i32.to_lexical(&mut buffer)); 255 assert_eq!(b"-2147483648", (2147483648u32 as i32).to_lexical(&mut buffer)); 256 assert_eq!(b"-1", (4294967295u32 as i32).to_lexical(&mut buffer)); 257 assert_eq!(b"-1", (-1i32).to_lexical(&mut buffer)); 258 } 259 260 #[test] u64_test()261 fn u64_test() { 262 let mut buffer = new_buffer(); 263 assert_eq!(b"0", 0u64.to_lexical(&mut buffer)); 264 assert_eq!(b"1", 1u64.to_lexical(&mut buffer)); 265 assert_eq!(b"5", 5u64.to_lexical(&mut buffer)); 266 assert_eq!(b"9223372036854775807", 9223372036854775807u64.to_lexical(&mut buffer)); 267 assert_eq!(b"9223372036854775808", 9223372036854775808u64.to_lexical(&mut buffer)); 268 assert_eq!(b"18446744073709551615", 18446744073709551615u64.to_lexical(&mut buffer)); 269 assert_eq!(b"18446744073709551615", (-1i64 as u64).to_lexical(&mut buffer)); 270 } 271 272 #[test] i64_test()273 fn i64_test() { 274 let mut buffer = new_buffer(); 275 assert_eq!(b"0", 0i64.to_lexical(&mut buffer)); 276 assert_eq!(b"1", 1i64.to_lexical(&mut buffer)); 277 assert_eq!(b"5", 5i64.to_lexical(&mut buffer)); 278 assert_eq!(b"9223372036854775807", 9223372036854775807i64.to_lexical(&mut buffer)); 279 assert_eq!(b"-9223372036854775808", (9223372036854775808u64 as i64).to_lexical(&mut buffer)); 280 assert_eq!(b"-1", (18446744073709551615u64 as i64).to_lexical(&mut buffer)); 281 assert_eq!(b"-1", (-1i64).to_lexical(&mut buffer)); 282 } 283 284 #[test] u128_test()285 fn u128_test() { 286 let mut buffer = new_buffer(); 287 assert_eq!(b"0", 0u128.to_lexical(&mut buffer)); 288 assert_eq!(b"1", 1u128.to_lexical(&mut buffer)); 289 assert_eq!(b"5", 5u128.to_lexical(&mut buffer)); 290 assert_eq!(&b"170141183460469231731687303715884105727"[..], 170141183460469231731687303715884105727u128.to_lexical(&mut buffer)); 291 assert_eq!(&b"170141183460469231731687303715884105728"[..], 170141183460469231731687303715884105728u128.to_lexical(&mut buffer)); 292 assert_eq!(&b"340282366920938463463374607431768211455"[..], 340282366920938463463374607431768211455u128.to_lexical(&mut buffer)); 293 assert_eq!(&b"340282366920938463463374607431768211455"[..], (-1i128 as u128).to_lexical(&mut buffer)); 294 } 295 296 #[test] i128_test()297 fn i128_test() { 298 let mut buffer = new_buffer(); 299 assert_eq!(b"0", 0i128.to_lexical(&mut buffer)); 300 assert_eq!(b"1", 1i128.to_lexical(&mut buffer)); 301 assert_eq!(b"5", 5i128.to_lexical(&mut buffer)); 302 assert_eq!(&b"170141183460469231731687303715884105727"[..], 170141183460469231731687303715884105727i128.to_lexical(&mut buffer)); 303 assert_eq!(&b"-170141183460469231731687303715884105728"[..], (170141183460469231731687303715884105728u128 as i128).to_lexical(&mut buffer)); 304 assert_eq!(b"-1", (340282366920938463463374607431768211455u128 as i128).to_lexical(&mut buffer)); 305 assert_eq!(b"-1", (-1i128).to_lexical(&mut buffer)); 306 } 307 308 #[cfg(feature = "radix")] 309 #[test] radix_test()310 fn radix_test() { 311 let data = [ 312 (2, "100101"), 313 (3, "1101"), 314 (4, "211"), 315 (5, "122"), 316 (6, "101"), 317 (7, "52"), 318 (8, "45"), 319 (9, "41"), 320 (10, "37"), 321 (11, "34"), 322 (12, "31"), 323 (13, "2B"), 324 (14, "29"), 325 (15, "27"), 326 (16, "25"), 327 (17, "23"), 328 (18, "21"), 329 (19, "1I"), 330 (20, "1H"), 331 (21, "1G"), 332 (22, "1F"), 333 (23, "1E"), 334 (24, "1D"), 335 (25, "1C"), 336 (26, "1B"), 337 (27, "1A"), 338 (28, "19"), 339 (29, "18"), 340 (30, "17"), 341 (31, "16"), 342 (32, "15"), 343 (33, "14"), 344 (34, "13"), 345 (35, "12"), 346 (36, "11"), 347 ]; 348 349 let mut buffer = new_buffer(); 350 for (base, expected) in data.iter() { 351 assert_eq!(expected.as_bytes(), 37.to_lexical_radix(*base, &mut buffer)); 352 } 353 } 354 355 // Extensive tests 356 357 #[test] u8_pow2_test()358 fn u8_pow2_test() { 359 let mut buffer = new_buffer(); 360 let values: &[u8] = &[0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 127, 128, 129, 255]; 361 for &i in values.iter() { 362 assert_eq!(i, u8::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 363 } 364 } 365 366 #[test] u8_pow10_test()367 fn u8_pow10_test() { 368 let mut buffer = new_buffer(); 369 let values: &[u8] = &[0, 1, 5, 9, 10, 11, 15, 99, 100, 101, 105]; 370 for &i in values.iter() { 371 assert_eq!(i, u8::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 372 } 373 } 374 375 #[test] u16_pow2_test()376 fn u16_pow2_test() { 377 let mut buffer = new_buffer(); 378 let values: &[u16] = &[0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 127, 128, 129, 255, 256, 257, 511, 512, 513, 1023, 1024, 1025, 2047, 2048, 2049, 4095, 4096, 4097, 8191, 8192, 8193, 16383, 16384, 16385, 32767, 32768, 32769, 65535]; 379 for &i in values.iter() { 380 assert_eq!(i, u16::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 381 } 382 } 383 384 #[test] u16_pow10_test()385 fn u16_pow10_test() { 386 let mut buffer = new_buffer(); 387 let values: &[u16] = &[0, 1, 5, 9, 10, 11, 15, 99, 100, 101, 105, 999, 1000, 1001, 1005, 9999, 10000, 10001, 10005]; 388 for &i in values.iter() { 389 assert_eq!(i, u16::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 390 } 391 } 392 393 #[test] u32_pow2_test()394 fn u32_pow2_test() { 395 let mut buffer = new_buffer(); 396 let values: &[u32] = &[0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 127, 128, 129, 255, 256, 257, 511, 512, 513, 1023, 1024, 1025, 2047, 2048, 2049, 4095, 4096, 4097, 8191, 8192, 8193, 16383, 16384, 16385, 32767, 32768, 32769, 65535, 65536, 65537, 131071, 131072, 131073, 262143, 262144, 262145, 524287, 524288, 524289, 1048575, 1048576, 1048577, 2097151, 2097152, 2097153, 4194303, 4194304, 4194305, 8388607, 8388608, 8388609, 16777215, 16777216, 16777217, 33554431, 33554432, 33554433, 67108863, 67108864, 67108865, 134217727, 134217728, 134217729, 268435455, 268435456, 268435457, 536870911, 536870912, 536870913, 1073741823, 1073741824, 1073741825, 2147483647, 2147483648, 2147483649, 4294967295]; 397 for &i in values.iter() { 398 assert_eq!(i, u32::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 399 } 400 } 401 402 #[test] u32_pow10_test()403 fn u32_pow10_test() { 404 let mut buffer = new_buffer(); 405 let values: &[u32] = &[0, 1, 5, 9, 10, 11, 15, 99, 100, 101, 105, 999, 1000, 1001, 1005, 9999, 10000, 10001, 10005, 99999, 100000, 100001, 100005, 999999, 1000000, 1000001, 1000005, 9999999, 10000000, 10000001, 10000005, 99999999, 100000000, 100000001, 100000005, 999999999, 1000000000, 1000000001, 1000000005]; 406 for &i in values.iter() { 407 assert_eq!(i, u32::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 408 } 409 } 410 411 #[test] u64_pow2_test()412 fn u64_pow2_test() { 413 let mut buffer = new_buffer(); 414 let values: &[u64] = &[0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 127, 128, 129, 255, 256, 257, 511, 512, 513, 1023, 1024, 1025, 2047, 2048, 2049, 4095, 4096, 4097, 8191, 8192, 8193, 16383, 16384, 16385, 32767, 32768, 32769, 65535, 65536, 65537, 131071, 131072, 131073, 262143, 262144, 262145, 524287, 524288, 524289, 1048575, 1048576, 1048577, 2097151, 2097152, 2097153, 4194303, 4194304, 4194305, 8388607, 8388608, 8388609, 16777215, 16777216, 16777217, 33554431, 33554432, 33554433, 67108863, 67108864, 67108865, 134217727, 134217728, 134217729, 268435455, 268435456, 268435457, 536870911, 536870912, 536870913, 1073741823, 1073741824, 1073741825, 2147483647, 2147483648, 2147483649, 4294967295, 4294967296, 4294967297, 8589934591, 8589934592, 8589934593, 17179869183, 17179869184, 17179869185, 34359738367, 34359738368, 34359738369, 68719476735, 68719476736, 68719476737, 137438953471, 137438953472, 137438953473, 274877906943, 274877906944, 274877906945, 549755813887, 549755813888, 549755813889, 1099511627775, 1099511627776, 1099511627777, 2199023255551, 2199023255552, 2199023255553, 4398046511103, 4398046511104, 4398046511105, 8796093022207, 8796093022208, 8796093022209, 17592186044415, 17592186044416, 17592186044417, 35184372088831, 35184372088832, 35184372088833, 70368744177663, 70368744177664, 70368744177665, 140737488355327, 140737488355328, 140737488355329, 281474976710655, 281474976710656, 281474976710657, 562949953421311, 562949953421312, 562949953421313, 1125899906842623, 1125899906842624, 1125899906842625, 2251799813685247, 2251799813685248, 2251799813685249, 4503599627370495, 4503599627370496, 4503599627370497, 9007199254740991, 9007199254740992, 9007199254740993, 18014398509481983, 18014398509481984, 18014398509481985, 36028797018963967, 36028797018963968, 36028797018963969, 72057594037927935, 72057594037927936, 72057594037927937, 144115188075855871, 144115188075855872, 144115188075855873, 288230376151711743, 288230376151711744, 288230376151711745, 576460752303423487, 576460752303423488, 576460752303423489, 1152921504606846975, 1152921504606846976, 1152921504606846977, 2305843009213693951, 2305843009213693952, 2305843009213693953, 4611686018427387903, 4611686018427387904, 4611686018427387905, 9223372036854775807, 9223372036854775808, 9223372036854775809, 18446744073709551615]; 415 for &i in values.iter() { 416 assert_eq!(i, u64::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 417 } 418 } 419 420 #[test] u64_pow10_test()421 fn u64_pow10_test() { 422 let mut buffer = new_buffer(); 423 let values: &[u64] = &[0, 1, 5, 9, 10, 11, 15, 99, 100, 101, 105, 999, 1000, 1001, 1005, 9999, 10000, 10001, 10005, 99999, 100000, 100001, 100005, 999999, 1000000, 1000001, 1000005, 9999999, 10000000, 10000001, 10000005, 99999999, 100000000, 100000001, 100000005, 999999999, 1000000000, 1000000001, 1000000005, 9999999999, 10000000000, 10000000001, 10000000005, 99999999999, 100000000000, 100000000001, 100000000005, 999999999999, 1000000000000, 1000000000001, 1000000000005, 9999999999999, 10000000000000, 10000000000001, 10000000000005, 99999999999999, 100000000000000, 100000000000001, 100000000000005, 999999999999999, 1000000000000000, 1000000000000001, 1000000000000005, 9999999999999999, 10000000000000000, 10000000000000001, 10000000000000005, 99999999999999999, 100000000000000000, 100000000000000001, 100000000000000005, 999999999999999999, 1000000000000000000, 1000000000000000001, 1000000000000000005]; 424 for &i in values.iter() { 425 assert_eq!(i, u64::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 426 } 427 } 428 429 #[test] u128_pow2_test()430 fn u128_pow2_test() { 431 let mut buffer = new_buffer(); 432 let values: &[u128] = &[0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 127, 128, 129, 255, 256, 257, 511, 512, 513, 1023, 1024, 1025, 2047, 2048, 2049, 4095, 4096, 4097, 8191, 8192, 8193, 16383, 16384, 16385, 32767, 32768, 32769, 65535, 65536, 65537, 131071, 131072, 131073, 262143, 262144, 262145, 524287, 524288, 524289, 1048575, 1048576, 1048577, 2097151, 2097152, 2097153, 4194303, 4194304, 4194305, 8388607, 8388608, 8388609, 16777215, 16777216, 16777217, 33554431, 33554432, 33554433, 67108863, 67108864, 67108865, 134217727, 134217728, 134217729, 268435455, 268435456, 268435457, 536870911, 536870912, 536870913, 1073741823, 1073741824, 1073741825, 2147483647, 2147483648, 2147483649, 4294967295, 4294967296, 4294967297, 8589934591, 8589934592, 8589934593, 17179869183, 17179869184, 17179869185, 34359738367, 34359738368, 34359738369, 68719476735, 68719476736, 68719476737, 137438953471, 137438953472, 137438953473, 274877906943, 274877906944, 274877906945, 549755813887, 549755813888, 549755813889, 1099511627775, 1099511627776, 1099511627777, 2199023255551, 2199023255552, 2199023255553, 4398046511103, 4398046511104, 4398046511105, 8796093022207, 8796093022208, 8796093022209, 17592186044415, 17592186044416, 17592186044417, 35184372088831, 35184372088832, 35184372088833, 70368744177663, 70368744177664, 70368744177665, 140737488355327, 140737488355328, 140737488355329, 281474976710655, 281474976710656, 281474976710657, 562949953421311, 562949953421312, 562949953421313, 1125899906842623, 1125899906842624, 1125899906842625, 2251799813685247, 2251799813685248, 2251799813685249, 4503599627370495, 4503599627370496, 4503599627370497, 9007199254740991, 9007199254740992, 9007199254740993, 18014398509481983, 18014398509481984, 18014398509481985, 36028797018963967, 36028797018963968, 36028797018963969, 72057594037927935, 72057594037927936, 72057594037927937, 144115188075855871, 144115188075855872, 144115188075855873, 288230376151711743, 288230376151711744, 288230376151711745, 576460752303423487, 576460752303423488, 576460752303423489, 1152921504606846975, 1152921504606846976, 1152921504606846977, 2305843009213693951, 2305843009213693952, 2305843009213693953, 4611686018427387903, 4611686018427387904, 4611686018427387905, 9223372036854775807, 9223372036854775808, 9223372036854775809, 18446744073709551615, 18446744073709551616, 18446744073709551617, 36893488147419103231, 36893488147419103232, 36893488147419103233, 73786976294838206463, 73786976294838206464, 73786976294838206465, 147573952589676412927, 147573952589676412928, 147573952589676412929, 295147905179352825855, 295147905179352825856, 295147905179352825857, 590295810358705651711, 590295810358705651712, 590295810358705651713, 1180591620717411303423, 1180591620717411303424, 1180591620717411303425, 2361183241434822606847, 2361183241434822606848, 2361183241434822606849, 4722366482869645213695, 4722366482869645213696, 4722366482869645213697, 9444732965739290427391, 9444732965739290427392, 9444732965739290427393, 18889465931478580854783, 18889465931478580854784, 18889465931478580854785, 37778931862957161709567, 37778931862957161709568, 37778931862957161709569, 75557863725914323419135, 75557863725914323419136, 75557863725914323419137, 151115727451828646838271, 151115727451828646838272, 151115727451828646838273, 302231454903657293676543, 302231454903657293676544, 302231454903657293676545, 604462909807314587353087, 604462909807314587353088, 604462909807314587353089, 1208925819614629174706175, 1208925819614629174706176, 1208925819614629174706177, 2417851639229258349412351, 2417851639229258349412352, 2417851639229258349412353, 4835703278458516698824703, 4835703278458516698824704, 4835703278458516698824705, 9671406556917033397649407, 9671406556917033397649408, 9671406556917033397649409, 19342813113834066795298815, 19342813113834066795298816, 19342813113834066795298817, 38685626227668133590597631, 38685626227668133590597632, 38685626227668133590597633, 77371252455336267181195263, 77371252455336267181195264, 77371252455336267181195265, 154742504910672534362390527, 154742504910672534362390528, 154742504910672534362390529, 309485009821345068724781055, 309485009821345068724781056, 309485009821345068724781057, 618970019642690137449562111, 618970019642690137449562112, 618970019642690137449562113, 1237940039285380274899124223, 1237940039285380274899124224, 1237940039285380274899124225, 2475880078570760549798248447, 2475880078570760549798248448, 2475880078570760549798248449, 4951760157141521099596496895, 4951760157141521099596496896, 4951760157141521099596496897, 9903520314283042199192993791, 9903520314283042199192993792, 9903520314283042199192993793, 19807040628566084398385987583, 19807040628566084398385987584, 19807040628566084398385987585, 39614081257132168796771975167, 39614081257132168796771975168, 39614081257132168796771975169, 79228162514264337593543950335, 79228162514264337593543950336, 79228162514264337593543950337, 158456325028528675187087900671, 158456325028528675187087900672, 158456325028528675187087900673, 316912650057057350374175801343, 316912650057057350374175801344, 316912650057057350374175801345, 633825300114114700748351602687, 633825300114114700748351602688, 633825300114114700748351602689, 1267650600228229401496703205375, 1267650600228229401496703205376, 1267650600228229401496703205377, 2535301200456458802993406410751, 2535301200456458802993406410752, 2535301200456458802993406410753, 5070602400912917605986812821503, 5070602400912917605986812821504, 5070602400912917605986812821505, 10141204801825835211973625643007, 10141204801825835211973625643008, 10141204801825835211973625643009, 20282409603651670423947251286015, 20282409603651670423947251286016, 20282409603651670423947251286017, 40564819207303340847894502572031, 40564819207303340847894502572032, 40564819207303340847894502572033, 81129638414606681695789005144063, 81129638414606681695789005144064, 81129638414606681695789005144065, 162259276829213363391578010288127, 162259276829213363391578010288128, 162259276829213363391578010288129, 324518553658426726783156020576255, 324518553658426726783156020576256, 324518553658426726783156020576257, 649037107316853453566312041152511, 649037107316853453566312041152512, 649037107316853453566312041152513, 1298074214633706907132624082305023, 1298074214633706907132624082305024, 1298074214633706907132624082305025, 2596148429267413814265248164610047, 2596148429267413814265248164610048, 2596148429267413814265248164610049, 5192296858534827628530496329220095, 5192296858534827628530496329220096, 5192296858534827628530496329220097, 10384593717069655257060992658440191, 10384593717069655257060992658440192, 10384593717069655257060992658440193, 20769187434139310514121985316880383, 20769187434139310514121985316880384, 20769187434139310514121985316880385, 41538374868278621028243970633760767, 41538374868278621028243970633760768, 41538374868278621028243970633760769, 83076749736557242056487941267521535, 83076749736557242056487941267521536, 83076749736557242056487941267521537, 166153499473114484112975882535043071, 166153499473114484112975882535043072, 166153499473114484112975882535043073, 332306998946228968225951765070086143, 332306998946228968225951765070086144, 332306998946228968225951765070086145, 664613997892457936451903530140172287, 664613997892457936451903530140172288, 664613997892457936451903530140172289, 1329227995784915872903807060280344575, 1329227995784915872903807060280344576, 1329227995784915872903807060280344577, 2658455991569831745807614120560689151, 2658455991569831745807614120560689152, 2658455991569831745807614120560689153, 5316911983139663491615228241121378303, 5316911983139663491615228241121378304, 5316911983139663491615228241121378305, 10633823966279326983230456482242756607, 10633823966279326983230456482242756608, 10633823966279326983230456482242756609, 21267647932558653966460912964485513215, 21267647932558653966460912964485513216, 21267647932558653966460912964485513217, 42535295865117307932921825928971026431, 42535295865117307932921825928971026432, 42535295865117307932921825928971026433, 85070591730234615865843651857942052863, 85070591730234615865843651857942052864, 85070591730234615865843651857942052865, 170141183460469231731687303715884105727, 170141183460469231731687303715884105728, 170141183460469231731687303715884105729, 340282366920938463463374607431768211455]; 433 for &i in values.iter() { 434 assert_eq!(i, u128::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 435 } 436 } 437 438 #[test] u128_pow10_test()439 fn u128_pow10_test() { 440 let mut buffer = new_buffer(); 441 let values: &[u128] = &[0, 1, 5, 9, 10, 11, 15, 99, 100, 101, 105, 999, 1000, 1001, 1005, 9999, 10000, 10001, 10005, 99999, 100000, 100001, 100005, 999999, 1000000, 1000001, 1000005, 9999999, 10000000, 10000001, 10000005, 99999999, 100000000, 100000001, 100000005, 999999999, 1000000000, 1000000001, 1000000005, 9999999999, 10000000000, 10000000001, 10000000005, 99999999999, 100000000000, 100000000001, 100000000005, 999999999999, 1000000000000, 1000000000001, 1000000000005, 9999999999999, 10000000000000, 10000000000001, 10000000000005, 99999999999999, 100000000000000, 100000000000001, 100000000000005, 999999999999999, 1000000000000000, 1000000000000001, 1000000000000005, 9999999999999999, 10000000000000000, 10000000000000001, 10000000000000005, 99999999999999999, 100000000000000000, 100000000000000001, 100000000000000005, 999999999999999999, 1000000000000000000, 1000000000000000001, 1000000000000000005, 9999999999999999999, 10000000000000000000, 10000000000000000001, 10000000000000000005, 99999999999999999999, 100000000000000000000, 100000000000000000001, 100000000000000000005, 999999999999999999999, 1000000000000000000000, 1000000000000000000001, 1000000000000000000005, 9999999999999999999999, 10000000000000000000000, 10000000000000000000001, 10000000000000000000005, 99999999999999999999999, 100000000000000000000000, 100000000000000000000001, 100000000000000000000005, 999999999999999999999999, 1000000000000000000000000, 1000000000000000000000001, 1000000000000000000000005, 9999999999999999999999999, 10000000000000000000000000, 10000000000000000000000001, 10000000000000000000000005, 99999999999999999999999999, 100000000000000000000000000, 100000000000000000000000001, 100000000000000000000000005, 999999999999999999999999999, 1000000000000000000000000000, 1000000000000000000000000001, 1000000000000000000000000005, 9999999999999999999999999999, 10000000000000000000000000000, 10000000000000000000000000001, 10000000000000000000000000005, 99999999999999999999999999999, 100000000000000000000000000000, 100000000000000000000000000001, 100000000000000000000000000005, 999999999999999999999999999999, 1000000000000000000000000000000, 1000000000000000000000000000001, 1000000000000000000000000000005, 9999999999999999999999999999999, 10000000000000000000000000000000, 10000000000000000000000000000001, 10000000000000000000000000000005, 99999999999999999999999999999999, 100000000000000000000000000000000, 100000000000000000000000000000001, 100000000000000000000000000000005, 999999999999999999999999999999999, 1000000000000000000000000000000000, 1000000000000000000000000000000001, 1000000000000000000000000000000005, 9999999999999999999999999999999999, 10000000000000000000000000000000000, 10000000000000000000000000000000001, 10000000000000000000000000000000005, 99999999999999999999999999999999999, 100000000000000000000000000000000000, 100000000000000000000000000000000001, 100000000000000000000000000000000005, 999999999999999999999999999999999999, 1000000000000000000000000000000000000, 1000000000000000000000000000000000001, 1000000000000000000000000000000000005, 9999999999999999999999999999999999999, 10000000000000000000000000000000000000, 10000000000000000000000000000000000001, 10000000000000000000000000000000000005, 99999999999999999999999999999999999999, 100000000000000000000000000000000000000, 100000000000000000000000000000000000001, 100000000000000000000000000000000000005]; 442 for &i in values.iter() { 443 assert_eq!(i, u128::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 444 } 445 } 446 447 // Quickcheck 448 449 #[cfg(feature = "property_tests")] 450 quickcheck! { 451 fn u8_quickcheck(i: u8) -> bool { 452 let mut buffer = new_buffer(); 453 i == u8::from_lexical(i.to_lexical(&mut buffer)).unwrap() 454 } 455 456 fn u16_quickcheck(i: u16) -> bool { 457 let mut buffer = new_buffer(); 458 i == u16::from_lexical(i.to_lexical(&mut buffer)).unwrap() 459 } 460 461 fn u32_quickcheck(i: u32) -> bool { 462 let mut buffer = new_buffer(); 463 i == u32::from_lexical(i.to_lexical(&mut buffer)).unwrap() 464 } 465 466 fn u64_quickcheck(i: u64) -> bool { 467 let mut buffer = new_buffer(); 468 i == u64::from_lexical(i.to_lexical(&mut buffer)).unwrap() 469 } 470 471 fn u128_quickcheck(i: u128) -> bool { 472 let mut buffer = new_buffer(); 473 i == u128::from_lexical(i.to_lexical(&mut buffer)).unwrap() 474 } 475 476 fn usize_quickcheck(i: usize) -> bool { 477 let mut buffer = new_buffer(); 478 i == usize::from_lexical(i.to_lexical(&mut buffer)).unwrap() 479 } 480 481 fn i8_quickcheck(i: i8) -> bool { 482 let mut buffer = new_buffer(); 483 i == i8::from_lexical(i.to_lexical(&mut buffer)).unwrap() 484 } 485 486 fn i16_quickcheck(i: i16) -> bool { 487 let mut buffer = new_buffer(); 488 i == i16::from_lexical(i.to_lexical(&mut buffer)).unwrap() 489 } 490 491 fn i32_quickcheck(i: i32) -> bool { 492 let mut buffer = new_buffer(); 493 i == i32::from_lexical(i.to_lexical(&mut buffer)).unwrap() 494 } 495 496 fn i64_quickcheck(i: i64) -> bool { 497 let mut buffer = new_buffer(); 498 i == i64::from_lexical(i.to_lexical(&mut buffer)).unwrap() 499 } 500 501 fn i128_quickcheck(i: i128) -> bool { 502 let mut buffer = new_buffer(); 503 i == i128::from_lexical(i.to_lexical(&mut buffer)).unwrap() 504 } 505 506 fn isize_quickcheck(i: isize) -> bool { 507 let mut buffer = new_buffer(); 508 i == isize::from_lexical(i.to_lexical(&mut buffer)).unwrap() 509 } 510 } 511 512 // Proptest 513 514 #[cfg(all(feature = "std", feature = "property_tests"))] 515 proptest! { 516 #[test] 517 fn u8_proptest(i in u8::min_value()..u8::max_value()) { 518 let mut buffer = new_buffer(); 519 assert_eq!(i, u8::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 520 } 521 522 #[test] 523 fn i8_proptest(i in i8::min_value()..i8::max_value()) { 524 let mut buffer = new_buffer(); 525 assert_eq!(i, i8::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 526 } 527 528 #[test] 529 fn u16_proptest(i in u16::min_value()..u16::max_value()) { 530 let mut buffer = new_buffer(); 531 assert_eq!(i, u16::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 532 } 533 534 #[test] 535 fn i16_proptest(i in i16::min_value()..i16::max_value()) { 536 let mut buffer = new_buffer(); 537 assert_eq!(i, i16::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 538 } 539 540 #[test] 541 fn u32_proptest(i in u32::min_value()..u32::max_value()) { 542 let mut buffer = new_buffer(); 543 assert_eq!(i, u32::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 544 } 545 546 #[test] 547 fn i32_proptest(i in i32::min_value()..i32::max_value()) { 548 let mut buffer = new_buffer(); 549 assert_eq!(i, i32::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 550 } 551 552 #[test] 553 fn u64_proptest(i in u64::min_value()..u64::max_value()) { 554 let mut buffer = new_buffer(); 555 assert_eq!(i, u64::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 556 } 557 558 #[test] 559 fn i64_proptest(i in i64::min_value()..i64::max_value()) { 560 let mut buffer = new_buffer(); 561 assert_eq!(i, i64::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 562 } 563 564 #[test] 565 fn u128_proptest(i in u128::min_value()..u128::max_value()) { 566 let mut buffer = new_buffer(); 567 assert_eq!(i, u128::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 568 } 569 570 #[test] 571 fn i128_proptest(i in i128::min_value()..i128::max_value()) { 572 let mut buffer = new_buffer(); 573 assert_eq!(i, i128::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 574 } 575 576 #[test] 577 fn usize_proptest(i in usize::min_value()..usize::max_value()) { 578 let mut buffer = new_buffer(); 579 assert_eq!(i, usize::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 580 } 581 582 #[test] 583 fn isize_proptest(i in isize::min_value()..isize::max_value()) { 584 let mut buffer = new_buffer(); 585 assert_eq!(i, isize::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 586 } 587 } 588 589 // Panic tests 590 591 #[test] 592 #[should_panic] i8_buffer_test()593 fn i8_buffer_test() { 594 let mut buffer = [b'0'; i8::FORMATTED_SIZE_DECIMAL-1]; 595 12i8.to_lexical(&mut buffer); 596 } 597 598 #[test] 599 #[should_panic] i16_buffer_test()600 fn i16_buffer_test() { 601 let mut buffer = [b'0'; i16::FORMATTED_SIZE_DECIMAL-1]; 602 12i16.to_lexical(&mut buffer); 603 } 604 605 #[test] 606 #[should_panic] i32_buffer_test()607 fn i32_buffer_test() { 608 let mut buffer = [b'0'; i32::FORMATTED_SIZE_DECIMAL-1]; 609 12i32.to_lexical(&mut buffer); 610 } 611 612 #[test] 613 #[should_panic] i64_buffer_test()614 fn i64_buffer_test() { 615 let mut buffer = [b'0'; i64::FORMATTED_SIZE_DECIMAL-1]; 616 12i64.to_lexical(&mut buffer); 617 } 618 619 #[test] 620 #[should_panic] i128_buffer_test()621 fn i128_buffer_test() { 622 let mut buffer = [b'0'; i128::FORMATTED_SIZE_DECIMAL-1]; 623 12i128.to_lexical(&mut buffer); 624 } 625 626 #[test] 627 #[should_panic] isize_buffer_test()628 fn isize_buffer_test() { 629 let mut buffer = [b'0'; isize::FORMATTED_SIZE_DECIMAL-1]; 630 12isize.to_lexical(&mut buffer); 631 } 632 633 #[test] 634 #[should_panic] u8_buffer_test()635 fn u8_buffer_test() { 636 let mut buffer = [b'0'; u8::FORMATTED_SIZE_DECIMAL-1]; 637 12i8.to_lexical(&mut buffer); 638 } 639 640 #[test] 641 #[should_panic] u16_buffer_test()642 fn u16_buffer_test() { 643 let mut buffer = [b'0'; u16::FORMATTED_SIZE_DECIMAL-1]; 644 12i16.to_lexical(&mut buffer); 645 } 646 647 #[test] 648 #[should_panic] u32_buffer_test()649 fn u32_buffer_test() { 650 let mut buffer = [b'0'; u32::FORMATTED_SIZE_DECIMAL-1]; 651 12i32.to_lexical(&mut buffer); 652 } 653 654 #[test] 655 #[should_panic] u64_buffer_test()656 fn u64_buffer_test() { 657 let mut buffer = [b'0'; u64::FORMATTED_SIZE_DECIMAL-1]; 658 12i64.to_lexical(&mut buffer); 659 } 660 661 #[test] 662 #[should_panic] u128_buffer_test()663 fn u128_buffer_test() { 664 let mut buffer = [b'0'; u128::FORMATTED_SIZE_DECIMAL-1]; 665 12i128.to_lexical(&mut buffer); 666 } 667 668 #[test] 669 #[should_panic] usize_buffer_test()670 fn usize_buffer_test() { 671 let mut buffer = [b'0'; usize::FORMATTED_SIZE_DECIMAL-1]; 672 12usize.to_lexical(&mut buffer); 673 } 674 } 675