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

Success

Returns the length of the longest consecutive run of bits equal to value. The bitvector is not modified.

Failure

Returns 0 when no bit matches value (including an empty bitvector). The bitvector is not modified.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:1225:

    }
    
    u64 BitVecLongestRun(const BitVec *bv, bool value) {
        ValidateBitVec(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.Simple.c:572:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLongestRun\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:584:

    
        // 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:585:

        // 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:592:

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

In BitVec.Access.Simple.c:593:

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

In BitVec.Access.Simple.c:600:

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

In BitVec.Access.Simple.c:601:

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

In BitVec.Access.Simple.c:690:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLongestRun edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.Simple.c:696:

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

In BitVec.Access.Simple.c:697:

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

In BitVec.Access.Simple.c:701:

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

In BitVec.Access.Simple.c:702:

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

In BitVec.Access.Simple.c:709:

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

In BitVec.Access.Simple.c:710:

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

In BitVec.Access.Simple.c:714:

        // 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:715:

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

In BitVec.Access.c:788:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLongestRun function\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:810:

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

In BitVec.Access.c:813:

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

In BitVec.Access.c:820:

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

In BitVec.Access.c:821:

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

In BitVec.Access.c:828:

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

In BitVec.Access.c:829:

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

In BitVec.Access.c:918:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecLongestRun edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Access.c:924:

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

In BitVec.Access.c:925:

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

In BitVec.Access.c:929:

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

In BitVec.Access.c:930:

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

In BitVec.Access.c:937:

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

In BitVec.Access.c:938:

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

In BitVec.Access.c:942:

        // 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:943:

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

In BitVec.Access.c:970:

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

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

Last updated on June 4, 2026

BitVecLen BitVecMatches