First pass at a generic reusable command line option parser.

lib/unittest/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.
  *
  * ##Concepts##
  *
  *  * Tests: Tests are specified via the top-level function [test], they can be
@@ skipping 154 matching lines @@
  */
 final _UNCAUGHT_ERROR = 3;
 
 int _state = _UNINITIALIZED;
 String _uncaughtErrorMessage = null;
 
 final _PASS  = 'pass';
 final _FAIL  = 'fail';
 final _ERROR = 'error';
 
+/** If set, then all other test cases will be ignored. */
+TestCase _soloTest;
+
 /** Creates an expectation for the given value. */
 Expectation expect(value) => new Expectation(value);
 
-/** Evaluates the given function and validates that it throws an exception. */
-void expectThrow(function) {
+/**
+ * Evaluates the [function] and validates that it throws an exception. If
+ * [callback] is provided, then it will be invoked with the thrown exception.
+ * The callback may do any validation it wants. In addition, if it returns
+ * `false`, that also indicates an expectation failure.
+ */
+void expectThrow(function, [bool callback(exception)]) {
   bool threw = false;
   try {
     function();
   } catch (var e) {
     threw = true;
+
+    // Also let the callback look at it.
+    if (callback != null) {
+      var result = callback(e);
+
+      // If the callback explicitly returned false, treat that like an
+      // expectation too. (If it returns null, though, don't.)
+      if (result == false) {
+        _fail('Exception:\n$e\ndid not match expectation.');
+      }
+    }
   }
-  Expect.equals(true, threw, 'Expected exception but none was thrown.');
+
+  if (threw != true) _fail('An expected exception was not thrown.');
 }
 
 /**
  * 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();
 
@@ skipping 12 matching lines @@
   final testCase = new TestCase(
       _tests.length + 1, _fullSpec(spec), body, callbacks);
   _tests.add(testCase);
 
   if (callbacks < 1) {
     testCase.error(
         'Async tests must wait for at least one callback ', '');
   }
 }
 
+/**
+ * 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.
+ */
+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();
+
+  _soloTest = new TestCase(_tests.length + 1, _fullSpec(spec), body, 0);
+  _tests.add(_soloTest);
+}
+
 /** Sentinel value for [_SpreadArgsHelper]. */
 class _Sentinel {
   const _Sentinel();
 }
 
 // TODO(sigmund): make a singleton const field when frog supports passing those
 // as default values to named arguments.
 final _sentinel = const _Sentinel();
 
 /** Simulates spread arguments using named arguments. */
@@ skipping 172 matching lines @@
   final port = new ReceivePort();
   port.receive((msg, reply) {
     callback();
     port.close();
   });
   port.toSendPort().send(null, null);
 }
 
 /** Runs all queued tests, one at a time. */
 _runTests() {
+  // If we are soloing a test, remove all the others.
+  if (_soloTest != null) {
+    _tests = _tests.filter((t) => t == _soloTest);
+  }
+
   _config.onStart();
 
   _defer(() {
     assert (_currentTest == 0);
     _testRunner();
   });
 }
 
 /**
  * Run [tryBody] guarded in a try-catch block. If an exception is thrown, update
  * the [_currentTest] status accordingly.
  */
 _guard(tryBody, [finallyBody]) {
   try {
     return tryBody();
   } catch (ExpectException e, var trace) {
     if (_state != _UNCAUGHT_ERROR) {
       _tests[_currentTest].fail(e.message,
           trace == null ? '' : trace.toString());
     }
   } catch (var e, var trace) {
-    if (_state != _UNCAUGHT_ERROR) {
+    if (_state == _RUNNING_TEST) {
+      // If a random exception is thrown from within a test, we consider that
+      // a test failure too. A test case implicitly has an expectation that it
+      // will run to completion without an uncaught exception being thrown.
+      _tests[_currentTest].fail('Caught $e',
+          trace == null ? '' : trace.toString());
+    } else if (_state != _UNCAUGHT_ERROR) {
       _tests[_currentTest].error('Caught $e',
           trace == null ? '' : trace.toString());
     }
   } finally {
     _state = _READY;
     if (finallyBody != null) finallyBody();
   }
 }
 
 /**
@@ skipping 43 matching lines @@
 
   _config.onDone(testsPassed_, testsFailed_, testsErrors_, _tests,
       _uncaughtErrorMessage);
 }
 
 String _fullSpec(String spec) {
   if (spec === null) return '$_currentGroup';
   return _currentGroup != '' ? '$_currentGroup $spec' : spec;
 }
 
+void _fail(String message) {
+  throw new ExpectException(message);
+}
+
 /**
  * Lazily initializes the test library if not already initialized.
  */
 ensureInitialized() {
   if (_state != _UNINITIALIZED) return;
 
   _tests = <TestCase>[];
   _currentGroup = '';
   _state = _READY;
   _testRunner = _nextBatch;
 
   if (_config == null) {
     _config = new Configuration();
   }
   _config.onInit();
 
   // Immediately queue the suite up. It will run after a timeout (i.e. after
   // main() has returned).
   _defer(_runTests);
 }
 
 /** Signature for a test function. */
 typedef void TestFunction();