Roll back "Use package:stack_trace in unittest."

pkg/unittest/lib/src/test_case.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.
 
 part of unittest;
 
 /**
  * Represents the state for an individual unit test.
  *
  * Create by calling [test] or [solo_test].
@@ skipping 23 matching lines @@
   String _message = '';
   /** Error or failure message. */
   String get message => _message;
 
   String _result;
   /**
    * One of [PASS], [FAIL], [ERROR], or [null] if the test hasn't run yet.
    */
   String get result => _result;
 
-  Trace _stackTrace;
+  String _stackTrace;
   /** Stack trace associated with this test, or [null] if it succeeded. */
-  Trace get stackTrace => _stackTrace;
+  String get stackTrace => _stackTrace;
 
   /** The group (or groups) under which this test is running. */
   final String currentGroup;
 
   DateTime _startTime;
   DateTime get startTime => _startTime;
 
   Duration _runningTime;
   Duration get runningTime => _runningTime;
 
   bool enabled = true;
 
   bool _doneTeardown = false;
 
   Completer _testComplete;
 
   TestCase._internal(this.id, this.description, this.testFunction)
   : currentGroup = _currentContext.fullName,
     setUp = _currentContext.testSetup,
     tearDown = _currentContext.testTeardown;
 
   bool get isComplete => !enabled || result != null;
 
   Function _errorHandler(String stage) => (e) {
     var stack = getAttachedStackTrace(e);
+    stack = (stack == null) ? '' : '$stack';
     if (result == null || result == PASS) {
       if (e is TestFailure) {
         fail("$e", stack);
       } else {
         error("$stage failed: Caught $e", stack);
       }
     }
   };
 
   /**
@@ skipping 32 matching lines @@
             }).catchError(_errorHandler('Teardown'));
           } else if (tearDown != null) {
             return tearDown();
           }
         })
         .catchError(_errorHandler('Teardown'));
   }
 
   // Set the results, notify the config, and return true if this
   // is the first time the result is being set.
-  void _setResult(String testResult, String messageText, stack) {
+  void _setResult(String testResult, String messageText, String stack) {
     _message = messageText;
-    _stackTrace = _getTrace(stack);
+    _stackTrace = _formatStack(stack);
     if (result == null) {
       _result = testResult;
       _config.onTestResult(this);
     } else {
       _result = testResult;
       _config.onTestResultChanged(this);
     }
   }
 
-  void _complete(String testResult, [String messageText = '', stack]) {
+  void _complete(String testResult,
+                [String messageText = '',
+                 String stack = '']) {
     if (runningTime == null) {
       // The startTime can be `null` if an error happened during setup. In this
       // case we simply report a running time of 0.
       if (startTime != null) {
         _runningTime = new DateTime.now().difference(startTime);
       } else {
         _runningTime = const Duration(seconds: 0);
       }
     }
     _setResult(testResult, messageText, stack);
     if (_testComplete != null) {
       var t = _testComplete;
       _testComplete = null;
       t.complete(this);
     }
   }
 
   void pass() {
     _complete(PASS);
   }
 
-  void fail(String messageText, [stack]) {
+  void fail(String messageText, [String stack = '']) {
+    assert(stack != null);
     if (result != null) {
       String newMessage = (result == PASS)
           ? 'Test failed after initially passing: $messageText'
           : 'Test failed more than once: $messageText';
       // TODO(gram): Should we combine the stack with the old one?
       _complete(ERROR, newMessage, stack);
     } else {
       _complete(FAIL, messageText, stack);
     }
   }
 
-  void error(String messageText, [stack]) {
+  void error(String messageText, [String stack = '']) {
+    assert(stack != null);
     _complete(ERROR, messageText, stack);
   }
 
   void _markCallbackComplete() {
     if (--_callbackFunctionsOutstanding == 0 && !isComplete) {
       pass();
     }
   }
 }