pkg/vm_service_client: add getSourceReport to VMServiceReference

test/source_report_test.dart

Index: test/source_report_test.dart
diff --git a/test/source_report_test.dart b/test/source_report_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..4a8e216c4a6718681a1effc08fa0de4da28a1562
--- /dev/null
+++ b/test/source_report_test.dart
@@ -0,0 +1,204 @@
+// 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 'package:test/test.dart';
+import 'package:vm_service_client/vm_service_client.dart';
+
+import 'utils.dart';
+
+const _mainContent = r"""
+print("one");
+  print("two");
+
+  if (false) {
+    print("three");
+    print("four");
+  }""";
+
+void main() {
+  VMServiceClient client;
+  VMIsolateRef isolate;
+
+  tearDown(() {
+    if (client != null) client.close();
+  });
+
+  group('a script with one range', () {
+    setUp(() async {
+      client = await runAndConnect(main: _mainContent);
+
+      isolate = (await client.getVM()).isolates.single;
+
+      await isolate.pause();
+    });
+
+    test("and no options", () async {
+      var report = await isolate.getSourceReport();
+
+      expect(report.ranges, hasLength(greaterThan(1)));
+
+      var range = report.ranges.singleWhere((range) =>
+          range.script.uri.toString().startsWith('data:application/dart'));
+
+      expect(range.compiled, isTrue);
+
+      var script = await range.script.load();
+
+      var startLocation = script.sourceLocation(range.location.token);
+      expect(startLocation.line, 5);
+      expect(startLocation.column, 1);
+
+      var endLocation = script.sourceLocation(range.location.end);
+      expect(endLocation.line, 15);
+      expect(endLocation.column, 1);
+
+      expect(range.hits, isNull);
+      expect(range.misses, isNull);
+      expect(range.possibleBreakpoints, isNull);
+    });
+
+    test("including coverage", () async {
+      var report = await isolate.getSourceReport(includeCoverageReport: true);
+
+      var range = report.ranges.singleWhere((range) =>
+          range.script.uri.toString().startsWith('data:application/dart'));
+      expect(range.possibleBreakpoints, isNull);
+
+      var script = await range.script.load();
+
+      var hitLocations =
+          range.hits.map((token) => script.sourceLocation(token).line);
+
+      expect(hitLocations, [7, 8, 9, 15]);
+
+      var missLocations =
+          range.misses.map((token) => script.sourceLocation(token).line);
+
+      expect(missLocations, [12, 13]);
+    });
+
+    test("including possible breakpoints", () async {
+      var report =
+          await isolate.getSourceReport(includePossibleBreakpoints: true);
+
+      var range = report.ranges.singleWhere((range) =>
+          range.script.uri.toString().startsWith('data:application/dart'));
+
+      expect(range.hits, isNull);
+      expect(range.misses, isNull);
+
+      var script = await range.script.load();
+
+      expect(range.possibleBreakpoints, isNotEmpty);
+
+      var breakPointLines = range.possibleBreakpoints
+          .map((token) => script.sourceLocation(token).line);
+
+      expect(breakPointLines, [5, 7, 8, 9, 12, 13, 15]);
+    });
+
+    test("including coverage and possible breakpoints", () async {
+      var report = await isolate.getSourceReport(
+          includeCoverageReport: true, includePossibleBreakpoints: true);
+
+      var range = report.ranges.singleWhere((range) =>
+          range.script.uri.toString().startsWith('data:application/dart'));
+
+      expect(range.hits, isNotEmpty);
+      expect(range.misses, isNotEmpty);
+      expect(range.possibleBreakpoints, isNotEmpty);
+    });
+  });
+
+  group('a script with multiple ranges', () {
+    VMScript script;
+    int mainFunctionTokenOffset;
+    VMLibrary rootLib;
+
+    setUp(() async {
+      client = await runAndConnect(
+          topLevel: r'''final unusedField = 5;
+
+int unusedFunction(a, b) {
+  return a + b;
+}''',
+          main: _mainContent);
+
+      isolate = (await client.getVM()).isolates.single;
+
+      await isolate.pause();
+
+      var runnableIsolate = await isolate.loadRunnable();
+      rootLib = await runnableIsolate.rootLibrary.load();
+
+      var mainFunc = await rootLib.functions['main'].load();
+
+      mainFunctionTokenOffset = mainFunc.location.token.offset;
+
+      script = await rootLib.scripts.single.load();
+    });
+
+    test("not foce compiled", () async {
+      var report = await script.getSourceReport(
+          includeCoverageReport: true, includePossibleBreakpoints: true);
+
+      expect(report.ranges, hasLength(2));
+
+      var firstRange = report.ranges.first;
+      expect(firstRange.compiled, isFalse);
+      expect(firstRange.location.end.offset, lessThan(mainFunctionTokenOffset));
+
+      var secondRange = report.ranges.last;
+      expect(secondRange.compiled, isTrue);
+      expect(secondRange.location.token.offset, mainFunctionTokenOffset);
+    });
+
+    test("foce compiled", () async {
+      var report = await script.getSourceReport(
+          includeCoverageReport: true,
+          includePossibleBreakpoints: true,
+          forceCompile: true);
+
+      expect(report.ranges, hasLength(2));
+
+      var firstRange = report.ranges.first;
+      expect(firstRange.compiled, isTrue);
+
+      var secondRange = report.ranges.last;
+      expect(secondRange.compiled, isTrue);
+    });
+
+    test("with tokenPos set", () async {
+      var report = await script.getSourceReport(
+          includeCoverageReport: true,
+          includePossibleBreakpoints: true,
+          tokenPos: mainFunctionTokenOffset);
+
+      expect(
+          report.ranges.single.location.token.offset, mainFunctionTokenOffset);
+    });
+
+    test("with endTokenPos set", () async {
+      var report = await script.getSourceReport(
+          includeCoverageReport: true,
+          includePossibleBreakpoints: true,
+          endTokenPos: mainFunctionTokenOffset - 1);
+
+      expect(report.ranges.single.location.end.offset,
+          lessThan(mainFunctionTokenOffset));
+    });
+
+    test("with an empty token range", () async {
+      var unusedFunction = await rootLib.functions['unusedFunction'].load();
+
+      var report = await script.getSourceReport(
+          includeCoverageReport: true,
+          includePossibleBreakpoints: true,
+          tokenPos: unusedFunction.location.end.offset + 1,
+          endTokenPos: mainFunctionTokenOffset - 1);
+
+      expect(report.ranges, isEmpty);
+    });
+  });
+}