Format all tests.

tests/language_strong/naming_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";
 
 class A {
-  A() { NamingTest.count++; }
+  A() {
+    NamingTest.count++;
+  }
   foo(a, b) {
     Expect.equals(1, a);
     Expect.equals(2, b);
   }
 }
 
 class MyException {
   MyException() {}
 }
 
 class debugger {
   static const int __PROTO__ = 5;
 
   int x;
 
   factory debugger.F() {
     return new debugger(1);
   }
-  debugger(x) : this.x = x + 1 { }
-  debugger.C(x) : this.x = x + 2 { }
-  debugger.C$C(x) : this.x = x + 3 { }
-  debugger.C$I(x) : this.x = x + 4 { }
+  debugger(x) : this.x = x + 1 {}
+  debugger.C(x) : this.x = x + 2 {}
+  debugger.C$C(x) : this.x = x + 3 {}
+  debugger.C$I(x) : this.x = x + 4 {}
 }
 
 class debugger$C {
   int x;
 
   factory debugger$C.F() {
     return new debugger$C(1);
   }
-  debugger$C(x) : this.x = x + 5 { }
-  debugger$C.C(x) : this.x = x + 6 { }
-  debugger$C.C$C(x) : this.x = x + 7 { }
-  debugger$C.C$I(x) : this.x = x + 8 { }
+  debugger$C(x) : this.x = x + 5 {}
+  debugger$C.C(x) : this.x = x + 6 {}
+  debugger$C.C$C(x) : this.x = x + 7 {}
+  debugger$C.C$I(x) : this.x = x + 8 {}
 }
 
 class debugger$C$C {
   int x;
 
   factory debugger$C$C.F() {
     return new debugger$C$C(1);
   }
-  debugger$C$C(x) : this.x = x + 9 { }
-  debugger$C$C.C(x) : this.x = x + 10 { }
-  debugger$C$C.C$C(x) : this.x = x + 11 { }
-  debugger$C$C.C$I(x) : this.x = x + 12 { }
+  debugger$C$C(x) : this.x = x + 9 {}
+  debugger$C$C.C(x) : this.x = x + 10 {}
+  debugger$C$C.C$C(x) : this.x = x + 11 {}
+  debugger$C$C.C$I(x) : this.x = x + 12 {}
 }
 
 class with$I extends debugger$C {
   int y;
 
   factory with$I.F() {
     return new with$I(1, 2);
   }
-  with$I(x, y) : super(x), this.y = y + 11 { }
-  with$I.I(x, y) : super.C(x), this.y = y + 12 { }
-  with$I.C(x, y) : super.C$C(x), this.y = y + 13 { }
-  with$I.I$C(x, y) : super.C$I(x), this.y = y + 14 { }
-  with$I.C$C(x, y) : super(x), this.y = y + 15 { }
-  with$I.C$C$C(x, y) : super.C(x), this.y = y + 16 { }
-  with$I.$C$I(x, y) : super.C$C(x), this.y = y + 17 { }
-  with$I.$$I$C(x, y) : super.C$I(x), this.y = y + 18 { }
-  with$I.$(x, y) : super(x), this.y = y + 19 { }
-  with$I.$$(x, y) : super.C(x), this.y = y + 20 { }
+  with$I(x, y)
+      : super(x),
+        this.y = y + 11 {}
+  with$I.I(x, y)
+      : super.C(x),
+        this.y = y + 12 {}
+  with$I.C(x, y)
+      : super.C$C(x),
+        this.y = y + 13 {}
+  with$I.I$C(x, y)
+      : super.C$I(x),
+        this.y = y + 14 {}
+  with$I.C$C(x, y)
+      : super(x),
+        this.y = y + 15 {}
+  with$I.C$C$C(x, y)
+      : super.C(x),
+        this.y = y + 16 {}
+  with$I.$C$I(x, y)
+      : super.C$C(x),
+        this.y = y + 17 {}
+  with$I.$$I$C(x, y)
+      : super.C$I(x),
+        this.y = y + 18 {}
+  with$I.$(x, y)
+      : super(x),
+        this.y = y + 19 {}
+  with$I.$$(x, y)
+      : super.C(x),
+        this.y = y + 20 {}
 }
 
 class with$C extends debugger$C$C {
   int y;
 
   factory with$C.F() {
     return new with$C(1, 2);
   }
-  with$C(x, y) : super(x), this.y = y + 21 { }
-  with$C.I(x, y) : super.C(x), this.y = y + 22 { }
-  with$C.C(x, y) : super.C$C(x), this.y = y + 23 { }
-  with$C.I$C(x, y) : super.C$I(x), this.y = y + 24 { }
-  with$C.C$C(x, y) : super(x), this.y = y + 25 { }
-  with$C.C$C$C(x, y) : super.C(x), this.y = y + 26 { }
-  with$C.$C$I(x, y) : super.C$C(x), this.y = y + 27 { }
-  with$C.$$I$C(x, y) : super.C$I(x), this.y = y + 28 { }
-  with$C.$(x, y) : super(x), this.y = y + 29 { }
-  with$C.$$(x, y) : super.C(x), this.y = y + 30 { }
+  with$C(x, y)
+      : super(x),
+        this.y = y + 21 {}
+  with$C.I(x, y)
+      : super.C(x),
+        this.y = y + 22 {}
+  with$C.C(x, y)
+      : super.C$C(x),
+        this.y = y + 23 {}
+  with$C.I$C(x, y)
+      : super.C$I(x),
+        this.y = y + 24 {}
+  with$C.C$C(x, y)
+      : super(x),
+        this.y = y + 25 {}
+  with$C.C$C$C(x, y)
+      : super.C(x),
+        this.y = y + 26 {}
+  with$C.$C$I(x, y)
+      : super.C$C(x),
+        this.y = y + 27 {}
+  with$C.$$I$C(x, y)
+      : super.C$I(x),
+        this.y = y + 28 {}
+  with$C.$(x, y)
+      : super(x),
+        this.y = y + 29 {}
+  with$C.$$(x, y)
+      : super.C(x),
+        this.y = y + 30 {}
 }
 
 class with$I$C extends debugger$C$C {
   int y;
 
   factory with$I$C.F() {
     return new with$I$C(1, 2);
   }
-  with$I$C(x, y) : super(x), this.y = y + 31 { }
-  with$I$C.I(x, y) : super.C(x), this.y = y + 32 { }
-  with$I$C.C(x, y) : super.C$C(x), this.y = y + 33 { }
-  with$I$C.I$C(x, y) : super.C$I(x), this.y = y + 34 { }
-  with$I$C.C$C(x, y) : super(x), this.y = y + 35 { }
-  with$I$C.C$C$C(x, y) : super.C(x), this.y = y + 36 { }
-  with$I$C.$C$I(x, y) : super.C$C(x), this.y = y + 37 { }
-  with$I$C.$$I$C(x, y) : super.C$I(x), this.y = y + 38 { }
-  with$I$C.$(x, y) : super(x), this.y = y + 39 { }
-  with$I$C.$$(x, y) : super.C(x), this.y = y + 40 { }
+  with$I$C(x, y)
+      : super(x),
+        this.y = y + 31 {}
+  with$I$C.I(x, y)
+      : super.C(x),
+        this.y = y + 32 {}
+  with$I$C.C(x, y)
+      : super.C$C(x),
+        this.y = y + 33 {}
+  with$I$C.I$C(x, y)
+      : super.C$I(x),
+        this.y = y + 34 {}
+  with$I$C.C$C(x, y)
+      : super(x),
+        this.y = y + 35 {}
+  with$I$C.C$C$C(x, y)
+      : super.C(x),
+        this.y = y + 36 {}
+  with$I$C.$C$I(x, y)
+      : super.C$C(x),
+        this.y = y + 37 {}
+  with$I$C.$$I$C(x, y)
+      : super.C$I(x),
+        this.y = y + 38 {}
+  with$I$C.$(x, y)
+      : super(x),
+        this.y = y + 39 {}
+  with$I$C.$$(x, y)
+      : super.C(x),
+        this.y = y + 40 {}
 }
 
 class Tata {
   var prototype;
 
   Tata() : this.prototype = 0 {}
 
-  __PROTO__$() { return 12; }
+  __PROTO__$() {
+    return 12;
+  }
 }
 
 class Toto extends Tata {
   var __PROTO__;
 
-  Toto() : super(), this.__PROTO__ = 0 { }
+  Toto()
+      : super(),
+        this.__PROTO__ = 0 {}
 
-  prototype$() { return 10; }
+  prototype$() {
+    return 10;
+  }
 
   titi() {
     Expect.equals(0, prototype);
     Expect.equals(0, __PROTO__);
     prototype = 3;
     __PROTO__ = 5;
     Expect.equals(3, prototype);
     Expect.equals(5, __PROTO__);
     Expect.equals(10, prototype$());
     Expect.equals(12, __PROTO__$());
     Expect.equals(12, this.__PROTO__$());
     Expect.equals(10, this.prototype$());
     Expect.equals(12, __PROTO__$());
   }
 }
 
 class Bug4082360 {
   int x_;
   Bug4082360() {}
 
-  int get x { return x_; }
-  void set x(int value) { x_ = value; }
+  int get x {
+    return x_;
+  }
 
-  void indirectSet(int value) { x = value; }
+  void set x(int value) {
+    x_ = value;
+  }
+
+  void indirectSet(int value) {
+    x = value;
+  }
 
   static void test() {
     var bug = new Bug4082360();
     bug.indirectSet(42);
     Expect.equals(42, bug.x_);
     Expect.equals(42, bug.x);
   }
 }
 
 class Hoisting {
   var f_;
   Hoisting.negate(var x) {
-    f_ = () { return x; };
+    f_ = () {
+      return x;
+    };
   }
 
   operator -() {
     var x = 3;
-    return () { return x + 1; };
+    return () {
+      return x + 1;
+    };
   }
 
-  operator[] (x) {
-    return () { return x + 3; };
+  operator [](x) {
+    return () {
+      return x + 3;
+    };
   }
 
   static void test() {
     var h = new Hoisting.negate(1);
     Expect.equals(1, (h.f_)());
     var f = -h;
     Expect.equals(4, f());
     Expect.equals(7, h[4]());
   }
 }
@@ skipping 238 matching lines @@
   $add(Object other) => other;
   $negate() => wrapped;
 
   operator +(Object other) => 123;
   operator -() => 444;
 }
 
 $add(Object first, Object second) => second;
 DartQuery $(Object obj) => new DartQuery(obj);
 
-
 // Ensure we don't have false positive.
 class Naming2Test {
-  Naming2Test() { }
-  int get foo { return 1; }
-  set foo(x) { }
+  Naming2Test() {}
+  int get foo {
+    return 1;
+  }
+
+  set foo(x) {}
 
   static void main(args) {
     var a = new Naming2Test();
     Expect.throws(
         () => a.foo(2),
         // We check for both exceptions because the exact exception to
         // throw is hard to compute on some browsers.
         (e) => e is NoSuchMethodError);
   }
 }
 
 main() {
   NamingTest.testMain();
   Naming2Test.main(null);
 }