Create Ot_test · cpp

Ot_test · cpp

@@ -0,0 +1,343 @@
+/*
+ * CollabDocs C++ — OT Engine Test Suite
+ *
+ * Tests all 4 transform cases + convergence + log-transform.
+ * No external test framework needed — pure C++17.
+ */
+
+#include "ot_engine.hpp"
+#include <iostream>
+#include <cassert>
+#include <cstring>
+#include <random>
+#include <string>
+
+using namespace collab;
+
+// ─── Mini test framework ─────────────────────────────────────────────────────
+
+static int g_pass = 0, g_fail = 0;
+
+#define EXPECT_EQ(a, b) do { \
+    if ((a) == (b)) { g_pass++; } \
+    else { g_fail++; \
+        std::cerr << "FAIL " << __FILE__ << ":" << __LINE__ \
+                  << "  expected=" << (b) << "  got=" << (a) << "\n"; } \
+} while(0)
+
+#define EXPECT_STR_EQ(a, b) do { \
+    if (std::string(a) == std::string(b)) { g_pass++; } \
+    else { g_fail++; \
+        std::cerr << "FAIL " << __FILE__ << ":" << __LINE__ \
+                  << "\n  expected: " << (b) \
+                  << "\n  got:      " << (a) << "\n"; } \
+} while(0)
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+Operation ins(int pos, const std::string& val,
+              const std::string& uid = "", int base = 0) {
+    Operation op;
+    op.type = OpType::INSERT;
+    op.position = pos;
+    op.value = val;
+    op.length = static_cast<int>(val.size());
+    op.user_id = uid;
+    op.base_version = base;
+    return op;
+}
+
+Operation del(int pos, int len,
+              const std::string& uid = "", int base = 0) {
+    Operation op;
+    op.type = OpType::DELETE;
+    op.position = pos;
+    op.length = len;
+    op.user_id = uid;
+    op.base_version = base;
+    return op;
+}
+
+// ─── Insert-Insert ────────────────────────────────────────────────────────────
+
+void test_ii_before() {
+    auto r = transform_operation(ins(5,"X"), ins(2,"AB"));
+    EXPECT_EQ(r.position, 7);
+}
+
+void test_ii_after() {
+    auto r = transform_operation(ins(2,"X"), ins(5,"AB"));
+    EXPECT_EQ(r.position, 2);
+}
+
+void test_ii_same_tiebreak_shift() {
+    // alice < bob → alice wins → bob shifts
+    auto r = transform_operation(ins(3,"X","bob"), ins(3,"Y","alice"));
+    EXPECT_EQ(r.position, 4);
+}
+
+void test_ii_same_tiebreak_no_shift() {
+    auto r = transform_operation(ins(3,"X","alice"), ins(3,"Y","bob"));
+    EXPECT_EQ(r.position, 3);
+}
+
+// ─── Delete-Insert ────────────────────────────────────────────────────────────
+
+void test_di_insert_before_delete() {
+    auto r = transform_operation(del(5,3), ins(2,"XX"));
+    EXPECT_EQ(r.position, 7);
+    EXPECT_EQ(r.length, 3);
+}
+
+void test_di_insert_inside_delete() {
+    auto r = transform_operation(del(3,5), ins(5,"AB"));
+    EXPECT_EQ(r.position, 3);
+    EXPECT_EQ(r.length, 7); // expanded
+}
+
+void test_di_insert_after_delete() {
+    auto r = transform_operation(del(3,4), ins(10,"AB"));
+    EXPECT_EQ(r.position, 3);
+    EXPECT_EQ(r.length, 4);
+}
+
+// ─── Insert-Delete ────────────────────────────────────────────────────────────
+
+void test_id_delete_before_insert() {
+    auto r = transform_operation(ins(8,"X"), del(2,3));
+    EXPECT_EQ(r.position, 5);
+}
+
+void test_id_delete_contains_insert() {
+    auto r = transform_operation(ins(5,"X"), del(3,5));
+    EXPECT_EQ(r.position, 3);
+}
+
+void test_id_delete_after_insert() {
+    auto r = transform_operation(ins(2,"X"), del(5,3));
+    EXPECT_EQ(r.position, 2);
+}
+
+// ─── Delete-Delete ────────────────────────────────────────────────────────────
+
+void test_dd_applied_before() {
+    auto r = transform_operation(del(8,4), del(2,3));
+    EXPECT_EQ(r.position, 5);
+    EXPECT_EQ(r.length, 4);
+}
+
+void test_dd_applied_after() {
+    auto r = transform_operation(del(2,3), del(8,4));
+    EXPECT_EQ(r.position, 2);
+    EXPECT_EQ(r.length, 3);
+}
+
+void test_dd_overlap_right() {
+    // incoming [3,7), applied [5,9): overlap [5,7)=2
+    auto r = transform_operation(del(3,4), del(5,4));
+    EXPECT_EQ(r.position, 3);
+    EXPECT_EQ(r.length, 2);
+}
+
+void test_dd_overlap_left() {
+    // incoming [5,9), applied [2,7): overlap [5,7)=2
+    auto r = transform_operation(del(5,4), del(2,5));
+    EXPECT_EQ(r.position, 2);
+    EXPECT_EQ(r.length, 2);
+}
+
+void test_dd_applied_contains_incoming() {
+    auto r = transform_operation(del(4,2), del(2,8));
+    EXPECT_EQ(r.length, 0);
+}
+
+void test_dd_identical() {
+    auto r = transform_operation(del(3,4,"b"), del(3,4,"a"));
+    EXPECT_EQ(r.length, 0);
+}
+
+// ─── Convergence ─────────────────────────────────────────────────────────────
+
+void test_convergence_ii() {
+    std::string doc = "hello world";
+    auto op1 = ins(5,"_A_","u1");
+    auto op2 = ins(5,"_B_","u2");
+
+    auto d1 = apply_operation(doc, op1);
+    d1 = apply_operation(d1, transform_operation(op2, op1));
+
+    auto d2 = apply_operation(doc, op2);
+    d2 = apply_operation(d2, transform_operation(op1, op2));
+
+    EXPECT_STR_EQ(d1, d2);
+}
+
+void test_convergence_dd() {
+    std::string doc = "abcdefghij";
+    auto op1 = del(2,5,"u1");
+    auto op2 = del(4,4,"u2");
+
+    auto d1 = apply_operation(doc, op1);
+    d1 = apply_operation(d1, transform_operation(op2, op1));
+
+    auto d2 = apply_operation(doc, op2);
+    d2 = apply_operation(d2, transform_operation(op1, op2));
+
+    EXPECT_STR_EQ(d1, d2);
+}
+
+void test_transform_against_log() {
+    std::string doc = "hello world";
+    Operation srv1 = ins(0,">> ","s",0);
+    Operation srv2 = del(9,3,"s",1);
+
+    std::vector<std::pair<int,Operation>> log = {{1,srv1},{2,srv2}};
+
+    Operation client_op = ins(5,"X","c",0);
+    auto result = transform_against_log(client_op, log, 0, 2);
+
+    // Manual:
+    // After srv1 (ins 3 chars at 0): pos 5 → 8
+    auto after1 = transform_operation(client_op, srv1);
+    // After srv2 (del 3 at 9): pos 8 < 9 → no change
+    auto after2 = transform_operation(after1, srv2);
+
+    EXPECT_EQ(result.position, after2.position);
+}
+
+// ─── Apply tests ──────────────────────────────────────────────────────────────
+
+void test_apply_insert() {
+    EXPECT_STR_EQ(apply_operation("abcde", ins(2,"XY")), "abXYcde");
+}
+
+void test_apply_delete() {
+    EXPECT_STR_EQ(apply_operation("abcde", del(1,3)), "ae");
+}
+
+void test_apply_insert_end() {
+    EXPECT_STR_EQ(apply_operation("abc", ins(3,"Z")), "abcZ");
+}
+
+void test_apply_delete_out_of_range() {
+    EXPECT_STR_EQ(apply_operation("abc", del(2,100)), "ab");
+}
+
+// ─── Cursor sync ──────────────────────────────────────────────────────────────
+
+void test_cursor_insert_before() {
+    auto c = transform_cursor(8, ins(3,"AB"));
+    EXPECT_EQ(c, 10);
+}
+
+void test_cursor_insert_after() {
+    auto c = transform_cursor(2, ins(5,"AB"));
+    EXPECT_EQ(c, 2);
+}
+
+void test_cursor_delete_before() {
+    auto c = transform_cursor(8, del(2,3));
+    EXPECT_EQ(c, 5);
+}
+
+void test_cursor_delete_over() {
+    auto c = transform_cursor(4, del(2,5));
+    EXPECT_EQ(c, 2);
+}
+
+// ─── Stress convergence ───────────────────────────────────────────────────────
+
+void stress_convergence(int trials = 500) {
+    std::mt19937 rng(42);
+    const std::string alphabet = "abcdefghijklmnopqrstuvwxyz ";
+    int failures = 0;
+
+    auto rand_op = [&](const std::string& content, const std::string& uid) {
+        if (content.empty() || std::uniform_real_distribution<>()(rng) < 0.55) {
+            int pos = std::uniform_int_distribution<>(0, static_cast<int>(content.size()))(rng);
+            char c = alphabet[std::uniform_int_distribution<>(0,static_cast<int>(alphabet.size())-1)(rng)];
+            return ins(pos, std::string(1,c), uid);
+        } else {
+            int pos = std::uniform_int_distribution<>(0, static_cast<int>(content.size())-1)(rng);
+            int len = std::uniform_int_distribution<>(1, std::min(3, static_cast<int>(content.size())-pos))(rng);
+            return del(pos, len, uid);
+        }
+    };
+
+    std::string initial = "The quick brown fox jumps.";
+    for (int t = 0; t < trials; ++t) {
+        std::string doc = initial;
+        auto op1 = rand_op(doc, "u1");
+        auto op2 = rand_op(doc, "u2");
+
+        auto d1 = apply_operation(doc, op1);
+        d1 = apply_operation(d1, transform_operation(op2, op1));
+
+        auto d2 = apply_operation(doc, op2);
+        d2 = apply_operation(d2, transform_operation(op1, op2));
+
+        if (d1 != d2) failures++;
+    }
+
+    if (failures > 0) {
+        g_fail++;
+        std::cerr << "FAIL stress_convergence: " << failures << "/" << trials << " diverged\n";
+    } else {
+        g_pass++;
+        std::cout << "  stress_convergence: " << trials << " trials OK\n";
+    }
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+int main() {
+    std::cout << "=== CollabDocs C++ OT Test Suite ===\n\n";
+
+    // Insert-Insert
+    test_ii_before();
+    test_ii_after();
+    test_ii_same_tiebreak_shift();
+    test_ii_same_tiebreak_no_shift();
+
+    // Delete-Insert
+    test_di_insert_before_delete();
+    test_di_insert_inside_delete();
+    test_di_insert_after_delete();
+
+    // Insert-Delete
+    test_id_delete_before_insert();
+    test_id_delete_contains_insert();
+    test_id_delete_after_insert();
+
+    // Delete-Delete
+    test_dd_applied_before();
+    test_dd_applied_after();
+    test_dd_overlap_right();
+    test_dd_overlap_left();
+    test_dd_applied_contains_incoming();
+    test_dd_identical();
+
+    // Convergence
+    test_convergence_ii();
+    test_convergence_dd();
+    test_transform_against_log();
+
+    // Apply
+    test_apply_insert();
+    test_apply_delete();
+    test_apply_insert_end();
+    test_apply_delete_out_of_range();
+
+    // Cursor
+    test_cursor_insert_before();
+    test_cursor_insert_after();
+    test_cursor_delete_before();
+    test_cursor_delete_over();
+
+    // Stress
+    stress_convergence(500);
+
+    std::cout << "\n=== Results: "
+              << g_pass << " passed, " << g_fail << " failed ===\n";
+    return g_fail > 0 ? 1 : 0;
+}