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 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 usize } 64 #[cfg(has_i128)] itoa_impl! { u128 } 65 66 // FORWARD 67 68 // Forward itoa arguments to an optimized backend. 69 // Preconditions: `value` must be non-negative and unsigned. 70 perftools_inline!{ 71 #[cfg(all(feature = "table", not(feature = "radix")))] 72 pub(crate) fn itoa_positive<T>(value: T, _: u32, buffer: &mut [u8]) 73 -> usize 74 where T: Itoa 75 { 76 value.decimal(buffer) 77 }} 78 79 // Forward itoa arguments to an optimized backend. 80 // Preconditions: `value` must be non-negative and unsigned. 81 perftools_inline!{ 82 #[cfg(all(feature = "table", feature = "radix"))] 83 pub(crate) fn itoa_positive<T>(value: T, radix: u32, buffer: &mut [u8]) 84 -> usize 85 where T: Itoa 86 { 87 if radix == 10 { 88 value.decimal(buffer) 89 } else { 90 write_backwards!(value, radix, buffer, T, generic) 91 } 92 }} 93 94 // Forward itoa arguments to a naive backend. 95 // Preconditions: `value` must be non-negative and unsigned. 96 perftools_inline!{ 97 #[cfg(not(feature = "table"))] 98 pub(crate) fn itoa_positive<T>(value: T, radix: u32, buffer: &mut [u8]) 99 -> usize 100 where T: Itoa 101 { 102 write_backwards!(value, radix, buffer, T, naive) 103 }} 104 105 // TO LEXICAL 106 107 // Callback for unsigned integer formatter. 108 perftools_inline!{ 109 fn unsigned<Narrow, Wide>(value: Narrow, radix: u32, buffer: &mut [u8]) 110 -> usize 111 where Narrow: UnsignedInteger, 112 Wide: Itoa 113 { 114 let value: Wide = as_cast(value); 115 itoa_positive(value, radix, buffer) 116 }} 117 118 macro_rules! unsigned_to_lexical { 119 ($narrow:ty, $wide:ty) => ( 120 to_lexical!(unsigned::<$narrow, $wide>, $narrow); 121 ); 122 } 123 124 unsigned_to_lexical!(u8, u32); 125 unsigned_to_lexical!(u16, u32); 126 unsigned_to_lexical!(u32, u32); 127 unsigned_to_lexical!(u64, u64); 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 #[cfg(has_i128)] 136 unsigned_to_lexical!(u128, u128); 137 138 // Callback for signed integer formatter. 139 perftools_inline!{ 140 fn signed<Narrow, Wide, Unsigned>(value: Narrow, radix: u32, buffer: &mut [u8]) 141 -> usize 142 where Narrow: SignedInteger, 143 Wide: SignedInteger, 144 Unsigned: Itoa 145 { 146 if value < Narrow::ZERO { 147 unchecked_index_mut!(buffer[0] = b'-'); 148 let value: Wide = as_cast(value); 149 let value: Unsigned = as_cast(value.wrapping_neg()); 150 itoa_positive(value, radix, &mut unchecked_index_mut!(buffer[1..])) + 1 151 } else { 152 let value: Unsigned = as_cast(value); 153 itoa_positive(value, radix, buffer) 154 } 155 }} 156 157 macro_rules! signed_to_lexical { 158 ($narrow:ty, $wide:ty, $unsigned:ty) => ( 159 to_lexical!(signed::<$narrow, $wide, $unsigned>, $narrow); 160 ); 161 } 162 163 signed_to_lexical!(i8, i32, u32); 164 signed_to_lexical!(i16, i32, u32); 165 signed_to_lexical!(i32, i32, u32); 166 signed_to_lexical!(i64, i64, u64); 167 168 #[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))] 169 signed_to_lexical!(isize, i32, u32); 170 171 #[cfg(target_pointer_width = "64")] 172 signed_to_lexical!(isize, i64, u64); 173 174 #[cfg(has_i128)] 175 signed_to_lexical!(i128, i128, u128); 176 177 // TESTS 178 // ----- 179 180 #[cfg(test)] 181 mod tests { 182 // Shouldn't need to include atoi, should be fine with ToLexical in scope. 183 use util::*; 184 use util::test::*; 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 #[cfg(has_i128)] 285 #[test] u128_test()286 fn u128_test() { 287 let mut buffer = new_buffer(); 288 assert_eq!(b"0", 0u128.to_lexical(&mut buffer)); 289 assert_eq!(b"1", 1u128.to_lexical(&mut buffer)); 290 assert_eq!(b"5", 5u128.to_lexical(&mut buffer)); 291 assert_eq!(&b"170141183460469231731687303715884105727"[..], 170141183460469231731687303715884105727u128.to_lexical(&mut buffer)); 292 assert_eq!(&b"170141183460469231731687303715884105728"[..], 170141183460469231731687303715884105728u128.to_lexical(&mut buffer)); 293 assert_eq!(&b"340282366920938463463374607431768211455"[..], 340282366920938463463374607431768211455u128.to_lexical(&mut buffer)); 294 assert_eq!(&b"340282366920938463463374607431768211455"[..], (-1i128 as u128).to_lexical(&mut buffer)); 295 } 296 297 #[cfg(has_i128)] 298 #[test] i128_test()299 fn i128_test() { 300 let mut buffer = new_buffer(); 301 assert_eq!(b"0", 0i128.to_lexical(&mut buffer)); 302 assert_eq!(b"1", 1i128.to_lexical(&mut buffer)); 303 assert_eq!(b"5", 5i128.to_lexical(&mut buffer)); 304 assert_eq!(&b"170141183460469231731687303715884105727"[..], 170141183460469231731687303715884105727i128.to_lexical(&mut buffer)); 305 assert_eq!(&b"-170141183460469231731687303715884105728"[..], (170141183460469231731687303715884105728u128 as i128).to_lexical(&mut buffer)); 306 assert_eq!(b"-1", (340282366920938463463374607431768211455u128 as i128).to_lexical(&mut buffer)); 307 assert_eq!(b"-1", (-1i128).to_lexical(&mut buffer)); 308 } 309 310 #[cfg(feature = "radix")] 311 #[test] radix_test()312 fn radix_test() { 313 let data = [ 314 (2, "100101"), 315 (3, "1101"), 316 (4, "211"), 317 (5, "122"), 318 (6, "101"), 319 (7, "52"), 320 (8, "45"), 321 (9, "41"), 322 (10, "37"), 323 (11, "34"), 324 (12, "31"), 325 (13, "2B"), 326 (14, "29"), 327 (15, "27"), 328 (16, "25"), 329 (17, "23"), 330 (18, "21"), 331 (19, "1I"), 332 (20, "1H"), 333 (21, "1G"), 334 (22, "1F"), 335 (23, "1E"), 336 (24, "1D"), 337 (25, "1C"), 338 (26, "1B"), 339 (27, "1A"), 340 (28, "19"), 341 (29, "18"), 342 (30, "17"), 343 (31, "16"), 344 (32, "15"), 345 (33, "14"), 346 (34, "13"), 347 (35, "12"), 348 (36, "11"), 349 ]; 350 351 let mut buffer = new_buffer(); 352 for (base, expected) in data.iter() { 353 assert_eq!(expected.as_bytes(), 37.to_lexical_radix(*base, &mut buffer)); 354 } 355 } 356 357 // Extensive tests 358 359 #[test] u8_pow2_test()360 fn u8_pow2_test() { 361 let mut buffer = new_buffer(); 362 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]; 363 for &i in values.iter() { 364 assert_eq!(i, u8::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 365 } 366 } 367 368 #[test] u8_pow10_test()369 fn u8_pow10_test() { 370 let mut buffer = new_buffer(); 371 let values: &[u8] = &[0, 1, 5, 9, 10, 11, 15, 99, 100, 101, 105]; 372 for &i in values.iter() { 373 assert_eq!(i, u8::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 374 } 375 } 376 377 #[test] u16_pow2_test()378 fn u16_pow2_test() { 379 let mut buffer = new_buffer(); 380 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]; 381 for &i in values.iter() { 382 assert_eq!(i, u16::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 383 } 384 } 385 386 #[test] u16_pow10_test()387 fn u16_pow10_test() { 388 let mut buffer = new_buffer(); 389 let values: &[u16] = &[0, 1, 5, 9, 10, 11, 15, 99, 100, 101, 105, 999, 1000, 1001, 1005, 9999, 10000, 10001, 10005]; 390 for &i in values.iter() { 391 assert_eq!(i, u16::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 392 } 393 } 394 395 #[test] u32_pow2_test()396 fn u32_pow2_test() { 397 let mut buffer = new_buffer(); 398 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]; 399 for &i in values.iter() { 400 assert_eq!(i, u32::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 401 } 402 } 403 404 #[test] u32_pow10_test()405 fn u32_pow10_test() { 406 let mut buffer = new_buffer(); 407 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]; 408 for &i in values.iter() { 409 assert_eq!(i, u32::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 410 } 411 } 412 413 #[test] u64_pow2_test()414 fn u64_pow2_test() { 415 let mut buffer = new_buffer(); 416 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]; 417 for &i in values.iter() { 418 assert_eq!(i, u64::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 419 } 420 } 421 422 #[test] u64_pow10_test()423 fn u64_pow10_test() { 424 let mut buffer = new_buffer(); 425 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]; 426 for &i in values.iter() { 427 assert_eq!(i, u64::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 428 } 429 } 430 431 #[cfg(has_i128)] 432 #[test] u128_pow2_test()433 fn u128_pow2_test() { 434 let mut buffer = new_buffer(); 435 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]; 436 for &i in values.iter() { 437 assert_eq!(i, u128::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 438 } 439 } 440 441 #[cfg(has_i128)] 442 #[test] u128_pow10_test()443 fn u128_pow10_test() { 444 let mut buffer = new_buffer(); 445 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]; 446 for &i in values.iter() { 447 assert_eq!(i, u128::from_lexical(i.to_lexical(&mut buffer)).unwrap()); 448 } 449 } 450 451 // Quickcheck 452 453 #[cfg(feature = "property_tests")] 454 quickcheck! { 455 fn u8_quickcheck(i: u8) -> bool { 456 let mut buffer = new_buffer(); 457 i == u8::from_lexical(i.to_lexical(&mut buffer)).unwrap() 458 } 459 460 fn u16_quickcheck(i: u16) -> bool { 461 let mut buffer = new_buffer(); 462 i == u16::from_lexical(i.to_lexical(&mut buffer)).unwrap() 463 } 464 465 fn u32_quickcheck(i: u32) -> bool { 466 let mut buffer = new_buffer(); 467 i == u32::from_lexical(i.to_lexical(&mut buffer)).unwrap() 468 } 469 470 fn u64_quickcheck(i: u64) -> bool { 471 let mut buffer = new_buffer(); 472 i == u64::from_lexical(i.to_lexical(&mut buffer)).unwrap() 473 } 474 475 #[cfg(has_i128)] 476 fn u128_quickcheck(i: u128) -> bool { 477 let mut buffer = new_buffer(); 478 i == u128::from_lexical(i.to_lexical(&mut buffer)).unwrap() 479 } 480 481 fn usize_quickcheck(i: usize) -> bool { 482 let mut buffer = new_buffer(); 483 i == usize::from_lexical(i.to_lexical(&mut buffer)).unwrap() 484 } 485 486 fn i8_quickcheck(i: i8) -> bool { 487 let mut buffer = new_buffer(); 488 i == i8::from_lexical(i.to_lexical(&mut buffer)).unwrap() 489 } 490 491 fn i16_quickcheck(i: i16) -> bool { 492 let mut buffer = new_buffer(); 493 i == i16::from_lexical(i.to_lexical(&mut buffer)).unwrap() 494 } 495 496 fn i32_quickcheck(i: i32) -> bool { 497 let mut buffer = new_buffer(); 498 i == i32::from_lexical(i.to_lexical(&mut buffer)).unwrap() 499 } 500 501 fn i64_quickcheck(i: i64) -> bool { 502 let mut buffer = new_buffer(); 503 i == i64::from_lexical(i.to_lexical(&mut buffer)).unwrap() 504 } 505 506 #[cfg(has_i128)] 507 fn i128_quickcheck(i: i128) -> bool { 508 let mut buffer = new_buffer(); 509 i == i128::from_lexical(i.to_lexical(&mut buffer)).unwrap() 510 } 511 512 fn isize_quickcheck(i: isize) -> bool { 513 let mut buffer = new_buffer(); 514 i == isize::from_lexical(i.to_lexical(&mut buffer)).unwrap() 515 } 516 } 517 518 // Proptest 519 520 #[cfg(all(feature = "std", feature = "property_tests"))] 521 proptest! { 522 #[test] 523 fn u8_proptest(i in u8::min_value()..u8::max_value()) { 524 let mut buffer = new_buffer(); 525 i == u8::from_lexical(i.to_lexical(&mut buffer)).unwrap() 526 } 527 528 #[test] 529 fn i8_proptest(i in i8::min_value()..i8::max_value()) { 530 let mut buffer = new_buffer(); 531 i == i8::from_lexical(i.to_lexical(&mut buffer)).unwrap() 532 } 533 534 #[test] 535 fn u16_proptest(i in u16::min_value()..u16::max_value()) { 536 let mut buffer = new_buffer(); 537 i == u16::from_lexical(i.to_lexical(&mut buffer)).unwrap() 538 } 539 540 #[test] 541 fn i16_proptest(i in i16::min_value()..i16::max_value()) { 542 let mut buffer = new_buffer(); 543 i == i16::from_lexical(i.to_lexical(&mut buffer)).unwrap() 544 } 545 546 #[test] 547 fn u32_proptest(i in u32::min_value()..u32::max_value()) { 548 let mut buffer = new_buffer(); 549 i == u32::from_lexical(i.to_lexical(&mut buffer)).unwrap() 550 } 551 552 #[test] 553 fn i32_proptest(i in i32::min_value()..i32::max_value()) { 554 let mut buffer = new_buffer(); 555 i == i32::from_lexical(i.to_lexical(&mut buffer)).unwrap() 556 } 557 558 #[test] 559 fn u64_proptest(i in u64::min_value()..u64::max_value()) { 560 let mut buffer = new_buffer(); 561 i == u64::from_lexical(i.to_lexical(&mut buffer)).unwrap() 562 } 563 564 #[test] 565 fn i64_proptest(i in i64::min_value()..i64::max_value()) { 566 let mut buffer = new_buffer(); 567 i == i64::from_lexical(i.to_lexical(&mut buffer)).unwrap() 568 } 569 570 #[cfg(has_i128)] 571 #[test] 572 fn u128_proptest(i in u128::min_value()..u128::max_value()) { 573 let mut buffer = new_buffer(); 574 i == u128::from_lexical(i.to_lexical(&mut buffer)).unwrap() 575 } 576 577 #[cfg(has_i128)] 578 #[test] 579 fn i128_proptest(i in i128::min_value()..i128::max_value()) { 580 let mut buffer = new_buffer(); 581 i == i128::from_lexical(i.to_lexical(&mut buffer)).unwrap() 582 } 583 584 #[test] 585 fn usize_proptest(i in usize::min_value()..usize::max_value()) { 586 let mut buffer = new_buffer(); 587 i == usize::from_lexical(i.to_lexical(&mut buffer)).unwrap() 588 } 589 590 #[test] 591 fn isize_proptest(i in isize::min_value()..isize::max_value()) { 592 let mut buffer = new_buffer(); 593 i == isize::from_lexical(i.to_lexical(&mut buffer)).unwrap() 594 } 595 } 596 597 // Panic tests 598 599 #[test] 600 #[should_panic] i8_buffer_test()601 fn i8_buffer_test() { 602 let mut buffer = [b'0'; i8::FORMATTED_SIZE_DECIMAL-1]; 603 12i8.to_lexical(&mut buffer); 604 } 605 606 #[test] 607 #[should_panic] i16_buffer_test()608 fn i16_buffer_test() { 609 let mut buffer = [b'0'; i16::FORMATTED_SIZE_DECIMAL-1]; 610 12i16.to_lexical(&mut buffer); 611 } 612 613 #[test] 614 #[should_panic] i32_buffer_test()615 fn i32_buffer_test() { 616 let mut buffer = [b'0'; i32::FORMATTED_SIZE_DECIMAL-1]; 617 12i32.to_lexical(&mut buffer); 618 } 619 620 #[test] 621 #[should_panic] i64_buffer_test()622 fn i64_buffer_test() { 623 let mut buffer = [b'0'; i64::FORMATTED_SIZE_DECIMAL-1]; 624 12i64.to_lexical(&mut buffer); 625 } 626 627 #[cfg(has_i128)] 628 #[test] 629 #[should_panic] i128_buffer_test()630 fn i128_buffer_test() { 631 let mut buffer = [b'0'; i128::FORMATTED_SIZE_DECIMAL-1]; 632 12i128.to_lexical(&mut buffer); 633 } 634 635 #[test] 636 #[should_panic] isize_buffer_test()637 fn isize_buffer_test() { 638 let mut buffer = [b'0'; isize::FORMATTED_SIZE_DECIMAL-1]; 639 12isize.to_lexical(&mut buffer); 640 } 641 642 #[test] 643 #[should_panic] u8_buffer_test()644 fn u8_buffer_test() { 645 let mut buffer = [b'0'; u8::FORMATTED_SIZE_DECIMAL-1]; 646 12i8.to_lexical(&mut buffer); 647 } 648 649 #[test] 650 #[should_panic] u16_buffer_test()651 fn u16_buffer_test() { 652 let mut buffer = [b'0'; u16::FORMATTED_SIZE_DECIMAL-1]; 653 12i16.to_lexical(&mut buffer); 654 } 655 656 #[test] 657 #[should_panic] u32_buffer_test()658 fn u32_buffer_test() { 659 let mut buffer = [b'0'; u32::FORMATTED_SIZE_DECIMAL-1]; 660 12i32.to_lexical(&mut buffer); 661 } 662 663 #[test] 664 #[should_panic] u64_buffer_test()665 fn u64_buffer_test() { 666 let mut buffer = [b'0'; u64::FORMATTED_SIZE_DECIMAL-1]; 667 12i64.to_lexical(&mut buffer); 668 } 669 670 #[cfg(has_i128)] 671 #[test] 672 #[should_panic] u128_buffer_test()673 fn u128_buffer_test() { 674 let mut buffer = [b'0'; u128::FORMATTED_SIZE_DECIMAL-1]; 675 12i128.to_lexical(&mut buffer); 676 } 677 678 #[test] 679 #[should_panic] usize_buffer_test()680 fn usize_buffer_test() { 681 let mut buffer = [b'0'; usize::FORMATTED_SIZE_DECIMAL-1]; 682 12usize.to_lexical(&mut buffer); 683 } 684 } 685