dart2js: run dartfmt on tests

tests/compiler/dart2js/serialization/test_data.dart

 // Copyright (c) 2016, 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 dart2js.serialization_test_data;
 
 const List<Test> TESTS = const <Test>[
   // These tests are very long-running and put here first to compile them on
   // their own tests.
-  const Test('Disable tree shaking through reflection', const {
-    'main.dart': '''
+  const Test(
+      'Disable tree shaking through reflection',
+      const {
+        'main.dart': '''
 import 'dart:mirrors';
 
 main() {
   reflect(null).invoke(#toString, []).reflectee;
 }
 ''',
-  }, expectedWarningCount: 1),
+      },
+      expectedWarningCount: 1),
 
   const Test('Use of dart:indexed_db', const {
     'main.dart': '''
 import 'a.dart';
 
 main() {}
 ''',
   }, preserializedSourceFiles: const {
     'a.dart': '''
 import 'dart:indexed_db';
 ''',
   }),
 
   // These tests
-  const Test('Empty program', const {
-    'main.dart': 'main() {}'
-  }),
+  const Test('Empty program', const {'main.dart': 'main() {}'}),
 
-  const Test('Hello World', const {
-    'main.dart': 'main() => print("Hello World");'
-  }),
+  const Test(
+      'Hello World', const {'main.dart': 'main() => print("Hello World");'}),
 
-  const Test('Too many arguments to print', const {
-    'main.dart': 'main() => print("Hello World", 0);'
-  },
-  expectedWarningCount: 1,
-  expectedInfoCount: 1),
+  const Test('Too many arguments to print',
+      const {'main.dart': 'main() => print("Hello World", 0);'},
+      expectedWarningCount: 1, expectedInfoCount: 1),
 
   const Test('Hello World with string interpolation', const {
     'main.dart': r'''
 main() {
   String text = "Hello World";
   print('$text');
 }'''
   }),
 
-  const Test('Too many arguments to print with string interpolation', const {
-    'main.dart': r'''
+  const Test(
+      'Too many arguments to print with string interpolation',
+      const {
+        'main.dart': r'''
 main() {
   String text = "Hello World";
   print('$text', text);
 }'''
-  },
-  expectedWarningCount: 1,
-  expectedInfoCount: 1),
+      },
+      expectedWarningCount: 1,
+      expectedInfoCount: 1),
 
   const Test('Print main arguments', const {
     'main.dart': r'''
 main(List<String> arguments) {
   print(arguments);
 }'''
   }),
 
   const Test('For loop on main arguments', const {
-      'main.dart': r'''
+    'main.dart': r'''
 main(List<String> arguments) {
   for (int i = 0; i < arguments.length; i++) {
     print(arguments[i]);
   }
 }'''
-    }),
+  }),
 
   const Test('For-in loop on main arguments', const {
     'main.dart': r'''
 main(List<String> arguments) {
   for (String argument in arguments) {
     print(argument);
   }
 }'''
   }),
 
   const Test('Simple class', const {
     'main.dart': r'''
 class Class {}
 main() {
   print(new Class());
 }'''
   }),
 
-  const Test('Simple class implements Function without call method', const {
-    'main.dart': r'''
+  const Test(
+      'Simple class implements Function without call method',
+      const {
+        'main.dart': r'''
 class Class implements Function {}
 main() {
   print(new Class());
 }'''
-  },
-  expectedWarningCount: 1),
+      },
+      expectedWarningCount: 1),
 
   const Test('Simple class implements Function with call method', const {
     'main.dart': r'''
 class Class implements Function {
   call() {}
 }
 main() {
   print(new Class()());
 }'''
   }),
 
   const Test('Implement Comparable', const {
     'main.dart': r'''
 class Class implements Comparable<Class> {
   int compareTo(Class other) => 0;
 }
 main() {
   print(new Class());
 }'''
   }),
 
-  const Test('Implement Comparable with two many type arguments', const {
-    'main.dart': r'''
+  const Test(
+      'Implement Comparable with two many type arguments',
+      const {
+        'main.dart': r'''
 class Class implements Comparable<Class, Class> {
   int compareTo(other) => 0;
 }
 main() {
   print(new Class());
 }'''
-  },
-  expectedWarningCount: 1),
+      },
+      expectedWarningCount: 1),
 
-  const Test('Implement Comparable with incompatible parameter types', const {
-    'main.dart': r'''
+  const Test(
+      'Implement Comparable with incompatible parameter types',
+      const {
+        'main.dart': r'''
 class Class implements Comparable<Class> {
   int compareTo(String other) => 0;
 }
 main() {
   print(new Class().compareTo(null));
 }'''
-  },
-  expectedWarningCount: 1,
-  expectedInfoCount: 1),
+      },
+      expectedWarningCount: 1,
+      expectedInfoCount: 1),
 
-  const Test('Implement Comparable with incompatible parameter count', const {
-    'main.dart': r'''
+  const Test(
+      'Implement Comparable with incompatible parameter count',
+      const {
+        'main.dart': r'''
 class Class implements Comparable {
   bool compareTo(a, b) => true;
 }
 main() {
   print(new Class().compareTo(null, null));
 }'''
-  },
-  expectedWarningCount: 1,
-  expectedInfoCount: 1),
+      },
+      expectedWarningCount: 1,
+      expectedInfoCount: 1),
 
-  const Test('Implement Random and call nextInt directly', const {
-    'main.dart': r'''
+  const Test(
+      'Implement Random and call nextInt directly',
+      const {
+        'main.dart': r'''
 import 'dart:math';
 
 class MyRandom implements Random {
   int nextInt(int max) {
     return max.length;
   }
   bool nextBool() => true;
   double nextDouble() => 0.0;
 }
 main() {
   new MyRandom().nextInt(0);
 }'''
-  },
-  expectedWarningCount: 1,
-  expectedInfoCount: 0),
+      },
+      expectedWarningCount: 1,
+      expectedInfoCount: 0),
 
   const Test('Implement Random and do not call nextInt', const {
     'main.dart': r'''
 import 'dart:math';
 
 class MyRandom implements Random {
   int nextInt(int max) {
     return max.length;
   }
   bool nextBool() => true;
   double nextDouble() => 0.0;
 }
 main() {
   new MyRandom();
 }'''
   }),
 
-  const Test('Implement Random and call nextInt through native code', const {
-    'main.dart': r'''
+  const Test(
+      'Implement Random and call nextInt through native code',
+      const {
+        'main.dart': r'''
 import 'dart:math';
 
 class MyRandom implements Random {
   int nextInt(int max) {
     return max.length;
   }
   bool nextBool() => true;
   double nextDouble() => 0.0;
 }
 main() {
   // Invocation of `MyRandom.nextInt` is only detected knowing the actual 
   // implementation class for `List` and the world impact of its `shuffle` 
   // method.  
   [].shuffle(new MyRandom());
 }'''
-  },
-  expectedWarningCount: 1,
-  expectedInfoCount: 0),
+      },
+      expectedWarningCount: 1,
+      expectedInfoCount: 0),
 
   const Test('Handle break and continue', const {
     'main.dart': '''
 main() {
   loop: for (var a in []) {
     for (var b in []) {
       continue loop;
     }
     break;
   }      
@@ skipping 45 matching lines @@
 }
 main() => new C();'''
   }),
 
   const Test('Constructed constant using its default values.', const {
     'main.dart': '''
 main() => const Duration();
 ''',
   }),
 
-  const Test('Call forwarding constructor on named mixin application',
-      const {
-        'main.dart': '''
+  const Test('Call forwarding constructor on named mixin application', const {
+    'main.dart': '''
 import 'dart:collection';
 main() => new UnmodifiableListView(null);
 ''',
   }),
 
   const Test('Function reference constant', const {
     'main.dart': '''
 var myIdentical = identical;
 main() => myIdentical;
 ''',
   }),
 
   const Test('Super method call', const {
     'main.dart': '''
 class Foo {
   String toString() => super.toString();
 }
 main() {
   print(new Foo());
 }
 ''',
   }),
 
-  const Test('Call forwarding constructor on named mixin application, no args.',
+  const Test(
+      'Call forwarding constructor on named mixin application, no args.',
       const {
         'main.dart': '''
 import 'lib.dart';
 main() => new C();
 ''',
-  }, preserializedSourceFiles: const {
+      },
+      preserializedSourceFiles: const {
         'lib.dart': '''
 class M {}
 class S {}
 class C = S with M;
 ''',
       }),
 
-  const Test('Call forwarding constructor on named mixin application, one arg.',
+  const Test(
+      'Call forwarding constructor on named mixin application, one arg.',
       const {
         'main.dart': '''
 import 'lib.dart';
 main() => new C(0);
 ''',
-      }, preserializedSourceFiles: const {
+      },
+      preserializedSourceFiles: const {
         'lib.dart': '''
 class M {}
 class S {
   S(a);
 }
 class C = S with M;
 ''',
       }),
 
-  const Test('Import mirrors, thus checking import paths', const {
-    'main.dart': '''
+  const Test(
+      'Import mirrors, thus checking import paths',
+      const {
+        'main.dart': '''
 import 'dart:mirrors';
 main() {}
 ''',
-  },
+      },
       expectedWarningCount: 1),
 
   const Test('Serialized symbol literal', const {
     'main.dart': '''
 import 'lib.dart';
 main() => m();
 ''',
   }, preserializedSourceFiles: const {
     'lib.dart': '''
 m() => print(#main);
@@ skipping 154 matching lines @@
 ''',
   }, preserializedSourceFiles: const {
     'a.dart': '''
 class A {}
 class B {}
 class C {}
 class D = A with B, C;
 ''',
     'b.dart': '''
 ''',
-}),
+  }),
 
   const Test('Deferred prefix loadLibrary', const {
     'main.dart': '''
 import 'a.dart';
 
 main() {
   test();
 }
 ''',
   }, preserializedSourceFiles: const {
     'a.dart': '''
 import 'b.dart' deferred as pre;
 test() {
   pre.loadLibrary();
 }
 ''',
     'b.dart': '''
 ''',
   }),
 
-  const Test('Deferred without prefix', const {
-    'main.dart': '''
+  const Test(
+      'Deferred without prefix',
+      const {
+        'main.dart': '''
 import 'a.dart';
 
 main() {
   test();
 }
 ''',
-  }, preserializedSourceFiles: const {
-    'a.dart': '''
+      },
+      preserializedSourceFiles: const {
+        'a.dart': '''
 import 'b.dart' deferred;
 test() {}
 ''',
-    'b.dart': '''
+        'b.dart': '''
 ''',
-  }, expectedErrorCount: 1),
+      },
+      expectedErrorCount: 1),
 
-  const Test('Deferred with duplicate prefix', const {
-    'main.dart': '''
+  const Test(
+      'Deferred with duplicate prefix',
+      const {
+        'main.dart': '''
 import 'a.dart';
 
 main() {
   test();
 }
 ''',
-  }, preserializedSourceFiles: const {
-    'a.dart': '''
+      },
+      preserializedSourceFiles: const {
+        'a.dart': '''
 import 'b.dart' deferred as pre;
 import 'c.dart' deferred as pre;
 test() {}
 ''',
-    'b.dart': '''
+        'b.dart': '''
 ''',
-    'c.dart': '''
+        'c.dart': '''
 ''',
-  }, expectedErrorCount: 1),
+      },
+      expectedErrorCount: 1),
 
   const Test('Closure in operator function', const {
     'main.dart': '''
 import 'a.dart';
 
 main() {
   test();
 }
 ''',
   }, preserializedSourceFiles: const {
     'a.dart': '''
 class C {
   operator ==(other) => () {};
 }
 
 test() => new C() == null;
 ''',
   }),
 
-  const Test('Checked setter', const {
-    'main.dart': '''
+  const Test(
+      'Checked setter',
+      const {
+        'main.dart': '''
 import 'a.dart';
 
 main() {
   test();
 }
 ''',
-  }, preserializedSourceFiles: const {
-    'a.dart': '''
+      },
+      preserializedSourceFiles: const {
+        'a.dart': '''
 class C {
   set foo(int i) {}
 }
 
 test() => new C().foo = 0;
 ''',
-  }, checkedMode: true),
+      },
+      checkedMode: true),
 
   const Test('Deferred access', const {
     'main.dart': '''
 import 'a.dart';
 
 main() {
   test();
 }
 ''',
   }, preserializedSourceFiles: const {
@@ skipping 32 matching lines @@
 main() {}
 ''',
   }, preserializedSourceFiles: const {
     'a.dart': '''
 import 'dart:indexed_db';
 ''',
   }),
 
   const Test('Deferred static access', const {},
       preserializedSourceFiles: const {
-    'main.dart': '''
+        'main.dart': '''
 import 'b.dart' deferred as prefix;
 
 main() => prefix.loadLibrary().then((_) => prefix.test2());
 ''',
-    'b.dart': '''
+        'b.dart': '''
 test2() => x;
 var x = const ConstClass(const ConstClass(1));
 class ConstClass {
   final x;
   const ConstClass(this.x);
 }
 ''',
-  }),
+      }),
 
   const Test('Multi variable declaration', const {
     'main.dart': '''
 import 'a.dart';
 
 main() => y;
 ''',
   }, preserializedSourceFiles: const {
     'a.dart': '''
 var x, y = 2;
 ''',
   }),
 
-  const Test('Double values', const {},
-      preserializedSourceFiles: const {
-  'main.dart': '''
+  const Test('Double values', const {}, preserializedSourceFiles: const {
+    'main.dart': '''
 const a = 1e+400;
 main() => a;
 ''',
   }),
 
   const Test('Erroneous constructor', const {},
       preserializedSourceFiles: const {
+        'main.dart': '''
+main() => new Null();
+'''
+      }),
+
+  const Test('Metadata on imports', const {}, preserializedSourceFiles: const {
     'main.dart': '''
-main() => new Null();
-'''}),
-
-  const Test('Metadata on imports', const {},
-      preserializedSourceFiles: const {
-        'main.dart': '''
 @deprecated
 import 'main.dart';
 
 main() {}
-'''}),
+'''
+  }),
 
-  const Test('Metadata on exports', const {},
-      preserializedSourceFiles: const {
-        'main.dart': '''
+  const Test('Metadata on exports', const {}, preserializedSourceFiles: const {
+    'main.dart': '''
 @deprecated
 export 'main.dart';
 
 main() {}
-'''}),
+'''
+  }),
 
   const Test('Metadata on part tags', const {},
       preserializedSourceFiles: const {
         'main.dart': '''
 library main;
 
 @deprecated
 part 'a.dart';
 
 main() {}
-'''},
+'''
+      },
       unserializedSourceFiles: const {
         'a.dart': '''
 part of main;
-'''}),
+'''
+      }),
 
   const Test('Metadata on part-of tags', const {},
       preserializedSourceFiles: const {
         'main.dart': '''
 library main;
 
 part 'a.dart';
 
 main() {}
-'''},
+'''
+      },
       unserializedSourceFiles: const {
         'a.dart': '''
 @deprecated
 part of main;
-'''}),
+'''
+      }),
 
-  const Test('Ambiguous elements', const {},
-      preserializedSourceFiles: const {
-        'main.dart': '''
+  const Test('Ambiguous elements', const {}, preserializedSourceFiles: const {
+    'main.dart': '''
 import 'a.dart';
 import 'b.dart';
 
 main() => new foo();
 ''',
-        'a.dart': '''
+    'a.dart': '''
 var foo;
 ''',
-        'b.dart': '''
+    'b.dart': '''
 var foo;
-''',}),
+''',
+  }),
 
   const Test('html and mirrors', const {},
       preserializedSourceFiles: const {
         'main.dart': '''
 import 'dart:html';
 import 'dart:mirrors';
 main() {}
-'''},
+'''
+      },
       expectedWarningCount: 1),
 ];
 
 class Test {
   final String name;
   final Map sourceFiles;
   final Map preserializedSourceFiles;
   final Map unserializedSourceFiles;
   final int expectedErrorCount;
   final int expectedWarningCount;
   final int expectedHintCount;
   final int expectedInfoCount;
   final bool checkedMode;
 
-  const Test(
-      this.name,
-      this.sourceFiles,
+  const Test(this.name, this.sourceFiles,
       {this.preserializedSourceFiles,
       this.unserializedSourceFiles,
       this.expectedErrorCount: 0,
       this.expectedWarningCount: 0,
       this.expectedHintCount: 0,
       this.expectedInfoCount: 0,
       this.checkedMode: false});
 }