feat: C

generator/c_test.go

@@ -0,0 +1,802 @@
+package generator
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/edmand46/arpack/parser"
+)
+
+func TestCSnakeCase(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"", ""},
+		{"Simple", "simple"},
+		{"PlayerID", "player_id"},
+		{"HTTPRequest", "http_request"},
+		{"XMLParser", "xml_parser"},
+		{"MoveMessage", "move_message"},
+		{"position", "position"},
+		{"X", "x"},
+		{"HTTPServer", "http_server"},
+		{"URLHandler", "url_handler"},
+	}
+
+	for _, tc := range tests {
+		result := snakeCase(tc.input)
+		if result != tc.expected {
+			t.Errorf("snakeCase(%q) = %q, want %q", tc.input, result, tc.expected)
+		}
+	}
+}
+
+func TestCGenerateSchema_BasicTypes(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "BasicTypes",
+				Fields: []parser.Field{
+					{Name: "Int8Field", Kind: parser.KindPrimitive, Primitive: parser.KindInt8},
+					{Name: "Int16Field", Kind: parser.KindPrimitive, Primitive: parser.KindInt16},
+					{Name: "Int32Field", Kind: parser.KindPrimitive, Primitive: parser.KindInt32},
+					{Name: "Int64Field", Kind: parser.KindPrimitive, Primitive: parser.KindInt64},
+					{Name: "Uint8Field", Kind: parser.KindPrimitive, Primitive: parser.KindUint8},
+					{Name: "Uint16Field", Kind: parser.KindPrimitive, Primitive: parser.KindUint16},
+					{Name: "Uint32Field", Kind: parser.KindPrimitive, Primitive: parser.KindUint32},
+					{Name: "Uint64Field", Kind: parser.KindPrimitive, Primitive: parser.KindUint64},
+					{Name: "Float32Field", Kind: parser.KindPrimitive, Primitive: parser.KindFloat32},
+					{Name: "Float64Field", Kind: parser.KindPrimitive, Primitive: parser.KindFloat64},
+					{Name: "BoolField", Kind: parser.KindPrimitive, Primitive: parser.KindBool},
+					{Name: "StringField", Kind: parser.KindPrimitive, Primitive: parser.KindString},
+				},
+			},
+		},
+	}
+
+	header, _, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+
+	// Check struct declaration
+	if !strings.Contains(headerStr, "typedef struct test_basic_types {") {
+		t.Error("Missing test_basic_types struct declaration")
+	}
+
+	// Check primitive field types
+	if !strings.Contains(headerStr, "int8_t int8_field;") {
+		t.Error("Missing int8_field")
+	}
+	if !strings.Contains(headerStr, "int16_t int16_field;") {
+		t.Error("Missing int16_field")
+	}
+	if !strings.Contains(headerStr, "int32_t int32_field;") {
+		t.Error("Missing int32_field")
+	}
+	if !strings.Contains(headerStr, "int64_t int64_field;") {
+		t.Error("Missing int64_field")
+	}
+	if !strings.Contains(headerStr, "uint8_t uint8_field;") {
+		t.Error("Missing uint8_field")
+	}
+	if !strings.Contains(headerStr, "uint16_t uint16_field;") {
+		t.Error("Missing uint16_field")
+	}
+	if !strings.Contains(headerStr, "uint32_t uint32_field;") {
+		t.Error("Missing uint32_field")
+	}
+	if !strings.Contains(headerStr, "uint64_t uint64_field;") {
+		t.Error("Missing uint64_field")
+	}
+	if !strings.Contains(headerStr, "float float32_field;") {
+		t.Error("Missing float32_field")
+	}
+	if !strings.Contains(headerStr, "double float64_field;") {
+		t.Error("Missing float64_field")
+	}
+	if !strings.Contains(headerStr, "bool bool_field;") {
+		t.Error("Missing bool_field")
+	}
+	if !strings.Contains(headerStr, "arpack_string_view string_field;") {
+		t.Error("Missing string_field")
+	}
+}
+
+func TestCGenerateSchema_Enum(t *testing.T) {
+	schema := parser.Schema{
+		Enums: []parser.Enum{
+			{
+				Name:      "Opcode",
+				Primitive: parser.KindUint16,
+				Values: []parser.EnumValue{
+					{Name: "Unknown", Value: "0"},
+					{Name: "Join", Value: "1"},
+					{Name: "Leave", Value: "2"},
+				},
+			},
+		},
+		Messages: []parser.Message{
+			{
+				Name: "MessageWithEnum",
+				Fields: []parser.Field{
+					{Name: "Op", Kind: parser.KindPrimitive, Primitive: parser.KindUint16, NamedType: "Opcode"},
+				},
+			},
+		},
+	}
+
+	header, _, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+
+	// Check enum declaration
+	if !strings.Contains(headerStr, "typedef enum test_opcode {") {
+		t.Error("Missing test_opcode enum declaration")
+	}
+	if !strings.Contains(headerStr, "test_opcode_unknown = 0,") {
+		t.Error("Missing Unknown enum value")
+	}
+	if !strings.Contains(headerStr, "test_opcode_join = 1,") {
+		t.Error("Missing Join enum value")
+	}
+	if !strings.Contains(headerStr, "test_opcode_leave = 2,") {
+		t.Error("Missing Leave enum value")
+	}
+	if !strings.Contains(headerStr, "test_opcode op;") {
+		t.Error("Enum-backed field should use generated enum type")
+	}
+}
+
+func TestCGenerateSchema_HeaderGuard(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{Name: "Simple", Fields: []parser.Field{}},
+		},
+	}
+
+	header, _, err := GenerateCSchema(schema, "my_base")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+
+	if !strings.Contains(headerStr, "#ifndef MY_BASE_GEN_H") {
+		t.Error("Missing header guard ifndef")
+	}
+	if !strings.Contains(headerStr, "#define MY_BASE_GEN_H") {
+		t.Error("Missing header guard define")
+	}
+	if !strings.Contains(headerStr, "#endif // MY_BASE_GEN_H") {
+		t.Error("Missing header guard endif")
+	}
+}
+
+func TestCGenerateSchema_RuntimeTypes(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{Name: "Simple", Fields: []parser.Field{}},
+		},
+	}
+
+	header, _, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+
+	// Check arpack_status enum
+	if !strings.Contains(headerStr, "typedef enum arpack_status {") {
+		t.Error("Missing arpack_status enum")
+	}
+	if !strings.Contains(headerStr, "ARPACK_OK = 0,") {
+		t.Error("Missing ARPACK_OK")
+	}
+
+	// Check string view
+	if !strings.Contains(headerStr, "typedef struct arpack_string_view {") {
+		t.Error("Missing arpack_string_view")
+	}
+
+	// Check bytes view
+	if !strings.Contains(headerStr, "typedef struct arpack_bytes_view {") {
+		t.Error("Missing arpack_bytes_view")
+	}
+
+	// Check standard includes
+	if !strings.Contains(headerStr, "#include <stdint.h>") {
+		t.Error("Missing stdint.h include")
+	}
+	if !strings.Contains(headerStr, "#include <stddef.h>") {
+		t.Error("Missing stddef.h include")
+	}
+	if !strings.Contains(headerStr, "#include <stdbool.h>") {
+		t.Error("Missing stdbool.h include")
+	}
+}
+
+func TestCGenerateSchema_NestedMessages(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "Inner",
+				Fields: []parser.Field{
+					{Name: "Value", Kind: parser.KindPrimitive, Primitive: parser.KindInt32},
+				},
+			},
+			{
+				Name: "Outer",
+				Fields: []parser.Field{
+					{Name: "InnerMsg", Kind: parser.KindNested, TypeName: "Inner"},
+				},
+			},
+		},
+	}
+
+	header, _, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+
+	// Check inner struct
+	if !strings.Contains(headerStr, "typedef struct test_inner {") {
+		t.Error("Missing test_inner struct")
+	}
+
+	// Check outer struct with nested field
+	if !strings.Contains(headerStr, "test_inner inner_msg;") {
+		t.Error("Missing nested inner_msg field")
+	}
+}
+
+func TestCGenerateSchema_FixedArrays(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "ArrayMessage",
+				Fields: []parser.Field{
+					{
+						Name:     "Values",
+						Kind:     parser.KindFixedArray,
+						FixedLen: 3,
+						Elem: &parser.Field{
+							Kind:      parser.KindPrimitive,
+							Primitive: parser.KindFloat32,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	header, _, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+
+	if !strings.Contains(headerStr, "float values[3];") {
+		t.Error("Missing fixed array field")
+	}
+}
+
+func TestCGenerateSchema_BoolPacking(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "BoolMessage",
+				Fields: []parser.Field{
+					{Name: "Active", Kind: parser.KindPrimitive, Primitive: parser.KindBool},
+					{Name: "Visible", Kind: parser.KindPrimitive, Primitive: parser.KindBool},
+					{Name: "Ghost", Kind: parser.KindPrimitive, Primitive: parser.KindBool},
+					{Name: "Count", Kind: parser.KindPrimitive, Primitive: parser.KindInt32},
+				},
+			},
+		},
+	}
+
+	header, source, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+	sourceStr := string(source)
+
+	// Check struct fields
+	if !strings.Contains(headerStr, "bool active;") {
+		t.Error("Missing active field")
+	}
+	if !strings.Contains(headerStr, "bool visible;") {
+		t.Error("Missing visible field")
+	}
+
+	// Check encode uses bool packing
+	if !strings.Contains(sourceStr, "_boolByte") {
+		t.Error("Bool packing not used in encode")
+	}
+	if !strings.Contains(sourceStr, "_arpack_write_u8(buf, &offset, _boolByte);") {
+		t.Error("Bool byte not written")
+	}
+}
+
+func TestCGenerateSchema_QuantizedFloats(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "QuantMessage",
+				Fields: []parser.Field{
+					{
+						Name:      "Q8",
+						Kind:      parser.KindPrimitive,
+						Primitive: parser.KindFloat32,
+						Quant:     &parser.QuantInfo{Min: 0, Max: 100, Bits: 8},
+					},
+					{
+						Name:      "Q16",
+						Kind:      parser.KindPrimitive,
+						Primitive: parser.KindFloat32,
+						Quant:     &parser.QuantInfo{Min: -500, Max: 500, Bits: 16},
+					},
+				},
+			},
+		},
+	}
+
+	_, source, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	sourceStr := string(source)
+
+	// Check 8-bit quantization (uses 255 as max value)
+	if !strings.Contains(sourceStr, "255") {
+		t.Error("Missing 8-bit quantization")
+	}
+
+	// Check 16-bit quantization (uses 65535 as max value)
+	if !strings.Contains(sourceStr, "65535") {
+		t.Error("Missing 16-bit quantization")
+	}
+
+	// Check encode uses quantization
+	if !strings.Contains(sourceStr, "_arpack_write_u8(buf, &offset, _qv)") {
+		t.Error("8-bit quantized value not written")
+	}
+	if !strings.Contains(sourceStr, "_arpack_write_u16_le(buf, &offset, _qv)") {
+		t.Error("16-bit quantized value not written")
+	}
+}
+
+func TestCGenerateSchema_VariableLength(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "VarMessage",
+				Fields: []parser.Field{
+					{Name: "Id", Kind: parser.KindPrimitive, Primitive: parser.KindUint32},
+					{Name: "Name", Kind: parser.KindPrimitive, Primitive: parser.KindString},
+					{
+						Name: "Data",
+						Kind: parser.KindSlice,
+						Elem: &parser.Field{
+							Kind:      parser.KindPrimitive,
+							Primitive: parser.KindUint8,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	header, _, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+
+	// Check min_size function exists
+	if !strings.Contains(headerStr, "size_t test_var_message_min_size(void);") {
+		t.Error("Missing min_size function declaration")
+	}
+
+	// Check size function exists
+	if !strings.Contains(headerStr, "arpack_status test_var_message_size(const test_var_message *msg, size_t *out_size);") {
+		t.Error("Missing size function declaration")
+	}
+
+	// Check encode function exists
+	if !strings.Contains(headerStr, "arpack_status test_var_message_encode(const test_var_message *msg, uint8_t *buf, size_t buf_len, size_t *out_written);") {
+		t.Error("Missing encode function declaration")
+	}
+
+	// Check decode function exists without context (only byte slices and strings)
+	if !strings.Contains(headerStr, "arpack_status test_var_message_decode(test_var_message *msg, const uint8_t *buf, size_t buf_len, size_t *out_read);") {
+		t.Error("Missing decode function declaration")
+	}
+}
+
+func TestCCompile_SampleSchema(t *testing.T) {
+	hasCC := false
+	if _, err := exec.LookPath("cc"); err == nil {
+		hasCC = true
+	} else if _, err := exec.LookPath("gcc"); err == nil {
+		hasCC = true
+	} else if _, err := exec.LookPath("clang"); err == nil {
+		hasCC = true
+	}
+
+	if !hasCC {
+		t.Skip("No C compiler found (tried cc, gcc, clang)")
+	}
+
+	schema, err := parser.ParseSchemaFile("../testdata/sample.go")
+	if err != nil {
+		t.Fatalf("Failed to parse sample.go: %v", err)
+	}
+
+	// Generate C code
+	header, source, err := GenerateCSchema(schema, "sample")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	// Create temp directory
+	tmpDir := t.TempDir()
+
+	// Write header
+	headerPath := filepath.Join(tmpDir, "sample.gen.h")
+	if err := os.WriteFile(headerPath, header, 0644); err != nil {
+		t.Fatalf("Failed to write header: %v", err)
+	}
+
+	// Write source
+	sourcePath := filepath.Join(tmpDir, "sample.gen.c")
+	if err := os.WriteFile(sourcePath, source, 0644); err != nil {
+		t.Fatalf("Failed to write source: %v", err)
+	}
+
+	// Compile
+	objPath := filepath.Join(tmpDir, "sample.gen.o")
+	cmd := exec.Command("cc", "-std=c11", "-Wall", "-Wextra", "-Wno-unused-function", "-c", sourcePath, "-o", objPath)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("C compilation failed:\n%s\n%s", string(output), err)
+	}
+
+	// Verify object file exists
+	if _, err := os.Stat(objPath); os.IsNotExist(err) {
+		t.Fatal("Object file was not created")
+	}
+}
+
+func TestCGenerateSchema_DecodeContext(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "Inner",
+				Fields: []parser.Field{
+					{Name: "Value", Kind: parser.KindPrimitive, Primitive: parser.KindInt32},
+				},
+			},
+			{
+				Name: "CtxMessage",
+				Fields: []parser.Field{
+					{
+						Name: "Items",
+						Kind: parser.KindSlice,
+						Elem: &parser.Field{
+							Kind:     parser.KindNested,
+							TypeName: "Inner",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	header, _, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+
+	// Check decode context struct exists
+	if !strings.Contains(headerStr, "typedef struct test_ctx_message_decode_ctx {") {
+		t.Error("Missing decode context struct")
+	}
+
+	// Check data pointer in context
+	if !strings.Contains(headerStr, "test_inner *items_data;") {
+		t.Error("Missing items_data field in context")
+	}
+
+	// Check capacity field in context
+	if !strings.Contains(headerStr, "uint16_t items_cap;") {
+		t.Error("Missing items_cap field in context")
+	}
+
+	// Check decode function with context
+	if !strings.Contains(headerStr, "arpack_status test_ctx_message_decode(test_ctx_message *msg, const uint8_t *buf, size_t buf_len, test_ctx_message_decode_ctx *ctx, size_t *out_read);") {
+		t.Error("Missing decode function with context")
+	}
+}
+
+func TestCGenerateSchema_PrimitiveSlices(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "SliceMessage",
+				Fields: []parser.Field{
+					{
+						Name: "Values",
+						Kind: parser.KindSlice,
+						Elem: &parser.Field{
+							Kind:      parser.KindPrimitive,
+							Primitive: parser.KindUint16,
+						},
+					},
+					{
+						Name: "Floats",
+						Kind: parser.KindSlice,
+						Elem: &parser.Field{
+							Kind:      parser.KindPrimitive,
+							Primitive: parser.KindFloat32,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	header, source, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	headerStr := string(header)
+	if !strings.Contains(headerStr, "typedef struct test_uint16_slice_view {") {
+		t.Fatal("Missing uint16 slice view typedef")
+	}
+	if !strings.Contains(headerStr, "const uint16_t *data;") {
+		t.Fatal("uint16 slice view should reference uint16_t")
+	}
+	if !strings.Contains(headerStr, "typedef struct test_float32_slice_view {") {
+		t.Fatal("Missing float32 slice view typedef")
+	}
+	if !strings.Contains(headerStr, "const float *data;") {
+		t.Fatal("float32 slice view should reference float")
+	}
+	if !strings.Contains(headerStr, "uint16_t *values_data;") {
+		t.Fatal("Missing decode context storage for uint16 slice")
+	}
+	if !strings.Contains(headerStr, "float *floats_data;") {
+		t.Fatal("Missing decode context storage for float32 slice")
+	}
+
+	compileCGeneratedObject(t, "test", header, source)
+}
+
+func TestCGenerateSchema_FixedArrayNestedAndQuantized(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "Vector3",
+				Fields: []parser.Field{
+					{
+						Name:      "X",
+						Kind:      parser.KindPrimitive,
+						Primitive: parser.KindFloat32,
+						Quant:     &parser.QuantInfo{Min: -500, Max: 500, Bits: 16},
+					},
+				},
+			},
+			{
+				Name: "ArrayMessage",
+				Fields: []parser.Field{
+					{
+						Name:     "Points",
+						Kind:     parser.KindFixedArray,
+						FixedLen: 2,
+						Elem: &parser.Field{
+							Kind:     parser.KindNested,
+							TypeName: "Vector3",
+						},
+					},
+					{
+						Name:     "Samples",
+						Kind:     parser.KindFixedArray,
+						FixedLen: 3,
+						Elem: &parser.Field{
+							Kind:      parser.KindPrimitive,
+							Primitive: parser.KindFloat32,
+							Quant:     &parser.QuantInfo{Min: 0, Max: 10, Bits: 8},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	header, source, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	sourceStr := string(source)
+	if !strings.Contains(sourceStr, "test_vector3_encode(&msg->points[_i0],") {
+		t.Fatal("Nested fixed array elements should call nested encode")
+	}
+	if !strings.Contains(sourceStr, "msg->samples[_i0]") {
+		t.Fatal("Quantized fixed array elements should be encoded through recursive element access")
+	}
+
+	compileCGeneratedObject(t, "test", header, source)
+}
+
+func TestCVariableLength_BoundsChecks(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "StringMessage",
+				Fields: []parser.Field{
+					{Name: "Name", Kind: parser.KindPrimitive, Primitive: parser.KindString},
+				},
+			},
+		},
+	}
+
+	header, source, err := GenerateCSchema(schema, "test")
+	if err != nil {
+		t.Fatalf("GenerateCSchema failed: %v", err)
+	}
+
+	harness := `#include <stdio.h>
+#include "test.gen.h"
+
+int main(void) {
+    static const uint8_t truncated[] = {0x03, 0x00, 'a'};
+    test_string_message decoded;
+    size_t read = 0;
+    arpack_status status = test_string_message_decode(&decoded, truncated, sizeof(truncated), &read);
+    printf("DECODE=%d\n", (int)status);
+
+    test_string_message encoded;
+    encoded.name.data = "abc";
+    encoded.name.len = 3;
+    uint8_t out[2];
+    size_t written = 0;
+    status = test_string_message_encode(&encoded, out, sizeof(out), &written);
+    printf("ENCODE=%d\n", (int)status);
+    return 0;
+}
+`
+
+	output := runGeneratedCProgram(t, "test", header, source, harness)
+	if !strings.Contains(output, "DECODE=1") {
+		t.Fatalf("decode should fail with ARPACK_ERR_BUFFER_TOO_SHORT, got:\n%s", output)
+	}
+	if !strings.Contains(output, "ENCODE=1") {
+		t.Fatalf("encode should fail with ARPACK_ERR_BUFFER_TOO_SHORT, got:\n%s", output)
+	}
+}
+
+func TestCGenerateSchema_RejectsFixedArrayOfSlices(t *testing.T) {
+	schema := parser.Schema{
+		Messages: []parser.Message{
+			{
+				Name: "BadMessage",
+				Fields: []parser.Field{
+					{
+						Name:     "Values",
+						Kind:     parser.KindFixedArray,
+						FixedLen: 2,
+						Elem: &parser.Field{
+							Kind: parser.KindSlice,
+							Elem: &parser.Field{
+								Kind:      parser.KindPrimitive,
+								Primitive: parser.KindUint16,
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	_, _, err := GenerateCSchema(schema, "test")
+	if err == nil {
+		t.Fatal("expected GenerateCSchema to reject fixed arrays of slices")
+	}
+	if !strings.Contains(err.Error(), "fixed arrays of slices") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func requireCCompiler(t *testing.T) string {
+	t.Helper()
+
+	for _, compiler := range []string{"cc", "gcc", "clang"} {
+		if _, err := exec.LookPath(compiler); err == nil {
+			return compiler
+		}
+	}
+
+	t.Skip("No C compiler found (tried cc, gcc, clang)")
+	return ""
+}
+
+func compileCGeneratedObject(t *testing.T, base string, header []byte, source []byte) {
+	t.Helper()
+
+	cc := requireCCompiler(t)
+	tmpDir := t.TempDir()
+	headerPath := filepath.Join(tmpDir, base+".gen.h")
+	sourcePath := filepath.Join(tmpDir, base+".gen.c")
+	objPath := filepath.Join(tmpDir, base+".gen.o")
+
+	if err := os.WriteFile(headerPath, header, 0644); err != nil {
+		t.Fatalf("Failed to write header: %v", err)
+	}
+	if err := os.WriteFile(sourcePath, source, 0644); err != nil {
+		t.Fatalf("Failed to write source: %v", err)
+	}
+
+	cmd := exec.Command(cc, "-std=c11", "-Wall", "-Wextra", "-Wno-unused-function", "-c", sourcePath, "-o", objPath)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("C compilation failed:\n%s\n%s", string(output), err)
+	}
+}
+
+func runGeneratedCProgram(t *testing.T, base string, header []byte, source []byte, harness string) string {
+	t.Helper()
+
+	cc := requireCCompiler(t)
+	tmpDir := t.TempDir()
+	headerPath := filepath.Join(tmpDir, base+".gen.h")
+	sourcePath := filepath.Join(tmpDir, base+".gen.c")
+	testPath := filepath.Join(tmpDir, "test.c")
+	binPath := filepath.Join(tmpDir, "test")
+
+	if err := os.WriteFile(headerPath, header, 0644); err != nil {
+		t.Fatalf("Failed to write header: %v", err)
+	}
+	if err := os.WriteFile(sourcePath, source, 0644); err != nil {
+		t.Fatalf("Failed to write source: %v", err)
+	}
+	if err := os.WriteFile(testPath, []byte(harness), 0644); err != nil {
+		t.Fatalf("Failed to write harness: %v", err)
+	}
+
+	cmd := exec.Command(cc, "-std=c11", "-Wall", "-Wextra", "-Wno-unused-function", "-o", binPath, testPath, sourcePath)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("C compilation failed:\n%s\n%s", string(output), err)
+	}
+
+	runCmd := exec.Command(binPath)
+	runCmd.Dir = tmpDir
+	output, err = runCmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("C program failed:\n%s\n%s", string(output), err)
+	}
+	return string(output)
+}