Don't throw exception for non-integer args to fixnum int32,int64 op ==

pkg/fixnum/test/int_64_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() {
   group("arithmetic operators", () {
@@ skipping 141 matching lines @@
           new int32.fromInt(432461));
       expect(new int64.fromInt(829893893) ~/ 1919,
           new int32.fromInt(432461));
       expect(() => new int64.fromInt(1) ~/ new int64.fromInt(0),
           throwsA(new isInstanceOf<IntegerDivisionByZeroException>()));
       expect(int64.MIN_VALUE ~/ new int64.fromInt(2),
           new int64.fromInts(0xc0000000, 0x00000000));
       expect(int64.MIN_VALUE ~/ new int64.fromInt(1), int64.MIN_VALUE);
       expect(int64.MIN_VALUE ~/ new int64.fromInt(-1), int64.MIN_VALUE);
       expect(() => new int64.fromInt(17) ~/ int64.ZERO, throws);
-      expect(() => new int64.fromInt(17) ~/ null, throws);
+      expect(() => new int64.fromInt(17) ~/ null, throwsArgumentError);
     });
 
     test("%", () {
       // Define % as Euclidean mod, with positive result for all arguments
       expect(int64.ZERO % new int64.fromInt(1000), new int64.fromInt(0));
       expect(int64.MIN_VALUE % int64.MIN_VALUE, new int64.fromInt(0));
       expect(new int64.fromInt(1000) % int64.MIN_VALUE,
           new int64.fromInt(1000));
       expect(int64.MIN_VALUE % new int64.fromInt(8192), new int64.fromInt(0));
       expect(int64.MIN_VALUE % new int64.fromInt(8193),
@@ skipping 38 matching lines @@
   });
 
   group("comparison operators", () {
     int64 largeNeg = new int64.fromInts(0x82341234, 0x0);
     int64 largePos = new int64.fromInts(0x12341234, 0x0);
     int64 largePosPlusOne = largePos + new int64.fromInt(1);
 
     test("<", () {
       expect(new int64.fromInt(10) < new int64.fromInt(11), true);
       expect(new int64.fromInt(10) < new int64.fromInt(10), false);
-      expect(new int64.fromInt(12) < new int64.fromInt(11), false);
+      expect(new int64.fromInt(10) < new int64.fromInt(9), false);
+      expect(new int64.fromInt(10) < new int32.fromInt(11), true);
+      expect(new int64.fromInt(10) < new int32.fromInt(10), false);
+      expect(new int64.fromInt(10) < new int32.fromInt(9), false);
       expect(new int64.fromInt(-10) < new int64.fromInt(-11), false);
       expect(int64.MIN_VALUE < new int64.fromInt(0), 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.fromInt(17) < null, throwsArgumentError);
     });
 
     test("<=", () {
       expect(new int64.fromInt(10) <= new int64.fromInt(11), true);
       expect(new int64.fromInt(10) <= new int64.fromInt(10), true);
-      expect(new int64.fromInt(12) <= new int64.fromInt(11), false);
+      expect(new int64.fromInt(10) <= new int64.fromInt(9), false);
+      expect(new int64.fromInt(10) <= new int32.fromInt(11), true);
+      expect(new int64.fromInt(10) <= new int32.fromInt(10), true);
+      expect(new int64.fromInt(10) <= new int64.fromInt(9), false);
       expect(new int64.fromInt(-10) <= new int64.fromInt(-11), false);
       expect(new int64.fromInt(-10) <= new int64.fromInt(-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.fromInt(17) <= null, throwsArgumentError);
     });
 
     test("==", () {
       expect(new int64.fromInt(10) == new int64.fromInt(11), false);
       expect(new int64.fromInt(10) == new int64.fromInt(10), true);
-      expect(new int64.fromInt(12) == new int64.fromInt(11), false);
+      expect(new int64.fromInt(10) == new int64.fromInt(9), false);
+      expect(new int64.fromInt(10) == new int32.fromInt(11), false);
+      expect(new int64.fromInt(10) == new int32.fromInt(10), true);
+      expect(new int64.fromInt(10) == new int32.fromInt(9), false);
       expect(new int64.fromInt(-10) == new int64.fromInt(-10), true);
       expect(new int64.fromInt(-10) != new int64.fromInt(-10), false);
       expect(largePos == largePos, true);
       expect(largePos == largePosPlusOne, false);
       expect(largePosPlusOne == largePos, false);
       expect(int64.MIN_VALUE == int64.MAX_VALUE, false);
+      expect(new int64.fromInt(17) == new Object(), false);
       expect(new int64.fromInt(17) == null, false);
     });
 
     test(">=", () {
       expect(new int64.fromInt(10) >= new int64.fromInt(11), false);
       expect(new int64.fromInt(10) >= new int64.fromInt(10), true);
-      expect(new int64.fromInt(12) >= new int64.fromInt(11), true);
+      expect(new int64.fromInt(10) >= new int64.fromInt(9), true);
+      expect(new int64.fromInt(10) >= new int32.fromInt(11), false);
+      expect(new int64.fromInt(10) >= new int32.fromInt(10), true);
+      expect(new int64.fromInt(10) >= new int32.fromInt(9), true);
       expect(new int64.fromInt(-10) >= new int64.fromInt(-11), true);
       expect(new int64.fromInt(-10) >= new int64.fromInt(-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.fromInt(17) >= null, throwsArgumentError);
     });
 
     test(">", () {
       expect(new int64.fromInt(10) > new int64.fromInt(11), false);
       expect(new int64.fromInt(10) > new int64.fromInt(10), false);
-      expect(new int64.fromInt(12) > new int64.fromInt(11), true);
+      expect(new int64.fromInt(10) > new int64.fromInt(9), true);
+      expect(new int64.fromInt(10) > new int32.fromInt(11), false);
+      expect(new int64.fromInt(10) > new int32.fromInt(10), false);
+      expect(new int64.fromInt(10) > new int32.fromInt(9), true);
       expect(new int64.fromInt(-10) > new int64.fromInt(-11), true);
       expect(new int64.fromInt(10) > new int64.fromInt(-11), true);
       expect(new int64.fromInt(-10) > new int64.fromInt(11), false);
       expect(largePos > largeNeg, true);
       expect(largeNeg > largePos, false);
       expect(largePos > largePosPlusOne, false);
       expect(largePos > largePos, false);
       expect(largePosPlusOne > largePos, true);
       expect(new int64.fromInt(0) > int64.MIN_VALUE, true);
       expect(int64.MIN_VALUE > int64.MAX_VALUE, false);
       expect(int64.MAX_VALUE > int64.MIN_VALUE, true);
       expect(() => new int64.fromInt(17) > null, throwsArgumentError);
     });
   });
 
   group("bitwise operators", () {
     int64 n1 = new int64.fromInt(1234);
     int64 n2 = new int64.fromInt(9876);
     int64 n3 = new int64.fromInt(-1234);
     int64 n4 = new int64.fromInt(0x1234) << 32;
     int64 n5 = new int64.fromInt(0x9876) << 32;
 
     test("&", () {
       expect(n1 & n2, new int64.fromInt(1168));
       expect(n3 & n2, new int64.fromInt(8708));
       expect(n4 & n5, new int64.fromInt(0x1034) << 32);
-      expect(() => n1 & null, throws);
+      expect(() => n1 & null, throwsArgumentError);
     });
 
     test("|", () {
       expect(n1 | n2, new int64.fromInt(9942));
       expect(n3 | n2, new int64.fromInt(-66));
       expect(n4 | n5, new int64.fromInt(0x9a76) << 32);
-      expect(() => n1 | null, throws);
+      expect(() => n1 | null, throwsArgumentError);
     });
 
     test("^", () {
       expect(n1 ^ n2, new int64.fromInt(8774));
       expect(n3 ^ n2, new int64.fromInt(-8774));
       expect(n4 ^ n5, new int64.fromInt(0x8a42) << 32);
-      expect(() => n1 ^ null, throws);
+      expect(() => n1 ^ null, throwsArgumentError);
     });
 
     test("~", () {
       expect(-new int64.fromInt(1), new int64.fromInt(-1));
       expect(-new int64.fromInt(-1), new int64.fromInt(1));
       expect(-int64.MIN_VALUE, int64.MIN_VALUE);
 
       expect(~n1, new int64.fromInt(-1235));
       expect(~n2, new int64.fromInt(-9877));
       expect(~n3, new int64.fromInt(1233));
@@ skipping 241 matching lines @@
       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");
     });
   });
 }