pkg/unittest: handling of runTests being called without any tests

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';
 
 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,
                          String message: ''}) {
   var totalTests = 0;
-  String testDetails = '';
-  if (results is String) {
+  var testDetails = new StringBuffer();
+  if(results == null) {
+    // no op
+    assert(message == '');
+  } else if (results is String) {
     totalTests = passed + failed + errors;
-    testDetails = ':$results:$message';
+    testDetails.write(':$results:$message');
   } else {
     totalTests = results.length;
     for (var i = 0; i < results.length; i++) {
-      testDetails = '$testDetails:${results[i].description}:'
-          '${collapseWhitespace(results[i].message)}';
+      testDetails.write(':${results[i].description}:'
+          '${collapseWhitespace(results[i].message)}');
     }
   }
-  var result = '$passed:$failed:$errors:$totalTests:$count:'
+  return '$passed:$failed:$errors:$totalTests:$count:'
       '$setup:$teardown:$uncaughtError$testDetails';
-  return result;
 }
 
 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
   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((String testName, sendport) {
-    var _testconfig= new TestConfiguration(sendport);
-    unittestConfiguration = _testconfig;
+    var testConfig = new TestConfiguration(sendport);
+    unittestConfiguration = testConfig;
 
     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', () {
           test('b', () {});
         });
       });
     } else if (testName == 'setup test') {
       group('a', () {
-        setUp(() { _testconfig.setup = 'setup'; });
+        setUp(() { testConfig.setup = 'setup'; });
         test(testName, () {});
       });
     } else if (testName == 'teardown test') {
       group('a', () {
-        tearDown(() { _testconfig.teardown = 'teardown'; });
+        tearDown(() { testConfig.teardown = 'teardown'; });
         test(testName, () {});
       });
     } else if (testName == 'setup and teardown test') {
       group('a', () {
-        setUp(() { _testconfig.setup = 'setup'; });
-        tearDown(() { _testconfig.teardown = 'teardown'; });
+        setUp(() { testConfig.setup = 'setup'; });
+        tearDown(() { testConfig.teardown = 'teardown'; });
         test(testName, () {});
       });
     } else if (testName == 'correct callback test') {
       test(testName,
-        () =>_defer(expectAsync0((){ ++_testconfig.count;})));
+        () =>_defer(expectAsync0((){ ++testConfig.count;})));
     } else if (testName == 'excess callback test') {
       test(testName, () {
-        var _callback0 = expectAsync0(() => ++_testconfig.count);
-        var _callback1 = expectAsync0(() => ++_testconfig.count);
+        var _callback0 = expectAsync0(() => ++testConfig.count);
+        var _callback1 = expectAsync0(() => ++testConfig.count);
         var _callback2 = expectAsync0(() {
           _callback1();
           _callback1();
           _callback0();
         });
         _defer(_callback2);
       });
     } else if (testName == 'completion test') {
       test(testName, () {
              var _callback;
              _callback = expectAsyncUntil0(() {
-               if (++_testconfig.count < 10) {
+               if (++testConfig.count < 10) {
                  _defer(_callback);
                }
              },
-             () => (_testconfig.count == 10));
+             () => (testConfig.count == 10));
              _defer(_callback);
       });
     } else if (testName == 'async exception test') {
       test(testName, () {
         expectAsync0(() {});
         _defer(() => guardAsync(() { throw "error!"; }));
       });
     } else if (testName == 'late exception test') {
       var f;
       test('testOne', () {
@@ skipping 152 matching lines @@
           });
         });
       });
       test('foo6', () {
       });
     } else if (testName == 'testCases immutable') {
       test(testName, () {
         expect(() => testCases.clear(), throwsUnsupportedError);
         expect(() => testCases.removeLast(), throwsUnsupportedError);
       });
+    } else if (testName == 'runTests without tests') {
+      runTests();
     }
   });
 }
 
 main() {
   var tests = {
     'single correct test': buildStatusString(1, 0, 0, 'single correct test'),
     'single failing test': buildStatusString(0, 1, 0, 'single failing test',
         message: 'Expected: <5> but: was <4>.'),
     'exception test': buildStatusString(0, 1, 0, 'exception test',
@@ skipping 36 matching lines @@
         'foo5'),
     'test returning future using Timer': buildStatusString(2, 4, 0,
         'successful::'
         'fail1:Expected: <false> but: was <true>.:'
         'error1:Callback called more times than expected (1).:'
         'fail2:failure:'
         'error2:Callback called more times than expected (1).:'
         'foo6'),
     'testCases immutable':
         buildStatusString(1, 0, 0, 'testCases immutable'),
+    'runTests without tests': buildStatusString(0, 0, 0, null)
   };
 
   tests.forEach((String name, String expected) {
     test(name, () => spawnFunction(runTest)
         .call(name)
         .then((String msg) => expect(msg.trim(), equals(expected))));
     });
 }