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

(* 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 *)

(* Test basic type unification *)

check bool "U32 unifies with U32" true (can_unify U32 U32);

check bool "U32 can unify with U64 (promotion)" true (can_unify U32 U64);

check bool "Pointer U8 unifies with Pointer U8" true (can_unify (Pointer U8) (Pointer U8));

check bool "Array types unify" true (can_unify (Array (U32, 10)) (Array (U32, 10)));

let program_text = {|

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

var x = 42

var y = true

var z = "hello"

return 2

}

|} in

try

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed programs count" 1 (List.length typed_attributed_functions);

(* Verify that type checking completed without errors *)

match List.hd typed_attributed_functions with

| (attr_list, typed_func) ->

check string "program name" "test" typed_func.tfunc_name;

check int "function parameters" 1 (List.length typed_func.tfunc_params);

check bool "has xdp attribute" true (List.exists (function SimpleAttribute "xdp" -> true | _ -> false) attr_list)

with

let program_text = {|

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

var x: u32 = 42

var y: bool = true

var z = x + 10

return 2

}

|} in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed functions count" 1 (List.length typed_attributed_functions);

let (_attrs, typed_func) = List.hd typed_attributed_functions in

check string "function name" "test" typed_func.tfunc_name;

let valid_operations = [

("var x = 1 + 2", true);

("var x = 1 - 2", true);

("var x = 1 * 2", true);

("var x = 1 / 2", true);

("var x = 1 == 2", true);

("var x = 1 != 2", true);

("var x = 1 < 2", true);

("var x = true && false", true);

("var x = true || false", true);

] in

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

let program_text = Printf.sprintf {|

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

%s

return 0

}

|} stmt in

try

let ast = parse_string program_text in

let _ = type_check_and_annotate_ast_with_builtins ast in

check bool ("binary operation: " ^ stmt) should_succeed true

with

| _ -> check bool ("binary operation: " ^ stmt) should_succeed false

let program_text = {|

@helper

fn helper(x: u32, y: u32) -> u32 {

return x + y

}

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

var result = helper(10, 20)

return result

}

|} in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed functions count" 2 (List.length typed_attributed_functions);

let helper_func = List.find (fun (_, tf) -> tf.tfunc_name = "helper") typed_attributed_functions in

let (_, helper_tf) = helper_func in

check int "helper params" 2 (List.length helper_tf.tfunc_params);

let program_text = {|

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

return 2

}

|} in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed functions count" 1 (List.length typed_attributed_functions);

let (_attrs, typed_func) = List.hd typed_attributed_functions in

check string "function name" "test" typed_func.tfunc_name;

check int "param count" 1 (List.length typed_func.tfunc_params);

let (param_name, param_type) = List.hd typed_func.tfunc_params in

check string "context param name" "ctx" param_name;

let program_text = {|

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

var packet = ctx->data

return 0

}

|} in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed functions count" 1 (List.length typed_attributed_functions);

let (_attrs, typed_func) = List.hd typed_attributed_functions in

let program_text = {|

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

var x: u32 = 42

x = 50

if (x > 0) {

return 1

}

return 0

}

|} in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed functions count" 1 (List.length typed_attributed_functions);

let (_attrs, typed_func) = List.hd typed_attributed_functions in

check string "function name" "test" typed_func.tfunc_name;

let program_text = {|

@helper

fn calculate(a: u32, b: u32) -> u32 {

var result = a + b

return result

}

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

var value = calculate(10, 20)

return value

}

|} in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed functions count" 2 (List.length typed_attributed_functions);

let calc_func = List.find (fun (_, tf) -> tf.tfunc_name = "calculate") typed_attributed_functions in

let (_, calc_tf) = calc_func in

check int "calculate params" 2 (List.length calc_tf.tfunc_params);

let program_text = {|

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

print("Hello from eBPF")

print("Message with value: ", 42)

print()

return 0

}

|} in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed functions count" 1 (List.length typed_attributed_functions);

let (_attrs, typed_func) = List.hd typed_attributed_functions in

let test_cases = [

("print()", true, "no arguments");

("print(\"hello\")", true, "single string argument");

("print(\"value: \", 42)", true, "string and number");

("print(\"a\", \"b\", \"c\")", true, "multiple arguments");

("print(1, 2, 3, 4, 5)", true, "many arguments");

] in

List.iter (fun (call, should_succeed, desc) ->

let program_text = Printf.sprintf {|

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

%s

return 0

}

|} call in

try

let ast = parse_string program_text in

let _ = type_check_and_annotate_ast_with_builtins ast in

check bool ("variadic function: " ^ desc) should_succeed true

with

| _ -> check bool ("variadic function: " ^ desc) should_succeed false

let program_text = {|

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

var result: u32 = print("test message")

return result

}

|} in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed functions count" 1 (List.length typed_attributed_functions);

let (_attrs, typed_func) = List.hd typed_attributed_functions in

let program_text = {|

@helper

fn my_function(x: u32) -> u32 {

return x + 1

}

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

var user_result = my_function(10)

print("User function result: ", user_result)

return user_result

}

|} in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "typed functions count" 2 (List.length typed_attributed_functions);

let my_func = List.find (fun (_, tf) -> tf.tfunc_name = "my_function") typed_attributed_functions in

let (_, my_tf) = my_func in

(* Test that stdlib functions are properly recognized *)

check bool "print is builtin" true (Kernelscript.Stdlib.is_builtin_function "print");

check bool "non_existent is not builtin" false (Kernelscript.Stdlib.is_builtin_function "non_existent_function");

(* Test getting function signature *)

(match Kernelscript.Stdlib.get_builtin_function_signature "print" with

| Some (params, return_type) ->

check int "print parameter count" 0 (List.length params);

check bool "print return type is U32" true (return_type = Kernelscript.Ast.U32)

| None -> check bool "print function signature should exist" false true);

(* Test context-specific implementations *)

(match Kernelscript.Stdlib.get_ebpf_implementation "print" with

| Some impl -> check string "eBPF implementation" "bpf_printk" impl

| None -> check bool "eBPF implementation should exist" false true);

(match Kernelscript.Stdlib.get_userspace_implementation "print" with

| Some impl -> check string "userspace implementation" "printf" impl

let invalid_programs = [

("var x: u32 = true", "type mismatch");

("var x = 1 + true", "invalid binary operation");

("var x = unknown_var", "undefined variable");

("var x = func_not_exists()", "undefined function");

] in

List.iter (fun (stmt, description) ->

let program_text = Printf.sprintf {|

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

%s

return 2 // XDP_PASS

}

|} stmt in

try

let ast = parse_string program_text in

let _ = type_check_and_annotate_ast_with_builtins ast in

fail ("Should have failed for: " ^ description)

with

| Type_error (msg, _) ->

check bool ("error handling got Type_error: " ^ description) true (String.length msg > 0)

| Kernelscript.Symbol_table.Symbol_error (msg, _) ->

check bool ("error handling got Symbol_error: " ^ description) true (String.length msg > 0)

| Failure msg ->

check bool ("error handling got Failure: " ^ description) true (String.length msg > 0)

let program_text = {|

@helper

fn is_tcp(protocol: u8) -> bool {

return protocol == 6

}

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

var protocol: u8 = 6

if (is_tcp(protocol)) {

return 2 // 2 // XDP_PASS

}

return 1 // 1 // XDP_DROP

}

|} in

try

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "program type checking" 2 (List.length typed_attributed_functions);

(* Verify that type checking completed without errors *)

(* Find the XDP attributed function *)

let xdp_func = List.find (fun (attr_list, _) ->

List.exists (function SimpleAttribute "xdp" -> true | _ -> false) attr_list

) typed_attributed_functions in

match xdp_func with

| (attr_list, typed_func) ->

check string "typed program name" "packet_filter" typed_func.tfunc_name;

check int "typed function parameters" 1 (List.length typed_func.tfunc_params);

check bool "has xdp attribute" true (List.exists (function SimpleAttribute "xdp" -> true | _ -> false) attr_list)

with

let program_text = {|

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

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

// Test U32 literal assignment to U64 map value

counter[1] = 100 // U32 literal should promote to U64

counter[2] = 200 // U32 literal should promote to U64

// Test arithmetic with different sizes

var small: u32 = 50

var large: u64 = 1000

var result = small + large // U32 should promote to U64

// Test map access with promoted values

var val1 = counter[1] + 50 // U64 + U32 -> U64

counter[3] = val1

return XDP_PASS

}

|} in

try

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "type promotion programs count" 1 (List.length typed_attributed_functions);

let xdp_func = List.find (fun (_, tf) -> tf.tfunc_name = "test_promotion") typed_attributed_functions in

let (_, typed_func) = xdp_func in

check string "type promotion program name" "test_promotion" typed_func.tfunc_name;

check int "body statements" 8 (List.length typed_func.tfunc_body)

with

| exn ->

Printf.printf "Error in integer type promotion test: %s\n" (Printexc.to_string exn);

(* Test the specific type promotions we added *)

check bool "U32 promotes to U64" true (can_unify U32 U64);

check bool "U64 unifies with U32" true (can_unify U64 U32);

check bool "I32 promotes to I64" true (can_unify I32 I64);

check bool "I64 unifies with I32" true (can_unify I64 I32);

check bool "U16 promotes to U64" true (can_unify U16 U64);

check bool "U8 promotes to U64" true (can_unify U8 U64);

(* Test that incompatible types still don't unify *)

check bool "U32 does not unify with Bool" false (can_unify U32 Bool);

(* I32 and U32 should now unify due to permissive integer literal behavior *)

let program_text = {|

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

@helper

fn increment_counter(key: u32) -> u64 {

var current = counter[key]

var new_value = current + 1

counter[key] = new_value

return new_value

}

@helper

fn process_packet(size: u32) -> bool {

return size > 1500

}

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

var packet_size: u32 = 1000

var counter_val = increment_counter(packet_size)

var is_large = process_packet(packet_size)

if (is_large && counter_val > 100) {

return XDP_DROP

} else {

return XDP_PASS

}

}

|} in

try

let ast = parse_string_with_builtins program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int "comprehensive AST length" 3 (List.length typed_attributed_functions);

(* Verify that type checking completed without errors *)

(* Find the XDP attributed function *)

let xdp_func = List.find (fun (attr_list, _) ->

List.exists (function SimpleAttribute "xdp" -> true | _ -> false) attr_list

) typed_attributed_functions in

match xdp_func with

| (attr_list, typed_func) ->

check string "comprehensive program name" "comprehensive_test" typed_func.tfunc_name;

check int "comprehensive function parameters" 1 (List.length typed_func.tfunc_params);

check bool "has xdp attribute" true (List.exists (function SimpleAttribute "xdp" -> true | _ -> false) attr_list)

with

(* Test all integer promotion combinations *)

let promotion_tests = [

(* U8 promotions *)

(U8, U16, "U8 promotes to U16");

(U8, U32, "U8 promotes to U32");

(U8, U64, "U8 promotes to U64");

(U16, U8, "U16 promotes to U16 (reverse)");

(U32, U8, "U32 promotes to U32 (reverse)");

(U64, U8, "U64 promotes to U64 (reverse)");

(* U16 promotions *)

(U16, U32, "U16 promotes to U32");

(U16, U64, "U16 promotes to U64");

(U32, U16, "U32 promotes to U32 (reverse)");

(U64, U16, "U64 promotes to U64 (reverse)");

(* U32 promotions *)

(U32, U64, "U32 promotes to U64");

(U64, U32, "U64 promotes to U64 (reverse)");

(* I8 promotions *)

(I8, I16, "I8 promotes to I16");

(I8, I32, "I8 promotes to I32");

(I8, I64, "I8 promotes to I64");

(I16, I8, "I16 promotes to I16 (reverse)");

(I32, I8, "I32 promotes to I32 (reverse)");

(I64, I8, "I64 promotes to I64 (reverse)");

(* I16 promotions *)

(I16, I32, "I16 promotes to I32");

(I16, I64, "I16 promotes to I64");

(I32, I16, "I32 promotes to I32 (reverse)");

(I64, I16, "I64 promotes to I64 (reverse)");

(* I32 promotions *)

(I32, I64, "I32 promotes to I64");

(I64, I32, "I64 promotes to I64 (reverse)");

] in

List.iter (fun (t1, t2, desc) ->

check bool desc true (can_unify t1 t2)

) promotion_tests;

(* Test that incompatible types still don't unify *)

let incompatible_tests = [

(U8, Bool, "U8 does not unify with Bool");

(I16, Str 32, "I16 does not unify with Str");

(U32, Pointer U32, "U32 does not unify with Pointer U32");

] in

List.iter (fun (t1, t2, desc) ->

check bool desc false (can_unify t1 t2)

) incompatible_tests;

(* Test that compatible integer types do unify (permissive behavior) *)

let compatible_tests = [

(U32, I32, "U32 unifies with I32");

(U64, I64, "U64 unifies with I64");

(I32, U32, "I32 unifies with U32");

(I64, U64, "I64 unifies with U64");

] in

List.iter (fun (t1, t2, desc) ->

check bool desc true (can_unify t1 t2)

let arithmetic_tests = [

(* Basic arithmetic with different sizes *)

("var x: u8 = 10\n var y: u64 = 1000\n var result = x + y", "u8 + u64 addition");

("var x: u16 = 100\n var y: u32 = 2000\n var result = x * y", "u16 * u32 multiplication");

("var x: u32 = 500\n var y: u64 = 1000\n var result = y - x", "u64 - u32 subtraction");

("var x: u8 = 5\n var y: u16 = 10\n var result = x / y", "u8 / u16 division");

("var x: u16 = 17\n var y: u32 = 5\n var result = x % y", "u16 % u32 modulo");

(* Signed arithmetic *)

("var x: i8 = -10\n var y: i64 = 1000\n var result = x + y", "i8 + i64 addition");

("var x: i16 = -100\n var y: i32 = 2000\n var result = x * y", "i16 * i32 multiplication");

("var x: i32 = -500\n var y: i64 = 1000\n var result = y - x", "i64 - i32 subtraction");

] in

List.iter (fun (stmt, desc) ->

let program_text = Printf.sprintf {|

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

%s

return 2 // XDP_PASS

}

|} stmt in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int ("arithmetic promotion func count: " ^ desc) 1 (List.length typed_attributed_functions);

let (_, tf) = List.hd typed_attributed_functions in

check string ("arithmetic promotion func name: " ^ desc) "test" tf.tfunc_name

let comparison_tests = [

(* Equality comparisons *)

("var x: u8 = 10\n var y: u64 = 10\n var result = x == y", "u8 == u64 equality");

("var x: u16 = 100\n var y: u32 = 200\n var result = x != y", "u16 != u32 inequality");

("var x: i8 = -5\n var y: i64 = -5\n var result = x == y", "i8 == i64 equality");

(* Ordering comparisons *)

("var x: u8 = 10\n var y: u64 = 100\n var result = x < y", "u8 < u64 less than");

("var x: u16 = 1000\n var y: u32 = 500\n var result = x > y", "u16 > u32 greater than");

("var x: u32 = 100\n var y: u64 = 100\n var result = x <= y", "u32 <= u64 less equal");

("var x: u8 = 50\n var y: u16 = 30\n var result = x >= y", "u8 >= u16 greater equal");

(* Signed comparisons *)

("var x: i8 = -10\n var y: i64 = 100\n var result = x < y", "i8 < i64 less than");

("var x: i16 = -5\n var y: i32 = -10\n var result = x > y", "i16 > i32 greater than");

] in

List.iter (fun (stmt, desc) ->

let program_text = Printf.sprintf {|

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

%s

return 2 // XDP_PASS

}

|} stmt in

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check int ("comparison promotion func count: " ^ desc) 1 (List.length typed_attributed_functions);

let (_, tf) = List.hd typed_attributed_functions in

check string ("comparison promotion func name: " ^ desc) "test" tf.tfunc_name

let map_tests = [

(* Map key promotion *)

({|

type IpAddress = u32

var counters : hash<IpAddress, u64>(1000)

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

var ip: u16 = 12345 // u16 should promote to u32 (IpAddress)

counters[ip] = 100

return 2 // XDP_PASS

}

|}, "map key promotion");

(* Map value promotion *)

({|

type Counter = u64

var stats : hash<u32, Counter>(1000)

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

var value: u16 = 1500 // u16 should promote to u64 (Counter)

stats[1] = value

return 2 // XDP_PASS

}

|}, "map value promotion");

(* Map access with arithmetic *)

({|

type PacketSize = u16

type Counter = u64

var stats : hash<u32, Counter>(1000)

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

var size: PacketSize = 1500

var current = stats[1] // u64

var new_value = current + size // u64 + u16 -> u64

stats[1] = new_value

return 2 // XDP_PASS

}

|}, "map access with arithmetic promotion");

] in

List.iter (fun (program_text, desc) ->

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check bool ("map promotion has typed funcs: " ^ desc) true (List.length typed_attributed_functions >= 1);

let (_, tf) = List.hd typed_attributed_functions in

check string ("map promotion func name: " ^ desc) "test" tf.tfunc_name

let edge_case_tests = [

(* Nested arithmetic with multiple promotions *)

({|

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

var a: u8 = 10

var b: u16 = 100

var c: u32 = 1000

var d: u64 = 10000

var result = a + b + c + d // Chain of promotions

return 2 // XDP_PASS

}

|}, "nested arithmetic with multiple promotions");

(* Function parameters with promotion *)

({|

@helper

fn process(value: u64) -> u64 {

return value * 2

}

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

var small: u16 = 100

var result = process(small) // u16 -> u64 promotion in function call

return 2 // XDP_PASS

}

|}, "function parameter promotion");

(* Complex expression with promotions *)

({|

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

var a: u8 = 5

var b: u16 = 10

var c: u32 = 20

var d: u64 = 40

var result = (a + b) * (c + d) // Mixed promotions in complex expression

return 2 // XDP_PASS

}

|}, "complex expression with promotions");

(* Assignment with promotion *)

({|

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

var big: u64 = 1000

var small: u16 = 100

big = big + small // u64 = u64 + u16

return 2 // XDP_PASS

}

|}, "assignment with promotion");

] in

List.iter (fun (program_text, desc) ->

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check bool ("edge case promotion has typed funcs: " ^ desc) true (List.length typed_attributed_functions >= 1);

let test_func = List.find (fun (_, tf) -> tf.tfunc_name = "test") typed_attributed_functions in

let (_, tf) = test_func in

check string ("edge case promotion func name: " ^ desc) "test" tf.tfunc_name

let null_tests = [

(* Basic null literal *)

({|

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

var x = null

return 2 // XDP_PASS

}

|}, "basic null literal");

(* Null comparison with typed variable *)

({|

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

var x: u32 = 42

if (x == null) {

return 1 // XDP_DROP

}

return 2 // XDP_PASS

}

|}, "null comparison with u32");

(* Null assignment in variable declaration *)

({|

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

var ptr = null

return 2 // XDP_PASS

}

|}, "null assignment in declaration");

] in

List.iter (fun (program_text, desc) ->

let ast = parse_string program_text in

let symbol_table = create_symbol_table_with_builtins ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast_with_builtins ast in

let ir_program = Kernelscript.Ir_generator.generate_ir annotated_ast symbol_table "test" in

check bool ("null literal typing IR generated: " ^ desc) true (List.length ir_program.Kernelscript.Ir.source_declarations > 0)

let comparison_tests = [

(* Comparisons with different numeric types *)

("var x: u8 = 10\n var result = x == null", "u8 == null");

("var x: u16 = 100\n var result = x != null", "u16 != null");

("var x: u32 = 1000\n var result = x == null", "u32 == null");

("var x: u64 = 10000\n var result = x != null", "u64 != null");

("var x: i8 = -5\n var result = x == null", "i8 == null");

("var x: i16 = -100\n var result = x != null", "i16 != null");

("var x: i32 = -1000\n var result = x == null", "i32 == null");

("var x: i64 = -10000\n var result = x != null", "i64 != null");

(* Basic null comparisons *)

("var ptr = null\n var result = ptr == null", "null variable == null");

("var ptr = null\n var result = ptr != null", "null variable != null");

(* Double null comparison *)

("var result = null == null", "null == null");

("var result = null != null", "null != null");

] in

List.iter (fun (stmt, desc) ->

let program_text = Printf.sprintf {|

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

%s

return 2 // XDP_PASS

}

|} stmt in

let ast = parse_string program_text in

let symbol_table = create_symbol_table_with_builtins ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast_with_builtins ast in

let ir_program = Kernelscript.Ir_generator.generate_ir annotated_ast symbol_table "test" in

check bool ("null comparison IR generated: " ^ desc) true (List.length ir_program.Kernelscript.Ir.source_declarations > 0)

let map_null_tests = [

(* Map access returning nullable value *)

({|

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

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

var value = test_map[42]

if (value == null) {

return 1 // XDP_DROP

}

return 2 // XDP_PASS

}

|}, "map access null check");

(* Null initialization pattern *)

({|

var counters : hash<u32, u32>(100)

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

var count = counters[1]

if (count == null) {

counters[1] = 1

} else {

counters[1] = count + 1

}

return 2 // XDP_PASS

}

|}, "null initialization pattern");

(* Multiple map null checks *)

({|

var flows : hash<u32, u64>(100)

var packets : hash<u32, u32>(100)

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

var flow = flows[123]

var packet_count = packets[123]

if (flow == null || packet_count == null) {

return 1 // XDP_DROP

}

return 2 // XDP_PASS

}

|}, "multiple map null checks");

] in

List.iter (fun (program_text, desc) ->

let ast = parse_string program_text in

let symbol_table = create_symbol_table_with_builtins ast in

let (annotated_ast, _typed_programs) = type_check_and_annotate_ast_with_builtins ast in

let ir_program = Kernelscript.Ir_generator.generate_ir annotated_ast symbol_table "test" in

check bool ("map null semantics IR generated: " ^ desc) true (List.length ir_program.Kernelscript.Ir.source_declarations > 0)

let pattern_tests = [

(* Correct: null for expected absence *)

({|

var cache : hash<u32, u64>(100)

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

var cached_value = cache[42]

if (cached_value == null) {

// Key doesn't exist - expected case

cache[42] = 100

return 2 // XDP_PASS

}

return cached_value

}

|}, "null for expected absence");

(* Correct: error checking (simplified without throw) *)

({|

@helper

fn validate_input(value: u32) -> u32 {

if (value > 1000) {

return 0 // Error case

}

return value * 2

}

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

var result = validate_input(500)

return 2 // XDP_PASS

}

|}, "error validation pattern");

(* Function returning nullable value *)

({|

var data : hash<u32, u32>(100)

@helper

fn lookup_value(key: u32) -> u32 {

var value = data[key]

if (value == null) {

return 0 // Default value for missing key

}

return value

}

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

var result = lookup_value(42)

return 2 // XDP_PASS

}

|}, "function with nullable return pattern");

] in

List.iter (fun (program_text, desc) ->

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check bool ("null vs throw pattern has typed funcs: " ^ desc) true (List.length typed_attributed_functions >= 1)

let comprehensive_tests = [

(* Null in conditional expressions *)

({|

var test_map : hash<u32, u32>(100)

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

var value = test_map[1]

var result = 0

if (value == null) {

result = 0

} else {

result = value

}

return 2 // XDP_PASS

}

|}, "null in if-else expression");

(* Null in logical operations *)

({|

var map1 : hash<u32, u32>(100)

var map2 : hash<u32, u32>(100)

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

var val1 = map1[1]

var val2 = map2[1]

if (val1 != null && val2 != null) {

return 2 // XDP_PASS

}

return 2 // XDP_PASS

}

|}, "null in logical AND");

(* Basic null assignments *)

({|

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

var x = null

if (x == null) {

return 1 // XDP_DROP

}

return 2 // XDP_PASS

}

|}, "basic null assignment and check");

] in

List.iter (fun (program_text, desc) ->

let ast = parse_string program_text in

let (_enhanced_ast, typed_attributed_functions) = type_check_and_annotate_ast_with_builtins ast in

check bool ("comprehensive null has typed funcs: " ^ desc) true (List.length typed_attributed_functions >= 1)

try

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

true

let invalid_signature_tests = [

(* Missing context parameter *)

({|

@xdp fn test() -> xdp_action {

return 2 // XDP_PASS

}

|}, "missing context parameter");

(* Wrong parameter type *)

({|

@xdp fn test(wrong_param: u32) -> xdp_action {

return 2 // XDP_PASS

}

|}, "wrong parameter type");

(* No parameters and wrong return type *)

({|

@xdp fn test() -> u32 {

return 0

}

|}, "no parameters and wrong return type");

] in

List.iter (fun (program_text, desc) ->