Make int.gcd accept zero operands.

tests/corelib/int_modulo_arith_test.dart

 // Copyright (c) 2015, 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.
 
 import "package:expect/expect.dart";
 
 import "dart:math" show pow;
 
 var smallNumber = 1234567890;   // is 31-bit integer.
 var mediumNumber = 1234567890123456;  // is 53-bit integer
@@ skipping 123 matching lines @@
     if (value == other) return;
     testFunc(other, value);
     testFunc(other, -value);
     testFunc(-other, value);
     testFunc(-other, -value);
   }
 
   // Test that gcd of value and other (non-negative) is expectedResult.
   // Tests all combinations of positive and negative values and order of
   // operands, so use positive values and order is not important.
-  test(value, other, [expectedResult]) {
-    assert(value % expectedResult == 0);  // Check for bug in test.
-    assert(other % expectedResult == 0);
+  test(value, other, expectedResult) {
+    // Check for bug in test.
+    assert(expectedResult == 0 || value % expectedResult == 0);
+    assert(expectedResult == 0 || other % expectedResult == 0);
     callCombos(value, other, (a, b) {
       var result = a.gcd(b);
       /// Check that the result is a divisor.
-      Expect.equals(0, a % result, "$result | $a");
-      Expect.equals(0, b % result, "$result | $b");
+      Expect.equals(0, result == 0 ? a : a % result, "$result | $a");
+      Expect.equals(0, result == 0 ? b : b % result, "$result | $b");
       // Check for bug in test. If assert fails, the expected value is too low,
       // and the gcd call has found a greater common divisor.
       assert(result >= expectedResult);
       Expect.equals(expectedResult, result, "$a.gcd($b)");
     });
   }
 
   // Test that gcd of value and other (non-negative) throws.
   testThrows(value, other) {
     callCombos(value, other, (a, b) {
       Expect.throws(() => a.gcd(b), null, "$a.gcd($b)");
     });
   }
 
-  // Throws if either operand is zero, and if both operands are zero.
-  testThrows(0, 1000);
-  testThrows(0, 0);
+  testThrows(2.5, 5);  // Not a method on double.
+  testThrows(5, 2.5);  // Not accepting non-int arguments.
 
   // Format:
   //  test(value1, value2, expectedResult);
   test(1, 1, 1);     // both are 1
   test(1, 2, 1);     // one is 1
   test(3, 5, 1);     // coprime.
   test(37, 37, 37);  // Same larger prime.
 
   test(9999, 7272, 909);  // Larger numbers
 
+  test(0, 1000, 1000);  // One operand is zero.
+  test(0, 0, 0);        // Both operands are zero.
+
   // Multiplying both operands by a number multiplies result by same number.
   test(693, 609, 21);
   test(693 << 5, 609 << 5, 21 << 5);
   test(693 * 937, 609 * 937, 21 * 937);
   test(693 * pow(2, 32), 609 * pow(2, 32), 21 * pow(2, 32));
   test(693 * pow(2, 52), 609 * pow(2, 52), 21 * pow(2, 52));
   test(693 * pow(2, 53), 609 * pow(2, 53), 21 * pow(2, 53));  // Regression.
   test(693 * pow(2, 99), 609 * pow(2, 99), 21 * pow(2, 99));
 
   test(1234567890, 19, 1);
   test(1234567890, 1000000001, 1);
   test(19, 1000000001, 19);
 
   test(0x3FFFFFFF, 0x3FFFFFFF, 0x3FFFFFFF);
   test(0x3FFFFFFF, 0x40000000, 1);
 
   test(pow(2, 54), pow(2, 53), pow(2, 53));
 
   test((pow(2, 52) - 1) * pow(2, 14),
        (pow(2, 26) - 1) * pow(2, 22),
        (pow(2, 26) - 1) * pow(2, 14));
 }
 
 main() {
   testModPow();  /// modPow: ok
   testModInverse();
   testGcd();
 }