Roll back "Use package:stack_trace in unittest."

pkg/unittest/lib/src/config.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.
 
 part of unittest;
 
 // A custom failure handler for [expect] that routes expect failures
 // to the config.
 class _ExpectFailureHandler extends DefaultFailureHandler {
   Configuration _config;
@@ skipping 37 matching lines @@
 
   /**
    * If true (the default), then tests will stop after the first failed
    * [expect]. If false, failed [expect]s will not cause the test
    * to stop (other exceptions will still terminate the test).
    */
   bool stopTestOnExpectFailure = true;
 
   // If stopTestOnExpectFailure is false, we need to capture failures, which
   // we do with this List.
-  final _testLogBuffer = <Pair<String, Trace>>[];
-
+  List _testLogBuffer = new List();
+  
   /**
    * The constructor sets up a failure handler for [expect] that redirects
    * [expect] failures to [onExpectFailure].
    */
   Configuration() {
     configureExpectFailureHandler(new _ExpectFailureHandler(this));
   }
   /**
    * Called as soon as the unittest framework becomes initialized. This is done
    * even before tests are added to the test framework. It might be used to
@@ skipping 22 matching lines @@
   /**
    * Called when each test is first completed. Useful to show intermediate
    * progress on a test suite. Derived classes should call this first 
    * before their own override code.
    */
   void onTestResult(TestCase testCase) {
     assert(testCase != null);
     if (!stopTestOnExpectFailure && _testLogBuffer.length > 0) {
       // Write the message/stack pairs up to the last pairs.
       var reason = new StringBuffer();
-      for (var reasonAndTrace in
-             _testLogBuffer.take(_testLogBuffer.length - 1)) {
-        reason.write(reasonAndTrace.first);
+      for (var i = 0; i < _testLogBuffer.length - 2; i += 2) {
+        reason.write(_testLogBuffer[i]);
         reason.write('\n');
-        reason.write(reasonAndTrace.last);
+        reason.write(_formatStack(_testLogBuffer[i+1]));
         reason.write('\n');
       }
-      var lastReasonAndTrace = _testLogBuffer.last;
       // Write the last message.
-      reason.write(lastReasonAndTrace.first);
+      reason.write(_testLogBuffer[_testLogBuffer.length - 2]);
       if (testCase.result == PASS) {
         testCase._result = FAIL;
         testCase._message = reason.toString();
         // Use the last stack as the overall failure stack.    
-        testCase._stackTrace = lastReasonAndTrace.last;
+        testCase._stackTrace = 
+            _formatStack(_testLogBuffer[_testLogBuffer.length - 1]);
       } else {
         // Add the last stack to the message; we have a further stack
         // caused by some other failure.
-        reason.write(lastReasonAndTrace.last);
+        reason.write(_formatStack(_testLogBuffer[_testLogBuffer.length - 1]));
         reason.write('\n');
         // Add the existing reason to the end of the expect log to 
         // create the final message.
         testCase._message = '${reason.toString()}\n${testCase._message}';
       }
     }
   }
 
   /**
    * Called when an already completed test changes state; for example a test
@@ skipping 13 matching lines @@
   }
 
   /**
    * Handles failures from expect(). The default in
    * this base configuration is to throw an exception;
    */
   void onExpectFailure(String reason) {
     if (stopTestOnExpectFailure) {
       throw new TestFailure(reason);
     } else {
+      _testLogBuffer.add(reason);
       try {
         throw '';
       } catch (_, stack) {
-        _testLogBuffer.add(
-            new Pair<String, Trace>(reason, new Trace.from(stack)));
+        _testLogBuffer.add(stack);
       }
     }
   }
   
   /**
    * Format a test result.
    */
   String formatResult(TestCase testCase) {
     var result = new StringBuffer();
     result.write(testCase.result.toUpperCase());
     result.write(": ");
     result.write(testCase.description);
     result.write("\n");
 
     if (testCase.message != '') {
-      result.write(indent(testCase.message));
+      result.write(_indent(testCase.message));
       result.write("\n");
     }
 
-    if (testCase.stackTrace != null) {
-      result.write(indent(testCase.stackTrace.toString()));
+    if (testCase.stackTrace != null && testCase.stackTrace != '') {
+      result.write(_indent(testCase.stackTrace));
       result.write("\n");
     }
     return result.toString();
   }
 
   /**
    * Called with the result of all test cases. The default implementation prints
    * the result summary using the built-in [print] command. Browser tests
    * commonly override this to reformat the output.
    *
@@ skipping 32 matching lines @@
       _postMessage('unittest-suite-success');
       _receivePort.close();
     } else {
       _receivePort.close();
       if (throwOnTestFailures) {
         throw new Exception('Some tests failed.');
       }
     }
   }
 
+  String _indent(String str) {
+    // TODO(nweiz): Use this simpler code once issue 2980 is fixed.
+    // return str.replaceAll(new RegExp("^", multiLine: true), "  ");
+
+    return str.split("\n").map((line) => "  $line").join("\n");
+  }
+
   /** Handle errors that happen outside the tests. */
   // TODO(vsm): figure out how to expose the stack trace here
   // Currently e.message works in dartium, but not in dartc.
-  void handleExternalError(e, String message, [stack]) =>
+  void handleExternalError(e, String message, [String stack = '']) =>
       _reportTestError('$message\nCaught $e', stack);
 
   _postMessage(String message) {
     // In dart2js browser tests, the JavaScript-based test controller
     // intercepts calls to print and listens for "secret" messages.
     print(message);
   }
 }