Add the --steal-breakpoints flag.

runtime/observatory/tests/service/debugging_test.dart

Index: runtime/observatory/tests/service/debugging_test.dart
diff --git a/runtime/observatory/tests/service/debugging_test.dart b/runtime/observatory/tests/service/debugging_test.dart
index e99c60b418d69337317c6d9d0d2e2fb4273291d3..3eafe2d9d27bc722068e7c08ee215aa305d43b01 100644
--- a/runtime/observatory/tests/service/debugging_test.dart
+++ b/runtime/observatory/tests/service/debugging_test.dart
@@ -8,23 +8,25 @@ import 'package:unittest/unittest.dart';
 import 'test_helper.dart';
 import 'dart:async';
 
-void helper(i) {
-  print(i);
+int counter = 0;
+
+void periodicTask(_) {
+  counter++;
+  counter++;  // Line 15.  We set our breakpoint here.
+  counter++;
+  if (counter % 300 == 0) {
+    print('counter = $counter');
+  }
 }
 
-void testFunction() {
-  int i = 0;
-  while (true) {
-    if (++i % 100000000 == 0) {
-      helper(i);  // line 18
-    }
-  }
+void startTimer() {
+  new Timer.periodic(const Duration(milliseconds:10), periodicTask);
 }
 
 var tests = [
 
 // Pause
-(Isolate isolate) {
+(Isolate isolate) async {

[hausner, 2015/04/30 23:17:31]

DBC: I'm not familiar with the harness and what it expects the functions in the
tests array to do. But adding the async modifier to the function makes it return
a future immediately. That future then completes with the return value of this
function. The return value is a future, too. Is that really what is intended
here?

[hausner, 2015/04/30 23:41:48]

Commenting on my own comment :)

After looking at runIsolateTests() to see what it does with the tests array, I
think marking the function literals as async is wrong. The harness iterates over
the array with Future.forEach(), which invokes each function when the previous
one has completed the future it returns.

Marking the function literal as async now means that the future it returns
completes with the "return completer.future" statement, not with the
"completer.complete()" call in the event handler. That is probably not what you
want.

[turnidge, 2015/05/01 16:54:15]

Thanks.  The old code was vastly wrong.  Edited the test as discussed with you
offline.

   Completer completer = new Completer();
   var subscription;
   subscription = isolate.vm.events.stream.listen((ServiceEvent event) {
@@ -38,7 +40,7 @@ var tests = [
 },
 
 // Resume
-(Isolate isolate) {
+(Isolate isolate) async {
   Completer completer = new Completer();
   var subscription;
   subscription = isolate.vm.events.stream.listen((ServiceEvent event) {
@@ -52,45 +54,48 @@ var tests = [
 },
 
 // Add breakpoint
-(Isolate isolate) {
-  return isolate.rootLib.load().then((_) {
-      // Set up a listener to wait for breakpoint events.
-      Completer completer = new Completer();
-      var subscription;
-      subscription = isolate.vm.events.stream.listen((ServiceEvent event) {
-        if (event.eventType == ServiceEvent.kPauseBreakpoint) {
-          print('Breakpoint reached');
-          subscription.cancel();
-          completer.complete();
-        }
-      });
-
-      // Add the breakpoint.
-      var script = isolate.rootLib.scripts[0];
-      return isolate.addBreakpoint(script, 18).then((result) {
-          expect(result is Breakpoint, isTrue);
-          Breakpoint bpt = result;
-          expect(bpt.type, equals('Breakpoint'));
-          expect(bpt.script.id, equals(script.id));
-          expect(bpt.tokenPos, equals(58));
-          expect(isolate.breakpoints.length, equals(1));
-          return completer.future;  // Wait for breakpoint events.
-      });
+(Isolate isolate) async {
+  await isolate.rootLib.load();
+
+  // Set up a listener to wait for breakpoint events.
+  Completer completer = new Completer();
+  var subscription;
+  subscription = isolate.vm.events.stream.listen((ServiceEvent event) {
+    if (event.eventType == ServiceEvent.kPauseBreakpoint) {
+      print('Breakpoint reached');
+      subscription.cancel();
+      completer.complete();
+    }
     });
+
+  var script = isolate.rootLib.scripts[0];
+  await script.load();
+
+  // Add the breakpoint.
+  var result = await isolate.addBreakpoint(script, 15);
+  expect(result is Breakpoint, isTrue);
+  Breakpoint bpt = result;
+  expect(bpt.type, equals('Breakpoint'));
+  expect(bpt.script.id, equals(script.id));
+  expect(bpt.script.tokenToLine(bpt.tokenPos), equals(15));
+  expect(isolate.breakpoints.length, equals(1));
+
+  return completer.future;  // Wait for breakpoint events.
 },
 
-// Get the stack trace
-(Isolate isolate) {
-  return isolate.getStack().then((ServiceMap stack) {
-      expect(stack.type, equals('Stack'));
-      expect(stack['frames'].length, greaterThanOrEqualTo(1));
-      expect(stack['frames'][0]['function'].name, equals('testFunction'));
-      expect(stack['frames'][0]['tokenPos'], equals(58));
-  });
+// We are at the breakpoint on line 14.

[rmacnak, 2015/04/30 21:48:55]

15

[turnidge, 2015/05/01 16:54:15]

Done.

+(Isolate isolate) async {
+  ServiceMap stack = await isolate.getStack();
+  expect(stack.type, equals('Stack'));
+  expect(stack['frames'].length, greaterThanOrEqualTo(1));
+
+  Script script = stack['frames'][0]['script'];
+  expect(script.name,endsWith('debugging_test.dart'));
+  expect(script.tokenToLine(stack['frames'][0]['tokenPos']), equals(15));
 },
 
 // Stepping
-(Isolate isolate) {
+(Isolate isolate) async {
   // Set up a listener to wait for breakpoint events.
   Completer completer = new Completer();
   var subscription;
@@ -102,23 +107,23 @@ var tests = [
     }
   });
 
-  return isolate.stepInto().then((isolate) {
-    return completer.future;  // Wait for breakpoint events.
-  });
+  await isolate.stepInto();

[rmacnak, 2015/04/30 21:48:55]

stepOver()? This assumes Integer.+ is unsteppable.

[turnidge, 2015/05/01 16:54:15]

Done.

+  return completer.future;  // Wait for breakpoint events.
 },
 
-// Get the stack trace again.  Our position has updated.
-(Isolate isolate) {
-  return isolate.getStack().then((ServiceMap stack) {
-      expect(stack.type, equals('Stack'));
-      expect(stack['frames'].length, greaterThanOrEqualTo(2));
-      expect(stack['frames'][0]['function'].name, equals('testFunction'));
-      expect(stack['frames'][0]['tokenPos'], equals(60));
-  });
+// We are now at line 16.
+(Isolate isolate) async {
+  ServiceMap stack = await isolate.getStack();
+  expect(stack.type, equals('Stack'));
+  expect(stack['frames'].length, greaterThanOrEqualTo(1));
+
+  Script script = stack['frames'][0]['script'];
+  expect(script.name,endsWith('debugging_test.dart'));
+  expect(script.tokenToLine(stack['frames'][0]['tokenPos']), equals(16));
 },
 
 // Remove breakpoint
-(Isolate isolate) {
+(Isolate isolate) async {
   // Set up a listener to wait for breakpoint events.
   Completer completer = new Completer();
   var subscription;
@@ -133,13 +138,12 @@ var tests = [
 
   expect(isolate.breakpoints.length, equals(1));
   var bpt = isolate.breakpoints.values.first;
-  return isolate.removeBreakpoint(bpt).then((_) {
-    return completer.future;
-  });
+  await isolate.removeBreakpoint(bpt);
+  return completer.future;
 },
 
 // Resume
-(Isolate isolate) {
+(Isolate isolate) async {
   Completer completer = new Completer();
   var subscription;
   subscription = isolate.vm.events.stream.listen((ServiceEvent event) {
@@ -153,7 +157,7 @@ var tests = [
 },
 
 // Add breakpoint at function entry
-(Isolate isolate) {
+(Isolate isolate) async {
   // Set up a listener to wait for breakpoint events.
   Completer completer = new Completer();
   var subscription;
@@ -167,21 +171,32 @@ var tests = [
 
   // Find a specific function.
   ServiceFunction function = isolate.rootLib.functions.firstWhere(
-      (f) => f.name == 'helper');
+      (f) => f.name == 'periodicTask');
   expect(function, isNotNull);
 
   // Add the breakpoint at function entry
-  return isolate.addBreakpointAtEntry(function).then((result) {
-    expect(result is Breakpoint, isTrue);
-    Breakpoint bpt = result;
-    expect(bpt.type, equals('Breakpoint'));
-    expect(bpt.script.name, equals('debugging_test.dart'));
-    expect(bpt.tokenPos, equals(29));
-    expect(isolate.breakpoints.length, equals(1));
-    return completer.future;  // Wait for breakpoint events.
-  });
+  var result = await isolate.addBreakpointAtEntry(function);
+  expect(result is Breakpoint, isTrue);
+  Breakpoint bpt = result;
+  expect(bpt.type, equals('Breakpoint'));
+  expect(bpt.script.name, equals('debugging_test.dart'));
+  expect(bpt.script.tokenToLine(bpt.tokenPos), equals(14));
+  expect(isolate.breakpoints.length, equals(1));
+
+  return completer.future;  // Wait for breakpoint events.
+},
+
+// We are now at line 14.
+(Isolate isolate) async {
+  ServiceMap stack = await isolate.getStack();
+  expect(stack.type, equals('Stack'));
+  expect(stack['frames'].length, greaterThanOrEqualTo(1));
+
+  Script script = stack['frames'][0]['script'];
+  expect(script.name,endsWith('debugging_test.dart'));
+  expect(script.tokenToLine(stack['frames'][0]['tokenPos']), equals(14));
 },
 
 ];
 
-main(args) => runIsolateTests(args, tests, testeeConcurrent: testFunction);
+main(args) => runIsolateTests(args, tests, testeeBefore: startTimer);