Autoformat tools/testing/dart

tools/testing/dart/multitest.dart

 // Copyright (c) 2012, 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 multitest;
 
 import "dart:async";
 import "dart:io";
 
 import "path.dart";
@@ skipping 43 matching lines @@
 //   aaa
 //   eee /// 10: ok
 //   fff
 //
 // Note that it is possible to indicate more than one acceptable outcome
 // in the case of dynamic and static type warnings
 //   aaa
 //   ddd /// 07: static type warning, dynamic type error
 //   fff
 
-void ExtractTestsFromMultitest(Path filePath,
-                               Map<String, String> tests,
-                               Map<String, Set<String>> outcomes) {
+void ExtractTestsFromMultitest(Path filePath, Map<String, String> tests,
+    Map<String, Set<String>> outcomes) {
   // Read the entire file into a byte buffer and transform it to a
   // String. This will treat the file as ascii but the only parts
   // we are interested in will be ascii in any case.
   List bytes = new File(filePath.toNativePath()).readAsBytesSync();
   String contents = decodeUtf8(bytes);
   int first_newline = contents.indexOf('\n');
-  final String line_separator =
-      (first_newline == 0 || contents[first_newline - 1] != '\r')
-      ? '\n'
-      : '\r\n';
+  final String line_separator = (first_newline == 0 ||
+      contents[first_newline - 1] != '\r') ? '\n' : '\r\n';
   List<String> lines = contents.split(line_separator);
   if (lines.last == '') lines.removeLast();
   bytes = null;
   contents = null;
-  Set<String> validMultitestOutcomes = new Set<String>.from(
-      ['ok', 'compile-time error', 'runtime error',
-       'static type warning', 'dynamic type error',
-       'checked mode compile-time error']);
+  Set<String> validMultitestOutcomes = new Set<String>.from([
+    'ok',
+    'compile-time error',
+    'runtime error',
+    'static type warning',
+    'dynamic type error',
+    'checked mode compile-time error'
+  ]);
 
   // Create the set of multitests, which will have a new test added each
   // time we see a multitest line with a new key.
   Map<String, List<String>> testsAsLines = new Map<String, List<String>>();
 
   // Add the default case with key "none".
   testsAsLines['none'] = new List<String>();
   outcomes['none'] = new Set<String>();
 
   int lineCount = 0;
   for (String line in lines) {
     lineCount++;
     var annotation = new _Annotation.from(line);
     if (annotation != null) {
-      testsAsLines.putIfAbsent(annotation.key,
-          () => new List<String>.from(testsAsLines["none"]));
+      testsAsLines.putIfAbsent(
+          annotation.key, () => new List<String>.from(testsAsLines["none"]));
       // Add line to test with annotation.key as key, empty line to the rest.
       for (var key in testsAsLines.keys) {
         testsAsLines[key].add(annotation.key == key ? line : "");
       }
       outcomes.putIfAbsent(annotation.key, () => new Set<String>());
       if (annotation.rest != 'continued') {
         for (String nextOutcome in annotation.outcomesList) {
           if (validMultitestOutcomes.contains(nextOutcome)) {
             outcomes[annotation.key].add(nextOutcome);
           } else {
@@ skipping 54 matching lines @@
         .map((s) => s.trim())
         .where((s) => s.length > 0)
         .toList();
     if (parts.length <= 1) {
       return null;
     }
 
     var annotation = new _Annotation();
     annotation.key = parts[0];
     annotation.rest = parts[1];
-    annotation.outcomesList = annotation.rest.split(',')
-        .map((s) => s.trim()).toList();
+    annotation.outcomesList =
+        annotation.rest.split(',').map((s) => s.trim()).toList();
     return annotation;
   }
 }
 
 // Find all relative imports and copy them into the dir that contains
 // the generated tests.
 Set<String> _findAllRelativeImports(Path topLibrary) {
   Set<Path> toSearch = new Set<Path>.from([topLibrary]);
   Set<String> foundImports = new Set<String>();
   Path libraryDir = topLibrary.directoryPath;
@@ skipping 25 matching lines @@
           }
           foundImports.add(relativePath.toString());
           toSearch.add(libraryDir.join(relativePath));
         }
       }
     }
   }
   return foundImports;
 }
 
-Future doMultitest(Path filePath, String outputDir, Path suiteDir,
-                   CreateTest doTest) {
+Future doMultitest(
+    Path filePath, String outputDir, Path suiteDir, CreateTest doTest) {
   void writeFile(String filepath, String content) {
     final File file = new File(filepath);
 
     if (file.existsSync()) {
       var oldContent = file.readAsStringSync();
       if (oldContent == content) {
         // Don't write to the file if the content is the same
         return;
       }
     }
@@ skipping 13 matching lines @@
   Set<String> importsToCopy = _findAllRelativeImports(filePath);
   List<Future> futureCopies = [];
   for (String relativeImport in importsToCopy) {
     Path importPath = new Path(relativeImport);
     // Make sure the target directory exists.
     Path importDir = importPath.directoryPath;
     if (!importDir.isEmpty) {
       TestUtils.mkdirRecursive(targetDir, importDir);
     }
     // Copy file.
-    futureCopies.add(TestUtils.copyFile(sourceDir.join(importPath),
-                                        targetDir.join(importPath)));
+    futureCopies.add(TestUtils.copyFile(
+        sourceDir.join(importPath), targetDir.join(importPath)));
   }
 
   // Wait until all imports are copied before scheduling test cases.
   return Future.wait(futureCopies).then((_) {
     String baseFilename = filePath.filenameWithoutExtension;
     for (String key in tests.keys) {
       final Path multitestFilename =
           targetDir.append('${baseFilename}_$key.dart');
       writeFile(multitestFilename.toNativePath(), tests[key]);
       Set<String> outcome = outcomes[key];
       bool hasStaticWarning = outcome.contains('static type warning');
       bool hasRuntimeErrors = outcome.contains('runtime error');
       bool hasCompileError = outcome.contains('compile-time error');
       bool isNegativeIfChecked = outcome.contains('dynamic type error');
       bool hasCompileErrorIfChecked =
           outcome.contains('checked mode compile-time error');
-      doTest(multitestFilename,
-             filePath,
-             hasCompileError,
-             hasRuntimeErrors,
-             isNegativeIfChecked: isNegativeIfChecked,
-             hasCompileErrorIfChecked: hasCompileErrorIfChecked,
-             hasStaticWarning: hasStaticWarning,
-             multitestKey: key);
+      doTest(multitestFilename, filePath, hasCompileError, hasRuntimeErrors,
+          isNegativeIfChecked: isNegativeIfChecked,
+          hasCompileErrorIfChecked: hasCompileErrorIfChecked,
+          hasStaticWarning: hasStaticWarning,
+          multitestKey: key);
     }
 
     return null;
   });
 }
 
-
 Path CreateMultitestDirectory(String outputDir, Path suiteDir) {
   Directory generatedTestDir = new Directory('$outputDir/generated_tests');
   if (!new Directory(outputDir).existsSync()) {
     new Directory(outputDir).createSync();
   }
   if (!generatedTestDir.existsSync()) {
     generatedTestDir.createSync();
   }
   var split = suiteDir.segments();
   if (split.last == 'src') {
     // TODO(sigmund): remove this once all tests are migrated to use
     // TestSuite.forDirectory.
     split.removeLast();
   }
   String path = '${generatedTestDir.path}/${split.last}';
   Directory dir = new Directory(path);
   if (!dir.existsSync()) {
     dir.createSync();
   }
   return new Path(new File(path).absolute.path);
 }