Refactoring of ProgressIndicator

tools/testing/dart/test_progress.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 test_progress;
 
 import "dart:io";
 import "dart:io" as io;
 import "http_server.dart" as http_server;
 import "status_file_parser.dart";
 import "test_runner.dart";
 import "test_suite.dart";
 import "utils.dart";
 
-class ProgressIndicator {
-  ProgressIndicator(this._startTime, this._printTiming)
-      : _tests = [], _failureSummary = [];
+String _padTime(int time) {
+  if (time == 0) {
+    return '00';
+  } else if (time < 10) {
+    return '0$time';
+  } else {
+    return '$time';
+  }
+}
+
+String _timeString(Duration d) {
+  var min = d.inMinutes;
+  var sec = d.inSeconds % 60;
+  return '${_padTime(min)}:${_padTime(sec)}';
+}
+
+class EventListener {
+  void testAdded() { }
+  void start(TestCase test) { }
+  void done(TestCase test) { }
+  void allTestsKnown() { }
+  void allDone() { }
+}
+
+class ExitCodeSetter extends EventListener {
+  bool _failingTest = false;
+
+  void done(TestCase test) {
+    _failingTest = _failingTest || test.lastCommandOutput.unexpectedOutput;
+  }
+  void allDone() {
+    if (_failingTest) {
+      io.exitCode = 1;
+    }
+  }
+}
+
+class SummaryPrinter extends EventListener {
+  void allTestsKnown() {
+    if (SummaryReport.total > 0) {
+      SummaryReport.printReport();
+    }
+  }
+}
+
+class TimingPrinter extends EventListener {
+  List<TestCase> _tests = <TestCase>[];
+  Date _startTime;
+
+  TimingPrinter(this._startTime);
+
+  void done(TestCase testCase) {
+    _tests.add(testCase);
+  }
+
+  void allDone() {
+    // TODO: We should take all the commands into account

[ahe, 2013/02/19 11:43:42]

Please use "TODO(username): Comment".

+    Duration d = (new Date.now()).difference(_startTime);
+    print('\n--- Total time: ${_timeString(d)} ---');
+    _tests.sort((a, b) {
+      Duration aDuration = a.lastCommandOutput.time;
+      Duration bDuration = b.lastCommandOutput.time;
+      return bDuration.inMilliseconds - aDuration.inMilliseconds;
+    });
+    for (int i = 0; i < 20 && i < _tests.length; i++) {
+      var name = _tests[i].displayName;
+      var duration = _tests[i].lastCommandOutput.time;
+      var configuration = _tests[i].configurationString;
+      print('${duration} - $configuration $name');
+    }
+  }
+}
+
+class LineProgressIndicator extends EventListener {
+  void done(TestCase test) {
+    var status = 'pass';
+    if (test.lastCommandOutput.unexpectedOutput) {
+      status = 'fail';
+    }
+    print('Done ${test.configurationString} ${test.displayName}: $status');
+  }
+}
+
+class ProgressIndicator extends EventListener {
+  ProgressIndicator(this._startTime)
+      : _failureSummary = [];
 
   factory ProgressIndicator.fromName(String name,
-                                     Date startTime,
-                                     bool printTiming) {
+                                     Date startTime) {
     switch (name) {
       case 'compact':
-        return new CompactProgressIndicator(startTime, printTiming);
+        return new CompactProgressIndicator(startTime);
       case 'color':
-        return new ColorProgressIndicator(startTime, printTiming);
+        return new ColorProgressIndicator(startTime);
       case 'line':
-        return new LineProgressIndicator(startTime, printTiming);
+        return new LineProgressIndicator();
       case 'verbose':
-        return new VerboseProgressIndicator(startTime, printTiming);
-      case 'silent':
-        return new SilentProgressIndicator(startTime, printTiming);
+        return new VerboseProgressIndicator(startTime);
       case 'status':
-        return new StatusProgressIndicator(startTime, printTiming);
+        return new StatusProgressIndicator(startTime);
       case 'buildbot':
-        return new BuildbotProgressIndicator(startTime, printTiming);
+        return new BuildbotProgressIndicator(startTime);
       case 'diff':
-        return new DiffProgressIndicator(startTime, printTiming);
+        return new DiffProgressIndicator(startTime);
       default:
         assert(false);
         break;
     }
   }
 
   void testAdded() { _foundTests++; }
 
   void start(TestCase test) {
     _printStartProgress(test);
@@ skipping 12 matching lines @@
         _skippedCompilations++;
     }
 
     if (test.lastCommandOutput.unexpectedOutput) {
       _failedTests++;
       _printFailureOutput(test);
     } else {
       _passedTests++;
     }
     _printDoneProgress(test);
-    // If we need to print timing information we hold on to all completed
-    // tests.
-    if (_printTiming) _tests.add(test);
   }
 
   void allTestsKnown() {
-    if (!_allTestsKnown) SummaryReport.printReport();
     _allTestsKnown = true;
   }
 
   void _printSkippedCompilationInfo() {
     if (_skippedCompilations > 0) {
       print('\n$_skippedCompilations compilations were skipped because '
             'the previous output was already up to date\n');
     }
   }
 
-  void _printTimingInformation() {
-    if (_printTiming) {
-      // TODO: We should take all the commands into account
-      Duration d = (new Date.now()).difference(_startTime);
-      print('\n--- Total time: ${_timeString(d)} ---');
-      _tests.sort((a, b) {
-        Duration aDuration = a.lastCommandOutput.time;
-        Duration bDuration = b.lastCommandOutput.time;
-        return bDuration.inMilliseconds - aDuration.inMilliseconds;
-      });
-      for (int i = 0; i < 20 && i < _tests.length; i++) {
-        var name = _tests[i].displayName;
-        var duration = _tests[i].lastCommandOutput.time;
-        var configuration = _tests[i].configurationString;
-        print('${duration} - $configuration $name');
-      }
-    }
-  }
-
   void allDone() {
     _printFailureSummary();
     _printStatus();
     _printSkippedCompilationInfo();
-    _printTimingInformation();
     stdout.close();
     stderr.close();
-    if (_failedTests > 0) {
-      io.exitCode = 1;
-    }
   }
 
   void _printStartProgress(TestCase test) {}
   void _printDoneProgress(TestCase test) {}
 
   String _pad(String s, int length) {
     StringBuffer buffer = new StringBuffer();
     for (int i = s.length; i < length; i++) {
       buffer.add(' ');
     }
     buffer.add(s);
     return buffer.toString();
   }
 
-  String _padTime(int time) {
-    if (time == 0) {
-      return '00';
-    } else if (time < 10) {
-      return '0$time';
-    } else {
-      return '$time';
-    }
-  }
-
-  String _timeString(Duration d) {
-    var min = d.inMinutes;
-    var sec = d.inSeconds % 60;
-    return '${_padTime(min)}:${_padTime(sec)}';
-  }
-
   String _header(String header) => header;
 
   void _printFailureOutput(TestCase test) {
     var failureOutput = _buildFailureOutput(test);
     for (var line in failureOutput) {
       print(line);
     }
     _failureSummary.addAll(failureOutput);
   }
 
@@ skipping 93 matching lines @@
   int get numFailedTests => _failedTests;
 
   int _completedTests() => _passedTests + _failedTests;
 
   int _foundTests = 0;
   int _passedTests = 0;
   int _failedTests = 0;
   int _skippedCompilations = 0;
   bool _allTestsKnown = false;
   Date _startTime;
-  bool _printTiming;
-  List<TestCase> _tests;
   List<String> _failureSummary;
 }
 
-
-class SilentProgressIndicator extends ProgressIndicator {
-  SilentProgressIndicator(Date startTime, bool printTiming)
-      : super(startTime, printTiming);
-  void testAdded() { }
-  void start(TestCase test) { }
-  void done(TestCase test) { }
-  void _printStartProgress(TestCase test) { }
-  void _printDoneProgress(TestCase test) { }
-  void allTestsKnown() { }
-  void allDone() { }
-}
-
 abstract class CompactIndicator extends ProgressIndicator {
-  CompactIndicator(Date startTime, bool printTiming)
-      : super(startTime, printTiming);
+  CompactIndicator(Date startTime)
+      : super(startTime);
 
   void allDone() {
     stdout.write('\n'.charCodes);
     _printFailureSummary();
     _printSkippedCompilationInfo();
-    _printTimingInformation();
     if (_failedTests > 0) {
       // We may have printed many failure logs, so reprint the summary data.
       _printProgress();
       print('');
     }
     stdout.close();
     stderr.close();
-    if (_failedTests > 0) {
-      io.exitCode = 1;
-    }
-  }
-
-  void allTestsKnown() {
-    if (!_allTestsKnown && SummaryReport.total > 0) {
-      // Clear progress indicator before printing summary report.
-      stdout.write(
-          '\r                                               \r'.charCodes);
-      SummaryReport.printReport();
-    }
-    _allTestsKnown = true;
   }
 
   void _printStartProgress(TestCase test) => _printProgress();
   void _printDoneProgress(TestCase test) => _printProgress();
 
   void _printProgress();
 }
 
 
 class CompactProgressIndicator extends CompactIndicator {
-  CompactProgressIndicator(Date startTime, bool printTiming)
-      : super(startTime, printTiming);
+  CompactProgressIndicator(Date startTime)
+      : 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 Date.now()).difference(_startTime);
     var progressLine =
         '\r[${_timeString(d)} | $progressPadded% | '
         '+$passedPadded | -$failedPadded]';
     stdout.write(progressLine.charCodes);
   }
 }
 
 
 class ColorProgressIndicator extends CompactIndicator {
-  ColorProgressIndicator(Date startTime, bool printTiming)
-      : super(startTime, printTiming);
+  ColorProgressIndicator(Date startTime)
+      : super(startTime);
 
   static int BOLD = 1;
   static int GREEN = 32;
   static int RED = 31;
   static int NONE = 0;
 
   addColorWrapped(List<int> codes, String string, int color) {
     codes.add(27);
     codes.addAll('[${color}m'.charCodes);
     codes.addAll(encodeUtf8(string));
@@ skipping 18 matching lines @@
   }
 
   String _header(String header) {
     var result = [];
     addColorWrapped(result, header, BOLD);
     return decodeUtf8(result);
   }
 }
 
 
-class LineProgressIndicator extends ProgressIndicator {
-  LineProgressIndicator(Date startTime, bool printTiming)
-      : super(startTime, printTiming);
-
-  void _printStartProgress(TestCase test) {
-  }
-
-  void _printDoneProgress(TestCase test) {
-    var status = 'pass';
-    if (test.lastCommandOutput.unexpectedOutput) {
-      status = 'fail';
-    }
-    print('Done ${test.configurationString} ${test.displayName}: $status');
-  }
-}
-
-
 class VerboseProgressIndicator extends ProgressIndicator {
-  VerboseProgressIndicator(Date startTime, bool printTiming)
-      : super(startTime, printTiming);
+  VerboseProgressIndicator(Date startTime)
+      : super(startTime);
 
   void _printStartProgress(TestCase test) {
     print('Starting ${test.configurationString} ${test.displayName}...');
   }
 
   void _printDoneProgress(TestCase test) {
     var status = 'pass';
     if (test.lastCommandOutput.unexpectedOutput) {
       status = 'fail';
     }
     print('Done ${test.configurationString} ${test.displayName}: $status');
   }
 }
 
 
 class StatusProgressIndicator extends ProgressIndicator {
-  StatusProgressIndicator(Date startTime, bool printTiming)
-      : super(startTime, printTiming);
+  StatusProgressIndicator(Date startTime)
+      : super(startTime);
 
   void _printStartProgress(TestCase test) {
   }
 
   void _printDoneProgress(TestCase test) {
   }
 }
 
 
 class BuildbotProgressIndicator extends ProgressIndicator {
   static String stepName;
 
-  BuildbotProgressIndicator(Date startTime, bool printTiming)
-      : super(startTime, printTiming);
+  BuildbotProgressIndicator(Date startTime)
+      : super(startTime);
 
   void _printStartProgress(TestCase test) {
   }
 
   void _printDoneProgress(TestCase test) {
     var status = 'pass';
     if (test.lastCommandOutput.unexpectedOutput) {
       status = 'fail';
     }
     var percent = ((_completedTests() / _foundTests) * 100).toInt().toString();
     print('Done ${test.configurationString} ${test.displayName}: $status');
     print('@@@STEP_CLEAR@@@');
     print('@@@STEP_TEXT@ $percent% +$_passedTests -$_failedTests @@@');
   }
 
   void _printFailureSummary() {
     if (!_failureSummary.isEmpty && stepName != null) {
       print('@@@STEP_FAILURE@@@');
       print('@@@BUILD_STEP $stepName failures@@@');
     }
     super._printFailureSummary();
   }
 }
 
 class DiffProgressIndicator extends ColorProgressIndicator {
   Map<String, List<String>> statusToConfigs = new Map<String, List<String>>();
 
-  DiffProgressIndicator(Date startTime, bool printTiming)
-      : super(startTime, printTiming);
+  DiffProgressIndicator(Date startTime)
+      : super(startTime);
 
   void _printFailureOutput(TestCase test) {
     String status = '${test.displayName}: ${test.lastCommandOutput.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}');
     }
   }
@@ skipping 30 matching lines @@
       print('');
       print('$config:');
       statuses.sort((a, b) => a.compareTo(b));
       for (String status in statuses) {
         print('  $status');
       }
     });
     _printStatus();
   }
 }