Format all tests.

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.
 // VMOptions=--optimization-counter-threshold=10 --no-use-osr --no-background-compilation
 
 library arithmetic_test;
+
 import "package:expect/expect.dart";
 import 'dart:math';
 
 class ArithmeticTest {
-
   static bool exceptionCaughtParseInt(String s) {
     try {
       int.parse(s);
       return false;
     } on FormatException catch (e) {
       return true;
     }
   }
 
   static bool exceptionCaughtParseDouble(String s) {
@@ skipping 83 matching lines @@
     Expect.equals(big, big.ceil());
     Expect.equals(big, big.round());
     Expect.equals(big, big.truncate());
     big = -big;
     Expect.equals(big, big.floor());
     Expect.equals(big, big.ceil());
     Expect.equals(big, big.round());
     Expect.equals(big, big.truncate());
 
     // Test if double is contagious. The assignment will check the type.
-    { double d = 1 + 1.0; }
-    { double d = 1.0 + 1; }
-    { double d = 1 * 1.0; }
-    { double d = 0 * 1.0; }
-    { double d = 1.0 * 0; }
-    { double d = 1 / 1.0; }
-    { double d = 1.0 / 0; }
-    { double d = 1 - 1.0; }
-    { double d = 1.0 - 1; }
-    { double d = big * 1.0; }
-    { double d = 1.0 * big; }
+    {
+      double d = 1 + 1.0;
+    }
+    {
+      double d = 1.0 + 1;
+    }
+    {
+      double d = 1 * 1.0;
+    }
+    {
+      double d = 0 * 1.0;
+    }
+    {
+      double d = 1.0 * 0;
+    }
+    {
+      double d = 1 / 1.0;
+    }
+    {
+      double d = 1.0 / 0;
+    }
+    {
+      double d = 1 - 1.0;
+    }
+    {
+      double d = 1.0 - 1;
+    }
+    {
+      double d = big * 1.0;
+    }
+    {
+      double d = 1.0 * big;
+    }
 
     // Reset big to positive value.
     big = 123456789012345;
     // -- isNegative --.
     // Smi.
     Expect.equals(false, (0).isNegative);
     Expect.equals(false, (1).isNegative);
     Expect.equals(true, (-1).isNegative);
     // Big.
     Expect.equals(false, big.isNegative);
     Expect.equals(true, (-big).isNegative);
     // Double.
     // TODO(srdjan): enable the following test once isNegative works.
     // Expect.equals(true, (-0.0).isNegative);
     Expect.equals(false, (0.0).isNegative);
     Expect.equals(false, (2.0).isNegative);
     Expect.equals(true, (-2.0).isNegative);
 
     double negateDouble(double x) {
       return -x;
     }
 
     Expect.isTrue(negateDouble(0.0).isNegative);
     Expect.isFalse(negateDouble(-0.0).isNegative);
     Expect.isTrue(negateDouble(3.5e3).isNegative);
     Expect.isFalse(negateDouble(-3.5e3).isNegative);
 
-
     // Constants.
-    final nan = 0.0/0.0;
-    final infinity = 1.0/0.0;
+    final nan = 0.0 / 0.0;
+    final infinity = 1.0 / 0.0;
 
     // -- isInfinite --.
     // Smi.
     Expect.equals(false, (0).isInfinite);
     Expect.equals(false, (1).isInfinite);
     Expect.equals(false, (-1).isInfinite);
     // Big.
     Expect.equals(false, big.isInfinite);
     Expect.equals(false, (-big).isInfinite);
     // Double.
@@ skipping 69 matching lines @@
     Expect.isTrue((0.0).floor() is int);
     Expect.isTrue((0.1).floor() is int);
     Expect.equals(0, (-0.0).floor());
     Expect.isTrue((-0.0).floor() is int);
     Expect.equals(-1, (-0.1).floor());
     Expect.equals(2, (2.1).floor());
     Expect.equals(-3, (-2.1).floor());
     Expect.equals(-1.0, (-0.49999999999999994).floor());
     Expect.equals(-3.0, (-2.1).floor());
 
-
     // -- truncate --.
     // Smi.
     Expect.equals(0, (0).truncate());
     Expect.equals(1, (1).truncate());
     Expect.equals(-1, (-1).truncate());
     // Big.
     Expect.equals(big, big.truncate());
     Expect.equals(-big, (-big).truncate());
     // Double.
     Expect.equals(0, (0.0).truncate());
@@ skipping 40 matching lines @@
     Expect.equals(2, (1.5).round());
     Expect.equals(-2, (-1.5).round());
     Expect.equals(1, (0.99).round());
 
     // -- toInt --.
     // Smi.
     Expect.equals(0, (0).toInt());
     Expect.equals(1, (1).toInt());
     Expect.equals(-1, (-1).toInt());
     // Type checks.
-    { int i = (0).toInt(); }
-    { int i = (1).toInt(); }
-    { int i = (-1).toInt(); }
+    {
+      int i = (0).toInt();
+    }
+    {
+      int i = (1).toInt();
+    }
+    {
+      int i = (-1).toInt();
+    }
     // Big.
     Expect.equals(big, big.toInt());
     Expect.equals(-big, (-big).toInt());
-    { int i = big.toInt(); }
-    { int i = (-big).toInt(); }
+    {
+      int i = big.toInt();
+    }
+    {
+      int i = (-big).toInt();
+    }
     // Double.
     Expect.equals(1234567890123, (1234567890123.0).toInt());
     Expect.equals(-1234567890123, (-1234567890123.0).toInt());
-    { int i = (1234567890123.0).toInt(); }
-    { int i = (-1234567890123.0).toInt(); }
+    {
+      int i = (1234567890123.0).toInt();
+    }
+    {
+      int i = (-1234567890123.0).toInt();
+    }
     // 32bit Smi border cases.
     Expect.equals(-1073741824, (-1073741824.0).toInt());
     Expect.equals(-1073741825, (-1073741825.0).toInt());
     Expect.equals(1073741823, (1073741823.0).toInt());
     Expect.equals(1073741824, (1073741824.0).toInt());
 
-    { int i = (-1073741824.0).toInt(); }
-    { int i = (-1073741825.0).toInt(); }
-    { int i = (1073741823.0).toInt(); }
-    { int i = (1073741824.0).toInt(); }
+    {
+      int i = (-1073741824.0).toInt();
+    }
+    {
+      int i = (-1073741825.0).toInt();
+    }
+    {
+      int i = (1073741823.0).toInt();
+    }
+    {
+      int i = (1073741824.0).toInt();
+    }
 
     // -- toDouble --.
     // Smi.
     Expect.equals(0.0, (0).toDouble());
     Expect.equals(1.0, (1).toDouble());
     Expect.equals(-1.0, (-1).toDouble());
     // Type checks.
-    { double d = (0).toDouble(); }
-    { double d = (1).toDouble(); }
-    { double d = (-1).toDouble(); }
+    {
+      double d = (0).toDouble();
+    }
+    {
+      double d = (1).toDouble();
+    }
+    {
+      double d = (-1).toDouble();
+    }
     // Big.
     Expect.equals(big, big.toInt());
     Expect.equals(-big, (-big).toInt());
-    { int i = big.toInt(); }
-    { int i = (-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, int.parse("12"));
     Expect.equals(-12, int.parse("-12"));
-    Expect.equals(12345678901234567890,
-                  int.parse("12345678901234567890"));
-    Expect.equals(-12345678901234567890,
-                  int.parse("-12345678901234567890"));
+    Expect.equals(12345678901234567890, int.parse("12345678901234567890"));
+    Expect.equals(-12345678901234567890, int.parse("-12345678901234567890"));
     // Type checks.
-    { int i = int.parse("12"); }
-    { int i = int.parse("-12"); }
-    { int i = int.parse("12345678901234567890"); }
-    { int i = int.parse("-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, double.parse("1.2"));
     Expect.equals(-1.2, double.parse("-1.2"));
     // Type checks.
-    { double d = double.parse("1.2"); }
-    { double d = double.parse("-1.2"); }
-    { double d = double.parse("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"));
@@ skipping 37 matching lines @@
   }
 
   static int div(a, b) => a ~/ b;
 
   static void testSmiDivDeopt() {
     var a = -0x40000000;
     var b = -1;
     for (var i = 0; i < 10; i++) Expect.equals(0x40000000, div(a, b));
   }
 
-
   static int divMod(a, b) => a ~/ b + a % b;
 
   static void testSmiDivModDeopt() {
     var a = -0x40000000;
     var b = -1;
     for (var i = 0; i < 10; i++) Expect.equals(0x40000000, divMod(a, b));
   }
 
   static double sinCosSub(double a) => sin(a) - cos(a);
 
-  static double sinCosAddCos(double a)  => sin(a) * cos(a) + cos(a);
+  static double sinCosAddCos(double a) => sin(a) * cos(a) + cos(a);
 
   static void testSinCos() {
     var e = sin(1.234) - cos(1.234);
     var f = sin(1.234) * cos(1.234) + cos(1.234);
 
     for (var i = 0; i < 20; i++) {
       Expect.approxEquals(e, sinCosSub(1.234));
       Expect.approxEquals(f, sinCosAddCos(1.234));
     }
     Expect.approxEquals(1.0, sinCosSub(3.14159265));
@@ skipping 37 matching lines @@
       testDoubleEquality();
       testSinCos();
       testSinCosNoUse();
     }
   }
 }
 
 main() {
   ArithmeticTest.testMain();
 }