Merge in changes from SDK branch

test/int64_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library int64test;
 
 import 'package:fixnum/fixnum.dart';
 import 'package:unittest/unittest.dart';
 
 void main() {
@@ skipping 17 matching lines @@
       checkBytes([ 0, 0, 0, 0, 0, 0, 0, 0 ], 0, 0);
       checkBytes([ 0, 0, 0, 0, 0, 0, 0, 1 ], 0, 1);
       checkBytes([ 8, 7, 6, 5, 4, 3, 2, 1 ], 0x08070605, 0x04030201);
       checkBytes([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe ],
           0xffffffff, 0xfffffffe);
       checkBytes([ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff ],
           0xffffffff, 0xffffffff);
     });
   });
 
+  argumentErrorTest(name, op, [receiver = Int64.ONE]) {
+    throwsArgumentErrorMentioning(substring) =>
+        throwsA((e) => e is ArgumentError && '$e'.contains(substring));
+
+    expect(() => op(receiver, null), throwsArgumentErrorMentioning('null'));
+    expect(() => op(receiver, 'foo'), throwsArgumentErrorMentioning(r'"foo"'));
+  }
+
   group("is-tests", () {
     test("isEven", () {
       expect((-Int64.ONE).isEven, false);
       expect(Int64.ZERO.isEven, true);
       expect(Int64.ONE.isEven, false);
       expect(Int64.TWO.isEven, true);
     });
     test("isMaxValue", () {
       expect(Int64.MIN_VALUE.isMaxValue, false);
       expect(Int64.ZERO.isMaxValue, false);
@@ skipping 41 matching lines @@
     Int64 n4 = new Int64(-9876);
     Int64 n5 = new Int64.fromInts(0x12345678, 0xabcdabcd);
     Int64 n6 = new Int64.fromInts(0x77773333, 0x22224444);
 
     test("+", () {
       expect(n1 + n2, new Int64(11110));
       expect(n3 + n2, new Int64(8642));
       expect(n3 + n4, new Int64(-11110));
       expect(n5 + n6, new Int64.fromInts(0x89ab89ab, 0xcdeff011));
       expect(Int64.MAX_VALUE + 1, Int64.MIN_VALUE);
+      argumentErrorTest("+", (a, b) => a + b);
     });
 
     test("-", () {
       expect(n1 - n2, new Int64(-8642));
       expect(n3 - n2, new Int64(-11110));
       expect(n3 - n4, new Int64(8642));
       expect(n5 - n6, new Int64.fromInts(0x9abd2345, 0x89ab6789));
       expect(Int64.MIN_VALUE - 1, Int64.MAX_VALUE);
+      argumentErrorTest("-", (a, b) => a - b);
     });
 
     test("unary -", () {
       expect(-n1, new Int64(-1234));
       expect(-Int64.ZERO, Int64.ZERO);
     });
 
     test("*", () {
       expect(new Int64(1111) * new Int64(3), new Int64(3333));
       expect(new Int64(1111) * new Int64(-3), new Int64(-3333));
@@ skipping 17 matching lines @@
       expect((new Int64(123456789) * new Int32(987654321)),
           new Int64.fromInts(0x1b13114, 0xfbff5385));
 
       // Wraparound
       expect((new Int64(123456789) * new Int64(987654321)),
           new Int64.fromInts(0x1b13114, 0xfbff5385));
 
       expect(Int64.MIN_VALUE * new Int64(2), Int64.ZERO);
       expect(Int64.MIN_VALUE * new Int64(1), Int64.MIN_VALUE);
       expect(Int64.MIN_VALUE * new Int64(-1), Int64.MIN_VALUE);
+      argumentErrorTest("*", (a, b) => a * b);
     });
 
     test("~/", () {
       Int64 deadBeef = new Int64.fromInts(0xDEADBEEF, 0xDEADBEEF);
       Int64 ten = new Int64(10);
 
       expect(deadBeef ~/ ten, new Int64.fromInts(0xfcaaf97e, 0x63115fe5));
       expect(Int64.ONE ~/ Int64.TWO, Int64.ZERO);
       expect(Int64.MAX_VALUE ~/ Int64.TWO,
           new Int64.fromInts(0x3fffffff, 0xffffffff));
@@ skipping 52 matching lines @@
       expect(new Int64(829893893) ~/ new Int32(1919), new Int32(432461));
       expect(new Int64(829893893) ~/ new Int64(1919), new Int32(432461));
       expect(new Int64(829893893) ~/ 1919, new Int32(432461));
       expect(() => new Int64(1) ~/ Int64.ZERO,
           throwsA(new isInstanceOf<IntegerDivisionByZeroException>()));
       expect(Int64.MIN_VALUE ~/ new Int64(2),
           new Int64.fromInts(0xc0000000, 0x00000000));
       expect(Int64.MIN_VALUE ~/ new Int64(1), Int64.MIN_VALUE);
       expect(Int64.MIN_VALUE ~/ new Int64(-1), Int64.MIN_VALUE);
       expect(() => new Int64(17) ~/ Int64.ZERO, throws);
-      expect(() => new Int64(17) ~/ null, throwsArgumentError);
+      argumentErrorTest("~/", (a, b) => a ~/ b);
     });
 
     test("%", () {
       // Define % as Euclidean mod, with positive result for all arguments
       expect(Int64.ZERO % new Int64(1000), Int64.ZERO);
       expect(Int64.MIN_VALUE % Int64.MIN_VALUE, Int64.ZERO);
       expect(new Int64(1000) % Int64.MIN_VALUE, new Int64(1000));
       expect(Int64.MIN_VALUE % new Int64(8192), Int64.ZERO);
       expect(Int64.MIN_VALUE % new Int64(8193), new Int64(6145));
       expect(new Int64(-1000) % new Int64(8192), new Int64(7192));
@@ skipping 19 matching lines @@
       expect(new Int64(0x12345678).remainder(new Int64(0x22)),
           new Int64(0x12345678.remainder(0x22)));
       expect(new Int64(0x12345678).remainder(new Int64(-0x22)),
           new Int64(0x12345678.remainder(-0x22)));
       expect(new Int64(-0x12345678).remainder(new Int64(-0x22)),
           new Int64(-0x12345678.remainder(-0x22)));
       expect(new Int64(-0x12345678).remainder(new Int64(0x22)),
           new Int64(-0x12345678.remainder(0x22)));
       expect(new Int32(0x12345678).remainder(new Int64(0x22)),
           new Int64(0x12345678.remainder(0x22)));
+      argumentErrorTest("%", (a, b) => a % b);
     });
 
     test("clamp", () {
       Int64 val = new Int64(17);
       expect(val.clamp(20, 30), new Int64(20));
       expect(val.clamp(10, 20), new Int64(17));
       expect(val.clamp(10, 15), new Int64(15));
 
       expect(val.clamp(new Int32(20), new Int32(30)), new Int64(20));
       expect(val.clamp(new Int32(10), new Int32(20)), new Int64(17));
@@ skipping 54 matching lines @@
       expect(new Int64(10) < new Int32(10), false);
       expect(new Int64(10) < new Int32(9), false);
       expect(new Int64(-10) < new Int64(-11), false);
       expect(Int64.MIN_VALUE < Int64.ZERO, true);
       expect(largeNeg < largePos, true);
       expect(largePos < largePosPlusOne, true);
       expect(largePos < largePos, false);
       expect(largePosPlusOne < largePos, false);
       expect(Int64.MIN_VALUE < Int64.MAX_VALUE, true);
       expect(Int64.MAX_VALUE < Int64.MIN_VALUE, false);
-      expect(() => new Int64(17) < null, throwsArgumentError);
+      argumentErrorTest("<", (a, b) => a < b);
     });
 
     test("<=", () {
       expect(new Int64(10) <= new Int64(11), true);
       expect(new Int64(10) <= new Int64(10), true);
       expect(new Int64(10) <= new Int64(9), false);
       expect(new Int64(10) <= new Int32(11), true);
       expect(new Int64(10) <= new Int32(10), true);
       expect(new Int64(10) <= new Int64(9), false);
       expect(new Int64(-10) <= new Int64(-11), false);
       expect(new Int64(-10) <= new Int64(-10), true);
       expect(largeNeg <= largePos, true);
       expect(largePos <= largeNeg, false);
       expect(largePos <= largePosPlusOne, true);
       expect(largePos <= largePos, true);
       expect(largePosPlusOne <= largePos, false);
       expect(Int64.MIN_VALUE <= Int64.MAX_VALUE, true);
       expect(Int64.MAX_VALUE <= Int64.MIN_VALUE, false);
-      expect(() => new Int64(17) <= null, throwsArgumentError);
+      argumentErrorTest("<=", (a, b) => a <= b);
     });
 
     test("==", () {
       expect(new Int64(0) == new Int64(0), true);
       expect(new Int64(0) == new Int64(1), false);
       expect(new Int64(0) == new Int32(0), true);
       expect(new Int64(0) == new Int32(1), false);
       expect(new Int64(0) == 0, true);
       expect(new Int64(0) == 1, false);
       expect(new Int64(10) == new Int64(11), false);
@@ skipping 26 matching lines @@
       expect(new Int64(10) >= new Int32(9), true);
       expect(new Int64(-10) >= new Int64(-11), true);
       expect(new Int64(-10) >= new Int64(-10), true);
       expect(largePos >= largeNeg, true);
       expect(largeNeg >= largePos, false);
       expect(largePos >= largePosPlusOne, false);
       expect(largePos >= largePos, true);
       expect(largePosPlusOne >= largePos, true);
       expect(Int64.MIN_VALUE >= Int64.MAX_VALUE, false);
       expect(Int64.MAX_VALUE >= Int64.MIN_VALUE, true);
-      expect(() => new Int64(17) >= null, throwsArgumentError);
+      argumentErrorTest(">=", (a, b) => a >= b);
     });
 
     test(">", () {
       expect(new Int64(10) > new Int64(11), false);
       expect(new Int64(10) > new Int64(10), false);
       expect(new Int64(10) > new Int64(9), true);
       expect(new Int64(10) > new Int32(11), false);
       expect(new Int64(10) > new Int32(10), false);
       expect(new Int64(10) > new Int32(9), true);
       expect(new Int64(-10) > new Int64(-11), true);
       expect(new Int64(10) > new Int64(-11), true);
       expect(new Int64(-10) > new Int64(11), false);
       expect(largePos > largeNeg, true);
       expect(largeNeg > largePos, false);
       expect(largePos > largePosPlusOne, false);
       expect(largePos > largePos, false);
       expect(largePosPlusOne > largePos, true);
       expect(Int64.ZERO > Int64.MIN_VALUE, true);
       expect(Int64.MIN_VALUE > Int64.MAX_VALUE, false);
       expect(Int64.MAX_VALUE > Int64.MIN_VALUE, true);
-      expect(() => new Int64(17) > null, throwsArgumentError);
+      argumentErrorTest(">", (a, b) => a > b);
     });
   });
 
   group("bitwise operators", () {
     Int64 n1 = new Int64(1234);
     Int64 n2 = new Int64(9876);
     Int64 n3 = new Int64(-1234);
     Int64 n4 = new Int64(0x1234) << 32;
     Int64 n5 = new Int64(0x9876) << 32;
 
     test("&", () {
       expect(n1 & n2, new Int64(1168));
       expect(n3 & n2, new Int64(8708));
       expect(n4 & n5, new Int64(0x1034) << 32);
       expect(() => n1 & null, throwsArgumentError);
+      argumentErrorTest("&", (a, b) => a & b);
     });
 
     test("|", () {
       expect(n1 | n2, new Int64(9942));
       expect(n3 | n2, new Int64(-66));
       expect(n4 | n5, new Int64(0x9a76) << 32);
       expect(() => n1 | null, throwsArgumentError);
+      argumentErrorTest("|", (a, b) => a | b);
     });
 
     test("^", () {
       expect(n1 ^ n2, new Int64(8774));
       expect(n3 ^ n2, new Int64(-8774));
       expect(n4 ^ n5, new Int64(0x8a42) << 32);
       expect(() => n1 ^ null, throwsArgumentError);
+      argumentErrorTest("^", (a, b) => a ^ b);
     });
 
     test("~", () {
       expect(-new Int64(1), new Int64(-1));
       expect(-new Int64(-1), new Int64(1));
       expect(-Int64.MIN_VALUE, Int64.MIN_VALUE);
 
       expect(~n1, new Int64(-1235));
       expect(~n2, new Int64(-9877));
       expect(~n3, new Int64(1233));
@@ skipping 128 matching lines @@
       expect((Int64.ONE << 44).toSigned(46), Int64.ONE << 44);
       expect((Int64.ONE << 44).toSigned(45), -(Int64.ONE << 44));
       expect((Int64.ONE << 22).toSigned(24), Int64.ONE << 22);
       expect((Int64.ONE << 22).toSigned(23), -(Int64.ONE << 22));
       expect(Int64.ONE.toSigned(2), Int64.ONE);
       expect(Int64.ONE.toSigned(1), -Int64.ONE);
       expect(Int64.MAX_VALUE.toSigned(64), Int64.MAX_VALUE);
       expect(Int64.MIN_VALUE.toSigned(64), Int64.MIN_VALUE);
       expect(Int64.MAX_VALUE.toSigned(63), -Int64.ONE);
       expect(Int64.MIN_VALUE.toSigned(63), Int64.ZERO);
-      expect(() => Int64.ONE.toSigned(0), throws);
-      expect(() => Int64.ONE.toSigned(65), throws);
+      expect(() => Int64.ONE.toSigned(0), throwsRangeError);
+      expect(() => Int64.ONE.toSigned(65), throwsRangeError);
     });
     test("toUnsigned", () {
       expect((Int64.ONE << 44).toUnsigned(45), Int64.ONE << 44);
       expect((Int64.ONE << 44).toUnsigned(44), Int64.ZERO);
       expect((Int64.ONE << 22).toUnsigned(23), Int64.ONE << 22);
       expect((Int64.ONE << 22).toUnsigned(22), Int64.ZERO);
       expect(Int64.ONE.toUnsigned(1), Int64.ONE);
       expect(Int64.ONE.toUnsigned(0), Int64.ZERO);
       expect(Int64.MAX_VALUE.toUnsigned(64), Int64.MAX_VALUE);
       expect(Int64.MIN_VALUE.toUnsigned(64), Int64.MIN_VALUE);
       expect(Int64.MAX_VALUE.toUnsigned(63), Int64.MAX_VALUE);
       expect(Int64.MIN_VALUE.toUnsigned(63), Int64.ZERO);
-      expect(() => Int64.ONE.toUnsigned(-1), throws);
-      expect(() => Int64.ONE.toUnsigned(65), throws);
+      expect(() => Int64.ONE.toUnsigned(-1), throwsRangeError);
+      expect(() => Int64.ONE.toUnsigned(65), throwsRangeError);
     });
     test("toDouble", () {
       expect(new Int64(0).toDouble(), same(0.0));
       expect(new Int64(100).toDouble(), same(100.0));
       expect(new Int64(-100).toDouble(), same(-100.0));
       expect(new Int64(2147483647).toDouble(), same(2147483647.0));
       expect(new Int64(2147483648).toDouble(), same(2147483648.0));
       expect(new Int64(-2147483647).toDouble(), same(-2147483647.0));
       expect(new Int64(-2147483648).toDouble(), same(-2147483648.0));
       expect(new Int64(4503599627370495).toDouble(), same(4503599627370495.0));
       expect(new Int64(4503599627370496).toDouble(), same(4503599627370496.0));
-      expect(
-          new Int64(-4503599627370495).toDouble(), same(-4503599627370495.0));
-      expect(
-          new Int64(-4503599627370496).toDouble(), same(-4503599627370496.0));
-      expect(Int64
-          .parseInt("-10000000000000000")
-          .toDouble()
-          .toStringAsFixed(1), "-10000000000000000.0");
+      expect(new Int64(-4503599627370495).toDouble(),
+          same(-4503599627370495.0));
+      expect(new Int64(-4503599627370496).toDouble(),
+          same(-4503599627370496.0));
+      expect(Int64.parseInt("-10000000000000000").toDouble().toStringAsFixed(1),
+          "-10000000000000000.0");
       expect(Int64.parseInt("-10000000000000001").toDouble().toStringAsFixed(1),
           "-10000000000000000.0");
       expect(Int64.parseInt("-10000000000000002").toDouble().toStringAsFixed(1),
           "-10000000000000002.0");
       expect(Int64.parseInt("-10000000000000003").toDouble().toStringAsFixed(1),
           "-10000000000000004.0");
       expect(Int64.parseInt("-10000000000000004").toDouble().toStringAsFixed(1),
           "-10000000000000004.0");
       expect(Int64.parseInt("-10000000000000005").toDouble().toStringAsFixed(1),
           "-10000000000000004.0");
@@ skipping 10 matching lines @@
       expect(new Int64(100).toInt(), 100);
       expect(new Int64(-100).toInt(), -100);
       expect(new Int64(2147483647).toInt(), 2147483647);
       expect(new Int64(2147483648).toInt(), 2147483648);
       expect(new Int64(-2147483647).toInt(), -2147483647);
       expect(new Int64(-2147483648).toInt(), -2147483648);
       expect(new Int64(4503599627370495).toInt(), 4503599627370495);
       expect(new Int64(4503599627370496).toInt(), 4503599627370496);
       expect(new Int64(-4503599627370495).toInt(), -4503599627370495);
       expect(new Int64(-4503599627370496).toInt(), -4503599627370496);
-      expect(Int64
-          .parseInt("-10000000000000000")
-          .toInt(), same(-10000000000000000));
+      expect(Int64.parseInt("-10000000000000000").toInt(),
+          same(-10000000000000000));
       expect(Int64.parseInt("-10000000000000001").toInt(),
           same(-10000000000000001));
       expect(Int64.parseInt("-10000000000000002").toInt(),
           same(-10000000000000002));
       expect(Int64.parseInt("-10000000000000003").toInt(),
           same(-10000000000000003));
       expect(Int64.parseInt("-10000000000000004").toInt(),
           same(-10000000000000004));
       expect(Int64.parseInt("-10000000000000005").toInt(),
           same(-10000000000000005));
@@ skipping 95 matching lines @@
       check(String s, int r, String x) {
         expect(Int64.parseRadix(s, r).toString(), x);
       }
       check('ghoul', 36, '27699213');
       check('ghoul', 35, '24769346');
       // Min and max value.
       check("-9223372036854775808", 10, "-9223372036854775808");
       check("9223372036854775807", 10, "9223372036854775807");
       // Overflow during parsing.
       check("9223372036854775808", 10, "-9223372036854775808");
+
+      expect(() => Int64.parseRadix('0', 1), throwsRangeError);
+      expect(() => Int64.parseRadix('0', 37), throwsRangeError);
+      expect(() => Int64.parseRadix('xyzzy', -1), throwsRangeError);
+      expect(() => Int64.parseRadix('xyzzy', 10), throwsFormatException);
     });
 
     test("parseRadixN", () {
       check(String s, int r) {
         expect(Int64.parseRadix(s, r).toRadixString(r), s);
       }
-      check("2ppp111222333", 33); // This value & radix requires three chunks.
+      check("2ppp111222333", 33);  // This value & radix requires three chunks.
     });
   });
 
   group("string representation", () {
     test("toString", () {
       expect(new Int64(0).toString(), "0");
       expect(new Int64(1).toString(), "1");
       expect(new Int64(-1).toString(), "-1");
       expect(new Int64(-10).toString(), "-10");
       expect(Int64.MIN_VALUE.toString(), "-9223372036854775808");
@@ skipping 34 matching lines @@
       expect(Int64.MIN_VALUE.toRadixString(11), "-1728002635214590698");
       expect(Int64.MIN_VALUE.toRadixString(12), "-41a792678515120368");
       expect(Int64.MIN_VALUE.toRadixString(13), "-10b269549075433c38");
       expect(Int64.MIN_VALUE.toRadixString(14), "-4340724c6c71dc7a8");
       expect(Int64.MIN_VALUE.toRadixString(15), "-160e2ad3246366808");
       expect(Int64.MIN_VALUE.toRadixString(16), "-8000000000000000");
       expect(Int64.MAX_VALUE.toRadixString(2),
           "111111111111111111111111111111111111111111111111111111111111111");
       expect(Int64.MAX_VALUE.toRadixString(3),
           "2021110011022210012102010021220101220221");
-      expect(
-          Int64.MAX_VALUE.toRadixString(4), "13333333333333333333333333333333");
+      expect(Int64.MAX_VALUE.toRadixString(4),
+          "13333333333333333333333333333333");
       expect(Int64.MAX_VALUE.toRadixString(5), "1104332401304422434310311212");
       expect(Int64.MAX_VALUE.toRadixString(6), "1540241003031030222122211");
       expect(Int64.MAX_VALUE.toRadixString(7), "22341010611245052052300");
       expect(Int64.MAX_VALUE.toRadixString(8), "777777777777777777777");
       expect(Int64.MAX_VALUE.toRadixString(9), "67404283172107811827");
       expect(Int64.MAX_VALUE.toRadixString(10), "9223372036854775807");
       expect(Int64.MAX_VALUE.toRadixString(11), "1728002635214590697");
       expect(Int64.MAX_VALUE.toRadixString(12), "41a792678515120367");
       expect(Int64.MAX_VALUE.toRadixString(13), "10b269549075433c37");
       expect(Int64.MAX_VALUE.toRadixString(14), "4340724c6c71dc7a7");
       expect(Int64.MAX_VALUE.toRadixString(15), "160e2ad3246366807");
       expect(Int64.MAX_VALUE.toRadixString(16), "7fffffffffffffff");
       expect(() => new Int64(42).toRadixString(-1), throwsArgumentError);
       expect(() => new Int64(42).toRadixString(0), throwsArgumentError);
       expect(() => new Int64(42).toRadixString(37), throwsArgumentError);
     });
   });
 }