Added support for solo groups, multiple solo tests, and

pkg/unittest/lib/unittest.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.
 
 /**
  * A library for writing dart unit tests.
  *
  * ## Installing ##
  *
  * Use [pub][] to install this package. Add the following to your `pubspec.yaml`
@@ skipping 196 matching lines @@
 
 /** Separator used between group names and test names. */
 String groupSep = ' ';
 
 final List<TestCase> _testCases = new List<TestCase>();
 
 /** Tests executed in this suite. */
 final List<TestCase> testCases = new UnmodifiableListView<TestCase>(_testCases);
 
 /**
+ * The set of tests to run can be restricted by using [solo_test] and
+ * [solo_group].
+ * As groups can be nested we use a counter to keep track of the nest level
+ * of soloing, and a flag to tell if we have seen any solo tests.
+ */
+int _soloNestingLevel = 0;
+bool _soloTestSeen = false;
+
+/**
  * Setup and teardown functions for a group and its parents, the latter
  * for chaining.
  */
 class GroupContext {
   final GroupContext parent;
 
   /** Description text of the current test group. */
   final String _name;
 
   /** Setup function called before each test in a group. */
@@ skipping 73 matching lines @@
 
 /** Test case result strings. */
 // TODO(gram) we should change these constants to use a different string
 // (so that writing 'FAIL' in the middle of a test doesn't
 // imply that the test fails). We can't do it without also changing
 // the testrunner and test.dart though.
 const PASS  = 'pass';
 const FAIL  = 'fail';
 const ERROR = 'error';
 
-/** If set, then all other test cases will be ignored. */
-TestCase _soloTest;
-
 /**
  * A map that can be used to communicate state between a test driver
  * or main() function and the tests, particularly when these two
  * are otherwise independent. For example, a test driver that starts
  * an HTTP server and then runs tests that access that server could use
  * this as a way of communicating the server port to the tests.
  */
 Map testState = {};
 
 /**
  * Creates a new test case with the given description and body. The
  * description will include the descriptions of any surrounding group()
  * calls.
  */
 void test(String spec, TestFunction body) {
   ensureInitialized();
-  _testCases.add(new TestCase._internal(testCases.length + 1, _fullSpec(spec),
-                                        body));
+  if (!_soloTestSeen || _soloNestingLevel > 0) {
+    var testcase = new TestCase._internal(testCases.length + 1, _fullSpec(spec),
+                                        body);

[Siggi Cherem (dart-lang), 2013/04/26 18:53:47]

nit: fix indentation (should just be +4)

given that this is already wrapping, seems like we don't win much by adding the
variable declaration. 

+    _testCases.add(testcase);
+  }
 }
 
+/** Convenience function for skipping a test. */
+void skip_test(String spec, TestFunction body){}
+
 /**
  * Creates a new test case with the given description and body. The
  * description will include the descriptions of any surrounding group()
  * calls.
  *
- * "solo_" means that this will be the only test that is run. All other tests
- * will be skipped. This is a convenience function to let you quickly isolate
- * a single test by adding "solo_" before it to temporarily disable all other
- * tests.
+ * If we use [solo_test] (or [solo_group]) instead of test, then all non-solo
+ * tests will be disabled. Note that if we use [solo_group], all tests in
+ * the group will be enabled, regardless of whether they use [test] or
+ * [solo_test], or whether they are in a nested [group] vs [solo_group]. Put
+ * another way, if there are any calls to [solo_test] or [solo_group] in a test
+ * file, all tests that are not inside a [solo_group] will be disabled unless
+ * they are [solo_test]s.
+ *
+ * [skip_test] and [skip_group] take precedence over soloing, by virtue of the
+ * fact that they are effectively no-ops.
  */
 void solo_test(String spec, TestFunction body) {
-  // TODO(rnystrom): Support multiple solos. If more than one test is solo-ed,
-  // all of the solo-ed tests and none of the non-solo-ed ones should run.
-  if (_soloTest != null) {
-    throw new Exception('Only one test can be soloed right now.');
+  ensureInitialized();
+  if (!_soloTestSeen) {
+    _soloTestSeen = true;
+    // This is the first solo-ed test. Discard all tests up to now.
+    _testCases.clear();
   }
-
-  ensureInitialized();
-
-  _soloTest = new TestCase._internal(testCases.length + 1, _fullSpec(spec),
-                                     body);
-  _testCases.add(_soloTest);
+  ++_soloNestingLevel;
+  try {
+    test(spec, body);
+  } finally {
+    --_soloNestingLevel;
+  }
 }
 
 /** Sentinel value for [_SpreadArgsHelper]. */
 class _Sentinel {
   const _Sentinel();
 }
 
 /** Simulates spread arguments using named arguments. */
 // TODO(sigmund): remove this class and simply use a closure with named
 // arguments (if still applicable).
@@ skipping 223 matching lines @@
     body();
   } catch (e, trace) {
     var stack = (trace == null) ? '' : ': ${trace.toString()}';
     _uncaughtErrorMessage = "${e.toString()}$stack";
   } finally {
     // Now that the group is over, restore the previous one.
     _currentContext = _currentContext.parent;
   }
 }
 
+/** Like [skip_test], but for groups. */
+void skip_group(String description, void body()) {}
+
+/** Like [solo_test], but for groups. */
+void solo_group(String description, void body()) {
+  ensureInitialized();
+  if (!_soloTestSeen) {
+    _soloTestSeen = true;
+    // This is the first solo-ed group. Discard all tests up to now.
+    _testCases.clear();
+  }
+  ++_soloNestingLevel;
+  try {
+    group(description, body);
+  } finally {
+    --_soloNestingLevel;
+  }
+}
+
 /**
  * Register a [setUp] function for a test [group]. This function will
  * be called before each test in the group is run.
  * [setUp] and [tearDown] should be called within the [group] before any
  * calls to [test]. The [setupTest] function can be asynchronous; in this
  * case it must return a [Future].
  */
 void setUp(Function setupTest) {
   _currentContext.testSetup = setupTest;
 }
@@ skipping 53 matching lines @@
     filterFunction = testFilter;
   }
   _testCases.retainWhere(filterFunction);
 }
 
 /** Runs all queued tests, one at a time. */
 void runTests() {
   _ensureInitialized(false);
   _currentTestCaseIndex = 0;
 
-  // If we are soloing a test, remove all the others.
-  if (_soloTest != null) {
-    filterTests((t) => t == _soloTest);
-  }
-
   _config.onStart();
 
   runAsync(() {
     _nextBatch();
   });
 }
 
 /**
  * Run [tryBody] guarded in a try-catch block. If an exception is thrown, it is
  * passed to the corresponding test.
@@ skipping 107 matching lines @@
   _config.onInit();
 
   if (configAutoStart && _config.autoStart) {
     // Immediately queue the suite up. It will run after a timeout (i.e. after
     // main() has returned).
     runAsync(runTests);
   }
 }
 
 /** Select a solo test by ID. */
-void setSoloTest(int id) {
-  for (var i = 0; i < testCases.length; i++) {
-    if (testCases[i].id == id) {
-      _soloTest = testCases[i];
-      break;
-    }
-  }
-}
+void setSoloTest(int id) =>
+  _testCases.retainWhere((t) => t.id == id);
 
 /** Enable/disable a test by ID. */
 void _setTestEnabledState(int testId, bool state) {
   // Try fast path first.
   if (testCases.length > testId && testCases[testId].id == testId) {
     testCases[testId].enabled = state;
   } else {
     for (var i = 0; i < testCases.length; i++) {
       if (testCases[i].id == testId) {
         testCases[i].enabled = state;
         break;
       }
     }
   }
 }
 
 /** Enable a test by ID. */
 void enableTest(int testId) => _setTestEnabledState(testId, true);
 
 /** Disable a test by ID. */
 void disableTest(int testId) => _setTestEnabledState(testId, false);
 
 /** Signature for a test function. */
 typedef dynamic TestFunction();