Step 557: add exception and stack trace capture model

editor/tests/step557_test.cpp

@@ -0,0 +1,149 @@
+// Step 557: Exception + Stack Trace Capture (12 tests)
+
+#include "ExceptionStackTraceCapture.h"
+
+#include <iostream>
+
+static int passed = 0, failed = 0;
+#define TEST(name) { std::cout << "  " << #name << "... "; }
+#define PASS() { std::cout << "PASS\n"; ++passed; }
+#define FAIL(msg) { std::cout << "FAIL: " << msg << "\n"; ++failed; }
+#define CHECK(cond, msg) if (!(cond)) { FAIL(msg); return; } else {}
+
+static bool hasError(const ExceptionCaptureResult& r, const std::string& code) {
+    for (const auto& e : r.errors) {
+        if (e == code || e.find(code) == 0) return true;
+    }
+    return false;
+}
+
+void test_valid_exception_capture_passes() {
+    TEST(valid_exception_capture_passes);
+    auto r = ExceptionStackTraceCapture::capture(
+        "RuntimeError", "boom", "thread-1",
+        { {"foo", "main.cpp", 12, ""}, {"bar", "lib.cpp", 44, ""} });
+    CHECK(r.valid, "valid exception should pass");
+    CHECK(r.event.frames.size() == 2, "two frames expected");
+    PASS();
+}
+
+void test_missing_type_rejected() {
+    TEST(missing_type_rejected);
+    auto r = ExceptionStackTraceCapture::capture(
+        "", "boom", "thread-1", {{"foo", "main.cpp", 12, ""}});
+    CHECK(!r.valid, "missing type should fail");
+    CHECK(hasError(r, "missing_type"), "missing_type expected");
+    PASS();
+}
+
+void test_missing_message_rejected() {
+    TEST(missing_message_rejected);
+    auto r = ExceptionStackTraceCapture::capture(
+        "RuntimeError", "", "thread-1", {{"foo", "main.cpp", 12, ""}});
+    CHECK(!r.valid, "missing message should fail");
+    CHECK(hasError(r, "missing_message"), "missing_message expected");
+    PASS();
+}
+
+void test_missing_thread_id_rejected() {
+    TEST(missing_thread_id_rejected);
+    auto r = ExceptionStackTraceCapture::capture(
+        "RuntimeError", "boom", "", {{"foo", "main.cpp", 12, ""}});
+    CHECK(!r.valid, "missing thread id should fail");
+    CHECK(hasError(r, "missing_thread_id"), "missing_thread_id expected");
+    PASS();
+}
+
+void test_missing_frames_rejected() {
+    TEST(missing_frames_rejected);
+    auto r = ExceptionStackTraceCapture::capture("RuntimeError", "boom", "thread-1", {});
+    CHECK(!r.valid, "missing frames should fail");
+    CHECK(hasError(r, "missing_stack_frames"), "missing_stack_frames expected");
+    PASS();
+}
+
+void test_invalid_frame_function_rejected() {
+    TEST(invalid_frame_function_rejected);
+    auto r = ExceptionStackTraceCapture::capture(
+        "RuntimeError", "boom", "thread-1", {{"", "main.cpp", 12, ""}});
+    CHECK(!r.valid, "invalid frame should fail");
+    CHECK(hasError(r, "invalid_frame:0"), "invalid_frame expected");
+    PASS();
+}
+
+void test_invalid_frame_file_rejected() {
+    TEST(invalid_frame_file_rejected);
+    auto r = ExceptionStackTraceCapture::capture(
+        "RuntimeError", "boom", "thread-1", {{"foo", "", 12, ""}});
+    CHECK(!r.valid, "invalid frame should fail");
+    CHECK(hasError(r, "invalid_frame:0"), "invalid_frame expected");
+    PASS();
+}
+
+void test_invalid_frame_line_rejected() {
+    TEST(invalid_frame_line_rejected);
+    auto r = ExceptionStackTraceCapture::capture(
+        "RuntimeError", "boom", "thread-1", {{"foo", "main.cpp", 0, ""}});
+    CHECK(!r.valid, "invalid frame should fail");
+    CHECK(hasError(r, "invalid_frame:0"), "invalid_frame expected");
+    PASS();
+}
+
+void test_navigation_anchor_is_generated() {
+    TEST(navigation_anchor_is_generated);
+    auto r = ExceptionStackTraceCapture::capture(
+        "RuntimeError", "boom", "thread-1", {{"foo", "main.cpp", 12, ""}});
+    CHECK(r.valid, "capture should pass");
+    CHECK(r.event.frames[0].navigationAnchor == "main.cpp:12", "anchor mismatch");
+    PASS();
+}
+
+void test_multiple_invalid_frames_reported() {
+    TEST(multiple_invalid_frames_reported);
+    auto r = ExceptionStackTraceCapture::capture(
+        "RuntimeError", "boom", "thread-1",
+        {{"", "main.cpp", 10, ""}, {"ok", "ok.cpp", 2, ""}, {"bad", "", 2, ""}});
+    CHECK(!r.valid, "invalid frames should fail");
+    CHECK(hasError(r, "invalid_frame:0"), "first invalid frame expected");
+    CHECK(hasError(r, "invalid_frame:2"), "third invalid frame expected");
+    CHECK(r.event.frames.size() == 1, "only one valid frame expected");
+    PASS();
+}
+
+void test_event_fields_persist() {
+    TEST(event_fields_persist);
+    auto r = ExceptionStackTraceCapture::capture(
+        "TypeError", "bad arg", "thread-9", {{"foo", "main.cpp", 12, ""}});
+    CHECK(r.event.type == "TypeError", "type mismatch");
+    CHECK(r.event.message == "bad arg", "message mismatch");
+    CHECK(r.event.threadId == "thread-9", "thread id mismatch");
+    PASS();
+}
+
+void test_single_valid_frame_is_sufficient() {
+    TEST(single_valid_frame_is_sufficient);
+    auto r = ExceptionStackTraceCapture::capture(
+        "RuntimeError", "boom", "thread-1", {{"foo", "main.cpp", 1, ""}});
+    CHECK(r.valid, "single valid frame should pass");
+    PASS();
+}
+
+int main() {
+    std::cout << "Step 557: Exception + Stack Trace Capture\n";
+
+    test_valid_exception_capture_passes();       // 1
+    test_missing_type_rejected();                // 2
+    test_missing_message_rejected();             // 3
+    test_missing_thread_id_rejected();           // 4
+    test_missing_frames_rejected();              // 5
+    test_invalid_frame_function_rejected();      // 6
+    test_invalid_frame_file_rejected();          // 7
+    test_invalid_frame_line_rejected();          // 8
+    test_navigation_anchor_is_generated();       // 9
+    test_multiple_invalid_frames_reported();     // 10
+    test_event_fields_persist();                 // 11
+    test_single_valid_frame_is_sufficient();     // 12
+
+    std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n";
+    return failed == 0 ? 0 : 1;
+}