Autoformat tools/testing/dart

tools/testing/dart/test_progress.dart

 // Copyright (c) 2013, 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 test_progress;
 
 import "dart:async";
 import "dart:io";
 import "dart:io" as io;
 import "dart:convert" show JSON;
@@ skipping 43 matching lines @@
   static String ESCAPE = decodeUtf8([27]);
 
   String passed(String msg) => _color(msg, GREEN);
   String failed(String msg) => _color(msg, RED);
 
   static String _color(String msg, int color) {
     return "$ESCAPE[${color}m$msg$ESCAPE[0m";
   }
 }
 
-
 List<String> _buildFailureOutput(TestCase test,
-                                 [Formatter formatter = const Formatter()]) {
-
+    [Formatter formatter = const Formatter()]) {
   List<String> getLinesWithoutCarriageReturn(List<int> output) {
-    return decodeUtf8(output).replaceAll('\r\n', '\n')
-        .replaceAll('\r', '\n').split('\n');
+    return decodeUtf8(output)
+        .replaceAll('\r\n', '\n')
+        .replaceAll('\r', '\n')
+        .split('\n');
   }
 
   List<String> output = new List<String>();
   output.add('');
   output.add(formatter.failed('FAILED: ${test.configurationString}'
-                              ' ${test.displayName}'));
+      ' ${test.displayName}'));
   StringBuffer expected = new StringBuffer();
   expected.write('Expected: ');
   for (var expectation in test.expectedOutcomes) {
     expected.write('$expectation ');
   }
   output.add(expected.toString());
   output.add('Actual: ${test.result}');
   if (!test.lastCommandOutput.hasTimedOut) {
-    if (test.commandOutputs.length != test.commands.length
-        && !test.expectCompileError) {
+    if (test.commandOutputs.length != test.commands.length &&
+        !test.expectCompileError) {
       output.add('Unexpected compile-time error.');
     } else {
       if (test.expectCompileError) {
         output.add('Compile-time error expected.');
       }
       if (test.hasRuntimeError) {
         output.add('Runtime error expected.');
       }
       if (test.configuration['checked'] && test.isNegativeIfChecked) {
         output.add('Dynamic type error expected.');
@@ skipping 19 matching lines @@
       }
       if (!commandOutput.stderr.isEmpty) {
         output.add('');
         output.add('stderr:');
         output.addAll(getLinesWithoutCarriageReturn(commandOutput.stderr));
       }
     }
   }
   if (test is BrowserTestCase) {
     // Additional command for rerunning the steps locally after the fact.
-    var command =
-      test.configuration["_servers_"].httpServerCommandline();
+    var command = test.configuration["_servers_"].httpServerCommandline();
     output.add('');
     output.add('To retest, run:  $command');
   }
   for (var i = 0; i < test.commands.length; i++) {
     var command = test.commands[i];
     var commandOutput = test.commandOutputs[command];
     output.add('');
     output.add('Command[${command.displayName}]: $command');
     if (commandOutput != null) {
       output.add('Took ${commandOutput.time}');
     } else {
       output.add('Did not run');
     }
   }
 
   var arguments = ['python', 'tools/test.py'];
   arguments.addAll(test.configuration['_reproducing_arguments_']);
   arguments.add(test.displayName);
   var testPyCommandline = arguments.map(escapeCommandLineArgument).join(' ');
 
   output.add('');
   output.add('Short reproduction command (experimental):');
   output.add("    $testPyCommandline");
   return output;
 }
 
 String _buildSummaryEnd(int failedTests) {
-    if (failedTests == 0) {
-      return '\n===\n=== All tests succeeded\n===\n';
-    } else {
-      var pluralSuffix = failedTests != 1 ? 's' : '';
-      return '\n===\n=== ${failedTests} test$pluralSuffix failed\n===\n';
-    }
+  if (failedTests == 0) {
+    return '\n===\n=== All tests succeeded\n===\n';
+  } else {
+    var pluralSuffix = failedTests != 1 ? 's' : '';
+    return '\n===\n=== ${failedTests} test$pluralSuffix failed\n===\n';
+  }
 }
 
-
 class EventListener {
-  void testAdded() { }
-  void done(TestCase test) { }
-  void allTestsKnown() { }
-  void allDone() { }
+  void testAdded() {}
+  void done(TestCase test) {}
+  void allTestsKnown() {}
+  void allDone() {}
 }
 
 class ExitCodeSetter extends EventListener {
   void done(TestCase test) {
     if (test.unexpectedOutput) {
       io.exitCode = 1;
     }
   }
 }
 
@@ skipping 40 matching lines @@
    *         },
    *         {
    *           name: 'ff',
    *           duration: 200.2,
    *         },
    *       ],
    *     }
    *  },
    */
 
-  static final INTERESTED_CONFIGURATION_PARAMETERS =
-      ['mode', 'arch', 'compiler', 'runtime', 'checked', 'host_checked',
-       'minified', 'csp', 'system', 'vm_options', 'use_sdk',
-       'use_repository_packages', 'use_public_packages', 'builder_tag'];
+  static final INTERESTED_CONFIGURATION_PARAMETERS = [
+    'mode',
+    'arch',
+    'compiler',
+    'runtime',
+    'checked',
+    'host_checked',
+    'minified',
+    'csp',
+    'system',
+    'vm_options',
+    'use_sdk',
+    'use_repository_packages',
+    'use_public_packages',
+    'builder_tag'
+  ];
 
   IOSink _sink;
 
   void done(TestCase test) {
     var name = test.displayName;
     var configuration = {};
     for (var key in INTERESTED_CONFIGURATION_PARAMETERS) {
       configuration[key] = test.configuration[key];
     }
     var outcome = '${test.lastCommandOutput.result(test)}';
     var expectations =
         test.expectedOutcomes.map((expectation) => "$expectation").toList();
 
     var commandResults = [];
     double totalDuration = 0.0;
     for (var command in test.commands) {
       var output = test.commandOutputs[command];
       if (output != null) {
-        double duration = output.time.inMicroseconds/1000.0;
+        double duration = output.time.inMicroseconds / 1000.0;
         totalDuration += duration;
-        commandResults.add({
-          'name': command.displayName,
-          'duration': duration,
-        });
+        commandResults
+            .add({'name': command.displayName, 'duration': duration,});
       }
     }
     _writeTestOutcomeRecord({
-      'name' : name,
-      'configuration' : configuration,
-      'test_result' : {
-        'outcome' : outcome,
-        'expected_outcomes' : expectations,
-        'duration' : totalDuration,
-        'command_results' : commandResults,
+      'name': name,
+      'configuration': configuration,
+      'test_result': {
+        'outcome': outcome,
+        'expected_outcomes': expectations,
+        'duration': totalDuration,
+        'command_results': commandResults,
       },
     });
   }
 
   void allDone() {
     if (_sink != null) _sink.close();
   }
 
   void _writeTestOutcomeRecord(Map record) {
     if (_sink == null) {
       _sink = new File(TestUtils.testOutcomeFileName())
           .openWrite(mode: FileMode.APPEND);
     }
     _sink.write("${JSON.encode(record)}\n");
   }
 }
 
-
 class UnexpectedCrashDumpArchiver extends EventListener {
   void done(TestCase test) {
     if (test.unexpectedOutput && test.result == Expectation.CRASH) {
       var name = "core.dart.${test.lastCommandOutput.pid}";
       var file = new File(name);
       if (file.existsSync()) {
         // Find the binary - we assume this is the first part of the command
         var binName = test.lastCommandExecuted.toString().split(' ').first;
         var binFile = new File(binName);
         var binBaseName = new Path(binName).filename;
         if (binFile.existsSync()) {
           var tmpPath = new Path(Directory.systemTemp.path);
-          var dir = new Path(TestUtils.mkdirRecursive(tmpPath,
-              new Path('coredump_${test.lastCommandOutput.pid}')).path);
+          var dir = new Path(TestUtils
+              .mkdirRecursive(
+                  tmpPath, new Path('coredump_${test.lastCommandOutput.pid}'))
+              .path);
           TestUtils.copyFile(new Path(name), dir.append(name));
           TestUtils.copyFile(new Path(binName), dir.append(binBaseName));
           print("\nCopied core dump and binary for unexpected crash to: "
-                "$dir");
+              "$dir");
         }
       }
     }
   }
 }
 
-
 class SummaryPrinter extends EventListener {
   final bool jsonOnly;
 
   SummaryPrinter({bool jsonOnly})
       : jsonOnly = (jsonOnly == null) ? false : jsonOnly;
 
   void allTestsKnown() {
     if (jsonOnly) {
       print("JSON:");
       print(JSON.encode(summaryReport.values));
     } else {
       summaryReport.printReport();
     }
   }
 }
 
-
 class TimingPrinter extends EventListener {
   final _command2testCases = new Map<Command, List<TestCase>>();
   final _commandOutputs = new Set<CommandOutput>();
   DateTime _startTime;
 
   TimingPrinter(this._startTime);
 
   void done(TestCase testCase) {
     for (var commandOutput in testCase.commandOutputs.values) {
       var command = commandOutput.command;
@@ skipping 13 matching lines @@
     for (int i = 0; i < 20 && i < outputs.length; i++) {
       var commandOutput = outputs[i];
       var command = commandOutput.command;
       var testCases = _command2testCases[command];
 
       var testCasesDescription = testCases.map((testCase) {
         return "${testCase.configurationString}/${testCase.displayName}";
       }).join(', ');
 
       print('${commandOutput.time} - '
-            '${command.displayName} - '
-            '$testCasesDescription');
+          '${command.displayName} - '
+          '$testCasesDescription');
     }
   }
 }
 
 class StatusFileUpdatePrinter extends EventListener {
   var statusToConfigs = new Map<String, List<String>>();
   var _failureSummary = <String>[];
 
   void done(TestCase test) {
     if (test.unexpectedOutput) {
       _printFailureOutput(test);
     }
   }
 
   void allDone() {
     _printFailureSummary();
   }
 
-
   void _printFailureOutput(TestCase test) {
     String status = '${test.displayName}: ${test.result}';
     List<String> configs =
         statusToConfigs.putIfAbsent(status, () => <String>[]);
     configs.add(test.configurationString);
     if (test.lastCommandOutput.hasTimedOut) {
       print('\n${test.displayName} timed out on ${test.configurationString}');
     }
   }
 
   String _extractRuntime(String configuration) {
     // Extract runtime from a configuration, for example,
     // 'none-vm-checked release_ia32'.
     List<String> runtime = configuration.split(' ')[0].split('-');
     return '${runtime[0]}-${runtime[1]}';
   }
 
   void _printFailureSummary() {
     var groupedStatuses = new Map<String, List<String>>();
     statusToConfigs.forEach((String status, List<String> configs) {
       var runtimeToConfiguration = new Map<String, List<String>>();
       for (String config in configs) {
         String runtime = _extractRuntime(config);
         var runtimeConfigs =
             runtimeToConfiguration.putIfAbsent(runtime, () => <String>[]);
         runtimeConfigs.add(config);
       }
-      runtimeToConfiguration.forEach((String runtime,
-                                      List<String> runtimeConfigs) {
+      runtimeToConfiguration
+          .forEach((String runtime, List<String> runtimeConfigs) {
         runtimeConfigs.sort((a, b) => a.compareTo(b));
-        List<String> statuses =
-            groupedStatuses.putIfAbsent('$runtime: $runtimeConfigs',
-                                        () => <String>[]);
+        List<String> statuses = groupedStatuses.putIfAbsent(
+            '$runtime: $runtimeConfigs', () => <String>[]);
         statuses.add(status);
       });
     });
 
     print('\n\nNecessary status file updates:');
     groupedStatuses.forEach((String config, List<String> statuses) {
       print('');
       print('$config:');
       statuses.sort((a, b) => a.compareTo(b));
       for (String status in statuses) {
         print('  $status');
       }
     });
   }
 }
 
 class SkippedCompilationsPrinter extends EventListener {
   int _skippedCompilations = 0;
 
   void done(TestCase test) {
     for (var commandOutput in test.commandOutputs.values) {
-      if (commandOutput.compilationSkipped)
-        _skippedCompilations++;
+      if (commandOutput.compilationSkipped) _skippedCompilations++;
     }
   }
 
   void allDone() {
     if (_skippedCompilations > 0) {
       print('\n$_skippedCompilations compilations were skipped because '
-            'the previous output was already up to date\n');
+          'the previous output was already up to date\n');
     }
   }
 }
 
 class LeftOverTempDirPrinter extends EventListener {
   final MIN_NUMBER_OF_TEMP_DIRS = 50;
 
   static RegExp _getTemporaryDirectoryRegexp() {
     // These are the patterns of temporary directory names created by
     // 'Directory.systemTemp.createTemp()' on linux/macos and windows.
     if (['macos', 'linux'].contains(Platform.operatingSystem)) {
       return new RegExp(r'^temp_dir1_......$');
     } else {
       return new RegExp(r'tempdir-........-....-....-....-............$');
     }
   }
 
   static Stream<Directory> getLeftOverTemporaryDirectories() {
     var regExp = _getTemporaryDirectoryRegexp();
-    return Directory.systemTemp.list().where(
-        (FileSystemEntity fse) {
-          if (fse is Directory) {
-            if (regExp.hasMatch(new Path(fse.path).filename)) {
-              return true;
-            }
-          }
-          return false;
-        });
+    return Directory.systemTemp.list().where((FileSystemEntity fse) {
+      if (fse is Directory) {
+        if (regExp.hasMatch(new Path(fse.path).filename)) {
+          return true;
+        }
+      }
+      return false;
+    });
   }
 
   void allDone() {
     getLeftOverTemporaryDirectories().length.then((int count) {
       if (count > MIN_NUMBER_OF_TEMP_DIRS) {
         DebugLogger.warning("There are ${count} directories "
-                            "in the system tempdir "
-                            "('${Directory.systemTemp.path}')! "
-                            "Maybe left over directories?\n");
+            "in the system tempdir "
+            "('${Directory.systemTemp.path}')! "
+            "Maybe left over directories?\n");
       }
     }).catchError((error) {
       DebugLogger.warning("Could not list temp directories, got: $error");
     });
   }
 }
 
 class LineProgressIndicator extends EventListener {
   void done(TestCase test) {
     var status = 'pass';
     if (test.unexpectedOutput) {
       status = 'fail';
     }
     print('Done ${test.configurationString} ${test.displayName}: $status');
   }
 }
 
-
 class TestFailurePrinter extends EventListener {
   bool _printSummary;
   var _formatter;
   var _failureSummary = <String>[];
-  var _failedTests= 0;
+  var _failedTests = 0;
 
-  TestFailurePrinter(this._printSummary,
-                     [this._formatter = const Formatter()]);
+  TestFailurePrinter(this._printSummary, [this._formatter = const Formatter()]);
 
   void done(TestCase test) {
     if (test.unexpectedOutput) {
       _failedTests++;
       var lines = _buildFailureOutput(test, _formatter);
       for (var line in lines) {
         print(line);
       }
       print('');
       if (_printSummary) {
@@ skipping 14 matching lines @@
 
         print(_buildSummaryEnd(_failedTests));
       }
     }
   }
 }
 
 class ProgressIndicator extends EventListener {
   ProgressIndicator(this._startTime);
 
-
-  void testAdded() { _foundTests++; }
+  void testAdded() {
+    _foundTests++;
+  }
 
   void done(TestCase test) {
     if (test.unexpectedOutput) {
       _failedTests++;
     } else {
       _passedTests++;
     }
     _printDoneProgress(test);
   }
 
   void allTestsKnown() {
     _allTestsKnown = true;
   }
 
   void _printDoneProgress(TestCase test) {}
 
   int _completedTests() => _passedTests + _failedTests;
 
   int _foundTests = 0;
   int _passedTests = 0;
   int _failedTests = 0;
   bool _allTestsKnown = false;
   DateTime _startTime;
 }
 
 abstract class CompactIndicator extends ProgressIndicator {
-  CompactIndicator(DateTime startTime)
-      : super(startTime);
+  CompactIndicator(DateTime startTime) : super(startTime);
 
   void allDone() {
     if (_failedTests > 0) {
       // We may have printed many failure logs, so reprint the summary data.
       _printProgress();
     }
     print('');
   }
 
   void _printDoneProgress(TestCase test) => _printProgress();
 
   void _printProgress();
 }
 
-
 class CompactProgressIndicator extends CompactIndicator {
   Formatter _formatter;
 
   CompactProgressIndicator(DateTime startTime, this._formatter)
       : super(startTime);
 
   void _printProgress() {
     var percent = ((_completedTests() / _foundTests) * 100).toInt().toString();
     var progressPadded = _pad(_allTestsKnown ? percent : '--', 3);
     var passedPadded = _pad(_passedTests.toString(), 5);
     var failedPadded = _pad(_failedTests.toString(), 5);
     Duration d = (new DateTime.now()).difference(_startTime);
-    var progressLine =
-        '\r[${_timeString(d)} | $progressPadded% | '
+    var progressLine = '\r[${_timeString(d)} | $progressPadded% | '
         '+${_formatter.passed(passedPadded)} | '
         '-${_formatter.failed(failedPadded)}]';
     stdout.write(progressLine);
   }
 }
 
-
 class VerboseProgressIndicator extends ProgressIndicator {
-  VerboseProgressIndicator(DateTime startTime)
-      : super(startTime);
+  VerboseProgressIndicator(DateTime startTime) : super(startTime);
 
   void _printDoneProgress(TestCase test) {
     var status = 'pass';
     if (test.unexpectedOutput) {
       status = 'fail';
     }
     print('Done ${test.configurationString} ${test.displayName}: $status');
   }
 }
 
-
 class BuildbotProgressIndicator extends ProgressIndicator {
   static String stepName;
   var _failureSummary = <String>[];
 
   BuildbotProgressIndicator(DateTime startTime) : super(startTime);
 
   void done(TestCase test) {
     super.done(test);
     if (test.unexpectedOutput) {
       _failureSummary.addAll(_buildFailureOutput(test));
@@ skipping 19 matching lines @@
       }
       for (String line in _failureSummary) {
         print(line);
       }
       print('');
     }
     print(_buildSummaryEnd(_failedTests));
   }
 }
 
-
-EventListener progressIndicatorFromName(String name,
-                                        DateTime startTime,
-                                        Formatter formatter) {
+EventListener progressIndicatorFromName(
+    String name, DateTime startTime, Formatter formatter) {
   switch (name) {
     case 'compact':
       return new CompactProgressIndicator(startTime, formatter);
     case 'line':
       return new LineProgressIndicator();
     case 'verbose':
       return new VerboseProgressIndicator(startTime);
     case 'status':
       return new ProgressIndicator(startTime);
     case 'buildbot':
       return new BuildbotProgressIndicator(startTime);
     default:
       assert(false);
       break;
   }
 }