Changes to how we handle fancy stacks:

tools/testing/dart/test_suite.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Classes and methods for enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
@@ skipping 776 matching lines @@
               dart2JsBootstrapDependencies, compilerPath, args,
               configurationDir)];
       if (info.hasCompileError) {
         // Do not attempt to run the compiled result. A compilation
         // error should be reported by the compilation command.
       } else if (configuration['runtime'] == 'vm') {
         // TODO(antonm): support checked.
         var vmArguments = new List.from(vmOptions);
         vmArguments.addAll([
             '--ignore-unrecognized-flags', '$tempDir/out.dart']);
+        // Turn off fancy stacks or stack filtering.
+        if (configuration['raw-stacks']) {

[ricow1, 2013/08/21 12:44:10]

does this work, adding flags _after_ the dart file? (the dart file is above).
Normally these flags are actually given to the executing dart program

[ahe, 2013/08/21 12:48:21]

This is a flag to the Dart program, not the Dart VM.

I'd be concerned about passing command line arguments to Dart programs. It makes
it impossible to test new Options().arguments.

My understanding was that we agreed that the default in non-html configs would
be to not parse stack traces.

[gram, 2013/08/21 17:12:38]

Yes, these are passed to the Dart test. As it provides flexibility in handling
stack traces, it seemed worth doing. It doesn't make it impossible to test
Options (the options test was modified to deal with this); it just makes the
Options tests a bit more tricky to diagnose if they fail, but in that case it is
easy to get these arguments to be excluded by passing the --filter-stacks option
to test.dart. If you look at the Options tests I think you will agree that this
change is incredibly unlikely to introduce a false positive or negative, and the
test should still catch failures if Options actually breaks.

+          vmArguments.add('--no-fancy-stacks');
+        } else if (!configuration['filter-stacks']) {
+          vmArguments.add('--no-filtered-stacks');
+        }
         commands.add(CommandBuilder.instance.getCommand(
             "vm", vmFileName, vmArguments, configurationDir));
       } else {
         throw 'Unsupported runtime ${configuration["runtime"]} for dart2dart';
       }
       return commands;
 
     case 'none':
       var arguments = new List.from(vmOptions);
       arguments.addAll(args);
+      // Turn off fancy stacks.
+      if (configuration['raw-stacks']) {
+        arguments.add('--no-fancy-stacks');
+      } else if (!configuration['filter-stacks']) {
+        arguments.add('--no-filtered-stacks');
+      }
       return <Command>[CommandBuilder.instance.getCommand(
           'vm', dartShellFileName, arguments, configurationDir)];
 
     case 'dartanalyzer':
     case 'dart2analyzer':
       return <Command>[CommandBuilder.instance.getAnalysisCommand(
           compiler, dartShellFileName, args, configurationDir,
           flavor: compiler)];
 
     default:
@@ skipping 142 matching lines @@
       RandomAccessFile htmlTest =
           new File(htmlPath).openSync(mode: FileMode.WRITE);
       String content = null;
       Path dir = filePath.directoryPath;
       String nameNoExt = filePath.filenameWithoutExtension;
       Path pngPath = dir.append('$nameNoExt.png');
       Path txtPath = dir.append('$nameNoExt.txt');
       Path expectedOutput = null;
       if (new File.fromPath(pngPath).existsSync()) {
         expectedOutput = pngPath;
-        content = getHtmlLayoutContents(scriptType, new Path("$scriptPath"));
+        content = getHtmlLayoutContents(scriptType, new Path("$scriptPath"),
+            !configuration['raw-stacks'], configuration['filter-stacks']);
       } else if (new File.fromPath(txtPath).existsSync()) {
         expectedOutput = txtPath;
-        content = getHtmlLayoutContents(scriptType, new Path("$scriptPath"));
+        content = getHtmlLayoutContents(scriptType, new Path("$scriptPath"),
+          !configuration['raw-stacks'], configuration['filter-stacks']);
       } else {
         content = getHtmlContents(filename, scriptType,
-            new Path("$scriptPath"));
+            new Path("$scriptPath"), !configuration['raw-stacks'],
+            configuration['filter-stacks']);
       }
       htmlTest.writeStringSync(content);
       htmlTest.closeSync();
 
       // Construct the command(s) that compile all the inputs needed by the
       // browser test. For running Dart in DRT, this will be noop commands.
       List<Command> commands = [];
       if (compiler != 'none') {
         commands.add(_compileCommand(
             dartWrapperFilename, compiledDartWrapperFilename,
@@ skipping 969 matching lines @@
  * $pass tests are expected to pass
  * $failOk tests are expected to fail that we won't fix
  * $fail tests are expected to fail that we should fix
  * $crash tests are expected to crash that we should fix
  * $timeout tests are allowed to timeout
  * $compileErrorSkip tests are skipped on browsers due to compile-time error
 """;
     print(report);
    }
 }