Run dartfmt on remaining unformated pkg packages

pkg/testing/lib/src/analyze.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.analyze;
 
-import 'dart:async' show
-    Stream,
-    Future;
+import 'dart:async' show Stream, Future;
 
-import 'dart:convert' show
-    LineSplitter,
-    UTF8;
+import 'dart:convert' show LineSplitter, UTF8;
 
-import 'dart:io' show
-    File,
-    Process;
+import 'dart:io' show File, Process;
 
-import '../testing.dart' show
-    dartSdk;
+import '../testing.dart' show dartSdk;
 
-import 'log.dart' show
-    isVerbose;
+import 'log.dart' show isVerbose;
 
-import 'suite.dart' show
-    Suite;
+import 'suite.dart' show Suite;
 
 class Analyze extends Suite {
   final Uri analysisOptions;
 
   final List<Uri> uris;
 
   final List<RegExp> exclude;
 
   Analyze(this.analysisOptions, this.uris, this.exclude)
       : super("analyze", "analyze", null);
@@ skipping 41 matching lines @@
   final String message;
 
   AnalyzerDiagnostic(this.kind, this.detailedKind, this.code, this.uri,
       this.line, this.startColumn, this.endColumn, this.message);
 
   factory AnalyzerDiagnostic.fromLine(String line) {
     List<String> parts = line.split("|");
     if (parts.length != 8) {
       throw "Malformed output: $line";
     }
-    return new AnalyzerDiagnostic(parts[0], parts[1], parts[2],
+    return new AnalyzerDiagnostic(
+        parts[0],
+        parts[1],
+        parts[2],
         Uri.base.resolve(parts[3]),
-        int.parse(parts[4]), int.parse(parts[5]), int.parse(parts[6]),
+        int.parse(parts[4]),
+        int.parse(parts[5]),
+        int.parse(parts[6]),
         parts[7]);
   }
 
   String toString() {
     return "$uri:$line:$startColumn: "
         "${kind == 'INFO' ? 'warning: hint' : kind.toLowerCase()}:\n"
         "[$code] $message";
   }
 }
 
 Stream<AnalyzerDiagnostic> parseAnalyzerOutput(
     Stream<List<int>> stream) async* {
   Stream<String> lines =
       stream.transform(UTF8.decoder).transform(new LineSplitter());
   await for (String line in lines) {
     yield new AnalyzerDiagnostic.fromLine(line);
   }
 }
 
 /// Run dartanalyzer on all tests in [uris].
-Future<Null> analyzeUris(
-    Uri analysisOptions, Uri packages, List<Uri> uris,
+Future<Null> analyzeUris(Uri analysisOptions, Uri packages, List<Uri> uris,
     List<RegExp> exclude) async {
   if (uris.isEmpty) return;
   const String analyzerPath = "bin/dartanalyzer";
   Uri analyzer = dartSdk.resolve(analyzerPath);
   if (!await new File.fromUri(analyzer).exists()) {
     throw "Couldn't find '$analyzerPath' in '${dartSdk.toFilePath()}'";
   }
   List<String> arguments = <String>[
-      "--packages=${packages.toFilePath()}",
-      "--package-warnings",
-      "--format=machine",
+    "--packages=${packages.toFilePath()}",
+    "--package-warnings",
+    "--format=machine",
   ];
   if (analysisOptions != null) {
     arguments.add("--options=${analysisOptions.toFilePath()}");
   }
   arguments.addAll(uris.map((Uri uri) => uri.toFilePath()));
   if (isVerbose) {
     print("Running:\n  ${analyzer.toFilePath()} ${arguments.join(' ')}");
   } else {
     print("Running dartanalyzer.");
   }
@@ skipping 16 matching lines @@
       hasOutput = true;
       print(message);
     }
   }
   if (hasOutput) {
     throw "Non-empty output from analyzer.";
   }
   sw.stop();
   print("Running analyzer took: ${sw.elapsed}.");
 }
-