Reformatted code

lib/unittest.dart

 // Copyright (c) 2013, 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.
 
 /// Support for writing Dart unit tests.
 ///
 /// For information on installing and importing this library, see the
 /// [unittest package on pub.dartlang.org]
 /// (http://pub.dartlang.org/packages/unittest).
 ///
@@ skipping 120 matching lines @@
 ///           expect(delta, greaterThanOrEqualTo(duration));
 ///         });
 ///       });
 ///     }
 library unittest;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:isolate';
 
-import 'package:matcher/matcher.dart' show DefaultFailureHandler,
-    configureExpectFailureHandler, TestFailure, wrapAsync;
+import 'package:matcher/matcher.dart'
+    show
+        DefaultFailureHandler,
+        configureExpectFailureHandler,
+        TestFailure,
+        wrapAsync;
 export 'package:matcher/matcher.dart';
 
 import 'src/utils.dart';
 
 import 'src/configuration.dart';
 export 'src/configuration.dart';
 
 part 'src/simple_configuration.dart';
 part 'src/group_context.dart';
 part 'src/spread_args_helper.dart';
@@ skipping 59 matching lines @@
 
 /// Tests executed in this suite.
 List<TestCase> get testCases =>
     new UnmodifiableListView<TestCase>(_environment.testCases);
 
 /// Interval (in msecs) after which synchronous tests will insert an async
 /// delay to allow DOM or other updates.
 const int BREATH_INTERVAL = 200;
 
 /// [TestCase] currently being executed.
-TestCase get currentTestCase =>
-    (_environment.currentTestCaseIndex >= 0 &&
-     _environment.currentTestCaseIndex < testCases.length)
-        ? testCases[_environment.currentTestCaseIndex]
-        : null;
+TestCase get currentTestCase => (_environment.currentTestCaseIndex >= 0 &&
+        _environment.currentTestCaseIndex < testCases.length)
+    ? testCases[_environment.currentTestCaseIndex]
+    : null;
 
 /* Test case result strings. */
 // TODO(gram) we should change these constants to use a different string
 // (so that writing 'FAIL' in the middle of a test doesn't
 // imply that the test fails). We can't do it without also changing
 // the testrunner and test.dart though.
 /// Result string for a passing test case.
 const PASS = 'pass';
 /// Result string for a failing test case.
 const FAIL = 'fail';
 /// Result string for an test case with an error.
 const ERROR = 'error';
 
 /// 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) {
   _requireNotRunning();
   ensureInitialized();
   if (!_environment.soloTestSeen || _environment.soloNestingLevel > 0) {
-    var testcase = new TestCase._internal(testCases.length + 1, _fullSpec(spec),
-        body);
+    var testcase =
+        new TestCase._internal(testCases.length + 1, _fullSpec(spec), body);
     _testCases.add(testcase);
   }
 }
 
 /// Convenience function for skipping a test.
 void skip_test(String spec, TestFunction body) {}
 
 /// Creates a new test case with the given description and body. The
 /// description will include the descriptions of any surrounding group()
 /// calls.
@@ skipping 40 matching lines @@
 /// it was already complete). A value of 0 for [max] (the default) will set
 /// the upper bound to the same value as [count]; i.e. the callback should be
 /// called exactly [count] times. A value of -1 for [max] will mean no upper
 /// bound.
 ///
 /// [reason] is optional and is typically not supplied, as a reason is generated
 /// by the unittest package; if reason is included it is appended to the
 /// generated reason.
 Function expectAsync(Function callback,
     {int count: 1, int max: 0, String id, String reason}) =>
-  new _SpreadArgsHelper(callback, count, max, id, reason).func;
+        new _SpreadArgsHelper(callback, count, max, id, reason).func;
 
 /// Indicate that [callback] is expected to be called until [isDone] returns
 /// true.
 ///
 /// The unittest framework checks [isDone] after each callback and only
 /// when it returns true will it continue with the following test. Using
 /// [expectAsyncUntil] will also ensure that errors that occur within
 /// [callback] are tracked and reported. [callback] should take 0 positional
 /// arguments (named arguments are not supported). [id] can be used to
 /// identify the callback in error messages (for example if it is called
 /// after the test case is complete).
 ///
 /// [reason] is optional and is typically not supplied, as a reason is generated
 /// by the unittest package; if reason is included it is appended to the
 /// generated reason.
 Function expectAsyncUntil(Function callback, bool isDone(),
     {String id, String reason}) =>
-  new _SpreadArgsHelper(callback, 0, -1, id, reason, isDone: isDone).func;
+        new _SpreadArgsHelper(callback, 0, -1, id, reason, isDone: isDone).func;
 
 /// Creates a new named group of tests.
 ///
 /// Calls to group() or test() within the body of the function passed to this
 /// named group will inherit this group's description.
 void group(String description, void body()) {
   ensureInitialized();
   _requireNotRunning();
   _environment.currentContext =
       new _GroupContext(_environment.currentContext, description);
@@ skipping 155 matching lines @@
 
 /// Publish results on the page and notify controller.
 void _completeTests() {
   if (!_environment.initialized) return;
   int passed = 0;
   int failed = 0;
   int errors = 0;
 
   for (TestCase t in testCases) {
     switch (t.result) {
-      case PASS:  passed++; break;
-      case FAIL:  failed++; break;
-      case ERROR: errors++; break;
+      case PASS:
+        passed++;
+        break;
+      case FAIL:
+        failed++;
+        break;
+      case ERROR:
+        errors++;
+        break;
     }
   }
-  _config.onSummary(passed, failed, errors, testCases,
-      _environment.uncaughtErrorMessage);
-  _config.onDone(passed > 0 && failed == 0 && errors == 0 &&
+  _config.onSummary(
+      passed, failed, errors, testCases, _environment.uncaughtErrorMessage);
+  _config.onDone(passed > 0 &&
+      failed == 0 &&
+      errors == 0 &&
       _environment.uncaughtErrorMessage == null);
   _environment.initialized = false;
   _environment.currentTestCaseIndex = -1;
 }
 
 String _fullSpec(String spec) {
   var group = '${_environment.currentContext.fullName}';
   if (spec == null) return group;
   return group != '' ? '$group$groupSep$spec' : spec;
 }
@@ skipping 71 matching lines @@
 ///
 /// This allows for multiple invocations of the unittest library in the same
 /// application instance.
 /// This is useful when, for example, creating a test runner application which
 /// needs to create a new pristine test environment on each invocation to run
 /// a given set of test.
 dynamic withTestEnvironment(callback()) {
   return runZoned(callback,
       zoneValues: {_UNITTEST_ENVIRONMENT: new _TestEnvironment()});
 }