Update stacktrace_test with negative tests

tests/compiler/dart2js/sourcemaps/stacktrace_test.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/compiler_new.dart';
@@ skipping 98 matching lines @@
   try {
     @{2:test}throw '$EXCEPTION_MARKER';
   } on String catch (e) {
     rethrow;
   }
 }
 ''',
   '''
 import 'package:expect/expect.dart';
 main() {
-  test(); // This call is no longer on the stack when the error is thrown.
+  // This call is no longer on the stack when the error is thrown.
+  @{:main}test();
 }
 @NoInline()
 test() async {
   @{1:test}throw '$EXCEPTION_MARKER';
 }
 ''',
   '''
 import 'package:expect/expect.dart';
 main() {
   test1();
 }
 @NoInline()
 test1() async {
   // This call is no longer on the stack when the error is thrown.
-  await test2();
+  await @{:test1}test2();
 }
 @NoInline()
 test2() async {
   @{1:test2}throw '$EXCEPTION_MARKER';
 }
 ''',
   '''
 import 'package:expect/expect.dart';
 main() {
   test1();
 }
 @NoInline()
 test1() async {
   @{1:test1}test2();
 }
 @NoInline()
 test2() {
   @{2:test2}throw '$EXCEPTION_MARKER';
 }
 ''',
+  '''
+import 'package:expect/expect.dart';
+main() {
+  // This call is no longer on the stack when the error is thrown.
+  @{:main}test();
+}
+test() async {
+  var c = @{1:test}new Class();
+}
+class Class {
+  @NoInline()
+  Class() {
+    @{2:Class}throw '$EXCEPTION_MARKER';
+  }
+}
+''',
 ];
 
 class Test {
   final String code;
   final List<StackTraceLine> expectedLines;
+  final List<StackTraceLine> unexpectedLines;
 
-  Test(this.code, this.expectedLines);
+  Test(this.code, this.expectedLines, this.unexpectedLines);
 }
 
 const int _LF = 0x0A;
 const int _CR = 0x0D;
 const int _LBRACE = 0x7B;
 
 Test processTestCode(String code) {
   StringBuffer codeBuffer = new StringBuffer();
   Map<int, StackTraceLine> stackTraceMap = <int, StackTraceLine>{};
+  List<StackTraceLine> unexpectedLines = <StackTraceLine>[];
   int index = 0;
   int lineNo = 1;
   int columnNo = 1;
   while (index < code.length) {
     int charCode = code.codeUnitAt(index);
     switch (charCode) {
       case _LF:
         codeBuffer.write('\n');
         lineNo++;
         columnNo = 1;
         break;
       case _CR:
         if (index + 1 < code.length && code.codeUnitAt(index + 1) == _LF) {
           index++;
         }
         codeBuffer.write('\n');
         lineNo++;
         columnNo = 1;
         break;
       case 0x40:
         if (index + 1 < code.length && code.codeUnitAt(index + 1) == _LBRACE) {
           int colonIndex = code.indexOf(':', index);
           int endIndex = code.indexOf('}', index);
-          int stackTraceIndex =
-              int.parse(code.substring(index + 2, colonIndex));
           String methodName = code.substring(colonIndex + 1, endIndex);
-          assert(!stackTraceMap.containsKey(stackTraceIndex));
-          stackTraceMap[stackTraceIndex] =
+          String indexText = code.substring(index + 2, colonIndex);
+          StackTraceLine stackTraceLine =
               new StackTraceLine(methodName, INPUT_FILE_NAME, lineNo, columnNo);
+          if (indexText == '') {
+            unexpectedLines.add(stackTraceLine);
+          } else {
+            int stackTraceIndex = int.parse(indexText);
+            assert(!stackTraceMap.containsKey(stackTraceIndex));
+            stackTraceMap[stackTraceIndex] = stackTraceLine;
+          }
           index = endIndex;
         } else {
           codeBuffer.writeCharCode(charCode);
           columnNo++;
         }
         break;
       default:
         codeBuffer.writeCharCode(charCode);
         columnNo++;
     }
     index++;
   }
   List<StackTraceLine> expectedLines = <StackTraceLine>[];
   for (int stackTraceIndex in (stackTraceMap.keys.toList()..sort()).reversed) {
     expectedLines.add(stackTraceMap[stackTraceIndex]);
   }
-  return new Test(codeBuffer.toString(), expectedLines);
+  return new Test(codeBuffer.toString(), expectedLines, unexpectedLines);
 }
 
 void main(List<String> arguments) {
+  bool verbose = false;
+  bool printJs = false;
+  List<int> indices;
+  for (String arg in arguments) {
+    if (arg == '-v') {
+      verbose = true;
+    } else if (arg == '--print-js') {
+      printJs = true;
+    } else {
+      int index = int.parse(arg, onError: (_) => null);
+      if (index != null) {
+        indices ??= <int>[];
+        if (index < 0 || index >= TESTS.length) {
+          print('Index $index out of bounds: [0;${TESTS.length - 1}]');
+        } else {
+          indices.add(index);
+        }
+      }
+    }
+  }
+  if (indices == null) {
+    indices = new List<int>.generate(TESTS.length, (i) => i);
+  }
   asyncTest(() async {
-    for (String code in TESTS) {
-      await runTest(processTestCode(code), verbose: arguments.contains('-v'));
+    for (int index in indices) {
+      await runTest(index, processTestCode(TESTS[index]),
+          printJs: printJs, verbose: verbose);
     }
   });
 }
 
-Future runTest(Test test, {bool verbose: false}) async {
+Future runTest(int index, Test test,
+    {bool printJs: false, bool verbose: false}) async {
   Directory tmpDir = await createTempDir();
   String input = '${tmpDir.path}/$INPUT_FILE_NAME';
   new File(input).writeAsStringSync(test.code);
   String output = '${tmpDir.path}/out.js';
   List<String> arguments = [
     '-o$output',
     '--library-root=sdk',
     '--packages=${Platform.packageConfig}',
     Flags.useNewSourceInfo,
     input,
   ];
-  print("--------------------------------------------------------------------");
+  print("--$index------------------------------------------------------------");
   print("Compiling dart2js ${arguments.join(' ')}\n${test.code}");
   CompilationResult compilationResult = await entry.internalMain(arguments);
   Expect.isTrue(compilationResult.isSuccess,
       "Unsuccessful compilation of test:\n${test.code}");
   CompilerImpl compiler = compilationResult.compiler;
   SingleMapping sourceMap = new SingleMapping.fromJson(
       JSON.decode(new File('$output.map').readAsStringSync()));
 
+  if (printJs) {
+    print('JavaScript output:');
+    print(new File(output).readAsStringSync());
+  }
   print("Running d8 $output");
   ProcessResult runResult = Process.runSync(d8executable,
       ['sdk/lib/_internal/js_runtime/lib/preambles/d8.js', output]);
   String out = '${runResult.stderr}\n${runResult.stdout}';
   if (verbose) {
     print('d8 output:');
     print(out);
   }
   List<String> lines = out.split(new RegExp(r'(\r|\n|\r\n)'));
   List<StackTraceLine> jsStackTrace = <StackTraceLine>[];
@@ skipping 23 matching lines @@
       String fileName;
       if (targetEntry.sourceUrlId != 0) {
         fileName = sourceMap.urls[targetEntry.sourceUrlId];
       }
       dartStackTrace.add(new StackTraceLine(methodName, fileName,
           targetEntry.sourceLine + 1, targetEntry.sourceColumn + 1));
     }
   }
 
   int expectedIndex = 0;
+  List<StackTraceLine> unexpectedLines = <StackTraceLine>[];
   for (StackTraceLine line in dartStackTrace) {
     if (expectedIndex < test.expectedLines.length) {
       StackTraceLine expectedLine = test.expectedLines[expectedIndex];
       if (line.methodName == expectedLine.methodName &&
           line.lineNo == expectedLine.lineNo &&
           line.columnNo == expectedLine.columnNo) {
         expectedIndex++;
       }
     }
+    for (StackTraceLine unexpectedLine in test.unexpectedLines) {
+      if (line.methodName == unexpectedLine.methodName &&
+          line.lineNo == unexpectedLine.lineNo &&
+          line.columnNo == unexpectedLine.columnNo) {
+        unexpectedLines.add(line);
+      }
+    }
   }
   if (verbose) {
     print('JavaScript stacktrace:');
     print(jsStackTrace.join('\n'));
     print('Dart stacktrace:');
     print(dartStackTrace.join('\n'));
   }
   Expect.equals(
       expectedIndex,
       test.expectedLines.length,
       "Missing stack trace lines for test:\n${test.code}\n"
       "Actual:\n${dartStackTrace.join('\n')}\n"
       "Expected:\n${test.expectedLines.join('\n')}\n");
+  Expect.isTrue(
+      unexpectedLines.isEmpty,
+      "Unexpected stack trace lines for test:\n${test.code}\n"
+      "Actual:\n${dartStackTrace.join('\n')}\n"
+      "Unexpected:\n${test.unexpectedLines.join('\n')}\n");
 
   print("Deleting '${tmpDir.path}'.");
   tmpDir.deleteSync(recursive: true);
 }
 
 class StackTraceLine {
   String methodName;
   String fileName;
   int lineNo;
   int columnNo;
@@ skipping 106 matching lines @@
 String get d8executable {
   if (Platform.isWindows) {
     return 'third_party/d8/windows/d8.exe';
   } else if (Platform.isLinux) {
     return 'third_party/d8/linux/d8';
   } else if (Platform.isMacOS) {
     return 'third_party/d8/macos/d8';
   }
   throw new UnsupportedError('Unsupported platform.');
 }