Fix for an issue w/ breakpointResolved events not being sent.

tests/standalone/debugger/debug_lib.dart

 // Copyright (c) 2013, 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.
 
 // Library used by debugger wire protocol tests (standalone VM debugging).
 
 library DartDebugger;
 
 import "dart:async";
 import "dart:io";
@@ skipping 168 matching lines @@
       debugger.error("Error: expected messaged id $id but got ${response["id"]}.");
     }
   }
 }
 
 
 class FrameMatcher extends Command {
   int frameIndex;
   List<String> functionNames;
 
+  Map locals = {};
+  
   FrameMatcher(this.frameIndex, this.functionNames) {
     template = {"id": 0, "command": "getStackTrace", "params": {"isolateId": 0}};
   }
 
+  void matchLocal(String localName, String localValue) {
+    locals[localName] = localValue;    
+  }
+  
   void matchResponse(Debugger debugger) {
     super.matchResponse(debugger);
     var msg = debugger.currentMessage;
     List frames = getJsonValue(msg, "result:callFrames");
     assert(frames != null);
     if (debugger.scriptUrl == null) {
       var name = frames[0]["functionName"];
       if (name == "main") {
         // Extract script url of debugged script.
         debugger.scriptUrl = frames[0]["location"]["url"];
         assert(debugger.scriptUrl != null);
       }
     }
     if (frames.length < functionNames.length) {
       debugger.error("Error: stack trace not long enough "
                      "to match ${functionNames.length} frames");
       return;
     }
     for (int i = 0; i < functionNames.length; i++) {
       var idx = i + frameIndex;
       var name = frames[idx]["functionName"];
       assert(name != null);
       if (name != functionNames[i]) {
         debugger.error("Error: call frame $idx: "
           "expected function name '${functionNames[i]}' but found '$name'");
         return;
       }
     }
+    
+    // verify locals
+    String functionName = frames[frameIndex]['functionName'];
+    List localsList = frames[frameIndex]['locals'];
+    Map reportedLocals = {};
+    localsList.forEach((local) => reportedLocals[local['name']] = local['value']);    
+    for (String key in locals.keys) {
+      if (reportedLocals[key] == null) {
+        debugger.error("Error in $functionName(): no value reported for local "
+            "variable $key");
+        return;
+      }
+      String expected = locals[key];
+      String actual = reportedLocals[key]['text'];
+      if (expected != actual) {
+        debugger.error("Error in $functionName(): got '$actual' for local "
+            "variable $key, but expected '$expected'");
+        return;
+      }
+    }
   }
 }
 
 
 MatchFrame(int frameIndex, String functionName) {
   return new FrameMatcher(frameIndex, [ functionName ]);
 }
 
 MatchFrames(List<String> functionNames) {

[hausner, 2013/06/18 17:30:25]

How about an optional parameter here that takes a map of expected local names
values? That would eliminate the need for matchLocals() and the IMO ugly
cascaded calls to it.

Same for MatchFrame above.

Even better, you could create a separate matcher class for locals. That would
make the tests more readable:
  MatchFrames(['foo', 'bar', 'main']);
  MatchLocals(0, {'var1': 0, 'var2': null});  // locals in function 'foo'.
  MatchLocals(2, {'m1': 'hello'});  // locals in function 'main'.

   return new FrameMatcher(0, functionNames);
 }
 
 
+class EventMatcher {
+  String eventName;
+  
+  EventMatcher(this.eventName);
+  
+  void matchEvent(Debugger debugger, Map event) {
+    String actualName = event['event'];
+    
+    if (eventName != actualName) {
+      debugger.error("Error: got event $actualName but expected event $eventName");
+      return;
+    }
+  }
+}
+
+
+ExpectEvent(String eventName) {
+  return new EventMatcher(eventName);
+}
+
+
 class RunCommand extends Command {
   RunCommand.resume() {
     template = {"id": 0, "command": "resume", "params": {"isolateId": 0}};
   }
   RunCommand.step() {
     template = {"id": 0, "command": "stepOver", "params": {"isolateId": 0}};
   }
   RunCommand.stepInto() {
     template = {"id": 0, "command": "stepInto", "params": {"isolateId": 0}};
   }
@@ skipping 34 matching lines @@
 
 
 // A debug script is a list of Command objects.
 class DebugScript {
   List entries;
   DebugScript(List scriptEntries) {
     entries = new List.from(scriptEntries.reversed);
     entries.add(MatchFrame(0, "main"));
   }
   bool get isEmpty => entries.isEmpty;
+  bool get isNextEventMatcher => !isEmpty && currentEntry is EventMatcher;
   get currentEntry => entries.last;
   advance() => entries.removeLast();
   add(entry) => entries.add(entry);
 }
 
 
 class Debugger {
   // Debug target process properties.
   Process targetProcess;
   Socket socket;
@@ skipping 56 matching lines @@
       var location = msg["params"]["location"];
       assert(location != null);
       print("Isolate $isolateId: breakpoint $bpId resolved"
             " at location $location");
       // We may want to maintain a table of breakpoints in the future.
     } else if (msg["event"] == "paused") {
       isPaused = true;
     } else {
       error("Error: unknown debugger event received");
     }
+    
+    if (script.isNextEventMatcher) {
+      EventMatcher matcher = script.currentEntry;
+      script.advance();
+      matcher.matchEvent(this, msg);
+    }
   }
 
   // Handle one JSON message object and match it to the
   // expected events and responses in the debugging script.
   void handleMessage(Map<String,dynamic> receivedMsg) {
     currentMessage = receivedMsg;
     if (receivedMsg["event"] != null) {
       handleEvent(receivedMsg);
       if (errorsDetected) {
         error("Error while handling debugger event");
@@ skipping 151 matching lines @@
   targetOpts.add("--debuggee");
   print('args: ${targetOpts.join(" ")}');
 
   Process.start(options.executable, targetOpts).then((Process process) {
     print("Debug target process started, pid ${process.pid}.");
     process.stdin.close();
     var debugger = new Debugger(process, new DebugScript(script));
   });
   return true;
 }