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 213 matching lines @@
 
 MatchFrame(int frameIndex, String functionName) {
   return new FrameMatcher(frameIndex, [ functionName ]);
 }
 
 MatchFrames(List<String> functionNames) {
   return new FrameMatcher(0, functionNames);
 }
 
 
+class LocalsMatcher extends Command {
+  Map locals = {};
+  
+  LocalsMatcher(this.locals) {
+    template = {"id": 0, "command": "getStackTrace", "params": {"isolateId": 0}};
+  }
+
+  void matchResponse(Debugger debugger) {
+    super.matchResponse(debugger);
+    
+    List frames = getJsonValue(debugger.currentMessage, "result:callFrames");
+    assert(frames != null);
+    
+    String functionName = frames[0]['functionName'];
+    List localsList = frames[0]['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;
+      }
+    }
+  }
+}
+
+
+MatchLocals(Map localValues) {
+  return new LocalsMatcher(localValues);
+}
+
+
+class EventMatcher {
+  String eventName;
+  Map params;
+  
+  EventMatcher(this.eventName, this.params);
+  
+  void matchEvent(Debugger debugger) {

[hausner, 2013/06/18 21:05:09]

If an event was matched, it might make sense to take it out of the events list
so you don't accidentally match the same event twice.

+    for (Event event in debugger.events) {
+      if (event.name == eventName) {
+        if (params == null) {
+          return;
+        } else if (matchMaps(params, event.params)) {
+          return;
+        }
+      }
+    }
+    
+    String msg = params == null ? '' : params.toString();
+    debugger.error("Error: could not match event $eventName $msg");
+  }
+}
+
+
+ExpectEvent(String eventName, [Map params]) {
+  return new EventMatcher(eventName, params);
+}
+
+
 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 25 matching lines @@
   void send(Debugger debugger) {
     assert(debugger.scriptUrl != null);
     template["params"]["url"] = debugger.scriptUrl;
     template["params"]["line"] = line;
     debugger.sendMessage(template);
   }
 }
 
 SetBreakpoint(int line) => new SetBreakpointCommand(line);
 
+class Event {
+  String name;
+  Map params;
+  
+  Event(Map json) {
+    name = json['event'];
+    params = json['params'];
+  }
+}
+
 
 // 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;
   JsonBuffer responses = new JsonBuffer();
 
   DebugScript script;
   int seqNr = 0;  // Sequence number of next debugger command message.
   Command lastCommand = null;  // Most recent command sent to target.
   List<String> errors = new List();
+  List<Event> events = new List();
   bool cleanupDone = false;
 
   // Data collected from debug target.
   Map currentMessage = null;  // Currently handled message sent by target.
   String scriptUrl = null;
   bool shutdownEventSeen = false;
   int isolateId = 0;
   bool isPaused = false;
 
   Debugger(this.targetProcess, this.script) {
@@ skipping 13 matching lines @@
     var stderrStringStream = targetProcess.stderr
         .transform(new StringDecoder())
         .transform(new LineTransformer());
     stderrStringStream.listen((line) {
       print("TARG: $line");
     });
   }
 
   // Handle debugger events, updating the debugger state.
   void handleEvent(Map<String,dynamic> msg) {
+    events.add(new Event(msg));
+    
     if (msg["event"] == "isolate") {
       if (msg["params"]["reason"] == "created") {
         isolateId = msg["params"]["id"];
         assert(isolateId != null);
         print("Debuggee isolate id $isolateId created.");
       } else if (msg["params"]["reason"] == "shutdown") {
         print("Debuggee isolate id ${msg["params"]["id"]} shut down.");
         shutdownEventSeen = true;
         if (!script.isEmpty) {
           error("Error: premature isolate shutdown event seen.");
@@ skipping 34 matching lines @@
       if (errorsDetected) {
         error("Error while matching response to debugger command");
         error("Response received from debug target: $receivedMsg");
       }
     }
   }
 
   // Send next debugger command in the script, if a response
   // form the last command has been received and processed.
   void sendNextCommand() {
+    while (script.isNextEventMatcher) {
+      EventMatcher matcher = script.currentEntry;
+      script.advance();      
+      matcher.matchEvent(this);
+    }
+    
     if (lastCommand == null) {
       if (script.currentEntry is Command) {
         script.currentEntry.send(this);
         lastCommand = script.currentEntry;
         seqNr++;
         script.advance();
       }
     }
   }
 
@@ skipping 124 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;
 }