Roll forward "Use package:stack_trace in unittest."

pkg/unittest/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.
 
 /**
  * A library for writing dart unit tests.
  *
  * ## Installing ##
  *
  * Use [pub][] to install this package. Add the following to your `pubspec.yaml`
@@ skipping 155 matching lines @@
  */
 library unittest;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:isolate';
 import 'dart:math' show max;
 import 'matcher.dart';
 export 'matcher.dart';
 
+import 'package:stack_trace/stack_trace.dart';
+
+import 'src/utils.dart';
 part 'src/config.dart';
 part 'src/test_case.dart';
 
 Configuration _config;
 
 /**
  * [Configuration] used by the unittest library. Note that if a
  * configuration has not been set, calling this getter will create
  * a default configuration.
  */
@@ skipping 260 matching lines @@
   bool shouldCallBack() {
     ++actualCalls;
     if (testCase.isComplete) {
       // Don't run if the test is done. We don't throw here as this is not
       // the current test, but we do mark the old test as having an error
       // if it previously passed.
       if (testCase.result == PASS) {
         testCase.error(
             'Callback ${id}called ($actualCalls) after test case '
             '${testCase.description} has already been marked as '
-            '${testCase.result}.', '');
+            '${testCase.result}.');
       }
       return false;
     } else if (maxExpectedCalls >= 0 && actualCalls > maxExpectedCalls) {
       throw new TestFailure('Callback ${id}called more times than expected '
                             '($maxExpectedCalls).');
     }
     return true;
   }
 
   void after() {
@@ skipping 200 matching lines @@
   runAsync(() {
     _currentTestCaseIndex++;
     _nextBatch();
   });
 }
 
 /**
  * Utility function that can be used to notify the test framework that an
  *  error was caught outside of this library.
  */
-void _reportTestError(String msg, String trace) {
+void _reportTestError(String msg, trace) {
  if (_currentTestCaseIndex < testCases.length) {
     final testCase = testCases[_currentTestCaseIndex];
     testCase.error(msg, trace);
   } else {
     _uncaughtErrorMessage = "$msg: $trace";
   }
 }
 
 void rerunTests() {
   _uncaughtErrorMessage = null;
@@ skipping 56 matching lines @@
  * Registers that an exception was caught for the current test.
  */
 void registerException(e, [trace]) {
   _registerException(currentTestCase, e, trace);
 }
 
 /**
  * Registers that an exception was caught for the current test.
  */
 void _registerException(TestCase testCase, e, [trace]) {
-  trace = trace == null ? '' : trace.toString();
   String message = (e is TestFailure) ? e.message : 'Caught $e';
   if (testCase.result == null) {
     testCase.fail(message, trace);
   } else {
     testCase.error(message, trace);
   }
 }
 
 /**
  * Runs a batch of tests, yielding whenever an asynchronous test starts
@@ skipping 92 matching lines @@
 /** Enable a test by ID. */
 void enableTest(int testId) => _setTestEnabledState(testId, true);
 
 /** Disable a test by ID. */
 void disableTest(int testId) => _setTestEnabledState(testId, false);
 
 /** Signature for a test function. */
 typedef dynamic TestFunction();
 
 /**
- * A flag that controls whether we hide unittest details in exception stacks.
+ * A flag that controls whether we hide unittest and core library details in
+ * exception stacks.
+ *
  * Useful to disable when debugging unittest or matcher customizations.
  */
 bool formatStacks = true;
 
-// Stack formatting utility. Strips extraneous content from a stack trace.
-// Stack frame lines are parsed with a regexp, which has been tested
-// in Chrome, Firefox and the VM. If a line fails to be parsed it is
-// included in the output to be conservative.
-//
-// The output stack consists of everything after the call to TestCase._run.
-// If we see an 'expect' in the frame we will prune everything above that
-// as well.
-final _frameRegExp = new RegExp(
-    r'^\s*' // Skip leading spaces.
-    r'(?:'  // Group of choices for the prefix.
-      r'(?:#\d+\s*)|' // Skip VM's #<frameNumber>.
-      r'(?:at )|'     // Skip Firefox's 'at '.
-      r'(?:))'        // Other environments have nothing here.
-    r'(.+)'           // Extract the function/method.
-    r'\s*[@\(]'       // Skip space and @ or (.
-    r'('              // This group of choices is for the source file.
-      r'(?:.+:\/\/.+\/[^:]*)|' // Handle file:// or http:// URLs.
-      r'(?:dart:[^:]*)|'  // Handle dart:<lib>.
-      r'(?:package:[^:]*)' // Handle package:<path>
-    r'):([:\d]+)[\)]?$'); // Get the line number and optional column number.
-
-String _formatStack(stack) {
-  if (!formatStacks) return "$stack";
-  var lines;
-  if (stack is StackTrace) {
-    lines = stack.toString().split('\n');
-  } else if (stack is String) {
-    lines = stack.split('\n');
+/** Returns a Trace object from a StackTrace object or a String. */
+Trace _getTrace(stack) {
+  Trace trace;
+  if (stack == null) return null;
+  if (stack is String) {
+    trace = new Trace.parse(stack);
+  } else if (stack is StackTrace) {
+    trace = new Trace.from(stack);
   } else {
-    return stack.toString();
+    throw new Exception('Invalid stack type ${stack.runtimeType} for $stack.');
   }
 
-  // Calculate the max width of first column so we can
-  // pad to align the second columns.
-  int padding = lines.fold(0, (n, line) {
-    var match = _frameRegExp.firstMatch(line);
-    if (match == null) return n;
-    return max(n, match[1].length + 1);
-  });
+  if (!formatStacks) return trace;
 
-  // We remove all entries that have a location in unittest.
-  // We strip out anything before _nextBatch too.
-  var sb = new StringBuffer();
-  for (var i = 0; i < lines.length; i++) {
-    var line = lines[i];
-    if (line == '') continue;
-    var match = _frameRegExp.firstMatch(line);
-    if (match == null) {
-      sb.write(line);
-      sb.write('\n');
-    } else {
-      var member = match[1];
-      var location = match[2];
-      var position = match[3];
-      if (member.indexOf('TestCase._runTest') >= 0) {
-        // Don't include anything after this.
-        break;
-      } else if (member.indexOf('expect') >= 0) {
-        // It looks like this was an expect() failure;
-        // drop all the frames up to here.
-        sb.clear();
-      } else {
-        sb.write(member);
-        // Pad second column to a fixed position.
-        for (var j = 0; j <= padding - member.length; j++) {
-          sb.write(' ');
-        }
-        sb.write(location);
-        sb.write(' ');
-        sb.write(position);
-        sb.write('\n');
-      }
-    }
-  }
-  return sb.toString();
+  // Format the stack trace by removing everything above TestCase._runTest,
+  // which is usually going to be irrelevant. Also fold together unittest and
+  // core library calls so only the function the user called is visible.
+  return new Trace(trace.frames.takeWhile((frame) {
+    return frame.package != 'unittest' || frame.member != 'TestCase._runTest';
+  })).terse.foldFrames((frame) => frame.package == 'unittest' || frame.isCore);
 }