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..46cae09d49417529ba945c7197b26d42373eb9f9
--- /dev/null
+++ b/test/source_report_test.dart
@@ -0,0 +1,167 @@
+// Copyright (c) 2015, 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';
+
+VMServiceClient client;
+VMIsolateRef isolate;
+
+void main() {
+  tearDown(() {
+    if (client != null) {
+      client.close();
+      client = null;
+    }
+    isolate = null;
+  });
+
+  group('simple script', () {
+    setUp(() async {
+      client = await runAndConnect(main: r"""
+      print("one");
+      print("two");
+    """);
+
+      isolate = (await client.getVM()).isolates.single;
+
+      await isolate.pause();
+    });
+
+    test("no options", () async {
+      var report = await isolate.getSourceReport();
+
+      expect(report.scripts, hasLength(greaterThan(1)));
+      expect(report.ranges, hasLength(greaterThan(1)));
+
+      var customScript = report.scripts.last;
+
+      expect(customScript.uri.toString(), startsWith('data:application/dart'));
+
+      var range = report.ranges.singleWhere(
+          (range) => range.scriptIndex == report.scripts.length - 1);
+
+      expect(range.compiled, isTrue);
+      expect(range.startPos, lessThan(range.endPos));
+      expect(range.coverage, isNull);
+      expect(range.possibleBreakpoints, isNull);
+    });
+
+    test("coverage", () async {
+      var report = await isolate.getSourceReport(includeCoverageReport: true);
+
+      var customScript = report.scripts.last;
+
+      expect(customScript.uri.toString(), startsWith('data:application/dart'));
+
+      var range = report.ranges.singleWhere(
+          (range) => range.scriptIndex == report.scripts.length - 1);
+
+      expect(range.possibleBreakpoints, isNull);
+
+      var coverage = range.coverage;
+
+      expect(coverage.hits, isNotEmpty);
+      expect(coverage.misses, isEmpty);
+    });
+
+    test("possible break points", () async {
+      var report =
+          await isolate.getSourceReport(includePossibleBreakpoints: true);
+
+      var customScript = report.scripts.last;
+
+      expect(customScript.uri.toString(), startsWith('data:application/dart'));
+
+      var range = report.ranges.singleWhere(
+          (range) => range.scriptIndex == report.scripts.length - 1);
+
+      expect(range.coverage, isNull);
+
+      expect(range.possibleBreakpoints, isNotEmpty);
+    });
+
+    test("both options", () async {
+      var report = await isolate.getSourceReport(
+          includeCoverageReport: true, includePossibleBreakpoints: true);
+
+      var customScript = report.scripts.last;
+
+      expect(customScript.uri.toString(), startsWith('data:application/dart'));
+
+      var range = report.ranges.singleWhere(
+          (range) => range.scriptIndex == report.scripts.length - 1);
+
+      expect(range.coverage, isNotNull);
+      expect(range.possibleBreakpoints, isNotNull);
+    });
+  });
+
+  test("script and ranges", () async {
+    client = await runAndConnect(
+        topLevel: r'''final foo = 5;
+        int add(a, b) => a + b;
+        ''',
+        main: r"""
+      print("one");
+      print("two");
+    """);
+
+    isolate = (await client.getVM()).isolates.single;
+
+    await isolate.pause();
+
+    var report = await isolate.getSourceReport(includeCoverageReport: true);
+
+    var customScript = report.scripts.last;
+
+    expect(customScript.uri.toString(), startsWith('data:application/dart'));
+
+    report = await isolate.getSourceReport(
+        includeCoverageReport: true,
+        includePossibleBreakpoints: true,
+        script: customScript);
+
+    expect(report.ranges, hasLength(2));
+
+    var firstRange = report.ranges.first;
+    var secondRange = report.ranges.last;
+
+    expect(firstRange.endPos, lessThan(secondRange.startPos),
+        reason: 'The first range should come before the second range.');
+
+    // validate the start param
+
+    report = await isolate.getSourceReport(
+        includeCoverageReport: true,
+        includePossibleBreakpoints: true,
+        script: customScript,
+        tokenPos: firstRange.endPos + 1);
+
+    expect(report.ranges.single.startPos, secondRange.startPos);
+
+    // validate the end param
+
+    report = await isolate.getSourceReport(
+        includeCoverageReport: true,
+        includePossibleBreakpoints: true,
+        script: customScript,
+        endTokenPos: secondRange.startPos - 1);
+
+    expect(report.ranges.single.endPos, firstRange.endPos);
+
+    // validate both params
+
+    report = await isolate.getSourceReport(
+        includeCoverageReport: true,
+        includePossibleBreakpoints: true,
+        script: customScript,
+        tokenPos: firstRange.endPos + 1,
+        endTokenPos: secondRange.startPos - 1);
+
+    expect(report.ranges, isEmpty);
+  });
+}