dart2js: run dartfmt on tests

tests/compiler/dart2js/world_test.dart

 // Copyright (c) 2015, 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.
 
 library world_test;
 
 import 'package:expect/expect.dart';
 import 'package:async_helper/async_helper.dart';
 import 'type_test_helper.dart';
 import 'package:compiler/src/common.dart';
-import 'package:compiler/src/elements/elements.dart'
-       show Element, ClassElement;
+import 'package:compiler/src/elements/elements.dart' show Element, ClassElement;
 import 'package:compiler/src/universe/class_set.dart';
 import 'package:compiler/src/world.dart' show ClassWorld;
 
 void main() {
   asyncTest(() async {
     await testClassSets();
     await testProperties();
   });
 }
 
 testClassSets() async {
-  var env = await TypeEnvironment.create(r"""
+  var env = await TypeEnvironment.create(
+      r"""
       class A implements X {}
       class B {}
       class C_Super extends A {}
       class C extends C_Super {}
       class D implements A {}
       class E extends B implements A {}
       class F extends Object with A implements B {}
       class G extends Object with A, B {}
       class X {}
       """,
@@ skipping 14 matching lines @@
   ClassElement Object_ = env.getElement("Object");
   ClassElement A = env.getElement("A");
   ClassElement B = env.getElement("B");
   ClassElement C = env.getElement("C");
   ClassElement D = env.getElement("D");
   ClassElement E = env.getElement("E");
   ClassElement F = env.getElement("F");
   ClassElement G = env.getElement("G");
   ClassElement X = env.getElement("X");
 
-  void checkClasses(
-      String property,
-      ClassElement cls,
-      Iterable<ClassElement> foundClasses,
-      List<ClassElement> expectedClasses,
+  void checkClasses(String property, ClassElement cls,
+      Iterable<ClassElement> foundClasses, List<ClassElement> expectedClasses,
       {bool exact: true}) {
-
     for (ClassElement expectedClass in expectedClasses) {
-      Expect.isTrue(foundClasses.contains(expectedClass),
+      Expect.isTrue(
+          foundClasses.contains(expectedClass),
           "Expect $expectedClass in '$property' on $cls. "
           "Found:\n ${foundClasses.join('\n ')}\n"
           "${env.compiler.world.dump(cls)}");
     }
     if (exact) {
-      Expect.equals(expectedClasses.length, foundClasses.length,
+      Expect.equals(
+          expectedClasses.length,
+          foundClasses.length,
           "Unexpected classes "
           "${foundClasses.where((c) => !expectedClasses.contains(c))} "
           "in '$property' on $cls.\n"
           "${env.compiler.world.dump(cls)}");
     }
   }
 
-  void check(
-      String property,
-      ClassElement cls,
-      Iterable<ClassElement> foundClasses,
-      List<ClassElement> expectedClasses,
+  void check(String property, ClassElement cls,
+      Iterable<ClassElement> foundClasses, List<ClassElement> expectedClasses,
       {bool exact: true,
-       void forEach(ClassElement cls, ForEachFunction f),
-       int getCount(ClassElement cls)}) {
+      void forEach(ClassElement cls, ForEachFunction f),
+      int getCount(ClassElement cls)}) {
     checkClasses(property, cls, foundClasses, expectedClasses, exact: exact);
 
     if (forEach != null) {
       List<ClassElement> visited = <ClassElement>[];
       forEach(cls, (ClassElement c) {
         visited.add(c);
       });
-      checkClasses(
-          'forEach($property)', cls, visited, expectedClasses, exact: exact);
+      checkClasses('forEach($property)', cls, visited, expectedClasses,
+          exact: exact);
     }
 
     if (getCount != null && exact) {
       int count = getCount(cls);
-      Expect.equals(expectedClasses.length, count,
+      Expect.equals(
+          expectedClasses.length,
+          count,
           "Unexpected class count in '$property' on $cls.\n"
           "${env.compiler.world.dump(cls)}");
     }
-
   }
 
-  void testSubclasses(
-      ClassElement cls,
-      List<ClassElement> expectedClasses,
+  void testSubclasses(ClassElement cls, List<ClassElement> expectedClasses,
       {bool exact: true}) {
-    check(
-      'subclassesOf',
-      cls,
-      classWorld.subclassesOf(cls),
-      expectedClasses,
-      exact: exact);
+    check('subclassesOf', cls, classWorld.subclassesOf(cls), expectedClasses,
+        exact: exact);
   }
 
   void testStrictSubclasses(
-      ClassElement cls,
-      List<ClassElement> expectedClasses,
+      ClassElement cls, List<ClassElement> expectedClasses,
       {bool exact: true}) {
-    check(
-      'strictSubclassesOf',
-      cls,
-      classWorld.strictSubclassesOf(cls),
-      expectedClasses,
-      exact: exact,
-      forEach: classWorld.forEachStrictSubclassOf,
-      getCount: classWorld.strictSubclassCount);
+    check('strictSubclassesOf', cls, classWorld.strictSubclassesOf(cls),
+        expectedClasses,
+        exact: exact,
+        forEach: classWorld.forEachStrictSubclassOf,
+        getCount: classWorld.strictSubclassCount);
   }
 
-  void testStrictSubtypes(
-      ClassElement cls,
-      List<ClassElement> expectedClasses,
+  void testStrictSubtypes(ClassElement cls, List<ClassElement> expectedClasses,
       {bool exact: true}) {
-    check(
-      'strictSubtypesOf',
-      cls,
-      classWorld.strictSubtypesOf(cls),
-      expectedClasses,
-      exact: exact,
-      forEach: classWorld.forEachStrictSubtypeOf,
-      getCount: classWorld.strictSubtypeCount);
+    check('strictSubtypesOf', cls, classWorld.strictSubtypesOf(cls),
+        expectedClasses,
+        exact: exact,
+        forEach: classWorld.forEachStrictSubtypeOf,
+        getCount: classWorld.strictSubtypeCount);
   }
 
-  void testMixinUses(
-      ClassElement cls,
-      List<ClassElement> expectedClasses,
+  void testMixinUses(ClassElement cls, List<ClassElement> expectedClasses,
       {bool exact: true}) {
-    check(
-      'mixinUsesOf',
-      cls,
-      classWorld.mixinUsesOf(cls),
-      expectedClasses,
-      exact: exact);
+    check('mixinUsesOf', cls, classWorld.mixinUsesOf(cls), expectedClasses,
+        exact: exact);
   }
 
   testSubclasses(Object_, [A, B, C, D, E, F, G], exact: false);
   testSubclasses(A, [A, C]);
   testSubclasses(B, [B, E]);
   testSubclasses(C, [C]);
   testSubclasses(D, [D]);
   testSubclasses(E, [E]);
   testSubclasses(F, [F]);
   testSubclasses(G, [G]);
@@ skipping 24 matching lines @@
   testMixinUses(B, [G.superclass]);
   testMixinUses(C, []);
   testMixinUses(D, []);
   testMixinUses(E, []);
   testMixinUses(F, []);
   testMixinUses(G, []);
   testMixinUses(X, []);
 }
 
 testProperties() async {
-  var env = await TypeEnvironment.create(r"""
+  var env = await TypeEnvironment.create(
+      r"""
       class A {}
       class A1 extends A {}
       class A2 implements A {}
       class A3 extends Object with A {}
 
       class B {}
       class B1 extends B {}
       class B2 implements B {}
       class B3 extends Object with B {}
 
@@ skipping 38 matching lines @@
         new F1();
         new F2();
         new G2();
         new G3();
         new H4();
       }
       """,
       useMockCompiler: false);
   ClassWorld classWorld = env.compiler.world;
 
-  check(String name,
-      {bool hasStrictSubtype,
-       bool hasOnlySubclasses}) {
+  check(String name, {bool hasStrictSubtype, bool hasOnlySubclasses}) {
     ClassElement cls = env.getElement(name);
     Expect.equals(hasStrictSubtype, classWorld.hasAnyStrictSubtype(cls),
         "Unexpected hasAnyStrictSubtype property on $cls.");
     Expect.equals(hasOnlySubclasses, classWorld.hasOnlySubclasses(cls),
         "Unexpected hasOnlySubclasses property on $cls.");
   }
 
   check("Object", hasStrictSubtype: true, hasOnlySubclasses: true);
 
   // No instantiated Ax classes.
@@ skipping 41 matching lines @@
   check("G3", hasStrictSubtype: false, hasOnlySubclasses: true);
   check("G4", hasStrictSubtype: false, hasOnlySubclasses: true);
 
   // class H4 extends H2 with H extends H1 extends H instantiated
   check("H", hasStrictSubtype: true, hasOnlySubclasses: true);
   check("H1", hasStrictSubtype: true, hasOnlySubclasses: true);
   check("H2", hasStrictSubtype: true, hasOnlySubclasses: true);
   check("H3", hasStrictSubtype: false, hasOnlySubclasses: true);
   check("H4", hasStrictSubtype: false, hasOnlySubclasses: true);
 }