Enhance the Dart unittest library to support multiple invocations in the same application run.

pkg/unittest/test/with_test_environment_test.dart

Index: pkg/unittest/test/with_test_environment_test.dart
diff --git a/pkg/unittest/test/with_test_environment_test.dart b/pkg/unittest/test/with_test_environment_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..57459136ec6d33f73a20a4a53f51633329f6c54d
--- /dev/null
+++ b/pkg/unittest/test/with_test_environment_test.dart
@@ -0,0 +1,50 @@
+// Copyright (c) 2014, 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 unittest.with_test_environment_test;
+
+import 'package:unittest/unittest.dart';
+
+void runUnittests(Function callback) {
+  unittestConfiguration = new SimpleConfiguration();
+  callback();
+}
+
+void runTests() {
+  test('test', () => expect(2 + 3, equals(5)));
+}
+
+void runTests1() {
+  test('test1', () => expect(4 + 3, equals(7)));
+}
+
+// Test that we can run two different sets of tests in the same run using the
+// withTestEnvironment method.
+void main() {

[nweiz, 2014/11/13 19:34:28]

Why doesn't this use metatest to isolate its test cases?

[wibling, 2014/11/14 10:09:49]

I am not sure what the benefit of metatests would be in this case?

As I mentioned in my reply to Kevin please let me know how this should be tested
using meta tests and I will be happy to change it.

[nweiz, 2014/11/17 23:02:54]

metatest allows you to create isolated test run with the normal unittest
infrasturcture when testing unittest code. Having a file that just throws an
error when it fails rather than printing useful information isn't friendly to
future people working on the code.
You can look at other unittest test files as examples. Basically, within each
[expectTestResults] you put code that would otherwise be run at the top level of
the test and that code is run in isolation.

[wibling, 2014/11/18 10:16:49]

I did look at the other tests and also at the metatest code. The problem as I
see it is that the metatest code is tailored to determine if the tests being run
are finishing with the expected results whereas this change is not about the
results of the specific tests, but whether the setup of the unittest library
succeeds or not.
Given that I am not validating the test results I don't understand the value of
running this in a metatest?

[nweiz, 2014/11/19 21:40:39]

Oh, I see, that's a good point. It's probably possible to add functionality to
metatest that would support this, but that's not necessary to do now.

+  // First check that we cannot call runUnittests twice in a row without it
+  // throwing a StateError due to the unittestConfiguration being set globally
+  // in the first call.
+  try {
+    runUnittests(runTests);
+    runUnittests(runTests1);
+    throw 'Expected this to be unreachable since 2nd run above should throw';
+  } catch(error) {

[nweiz, 2014/11/13 19:34:28]

Add a space after "catch".

Also, if you write "on StateError catch (error)" you can avoid the is check
below.

[wibling, 2014/11/14 10:09:49]

Done.

+    if (error is! StateError)
+      throw error;

[nweiz, 2014/11/13 19:34:28]

If you're using a bracketless if, you must put the body on the same line.

[wibling, 2014/11/14 10:09:49]

Done.

+    // expected, silently ignore.
+  }
+
+  // Second test that we can run both when encapsulating in their own private
+  // test environment.
+  withTestEnvironment(() => runUnittests(runTests));
+  withTestEnvironment(() => runUnittests(runTests1));
+
+  // Third test that we can run with two nested test environments.
+  withTestEnvironment(() {
+    runUnittests(runTests);
+    withTestEnvironment(() {
+      runUnittests(runTests1);
+    });
+  });
+}