blob: 5468af7e6fcb1bcc96fc4c5253aa4237f2f3b97f [file] [log] [blame]
import 'dart:io';
import 'package:_fe_analyzer_shared/src/testing/annotated_code_helper.dart';
import 'package:expect/minitest.dart';
import 'package:path/path.dart' as path;
import 'package:source_maps/source_maps.dart';
/**
* Runs D8 and steps as the AnnotatedCode dictates.
*
* Note that the compiled javascript is expected to be called "js.js" inside the
* outputPath directory. It is also expected that there is a "js.js.map" file.
* It is furthermore expected that the js has been compiled from a file in the
* same folder called test.dart.
*/
ProcessResult runD8AndStep(String outputPath, String testFileName,
AnnotatedCode code, List<String> scriptD8Command) {
var outputFile = path.join(outputPath, "js.js");
SingleMapping sourceMap =
parse(new File("${outputFile}.map").readAsStringSync());
Set<int> mappedToLines = sourceMap.lines
.map((entry) => entry.entries.map((entry) => entry.sourceLine).toSet())
.fold(new Set<int>(), (prev, e) => prev..addAll(e));
for (Annotation annotation
in code.annotations.where((a) => a.text.trim() == "nm")) {
if (mappedToLines.contains(annotation.lineNo - 1)) {
fail("Was not allowed to have a mapping to line "
"${annotation.lineNo}, but did.\n"
"Sourcemap looks like this (note 0-indexed):\n"
"${sourceMap.debugString}");
}
}
List<String> breakpoints = [];
// Annotations are 1-based, js breakpoints are 0-based.
for (Annotation breakAt
in code.annotations.where((a) => a.text.trim() == "bl")) {
breakpoints
.add(_getJsBreakpointLine(testFileName, sourceMap, breakAt.lineNo - 1));
}
for (Annotation breakAt
in code.annotations.where((a) => a.text.trim().startsWith("bc:"))) {
breakpoints.add(_getJsBreakpointLineAndColumn(
testFileName, sourceMap, breakAt.lineNo - 1, breakAt.columnNo - 1));
}
File inspectorFile = new File.fromUri(
sdkRoot.uri.resolve("pkg/sourcemap_testing/lib/src/js/inspector.js"));
if (!inspectorFile.existsSync()) throw "Couldn't find 'inspector.js'";
var outInspectorPath = path.join(outputPath, "inspector.js");
inspectorFile.copySync(outInspectorPath);
String debugAction = "Debugger.stepInto";
if (code.annotations.any((a) => a.text.trim() == "Debugger:stepOver")) {
debugAction = "Debugger.stepOver";
}
return _runD8(outInspectorPath, scriptD8Command, debugAction, breakpoints);
}
/**
* Translates the D8 js steps and checks against expectations.
*
* Note that the compiled javascript is expected to be called "js.js" inside the
* outputPath directory. It is also expected that there is a "js.js.map" file.
* It is furthermore expected that the js has been compiled from a file in the
* same folder called test.dart.
*/
void checkD8Steps(String outputPath, List<String> d8Output, AnnotatedCode code,
{bool debug: false}) {
var outputFilename = "js.js";
var outputFile = path.join(outputPath, outputFilename);
SingleMapping sourceMap =
parse(new File("${outputFile}.map").readAsStringSync());
List<List<_DartStackTraceDataEntry>> result =
_extractStackTraces(d8Output, sourceMap, outputFilename);
List<_DartStackTraceDataEntry> trace =
result.map((entry) => entry.first).toList();
if (debug) _debugPrint(trace, outputPath);
List<String> recordStops =
trace.where((entry) => !entry.isError).map((entry) => "$entry").toList();
Set<int> recordStopLines =
trace.where((entry) => !entry.isError).map((entry) => entry.line).toSet();
Set<String> recordStopLineColumns = trace
.where((entry) => !entry.isError)
.map((entry) => "${entry.line}:${entry.column}")
.toSet();
List<String> expectedStops = [];
for (Annotation annotation in code.annotations.where((annotation) =>
annotation.text.trim().startsWith("s:") ||
annotation.text.trim().startsWith("sl:") ||
annotation.text.trim().startsWith("bc:"))) {
String text = annotation.text.trim();
int stopNum = int.parse(text.substring(text.indexOf(":") + 1));
if (expectedStops.length < stopNum) expectedStops.length = stopNum;
if (text.startsWith("sl:")) {
expectedStops[stopNum - 1] = "test.dart:${annotation.lineNo}:";
} else {
expectedStops[stopNum - 1] =
"test.dart:${annotation.lineNo}:${annotation.columnNo}:";
}
}
List<List<String>> noBreaksStart = [];
List<List<String>> noBreaksEnd = [];
for (Annotation annotation in code.annotations
.where((annotation) => annotation.text.trim().startsWith("nbb:"))) {
String text = annotation.text.trim();
var split = text.split(":");
int stopNum1 = int.parse(split[1]);
int stopNum2 = int.parse(split[2]);
if (noBreaksStart.length <= stopNum1) noBreaksStart.length = stopNum1 + 1;
noBreaksStart[stopNum1] ??= [];
if (noBreaksEnd.length <= stopNum2) noBreaksEnd.length = stopNum2 + 1;
noBreaksEnd[stopNum2] ??= [];
noBreaksStart[stopNum1].add("test.dart:${annotation.lineNo}:");
noBreaksEnd[stopNum2].add("test.dart:${annotation.lineNo}:");
}
_checkRecordedStops(
recordStops, expectedStops, noBreaksStart, noBreaksEnd, debug);
for (Annotation annotation in code.annotations
.where((annotation) => annotation.text.trim() == "nb")) {
// Check that we didn't break where we're not allowed to.
if (recordStopLines.contains(annotation.lineNo)) {
fail("Was not allowed to stop on line ${annotation.lineNo}, but did!"
" Actual line stops: $recordStopLines${_debugHint(debug)}");
}
}
for (Annotation annotation in code.annotations
.where((annotation) => annotation.text.trim() == "nbc")) {
// Check that we didn't break where we're not allowed to.
if (recordStopLineColumns
.contains("${annotation.lineNo}:${annotation.columnNo}")) {
fail("Was not allowed to stop on line ${annotation.lineNo} "
"column ${annotation.columnNo}, but did!"
" Actual line stops: $recordStopLineColumns${_debugHint(debug)}");
}
}
if (code.annotations.any((a) => a.text.trim() == "fail")) {
fail("Test contains 'fail' annotation.");
}
}
void _checkRecordedStops(
List<String> recordStops,
List<String> expectedStops,
List<List<String>> noBreaksStart,
List<List<String>> noBreaksEnd,
bool debug) {
// We want to find all expected lines in recorded lines in order, but allow
// more in between in the recorded lines.
// noBreaksStart and noBreaksStart gives instructions on what's *NOT* allowed
// to be between those points though.
int expectedIndex = 0;
Set<String> aliveNoBreaks = new Set<String>();
if (noBreaksStart.length > 0 && noBreaksStart[0] != null) {
aliveNoBreaks.addAll(noBreaksStart[0]);
}
int stopNumber = 0;
for (String recorded in recordStops) {
stopNumber++;
if (expectedIndex == expectedStops.length) break;
if ("$recorded:".contains(expectedStops[expectedIndex])) {
++expectedIndex;
if (noBreaksStart.length > expectedIndex &&
noBreaksStart[expectedIndex] != null) {
aliveNoBreaks.addAll(noBreaksStart[expectedIndex]);
}
if (noBreaksEnd.length > expectedIndex &&
noBreaksEnd[expectedIndex] != null) {
aliveNoBreaks.removeAll(noBreaksEnd[expectedIndex]);
}
} else {
if (debug) {
// One of the most helpful debugging tools is to see stops that weren't
// matched. The most common failure is we didn't match one particular
// stop location (e.g. because of the column). This gets reported
// as an aliveNoBreaks failure (if the test is using no-breaks like
// `nbb`) or it's reported as "stops don't match" message.
//
// Both failures are difficult to debug without seeing the stops that
// didn't match. No breaks failures are misleading (the problem isn't
// an incorrect break, but we missed a stop, so the aliveNoBreaks is
// wrong), and the normal failure list dumps the enitre stop list,
// making it difficult to see where the mismatch was.
//
// Also we add 1 to expectedIndex, because the stop annotations are
// 1-based in the source files (e.g. `/*s:1*/` is expectedIndex 0)
print("Skipping stop `$recorded` that didn't match expected stop "
"${expectedIndex + 1} `${expectedStops[expectedIndex]}`");
}
if (aliveNoBreaks
.contains("${(recorded.split(":")..removeLast()).join(":")}:")) {
fail("Break '$recorded' was found when it wasn't allowed "
"(js step $stopNumber, after stop ${expectedIndex + 1}). "
"This can happen when an expected stop was not matched"
"${_debugHint(debug)}.");
}
}
}
if (expectedIndex != expectedStops.length) {
// Didn't find everything.
fail("Expected to find $expectedStops but found $recordStops"
"${_debugHint(debug)}");
}
}
/// If we're not in debug mode, this returns a message string with information
/// about how to enable debug mode in the test runner.
String _debugHint(bool debug) {
if (debug) return ''; // already in debug mode
return ' (pass -Ddebug=1 to the test runner to see debug information)';
}
void _debugPrint(List<_DartStackTraceDataEntry> trace, String outputPath) {
StringBuffer sb = new StringBuffer();
var jsFile =
new File(path.join(outputPath, "js.js")).readAsStringSync().split("\n");
var dartFile = new File(path.join(outputPath, "test.dart"))
.readAsStringSync()
.split("\n");
List<String> getSnippet(List<String> data, int line, int column) {
List<String> result = new List<String>.filled(5, "");
if (line < 0 || column < 0) return result;
for (int i = 0; i < 5; ++i) {
int j = line - 2 + i;
if (j < 0 || j >= data.length) continue;
result[i] = data[j];
}
if (result[2].length >= column) {
result[2] = result[2].substring(0, column) +
"/*STOP*/" +
result[2].substring(column);
}
return result;
}
List<String> sideBySide(List<String> a, List<String> b, int columns) {
List<String> result = new List<String>.filled(a.length, null);
for (int i = 0; i < a.length; ++i) {
String left = a[i].padRight(columns).substring(0, columns);
String right = b[i].padRight(columns).substring(0, columns);
result[i] = left + " | " + right;
}
return result;
}
for (int i = 0; i < trace.length; ++i) {
sb.write("\n\nStop #${i + 1}\n\n");
if (trace[i].isError && trace[i].jsLine < 0) {
sb.write("${trace[i].errorString}\n");
continue;
}
var jsSnippet = getSnippet(jsFile, trace[i].jsLine, trace[i].jsColumn);
var dartSnippet =
getSnippet(dartFile, trace[i].line - 1, trace[i].column - 1);
var view = sideBySide(jsSnippet, dartSnippet, 50);
sb.writeAll(view, "\n");
}
print(sb.toString());
}
List<List<_DartStackTraceDataEntry>> _extractStackTraces(
lines, SingleMapping sourceMap, String outputFilename) {
List<List<_DartStackTraceDataEntry>> result = [];
bool inStackTrace = false;
List<String> currentStackTrace = <String>[];
for (var line in lines) {
if (line.trim() == "--- Debugger stacktrace start ---") {
inStackTrace = true;
} else if (line.trim() == "--- Debugger stacktrace end ---") {
result.add(
_extractStackTrace(currentStackTrace, sourceMap, outputFilename));
currentStackTrace.clear();
inStackTrace = false;
} else if (inStackTrace) {
currentStackTrace.add(line.trim());
}
}
return result;
}
List<_DartStackTraceDataEntry> _extractStackTrace(
List<String> js, SingleMapping sourceMap, String wantedFile) {
List<_DartStackTraceDataEntry> result = [];
for (String line in js) {
if (!line.contains("$wantedFile:")) {
result.add(
new _DartStackTraceDataEntry.error("Not correct file @ '$line'"));
continue;
}
Iterable<Match> ms = new RegExp(r"(\d+):(\d+)").allMatches(line);
if (ms.isEmpty) {
result.add(new _DartStackTraceDataEntry.error(
"Line and column not found for '$line'"));
continue;
}
Match m = ms.first;
int l = int.parse(m.group(1));
int c = int.parse(m.group(2));
SourceMapSpan span = _getColumnOrPredecessor(sourceMap, l, c);
if (span?.start == null) {
result.add(new _DartStackTraceDataEntry.errorWithJsPosition(
"Source map not found for '$line'", l, c));
continue;
}
var file = span.sourceUrl?.pathSegments?.last ?? "(unknown file)";
result.add(new _DartStackTraceDataEntry(
file, span.start.line + 1, span.start.column + 1, l, c));
}
return result;
}
SourceMapSpan _getColumnOrPredecessor(
SingleMapping sourceMap, int line, int column) {
SourceMapSpan span = sourceMap.spanFor(line, column);
if (span == null && line > 0) {
span = sourceMap.spanFor(line - 1, 999999);
}
return span;
}
class _DartStackTraceDataEntry {
final String file;
final int line;
final int column;
final errorString;
final int jsLine;
final int jsColumn;
_DartStackTraceDataEntry(
this.file, this.line, this.column, this.jsLine, this.jsColumn)
: errorString = null;
_DartStackTraceDataEntry.error(this.errorString)
: file = null,
line = -1,
column = -1,
jsLine = -1,
jsColumn = -1;
_DartStackTraceDataEntry.errorWithJsPosition(
this.errorString, this.jsLine, this.jsColumn)
: file = null,
line = -1,
column = -1;
get isError => errorString != null;
String toString() => isError ? errorString : "$file:$line:$column";
}
class _PointMapping {
final int fromLine;
final int fromColumn;
final int toLine;
final int toColumn;
_PointMapping(this.fromLine, this.fromColumn, this.toLine, this.toColumn);
}
/**
* Input and output is expected to be 0-based.
*
* The "magic 4" below is taken from https://github.com/ChromeDevTools/devtools-
* frontend/blob/fa18d70a995f06cb73365b2e5b8ae974cf60bd3a/front_end/sources/
* JavaScriptSourceFrame.js#L1520-L1523
*/
String _getJsBreakpointLine(
String testFileName, SingleMapping sourceMap, int breakOnLine) {
List<_PointMapping> mappingsOnLines = [];
for (var line in sourceMap.lines) {
for (var entry in line.entries) {
if (entry.sourceLine == null) continue;
if (entry.sourceLine >= breakOnLine &&
entry.sourceLine < breakOnLine + 4 &&
entry.sourceUrlId != null &&
sourceMap.urls[entry.sourceUrlId] == testFileName) {
mappingsOnLines.add(new _PointMapping(
entry.sourceLine, entry.sourceColumn, line.line, entry.column));
}
}
}
if (mappingsOnLines.isEmpty) return null;
mappingsOnLines.sort((a, b) {
if (a.fromLine != b.fromLine) return a.fromLine - b.fromLine;
if (a.fromColumn != b.fromColumn) return a.fromColumn - b.fromColumn;
if (a.toLine != b.toLine) return a.toLine - b.toLine;
return a.toColumn - b.toColumn;
});
_PointMapping first = mappingsOnLines.first;
mappingsOnLines.retainWhere((p) => p.toLine >= first.toLine);
_PointMapping last = mappingsOnLines.last;
return "${first.toLine}:${first.toColumn}:${last.toLine}:${first.toColumn}";
}
/**
* Input and output is expected to be 0-based.
*/
String _getJsBreakpointLineAndColumn(String testFileName,
SingleMapping sourceMap, int breakOnLine, int breakOnColumn) {
for (var line in sourceMap.lines) {
for (var entry in line.entries) {
if (entry.sourceLine == breakOnLine &&
entry.sourceColumn == breakOnColumn &&
entry.sourceUrlId != null &&
sourceMap.urls[entry.sourceUrlId] == testFileName)
return "${line.line}:${entry.column}";
}
}
return null;
}
ProcessResult _runD8(String outInspectorPath, List<String> scriptD8Command,
String debugAction, List<String> breakpoints) {
var outInspectorPathRelative = path.relative(outInspectorPath);
ProcessResult runResult = Process.runSync(
d8Executable,
['--enable-inspector', outInspectorPathRelative]
..addAll(scriptD8Command)
..addAll(["--", debugAction])
..addAll(breakpoints.where((s) => s != null)));
if (runResult.exitCode != 0) {
print(runResult.stderr);
print(runResult.stdout);
throw "Exit code: ${runResult.exitCode} from d8";
}
return runResult;
}
File _cachedD8File;
Directory _cachedSdkRoot;
File getD8File() {
File attemptFileFromDir(Directory dir) {
if (Platform.isWindows) {
return new File(dir.path + Platform.pathSeparator + "d8/windows/d8.exe");
} else if (Platform.isLinux) {
return new File(dir.path + Platform.pathSeparator + "d8/linux/d8");
} else if (Platform.isMacOS) {
return new File(dir.path + Platform.pathSeparator + "d8/macos/d8");
}
throw new UnsupportedError('Unsupported platform.');
}
File search() {
Directory dir = new File.fromUri(Platform.script).parent;
while (dir.path.length > 1) {
for (var entry in dir.listSync()) {
if (entry is! Directory) continue;
if (entry.path.endsWith("third_party")) {
List<String> segments = entry.uri.pathSegments;
if (segments[segments.length - 2] == "third_party") {
File possibleD8 = attemptFileFromDir(entry);
if (possibleD8.existsSync()) {
_cachedSdkRoot = dir;
return possibleD8;
}
}
}
}
dir = dir.parent;
}
throw "Cannot find D8 directory.";
}
return _cachedD8File ??= search();
}
Directory get sdkRoot {
getD8File();
return _cachedSdkRoot;
}
String get d8Executable {
return getD8File().path;
}