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 // GENERIC 182 183 #[test] u8_test()184 fn u8_test() { 185 let mut buffer = new_buffer(); 186 assert_eq!(b"0", 0u8.to_lexical(&mut buffer)); 187 assert_eq!(b"1", 1u8.to_lexical(&mut buffer)); 188 assert_eq!(b"5", 5u8.to_lexical(&mut buffer)); 189 assert_eq!(b"127", 127u8.to_lexical(&mut buffer)); 190 assert_eq!(b"128", 128u8.to_lexical(&mut buffer)); 191 assert_eq!(b"255", 255u8.to_lexical(&mut buffer)); 192 assert_eq!(b"255", (-1i8 as u8).to_lexical(&mut buffer)); 193 } 194 195 #[test] i8_test()196 fn i8_test() { 197 let mut buffer = new_buffer(); 198 assert_eq!(b"0", 0i8.to_lexical(&mut buffer)); 199 assert_eq!(b"1", 1i8.to_lexical(&mut buffer)); 200 assert_eq!(b"5", 5i8.to_lexical(&mut buffer)); 201 assert_eq!(b"127", 127i8.to_lexical(&mut buffer)); 202 assert_eq!(b"-128", (128u8 as i8).to_lexical(&mut buffer)); 203 assert_eq!(b"-1", (255u8 as i8).to_lexical(&mut buffer)); 204 assert_eq!(b"-1", (-1i8).to_lexical(&mut buffer)); 205 } 206 207 #[test] u16_test()208 fn u16_test() { 209 let mut buffer = new_buffer(); 210 assert_eq!(b"0", 0u16.to_lexical(&mut buffer)); 211 assert_eq!(b"1", 1u16.to_lexical(&mut buffer)); 212 assert_eq!(b"5", 5u16.to_lexical(&mut buffer)); 213 assert_eq!(b"32767", 32767u16.to_lexical(&mut buffer)); 214 assert_eq!(b"32768", 32768u16.to_lexical(&mut buffer)); 215 assert_eq!(b"65535", 65535u16.to_lexical(&mut buffer)); 216 assert_eq!(b"65535", (-1i16 as u16).to_lexical(&mut buffer)); 217 } 218 219 #[test] i16_test()220 fn i16_test() { 221 let mut buffer = new_buffer(); 222 assert_eq!(b"0", 0i16.to_lexical(&mut buffer)); 223 assert_eq!(b"1", 1i16.to_lexical(&mut buffer)); 224 assert_eq!(b"5", 5i16.to_lexical(&mut buffer)); 225 assert_eq!(b"32767", 32767i16.to_lexical(&mut buffer)); 226 assert_eq!(b"-32768", (32768u16 as i16).to_lexical(&mut buffer)); 227 assert_eq!(b"-1", (65535u16 as i16).to_lexical(&mut buffer)); 228 assert_eq!(b"-1", (-1i16).to_lexical(&mut buffer)); 229 } 230 231 #[test] u32_test()232 fn u32_test() { 233 let mut buffer = new_buffer(); 234 assert_eq!(b"0", 0u32.to_lexical(&mut buffer)); 235 assert_eq!(b"1", 1u32.to_lexical(&mut buffer)); 236 assert_eq!(b"5", 5u32.to_lexical(&mut buffer)); 237 assert_eq!(b"2147483647", 2147483647u32.to_lexical(&mut buffer)); 238 assert_eq!(b"2147483648", 2147483648u32.to_lexical(&mut buffer)); 239 assert_eq!(b"4294967295", 4294967295u32.to_lexical(&mut buffer)); 240 assert_eq!(b"4294967295", (-1i32 as u32).to_lexical(&mut buffer)); 241 } 242 243 #[test] i32_test()244 fn i32_test() { 245 let mut buffer = new_buffer(); 246 assert_eq!(b"0", 0i32.to_lexical(&mut buffer)); 247 assert_eq!(b"1", 1i32.to_lexical(&mut buffer)); 248 assert_eq!(b"5", 5i32.to_lexical(&mut buffer)); 249 assert_eq!(b"2147483647", 2147483647i32.to_lexical(&mut buffer)); 250 assert_eq!(b"-2147483648", (2147483648u32 as i32).to_lexical(&mut buffer)); 251 assert_eq!(b"-1", (4294967295u32 as i32).to_lexical(&mut buffer)); 252 assert_eq!(b"-1", (-1i32).to_lexical(&mut buffer)); 253 } 254 255 #[test] u64_test()256 fn u64_test() { 257 let mut buffer = new_buffer(); 258 assert_eq!(b"0", 0u64.to_lexical(&mut buffer)); 259 assert_eq!(b"1", 1u64.to_lexical(&mut buffer)); 260 assert_eq!(b"5", 5u64.to_lexical(&mut buffer)); 261 assert_eq!(b"9223372036854775807", 9223372036854775807u64.to_lexical(&mut buffer)); 262 assert_eq!(b"9223372036854775808", 9223372036854775808u64.to_lexical(&mut buffer)); 263 assert_eq!(b"18446744073709551615", 18446744073709551615u64.to_lexical(&mut buffer)); 264 assert_eq!(b"18446744073709551615", (-1i64 as u64).to_lexical(&mut buffer)); 265 } 266 267 #[test] i64_test()268 fn i64_test() { 269 let mut buffer = new_buffer(); 270 assert_eq!(b"0", 0i64.to_lexical(&mut buffer)); 271 assert_eq!(b"1", 1i64.to_lexical(&mut buffer)); 272 assert_eq!(b"5", 5i64.to_lexical(&mut buffer)); 273 assert_eq!(b"9223372036854775807", 9223372036854775807i64.to_lexical(&mut buffer)); 274 assert_eq!(b"-9223372036854775808", (9223372036854775808u64 as i64).to_lexical(&mut buffer)); 275 assert_eq!(b"-1", (18446744073709551615u64 as i64).to_lexical(&mut buffer)); 276 assert_eq!(b"-1", (-1i64).to_lexical(&mut buffer)); 277 } 278 279 #[test] u128_test()280 fn u128_test() { 281 let mut buffer = new_buffer(); 282 assert_eq!(b"0", 0u128.to_lexical(&mut buffer)); 283 assert_eq!(b"1", 1u128.to_lexical(&mut buffer)); 284 assert_eq!(b"5", 5u128.to_lexical(&mut buffer)); 285 assert_eq!(&b"170141183460469231731687303715884105727"[..], 170141183460469231731687303715884105727u128.to_lexical(&mut buffer)); 286 assert_eq!(&b"170141183460469231731687303715884105728"[..], 170141183460469231731687303715884105728u128.to_lexical(&mut buffer)); 287 assert_eq!(&b"340282366920938463463374607431768211455"[..], 340282366920938463463374607431768211455u128.to_lexical(&mut buffer)); 288 assert_eq!(&b"340282366920938463463374607431768211455"[..], (-1i128 as u128).to_lexical(&mut buffer)); 289 } 290 291 #[test] i128_test()292 fn i128_test() { 293 let mut buffer = new_buffer(); 294 assert_eq!(b"0", 0i128.to_lexical(&mut buffer)); 295 assert_eq!(b"1", 1i128.to_lexical(&mut buffer)); 296 assert_eq!(b"5", 5i128.to_lexical(&mut buffer)); 297 assert_eq!(&b"170141183460469231731687303715884105727"[..], 170141183460469231731687303715884105727i128.to_lexical(&mut buffer)); 298 assert_eq!(&b"-170141183460469231731687303715884105728"[..], (170141183460469231731687303715884105728u128 as i128).to_lexical(&mut buffer)); 299 assert_eq!(b"-1", (340282366920938463463374607431768211455u128 as i128).to_lexical(&mut buffer)); 300 assert_eq!(b"-1", (-1i128).to_lexical(&mut buffer)); 301 } 302 303 #[cfg(feature = "radix")] 304 #[test] radix_test()305 fn radix_test() { 306 let data = [ 307 (2, "100101"), 308 (3, "1101"), 309 (4, "211"), 310 (5, "122"), 311 (6, "101"), 312 (7, "52"), 313 (8, "45"), 314 (9, "41"), 315 (10, "37"), 316 (11, "34"), 317 (12, "31"), 318 (13, "2B"), 319 (14, "29"), 320 (15, "27"), 321 (16, "25"), 322 (17, "23"), 323 (18, "21"), 324 (19, "1I"), 325 (20, "1H"), 326 (21, "1G"), 327 (22, "1F"), 328 (23, "1E"), 329 (24, "1D"), 330 (25, "1C"), 331 (26, "1B"), 332 (27, "1A"), 333 (28, "19"), 334 (29, "18"), 335 (30, "17"), 336 (31, "16"), 337 (32, "15"), 338 (33, "14"), 339 (34, "13"), 340 (35, "12"), 341 (36, "11"), 342 ]; 343 344 let mut buffer = new_buffer(); 345 for (base, expected) in data.iter() { 346 assert_eq!(expected.as_bytes(), 37.to_lexical_radix(*base, &mut buffer)); 347 } 348 } 349 350 // Extensive tests 351 352 #[test] u8_pow2_test()353 fn u8_pow2_test() { 354 let mut buffer = new_buffer(); 355 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]; 356 for &i in values.iter() { 357 assert_eq!(i, u8::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 358 } 359 } 360 361 #[test] u8_pow10_test()362 fn u8_pow10_test() { 363 let mut buffer = new_buffer(); 364 let values: &[u8] = &[0, 1, 5, 9, 10, 11, 15, 99, 100, 101, 105]; 365 for &i in values.iter() { 366 assert_eq!(i, u8::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 367 } 368 } 369 370 #[test] u16_pow2_test()371 fn u16_pow2_test() { 372 let mut buffer = new_buffer(); 373 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]; 374 for &i in values.iter() { 375 assert_eq!(i, u16::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 376 } 377 } 378 379 #[test] u16_pow10_test()380 fn u16_pow10_test() { 381 let mut buffer = new_buffer(); 382 let values: &[u16] = &[0, 1, 5, 9, 10, 11, 15, 99, 100, 101, 105, 999, 1000, 1001, 1005, 9999, 10000, 10001, 10005]; 383 for &i in values.iter() { 384 assert_eq!(i, u16::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 385 } 386 } 387 388 #[test] u32_pow2_test()389 fn u32_pow2_test() { 390 let mut buffer = new_buffer(); 391 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]; 392 for &i in values.iter() { 393 assert_eq!(i, u32::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 394 } 395 } 396 397 #[test] u32_pow10_test()398 fn u32_pow10_test() { 399 let mut buffer = new_buffer(); 400 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]; 401 for &i in values.iter() { 402 assert_eq!(i, u32::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 403 } 404 } 405 406 #[test] u64_pow2_test()407 fn u64_pow2_test() { 408 let mut buffer = new_buffer(); 409 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]; 410 for &i in values.iter() { 411 assert_eq!(i, u64::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 412 } 413 } 414 415 #[test] u64_pow10_test()416 fn u64_pow10_test() { 417 let mut buffer = new_buffer(); 418 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]; 419 for &i in values.iter() { 420 assert_eq!(i, u64::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 421 } 422 } 423 424 #[test] u128_pow2_test()425 fn u128_pow2_test() { 426 let mut buffer = new_buffer(); 427 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]; 428 for &i in values.iter() { 429 assert_eq!(i, u128::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 430 } 431 } 432 433 #[test] u128_pow10_test()434 fn u128_pow10_test() { 435 let mut buffer = new_buffer(); 436 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]; 437 for &i in values.iter() { 438 assert_eq!(i, u128::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 439 } 440 } 441 442 // Quickcheck 443 444 quickcheck! { 445 fn u8_quickcheck(i: u8) -> bool { 446 let mut buffer = new_buffer(); 447 i == u8::from_lexical(i.to_lexical(&mut buffer)).unwrap() 448 } 449 450 fn u16_quickcheck(i: u16) -> bool { 451 let mut buffer = new_buffer(); 452 i == u16::from_lexical(i.to_lexical(&mut buffer)).unwrap() 453 } 454 455 fn u32_quickcheck(i: u32) -> bool { 456 let mut buffer = new_buffer(); 457 i == u32::from_lexical(i.to_lexical(&mut buffer)).unwrap() 458 } 459 460 fn u64_quickcheck(i: u64) -> bool { 461 let mut buffer = new_buffer(); 462 i == u64::from_lexical(i.to_lexical(&mut buffer)).unwrap() 463 } 464 465 fn u128_quickcheck(i: u128) -> bool { 466 let mut buffer = new_buffer(); 467 i == u128::from_lexical(i.to_lexical(&mut buffer)).unwrap() 468 } 469 470 fn usize_quickcheck(i: usize) -> bool { 471 let mut buffer = new_buffer(); 472 i == usize::from_lexical(i.to_lexical(&mut buffer)).unwrap() 473 } 474 475 fn i8_quickcheck(i: i8) -> bool { 476 let mut buffer = new_buffer(); 477 i == i8::from_lexical(i.to_lexical(&mut buffer)).unwrap() 478 } 479 480 fn i16_quickcheck(i: i16) -> bool { 481 let mut buffer = new_buffer(); 482 i == i16::from_lexical(i.to_lexical(&mut buffer)).unwrap() 483 } 484 485 fn i32_quickcheck(i: i32) -> bool { 486 let mut buffer = new_buffer(); 487 i == i32::from_lexical(i.to_lexical(&mut buffer)).unwrap() 488 } 489 490 fn i64_quickcheck(i: i64) -> bool { 491 let mut buffer = new_buffer(); 492 i == i64::from_lexical(i.to_lexical(&mut buffer)).unwrap() 493 } 494 495 fn i128_quickcheck(i: i128) -> bool { 496 let mut buffer = new_buffer(); 497 i == i128::from_lexical(i.to_lexical(&mut buffer)).unwrap() 498 } 499 500 fn isize_quickcheck(i: isize) -> bool { 501 let mut buffer = new_buffer(); 502 i == isize::from_lexical(i.to_lexical(&mut buffer)).unwrap() 503 } 504 } 505 506 // Proptest 507 508 #[cfg(feature = "std")] 509 proptest! { 510 #[test] 511 fn u8_proptest(i in u8::min_value()..u8::max_value()) { 512 let mut buffer = new_buffer(); 513 assert_eq!(i, u8::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 514 } 515 516 #[test] 517 fn i8_proptest(i in i8::min_value()..i8::max_value()) { 518 let mut buffer = new_buffer(); 519 assert_eq!(i, i8::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 520 } 521 522 #[test] 523 fn u16_proptest(i in u16::min_value()..u16::max_value()) { 524 let mut buffer = new_buffer(); 525 assert_eq!(i, u16::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 526 } 527 528 #[test] 529 fn i16_proptest(i in i16::min_value()..i16::max_value()) { 530 let mut buffer = new_buffer(); 531 assert_eq!(i, i16::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 532 } 533 534 #[test] 535 fn u32_proptest(i in u32::min_value()..u32::max_value()) { 536 let mut buffer = new_buffer(); 537 assert_eq!(i, u32::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 538 } 539 540 #[test] 541 fn i32_proptest(i in i32::min_value()..i32::max_value()) { 542 let mut buffer = new_buffer(); 543 assert_eq!(i, i32::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 544 } 545 546 #[test] 547 fn u64_proptest(i in u64::min_value()..u64::max_value()) { 548 let mut buffer = new_buffer(); 549 assert_eq!(i, u64::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 550 } 551 552 #[test] 553 fn i64_proptest(i in i64::min_value()..i64::max_value()) { 554 let mut buffer = new_buffer(); 555 assert_eq!(i, i64::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 556 } 557 558 #[test] 559 fn u128_proptest(i in u128::min_value()..u128::max_value()) { 560 let mut buffer = new_buffer(); 561 assert_eq!(i, u128::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 562 } 563 564 #[test] 565 fn i128_proptest(i in i128::min_value()..i128::max_value()) { 566 let mut buffer = new_buffer(); 567 assert_eq!(i, i128::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 568 } 569 570 #[test] 571 fn usize_proptest(i in usize::min_value()..usize::max_value()) { 572 let mut buffer = new_buffer(); 573 assert_eq!(i, usize::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 574 } 575 576 #[test] 577 fn isize_proptest(i in isize::min_value()..isize::max_value()) { 578 let mut buffer = new_buffer(); 579 assert_eq!(i, isize::from_lexical(i.to_lexical(&mut buffer)).unwrap()) 580 } 581 } 582 583 // Panic tests 584 585 #[test] 586 #[should_panic] i8_buffer_test()587 fn i8_buffer_test() { 588 let mut buffer = [b'0'; i8::FORMATTED_SIZE_DECIMAL-1]; 589 12i8.to_lexical(&mut buffer); 590 } 591 592 #[test] 593 #[should_panic] i16_buffer_test()594 fn i16_buffer_test() { 595 let mut buffer = [b'0'; i16::FORMATTED_SIZE_DECIMAL-1]; 596 12i16.to_lexical(&mut buffer); 597 } 598 599 #[test] 600 #[should_panic] i32_buffer_test()601 fn i32_buffer_test() { 602 let mut buffer = [b'0'; i32::FORMATTED_SIZE_DECIMAL-1]; 603 12i32.to_lexical(&mut buffer); 604 } 605 606 #[test] 607 #[should_panic] i64_buffer_test()608 fn i64_buffer_test() { 609 let mut buffer = [b'0'; i64::FORMATTED_SIZE_DECIMAL-1]; 610 12i64.to_lexical(&mut buffer); 611 } 612 613 #[test] 614 #[should_panic] i128_buffer_test()615 fn i128_buffer_test() { 616 let mut buffer = [b'0'; i128::FORMATTED_SIZE_DECIMAL-1]; 617 12i128.to_lexical(&mut buffer); 618 } 619 620 #[test] 621 #[should_panic] isize_buffer_test()622 fn isize_buffer_test() { 623 let mut buffer = [b'0'; isize::FORMATTED_SIZE_DECIMAL-1]; 624 12isize.to_lexical(&mut buffer); 625 } 626 627 #[test] 628 #[should_panic] u8_buffer_test()629 fn u8_buffer_test() { 630 let mut buffer = [b'0'; u8::FORMATTED_SIZE_DECIMAL-1]; 631 12i8.to_lexical(&mut buffer); 632 } 633 634 #[test] 635 #[should_panic] u16_buffer_test()636 fn u16_buffer_test() { 637 let mut buffer = [b'0'; u16::FORMATTED_SIZE_DECIMAL-1]; 638 12i16.to_lexical(&mut buffer); 639 } 640 641 #[test] 642 #[should_panic] u32_buffer_test()643 fn u32_buffer_test() { 644 let mut buffer = [b'0'; u32::FORMATTED_SIZE_DECIMAL-1]; 645 12i32.to_lexical(&mut buffer); 646 } 647 648 #[test] 649 #[should_panic] u64_buffer_test()650 fn u64_buffer_test() { 651 let mut buffer = [b'0'; u64::FORMATTED_SIZE_DECIMAL-1]; 652 12i64.to_lexical(&mut buffer); 653 } 654 655 #[test] 656 #[should_panic] u128_buffer_test()657 fn u128_buffer_test() { 658 let mut buffer = [b'0'; u128::FORMATTED_SIZE_DECIMAL-1]; 659 12i128.to_lexical(&mut buffer); 660 } 661 662 #[test] 663 #[should_panic] usize_buffer_test()664 fn usize_buffer_test() { 665 let mut buffer = [b'0'; usize::FORMATTED_SIZE_DECIMAL-1]; 666 12usize.to_lexical(&mut buffer); 667 } 668 } 669