dart2js: run dartfmt on tests

tests/compiler/dart2js_extra/operator_test.dart

 // Copyright (c) 2011, 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";
-@NoInline() @AssumeDynamic()
+
+@NoInline()
+@AssumeDynamic()
 confuse(x) => x;
 
 @NoInline()
 asNum(x) {
   var result = confuse(x);
   if (result is num) return result;
   throw new ArgumentError.value(x);
 }
 
 @NoInline()
 uint31(x) {
   var result = confuse(x);
   if (x is int) {
-    var masked = 0x7fffffff & x;  // inferred uint31 type.
+    var masked = 0x7fffffff & x; // inferred uint31 type.
     if (masked == x) return masked;
   }
   throw new ArgumentError('Not uint31: $x');
 }
 
 @NoInline()
 uint32(x) {
   var result = confuse(x);
   if (x is int) {
-    var masked = 0xffffffff & x;  // inferred uint32 type.
+    var masked = 0xffffffff & x; // inferred uint32 type.
     if (masked == x) return masked;
   }
   throw new ArgumentError('Not uint32: $x');
 }
 
 @NoInline()
-int zero() { return 0; }
+int zero() {
+  return 0;
+}
 
 @NoInline()
-int one() { return 1; }
+int one() {
+  return 1;
+}
 
 @NoInline()
-int minus1() { return 0 - 1; }
+int minus1() {
+  return 0 - 1;
+}
 
 @NoInline()
-int minus2() { return 0 - 2; }
+int minus2() {
+  return 0 - 2;
+}
 
 @NoInline()
-int two() { return 2; }
+int two() {
+  return 2;
+}
 
 @NoInline()
-int three() { return 3; }
+int three() {
+  return 3;
+}
 
 @NoInline()
-int five() { return 5; }
+int five() {
+  return 5;
+}
 
 @NoInline()
-int minus5() { return 0 - 5; }
+int minus5() {
+  return 0 - 5;
+}
 
 @NoInline()
-int ninetyNine() { return 99; }
+int ninetyNine() {
+  return 99;
+}
 
 @NoInline()
-int four99() { return 499; }
+int four99() {
+  return 499;
+}
 
 @NoInline()
-int four99times99() { return 499 * 99; }
+int four99times99() {
+  return 499 * 99;
+}
 
 @NoInline()
-int four99times99plus1() { return 499 * 99 + 1; }
+int four99times99plus1() {
+  return 499 * 99 + 1;
+}
 
 @NoInline()
 void addTest() {
   var m1 = 0 - 1;
   Expect.equals(0, 0 + 0);
   Expect.equals(0, confuse(0) + 0);
   Expect.equals(0, asNum(0) + 0);
   Expect.equals(0, uint31(0) + 0);
 
   Expect.equals(m1, m1 + 0);
@@ skipping 71 matching lines @@
   Expect.equals(499, four99times99() ~/ 99);
   Expect.equals(499, four99times99plus1() ~/ 99);
 
   Expect.equals(-33, -100 ~/ 3);
   Expect.equals(-33, asNum(-100) ~/ 3);
   Expect.equals(33, -100 ~/ -3);
   Expect.equals(33, asNum(-100) ~/ -3);
 
   // Signed int32 boundary is involved in optimizations.
 
-  Expect.equals(-0x80000000,  -0x80000000 ~/ 1.0);
-  Expect.equals(-0x80000000,  -0x80000000 ~/ 1.0000000000000001);
-  Expect.equals(-0x7fffffff,  -0x80000000 ~/ 1.0000000000000002);
+  Expect.equals(-0x80000000, -0x80000000 ~/ 1.0);
+  Expect.equals(-0x80000000, -0x80000000 ~/ 1.0000000000000001);
+  Expect.equals(-0x7fffffff, -0x80000000 ~/ 1.0000000000000002);
 
-  Expect.equals(-0x80000000,  asNum(-0x80000000) ~/ 1.0);
-  Expect.equals(-0x80000000,  asNum(-0x80000000) ~/ 1.0000000000000001);
-  Expect.equals(-0x7fffffff,  asNum(-0x80000000) ~/ 1.0000000000000002);
+  Expect.equals(-0x80000000, asNum(-0x80000000) ~/ 1.0);
+  Expect.equals(-0x80000000, asNum(-0x80000000) ~/ 1.0000000000000001);
+  Expect.equals(-0x7fffffff, asNum(-0x80000000) ~/ 1.0000000000000002);
 
-  Expect.equals(-0x80000000,  asNum(0x80000000) ~/ -1.0);
-  Expect.equals(-0x80000000,  asNum(0x80000000) ~/ -1.0000000000000001);
-  Expect.equals(-0x7fffffff,  asNum(0x80000000) ~/ -1.0000000000000002);
+  Expect.equals(-0x80000000, asNum(0x80000000) ~/ -1.0);
+  Expect.equals(-0x80000000, asNum(0x80000000) ~/ -1.0000000000000001);
+  Expect.equals(-0x7fffffff, asNum(0x80000000) ~/ -1.0000000000000002);
 
-  Expect.equals(0x7fffffff,  0x10000000 ~/ .12500000000000002);
-  Expect.equals(0x80000000,  0x10000000 ~/ .125);
-  Expect.equals(-0x7fffffff,  0x10000000 ~/ -.12500000000000002);
-  Expect.equals(-0x80000000,  0x10000000 ~/ -.125);
+  Expect.equals(0x7fffffff, 0x10000000 ~/ .12500000000000002);
+  Expect.equals(0x80000000, 0x10000000 ~/ .125);
+  Expect.equals(-0x7fffffff, 0x10000000 ~/ -.12500000000000002);
+  Expect.equals(-0x80000000, 0x10000000 ~/ -.125);
 
-  Expect.equals(0x7fffffff,  uint31(0x10000000) ~/ .12500000000000002);
-  Expect.equals(0x80000000,  uint31(0x10000000) ~/ .125);
-  Expect.equals(-0x7fffffff,  uint31(0x10000000) ~/ -.12500000000000002);
-  Expect.equals(-0x80000000,  uint31(0x10000000) ~/ -.125);
+  Expect.equals(0x7fffffff, uint31(0x10000000) ~/ .12500000000000002);
+  Expect.equals(0x80000000, uint31(0x10000000) ~/ .125);
+  Expect.equals(-0x7fffffff, uint31(0x10000000) ~/ -.12500000000000002);
+  Expect.equals(-0x80000000, uint31(0x10000000) ~/ -.125);
 
   // These can be compiled to `(a / 2) | 0`.
-  Expect.equals(100,  uint31(200) ~/ 2);
-  Expect.equals(100,  uint32(200) ~/ 2);
+  Expect.equals(100, uint31(200) ~/ 2);
+  Expect.equals(100, uint32(200) ~/ 2);
 
-  Expect.equals(100,  asNum(200) ~/ 2);
-  Expect.equals(100,  confuse(200) ~/ 2);
-  Expect.equals(-100,  uint31(200) ~/ -2);
-  Expect.equals(-100,  uint32(200) ~/ -2);
-  Expect.equals(-100,  asNum(200) ~/ -2);
-  Expect.equals(-100,  confuse(200) ~/ -2);
+  Expect.equals(100, asNum(200) ~/ 2);
+  Expect.equals(100, confuse(200) ~/ 2);
+  Expect.equals(-100, uint31(200) ~/ -2);
+  Expect.equals(-100, uint32(200) ~/ -2);
+  Expect.equals(-100, asNum(200) ~/ -2);
+  Expect.equals(-100, confuse(200) ~/ -2);
 
   // These can be compiled to `((a + b) / 2) | 0`.
-  Expect.equals(100,  (uint31(100) + uint31(100)) ~/ 2);
-  Expect.equals(0x7fffffff,  (uint31(0x7fffffff) + uint31(0x7fffffff)) ~/ 2);
+  Expect.equals(100, (uint31(100) + uint31(100)) ~/ 2);
+  Expect.equals(0x7fffffff, (uint31(0x7fffffff) + uint31(0x7fffffff)) ~/ 2);
 
   // NaN and Infinity results are errors.
   Expect.throws(() => -1 ~/ 0);
   Expect.throws(() => 1.5 ~/ 0);
   Expect.throws(() => 1e200 ~/ 1e-200);
   Expect.throws(() => -1e200 ~/ 1e-200);
   Expect.throws(() => 1e200 ~/ -1e-200);
   Expect.throws(() => -1e200 ~/ -1e-200);
   Expect.throws(() => double.NAN ~/ 2);
 }
@@ skipping 87 matching lines @@
 @NoInline()
 void andTest() {
   Expect.equals(2, 10 & 3);
   Expect.equals(7, 15 & 7);
   Expect.equals(10, 10 & 10);
 
   Expect.equals(99, ninetyNine() & ninetyNine());
   Expect.equals(34, four99() & 42);
   Expect.equals(3, minus5() & 7);
 
-  Expect.equals(0,  uint31(0x7ffffffe) & uint31(1));
-  Expect.equals(0,  asNum(0x7ffffffe) & asNum(1));
+  Expect.equals(0, uint31(0x7ffffffe) & uint31(1));
+  Expect.equals(0, asNum(0x7ffffffe) & asNum(1));
 }
 
 @NoInline()
 void orTest() {
   Expect.equals(11, 10 | 3);
   Expect.equals(15, 15 | 7);
   Expect.equals(10, 10 | 10);
 
   Expect.equals(99, ninetyNine() | ninetyNine());
   Expect.equals(507, four99() | 42);
@@ skipping 212 matching lines @@
   orTest();
   xorTest();
   notTest();
   negateTest();
   equalsTest();
   lessTest();
   lessEqualTest();
   greaterTest();
   greaterEqualTest();
 }