| 1 | import strconv |
| 2 | |
| 3 | fn test_common_atoi() { |
| 4 | // test common cases |
| 5 | assert '70zzz'.int() == 70 |
| 6 | assert '2901issue'.int() == 2901 |
| 7 | assert '234232w'.int() == 234232 |
| 8 | assert '-9009x'.int() == -9009 |
| 9 | assert '0y'.int() == 0 |
| 10 | |
| 11 | // test lead zeros |
| 12 | assert '0000012'.int() == 12 |
| 13 | assert '-0000012'.int() == -12 |
| 14 | assert '0x001F'.int() == 31 |
| 15 | assert '-0x001F'.int() == -31 |
| 16 | assert '0x001f'.int() == 31 |
| 17 | assert '0o00011'.int() == 9 |
| 18 | assert '0b00001001'.int() == 9 |
| 19 | |
| 20 | // test underscore in string |
| 21 | assert '-10_000'.int() == -10000 |
| 22 | assert '-0x00_0_f_ff'.int() == -0xfff |
| 23 | assert '10_000_000'.int() == 10000000 |
| 24 | |
| 25 | for n in -10000 .. 100000 { |
| 26 | s := n.str() + 'z' |
| 27 | assert s.int() == n |
| 28 | } |
| 29 | } |
| 30 | |
| 31 | fn test_unsigned_cast() { |
| 32 | // tests for u16 |
| 33 | |
| 34 | // test common cases |
| 35 | assert '70zzz'.u16() == 70 |
| 36 | assert '2901issue'.u16() == 2901 |
| 37 | assert '0y'.u16() == 0 |
| 38 | |
| 39 | // test lead zeros |
| 40 | assert '0000012'.u16() == 12 |
| 41 | assert '0x001F'.u16() == 31 |
| 42 | assert '0x001f'.u16() == 31 |
| 43 | assert '0o00011'.u16() == 9 |
| 44 | assert '0b00001001'.u16() == 9 |
| 45 | |
| 46 | // tests for u32 |
| 47 | |
| 48 | // test common cases |
| 49 | assert '70zzz'.u32() == 70 |
| 50 | assert '2901issue'.u32() == 2901 |
| 51 | assert '234232w'.u32() == 234232 |
| 52 | assert '-9009x'.u32() == 0 |
| 53 | assert '0y'.u32() == 0 |
| 54 | |
| 55 | // test lead zeros |
| 56 | assert '0000012'.u32() == 12 |
| 57 | assert '-0000012'.u32() == 0 |
| 58 | assert '0x001F'.u32() == 31 |
| 59 | assert '-0x001F'.u32() == 0 |
| 60 | assert '0x001f'.u32() == 31 |
| 61 | assert '0o00011'.u32() == 9 |
| 62 | assert '0b00001001'.u32() == 9 |
| 63 | |
| 64 | // test underscore in string |
| 65 | assert '-10_000'.u32() == 0 |
| 66 | assert '-0x00_0_f_ff'.u32() == 0 |
| 67 | assert '10_000_000'.u32() == 10000000 |
| 68 | |
| 69 | for n in 0 .. u32(100) { |
| 70 | s := n.str() + 'z' |
| 71 | assert s.u32() == n |
| 72 | } |
| 73 | |
| 74 | // tests for u64 |
| 75 | |
| 76 | // test common cases |
| 77 | assert '70zzz'.u64() == 70 |
| 78 | assert '2901issue'.u64() == 2901 |
| 79 | assert '234232w'.u64() == 234232 |
| 80 | assert '-9009x'.u64() == 0 |
| 81 | assert '0y'.u64() == 0 |
| 82 | |
| 83 | // test lead zeros |
| 84 | assert '0000012'.u64() == 12 |
| 85 | assert '-0000012'.u64() == 0 |
| 86 | assert '0x001F'.u64() == 31 |
| 87 | assert '-0x001F'.u64() == 0 |
| 88 | assert '0x001f'.u64() == 31 |
| 89 | assert '0o00011'.u64() == 9 |
| 90 | assert '0b00001001'.u64() == 9 |
| 91 | |
| 92 | // test underscore in string |
| 93 | assert '-10_000'.u64() == 0 |
| 94 | assert '-0x00_0_f_ff'.u64() == 0 |
| 95 | assert '10_000_000'.u64() == 10000000 |
| 96 | |
| 97 | for n in 0 .. u64(10000) { |
| 98 | s := n.str() + 'z' |
| 99 | assert s.u64() == n |
| 100 | } |
| 101 | } |
| 102 | |
| 103 | fn test_signed_cast() { |
| 104 | // tests for i64 |
| 105 | |
| 106 | // test common cases |
| 107 | assert '70zzz'.i64() == 70 |
| 108 | assert '2901issue'.i64() == 2901 |
| 109 | assert '234232w'.i64() == 234232 |
| 110 | assert '-9009x'.i64() == -9009 |
| 111 | assert '0y'.i64() == 0 |
| 112 | |
| 113 | // test lead zeros |
| 114 | assert '0000012'.i64() == 12 |
| 115 | assert '-0000012'.i64() == -12 |
| 116 | assert '0x001F'.i64() == 31 |
| 117 | assert '-0x001F'.i64() == -31 |
| 118 | assert '0x001f'.i64() == 31 |
| 119 | assert '0o00011'.i64() == 9 |
| 120 | assert '0b00001001'.i64() == 9 |
| 121 | |
| 122 | // test underscore in string |
| 123 | assert '-10_000'.i64() == -10000 |
| 124 | assert '-0x00_0_f_ff'.i64() == -0xfff |
| 125 | assert '10_000_000'.i64() == 10000000 |
| 126 | |
| 127 | for n in -10000 .. 100000 { |
| 128 | s := n.str() + 'z' |
| 129 | assert s.i64() == n |
| 130 | } |
| 131 | |
| 132 | // tests for i8 |
| 133 | |
| 134 | // test common cases |
| 135 | assert '70zzz'.i8() == 70 |
| 136 | assert '29issue'.i8() == 29 |
| 137 | assert '22w'.i8() == 22 |
| 138 | assert '-90x'.i8() == -90 |
| 139 | assert '0y'.i8() == 0 |
| 140 | |
| 141 | // test lead zeros |
| 142 | assert '0000012'.i8() == 12 |
| 143 | assert '-0000012'.i8() == -12 |
| 144 | assert '0x001F'.i8() == 31 |
| 145 | assert '-0x001F'.i8() == -31 |
| 146 | assert '0x001f'.i8() == 31 |
| 147 | assert '0o00011'.i8() == 9 |
| 148 | assert '0b000011'.i8() == 3 |
| 149 | |
| 150 | // test underscore in string |
| 151 | assert '-10_0'.i8() == -100 |
| 152 | assert '-0x0_0_f'.i8() == -0xf |
| 153 | assert '10_0'.i8() == 100 |
| 154 | |
| 155 | for n in -10 .. 100 { |
| 156 | s := n.str() + 'z' |
| 157 | assert s.i8() == n |
| 158 | } |
| 159 | |
| 160 | // tests for i16 |
| 161 | |
| 162 | // test common cases |
| 163 | assert '70zzz'.i16() == 70 |
| 164 | assert '2901issue'.i16() == 2901 |
| 165 | assert '2342w'.i16() == 2342 |
| 166 | assert '-9009x'.i16() == -9009 |
| 167 | assert '0y'.i16() == 0 |
| 168 | |
| 169 | // test lead zeros |
| 170 | assert '0000012'.i16() == 12 |
| 171 | assert '-0000012'.i16() == -12 |
| 172 | assert '0x001F'.i16() == 31 |
| 173 | assert '-0x001F'.i16() == -31 |
| 174 | assert '0x001f'.i16() == 31 |
| 175 | assert '0o00011'.i16() == 9 |
| 176 | assert '0b00001001'.i16() == 9 |
| 177 | |
| 178 | // test underscore in string |
| 179 | assert '-10_0'.i16() == -100 |
| 180 | assert '-0x00_0_fff'.i16() == -0xfff |
| 181 | assert '10_0'.i16() == 100 |
| 182 | |
| 183 | for n in -100 .. 100 { |
| 184 | s := n.str() + 'z' |
| 185 | assert s.i16() == n |
| 186 | } |
| 187 | |
| 188 | // test g format |
| 189 | unsafe { |
| 190 | mut u := strconv.Float64u{ |
| 191 | u: strconv.double_plus_zero |
| 192 | } |
| 193 | assert '${u.f:g}' == '0.0' |
| 194 | assert '${u.f:G}' == '0.0' |
| 195 | u.u = strconv.double_minus_zero |
| 196 | assert '${u.f:g}' == '0.0' |
| 197 | assert '${u.f:G}' == '0.0' |
| 198 | u.u = strconv.double_plus_infinity |
| 199 | assert '${u.f:g}' == '+inf' |
| 200 | assert '${u.f:G}' == '+INF' |
| 201 | u.u = strconv.double_minus_infinity |
| 202 | assert '${u.f:g}' == '-inf' |
| 203 | assert '${u.f:G}' == '-INF' |
| 204 | } |
| 205 | unsafe { |
| 206 | mut u := strconv.Float32u{ |
| 207 | u: strconv.single_plus_zero |
| 208 | } |
| 209 | assert '${u.f:g}' == '0.0' |
| 210 | assert '${u.f:G}' == '0.0' |
| 211 | u.u = strconv.single_minus_zero |
| 212 | assert '${u.f:g}' == '0.0' |
| 213 | assert '${u.f:G}' == '0.0' |
| 214 | u.u = strconv.single_plus_infinity |
| 215 | assert '${u.f:g}' == '+inf' |
| 216 | assert '${u.f:G}' == '+INF' |
| 217 | u.u = strconv.single_minus_infinity |
| 218 | assert '${u.f:g}' == '-inf' |
| 219 | assert '${u.f:G}' == '-INF' |
| 220 | } |
| 221 | } |
| 222 | |
| 223 | fn test_binary() { |
| 224 | i := i8(127) |
| 225 | u := u8(127) |
| 226 | assert '${i:08b}' == '01111111' |
| 227 | assert '${u:08b}' == '01111111' |
| 228 | assert '${i16(i):08b}' == '01111111' |
| 229 | assert '${u16(u):08b}' == '01111111' |
| 230 | assert '${int(i):08b}' == '01111111' |
| 231 | assert '${u32(u):08b}' == '01111111' |
| 232 | assert '${i64(i):08b}' == '01111111' |
| 233 | assert '${u64(u):08b}' == '01111111' |
| 234 | |
| 235 | n := i8(-1) |
| 236 | assert '${u8(-1):08b}' == '11111111' |
| 237 | assert '${u16(n):08b}' == '1111111111111111' |
| 238 | assert '${u32(n):08b}' == '11111111111111111111111111111111' |
| 239 | assert '${u64(n):08b}' == '1111111111111111111111111111111111111111111111111111111111111111' |
| 240 | } |
| 241 | |
| 242 | fn test_binary32() { |
| 243 | i := int(0x7fff_ffff) |
| 244 | u := u32(0x7fff_ffff) |
| 245 | assert '${i:032b}' == '01111111111111111111111111111111' |
| 246 | assert '${u:032b}' == '01111111111111111111111111111111' |
| 247 | assert '${i64(i):032b}' == '01111111111111111111111111111111' |
| 248 | assert '${u64(u):032b}' == '01111111111111111111111111111111' |
| 249 | } |
| 250 | |
| 251 | fn test_binary64() { |
| 252 | i := i64(0x7fff_ffff_ffff_ffff) |
| 253 | u := u64(0x7fff_ffff_ffff_ffff) |
| 254 | assert '${i:064b}' == '0111111111111111111111111111111111111111111111111111111111111111' |
| 255 | assert '${u:064b}' == '0111111111111111111111111111111111111111111111111111111111111111' |
| 256 | } |
| 257 | |
| 258 | fn test_interpolation_of_negative_numbers_padding_and_width() { |
| 259 | a := -77 |
| 260 | assert ' -77' == '${a:20}' |
| 261 | assert ' -77' == '${a:20d}' |
| 262 | assert ' -4d' == '${a:20x}' |
| 263 | assert ' -1001101' == '${a:20b}' |
| 264 | |
| 265 | assert '-0000000000000000077' == '${a:020}' |
| 266 | assert '-0000000000000000077' == '${a:020d}' |
| 267 | assert '-000000000000000004d' == '${a:020x}' |
| 268 | assert '-0000000000001001101' == '${a:020b}' |
| 269 | |
| 270 | // |
| 271 | assert ' -77' == '${a:8}' |
| 272 | assert ' -77' == '${a:8d}' |
| 273 | assert ' -4d' == '${a:8x}' |
| 274 | assert '-1001101' == '${a:8b}' |
| 275 | |
| 276 | assert '-0000077' == '${a:08}' |
| 277 | assert '-0000077' == '${a:08d}' |
| 278 | assert '-1001101' == '${a:08b}' |
| 279 | assert '-000004d' == '${a:08x}' |
| 280 | |
| 281 | // |
| 282 | assert ' -77' == '${a:4}' |
| 283 | assert ' -77' == '${a:4d}' |
| 284 | assert '-1001101' == '${a:4b}' |
| 285 | assert ' -4d' == '${a:4x}' |
| 286 | |
| 287 | assert '-077' == '${a:04}' |
| 288 | assert '-077' == '${a:04d}' |
| 289 | assert '-1001101' == '${a:04b}' |
| 290 | assert '-04d' == '${a:04x}' |
| 291 | |
| 292 | // |
| 293 | assert '-77' == '${a:2}' |
| 294 | assert '-77' == '${a:2d}' |
| 295 | assert '-1001101' == '${a:2b}' |
| 296 | assert '-4d' == '${a:2x}' |
| 297 | |
| 298 | assert '-77' == '${a:02}' |
| 299 | assert '-77' == '${a:02d}' |
| 300 | assert '-1001101' == '${a:02b}' |
| 301 | assert '-4d' == '${a:02x}' |
| 302 | |
| 303 | // |
| 304 | bin0 := ~6 |
| 305 | assert bin0 == -7 |
| 306 | assert '-0000111' == '${bin0:08b}' // a minimum of 8 characters for the whole number, including the padding and the sign |
| 307 | assert '-0000111' == '${~6:08b}' |
| 308 | assert ' -111' == '${~6:8b}' |
| 309 | |
| 310 | // |
| 311 | assert '-0000110' == '${-6:08b}' |
| 312 | assert ' -110' == '${-6:8b}' |
| 313 | } |
| 314 | |
| 315 | fn test_parse() { |
| 316 | assert i64(1) == '1'.parse_int(0, 8) or { 0 } |
| 317 | assert i64(1) == '0b01'.parse_int(0, 8) or { 0 } |
| 318 | assert i64(1) == '01'.parse_int(0, 8) or { 0 } |
| 319 | assert i64(1) == '0o01'.parse_int(0, 8) or { 0 } |
| 320 | assert i64(1) == '0x01'.parse_int(0, 8) or { 0 } |
| 321 | assert i64(1) == '1'.parse_int(2, 8) or { 0 } |
| 322 | assert i64(1) == '1'.parse_int(8, 8) or { 0 } |
| 323 | assert i64(1) == '1'.parse_int(10, 8) or { 0 } |
| 324 | assert i64(1) == '1'.parse_int(16, 8) or { 0 } |
| 325 | |
| 326 | assert u64(1) == '1'.parse_uint(0, 8) or { 0 } |
| 327 | assert u64(1) == '0b01'.parse_uint(0, 8) or { 0 } |
| 328 | assert u64(1) == '01'.parse_uint(0, 8) or { 0 } |
| 329 | assert u64(1) == '0o01'.parse_uint(0, 8) or { 0 } |
| 330 | assert u64(1) == '0x01'.parse_uint(0, 8) or { 0 } |
| 331 | assert u64(1) == '1'.parse_uint(2, 8) or { 0 } |
| 332 | assert u64(1) == '1'.parse_uint(8, 8) or { 0 } |
| 333 | assert u64(1) == '1'.parse_uint(10, 8) or { 0 } |
| 334 | assert u64(1) == '1'.parse_uint(16, 8) or { 0 } |
| 335 | } |
| 336 | |
| 337 | fn test_interpolate_binary_literals() { |
| 338 | assert ' 1 ${i64(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000)}' == ' 1 -9223372036854775808' |
| 339 | assert ' 2 ${i64(0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)}' == ' 2 -1' |
| 340 | assert ' 3 ${i64(0b0111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)}' == ' 3 9223372036854775807' |
| 341 | assert ' 4 ${u64(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000)}' == ' 4 9223372036854775808' |
| 342 | assert ' 5 ${u64(0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)}' == ' 5 18446744073709551615' |
| 343 | assert ' 6 ${u64(0b0111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)}' == ' 6 9223372036854775807' |
| 344 | assert ' 7 ${u32(0b111_1111_1111_1111_1111)}' == ' 7 524287' |
| 345 | } |
| 346 | |
| 347 | fn test_interpolate_literal_limits() { |
| 348 | assert ' 8 ${u32(2147483648)}' == ' 8 2147483648' |
| 349 | assert ' 9 ${u64(0xFF_FF_FF_FF_FF_FF_FF_FF)}' == ' 9 18446744073709551615' |
| 350 | assert '10 ${u32(0o377777_77777)}' == '10 4294967295' |
| 351 | assert '11 ${i64(-2147483647)}' == '11 -2147483647' |
| 352 | } |