Replace all remaining trivial true/true assertions across 25 test files

congwang-mk · congwang-mk · commit f9805590b410 · 2026-03-05T11:58:57.000-08:00
Signed-off-by: Cong Wang &lt;cwang@multikernel.io&gt;
diff --git a/tests/test_address_of_user_types.ml b/tests/test_address_of_user_types.ml
@@ -48,7 +48,7 @@ let test_address_of_user_type_resolution () =
     let ast = Kernelscript.Parse.parse_string code in
     let symbol_table = Test_utils.Helpers.create_test_symbol_table ~include_xdp:true ast in
     let (_, _) = Kernelscript.Type_checker.type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in
-    check bool "Address-of user type resolution test passed" true true
+    ()
   with
   | Type_error (msg, _) -> 
     Alcotest.fail ("Type error should not occur: " ^ msg)
@@ -91,7 +91,7 @@ let test_address_of_nested_user_types () =
     let ast = Kernelscript.Parse.parse_string code in
     let symbol_table = Test_utils.Helpers.create_test_symbol_table ~include_xdp:true ast in
     let (_, _) = Kernelscript.Type_checker.type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in
-    check bool "Nested address-of user type resolution test passed" true true
+    ()
   with
   | Type_error (msg, _) -> 
     Alcotest.fail ("Type error should not occur: " ^ msg)
diff --git a/tests/test_array_init.ml b/tests/test_array_init.ml
@@ -139,7 +139,7 @@ let test_semantic_analysis () =
     ("var arr: bool[2] = [true]", "Boolean fill should work");
   ] in
   
-  List.iter (fun (input, description) ->
+  List.iter (fun (input, _description) ->
     let program_text = Printf.sprintf {|
 @xdp fn test(ctx: *xdp_md) -> xdp_action {
   %s
@@ -150,7 +150,7 @@ let test_semantic_analysis () =
       let ast = Kernelscript.Parse.parse_string program_text in
       let symbol_table = Kernelscript.Symbol_table.build_symbol_table ast in
       let (_typed_ast, _) = Kernelscript.Type_checker.type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in
-      check bool description true true
+      ()
     with
     | e -> fail ("Semantic analysis failed for " ^ input ^ ": " ^ Printexc.to_string e)
   ) test_cases
@@ -162,7 +162,7 @@ let test_error_cases () =
     ("var arr: u32[4] = [1, true, 3]", "Array elements must have consistent type");
   ] in
   
-  List.iter (fun (input, expected_error) ->
+  List.iter (fun (input, _expected_error) ->
     let program_text = Printf.sprintf {|
 @xdp fn test(ctx: *xdp_md) -> xdp_action {
   %s
@@ -175,7 +175,7 @@ let test_error_cases () =
       let (_typed_ast, _) = Kernelscript.Type_checker.type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in
       fail ("Expected error for " ^ input ^ " but compilation succeeded")
     with
-    | _ -> check bool expected_error true true
+    | _ -> ()
   ) test_cases
 
 let () =
diff --git a/tests/test_btf_binary_parser.ml b/tests/test_btf_binary_parser.ml
@@ -184,7 +184,7 @@ let test_btf_array_type_resolution () =
     );
     
     (* Verify that the function interface works correctly *)
-    check bool "BTF parser handles invalid input gracefully" true true
+    ()
   in
   
   test_array_scenario ()
@@ -206,11 +206,7 @@ let test_btf_kind_coverage () =
     *)
     
     (* Verify that these improvements compiled and are available *)
-    check bool "BTF kind coverage includes arrays" true true;
-    check bool "BTF kind coverage includes forward declarations" true true;
-    check bool "BTF kind coverage includes float types" true true;
-    check bool "BTF kind coverage includes variables" true true;
-    check bool "BTF kind coverage includes data sections" true true;
+    ();
   in
   
   test_kind_scenarios ()
diff --git a/tests/test_comment_positions.ml b/tests/test_comment_positions.ml
@@ -27,7 +27,7 @@ let test_comment_at_start () =
   try
     let ast = parse_string program_text in
     check int "AST declarations count" 1 (List.length ast);
-    check bool "comment at start parsing" true true
+    ()
   with
   | Parse_error (msg, pos) ->
     fail ("Parse error: " ^ msg ^ " at " ^ string_of_position pos)
@@ -41,7 +41,7 @@ let test_comment_with_whitespace () =
   try
     let ast = parse_string program_text in
     check int "AST declarations count" 1 (List.length ast);
-    check bool "comment with whitespace parsing" true true
+    ()
   with
   | Parse_error (msg, pos) ->
     fail ("Parse error: " ^ msg ^ " at " ^ string_of_position pos)
@@ -83,7 +83,7 @@ let test_multiple_line_comments () =
   try
     let ast = parse_string program_text in
     check int "AST declarations count" 1 (List.length ast);
-    check bool "multiple line comments parsing" true true
+    ()
   with
   | Parse_error (msg, pos) ->
     fail ("Parse error: " ^ msg ^ " at " ^ string_of_position pos)
@@ -96,7 +96,7 @@ let test_inline_comments () =
   try
     let ast = parse_string program_text in
     check int "AST declarations count" 1 (List.length ast);
-    check bool "inline comments parsing" true true
+    ()
   with
   | Parse_error (msg, pos) ->
     fail ("Parse error: " ^ msg ^ " at " ^ string_of_position pos)
diff --git a/tests/test_config_struct_generation.ml b/tests/test_config_struct_generation.ml
@@ -311,7 +311,7 @@ fn main() -> i32 {
     let ast = parse_string program_text in
     let _ = build_symbol_table ast in
     let _ = type_check_and_annotate_ast ast in
-    check bool "config field reads allowed in eBPF" true true
+    ()
   with
   | e -> fail ("Unexpected error in config read test: " ^ Printexc.to_string e)
 
diff --git a/tests/test_detach_api.ml b/tests/test_detach_api.ml
@@ -143,10 +143,10 @@ fn main() -> i32 {
   with
   | Type_error (_, _) -> 
       (* Expected type error *)
-      check bool "Got expected type error" true true
+      ()
   | Failure msg when string_contains_substring msg "type" -> 
       (* Expected type error as Failure *)
-      check bool "Got expected type error" true true
+      ()
   | _ -> (fail "Should have failed with type error" : unit)
 
 (* Test suite definition *)
diff --git a/tests/test_dynptr_bridge.ml b/tests/test_dynptr_bridge.ml
@@ -55,9 +55,9 @@ let test_memory_bridge_integration () =
    | Some info -> 
        (match info.Kernelscript.Ebpf_c_codegen.region_type with
         | Kernelscript.Ebpf_c_codegen.PacketData -> 
-            check bool (test_name ^ " - packet_ptr has PacketData region") true true
+            ()
         | Kernelscript.Ebpf_c_codegen.LocalStack ->
-            check bool (test_name ^ " - packet_ptr has LocalStack region (expected for variable allocation)") true true
+            ()
         | _ -> 
             let region_str = match info.Kernelscript.Ebpf_c_codegen.region_type with
               | Kernelscript.Ebpf_c_codegen.PacketData -> "PacketData"
diff --git a/tests/test_enum.ml b/tests/test_enum.ml
@@ -222,7 +222,7 @@ let test_enum_edge_cases () =
   with
   | Symbol_error _ -> 
     (* If it fails, that's also acceptable behavior *)
-    check bool "duplicate rejected" true true
+    ()
 
 (** Test enum with large values *)
 let test_enum_large_values () =
@@ -370,7 +370,7 @@ let test_enum_not_numeric_literals () =
   (* Verify it's NOT IRLiteral *)
   (match ir_value.value_desc with
    | IRLiteral _ -> check bool "should not be IRLiteral" false true
-   | IREnumConstant _ -> check bool "correctly preserved as IREnumConstant" true true
+   | IREnumConstant _ -> ()
    | _ -> check bool "unexpected IR value type" false true)
 
 (** Test complete enum preservation pipeline *)
@@ -580,14 +580,14 @@ let test_enum_array_index () =
     let _typed_ast = type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in
     
     (* If we reach here, type checking succeeded *)
-    check bool "enum array index type checking passes" true true
+    ()
   with
   | Type_error (msg, _) when String.contains msg 'A' && String.contains msg 'r' ->
       (* If we get "Array index must be integer type" error, the test fails *)
       check bool ("enum array index should be allowed: " ^ msg) false true
   | Type_error (_, _) ->
       (* Other type errors are acceptable for this test *)
-      check bool "enum array index type checking passes" true true
+      ()
   | Parse_error (msg, _) ->
       check bool ("parse error: " ^ msg) false true
   | e ->
diff --git a/tests/test_evaluator.ml b/tests/test_evaluator.ml
@@ -33,7 +33,7 @@ let test_basic_evaluation () =
   try
     let ast = parse_string program_text in
     let _ = List.length ast in
-    check bool "basic evaluation test" true true
+    check bool "basic evaluation test" true (List.length ast > 0)
   with
   | _ -> fail "Failed basic evaluation test"
 
@@ -70,7 +70,7 @@ let test_enum_constant_evaluation () =
     
     match eval_expression eval_ctx xdp_pass_expr with
     | EnumValue ("xdp_action", 2L) -> 
-        check bool "XDP_PASS correctly evaluated from symbol table" true true
+        ()
     | _ -> 
         fail "XDP_PASS should evaluate to EnumValue(xdp_action, 2)"
   with
@@ -99,15 +99,15 @@ let test_various_enum_constants () =
     let xdp_drop_expr = make_test_expr (Kernelscript.Ast.Identifier "XDP_DROP") in
     (match eval_expression eval_ctx xdp_drop_expr with
     | EnumValue ("xdp_action", 1L) ->
-        check bool "XDP_DROP correctly evaluated" true true  
+        ()
     | _ ->
         fail "XDP_DROP should evaluate to EnumValue(xdp_action, 1)");
     
     (* Test TC enum constant *)
     let tc_ok_expr = make_test_expr (Kernelscript.Ast.Identifier "TC_ACT_OK") in
     (match eval_expression eval_ctx tc_ok_expr with
     | EnumValue ("tc_action", 0L) ->
-        check bool "TC_ACT_OK correctly evaluated" true true  
+        ()
     | _ ->
         fail "TC_ACT_OK should evaluate to EnumValue(tc_action, 0)")
   with
diff --git a/tests/test_function_validation.ml b/tests/test_function_validation.ml
@@ -89,7 +89,7 @@ fn main() -> i32 {
     let ast = parse_string program_text in
     let _ = build_symbol_table ast in
     let (_, _) = type_check_and_annotate_ast ast in
-    check bool "proper eBPF function names should be accepted" true true
+    ()
   with
   | _ ->
       check bool "proper eBPF function names rejected unexpectedly" false true
@@ -109,7 +109,7 @@ fn main() -> i32 {
     let ast = parse_string program_text in
     let _ = build_symbol_table ast in
     let (_, _) = type_check_and_annotate_ast ast in
-    check bool "userspace main function should be accepted" true true
+    ()
   with
   | _ ->
       check bool "userspace main function rejected unexpectedly" false true
diff --git a/tests/test_integer_literal.ml b/tests/test_integer_literal.ml
@@ -316,7 +316,7 @@ let test_complete_pipeline () =
   (* This test would require full compilation pipeline, which is complex
      For now, we'll test the individual components above *)
   (* TODO: Add full pipeline test when integration test framework is available *)
-  check bool "pipeline test placeholder" true true
+  ()
 
 (** Test string_of_literal preserves format *)
 let test_string_of_literal () =
diff --git a/tests/test_map_assignment.ml b/tests/test_map_assignment.ml
@@ -131,7 +131,7 @@ var typed_map : hash<u32, u64>(1024)
     let type_check_result = {all_valid = false; errors = []; analysis_complete = true} in  (* Placeholder *)
     check bool "invalid assignments fail type check" false type_check_result.all_valid
   with
-  | _ -> check bool "expected error for invalid assignment" true true
+  | _ -> ()
   )
 
 (** Test assignment optimization *)
@@ -244,7 +244,7 @@ var valid_map : hash<u32, u64>(1024)
     let validation_result = validate_assignments assignments in
     check bool "invalid assignments fail validation" false validation_result.all_valid
   with
-  | _ -> check bool "expected parse error for invalid" true true
+  | _ -> ()
   )
 
 (** Test assignment safety analysis *)
diff --git a/tests/test_map_flags.ml b/tests/test_map_flags.ml
@@ -154,7 +154,7 @@ var invalid_map : hash<u32, u64>(0)  // Invalid size
     let validation_result = Maps.validate_map_flags map_flags in
     check bool "invalid flags fail validation" true validation_result.all_valid (* Maps with 0 entries are parsed but flagged later *)
   with
-  | _ -> check bool "expected parse error for invalid flags" true true
+  | _ -> ()
   )
 
 (** Test map flags with initialization *)
@@ -281,7 +281,7 @@ let test_map_flags_size_limits () =
       let validation_result = Maps.validate_map_flags map_flags in
       check bool ("size validation: " ^ string_of_int expected_size) should_be_valid validation_result.all_valid
     with
-    | _ when not should_be_valid -> check bool ("expected error for size: " ^ string_of_int expected_size) true true
+    | _ when not should_be_valid -> ()
     | _ -> fail ("Unexpected result for size: " ^ string_of_int expected_size)
   ) test_cases
 
diff --git a/tests/test_map_integration.ml b/tests/test_map_integration.ml
@@ -196,10 +196,10 @@ var test_map : hash<u32, u64>(100)
     with
     | Kernelscript.Type_checker.Type_error (_, _) -> 
         (* Expected to fail with Type_error *)
-        check bool "correctly rejected invalid map operation" true true
+        ()
     | Kernelscript.Symbol_table.Symbol_error (_, _) -> 
         (* Expected to fail with Symbol_error for undefined identifiers *)
-        check bool "correctly rejected invalid map operation" true true
+        ()
     | _ -> 
         fail "Unexpected error type for invalid map operation"
   ) invalid_programs
diff --git a/tests/test_maps.ml b/tests/test_maps.ml
@@ -124,7 +124,7 @@ let test_map_program_integration () =
   check string "second map name" "byte_count" byte_count_map.name;
   
   (* Test map compatibility - simplified *)
-  check bool "program uses maps" true true
+  ()
 
 (** Test map type compatibility *)
 let test_map_type_compatibility () =
@@ -164,9 +164,9 @@ let test_map_error_handling () =
   (* Test error conditions *)
   try
     let _ = make_ast_map_declaration "" U32 U64 Hash config true ~is_pinned:false pos in
-    check bool "empty name handled" true true
+    ()
   with
-  | _ -> check bool "empty name error handled" true true
+  | _ -> ()
 
 (** Test map metadata *)
 let test_map_metadata () =
diff --git a/tests/test_match.ml b/tests/test_match.ml
@@ -494,7 +494,7 @@ let test_match_block_implicit_returns () =
   (* The main test: Type checking should succeed (this would fail before the bug fix) *)
   (try 
     let (_typed_ast, _typed_functions) = Type_checker.type_check_and_annotate_ast ~symbol_table:(Some symbol_table) ast in
-    check bool "type checking should succeed for match arms with implicit returns" true true
+    ()
   with
   | Failure msg when msg = "Block arms must end with a return statement" ->
       fail "Bug regression: type checker still requires explicit returns in match arm blocks"
@@ -632,7 +632,7 @@ let test_enum_constant_resolution_in_match () =
      
   (* This test ensures that the bug fix works: enum constants in match patterns
      should be resolved to their actual values, not hardcoded to 0 *)
-  check bool "enum constants should be properly resolved in match patterns" true true
+  ()
 
 let suite = [
   "test_basic_match_parsing", `Quick, test_basic_match_parsing;
diff --git a/tests/test_object_allocation.ml b/tests/test_object_allocation.ml
@@ -66,7 +66,7 @@ let test_delete_targets () =
 let test_ir_generation () =
   (* This test verifies that the new and delete constructs can be processed *)
   (* In a real implementation, this would test IR generation *)
-  check bool "IR object allocation representable" true true
+  ()
 
 (** Test that variable assignments are correct (regression test for var_0/var_1 bug) *)
 let test_variable_assignment_bug () =
@@ -87,12 +87,12 @@ let test_variable_assignment_bug () =
   
   (* The core fix is in IR generation - if the above AST can be created, *)
   (* and our previous tests pass, then the variable assignment bug is fixed *)
-  check bool "variable assignment bug pattern works in AST" true true
+  ()
 
 (** Test error cases *)
 let test_error_cases () =
   (* This should be caught during validation *)
-  check bool "invalid delete target should be detected" true true
+  ()
 
 let tests = [
   ("new expression AST", `Quick, test_new_expression_ast);
diff --git a/tests/test_parser.ml b/tests/test_parser.ml
@@ -324,7 +324,7 @@ let test_error_handling () =
       let _ = parse_string invalid_text in
       fail ("Should have failed to parse: " ^ invalid_text)
     with
-    | _ -> check bool ("error handling: " ^ invalid_text) true true
+    | _ -> ()
   ) invalid_programs
 
 (** Test operator precedence *)
@@ -339,7 +339,7 @@ let test_operator_precedence () =
 |} in
   try
     let _ = parse_string program_text in
-    check bool "operator precedence parsing" true true
+    ()
   with
   | _ -> fail "Failed to parse operator precedence"
 
@@ -485,7 +485,7 @@ let test_if_else_if_else () =
               check int "else contains nested if" 1 (List.length else_stmts);
              (* Check that else contains another if statement *)
              (match (List.hd else_stmts).stmt_desc with
-              | If (_, _, Some _) -> check bool "nested if-else" true true
+              | If (_, _, Some _) -> ()
               | _ -> fail "Expected nested if-else")
          | _ -> fail "Expected if-else statement")
     | _ -> fail "Expected attributed function declaration"
@@ -622,7 +622,7 @@ let test_if_error_cases () =
       let _ = parse_string code in
       fail ("Should have failed: " ^ desc)
     with
-    | Parse_error (_, _) -> check bool ("error case: " ^ desc) true true
+    | Parse_error (_, _) -> ()
     | _ -> fail ("Expected parse error for: " ^ desc)
   ) error_cases
 
diff --git a/tests/test_pointer_syntax.ml b/tests/test_pointer_syntax.ml
diff --git a/tests/test_string_type.ml b/tests/test_string_type.ml
diff --git a/tests/test_test_attribute.ml b/tests/test_test_attribute.ml
diff --git a/tests/test_tracepoint.ml b/tests/test_tracepoint.ml
diff --git a/tests/test_userspace_maps.ml b/tests/test_userspace_maps.ml
diff --git a/tests/test_userspace_struct_flexibility.ml b/tests/test_userspace_struct_flexibility.ml
diff --git a/tests/test_void_functions.ml b/tests/test_void_functions.ml
