pkg/unittest: config refactor

pkg/unittest/test/unittest_test.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.
 
 // TODO(gram):
 // Unfortunately I can't seem to test anything that involves timeouts, e.g.
 // insufficient callbacks, because the timeout is controlled externally
 // (test.dart?), and we would need to use a shorter timeout for the inner tests
 // so the outer timeout doesn't fire. So I removed all such tests.
 // I'd like to revisit this at some point.
 
 library unittestTest;
 import 'dart:isolate';
 import 'dart:async';
 import 'package:unittest/unittest.dart';
 
 var tests; // array of test names
 var expected; // array of test expected results (from buildStatusString)
 var actual; // actual test results (from buildStatusString in config.onDone)
-var _testconfig; // test configuration to capture onDone
 
 Future _defer(void fn()) {
   return new Future.of(fn);
 }
 
 String buildStatusString(int passed, int failed, int errors,
                          var results,
                          {int count: 0,
                          String setup: '', String teardown: '',
                          String uncaughtError: null,
@@ skipping 16 matching lines @@
 }
 
 class TestConfiguration extends Configuration {
 
   // Some test state that is captured
   int count = 0; // a count of callbacks
   String setup = ''; // the name of the test group setup function, if any
   String teardown = ''; // the name of the test group teardown function, if any
 
   // The port to communicate with the parent isolate
-  SendPort _port;
+  final SendPort _port;
   String _result;
 
   TestConfiguration(this._port);
 
   void onSummary(int passed, int failed, int errors, List<TestCase> results,
       String uncaughtError) {
     _result = buildStatusString(passed, failed, errors, results,
         count: count, setup: setup, teardown: teardown,
         uncaughtError: uncaughtError);
   }
 
   void onDone(bool success) {
     _port.send(_result);
   }
 }
 
 runTest() {
   port.receive((testName, sendport) {
-    configure(_testconfig = new TestConfiguration(sendport));
+    var _testconfig= new TestConfiguration(sendport);
+    config = _testconfig;

[gram, 2013/03/25 17:09:19]

I wonder if config is not too generic a name and might result in collisions
(yes, you can argue the same about configure() but I intuitively feel that is
less likely a problem). Maybe we should call this something else like
testConfig.

[kevmoo-old, 2013/03/25 17:11:52]

or go all the way and call it unittestConfiguration

It's not like this is referenced a lot.

or testConfiguration

I have a paranoia about abbreviations in public API, but I'm open to discussion.

+
     if (testName == 'single correct test') {
       test(testName, () => expect(2 + 3, equals(5)));
     } else if (testName == 'single failing test') {
       test(testName, () => expect(2 + 2, equals(5)));
     } else if (testName == 'exception test') {
       test(testName, () { throw new Exception('Fail.'); });
     } else if (testName == 'group name test') {
       group('a', () {
         test('a', () {});
         group('b', () {
@@ skipping 288 matching lines @@
         'fail2:failure:'
         'error2:Callback called more times than expected (1).:'
         'foo6'),
   ];
 
   actual = [];
 
   nextTest(0);
 }