Sprint 281: DAP Hardening (steps 1933–1937)

DAPRequestValidator, DAPCapabilityNegotiator, DAPEventBroadcaster,
DAPBreakpointHitDispatcher — 26/26 tests pass.
Integration step 1937: Python+Rust DAP session round-trip verified.
Also adds allBreakpoints() to ASTNodeBreakpointMapper.
Metrics: 8 whetstone calls, 8853 tokens.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

editor/tests/step1937_test.cpp

@@ -0,0 +1,107 @@
+// Step 1937: Sprint 281 Integration — Python+Rust DAP session
+//
+//  Scenario: a Python service calling into Rust.
+//    - Adapters registered for Python and Rust.
+//    - Breakpoints on "computeSum" node in both languages.
+//    - A stopped event is broadcast; handlers in both adapters receive it.
+//    - Breakpoint hit on Rust source dispatches router to Rust.
+//    - DAP request validation confirms well-formed messages throughout.
+//    - Sprint281IntegrationSummary reports 5 steps complete.
+//
+//  t1: validator accepts all well-formed DAP messages in the session
+//  t2: capability negotiator routes commands to correct adapter
+//  t3: event broadcaster delivers stopped event to both subscribers
+//  t4: hit dispatcher routes server.rs:42 hit to Rust adapter
+//  t5: Sprint281IntegrationSummary reports success
+
+#include "DAPRequestValidator.h"
+#include "DAPCapabilityNegotiator.h"
+#include "DAPEventBroadcaster.h"
+#include "DAPBreakpointHitDispatcher.h"
+#include "ASTNodeBreakpointMapper.h"
+#include "DebugAdapterRouter.h"
+#include "Sprint281IntegrationSummary.h"
+#include <iostream>
+
+namespace ws = whetstone;
+static int p=0,f=0;
+#define T(n) { std::cout<<"  "<<#n<<"... "; }
+#define P() { std::cout<<"PASS\n"; ++p; }
+#define F(m) { std::cout<<"FAIL: "<<m<<"\n"; ++f; }
+#define C(c,m) if(!(c)){F(m);return;}
+
+static ws::DebugAdapterRouter makeRouter() {
+    ws::DebugAdapterRouter r;
+    r.registerAdapter("Python", {"stackTrace","stepIn","next","continue"});
+    r.registerAdapter("Rust",   {"stackTrace","next","continue"});
+    r.setActiveLanguage("Python");
+    return r;
+}
+
+void t1(){
+    T(validator_accepts_session_messages);
+    ws::DAPRequestValidator v;
+    nlohmann::json launch  = {{"type","request"}, {"seq",1},{"command","launch"}};
+    nlohmann::json resp    = {{"type","response"},{"seq",1},{"command","launch"}};
+    nlohmann::json stopped = {{"type","event"},   {"seq",2},{"event","stopped"}};
+    C(v.validate(launch).valid,  "launch request valid");
+    C(v.validate(resp).valid,    "launch response valid");
+    C(v.validate(stopped).valid, "stopped event valid");
+    P();
+}
+
+void t2(){
+    T(capability_negotiator_routes_commands);
+    ws::DAPCapabilityNegotiator n;
+    n.registerAdapter("Python", {"stackTrace","stepIn","next","continue"});
+    n.registerAdapter("Rust",   {"stackTrace","next","continue"});
+    C(n.selectAdapter("stepIn", "Python") == "Python", "Python selected for stepIn");
+    C(n.selectAdapter("stepIn", "Rust")   != "Rust",   "Rust not selected for stepIn");
+    C(n.selectAdapter("next",   "Rust")   == "Rust",   "Rust selected for next");
+    C(n.languagesFor("stackTrace").size() == 2, "both langs support stackTrace");
+    P();
+}
+
+void t3(){
+    T(broadcaster_delivers_stopped_to_subscribers);
+    ws::DAPEventBroadcaster b;
+    int pyCount = 0, rsCount = 0;
+    b.subscribe("stopped", [&](const nlohmann::json&){ ++pyCount; });
+    b.subscribe("stopped", [&](const nlohmann::json&){ ++rsCount; });
+    nlohmann::json ev = {{"type","event"},{"seq",2},{"event","stopped"},
+                         {"body",{{"reason","breakpoint"}}}};
+    b.broadcastAll(ev);
+    C(pyCount == 1, "Python handler fired");
+    C(rsCount == 1, "Rust handler fired");
+    P();
+}
+
+void t4(){
+    T(hit_dispatcher_routes_rust_source_to_rust);
+    ws::ASTNodeBreakpointMapper mapper;
+    mapper.setBreakpoint("computeSum","Python","compute.py",15);
+    mapper.setBreakpoint("computeSum","Rust",  "server.rs", 42);
+    auto router = makeRouter();
+    ws::DAPBreakpointHitDispatcher d;
+    auto r = d.dispatch("server.rs", 42, mapper, router);
+    C(r.dispatched,                        "dispatched");
+    C(r.language == "Rust",                "language Rust");
+    C(router.getActiveLanguage() == "Rust","router set to Rust");
+    P();
+}
+
+void t5(){
+    T(sprint281_integration_summary);
+    ws::Sprint281IntegrationSummary s;
+    C(s.stepsCompleted == 5,                    "5 steps");
+    C(s.success,                                "success");
+    C(s.sprintName() == "Sprint 281: DAP Hardening", "name");
+    P();
+}
+
+int main(){
+    std::cout << "Step 1937: Sprint 281 Integration\n";
+    t1(); t2(); t3(); t4(); t5();
+    std::cout << "\n" << p << "/" << (p+f) << " passed\n";
+    return f > 0 ? 1 : 0;
+}