Run dartfmt on remaining unformated pkg packages

pkg/testing/lib/src/run.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.md file.
 
 library testing.run;
 
-import 'dart:async' show
-    Future,
-    Stream;
+import 'dart:async' show Future, Stream;
 
-import 'dart:convert' show
-    JSON;
+import 'dart:convert' show JSON;
 
-import 'dart:io' show
-    Platform;
+import 'dart:io' show Platform;
 
-import 'dart:isolate' show
-    Isolate,
-    ReceivePort;
+import 'dart:isolate' show Isolate, ReceivePort;
 
-import 'test_root.dart' show
-    TestRoot;
+import 'test_root.dart' show TestRoot;
 
-import 'test_description.dart' show
-    TestDescription;
+import 'test_description.dart' show TestDescription;
 
-import 'error_handling.dart' show
-    withErrorHandling;
+import 'error_handling.dart' show withErrorHandling;
 
-import 'chain.dart' show
-    CreateContext;
+import 'chain.dart' show CreateContext;
 
-import '../testing.dart' show
-    Chain,
-    ChainContext,
-    TestDescription,
-    listTests;
+import '../testing.dart' show Chain, ChainContext, TestDescription, listTests;
 
-import 'analyze.dart' show
-    Analyze;
+import 'analyze.dart' show Analyze;
 
-import 'log.dart' show
-    isVerbose,
-    logMessage,
-    logNumberedLines,
-    splitLines;
+import 'log.dart' show isVerbose, logMessage, logNumberedLines, splitLines;
 
-import 'suite.dart' show
-    Dart,
-    Suite;
+import 'suite.dart' show Dart, Suite;
 
-import 'test_dart.dart' show
-    TestDart;
+import 'test_dart.dart' show TestDart;
 
-import 'zone_helper.dart' show
-    acknowledgeControlMessages;
+import 'zone_helper.dart' show acknowledgeControlMessages;
 
 Future<TestRoot> computeTestRoot(String configurationPath, Uri base) {
   Uri configuration = configurationPath == null
       ? Uri.base.resolve("testing.json")
       : base.resolve(configurationPath);
   return TestRoot.fromUri(configuration);
 }
 
 /// This is called from a Chain suite, and helps implement main. In most cases,
 /// main will look like this:
 ///
 ///     main(List<String> arguments) => runMe(arguments, createContext);
 ///
 /// The optional argument [configurationPath] should be used when
 /// `testing.json` isn't located in the current working directory and is a path
 /// relative to `Platform.script`.
-Future<Null> runMe(
-    List<String> arguments, CreateContext f, [String configurationPath]) {
+Future<Null> runMe(List<String> arguments, CreateContext f,
+    [String configurationPath]) {
   return withErrorHandling(() async {
     TestRoot testRoot =
         await computeTestRoot(configurationPath, Platform.script);
     for (Chain suite in testRoot.toolChains) {
       if (Platform.script == suite.source) {
         print("Running suite ${suite.name}...");
         ChainContext context = await f(suite, <String, String>{});
         await context.run(suite, new Set<String>());
       }
     }
@@ skipping 20 matching lines @@
 ///     import 'package:testing/testing.dart' show run;
 ///
 ///     main() {
 ///       test("my_suite", () => run([], ["my_suite"]),
 ///           timeout: new Timeout(new Duration(minutes: 5)));
 ///     }
 ///
 /// The optional argument [configurationPath] should be used when
 /// `testing.json` isn't located in the current working directory and is a path
 /// relative to `Uri.base`.
-Future<Null> run(
-    List<String> arguments, List<String> suiteNames,
+Future<Null> run(List<String> arguments, List<String> suiteNames,
     [String configurationPath]) {
   return withErrorHandling(() async {
     TestRoot root = await computeTestRoot(configurationPath, Uri.base);
-    List<Suite> suites = root.suites.where(
-        (Suite suite) => suiteNames.contains(suite.name)).toList();
-    SuiteRunner runner = new SuiteRunner(suites, <String, String>{}, null,
-        new Set<String>(), new Set<String>());
+    List<Suite> suites = root.suites
+        .where((Suite suite) => suiteNames.contains(suite.name))
+        .toList();
+    SuiteRunner runner = new SuiteRunner(
+        suites, <String, String>{}, null, new Set<String>(), new Set<String>());
     String program = await runner.generateDartProgram();
     await runner.analyze(root.packages);
     if (program != null) {
       await runProgram(program, root.packages);
     }
   });
 }
 
 Future<Null> runProgram(String program, Uri packages) async {
   logMessage("Running:");
   logNumberedLines(program);
   Uri dataUri = new Uri.dataFromString(program);
   ReceivePort exitPort = new ReceivePort();
   Isolate isolate = await Isolate.spawnUri(dataUri, <String>[], null,
-      paused: true, onExit: exitPort.sendPort, errorsAreFatal: false,
-      checked: true, packageConfig: packages);
+      paused: true,
+      onExit: exitPort.sendPort,
+      errorsAreFatal: false,
+      checked: true,
+      packageConfig: packages);
   List error;
   var subscription = isolate.errors.listen((data) {
     error = data;
     exitPort.close();
   });
   await acknowledgeControlMessages(isolate, resume: isolate.pauseCapability);
   await for (var _ in exitPort) {
     exitPort.close();
   }
   subscription.cancel();
@@ skipping 90 matching lines @@
       if (shouldRunSuite(suite)) {
         hasAnalyzerSuites = true;
         await suite.run(packages, testUris);
       }
     }
     return hasAnalyzerSuites;
   }
 
   Stream<TestDescription> listDescriptions() async* {
     for (Dart suite in suites.where((Suite suite) => suite is Dart)) {
-      await for (TestDescription description in
-                     listTests(<Uri>[suite.uri], pattern: "")) {
+      await for (TestDescription description
+          in listTests(<Uri>[suite.uri], pattern: "")) {
         testUris.add(await Isolate.resolvePackageUri(description.uri));
         if (shouldRunSuite(suite)) {
           String path = description.file.uri.path;
           if (suite.exclude.any((RegExp r) => path.contains(r))) continue;
           if (suite.pattern.any((RegExp r) => path.contains(r))) {
             yield description;
           }
         }
       }
     }
   }
 
   Stream<Chain> listChainSuites() async* {
     for (Chain suite in suites.where((Suite suite) => suite is Chain)) {
       testUris.add(await Isolate.resolvePackageUri(suite.source));
       if (shouldRunSuite(suite)) {
         yield suite;
       }
     }
   }
 
   Iterable<Suite> listTestDartSuites() {
     return suites.where((Suite suite) => suite is TestDart);
   }
 
   Iterable<Suite> listAnalyzerSuites() {
     return suites.where((Suite suite) => suite is Analyze);
   }
 }