dart2js: run dartfmt on tests

tests/compiler/dart2js/serialization/helper.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_helper;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common/names.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 
 import '../memory_compiler.dart';
 import 'test_data.dart';
 
 const String DEFAULT_DATA_FILE_NAME = 'out.data';
 
 class Arguments {
   final String filename;
   final int start;
   final int end;
   final bool loadSerializedData;
   final bool saveSerializedData;
   final String serializedDataFileName;
   final bool verbose;
 
-  const Arguments({
-    this.filename,
-    this.start,
-    this.end,
-    this.loadSerializedData: false,
-    this.saveSerializedData: false,
-    this.serializedDataFileName: DEFAULT_DATA_FILE_NAME,
-    this.verbose: false});
+  const Arguments(
+      {this.filename,
+      this.start,
+      this.end,
+      this.loadSerializedData: false,
+      this.saveSerializedData: false,
+      this.serializedDataFileName: DEFAULT_DATA_FILE_NAME,
+      this.verbose: false});
 
   factory Arguments.from(List<String> arguments) {
     String filename;
     int start;
     int end;
     for (String arg in arguments) {
       if (!arg.startsWith('-')) {
         int index = int.parse(arg, onError: (_) => null);
         if (index == null) {
           filename = arg;
@@ skipping 17 matching lines @@
     }
     return new Arguments(
         filename: filename,
         start: start,
         end: end,
         verbose: verbose,
         loadSerializedData: loadSerializedData,
         saveSerializedData: saveSerializedData);
   }
 
-  Future forEachTest(
-      SerializedData serializedData,
-      List<Test> tests,
+  Future forEachTest(SerializedData serializedData, List<Test> tests,
       TestFunction testFunction) async {
     Uri entryPoint = Uri.parse('memory:main.dart');
     int first = start ?? 0;
     int last = end ?? tests.length;
 
     for (int index = first; index < last; index++) {
       Test test = TESTS[index];
       List<SerializedData> dataList =
           await preserializeData(serializedData, test);
       Map<String, String> sourceFiles = <String, String>{};
@@ skipping 12 matching lines @@
       await testFunction(entryPoint,
           sourceFiles: sourceFiles,
           resolutionInputs: resolutionInputs,
           index: index,
           test: test,
           verbose: verbose);
     }
   }
 }
 
-typedef Future TestFunction(
-    Uri entryPoint,
+typedef Future TestFunction(Uri entryPoint,
     {Map<String, String> sourceFiles,
-     List<Uri> resolutionInputs,
-     int index,
-     Test test,
-     bool verbose});
+    List<Uri> resolutionInputs,
+    int index,
+    Test test,
+    bool verbose});
 
 Future<SerializedData> serializeDartCore(
     {Arguments arguments: const Arguments()}) {
   return measure('dart:core', 'serialize', () async {
     Uri uri = Uri.parse('memory:${arguments.serializedDataFileName}');
     SerializedData serializedData;
     if (arguments.loadSerializedData) {
       File file = new File(arguments.serializedDataFileName);
       if (file.existsSync()) {
         print('Loading data from $file');
@@ skipping 15 matching lines @@
 
 class SerializationResult {
   final Compiler compiler;
   final SerializedData serializedData;
 
   SerializationResult(this.compiler, this.serializedData);
 }
 
 Future<SerializationResult> serialize(Uri entryPoint,
     {Map<String, String> memorySourceFiles: const <String, String>{},
-     List<Uri> resolutionInputs: const <Uri>[],
-     Uri dataUri,
-     bool deserializeCompilationDataForTesting: false}) async {
+    List<Uri> resolutionInputs: const <Uri>[],
+    Uri dataUri,
+    bool deserializeCompilationDataForTesting: false}) async {
   if (dataUri == null) {
     dataUri = Uri.parse('memory:${DEFAULT_DATA_FILE_NAME}');
   }
   OutputCollector outputCollector = new OutputCollector();
   Compiler compiler = compilerFor(
       options: [Flags.resolveOnly],
       memorySourceFiles: memorySourceFiles,
       resolutionInputs: resolutionInputs,
       outputProvider: outputCollector);
   compiler.serialization.deserializeCompilationDataForTesting =
       deserializeCompilationDataForTesting;
   await compiler.run(entryPoint);
-  SerializedData serializedData = new SerializedData(
-      dataUri, outputCollector.getOutput('', 'data'));
+  SerializedData serializedData =
+      new SerializedData(dataUri, outputCollector.getOutput('', 'data'));
   return new SerializationResult(compiler, serializedData);
 }
 
 class SerializedData {
   final Uri uri;
   final String data;
 
   SerializedData(this.uri, this.data) {
     assert(uri != null);
     assert(data != null);
@@ skipping 41 matching lines @@
     uriList.add(Uri.parse('memory:$key'));
   }
   Map<String, String> sourceFiles = serializedData.toMemorySourceFiles();
   sourceFiles.addAll(test.preserializedSourceFiles);
   if (test.unserializedSourceFiles != null) {
     sourceFiles.addAll(test.unserializedSourceFiles);
   }
   Uri additionalDataUri = Uri.parse('memory:additional.data');
   SerializedData additionalSerializedData;
   if (test.sourceFiles.isEmpty) {
-    SerializationResult result = await serialize(
-        uriList.first,
+    SerializationResult result = await serialize(uriList.first,
         memorySourceFiles: sourceFiles,
-        resolutionInputs:  serializedData.toUris(),
+        resolutionInputs: serializedData.toUris(),
         dataUri: additionalDataUri);
     additionalSerializedData = result.serializedData;
   } else {
     OutputCollector outputCollector = new OutputCollector();
     Compiler compiler = compilerFor(
         entryPoint: test.sourceFiles.isEmpty ? uriList.first : null,
         memorySourceFiles: sourceFiles,
         resolutionInputs: serializedData.toUris(),
         options: [Flags.resolveOnly],
         outputProvider: outputCollector);
     compiler.librariesToAnalyzeWhenRun = uriList;
     await compiler.run(null);
     List<LibraryElement> libraries = <LibraryElement>[];
     for (Uri uri in uriList) {
       libraries.add(compiler.libraryLoader.lookupLibrary(uri));
     }
     additionalSerializedData = new SerializedData(
-        additionalDataUri,
-        outputCollector.getOutput('', 'data'));
+        additionalDataUri, outputCollector.getOutput('', 'data'));
   }
   return <SerializedData>[serializedData, additionalSerializedData];
 }
 
 class MeasurementResult {
   final String title;
   final String taskTitle;
   final int elapsedMilliseconds;
 
   MeasurementResult(this.title, this.taskTitle, this.elapsedMilliseconds);
@@ skipping 35 matching lines @@
 /// [measurementResults] for a summary.
 Future measure(String title, String taskTitle, Future task()) async {
   Stopwatch stopwatch = new Stopwatch()..start();
   print('================================================================');
   print('$taskTitle: $title');
   print('----------------------------------------------------------------');
   var result = await task();
   stopwatch.stop();
   int elapsedMilliseconds = stopwatch.elapsedMilliseconds;
   print('$taskTitle: $title: ${elapsedMilliseconds}ms');
-  measurementResults.add(
-      new MeasurementResult(title, taskTitle, elapsedMilliseconds));
+  measurementResults
+      .add(new MeasurementResult(title, taskTitle, elapsedMilliseconds));
   return result;
-}
+}