run_test_suite

Function
April 17, 2026

Table of Contents

`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)

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 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 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:366:

    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 Int.Compare.c:99:

    
    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 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 Float.Compare.c:119:

    
    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 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 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:1009:

    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 Str.Remove.c:202:

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

run_test_suite

`run_test_suite`

Description

Parameters

Success

Failure

Usage example (Cross-references)

Tags :

Share :

Related Posts

simple_test_driver

deadend_test_driver