run_test_suite

Documentation

API Reference

run_test_suite

Description

Main test driver that handles both normal and deadend tests.

Parameters

Name	Direction	Description
`normal_tests`	in	Array of normal test function pointers (can be NULL).
`normal_count`	in	Number of normal tests.
`deadend_tests`	in	Array of deadend test function pointers (can be NULL).
`deadend_count`	in	Number of deadend tests.
`test_name`	in	Name of the test suite for logging.

Success

Returns 0 if all tests passed.

Failure

Returns non-zero if some tests failed.

Usage example (Cross-references)

Usage examples (Cross-references)

In TestRunner.c:134:

    
    /// Main test driver - handles everything: normal tests and deadend tests
    int run_test_suite(
        TestFunction *normal_tests,
        int           normal_count,

In Parse.c:156:

    
        WriteFmt("[INFO] Starting KvConfig.Parse tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "KvConfig.Parse");
    }

In Write.Nested.c:542:

    
        // Use centralized test driver
        return run_test_suite(tests, test_count, NULL, 0, "Json.Write.Nested");
    }

In Read.Simple.c:482:

    
        // Use centralized test driver
        return run_test_suite(tests, test_count, NULL, 0, "Json.Read.Simple");
    }

In Read.Nested.c:1099:

    
        // Use centralized test driver
        return run_test_suite(tests, test_count, NULL, 0, "Json.Read");
    }

In Write.EdgeCases.c:510:

    
        // Use centralized test driver
        return run_test_suite(tests, test_count, NULL, 0, "Json.Write.EdgeCases");
    }

In Write.Simple.c:353:

    
        // Use centralized test driver
        return run_test_suite(tests, test_count, NULL, 0, "Json.Write.Simple");
    }

In RoundTrip.c:795:

    
        // Use centralized test driver
        return run_test_suite(tests, test_count, NULL, 0, "Json.RoundTrip");
    }

In Read.EdgeCases.c:666:

    
        // Use centralized test driver
        return run_test_suite(tests, test_count, NULL, 0, "Json.Read.EdgeCases");
    }

In BitVec.Pattern.Deadend.c:299:

    
        // Run all deadend tests using the centralized test driver
        return run_test_suite(NULL, 0, deadend_tests, total_deadend_tests, "BitVec.Pattern.Deadend");
    }

In Map.Type.c:122:

    
        WriteFmt("[INFO] Starting Map.Type tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Type");
    }

In Str.Insert.c:354:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Str.Insert");
    }

In Float.Math.c:416:

        int total_deadend_tests = sizeof(deadend_tests) / sizeof(deadend_tests[0]);
    
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "Float.Math");
    }

In Vec.Ops.c:164:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Vec.Ops");
    }

In Vec.Access.c:248:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Vec.Access");
    }

In Int.Convert.c:365:

        int total_deadend_tests = sizeof(deadend_tests) / sizeof(deadend_tests[0]);
    
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "Int.Convert");
    }

In Map.Remove.c:130:

    
        WriteFmt("[INFO] Starting Map.Remove tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Remove");
    }

In Int.Compare.c:87:

    
        int total_tests = sizeof(tests) / sizeof(tests[0]);
        return run_test_suite(tests, total_tests, NULL, 0, "Int.Compare");
    }

In Io.Read.c:998:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Io.Read");
    }

In Map.Foreach.c:86:

    
        WriteFmt("[INFO] Starting Map.Foreach tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Foreach");
    }

In BitVec.Access.Simple.c:693:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "BitVec.Access.Simple");
    }

In BitVec.Foreach.c:749:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Foreach");
    }

In Vec.Remove.c:847:

    
        // Use centralized test driver (no more argc/argv needed)
        return run_test_suite(normal_tests, normal_count, NULL, 0, "Vec.Remove");
    }

In Map.Insert.c:107:

    
        WriteFmt("[INFO] Starting Map.Insert tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Insert");
    }

In Float.Compare.c:128:

    
        int total_tests = sizeof(tests) / sizeof(tests[0]);
        return run_test_suite(tests, total_tests, NULL, 0, "Float.Compare");
    }

In Str.Type.c:161:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, deadend_count, "Str.Type");
    }

In BitVec.Access.Deadend.c:210:

    
        // Run all deadend tests using the centralized test driver
        return run_test_suite(NULL, 0, deadend_tests, total_deadend_tests, "BitVec.Access.Deadend");
    }

In Io.Write.c:741:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Io.Write");
    }

In Str.Foreach.c:625:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Str.Foreach.Simple");
    }

In Vec.Memory.c:189:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Vec.Memory");
    }

In Vec.Init.c:269:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Vec.Init");
    }

In Str.Convert.c:819:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "Str.Convert");
    }

In BitVec.Foreach.Simple.c:660:

    
        // Run simple tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "BitVec.Foreach.Simple");
    }

In BitVec.Remove.c:489:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Remove");
    }

In BitVec.Math.c:881:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Math");
    }

In BitVec.Compare.c:910:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Compare");
    }

In BitVec.Init.c:387:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Init");
    }

In Str.Memory.c:200:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Str.Memory");
    }

In BitVec.BitWise.Deadend.c:149:

    
        // Run all deadend tests using the centralized test driver
        return run_test_suite(NULL, 0, deadend_tests, total_deadend_tests, "BitVec.BitWise.Deadend");
    }

In BitVec.BitWise.Simple.c:921:

    
        // Run simple tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "BitVec.BitWise.Simple");
    }

In Vec.Type.c:79:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Vec.Type");
    }

In Int.Access.c:178:

        int total_deadend_tests = sizeof(deadend_tests) / sizeof(deadend_tests[0]);
    
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "Int.Access");
    }

In Map.Ops.c:184:

    
        WriteFmt("[INFO] Starting Map.Ops tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Ops");
    }

In BitVec.Type.c:59:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "BitVec.Type");
    }

In BitVec.Foreach.Deadend.c:120:

    
        // Run all deadend tests using the centralized test driver
        return run_test_suite(NULL, 0, deadend_tests, total_deadend_tests, "BitVec.Foreach.Deadend");
    }

In Str.Ops.c:258:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Str.Ops");
    }

In Vec.Foreach.c:598:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Vec.Foreach.Simple");
    }

In BitVec.Memory.c:435:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Memory");
    }

In BitVec.Convert.c:702:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Convert");
    }

In Map.Init.c:128:

    
        WriteFmt("[INFO] Starting Map.Init tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Init");
    }

In BitVec.BitWise.c:1034:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.BitWise");
    }

In Vec.Complex.c:880:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Vec.Complex");
    }

In BitVec.Insert.c:335:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Insert");
    }

In Str.Access.c:138:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Str.Access");
    }

In BitVec.Access.c:943:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Access");
    }

In Float.Convert.c:185:

        int total_deadend_tests = sizeof(deadend_tests) / sizeof(deadend_tests[0]);
    
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "Float.Convert");
    }

In Int.Math.c:991:

        int total_deadend_tests = sizeof(deadend_tests) / sizeof(deadend_tests[0]);
    
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "Int.Math");
    }

In Float.Access.c:62:

    
        int total_tests = sizeof(tests) / sizeof(tests[0]);
        return run_test_suite(tests, total_tests, NULL, 0, "Float.Access");
    }

In Float.Type.c:70:

    
        int total_tests = sizeof(tests) / sizeof(tests[0]);
        return run_test_suite(tests, total_tests, NULL, 0, "Float.Type");
    }

In BitVec.Pattern.c:1211:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, deadend_tests, total_deadend_tests, "BitVec.Pattern");
    }

In Int.Type.c:67:

    
        int total_tests = sizeof(tests) / sizeof(tests[0]);
        return run_test_suite(tests, total_tests, NULL, 0, "Int.Type");
    }

In BitVec.Pattern.Simple.c:931:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "BitVec.Pattern.Simple");
    }

In Str.Init.c:223:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Str.Init");
    }

In Vec.Insert.c:487:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Vec.Insert");
    }

In Map.Access.c:99:

    
        WriteFmt("[INFO] Starting Map.Access tests\n\n");
        return run_test_suite(tests, (int)(sizeof(tests) / sizeof(tests[0])), NULL, 0, "Map.Access");
    }

In Str.Remove.c:202:

    
        // Run all tests using the centralized test driver
        return run_test_suite(tests, total_tests, NULL, 0, "Str.Remove");
    }

Last updated on April 20, 2026

ReadCompleteFile Scope