Reduce test.dart memory usage.

tools/testing/dart/test_runner.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.
 
 /**
  * Classes and methods for executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
@@ skipping 558 matching lines @@
         other is MakeSymlinkCommand &&
         super._equal(other) &&
         _link == other._link &&
         _target == other._target;
   }
 }
 
 class CommandBuilder {
   static final CommandBuilder instance = new CommandBuilder._();
 
+  bool _cleared = false;
   final _cachedCommands = new Map<Command, Command>();
 
   CommandBuilder._();
 
+  void clearCommandCache() {
+    _cachedCommands.clear();
+    _cleared = true;
+  }
+
   ContentShellCommand getContentShellCommand(String executable,
                                              String htmlFile,
                                              List<String> options,
                                              List<String> dartFlags,
                                              Map<String, String> environment) {
     ContentShellCommand command = new ContentShellCommand._(
         executable, htmlFile, options, dartFlags, environment);
     return _getUniqueCommand(command);
   }
 
@@ skipping 74 matching lines @@
     if (destinationFile == null) destinationFile = pubspecYamlFile;
     return _getUniqueCommand(new ModifyPubspecYamlCommand._(
         pubspecYamlFile, destinationFile, depsOverrides));
   }
 
   Command _getUniqueCommand(Command command) {
     // All Command classes implement hashCode and operator==.
     // We check if this command has already been built.
     //  If so, we return the cached one. Otherwise we
     // store the one given as [command] argument.
+    if (_cleared) {
+      throw new Exception(
+          "CommandBuilder.get[type]Command called after cache cleared");
+    }
     var cachedCommand = _cachedCommands[command];
     if (cachedCommand != null) {
       return cachedCommand;
     }
     _cachedCommands[command] = command;
     return command;
   }
 }
 
 /**
@@ skipping 130 matching lines @@
   String _testingUrl;
 
   String get testingUrl => _testingUrl;
 }
 
 class UnittestSuiteMessagesMixin {
   bool _isAsyncTest(String testOutput) {
     return testOutput.contains("unittest-suite-wait-for-done");
   }
 
-  bool _isAsyncTestSuccessfull(String testOutput) {
+  bool _isAsyncTestSuccessful(String testOutput) {
     return testOutput.contains("unittest-suite-success");
   }
 
   Expectation _negateOutcomeIfIncompleteAsyncTest(Expectation outcome,
                                                   String testOutput) {
     // If this is an asynchronous test and the asynchronous operation didn't
     // complete successfully, it's outcome is Expectation.FAIL.
     // TODO: maybe we should introduce a AsyncIncomplete marker or so
     if (outcome == Expectation.PASS) {
       if (_isAsyncTest(testOutput) &&
-          !_isAsyncTestSuccessfull(testOutput)) {
+          !_isAsyncTestSuccessful(testOutput)) {
         return Expectation.FAIL;
       }
     }
     return outcome;
   }
 }
 
 /**
  * CommandOutput records the output of a completed command: the process's exit
  * code, the standard output and standard error, whether the process timed out,
@@ skipping 1422 matching lines @@
         _graph.changeState(node, newState);
       }
     }
   }
 }
 
 /*
  * [CommandQueue] will listen for nodes entering the NodeState.ENQUEUING state,
  * queue them up and run them. While nodes are processed they will be in the
  * NodeState.PROCESSING state. After running a command, the node will change
- * to a state of NodeState.Successfull or NodeState.Failed.
+ * to a state of NodeState.Successful or NodeState.Failed.
  *
  * It provides a synchronous stream [completedCommands] which provides the
  * [CommandOutputs] for the finished commands.
  *
  * It provides a [done] future, which will complete once there are no more
  * nodes left in the states Initialized/Waiting/Enqueing/Processing
  * and the [executor] has cleaned up it's resources.
  */
 class CommandQueue {
   final dgraph.Graph graph;
@@ skipping 23 matching lines @@
             var command = event.node.userData;
             if (event.node.dependencies.length > 0) {
               _runQueue.addFirst(command);
             } else {
               _runQueue.add(command);
             }
             Timer.run(() => _tryRunNextCommand());
           }
     });
     // We're finished if the graph is sealed and all nodes are in a finished
-    // state (Successfull, Failed or UnableToRun).
+    // state (Successful, Failed or UnableToRun).
     // So we're calling '_checkDone()' to check whether that condition is met
     // and we can cleanup.
     graph.events.listen((dgraph.GraphEvent event) {
       if (event is dgraph.GraphSealedEvent) {
         _checkDone();
       } else if (event is dgraph.StateChangedEvent) {
         if (event.to == dgraph.NodeState.UnableToRun) {
           _checkDone();
         }
       }
@@ skipping 308 matching lines @@
     // We currently rerun dartium tests, see issue 14074
     if (command is BrowserTestCommand && command.displayName == 'dartium') {
       return true;
     }
   }
   return false;
 }
 
 /*
  * [TestCaseCompleter] will listen for
- * NodeState.Processing -> NodeState.{Successfull,Failed} state changes and
+ * NodeState.Processing -> NodeState.{Successful,Failed} state changes and
  * will complete a TestCase if it is finished.
  *
  * It provides a stream [finishedTestCases], which will stream all TestCases
  * once they're finished. After all TestCases are done, the stream will be
  * closed.
  */
 class TestCaseCompleter {
   static final COMPLETED_STATES = [dgraph.NodeState.Failed,
                                    dgraph.NodeState.Successful];
   final dgraph.Graph graph;
@@ skipping 12 matching lines @@
     // (i.e. before state changes in the graph)
     commandQueue.completedCommands.listen((CommandOutput output) {
       _outputs[output.command] = output;
     }, onDone: () {
       _completeTestCasesIfPossible(new List.from(enqueuer.remainingTestCases));
       finishedRemainingTestCases = true;
       assert(enqueuer.remainingTestCases.isEmpty);
       _checkDone();
     });
 
-    // Listen for NodeState.Processing -> NodeState.{Successfull,Failed}
+    // Listen for NodeState.Processing -> NodeState.{Successful,Failed}
     // changes.
     eventCondition((event) => event is dgraph.StateChangedEvent)
         .listen((dgraph.StateChangedEvent event) {
           if (event.from == dgraph.NodeState.Processing &&
               !finishedRemainingTestCases ) {
             var command = event.node.userData;
 
             assert(COMPLETED_STATES.contains(event.to));
             assert(_outputs[command] != null);
 
@@ skipping 50 matching lines @@
         completeTestCase(testCase);
       }
     }
   }
 }
 
 
 class ProcessQueue {
   Map _globalConfiguration;
 
-  bool _allTestsWereEnqueued = false;
-
   bool _listTests;
   Function _allDone;
   final dgraph.Graph _graph = new dgraph.Graph();
   List<EventListener> _eventListener;
 
   ProcessQueue(this._globalConfiguration,
                maxProcesses,
                maxBrowserProcesses,
                DateTime startTime,
                testSuites,
@@ skipping 139 matching lines @@
     if (_globalConfiguration['list']) {
       setupForListing(testCaseEnqueuer);
     } else {
       setupForRunning(testCaseEnqueuer);
     }
 
     // Start enqueing all TestCases
     testCaseEnqueuer.enqueueTestSuites(testSuites);
   }
 
+  void freeEnqueueingStructures() {
+    CommandBuilder.instance.clearCommandCache();
+  }
+
   void eventFinishedTestCase(TestCase testCase) {
     for (var listener in _eventListener) {
       listener.done(testCase);
     }
   }
 
   void eventTestAdded(TestCase testCase) {
     for (var listener in _eventListener) {
       listener.testAdded();
     }
   }
 
   void eventAllTestsKnown() {
+    freeEnqueueingStructures();
     for (var listener in _eventListener) {
       listener.allTestsKnown();
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }