let ast = parse_string code in

(* Create symbol table with test builtin types *)

let symbol_table = Test_utils.Helpers.create_test_symbol_table ast in

(* Run type checking with builtin types loaded *)

let (typed_ast, _) = Kernelscript.Type_checker.type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in

try

let _ = Str.search_forward (Str.regexp_string substr) str 0 in

true

let test_cases = [

(* Basic Hash *)

("var test_map : hash<u32, u64>(1024)", true);

(* Array map *)

("var array_map : array<u32, u32>(512)", true);

(* Percpu_hash *)

("var percpu_map : percpu_hash<u64, u64>(256)", true);

(* Invalid syntax - wrong order *)

("var bad_map : hash<u32, u64>(1024)", true);

(* Invalid syntax - missing max_entries *)

("var default_map : hash<u32, u64>()", false);

(* Old syntax with blocks - should fail *)

("var old_map : hash<u32, u64>(1024) { }", false);

] in

List.iter (fun (code, should_succeed) ->

try

let program = Printf.sprintf "%s\n@xdp fn test() -> u32 { return 0 }" code in

let _ = parse_string program in

check bool ("parsing: " ^ code) should_succeed true

with

| _ ->

check bool ("parsing: " ^ code) should_succeed false

let test_cases = [

(* Basic block-less Hash *)

("var simple_map : hash<u32, u64>(1024)", true);

(* Block-less Array *)

("var array_map : array<u32, u32>(512)", true);

(* Block-less Percpu_hash *)

("var percpu_map : percpu_hash<u64, u64>(256)", true);

(* Block-less Lru_hash *)

("var lru_map : lru_hash<u32, u64>(128)", true);

(* Pinned map *)

("pin var pinned_map : hash<u32, u64>(1024)", true);

(* Map with flags *)

("@flags(no_prealloc) var flags_map : hash<u32, u64>(1024)", true);

(* Combined pin and flags *)

("@flags(rdonly) pin var combined_map : hash<u32, u64>(1024)", true);

(* Invalid - old syntax with blocks *)

("var invalid_map : hash<u32, u64>(1024) { }", false);

] in

List.iter (fun (code, should_succeed) ->

try

let program = Printf.sprintf "%s\n@xdp fn test() -> u32 { return 0 }" code in

let _ = parse_string program in

check bool ("blockless parsing: " ^ code) should_succeed true

with

| _ ->

check bool ("blockless parsing: " ^ code) should_succeed false

let test_cases = [

(* Pinned map *)

("pin var pinned_map : hash<u32, u64>(1024)", true);

(* Map with flags *)

("@flags(no_prealloc) var flags_map : hash<u32, u64>(1024)", true);

(* Combined attributes *)

("@flags(rdonly) pin var combined_map : hash<u32, u64>(1024)", true);

(* Multiple flags *)

("@flags(no_prealloc | rdonly) var multi_flags_map : hash<u32, u64>(1024)", true);

(* Regular map without attributes *)

("var regular_map : hash<u32, u64>(1024)", true);

(* Invalid - old syntax with blocks *)

("var invalid_map : hash<u32, u64>(1024) { pinned: \"/path\" }", false);

(* Invalid - old syntax with empty blocks *)

("var invalid_map : hash<u32, u64>(1024) { }", false);

] in

List.iter (fun (code, should_succeed) ->

try

let program = Printf.sprintf "%s\n@xdp fn test() -> u32 { return 0 }" code in

let _ = parse_string program in

check bool ("attributes parsing: " ^ code) should_succeed true

with

| _ ->

check bool ("attributes parsing: " ^ code) should_succeed false

let program = {|

// Block-less maps

var simple_counter : hash<u32, u64>(512)

var lookup_array : array<u32, u32>(256)

var percpu_stats : percpu_hash<u64, u64>(128)

// Pinned maps

pin var pinned_global : hash<u32, u64>(2048)

pin var pinned_local : hash<u32, u64>(512)

// Maps with flags

@flags(no_prealloc) var efficient_map : hash<u32, u64>(1024)

@flags(rdonly) var readonly_map : hash<u32, u64>(256)

// Combined attributes

@flags(no_prealloc | rdonly) pin var combined_map : hash<u32, u64>(1024)

@xdp fn test_syntax(ctx: *xdp_md) -> xdp_action {

// Test all map types can be used

simple_counter[42] = 100

lookup_array[10] = 200

percpu_stats[123] = 300

pinned_global[1] = 400

pinned_local[2] = 500

efficient_map[3] = 600

readonly_map[4] = 700

combined_map[5] = 800

return XDP_PASS

}

|} in

try

let (typed_ast, _) = parse_string_with_builtins program in

check bool "comprehensive syntax parsing" true (List.length typed_ast > 0)

with

| exn ->

Printf.printf "Comprehensive syntax parsing failed with: %s\n" (Printexc.to_string exn);

let program = {|

var blockless_map : hash<u32, u64>(512)

pin var pinned_map : hash<u32, u64>(1024)

@xdp fn test(ctx: *xdp_md) -> xdp_action {

// Test type checking works with new syntax

var key: u32 = 42

var value1: u64 = blockless_map[key]

var value2: u64 = pinned_map[key]

blockless_map[key] = value1 + 1

pinned_map[key] = value2 + 1

return XDP_PASS

}

|} in

try

let (ast, _) = parse_string_with_builtins program in

check bool "new syntax type checking" true (List.length ast > 0)

with

| exn ->

Printf.printf "New syntax type checking failed with: %s\n" (Printexc.to_string exn);

let program = {|

var simple_map : hash<u32, u64>(512)

pin var pinned_map : hash<u32, u64>(1024)

@xdp fn test(ctx: *xdp_md) -> xdp_action {

simple_map[42] = 100

pinned_map[42] = 200

var val1 = simple_map[42]

var val2 = pinned_map[42]

return XDP_PASS

}

|} in

try

(* Follow the complete compiler pipeline *)

let (typed_ast, symbol_table) = parse_string_with_builtins program in

(* Test that IR generation completes without errors *)

let ir = Kernelscript.Ir_generator.generate_ir typed_ast symbol_table "test" in

check bool "IR generation produces programs" true (List.length (Kernelscript.Ir.get_programs ir) > 0)

with

let program = {|

var blockless_counter : hash<u32, u64>(512)

pin var pinned_stats : hash<u32, u64>(1024)

@xdp fn counter(ctx: *xdp_md) -> xdp_action {

var key = 42

blockless_counter[key] = blockless_counter[key] + 1

pinned_stats[key] = pinned_stats[key] + 1

return XDP_PASS

}

|} in

try

let (typed_ast, symbol_table) = parse_string_with_builtins program in

let ir = Kernelscript.Ir_generator.generate_ir typed_ast symbol_table "test" in

let c_code = Kernelscript.Ebpf_c_codegen.generate_c_multi_program ir in

(* Verify both maps are generated *)

let has_blockless = contains_substr c_code "blockless_counter" in

let has_pinned = contains_substr c_code "pinned_stats" in

let has_map_ops = contains_substr c_code "bpf_map_lookup_elem" &&

contains_substr c_code "bpf_map_update_elem" in

let _ = has_blockless && has_pinned && has_map_ops in

check bool "C code generation test" true (has_blockless && has_pinned && has_map_ops)

with

| exn ->

Printf.printf "C generation failed with: %s\n" (Printexc.to_string exn);

let invalid_cases = [

(* Old syntax with blocks - should fail *)

"var invalid : hash<u32, u64>(512) { }";

(* Old syntax with attributes - should fail *)

"var invalid : hash<u32, u64>(512) { pinned: \"/path\" }";

(* Missing colon *)

"var bad_map hash<u32, u64>(1024)";

(* Invalid flags *)

"@flags(invalid_flag) var invalid : hash<u32, u64>(512)";

] in

let all_failed_as_expected = List.for_all (fun invalid_code ->

try

let program = Printf.sprintf "%s\n@xdp fn test() -> u32 { return 0 }" invalid_code in

let _ = parse_string program in

false (* Should have failed *)

with

| _ -> true (* Expected to fail *)

) invalid_cases in

let test_cases = [

("map[key] = value", true);

("var result = map[key]", true);

("delete map[key]", true);

("var inner_key = inner_map[key]\nvar result = outer_map[inner_key]", true);

] in

List.iter (fun (input, should_pass) ->

try

let _ = parse_string input in

if not should_pass then

Printf.printf "ERROR: Expected %s to fail\n" input

with

| _ when should_pass ->

Printf.printf "ERROR: Expected %s to pass\n" input

| _ -> () (* Expected failure *)

let program = {|

var packet_counts : hash<u32, u64>(1024)

@xdp fn rate_limiter(ctx: *xdp_md) -> xdp_action {

var src_ip = 0x08080808

var current_count = packet_counts[src_ip]

var new_count = current_count + 1

packet_counts[src_ip] = new_count

if (new_count > 100) {

return XDP_DROP

}

return XDP_PASS

}

|} in

try

let (typed_ast, _) = parse_string_with_builtins program in

check bool "complete map program parsing" true (List.length typed_ast > 0)

with

let program = {|

var test_map : hash<u32, u64>(1024)

@xdp fn test(ctx: *xdp_md) -> xdp_action {

var key = 42

var value = test_map[key]

test_map[key] = value + 1

return XDP_PASS

}

|} in

try

let (ast, _) = parse_string_with_builtins program in

check bool "map type checking" true (List.length ast > 0)

with

let test_cases = [

(* Valid: u32 key with u32 access *)

({|

var valid_map : hash<u32, u64>(1024)

@xdp fn test(ctx: *xdp_md) -> xdp_action {

var key: u32 = 42

var value = valid_map[key]

return XDP_PASS

}

|}, true);

(* Invalid: string key with u32 map *)

({|

var invalid_map : hash<u32, u64>(1024)

@xdp fn test(ctx: *xdp_md) -> xdp_action {

var key = "invalid"

var value = invalid_map[key]

return XDP_PASS

}

|}, false)

] in

let all_validation_passed = List.for_all (fun (code, should_succeed) ->

try

let (_ast, _) = parse_string_with_builtins code in

should_succeed

with

| _ -> not should_succeed

) test_cases in

let program = {|

var global_map : hash<u32, u64>(1024)

@xdp fn test(ctx: *xdp_md) -> xdp_action {

var value = global_map[42]

return XDP_PASS

}

|} in

try

let (typed_ast, _) = parse_string_with_builtins program in

check bool "map identifier resolution" true (List.length typed_ast > 0)

with

| _ ->

let program = {|

var test_map : hash<u32, u64>(1024)

@xdp fn test(ctx: *xdp_md) -> xdp_action {

var key = 42

var value = test_map[key]

test_map[key] = value + 1

return XDP_PASS

}

|} in

try

(* Follow the complete compiler pipeline *)

let (typed_ast, symbol_table) = parse_string_with_builtins program in

(* Test that IR generation completes without errors *)

let ir = Kernelscript.Ir_generator.generate_ir typed_ast symbol_table "test" in

check bool "map IR generation produces programs" true (List.length (Kernelscript.Ir.get_programs ir) > 0)

with

let program = {|

var packet_counter : hash<u32, u64>(1024)

@xdp fn test(ctx: *xdp_md) -> xdp_action {

var src_ip = 0x12345678

var count = packet_counter[src_ip]

packet_counter[src_ip] = count + 1

return XDP_PASS

}

|} in

try

(* Follow the complete compiler pipeline *)

let (typed_ast, symbol_table) = parse_string_with_builtins program in

(* Test that C code generation completes and produces expected output *)

let ir = Kernelscript.Ir_generator.generate_ir typed_ast symbol_table "test" in

let c_code = Kernelscript.Ebpf_c_codegen.generate_c_multi_program ir in

let contains_map_decl = contains_substr c_code "BPF_MAP_TYPE_HASH" &&

contains_substr c_code "packet_counter" in

let contains_lookup = contains_substr c_code "bpf_map_lookup_elem" in

let contains_update = contains_substr c_code "bpf_map_update_elem" in

check bool "C code generation test" true (contains_map_decl && contains_lookup && contains_update)

with

| exn ->

Printf.printf "Map C generation failed with: %s\n" (Printexc.to_string exn);

let map_types = [

("hash", "BPF_MAP_TYPE_HASH");

("array", "BPF_MAP_TYPE_ARRAY");

("percpu_hash", "BPF_MAP_TYPE_PERCPU_HASH");

("percpu_array", "BPF_MAP_TYPE_PERCPU_ARRAY");

("lru_hash", "BPF_MAP_TYPE_LRU_HASH");

] in

let all_map_types_work = List.for_all (fun (ks_type, c_type) ->

let program = Printf.sprintf {|

var test_map : %s<u32, u64>(1024)

@xdp fn test(ctx: *xdp_md) -> xdp_action {

var key = 42

var value = test_map[key]

return XDP_PASS

}

|} ks_type in

try

(* Follow the complete compiler pipeline *)

let (typed_ast, symbol_table) = parse_string_with_builtins program in

(* Test compilation and C code generation *)

let ir = Kernelscript.Ir_generator.generate_ir typed_ast symbol_table "test" in

let c_code = Kernelscript.Ebpf_c_codegen.generate_c_multi_program ir in

contains_substr c_code c_type

with

| _ -> false

) map_types in