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 693 matching lines @@
  * The output information is stored in a [CommandOutput] instance contained
  * in TestCase.commandOutputs. The last CommandOutput instance is responsible
  * for evaluating if the test has passed, failed, crashed, or timed out, and the
  * TestCase has information about what the expected result of the test should
  * be.
  *
  * The TestCase has a callback function, [completedHandler], that is run when
  * the test is completed.
  */
 class TestCase extends UniqueObject {
+  // Flags set in _expectations from the optional argument info.
+  static final int IS_NEGATIVE = 1 << 0;
+  static final int HAS_RUNTIME_ERROR = 1 << 1;
+  static final int HAS_STATIC_WARNING = 1 << 2;
+  static final int IS_NEGATIVE_IF_CHECKED = 1 << 3;
+  static final int HAS_COMPILE_ERROR = 1 << 4;
+  static final int HAS_COMPILE_ERROR_IF_CHECKED = 1 << 5;
+  static final int EXPECT_COMPILE_ERROR = 1 << 6;
   /**
    * A list of commands to execute. Most test cases have a single command.
    * Dart2js tests have two commands, one to compile the source and another
    * to execute it. Some isolate tests might even have three, if they require
    * compiling multiple sources that are run in isolation.
    */
   List<Command> commands;
   Map<Command, CommandOutput> commandOutputs = new Map<Command,CommandOutput>();
 
   Map configuration;
   String displayName;
-  bool isNegative;
+  int _expectations = 0;
+  int hash = 0;
   Set<Expectation> expectedOutcomes;
-  TestInformation info;
 
   TestCase(this.displayName,
            this.commands,
            this.configuration,
            this.expectedOutcomes,
-           {this.isNegative: false,
-            this.info: null}) {
-    if (!isNegative) {
-      this.isNegative = displayName.contains("negative_test");
+           {isNegative: false,
+            TestInformation info: null}) {
+    if (isNegative || displayName.contains("negative_test")) {
+      _expectations |= IS_NEGATIVE;
+    }
+    if (info != null) {
+      _setExpectations(info);
+      hash = info.originTestPath.relativeTo(TestUtils.dartDir)
+          .toString().hashCode;
     }
   }
 
-  /// Returns `true` if this test case should result in a compile-time error,
-  /// either unconditionally or if the configuration is 'checked'.
-  bool get expectCompileError {
-    if (info == null) return false;
-    return info.hasCompileError ||
-        (configuration['checked'] && info.hasCompileErrorIfChecked);
+  void _setExpectations(TestInformation info) {
+    // We don't want to keep the entire (large) TestInformation structure,
+    // so we copy the needed bools into flags set in a single integer.
+    if (info.hasRuntimeError) _expectations |= HAS_RUNTIME_ERROR;
+    if (info.hasStaticWarning) _expectations |= HAS_STATIC_WARNING;
+    if (info.isNegativeIfChecked) _expectations |= IS_NEGATIVE_IF_CHECKED;
+    if (info.hasCompileError) _expectations |= HAS_COMPILE_ERROR;
+    if (info.hasCompileErrorIfChecked) {
+      _expectations |= HAS_COMPILE_ERROR_IF_CHECKED;
+    }
+    if (info.hasCompileError ||
+        (configuration['checked'] && info.hasCompileErrorIfChecked)) {
+      _expectations |= EXPECT_COMPILE_ERROR;
+    }
   }
 
+  bool get isNegative => _expectations & IS_NEGATIVE != 0;
+  bool get hasRuntimeError => _expectations & HAS_RUNTIME_ERROR != 0;
+  bool get hasStaticWarning => _expectations & HAS_STATIC_WARNING != 0;
+  bool get isNegativeIfChecked => _expectations & IS_NEGATIVE_IF_CHECKED != 0;
+  bool get hasCompileError => _expectations & HAS_COMPILE_ERROR != 0;
+  bool get hasCompileErrorIfChecked =>
+      _expectations & HAS_COMPILE_ERROR_IF_CHECKED != 0;
+  bool get expectCompileError => _expectations & EXPECT_COMPILE_ERROR != 0;
+
   bool get unexpectedOutput {
     var outcome = lastCommandOutput.result(this);
     return !expectedOutcomes.any((expectation) {
       return outcome.canBeOutcomeOf(expectation);
     });
   }
 
   Expectation get result => lastCommandOutput.result(this);
 
   CommandOutput get lastCommandOutput {
@@ skipping 255 matching lines @@
     }
   }
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     var outcome = _getOutcome();
 
-    if (testCase.info != null && testCase.info.hasRuntimeError) {
+    if (testCase.hasRuntimeError) {
       if (!outcome.canBeOutcomeOf(Expectation.RUNTIME_ERROR)) {
         return Expectation.MISSING_RUNTIME_ERROR;
       }
     }
     if (testCase.isNegative) {
       if (outcome.canBeOutcomeOf(Expectation.FAIL)) return Expectation.PASS;
       return Expectation.FAIL;
     }
     return outcome;
   }
@@ skipping 322 matching lines @@
       : super(command, 0, result.didTimeout, stdout, stderr, result.duration,
               false, 0) {
     _result = result;
   }
 
   Expectation result(TestCase testCase) {
     // Handle timeouts first
     if (_result.didTimeout)  return Expectation.TIMEOUT;
 
     // Multitests are handled specially
-    if (testCase.info != null) {
-      if (testCase.info.hasRuntimeError) {
-        if (_rawOutcome == Expectation.RUNTIME_ERROR) return Expectation.PASS;
-        return Expectation.MISSING_RUNTIME_ERROR;
-      }
+    if (testCase.hasRuntimeError) {
+      if (_rawOutcome == Expectation.RUNTIME_ERROR) return Expectation.PASS;
+      return Expectation.MISSING_RUNTIME_ERROR;
     }
 
     return _negateOutcomeIfNegativeTest(_rawOutcome, testCase.isNegative);
   }
 }
 
 
 class AnalysisCommandOutputImpl extends CommandOutputImpl {
   // An error line has 8 fields that look like:
   // ERROR|COMPILER|MISSING_SOURCE|file:/tmp/t.dart|15|1|24|Missing source.
@@ skipping 26 matching lines @@
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     // Get the errors/warnings from the analyzer
     List<String> errors = [];
     List<String> warnings = [];
     parseAnalyzerOutput(errors, warnings);
 
     // Handle errors / missing errors
-    if (testCase.info.hasCompileError) {
+    if (testCase.hasCompileError) {
       // Don't use [TestCase.expectCompileError] since the analyzer does not
       // (currently) report checked-mode only compile time errors.
       if (errors.length > 0) {
         return Expectation.PASS;
       }
       return Expectation.MISSING_COMPILETIME_ERROR;
     }
     if (errors.length > 0) {
       return Expectation.COMPILETIME_ERROR;
     }
 
     // Handle static warnings / missing static warnings
-    if (testCase.info.hasStaticWarning) {
+    if (testCase.hasStaticWarning) {
       if (warnings.length > 0) {
         return Expectation.PASS;
       }
       return Expectation.MISSING_STATIC_WARNING;
     }
     if (warnings.length > 0) {
       return Expectation.STATIC_WARNING;
     }
 
     assert (errors.length == 0 && warnings.length == 0);
-    assert (!testCase.info.hasCompileError &&
-            !testCase.info.hasStaticWarning);
+    assert (!testCase.hasCompileError &&
+            !testCase.hasStaticWarning);
     return Expectation.PASS;
   }
 
   void parseAnalyzerOutput(List<String> outErrors, List<String> outWarnings) {
     AnalysisCommand analysisCommand = command;
 
     // Parse a line delimited by the | character using \ as an escape charager
     // like:  FOO|BAR|FOO\|BAR|FOO\\BAZ as 4 fields: FOO BAR FOO|BAR FOO\BAZ
     List<String> splitMachineError(String line) {
       StringBuffer field = new StringBuffer();
@@ skipping 42 matching lines @@
                       List<int> stdout, List<int> stderr, Duration time,
                       int pid)
       : super(command, exitCode, timedOut, stdout, stderr, time, false, pid);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     // Multitests are handled specially
-    if (testCase.info != null) {
-      if (testCase.expectCompileError) {
-        if (exitCode == DART_VM_EXITCODE_COMPILE_TIME_ERROR) {
-          return Expectation.PASS;
-        }
-
-        return Expectation.MISSING_COMPILETIME_ERROR;
+    if (testCase.expectCompileError) {
+      if (exitCode == DART_VM_EXITCODE_COMPILE_TIME_ERROR) {
+        return Expectation.PASS;
       }
-      if (testCase.info.hasRuntimeError) {
-        // TODO(kustermann): Do we consider a "runtimeError" only an uncaught
-        // exception or does any nonzero exit code fullfil this requirement?
-        if (exitCode != 0) {
-          return Expectation.PASS;
-        }
-        return Expectation.MISSING_RUNTIME_ERROR;
+      return Expectation.MISSING_COMPILETIME_ERROR;
+    }
+    if (testCase.hasRuntimeError) {
+      // TODO(kustermann): Do we consider a "runtimeError" only an uncaught
+      // exception or does any nonzero exit code fullfil this requirement?
+      if (exitCode != 0) {
+        return Expectation.PASS;
       }
+      return Expectation.MISSING_RUNTIME_ERROR;
     }
 
     // The actual outcome depends on the exitCode
     Expectation outcome;
     if (exitCode == DART_VM_EXITCODE_COMPILE_TIME_ERROR) {
       outcome = Expectation.COMPILETIME_ERROR;
     } else if (exitCode == DART_VM_EXITCODE_UNCAUGHT_EXCEPTION) {
       outcome = Expectation.RUNTIME_ERROR;
     } else if (exitCode != 0) {
       // This is a general fail, in case we get an unknown nonzero exitcode.
@@ skipping 21 matching lines @@
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     // Handle dart2js/dart2dart specific crash detection
     if (exitCode == DART2JS_EXITCODE_CRASH ||
         exitCode == VmCommandOutputImpl.DART_VM_EXITCODE_COMPILE_TIME_ERROR ||
         exitCode == VmCommandOutputImpl.DART_VM_EXITCODE_UNCAUGHT_EXCEPTION) {
       return Expectation.CRASH;
     }
 
     // Multitests are handled specially
-    if (testCase.info != null) {
     if (testCase.expectCompileError) {
-        // Nonzero exit code of the compiler means compilation failed
-        // TODO(kustermann): Do we have a special exit code in that case???
-        if (exitCode != 0) {
-          return Expectation.PASS;
-        }
-        return Expectation.MISSING_COMPILETIME_ERROR;
+      // Nonzero exit code of the compiler means compilation failed
+      // TODO(kustermann): Do we have a special exit code in that case???
+      if (exitCode != 0) {
+        return Expectation.PASS;
       }
+      return Expectation.MISSING_COMPILETIME_ERROR;
+    }
 
-      // TODO(kustermann): This is a hack, remove it
-      if (testCase.info.hasRuntimeError && testCase.commands.length > 1) {
-        // We expected to run the test, but we got an compile time error.
-        // If the compilation succeeded, we wouldn't be in here!
-        assert(exitCode != 0);
-        return Expectation.COMPILETIME_ERROR;
-      }
+    // TODO(kustermann): This is a hack, remove it
+    if (testCase.hasRuntimeError && testCase.commands.length > 1) {
+      // We expected to run the test, but we got an compile time error.
+      // If the compilation succeeded, we wouldn't be in here!
+      assert(exitCode != 0);
+      return Expectation.COMPILETIME_ERROR;
     }
 
     Expectation outcome =
         exitCode == 0 ? Expectation.PASS : Expectation.COMPILETIME_ERROR;
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class JsCommandlineOutputImpl extends CommandOutputImpl
                               with UnittestSuiteMessagesMixin {
   JsCommandlineOutputImpl(Command command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time)
       : super(command, exitCode, timedOut, stdout, stderr, time, false, 0);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
-    if (testCase.info != null && testCase.info.hasRuntimeError) {
+    if (testCase.hasRuntimeError) {
       if (exitCode != 0) return Expectation.PASS;
       return Expectation.MISSING_RUNTIME_ERROR;
     }
 
     var outcome = exitCode == 0 ? Expectation.PASS : Expectation.RUNTIME_ERROR;
     outcome = _negateOutcomeIfIncompleteAsyncTest(outcome, decodeUtf8(stdout));
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
@@ skipping 1338 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }