Format all multitests

tests/language_strong/super_bound_closure_test.dart

 // Copyright (c) 2014, 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 {
   bar([var optional = 1]) => 498 + optional;
-  bar2({ namedOptional: 2 }) => 40 + namedOptional;
+  bar2({namedOptional: 2}) => 40 + namedOptional;
   bar3(x, [var optional = 3]) => x + 498 + optional;
-  bar4(x, { namedOptional: 4 }) => 422 + x + namedOptional;
+  bar4(x, {namedOptional: 4}) => 422 + x + namedOptional;
 
   // Gee is the same as bar, but we make sure that gee is used. Potentially
   // this yields different code if the redirecting stub exists.
   gee([var optional = 1]) => 498 + optional;
-  gee2({ namedOptional: 2 }) => 40 + namedOptional;
+  gee2({namedOptional: 2}) => 40 + namedOptional;
   gee3(x, [var optional = 3]) => x + 498 + optional;
-  gee4(x, { namedOptional: 4 }) => 422 + x + namedOptional;
+  gee4(x, {namedOptional: 4}) => 422 + x + namedOptional;
 
   // Use identifiers that could be intercepted.
   add([var optional = 33]) => 1234 + optional;
-  trim({ namedOptional: 22 }) => 1313 + namedOptional;
+  trim({namedOptional: 22}) => 1313 + namedOptional;
   sublist(x, [optional = 44]) => 4321 + optional + x;
-  splitMapJoin(x, { onMatch: 55, onNonMatch: 66}) =>
+  splitMapJoin(x, {onMatch: 55, onNonMatch: 66}) =>
       111 + x + onMatch + onNonMatch;
 
   // Other interceptable identifiers, but all of them are used.
   shuffle([var optional = 121]) => 12342 + optional;
-  toList({ growable: 2233 }) => 13131 + growable;
+  toList({growable: 2233}) => 13131 + growable;
   lastIndexOf(x, [optional = 424]) => 14321 + optional + x;
-  lastWhere(x, { orElse: 555 }) => x + 1213 + 555;
+  lastWhere(x, {orElse: 555}) => x + 1213 + 555;
 }
 
 class B extends A {
   // The closure `super.bar` is invoked without the optional argument.
   // Dart2js must not generate a `bar$0 => bar$1(null)` closure, since that
   // would redirect to B's `bar$1`. Instead it must enforce that `bar$0` in
   // `A` redirects to A's bar$1.
   foo() => confuse(super.bar)();
   foo2() => confuse(super.bar)(2);
   foo3() => confuse(super.bar2)();
@@ skipping 34 matching lines @@
   bar2({ namedOptional }) => -1; //   //# 01: continued
   bar3(x, [var optional]) => -1; //   //# 01: continued
   bar4(x, { namedOptional }) => -1; //# 01: continued
 
   gee([var optional]) => -1; //       //# 01: continued
   gee2({ namedOptional }) => -1; //   //# 01: continued
   gee3(x, [var optional]) => -1; //   //# 01: continued
   gee4(x, { namedOptional }) => -1; //# 01: continued
 
   add([var optional = 33]) => -1;
-  trim({ namedOptional: 22 }) => -1;
+  trim({namedOptional: 22}) => -1;
   sublist(x, [optional = 44]) => -1;
-  splitMapJoin(x, { onMatch: 55, onNonMatch: 66}) => -1;
+  splitMapJoin(x, {onMatch: 55, onNonMatch: 66}) => -1;
 
   shuffle([var optional = 121]) => -1;
-  toList({ growable: 2233 }) => -1;
+  toList({growable: 2233}) => -1;
   lastIndexOf(x, [optional = 424]) => -1;
-  lastWhere(x, { orElse: 555 }) => -1;
+  lastWhere(x, {orElse: 555}) => -1;
 }
 
 confuse(x) {
   if (new DateTime.now().millisecondsSinceEpoch == 42) return confuse(x - 1);
   return x;
 }
 
 main() {
-  var list = [new A(), new B(), [], "foo" ];
+  var list = [new A(), new B(), [], "foo"];
   var a = list[confuse(0)];
   var b = list[confuse(1)];
   var ignored = list[confuse(2)];
   var ignored2 = list[confuse(3)];
 
   var t = b.gee() + b.gee2() + b.gee3(9) + b.gee4(19);
   Expect.equals(-4, t); //# 01: continued
   t = b.shuffle() + b.toList() + b.lastIndexOf(1) + b.lastWhere(2);
   Expect.equals(-4, t);
 
@@ skipping 26 matching lines @@
 
   Expect.equals(12463, b.fooIntercept21());
   Expect.equals(12344, b.fooIntercept22());
   Expect.equals(15364, b.fooIntercept23());
   Expect.equals(13208, b.fooIntercept24());
   Expect.equals(14742, b.fooIntercept25());
   Expect.equals(14291, b.fooIntercept26());
   Expect.equals(1768, b.fooIntercept27());
   Expect.equals(1771, b.fooIntercept28());
 }