OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 library int64test; | 5 library int64test; |
6 import 'package:fixnum/fixnum.dart'; | 6 import 'package:fixnum/fixnum.dart'; |
7 import 'package:unittest/unittest.dart'; | 7 import 'package:unittest/unittest.dart'; |
8 | 8 |
9 void main() { | 9 void main() { |
| 10 |
| 11 argumentErrorTest(name, op, [receiver = Int64.ONE]) { |
| 12 throwsArgumentErrorMentioning(substring) => |
| 13 throwsA((e) => e is ArgumentError && '$e'.contains(substring)); |
| 14 |
| 15 expect(() => op(receiver, null), throwsArgumentErrorMentioning('null')); |
| 16 expect(() => op(receiver, 'foo'), throwsArgumentErrorMentioning(r'"foo"')); |
| 17 } |
| 18 |
10 group("is-tests", () { | 19 group("is-tests", () { |
11 test("isEven", () { | 20 test("isEven", () { |
12 expect((-Int64.ONE).isEven, false); | 21 expect((-Int64.ONE).isEven, false); |
13 expect(Int64.ZERO.isEven, true); | 22 expect(Int64.ZERO.isEven, true); |
14 expect(Int64.ONE.isEven, false); | 23 expect(Int64.ONE.isEven, false); |
15 expect(Int64.TWO.isEven, true); | 24 expect(Int64.TWO.isEven, true); |
16 }); | 25 }); |
17 test("isMaxValue", () { | 26 test("isMaxValue", () { |
18 expect(Int64.MIN_VALUE.isMaxValue, false); | 27 expect(Int64.MIN_VALUE.isMaxValue, false); |
19 expect(Int64.ZERO.isMaxValue, false); | 28 expect(Int64.ZERO.isMaxValue, false); |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
61 Int64 n4 = new Int64(-9876); | 70 Int64 n4 = new Int64(-9876); |
62 Int64 n5 = new Int64.fromInts(0x12345678, 0xabcdabcd); | 71 Int64 n5 = new Int64.fromInts(0x12345678, 0xabcdabcd); |
63 Int64 n6 = new Int64.fromInts(0x77773333, 0x22224444); | 72 Int64 n6 = new Int64.fromInts(0x77773333, 0x22224444); |
64 | 73 |
65 test("+", () { | 74 test("+", () { |
66 expect(n1 + n2, new Int64(11110)); | 75 expect(n1 + n2, new Int64(11110)); |
67 expect(n3 + n2, new Int64(8642)); | 76 expect(n3 + n2, new Int64(8642)); |
68 expect(n3 + n4, new Int64(-11110)); | 77 expect(n3 + n4, new Int64(-11110)); |
69 expect(n5 + n6, new Int64.fromInts(0x89ab89ab, 0xcdeff011)); | 78 expect(n5 + n6, new Int64.fromInts(0x89ab89ab, 0xcdeff011)); |
70 expect(Int64.MAX_VALUE + 1, Int64.MIN_VALUE); | 79 expect(Int64.MAX_VALUE + 1, Int64.MIN_VALUE); |
| 80 argumentErrorTest("+", (a, b) => a + b); |
71 }); | 81 }); |
72 | 82 |
73 test("-", () { | 83 test("-", () { |
74 expect(n1 - n2, new Int64(-8642)); | 84 expect(n1 - n2, new Int64(-8642)); |
75 expect(n3 - n2, new Int64(-11110)); | 85 expect(n3 - n2, new Int64(-11110)); |
76 expect(n3 - n4, new Int64(8642)); | 86 expect(n3 - n4, new Int64(8642)); |
77 expect(n5 - n6, new Int64.fromInts(0x9abd2345, 0x89ab6789)); | 87 expect(n5 - n6, new Int64.fromInts(0x9abd2345, 0x89ab6789)); |
78 expect(Int64.MIN_VALUE - 1, Int64.MAX_VALUE); | 88 expect(Int64.MIN_VALUE - 1, Int64.MAX_VALUE); |
| 89 argumentErrorTest("-", (a, b) => a - b); |
79 }); | 90 }); |
80 | 91 |
81 test("unary -", () { | 92 test("unary -", () { |
82 expect(-n1, new Int64(-1234)); | 93 expect(-n1, new Int64(-1234)); |
83 expect(-Int64.ZERO, Int64.ZERO); | 94 expect(-Int64.ZERO, Int64.ZERO); |
84 }); | 95 }); |
85 | 96 |
86 test("*", () { | 97 test("*", () { |
87 expect(new Int64(1111) * new Int64(3), new Int64(3333)); | 98 expect(new Int64(1111) * new Int64(3), new Int64(3333)); |
88 expect(new Int64(1111) * new Int64(-3), new Int64(-3333)); | 99 expect(new Int64(1111) * new Int64(-3), new Int64(-3333)); |
(...skipping 17 matching lines...) Expand all Loading... |
106 expect((new Int64(123456789) * new Int32(987654321)), | 117 expect((new Int64(123456789) * new Int32(987654321)), |
107 new Int64.fromInts(0x1b13114, 0xfbff5385)); | 118 new Int64.fromInts(0x1b13114, 0xfbff5385)); |
108 | 119 |
109 // Wraparound | 120 // Wraparound |
110 expect((new Int64(123456789) * new Int64(987654321)), | 121 expect((new Int64(123456789) * new Int64(987654321)), |
111 new Int64.fromInts(0x1b13114, 0xfbff5385)); | 122 new Int64.fromInts(0x1b13114, 0xfbff5385)); |
112 | 123 |
113 expect(Int64.MIN_VALUE * new Int64(2), Int64.ZERO); | 124 expect(Int64.MIN_VALUE * new Int64(2), Int64.ZERO); |
114 expect(Int64.MIN_VALUE * new Int64(1), Int64.MIN_VALUE); | 125 expect(Int64.MIN_VALUE * new Int64(1), Int64.MIN_VALUE); |
115 expect(Int64.MIN_VALUE * new Int64(-1), Int64.MIN_VALUE); | 126 expect(Int64.MIN_VALUE * new Int64(-1), Int64.MIN_VALUE); |
| 127 argumentErrorTest("*", (a, b) => a * b); |
116 }); | 128 }); |
117 | 129 |
118 test("~/", () { | 130 test("~/", () { |
119 Int64 deadBeef = new Int64.fromInts(0xDEADBEEF, 0xDEADBEEF); | 131 Int64 deadBeef = new Int64.fromInts(0xDEADBEEF, 0xDEADBEEF); |
120 Int64 ten = new Int64(10); | 132 Int64 ten = new Int64(10); |
121 | 133 |
122 expect(deadBeef ~/ ten, new Int64.fromInts(0xfcaaf97e, 0x63115fe5)); | 134 expect(deadBeef ~/ ten, new Int64.fromInts(0xfcaaf97e, 0x63115fe5)); |
123 expect(Int64.ONE ~/ Int64.TWO, Int64.ZERO); | 135 expect(Int64.ONE ~/ Int64.TWO, Int64.ZERO); |
124 expect(Int64.MAX_VALUE ~/ Int64.TWO, | 136 expect(Int64.MAX_VALUE ~/ Int64.TWO, |
125 new Int64.fromInts(0x3fffffff, 0xffffffff)); | 137 new Int64.fromInts(0x3fffffff, 0xffffffff)); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
178 expect(new Int64(829893893) ~/ new Int32(1919), new Int32(432461)); | 190 expect(new Int64(829893893) ~/ new Int32(1919), new Int32(432461)); |
179 expect(new Int64(829893893) ~/ new Int64(1919), new Int32(432461)); | 191 expect(new Int64(829893893) ~/ new Int64(1919), new Int32(432461)); |
180 expect(new Int64(829893893) ~/ 1919, new Int32(432461)); | 192 expect(new Int64(829893893) ~/ 1919, new Int32(432461)); |
181 expect(() => new Int64(1) ~/ Int64.ZERO, | 193 expect(() => new Int64(1) ~/ Int64.ZERO, |
182 throwsA(new isInstanceOf<IntegerDivisionByZeroException>())); | 194 throwsA(new isInstanceOf<IntegerDivisionByZeroException>())); |
183 expect(Int64.MIN_VALUE ~/ new Int64(2), | 195 expect(Int64.MIN_VALUE ~/ new Int64(2), |
184 new Int64.fromInts(0xc0000000, 0x00000000)); | 196 new Int64.fromInts(0xc0000000, 0x00000000)); |
185 expect(Int64.MIN_VALUE ~/ new Int64(1), Int64.MIN_VALUE); | 197 expect(Int64.MIN_VALUE ~/ new Int64(1), Int64.MIN_VALUE); |
186 expect(Int64.MIN_VALUE ~/ new Int64(-1), Int64.MIN_VALUE); | 198 expect(Int64.MIN_VALUE ~/ new Int64(-1), Int64.MIN_VALUE); |
187 expect(() => new Int64(17) ~/ Int64.ZERO, throws); | 199 expect(() => new Int64(17) ~/ Int64.ZERO, throws); |
188 expect(() => new Int64(17) ~/ null, throwsArgumentError); | 200 argumentErrorTest("~/", (a, b) => a ~/ b); |
189 }); | 201 }); |
190 | 202 |
191 test("%", () { | 203 test("%", () { |
192 // Define % as Euclidean mod, with positive result for all arguments | 204 // Define % as Euclidean mod, with positive result for all arguments |
193 expect(Int64.ZERO % new Int64(1000), Int64.ZERO); | 205 expect(Int64.ZERO % new Int64(1000), Int64.ZERO); |
194 expect(Int64.MIN_VALUE % Int64.MIN_VALUE, Int64.ZERO); | 206 expect(Int64.MIN_VALUE % Int64.MIN_VALUE, Int64.ZERO); |
195 expect(new Int64(1000) % Int64.MIN_VALUE, new Int64(1000)); | 207 expect(new Int64(1000) % Int64.MIN_VALUE, new Int64(1000)); |
196 expect(Int64.MIN_VALUE % new Int64(8192), Int64.ZERO); | 208 expect(Int64.MIN_VALUE % new Int64(8192), Int64.ZERO); |
197 expect(Int64.MIN_VALUE % new Int64(8193), new Int64(6145)); | 209 expect(Int64.MIN_VALUE % new Int64(8193), new Int64(6145)); |
198 expect(new Int64(-1000) % new Int64(8192), new Int64(7192)); | 210 expect(new Int64(-1000) % new Int64(8192), new Int64(7192)); |
(...skipping 19 matching lines...) Expand all Loading... |
218 expect(new Int64(0x12345678).remainder(new Int64(0x22)), | 230 expect(new Int64(0x12345678).remainder(new Int64(0x22)), |
219 new Int64(0x12345678.remainder(0x22))); | 231 new Int64(0x12345678.remainder(0x22))); |
220 expect(new Int64(0x12345678).remainder(new Int64(-0x22)), | 232 expect(new Int64(0x12345678).remainder(new Int64(-0x22)), |
221 new Int64(0x12345678.remainder(-0x22))); | 233 new Int64(0x12345678.remainder(-0x22))); |
222 expect(new Int64(-0x12345678).remainder(new Int64(-0x22)), | 234 expect(new Int64(-0x12345678).remainder(new Int64(-0x22)), |
223 new Int64(-0x12345678.remainder(-0x22))); | 235 new Int64(-0x12345678.remainder(-0x22))); |
224 expect(new Int64(-0x12345678).remainder(new Int64(0x22)), | 236 expect(new Int64(-0x12345678).remainder(new Int64(0x22)), |
225 new Int64(-0x12345678.remainder(0x22))); | 237 new Int64(-0x12345678.remainder(0x22))); |
226 expect(new Int32(0x12345678).remainder(new Int64(0x22)), | 238 expect(new Int32(0x12345678).remainder(new Int64(0x22)), |
227 new Int64(0x12345678.remainder(0x22))); | 239 new Int64(0x12345678.remainder(0x22))); |
| 240 argumentErrorTest("%", (a, b) => a % b); |
228 }); | 241 }); |
229 | 242 |
230 test("clamp", () { | 243 test("clamp", () { |
231 Int64 val = new Int64(17); | 244 Int64 val = new Int64(17); |
232 expect(val.clamp(20, 30), new Int64(20)); | 245 expect(val.clamp(20, 30), new Int64(20)); |
233 expect(val.clamp(10, 20), new Int64(17)); | 246 expect(val.clamp(10, 20), new Int64(17)); |
234 expect(val.clamp(10, 15), new Int64(15)); | 247 expect(val.clamp(10, 15), new Int64(15)); |
235 | 248 |
236 expect(val.clamp(new Int32(20), new Int32(30)), new Int64(20)); | 249 expect(val.clamp(new Int32(20), new Int32(30)), new Int64(20)); |
237 expect(val.clamp(new Int32(10), new Int32(20)), new Int64(17)); | 250 expect(val.clamp(new Int32(10), new Int32(20)), new Int64(17)); |
(...skipping 23 matching lines...) Expand all Loading... |
261 expect(new Int64(10) < new Int32(10), false); | 274 expect(new Int64(10) < new Int32(10), false); |
262 expect(new Int64(10) < new Int32(9), false); | 275 expect(new Int64(10) < new Int32(9), false); |
263 expect(new Int64(-10) < new Int64(-11), false); | 276 expect(new Int64(-10) < new Int64(-11), false); |
264 expect(Int64.MIN_VALUE < Int64.ZERO, true); | 277 expect(Int64.MIN_VALUE < Int64.ZERO, true); |
265 expect(largeNeg < largePos, true); | 278 expect(largeNeg < largePos, true); |
266 expect(largePos < largePosPlusOne, true); | 279 expect(largePos < largePosPlusOne, true); |
267 expect(largePos < largePos, false); | 280 expect(largePos < largePos, false); |
268 expect(largePosPlusOne < largePos, false); | 281 expect(largePosPlusOne < largePos, false); |
269 expect(Int64.MIN_VALUE < Int64.MAX_VALUE, true); | 282 expect(Int64.MIN_VALUE < Int64.MAX_VALUE, true); |
270 expect(Int64.MAX_VALUE < Int64.MIN_VALUE, false); | 283 expect(Int64.MAX_VALUE < Int64.MIN_VALUE, false); |
271 expect(() => new Int64(17) < null, throwsArgumentError); | 284 argumentErrorTest("<", (a, b) => a < b); |
272 }); | 285 }); |
273 | 286 |
274 test("<=", () { | 287 test("<=", () { |
275 expect(new Int64(10) <= new Int64(11), true); | 288 expect(new Int64(10) <= new Int64(11), true); |
276 expect(new Int64(10) <= new Int64(10), true); | 289 expect(new Int64(10) <= new Int64(10), true); |
277 expect(new Int64(10) <= new Int64(9), false); | 290 expect(new Int64(10) <= new Int64(9), false); |
278 expect(new Int64(10) <= new Int32(11), true); | 291 expect(new Int64(10) <= new Int32(11), true); |
279 expect(new Int64(10) <= new Int32(10), true); | 292 expect(new Int64(10) <= new Int32(10), true); |
280 expect(new Int64(10) <= new Int64(9), false); | 293 expect(new Int64(10) <= new Int64(9), false); |
281 expect(new Int64(-10) <= new Int64(-11), false); | 294 expect(new Int64(-10) <= new Int64(-11), false); |
282 expect(new Int64(-10) <= new Int64(-10), true); | 295 expect(new Int64(-10) <= new Int64(-10), true); |
283 expect(largeNeg <= largePos, true); | 296 expect(largeNeg <= largePos, true); |
284 expect(largePos <= largeNeg, false); | 297 expect(largePos <= largeNeg, false); |
285 expect(largePos <= largePosPlusOne, true); | 298 expect(largePos <= largePosPlusOne, true); |
286 expect(largePos <= largePos, true); | 299 expect(largePos <= largePos, true); |
287 expect(largePosPlusOne <= largePos, false); | 300 expect(largePosPlusOne <= largePos, false); |
288 expect(Int64.MIN_VALUE <= Int64.MAX_VALUE, true); | 301 expect(Int64.MIN_VALUE <= Int64.MAX_VALUE, true); |
289 expect(Int64.MAX_VALUE <= Int64.MIN_VALUE, false); | 302 expect(Int64.MAX_VALUE <= Int64.MIN_VALUE, false); |
290 expect(() => new Int64(17) <= null, throwsArgumentError); | 303 argumentErrorTest("<=", (a, b) => a <= b); |
291 }); | 304 }); |
292 | 305 |
293 test("==", () { | 306 test("==", () { |
294 expect(new Int64(10) == new Int64(11), false); | 307 expect(new Int64(10) == new Int64(11), false); |
295 expect(new Int64(10) == new Int64(10), true); | 308 expect(new Int64(10) == new Int64(10), true); |
296 expect(new Int64(10) == new Int64(9), false); | 309 expect(new Int64(10) == new Int64(9), false); |
297 expect(new Int64(10) == new Int32(11), false); | 310 expect(new Int64(10) == new Int32(11), false); |
298 expect(new Int64(10) == new Int32(10), true); | 311 expect(new Int64(10) == new Int32(10), true); |
299 expect(new Int64(10) == new Int32(9), false); | 312 expect(new Int64(10) == new Int32(9), false); |
300 expect(new Int64(-10) == new Int64(-10), true); | 313 expect(new Int64(-10) == new Int64(-10), true); |
(...skipping 15 matching lines...) Expand all Loading... |
316 expect(new Int64(10) >= new Int32(9), true); | 329 expect(new Int64(10) >= new Int32(9), true); |
317 expect(new Int64(-10) >= new Int64(-11), true); | 330 expect(new Int64(-10) >= new Int64(-11), true); |
318 expect(new Int64(-10) >= new Int64(-10), true); | 331 expect(new Int64(-10) >= new Int64(-10), true); |
319 expect(largePos >= largeNeg, true); | 332 expect(largePos >= largeNeg, true); |
320 expect(largeNeg >= largePos, false); | 333 expect(largeNeg >= largePos, false); |
321 expect(largePos >= largePosPlusOne, false); | 334 expect(largePos >= largePosPlusOne, false); |
322 expect(largePos >= largePos, true); | 335 expect(largePos >= largePos, true); |
323 expect(largePosPlusOne >= largePos, true); | 336 expect(largePosPlusOne >= largePos, true); |
324 expect(Int64.MIN_VALUE >= Int64.MAX_VALUE, false); | 337 expect(Int64.MIN_VALUE >= Int64.MAX_VALUE, false); |
325 expect(Int64.MAX_VALUE >= Int64.MIN_VALUE, true); | 338 expect(Int64.MAX_VALUE >= Int64.MIN_VALUE, true); |
326 expect(() => new Int64(17) >= null, throwsArgumentError); | 339 argumentErrorTest(">=", (a, b) => a >= b); |
327 }); | 340 }); |
328 | 341 |
329 test(">", () { | 342 test(">", () { |
330 expect(new Int64(10) > new Int64(11), false); | 343 expect(new Int64(10) > new Int64(11), false); |
331 expect(new Int64(10) > new Int64(10), false); | 344 expect(new Int64(10) > new Int64(10), false); |
332 expect(new Int64(10) > new Int64(9), true); | 345 expect(new Int64(10) > new Int64(9), true); |
333 expect(new Int64(10) > new Int32(11), false); | 346 expect(new Int64(10) > new Int32(11), false); |
334 expect(new Int64(10) > new Int32(10), false); | 347 expect(new Int64(10) > new Int32(10), false); |
335 expect(new Int64(10) > new Int32(9), true); | 348 expect(new Int64(10) > new Int32(9), true); |
336 expect(new Int64(-10) > new Int64(-11), true); | 349 expect(new Int64(-10) > new Int64(-11), true); |
337 expect(new Int64(10) > new Int64(-11), true); | 350 expect(new Int64(10) > new Int64(-11), true); |
338 expect(new Int64(-10) > new Int64(11), false); | 351 expect(new Int64(-10) > new Int64(11), false); |
339 expect(largePos > largeNeg, true); | 352 expect(largePos > largeNeg, true); |
340 expect(largeNeg > largePos, false); | 353 expect(largeNeg > largePos, false); |
341 expect(largePos > largePosPlusOne, false); | 354 expect(largePos > largePosPlusOne, false); |
342 expect(largePos > largePos, false); | 355 expect(largePos > largePos, false); |
343 expect(largePosPlusOne > largePos, true); | 356 expect(largePosPlusOne > largePos, true); |
344 expect(Int64.ZERO > Int64.MIN_VALUE, true); | 357 expect(Int64.ZERO > Int64.MIN_VALUE, true); |
345 expect(Int64.MIN_VALUE > Int64.MAX_VALUE, false); | 358 expect(Int64.MIN_VALUE > Int64.MAX_VALUE, false); |
346 expect(Int64.MAX_VALUE > Int64.MIN_VALUE, true); | 359 expect(Int64.MAX_VALUE > Int64.MIN_VALUE, true); |
347 expect(() => new Int64(17) > null, throwsArgumentError); | 360 argumentErrorTest(">", (a, b) => a > b); |
348 }); | 361 }); |
349 }); | 362 }); |
350 | 363 |
351 group("bitwise operators", () { | 364 group("bitwise operators", () { |
352 Int64 n1 = new Int64(1234); | 365 Int64 n1 = new Int64(1234); |
353 Int64 n2 = new Int64(9876); | 366 Int64 n2 = new Int64(9876); |
354 Int64 n3 = new Int64(-1234); | 367 Int64 n3 = new Int64(-1234); |
355 Int64 n4 = new Int64(0x1234) << 32; | 368 Int64 n4 = new Int64(0x1234) << 32; |
356 Int64 n5 = new Int64(0x9876) << 32; | 369 Int64 n5 = new Int64(0x9876) << 32; |
357 | 370 |
358 test("&", () { | 371 test("&", () { |
359 expect(n1 & n2, new Int64(1168)); | 372 expect(n1 & n2, new Int64(1168)); |
360 expect(n3 & n2, new Int64(8708)); | 373 expect(n3 & n2, new Int64(8708)); |
361 expect(n4 & n5, new Int64(0x1034) << 32); | 374 expect(n4 & n5, new Int64(0x1034) << 32); |
362 expect(() => n1 & null, throwsArgumentError); | 375 expect(() => n1 & null, throwsArgumentError); |
| 376 argumentErrorTest("&", (a, b) => a & b); |
363 }); | 377 }); |
364 | 378 |
365 test("|", () { | 379 test("|", () { |
366 expect(n1 | n2, new Int64(9942)); | 380 expect(n1 | n2, new Int64(9942)); |
367 expect(n3 | n2, new Int64(-66)); | 381 expect(n3 | n2, new Int64(-66)); |
368 expect(n4 | n5, new Int64(0x9a76) << 32); | 382 expect(n4 | n5, new Int64(0x9a76) << 32); |
369 expect(() => n1 | null, throwsArgumentError); | 383 expect(() => n1 | null, throwsArgumentError); |
| 384 argumentErrorTest("|", (a, b) => a | b); |
370 }); | 385 }); |
371 | 386 |
372 test("^", () { | 387 test("^", () { |
373 expect(n1 ^ n2, new Int64(8774)); | 388 expect(n1 ^ n2, new Int64(8774)); |
374 expect(n3 ^ n2, new Int64(-8774)); | 389 expect(n3 ^ n2, new Int64(-8774)); |
375 expect(n4 ^ n5, new Int64(0x8a42) << 32); | 390 expect(n4 ^ n5, new Int64(0x8a42) << 32); |
376 expect(() => n1 ^ null, throwsArgumentError); | 391 expect(() => n1 ^ null, throwsArgumentError); |
| 392 argumentErrorTest("^", (a, b) => a ^ b); |
377 }); | 393 }); |
378 | 394 |
379 test("~", () { | 395 test("~", () { |
380 expect(-new Int64(1), new Int64(-1)); | 396 expect(-new Int64(1), new Int64(-1)); |
381 expect(-new Int64(-1), new Int64(1)); | 397 expect(-new Int64(-1), new Int64(1)); |
382 expect(-Int64.MIN_VALUE, Int64.MIN_VALUE); | 398 expect(-Int64.MIN_VALUE, Int64.MIN_VALUE); |
383 | 399 |
384 expect(~n1, new Int64(-1235)); | 400 expect(~n1, new Int64(-1235)); |
385 expect(~n2, new Int64(-9877)); | 401 expect(~n2, new Int64(-9877)); |
386 expect(~n3, new Int64(1233)); | 402 expect(~n3, new Int64(1233)); |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
516 expect((Int64.ONE << 44).toSigned(46), Int64.ONE << 44); | 532 expect((Int64.ONE << 44).toSigned(46), Int64.ONE << 44); |
517 expect((Int64.ONE << 44).toSigned(45), -(Int64.ONE << 44)); | 533 expect((Int64.ONE << 44).toSigned(45), -(Int64.ONE << 44)); |
518 expect((Int64.ONE << 22).toSigned(24), Int64.ONE << 22); | 534 expect((Int64.ONE << 22).toSigned(24), Int64.ONE << 22); |
519 expect((Int64.ONE << 22).toSigned(23), -(Int64.ONE << 22)); | 535 expect((Int64.ONE << 22).toSigned(23), -(Int64.ONE << 22)); |
520 expect(Int64.ONE.toSigned(2), Int64.ONE); | 536 expect(Int64.ONE.toSigned(2), Int64.ONE); |
521 expect(Int64.ONE.toSigned(1), -Int64.ONE); | 537 expect(Int64.ONE.toSigned(1), -Int64.ONE); |
522 expect(Int64.MAX_VALUE.toSigned(64), Int64.MAX_VALUE); | 538 expect(Int64.MAX_VALUE.toSigned(64), Int64.MAX_VALUE); |
523 expect(Int64.MIN_VALUE.toSigned(64), Int64.MIN_VALUE); | 539 expect(Int64.MIN_VALUE.toSigned(64), Int64.MIN_VALUE); |
524 expect(Int64.MAX_VALUE.toSigned(63), -Int64.ONE); | 540 expect(Int64.MAX_VALUE.toSigned(63), -Int64.ONE); |
525 expect(Int64.MIN_VALUE.toSigned(63), Int64.ZERO); | 541 expect(Int64.MIN_VALUE.toSigned(63), Int64.ZERO); |
526 expect(() => Int64.ONE.toSigned(0), throws); | 542 expect(() => Int64.ONE.toSigned(0), throwsRangeError); |
527 expect(() => Int64.ONE.toSigned(65), throws); | 543 expect(() => Int64.ONE.toSigned(65), throwsRangeError); |
528 }); | 544 }); |
529 test("toUnsigned", () { | 545 test("toUnsigned", () { |
530 expect((Int64.ONE << 44).toUnsigned(45), Int64.ONE << 44); | 546 expect((Int64.ONE << 44).toUnsigned(45), Int64.ONE << 44); |
531 expect((Int64.ONE << 44).toUnsigned(44), Int64.ZERO); | 547 expect((Int64.ONE << 44).toUnsigned(44), Int64.ZERO); |
532 expect((Int64.ONE << 22).toUnsigned(23), Int64.ONE << 22); | 548 expect((Int64.ONE << 22).toUnsigned(23), Int64.ONE << 22); |
533 expect((Int64.ONE << 22).toUnsigned(22), Int64.ZERO); | 549 expect((Int64.ONE << 22).toUnsigned(22), Int64.ZERO); |
534 expect(Int64.ONE.toUnsigned(1), Int64.ONE); | 550 expect(Int64.ONE.toUnsigned(1), Int64.ONE); |
535 expect(Int64.ONE.toUnsigned(0), Int64.ZERO); | 551 expect(Int64.ONE.toUnsigned(0), Int64.ZERO); |
536 expect(Int64.MAX_VALUE.toUnsigned(64), Int64.MAX_VALUE); | 552 expect(Int64.MAX_VALUE.toUnsigned(64), Int64.MAX_VALUE); |
537 expect(Int64.MIN_VALUE.toUnsigned(64), Int64.MIN_VALUE); | 553 expect(Int64.MIN_VALUE.toUnsigned(64), Int64.MIN_VALUE); |
538 expect(Int64.MAX_VALUE.toUnsigned(63), Int64.MAX_VALUE); | 554 expect(Int64.MAX_VALUE.toUnsigned(63), Int64.MAX_VALUE); |
539 expect(Int64.MIN_VALUE.toUnsigned(63), Int64.ZERO); | 555 expect(Int64.MIN_VALUE.toUnsigned(63), Int64.ZERO); |
540 expect(() => Int64.ONE.toUnsigned(-1), throws); | 556 expect(() => Int64.ONE.toUnsigned(-1), throwsRangeError); |
541 expect(() => Int64.ONE.toUnsigned(65), throws); | 557 expect(() => Int64.ONE.toUnsigned(65), throwsRangeError); |
542 }); | 558 }); |
543 test("toDouble", () { | 559 test("toDouble", () { |
544 expect(new Int64(0).toDouble(), same(0.0)); | 560 expect(new Int64(0).toDouble(), same(0.0)); |
545 expect(new Int64(100).toDouble(), same(100.0)); | 561 expect(new Int64(100).toDouble(), same(100.0)); |
546 expect(new Int64(-100).toDouble(), same(-100.0)); | 562 expect(new Int64(-100).toDouble(), same(-100.0)); |
547 expect(new Int64(2147483647).toDouble(), same(2147483647.0)); | 563 expect(new Int64(2147483647).toDouble(), same(2147483647.0)); |
548 expect(new Int64(2147483648).toDouble(), same(2147483648.0)); | 564 expect(new Int64(2147483648).toDouble(), same(2147483648.0)); |
549 expect(new Int64(-2147483647).toDouble(), same(-2147483647.0)); | 565 expect(new Int64(-2147483647).toDouble(), same(-2147483647.0)); |
550 expect(new Int64(-2147483648).toDouble(), same(-2147483648.0)); | 566 expect(new Int64(-2147483648).toDouble(), same(-2147483648.0)); |
551 expect(new Int64(4503599627370495).toDouble(), same(4503599627370495.0)); | 567 expect(new Int64(4503599627370495).toDouble(), same(4503599627370495.0)); |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
651 checkInt(12345678); | 667 checkInt(12345678); |
652 checkInt(-12345678); | 668 checkInt(-12345678); |
653 checkInt(2147483647); | 669 checkInt(2147483647); |
654 checkInt(2147483648); | 670 checkInt(2147483648); |
655 checkInt(-2147483647); | 671 checkInt(-2147483647); |
656 checkInt(-2147483648); | 672 checkInt(-2147483648); |
657 checkInt(4294967295); | 673 checkInt(4294967295); |
658 checkInt(4294967296); | 674 checkInt(4294967296); |
659 checkInt(-4294967295); | 675 checkInt(-4294967295); |
660 checkInt(-4294967296); | 676 checkInt(-4294967296); |
661 expect(() => Int64.parseRadix('xyzzy', -1), throwsArgumentError); | |
662 expect(() => Int64.parseRadix('plugh', 10), | |
663 throwsA(new isInstanceOf<FormatException>())); | |
664 }); | 677 }); |
665 | 678 |
666 test("parseRadix", () { | 679 test("parseRadix", () { |
667 check(String s, int r, String x) { | 680 check(String s, int r, String x) { |
668 expect(Int64.parseRadix(s, r).toString(), x); | 681 expect(Int64.parseRadix(s, r).toString(), x); |
669 } | 682 } |
670 check('ghoul', 36, '27699213'); | 683 check('ghoul', 36, '27699213'); |
671 check('ghoul', 35, '24769346'); | 684 check('ghoul', 35, '24769346'); |
672 // Min and max value. | 685 // Min and max value. |
673 check("-9223372036854775808", 10, "-9223372036854775808"); | 686 check("-9223372036854775808", 10, "-9223372036854775808"); |
674 check("9223372036854775807", 10, "9223372036854775807"); | 687 check("9223372036854775807", 10, "9223372036854775807"); |
675 // Overflow during parsing. | 688 // Overflow during parsing. |
676 check("9223372036854775808", 10, "-9223372036854775808"); | 689 check("9223372036854775808", 10, "-9223372036854775808"); |
| 690 |
| 691 expect(() => Int64.parseRadix('0', 1), throwsRangeError); |
| 692 expect(() => Int64.parseRadix('0', 37), throwsRangeError); |
| 693 expect(() => Int64.parseRadix('xyzzy', -1), throwsRangeError); |
| 694 expect(() => Int64.parseRadix('xyzzy', 10), throwsFormatException); |
677 }); | 695 }); |
678 | 696 |
679 test("parseRadixN", () { | 697 test("parseRadixN", () { |
680 check(String s, int r) { | 698 check(String s, int r) { |
681 expect(Int64.parseRadix(s, r).toRadixString(r), s); | 699 expect(Int64.parseRadix(s, r).toRadixString(r), s); |
682 } | 700 } |
683 check("2ppp111222333", 33); // This value & radix requires three chunks. | 701 check("2ppp111222333", 33); // This value & radix requires three chunks. |
684 }); | 702 }); |
685 }); | 703 }); |
686 | 704 |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
741 expect(Int64.MAX_VALUE.toRadixString(6), "1540241003031030222122211"); | 759 expect(Int64.MAX_VALUE.toRadixString(6), "1540241003031030222122211"); |
742 expect(Int64.MAX_VALUE.toRadixString(7), "22341010611245052052300"); | 760 expect(Int64.MAX_VALUE.toRadixString(7), "22341010611245052052300"); |
743 expect(Int64.MAX_VALUE.toRadixString(8), "777777777777777777777"); | 761 expect(Int64.MAX_VALUE.toRadixString(8), "777777777777777777777"); |
744 expect(Int64.MAX_VALUE.toRadixString(9), "67404283172107811827"); | 762 expect(Int64.MAX_VALUE.toRadixString(9), "67404283172107811827"); |
745 expect(Int64.MAX_VALUE.toRadixString(10), "9223372036854775807"); | 763 expect(Int64.MAX_VALUE.toRadixString(10), "9223372036854775807"); |
746 expect(Int64.MAX_VALUE.toRadixString(11), "1728002635214590697"); | 764 expect(Int64.MAX_VALUE.toRadixString(11), "1728002635214590697"); |
747 expect(Int64.MAX_VALUE.toRadixString(12), "41a792678515120367"); | 765 expect(Int64.MAX_VALUE.toRadixString(12), "41a792678515120367"); |
748 expect(Int64.MAX_VALUE.toRadixString(13), "10b269549075433c37"); | 766 expect(Int64.MAX_VALUE.toRadixString(13), "10b269549075433c37"); |
749 expect(Int64.MAX_VALUE.toRadixString(14), "4340724c6c71dc7a7"); | 767 expect(Int64.MAX_VALUE.toRadixString(14), "4340724c6c71dc7a7"); |
750 expect(Int64.MAX_VALUE.toRadixString(15), "160e2ad3246366807"); | 768 expect(Int64.MAX_VALUE.toRadixString(15), "160e2ad3246366807"); |
751 expect(Int64.MAX_VALUE.toRadixString(16), "7fffffffffffffff"); | 769 expect(() => Int64.ZERO.toRadixString(1), throwsRangeError); |
| 770 expect(() => Int64.ZERO.toRadixString(37), throwsRangeError); |
752 }); | 771 }); |
753 }); | 772 }); |
754 } | 773 } |
OLD | NEW |