Big merge from experimental to bleeding edge.

tests/language/arithmetic_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.
 // Dart test program to test arithmetic operations.
 
 library arithmetic_test;
 import 'dart:math';
 
 class ArithmeticTest {
 
   static bool exceptionCaughtParseInt(String s) {
     try {
-      parseInt(s);
+      int.parse(s);
       return false;
     } on FormatException catch (e) {
       return true;
     }
   }
 
   static bool exceptionCaughtParseDouble(String s) {
     try {
-      parseDouble(s);
+      double.parse(s);
       return false;
     } on FormatException catch (e) {
       return true;
     }
   }
 
-  static bool toIntThrowsFormatException(String str) {
+  static bool toIntThrowsUnsupportedError(String str) {
     // No exception allowed for parse double.
-    double d = parseDouble(str);
+    double d = double.parse(str);
     try {
       var a = d.toInt();
       return false;
-    } on FormatException catch (e) {
+    } on UnsupportedError catch (e) {
       return true;
     }
   }
 
   static runOne() {
     var a = 22;
     var b = 4;
     // Smi & smi.
     Expect.equals(26, a + b);
     Expect.equals(18, a - b);
     Expect.equals(88, a * b);
     Expect.equals(5, a ~/ b);
     Expect.equals(5.5, a / b);
     Expect.equals(2.0, 10 / 5);
     Expect.equals(2, a % b);
     Expect.equals(2, a.remainder(b));
     // Smi corner cases.
     for (int i = 0; i < 80; i++) {
       a = -(1 << i);
       b = -1;
       Expect.equals(1 << i, a ~/ b);
     }
     a = 22;
     b = 4.0;
     // Smi & double.
     Expect.equals(26.0, a + b);
     Expect.equals(18.0, a - b);
     Expect.equals(88.0, a * b);
-    Expect.equals(5.0, a ~/ b);
+    Expect.equals(5, a ~/ b);
     Expect.equals(5.5, a / b);
     Expect.equals(2.0, a % b);
     Expect.equals(2.0, a.remainder(b));
     a = 22.0;
     b = 4;
     // Double & smi.
     Expect.equals(26.0, a + b);
     Expect.equals(18.0, a - b);
     Expect.equals(88.0, a * b);
-    Expect.equals(5.0, a ~/ b);
+    Expect.equals(5, a ~/ b);
     Expect.equals(5.5, a / b);
     Expect.equals(2.0, a % b);
     Expect.equals(2.0, a.remainder(b));
     a = 22.0;
     b = 4.0;
     // Double & double.
     Expect.equals(26.0, a + b);
     Expect.equals(18.0, a - b);
     Expect.equals(88.0, a * b);
     Expect.equals(5.0, a ~/ b);
@@ skipping 253 matching lines @@
     Expect.equals(big, big.toInt());
     Expect.equals(-big, (-big).toInt());
     { int i = big.toInt(); }
     { int i = (-big).toInt(); }
 
     // Math functions.
     Expect.equals(2.0, sqrt(4.0));
     Expect.approxEquals(1.0, sin(3.14159265 / 2.0));
     Expect.approxEquals(-1.0, cos(3.14159265));
 
-    Expect.equals(12, parseInt("12"));
-    Expect.equals(-12, parseInt("-12"));
+    Expect.equals(12, int.parse("12"));
+    Expect.equals(-12, int.parse("-12"));
     Expect.equals(12345678901234567890,
-                  parseInt("12345678901234567890"));
+                  int.parse("12345678901234567890"));
     Expect.equals(-12345678901234567890,
-                  parseInt("-12345678901234567890"));
+                  int.parse("-12345678901234567890"));
     // Type checks.
-    { int i = parseInt("12"); }
-    { int i = parseInt("-12"); }
-    { int i = parseInt("12345678901234567890"); }
-    { int i = parseInt("-12345678901234567890"); }
+    { int i = int.parse("12"); }
+    { int i = int.parse("-12"); }
+    { int i = int.parse("12345678901234567890"); }
+    { int i = int.parse("-12345678901234567890"); }
 
-    Expect.equals(1.2, parseDouble("1.2"));
-    Expect.equals(-1.2, parseDouble("-1.2"));
+    Expect.equals(1.2, double.parse("1.2"));
+    Expect.equals(-1.2, double.parse("-1.2"));
     // Type checks.
-    { double d = parseDouble("1.2"); }
-    { double d = parseDouble("-1.2"); }
-    { double d = parseDouble("0"); }
+    { double d = double.parse("1.2"); }
+    { double d = double.parse("-1.2"); }
+    { double d = double.parse("0"); }
 
     // Random
     {
       Random rand = new Random();
       double d = rand.nextDouble();
     }
 
     Expect.equals(false, exceptionCaughtParseInt("22"));
     Expect.equals(true, exceptionCaughtParseInt("alpha"));
     Expect.equals(true, exceptionCaughtParseInt("-alpha"));
     Expect.equals(false, exceptionCaughtParseDouble("22.2"));
     Expect.equals(true, exceptionCaughtParseDouble("alpha"));
     Expect.equals(true, exceptionCaughtParseDouble("-alpha"));
 
-    Expect.equals(false, parseDouble("1.2").isNaN);
-    Expect.equals(false, parseDouble("1.2").isInfinite);
+    Expect.equals(false, double.parse("1.2").isNaN);
+    Expect.equals(false, double.parse("1.2").isInfinite);
 
-    Expect.equals(true, parseDouble("NaN").isNaN);
-    Expect.equals(true, parseDouble("Infinity").isInfinite);
-    Expect.equals(true, parseDouble("-Infinity").isInfinite);
+    Expect.equals(true, double.parse("NaN").isNaN);
+    Expect.equals(true, double.parse("Infinity").isInfinite);
+    Expect.equals(true, double.parse("-Infinity").isInfinite);
 
-    Expect.equals(false, parseDouble("NaN").isNegative);
-    Expect.equals(false, parseDouble("Infinity").isNegative);
-    Expect.equals(true, parseDouble("-Infinity").isNegative);
+    Expect.equals(false, double.parse("NaN").isNegative);
+    Expect.equals(false, double.parse("Infinity").isNegative);
+    Expect.equals(true, double.parse("-Infinity").isNegative);
 
-    Expect.equals("NaN", parseDouble("NaN").toString());
-    Expect.equals("Infinity", parseDouble("Infinity").toString());
-    Expect.equals("-Infinity", parseDouble("-Infinity").toString());
+    Expect.equals("NaN", double.parse("NaN").toString());
+    Expect.equals("Infinity", double.parse("Infinity").toString());
+    Expect.equals("-Infinity", double.parse("-Infinity").toString());
 
-    Expect.equals(false, toIntThrowsFormatException("1.2"));
-    Expect.equals(true, toIntThrowsFormatException("Infinity"));
-    Expect.equals(true, toIntThrowsFormatException("-Infinity"));
-    Expect.equals(true, toIntThrowsFormatException("NaN"));
+    Expect.equals(false, toIntThrowsUnsupportedError("1.2"));
+    Expect.equals(true, toIntThrowsUnsupportedError("Infinity"));
+    Expect.equals(true, toIntThrowsUnsupportedError("-Infinity"));
+    Expect.equals(true, toIntThrowsUnsupportedError("NaN"));
 
     // Min/max
     Expect.equals(1, min(1, 12));
     Expect.equals(12, max(1, 12));
     Expect.equals(1.0, min(1.0, 12.0));
     Expect.equals(12.0, max(1.0, 12.0));
     Expect.equals(false, 1.0 < min(1.0, 12.0));
     Expect.equals(true, 1.0 < max(1.0, 12.0));
 
     // Hashcode
@@ skipping 15 matching lines @@
     for (int i = 0; i < 1500; i++) {
       runOne();
       testSmiDivDeopt();
     }
   }
 }
 
 main() {
   ArithmeticTest.testMain();
 }