Make unit-test not create a fixed-length list of tests.

pkg/unittest/lib/unittest.dart

 // Copyright (c) 2011, 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.
  *
  * To import this library, use the pub package manager.
  * Create a pubspec.yaml file in your project and add
  * a dependency on unittest with the following lines:
@@ skipping 95 matching lines @@
  *     }
  *
  * expectAsyncX() will wrap the callback code in a try/catch handler to handle
  * exceptions (treated as test failures). There may be times when the number of
  * times a callback should be called is non-deterministic. In this case a dummy
  * callback can be created with expectAsync0((){}) and this can be called from
  * the real callback when it is finally complete. In this case the body of the
  * callback should be protected within a call to guardAsync(); this will ensure
  * that exceptions are properly handled.
  *
- * A variation on this is expectAsyncUntilX(), which takes a callback as the 
+ * A variation on this is expectAsyncUntilX(), which takes a callback as the
  * first parameter and a predicate function as the second parameter; after each
  * time * the callback is called, the predicate function will be called; if it
  * returns false the test will still be considered incomplete.
  *
  * Test functions can return [Future]s, which provide another way of doing
  * asynchronous tests. The test framework will handle exceptions thrown by
- * the Future, and will advance to the next test when the Future is complete. 
+ * the Future, and will advance to the next test when the Future is complete.
  * It is still important to use expectAsync/guardAsync with any parts of the
  * test that may be invoked from a top level context (for example, with
  * Timer.run()], as the Future exception handler may not capture exceptions
  * in such code.
  *
  * Note: due to some language limitations we have to use different functions
  * depending on the number of positional arguments of the callback. In the
  * future, we plan to expose a single `expectAsync` function that can be used
  * regardless of the number of positional arguments. This requires new langauge
  * features or fixes to the current spec (e.g. see
@@ skipping 584 matching lines @@
 void filterTests(testFilter) {
   var filterFunction;
   if (testFilter is String) {
     RegExp re = new RegExp(testFilter);
     filterFunction = (t) => re.hasMatch(t.description);
   } else if (testFilter is RegExp) {
     filterFunction = (t) => testFilter.hasMatch(t.description);
   } else if (testFilter is Function) {
     filterFunction = testFilter;
   }
-  _tests = _tests.where(filterFunction).toList();
+  _tests.retainMatching(filterFunction);
 }
 
 /** Runs all queued tests, one at a time. */
 runTests() {
   _currentTest = 0;
   _currentGroup = '';
 
   // If we are soloing a test, remove all the others.
   if (_soloTest != null) {
     filterTests((t) => t == _soloTest);
@@ skipping 146 matching lines @@
 }
 
 /** 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 void TestFunction();