feat(tests): add opcode round-trip and value tests; update CMake configuration

Author: ProgrammerKR

BASELINE_REPORT.md

@@ -47,5 +47,10 @@ If you want, I can:
 - Write `ir/opcodes.md` and an initial `TICKET-001` draft in `tickets/`.
 - Create a minimal benchmark harness under `tools/bench/` to start profiling.
 
+Progress updates (2025-12-13)
+- Added GitHub Actions CI workflow and cross-platform scripts.
+- Created `tests/test_opcode_roundtrip.c` and `tests/test_opcode_values.c` and wired them into CMake.
+- Added a micro-benchmark `tools/bench/bench_simple.c` and CMake target.
+
 ---
 Generated by automation on behalf of the ProXPL modernization plan.

CMakeLists.txt

@@ -7,11 +7,21 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -g")
 # Include directories
 include_directories(include)
 
+# Source files
 # Source files
 file(GLOB_RECURSE SOURCES "src/*.c")
 
+# Core library (exposed to tests and tools)
+add_library(prox_core STATIC ${SOURCES})
+target_include_directories(prox_core PUBLIC ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/src)
+
 # Executable
-add_executable(prox ${SOURCES})
+add_executable(prox src/main.c)
+target_link_libraries(prox PRIVATE prox_core)
+
+# Optional targets: tools and tests
+add_subdirectory(tests)
+add_subdirectory(tools/bench)
 
 # Tests
 enable_testing()

tests/CMakeLists.txt

@@ -1,10 +1,18 @@
 cmake_minimum_required(VERSION 3.10)
 
-file(GLOB_RECURSE PROX_SRC "${CMAKE_SOURCE_DIR}/src/*.c")
-add_library(prox_core OBJECT ${PROX_SRC})
 
 add_executable(bytecode_tests bytecode_tests.c)
 target_link_libraries(bytecode_tests PRIVATE prox_core)
 target_include_directories(bytecode_tests PRIVATE ${CMAKE_SOURCE_DIR}/include)
 
 add_test(NAME BytecodeTests COMMAND bytecode_tests)
+
+add_executable(test_opcode_roundtrip test_opcode_roundtrip.c)
+target_link_libraries(test_opcode_roundtrip PRIVATE prox_core)
+target_include_directories(test_opcode_roundtrip PRIVATE ${CMAKE_SOURCE_DIR}/include)
+add_test(NAME OpcodeRoundTrip COMMAND test_opcode_roundtrip)
+
+add_executable(test_opcode_values test_opcode_values.c)
+target_link_libraries(test_opcode_values PRIVATE prox_core)
+target_include_directories(test_opcode_values PRIVATE ${CMAKE_SOURCE_DIR}/include)
+add_test(NAME OpcodeValues COMMAND test_opcode_values)

tests/test_opcode_roundtrip.c

@@ -0,0 +1,71 @@
+/* test_opcode_roundtrip.c
+ * Verifies that a chunk with opcodes and constants round-trips through
+ * write_chunk_to_file() and read_chunk_from_file() preserving bytes.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "bytecode.h"
+
+int main(void) {
+    const char *tmp = "tests/tmp_opcode_rt.proxbc";
+
+    Chunk c;
+    chunk_init(&c);
+
+    /* Add a couple constants */
+    Value v1; v1.type = VAL_NUMBER; v1.as.number = 3.14; consttable_add(&c.constants, v1);
+    Value v2; v2.type = VAL_STRING; v2.as.string.length = 5; v2.as.string.chars = strdup("hello"); consttable_add(&c.constants, v2);
+
+    /* Emit instructions */
+    emit_opcode(&c, OP_PUSH_CONST);
+    emit_uleb128(&c, 0);
+    emit_opcode(&c, OP_PUSH_CONST);
+    emit_uleb128(&c, 1);
+    emit_opcode(&c, OP_ADD);
+    emit_opcode(&c, OP_HALT);
+
+    if (write_chunk_to_file(tmp, &c) != 0) {
+        fprintf(stderr, "Failed to write chunk to %s\n", tmp);
+        chunk_free(&c);
+        return 2;
+    }
+
+    Chunk out;
+    if (read_chunk_from_file(tmp, &out) != 0) {
+        fprintf(stderr, "Failed to read chunk back\n");
+        chunk_free(&c);
+        return 3;
+    }
+
+    /* Compare code bytes */
+    if (out.code_len != c.code_len) {
+        fprintf(stderr, "Code length mismatch: %zu vs %zu\n", out.code_len, c.code_len);
+        chunk_free(&c); chunk_free(&out); return 4;
+    }
+    if (memcmp(out.code, c.code, c.code_len) != 0) {
+        fprintf(stderr, "Code bytes differ\n");
+        chunk_free(&c); chunk_free(&out); return 5;
+    }
+
+    /* Compare constants count and first values */
+    if (out.constants.count != c.constants.count) {
+        fprintf(stderr, "Const count mismatch: %zu vs %zu\n", out.constants.count, c.constants.count);
+        chunk_free(&c); chunk_free(&out); return 6;
+    }
+    if (out.constants.items[0].type != VAL_NUMBER) {
+        fprintf(stderr, "Const type mismatch for idx 0\n"); chunk_free(&c); chunk_free(&out); return 7;
+    }
+
+    /* Clean up */
+    chunk_free(&c);
+    chunk_free(&out);
+
+    /* Remove temporary file */
+    remove(tmp);
+
+    printf("test_opcode_roundtrip: OK\n");
+    return 0;
+}

tests/test_opcode_values.c

@@ -0,0 +1,17 @@
+/* test_opcode_values.c
+ * Verifies opcode enum numeric assignments match documented values
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "bytecode.h"
+
+int main(void) {
+    assert(OP_ADD == 0x01);
+    assert(OP_HALT == 0xFF);
+    assert(OP_PUSH_CONST == 0x30);
+    assert(OP_CALL == 0x50);
+    printf("test_opcode_values: OK\n");
+    return 0;
+}

tools/bench/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.10)
+
+# Build bench_simple
+add_executable(bench_simple bench_simple.c)
+target_include_directories(bench_simple PRIVATE ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(bench_simple PRIVATE prox_core)
+
+add_custom_target(run_bench_simple
+    COMMAND bench_simple
+    DEPENDS bench_simple
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+)

tools/bench/README.md

@@ -0,0 +1,19 @@
+# Bench Simple
+
+This microbenchmark builds a CPU-bound chunk and runs it repeatedly against the VM to measure throughput.
+
+Build and Run
+-------------
+1. Configure the project with CMake (from project root):
+
+```bash
+mkdir build && cd build
+cmake .. -DCMAKE_BUILD_TYPE=Release
+cmake --build . --target bench_simple
+```
+
+2. Run the benchmark:
+
+```bash
+./bench_simple
+```