BitVecLongestRun

Documentation

API Reference

BitVecLongestRun

Description

Find the longest consecutive sequence of a specific bit value.

Parameters

Name	Direction	Description
`bv`	in	Bitvector to analyze
`value`	in	Bit value to find runs of (true or false)

Usage example (from documentation)

  u64 longest = BitVecLongestRun(&flags, true);

Returns

Length of longest consecutive sequence

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:1027:

    }
    
    u64 BitVecLongestRun(BitVec *bv, bool value) {
        ValidateBitVec(bv);

In BitVec.Access.Simple.c:522:

    // Test BitVecLongestRun function
    bool test_bitvec_longest_run(void) {
        WriteFmt("Testing BitVecLongestRun\n");
    
        BitVec bv     = BitVecInit();

In BitVec.Access.Simple.c:534:

    
        // Longest run of true should be 3, longest run of false should be 4
        result = result && (BitVecLongestRun(&bv, true) == 3);
        result = result && (BitVecLongestRun(&bv, false) == 4);

In BitVec.Access.Simple.c:535:

        // Longest run of true should be 3, longest run of false should be 4
        result = result && (BitVecLongestRun(&bv, true) == 3);
        result = result && (BitVecLongestRun(&bv, false) == 4);
    
        // Test with all same values

In BitVec.Access.Simple.c:542:

            BitVecPush(&bv, true);
        }
        result = result && (BitVecLongestRun(&bv, true) == 10);
        result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.Simple.c:543:

        }
        result = result && (BitVecLongestRun(&bv, true) == 10);
        result = result && (BitVecLongestRun(&bv, false) == 0);
    
        // Test alternating pattern

In BitVec.Access.Simple.c:550:

            BitVecPush(&bv, i % 2 == 0);
        }
        result = result && (BitVecLongestRun(&bv, true) == 1);
        result = result && (BitVecLongestRun(&bv, false) == 1);

In BitVec.Access.Simple.c:551:

        }
        result = result && (BitVecLongestRun(&bv, true) == 1);
        result = result && (BitVecLongestRun(&bv, false) == 1);
    
        BitVecDeinit(&bv);

In BitVec.Access.Simple.c:631:

    // Edge case tests for LongestRun function
    bool test_bitvec_longest_run_edge_cases(void) {
        WriteFmt("Testing BitVecLongestRun edge cases\n");
    
        BitVec bv     = BitVecInit();

In BitVec.Access.Simple.c:637:

    
        // Test empty bitvector
        result = result && (BitVecLongestRun(&bv, true) == 0);
        result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.Simple.c:638:

        // Test empty bitvector
        result = result && (BitVecLongestRun(&bv, true) == 0);
        result = result && (BitVecLongestRun(&bv, false) == 0);
    
        // Test single element

In BitVec.Access.Simple.c:642:

        // Test single element
        BitVecPush(&bv, true);
        result = result && (BitVecLongestRun(&bv, true) == 1);
        result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.Simple.c:643:

        BitVecPush(&bv, true);
        result = result && (BitVecLongestRun(&bv, true) == 1);
        result = result && (BitVecLongestRun(&bv, false) == 0);
    
        // Test large runs

In BitVec.Access.Simple.c:650:

            BitVecPush(&bv, true);
        }
        result = result && (BitVecLongestRun(&bv, true) == 10000);
        result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.Simple.c:651:

        }
        result = result && (BitVecLongestRun(&bv, true) == 10000);
        result = result && (BitVecLongestRun(&bv, false) == 0);
    
        // Test with one interruption in the middle

In BitVec.Access.Simple.c:655:

        // Test with one interruption in the middle
        BitVecSet(&bv, 5000, false);
        result = result && (BitVecLongestRun(&bv, true) == 5000);
        result = result && (BitVecLongestRun(&bv, false) == 1);

In BitVec.Access.Simple.c:656:

        BitVecSet(&bv, 5000, false);
        result = result && (BitVecLongestRun(&bv, true) == 5000);
        result = result && (BitVecLongestRun(&bv, false) == 1);
    
        BitVecDeinit(&bv);

In BitVec.Access.Deadend.c:46:

    
    bool test_bitvec_longest_run_deadend_tests(void) {
        WriteFmt("Testing BitVecLongestRun deadend scenarios\n");
    
        // This should cause LOG_FATAL and terminate the program

In BitVec.Access.Deadend.c:49:

    
        // This should cause LOG_FATAL and terminate the program
        BitVecLongestRun(NULL, true);
    
        return true; // Should never reach here

In BitVec.Access.c:712:

    // Test BitVecLongestRun function
    bool test_bitvec_longest_run(void) {
        WriteFmt("Testing BitVecLongestRun function\n");
    
        BitVec bv     = BitVecInit();

In BitVec.Access.c:734:

    
        // Longest run of trues should be 5
        result = result && (BitVecLongestRun(&bv, true) == 5);
    
        // Longest run of falses should be 2

In BitVec.Access.c:737:

    
        // Longest run of falses should be 2
        result = result && (BitVecLongestRun(&bv, false) == 2);
    
        // Test with all same values

In BitVec.Access.c:744:

            BitVecPush(&bv, true);
        }
        result = result && (BitVecLongestRun(&bv, true) == 10);
        result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.c:745:

        }
        result = result && (BitVecLongestRun(&bv, true) == 10);
        result = result && (BitVecLongestRun(&bv, false) == 0);
    
        // Test alternating pattern

In BitVec.Access.c:752:

            BitVecPush(&bv, i % 2 == 0);
        }
        result = result && (BitVecLongestRun(&bv, true) == 1);
        result = result && (BitVecLongestRun(&bv, false) == 1);

In BitVec.Access.c:753:

        }
        result = result && (BitVecLongestRun(&bv, true) == 1);
        result = result && (BitVecLongestRun(&bv, false) == 1);
    
        BitVecDeinit(&bv);

In BitVec.Access.c:833:

    // Edge case tests for LongestRun function
    bool test_bitvec_longest_run_edge_cases(void) {
        WriteFmt("Testing BitVecLongestRun edge cases\n");
    
        BitVec bv     = BitVecInit();

In BitVec.Access.c:839:

    
        // Test empty bitvector
        result = result && (BitVecLongestRun(&bv, true) == 0);
        result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.c:840:

        // Test empty bitvector
        result = result && (BitVecLongestRun(&bv, true) == 0);
        result = result && (BitVecLongestRun(&bv, false) == 0);
    
        // Test single element

In BitVec.Access.c:844:

        // Test single element
        BitVecPush(&bv, true);
        result = result && (BitVecLongestRun(&bv, true) == 1);
        result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.c:845:

        BitVecPush(&bv, true);
        result = result && (BitVecLongestRun(&bv, true) == 1);
        result = result && (BitVecLongestRun(&bv, false) == 0);
    
        // Test large runs

In BitVec.Access.c:852:

            BitVecPush(&bv, true);
        }
        result = result && (BitVecLongestRun(&bv, true) == 10000);
        result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.c:853:

        }
        result = result && (BitVecLongestRun(&bv, true) == 10000);
        result = result && (BitVecLongestRun(&bv, false) == 0);
    
        // Test with one interruption in the middle

In BitVec.Access.c:857:

        // Test with one interruption in the middle
        BitVecSet(&bv, 5000, false);
        result = result && (BitVecLongestRun(&bv, true) == 5000);
        result = result && (BitVecLongestRun(&bv, false) == 1);

In BitVec.Access.c:858:

        BitVecSet(&bv, 5000, false);
        result = result && (BitVecLongestRun(&bv, true) == 5000);
        result = result && (BitVecLongestRun(&bv, false) == 1);
    
        BitVecDeinit(&bv);

In BitVec.Access.c:884:

    
    bool test_bitvec_longest_run_deadend_tests(void) {
        WriteFmt("Testing BitVecLongestRun deadend scenarios\n");
    
        // This should cause LOG_FATAL and terminate the program

In BitVec.Access.c:887:

    
        // This should cause LOG_FATAL and terminate the program
        BitVecLongestRun(NULL, true);
    
        return true; // Should never reach here

Last updated on April 20, 2026

BitVecLen BitVecMatches