BitVecDeinit
- Function
- August 22, 2025
Table of Contents
BitVecDeinit
BitVecDeinitDescription
Deinitialize bitvector and free all allocated memory. After calling this, the bitvector should not be used unless re-initialized.
Parameters
| Name | Direction | Description |
|---|---|---|
bv | in | Pointer to bitvector to deinitialize |
Usage example (from documentation)
BitVecDeinit(&flags);
Usage example (Cross-references)
- In
BitVec.c:38:
#define BYTES_FOR_BITS(bits) (((bits) + BITS_PER_BYTE - 1) / BITS_PER_BYTE)
void BitVecDeinit(BitVec *bitvec) {
ValidateBitVec(bitvec);
if (bitvec->data) {
- In
BitVec.c:934:
}
BitVecDeinit(&temp);
}
- In
BitVec.c:958:
}
BitVecDeinit(&temp);
}
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
result = result && (count == 1000);
BitVecDeinit(&bv);
return result;
}
});
BitVecDeinit(&bv);
return result;
}
});
BitVecDeinit(&bv);
return result;
}
result = result && (count == 2); // Should iterate over indices 8,9
BitVecDeinit(&bv);
return result;
}
result = result && (count4 == sz);
BitVecDeinit(&bv);
}
}
BitVecDeinit(&bv);
return result;
}
u64 count = BitVecRunLengths(&empty_bv, runs, values, 5);
result = result && (count == 0);
BitVecDeinit(&empty_bv);
// Test 2: Single bit (true)
result = result && (count == 1);
result = result && (runs[0] == 1 && values[0] == true);
BitVecDeinit(&single_bv);
// Test 3: Single bit (false)
result = result && (count == 1);
result = result && (runs[0] == 1 && values[0] == false);
BitVecDeinit(&single_false_bv);
// Test 4: All same bits (all true)
result = result && (count == 1);
result = result && (runs[0] == 10 && values[0] == true);
BitVecDeinit(&all_true_bv);
// Test 5: Alternating bits (0101010)
result = result && (alt_values[i] == (i % 2 == 0));
}
BitVecDeinit(&alternating_bv);
return result;
result = result && (count == 8);
BitVecDeinit(&bv);
return result;
}
}
BitVecDeinit(&large_bv);
return result;
}
BitVecRunLengths(&bv, NULL, values, 5);
BitVecDeinit(&bv);
return true; // Should never reach here
}
BitVecRunLengths(&bv, runs, NULL, 5);
BitVecDeinit(&bv);
return true; // Should never reach here
}
BitVecRunLengths(&bv, runs, values, 0);
BitVecDeinit(&bv);
return true; // Should never reach here
}
- In
BitVec.Init.c:36:
// Clean up
BitVecDeinit(&bv);
return result;
- In
BitVec.Init.c:43:
// Test BitVecDeinit function
bool test_bitvec_deinit(void) {
printf("Testing BitVecDeinit\n");
BitVec bv = BitVecInit();
- In
BitVec.Init.c:56:
// Deinitialize
BitVecDeinit(&bv);
// After deinitialization, the bitvector should be in a safe state
- In
BitVec.Init.c:97:
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up all
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
// Clean up all
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
return result;
result = result && (bv.capacity == cap_before);
BitVecDeinit(&bv);
return result;
}
result = result && (bv.length == 10);
BitVecDeinit(&bv);
return result;
}
result = result && (bv.length == 0);
BitVecDeinit(&bv);
return result;
}
result = result && (bv.length == (size)(cycle % 10));
BitVecDeinit(&bv);
}
// Test NULL bitvec pointer - should abort
BitVecDeinit(NULL);
// If we reach here, validation didn't work as expected
// If we reach here, validation didn't work as expected
BitVecDeinit(&bv);
return false;
}
// If we reach here, validation didn't work as expected
BitVecDeinit(&bv);
return false;
}
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&original);
BitVecDeinit(&clone);
// Clean up
BitVecDeinit(&original);
BitVecDeinit(&clone);
return result;
result = result && (bv.length == 0);
BitVecDeinit(&bv);
return result;
}
result = result && (bv.capacity >= 10000);
BitVecDeinit(&bv);
return result;
}
result = result && (bv1.length == 2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
BitVec clone1 = BitVecClone(&bv);
result = result && (clone1.length == 0);
BitVecDeinit(&clone1);
// Test clone single element
result = result && (clone2.length == 1);
result = result && (BitVecGet(&clone2, 0) == true);
BitVecDeinit(&clone2);
// Test clone large data
result = result && (BitVecGet(&clone3, 0) != BitVecGet(&bv, 0));
BitVecDeinit(&clone3);
BitVecDeinit(&bv);
return result;
BitVecDeinit(&clone3);
BitVecDeinit(&bv);
return result;
}
}
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&clone);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&clone);
}
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&clone);
}
BitVecSwap(NULL, &bv);
BitVecDeinit(&bv);
return false;
}
(BitVecGet(&bv, 3) == false);
BitVecDeinit(&bv);
return result;
}
(BitVecGet(&bv, 3) == false);
BitVecDeinit(&bv);
return result;
}
(BitVecGet(&bv, 3) == false); // unchanged
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecCapacity(&bv) >= 100);
BitVecDeinit(&bv);
return result;
}
bool result = (BitVecCountOnes(&bv) == 3) && (BitVecCountZeros(&bv) == 2);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&bv, 63) == false); // 63 % 2 == 1, so i%2==0 is false for i=63
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&bv, 0) == false);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&bv, 0) == false);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecCountZeros(&bv) == 0);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecCountZeros(&bv) == 0);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecCountZeros(&bv) == 500);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecCountZeros(&bv) == 1);
BitVecDeinit(&bv);
return result;
}
}
BitVecDeinit(&bv);
return result;
}
}
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecFindLast(&bv, false) == SIZE_MAX);
BitVecDeinit(&bv);
return result;
}
result = result && !BitVecNone(&bv, false);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecLongestRun(&bv, false) == 1);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecFindLast(&bv, true) == 999);
BitVecDeinit(&bv);
return result;
}
result = result && BitVecAny(&bv, false);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecLongestRun(&bv, false) == 1);
BitVecDeinit(&bv);
return result;
}
BitVecGet(&bv, 0);
BitVecDeinit(&bv);
return false;
}
BitVecSet(&bv, 0, true);
BitVecDeinit(&bv);
return false;
}
BitVecFlip(&bv, 0);
BitVecDeinit(&bv);
return false;
}
BitVecGet(&bv, 1000);
BitVecDeinit(&bv);
return false;
}
BitVecSet(&bv, 500, true);
BitVecDeinit(&bv);
return false;
}
BitVecFlip(&bv, 10);
BitVecDeinit(&bv);
return false;
}
BitVecGet(&bv, SIZE_MAX);
BitVecDeinit(&bv);
return false;
}
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&source);
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&source);
return result;
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
return result;
result = result && (BitVecGet(&bv, 999) == true);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&bv, 500) == false);
BitVecDeinit(&bv);
BitVecDeinit(&empty);
BitVecDeinit(&source);
BitVecDeinit(&bv);
BitVecDeinit(&empty);
BitVecDeinit(&source);
return result;
BitVecDeinit(&bv);
BitVecDeinit(&empty);
BitVecDeinit(&source);
return result;
}
result = result && (BitVecGet(&bv, 1) == true); // Second bit
BitVecDeinit(&bv);
return result;
}
BitVecInsertRange(&bv, SIZE_MAX, 1, true);
BitVecDeinit(&bv);
return false;
}
BitVecFindPattern(NULL, &pattern); // Should cause LOG_FATAL
BitVecDeinit(&pattern);
return true;
}
BitVecFindPattern(&source, NULL); // Should cause LOG_FATAL
BitVecDeinit(&source);
return true;
}
BitVecFindLastPattern(NULL, &pattern); // Should cause LOG_FATAL
BitVecDeinit(&pattern);
return true;
}
BitVecFindLastPattern(&source, NULL); // Should cause LOG_FATAL
BitVecDeinit(&source);
return true;
}
BitVecFindAllPattern(&source, NULL, results, 10); // Should cause LOG_FATAL
BitVecDeinit(&source);
return true;
}
BitVecFindAllPattern(&source, &pattern, NULL, 10); // Should cause LOG_FATAL
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return true;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return true;
}
BitVecFindAllPattern(&source, &pattern, results, 0); // Should cause LOG_FATAL
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return true;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return true;
}
BitVecPush(&prefix, true);
BitVecStartsWith(NULL, &prefix);
BitVecDeinit(&prefix);
return true;
}
BitVecPush(&source, true);
BitVecStartsWith(&source, NULL);
BitVecDeinit(&source);
return true;
}
BitVecPush(&suffix, true);
BitVecEndsWith(NULL, &suffix);
BitVecDeinit(&suffix);
return true;
}
BitVecPush(&source, true);
BitVecEndsWith(&source, NULL);
BitVecDeinit(&source);
return true;
}
BitVecPush(&pattern, true);
BitVecContainsAt(NULL, &pattern, 0);
BitVecDeinit(&pattern);
return true;
}
BitVecPush(&source, true);
BitVecContainsAt(&source, NULL, 0);
BitVecDeinit(&source);
return true;
}
BitVecPush(&wildcard, false);
BitVecMatches(NULL, &pattern, &wildcard);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
return true;
BitVecMatches(NULL, &pattern, &wildcard);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
return true;
}
BitVecPush(&source, true);
BitVecRegexMatch(&source, NULL);
BitVecDeinit(&source);
return true;
}
bool test_bitvec_prefix_match_null_source(void) {
printf("Testing BitVecPrefixMatch(NULL, patterns, 1) - should fatal\n");
BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit);
BitVecPush(VecPtrAt(&vp, 0), true);
BitVecPrefixMatch(NULL, &vp);
BitVecPush(&source, true);
BitVecPrefixMatch(&source, NULL);
BitVecDeinit(&source);
return true;
}
bool test_bitvec_suffix_match_null_source(void) {
printf("Testing BitVecSuffixMatch(NULL, patterns, 1) - should fatal\n");
BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit);
BitVecPush(VecPtrAt(&vp, 0), true);
BitVecSuffixMatch(NULL, &vp);
BitVecPush(&source, true);
BitVecSuffixMatch(&source, NULL);
BitVecDeinit(&source);
return true;
}
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
}
BitVecDeinit(&bv);
return result;
}
result = result && (bv.length == 999);
BitVecDeinit(&bv);
return result;
}
result = result && (bv.length == 5); // Should have 5 elements left
BitVecDeinit(&bv);
return result;
}
result = result && (found == true) && (bv.length == 999);
BitVecDeinit(&bv);
return result;
}
result = result && (count == 500) && (bv.length == 500);
BitVecDeinit(&bv);
return result;
}
BitVecRemoveRange(&bv, SIZE_MAX, 1);
BitVecDeinit(&bv);
return false;
}
BitVecPop(&bv);
BitVecDeinit(&bv);
return false;
}
BitVecRemove(&bv, 0);
BitVecDeinit(&bv);
return false;
}
BitVecRemoveRange(&bv, 0, 1);
BitVecDeinit(&bv);
return false;
}
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&result);
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&result);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
result = result && (bv.length == 1000);
BitVecDeinit(&bv);
return result;
}
result = result && (bv.length == 2);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&result_bv, 0) == false);
BitVecDeinit(&result_bv);
BitVecDeinit(&bv1);
BitVecDeinit(&result_bv);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (BitVecGet(&bv, 1) == false);
BitVecDeinit(&bv);
return result;
}
}
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
}
result = result && (BitVecGet(&bv, 2) == true); // original bit 0
BitVecDeinit(&bv);
BitVecDeinit(&original);
return result;
BitVecDeinit(&bv);
BitVecDeinit(&original);
return result;
}
result = result && (BitVecGet(&bv, 4) == false);
BitVecDeinit(&bv);
BitVecDeinit(&original);
return result;
BitVecDeinit(&bv);
BitVecDeinit(&original);
return result;
}
test_result = test_result && or_ones;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
}
test_result = test_result && xor_commutative;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result1);
BitVecDeinit(&result2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result1);
BitVecDeinit(&result2);
return test_result;
BitVecDeinit(&bv2);
BitVecDeinit(&result1);
BitVecDeinit(&result2);
return test_result;
}
}
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
}
BitVecAnd(NULL, &bv, &bv2);
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
return false;
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
return false;
}
BitVecAnd(NULL, &bv1, &bv2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return false;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return false;
}
BitVecOr(&result, &bv1, NULL);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
return false;
BitVecDeinit(&result);
BitVecDeinit(&bv1);
return false;
}
BitVecXor(&result, NULL, &bv1);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
return false;
BitVecDeinit(&result);
BitVecDeinit(&bv1);
return false;
}
BitVecNot(&result, NULL);
BitVecDeinit(&result);
return false;
}
- In
Io.Write.c:608:
// Cleanup
BitVecDeinit(&bv1);
BitVecDeinit(&bv_empty);
BitVecDeinit(&bv2);
- In
Io.Write.c:609:
// Cleanup
BitVecDeinit(&bv1);
BitVecDeinit(&bv_empty);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
- In
Io.Write.c:610:
BitVecDeinit(&bv1);
BitVecDeinit(&bv_empty);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv_zero);
- In
Io.Write.c:611:
BitVecDeinit(&bv_empty);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv_zero);
StrDeinit(&output);
- In
Io.Write.c:612:
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv_zero);
StrDeinit(&output);
return success;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&result);
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&result);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
// Clean up
BitVecDeinit(&bv);
return test_result;
result = result && (bv.length == 1000);
BitVecDeinit(&bv);
return result;
}
result = result && (bv.length == 2);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&result_bv, 0) == false);
BitVecDeinit(&result_bv);
BitVecDeinit(&bv1);
BitVecDeinit(&result_bv);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (BitVecGet(&bv, 1) == false);
BitVecDeinit(&bv);
return result;
}
}
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
}
result = result && (BitVecGet(&bv, 2) == true); // original bit 0
BitVecDeinit(&bv);
BitVecDeinit(&original);
return result;
BitVecDeinit(&bv);
BitVecDeinit(&original);
return result;
}
result = result && (BitVecGet(&bv, 4) == false);
BitVecDeinit(&bv);
BitVecDeinit(&original);
return result;
BitVecDeinit(&bv);
BitVecDeinit(&original);
return result;
}
test_result = test_result && or_ones;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
}
test_result = test_result && xor_commutative;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result1);
BitVecDeinit(&result2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result1);
BitVecDeinit(&result2);
return test_result;
BitVecDeinit(&bv2);
BitVecDeinit(&result1);
BitVecDeinit(&result2);
return test_result;
}
}
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
return test_result;
}
// Clean up
StrDeinit(&str);
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&empty_bv);
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&empty_bv);
return result;
result = result && (bytes[0] == 0xCD || bytes[0] == 0xB3);
}
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&zero_bv);
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&zero_bv);
return result;
StrDeinit(&str_obj);
BitVecDeinit(&bv);
return result;
}
BitVec bv1 = BitVecFromStr("");
result = result && (bv1.length == 0);
BitVecDeinit(&bv1);
// Test single character
result = result && (bv2.length == 1);
result = result && (BitVecGet(&bv2, 0) == true);
BitVecDeinit(&bv2);
// Test long string
result = result && (BitVecGet(&bv3, 0) == true);
result = result && (BitVecGet(&bv3, 1) == false);
BitVecDeinit(&bv3);
return result;
BitVec bv2 = BitVecFromBytes(empty_bytes, 0); // 0 bits
result = result && (bv2.length == 0);
BitVecDeinit(&bv2);
// Test single byte
BitVec bv3 = BitVecFromBytes(single_byte, 8); // 8 bits from 1 byte
result = result && (bv3.length == 8);
BitVecDeinit(&bv3);
BitVecDeinit(&bv);
BitVecDeinit(&bv3);
BitVecDeinit(&bv);
return result;
}
BitVec bv2 = BitVecFromInteger(0, 8); // 8 bits for zero
result = result && (bv2.length == 8); // Should be 8 bits
BitVecDeinit(&bv2);
// Test large integer
BitVec bv3 = BitVecFromInteger(UINT64_MAX, 64); // 64 bits for max value
result = result && (bv3.length == 64);
BitVecDeinit(&bv3);
BitVecDeinit(&bv);
BitVecDeinit(&bv3);
BitVecDeinit(&bv);
return result;
}
StrDeinit(&str);
BitVecDeinit(&bv);
}
result = result && (recovered == value);
BitVecDeinit(&bv);
}
}
result = result && (recovered_byte == test_bytes[i]);
BitVecDeinit(&bv);
}
u64 large_value = BitVecToInteger(&large_bv);
result = result && (large_value == 0xFFFFFFFFFFFFFFFF);
BitVecDeinit(&large_bv);
// Test oversized bitvec to integer (should handle gracefully)
// Should return some value or 0, but not crash
result = result && (oversized_value >= 0); // Always true for u64, but documents intent
BitVecDeinit(&oversized);
// Test zero-length conversions
result = result && (empty_bytes[0] == 0xFF); // Should be unchanged
BitVecDeinit(&empty);
return result;
result = result && (written == test_cases[i].byte_count);
BitVecDeinit(&bv);
}
StrDeinit(&str2);
StrDeinit(&str3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
StrDeinit(&str3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
return result;
result = result && recovered_pattern_correct;
BitVecDeinit(&large_bv);
BitVecDeinit(&recovered_bv);
BitVecDeinit(&large_bv);
BitVecDeinit(&recovered_bv);
// Test string to bitvec with large patterns
result = result && large_pattern_correct;
BitVecDeinit(&large_from_str);
return result;
// Should handle gracefully
BitVecDeinit(&bv);
// Test fromBytes with 0 bit length - should return empty bitvec
BitVec empty_bv = BitVecFromBytes(dummy_bytes, 0);
bool result = (empty_bv.length == 0);
BitVecDeinit(&empty_bv);
return result;
- In
Io.Read.c:675:
);
StrDeinit(&result1);
BitVecDeinit(&bv1);
// Test 2: Reading hex format
- In
Io.Read.c:683:
success = success && (value2 == 0xDEAD);
printf("Test 2 - Hex: 0x%llx, Success: %s\n", value2, (value2 == 0xDEAD) ? "true" : "false");
BitVecDeinit(&bv2);
// Test 3: Reading octal format
- In
Io.Read.c:691:
success = success && (value3 == 0755);
printf("Test 3 - Octal: %llo, Success: %s\n", value3, (value3 == 0755) ? "true" : "false");
BitVecDeinit(&bv3);
// Test 4: Reading with whitespace
- In
Io.Read.c:705:
);
StrDeinit(&result4);
BitVecDeinit(&bv4);
// Test 5: Reading zero values
- In
Io.Read.c:719:
);
StrDeinit(&result5);
BitVecDeinit(&bv5);
printf("Overall BitVec reading success: %s\n", success ? "true" : "false");
- In
BitVec.Type.c:25:
// Clean up
BitVecDeinit(&bitvec);
return result;
- In
BitVec.Type.c:41:
// Clean up
BitVecDeinit(&bitvec);
// Note: We can't easily test the negative case (invalid bitvector)
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
result = result && (count == 1000);
BitVecDeinit(&bv);
return result;
}
});
BitVecDeinit(&bv);
return result;
}
});
BitVecDeinit(&bv);
return result;
}
result = result && (count == 2); // Should iterate over indices 8,9
BitVecDeinit(&bv);
return result;
}
result = result && (count4 == sz);
BitVecDeinit(&bv);
}
}
BitVecDeinit(&bv);
return result;
}
u64 count = BitVecRunLengths(&empty_bv, runs, values, 5);
result = result && (count == 0);
BitVecDeinit(&empty_bv);
// Test 2: Single bit (true)
result = result && (count == 1);
result = result && (runs[0] == 1 && values[0] == true);
BitVecDeinit(&single_bv);
// Test 3: Single bit (false)
result = result && (count == 1);
result = result && (runs[0] == 1 && values[0] == false);
BitVecDeinit(&single_false_bv);
// Test 4: All same bits (all true)
result = result && (count == 1);
result = result && (runs[0] == 10 && values[0] == true);
BitVecDeinit(&all_true_bv);
// Test 5: Alternating bits (0101010)
result = result && (alt_values[i] == (i % 2 == 0));
}
BitVecDeinit(&alternating_bv);
return result;
result = result && (count == 8);
BitVecDeinit(&bv);
return result;
}
}
BitVecDeinit(&large_bv);
return result;
}
result = result && (index == 1); // Should find pattern at index 1 (101...)
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
// Depending on the exact source pattern, adjust this test
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (index == 2); // Only occurrence at index 2
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (count == 3); // Should find at 0, 3, 6
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (results[0] == 0);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (count > 0); // Should find at least some patterns
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && !BitVecStartsWith(&source, &prefix);
BitVecDeinit(&source);
BitVecDeinit(&prefix);
return result;
BitVecDeinit(&source);
BitVecDeinit(&prefix);
return result;
}
result = result && BitVecStartsWith(&source, &prefix);
BitVecDeinit(&source);
BitVecDeinit(&prefix);
return result;
BitVecDeinit(&source);
BitVecDeinit(&prefix);
return result;
}
result = result && !BitVecEndsWith(&source, &suffix);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
return result;
BitVecDeinit(&source);
BitVecDeinit(&suffix);
return result;
}
result = result && !BitVecEndsWith(&source, &suffix);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
return result;
BitVecDeinit(&source);
BitVecDeinit(&suffix);
return result;
}
result = result && (BitVecFindPattern(&source, &pattern) == SIZE_MAX);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && BitVecContainsAt(&source, &pattern, 3); // Should match
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && !BitVecContainsAt(&source, &pattern, 0); // Pattern too long
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (count == 3);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (pos == 3); // Should find at position 3
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (BitVecGet(&source, 2) == true);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
return result;
}
result = result && (BitVecLen(&source) == 6); // 3 * 2 = 6
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
return result;
}
result = result && BitVecMatches(&source, &pattern, &wildcard);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
return result;
}
result = result && (pos == 0); // Should match 110 with 1 error
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && !BitVecRegexMatch(&source, "111");
BitVecDeinit(&source);
return result;
}
BitVec source = BitVecInit();
BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit);
bool result = true;
VecDeinit(&patterns);
BitVecDeinit(&source);
return result;
}
BitVec source = BitVecInit();
BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit);
bool result = true;
VecDeinit(&patterns);
BitVecDeinit(&source);
return result;
}
- In
BitVec.Math.c:88:
result = result && (distance == 1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
- In
BitVec.Math.c:89:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (distance == 2); // Length of bv1
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (fabs(similarity - 0.5) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (fabs(similarity - 1.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (fabs(similarity - 0.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (similarity == 0.0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (product == 0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (product == 1); // Only first position counts
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (distance == 1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (distance == 2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (fabs(correlation + 1.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (correlation == 0.0); // No variance
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (entropy == 0.0);
BitVecDeinit(&bv);
return result;
}
result = result && (entropy == 0.0);
BitVecDeinit(&bv);
return result;
}
result = result && (score == -3); // 3 mismatches * -1
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (score == 2); // 2 matches
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (best_pos == 0 || best_pos == 4);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (best_pos == 0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && (edit_dist < 100);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&small1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&small1);
BitVecDeinit(&small2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&small1);
BitVecDeinit(&small2);
return result;
BitVecDeinit(&bv2);
BitVecDeinit(&small1);
BitVecDeinit(&small2);
return result;
}
BitVecPush(&bv2, true);
BitVecHammingDistance(NULL, &bv2);
BitVecDeinit(&bv2);
return true;
}
BitVecPush(&bv1, true);
BitVecHammingDistance(&bv1, NULL);
BitVecDeinit(&bv1);
return true;
}
BitVecPush(&bv2, true);
BitVecJaccardSimilarity(NULL, &bv2);
BitVecDeinit(&bv2);
return true;
}
BitVecPush(&bv1, true);
BitVecJaccardSimilarity(&bv1, NULL);
BitVecDeinit(&bv1);
return true;
}
BitVecPush(&bv2, true);
BitVecCosineSimilarity(NULL, &bv2);
BitVecDeinit(&bv2);
return true;
}
BitVecPush(&bv1, true);
BitVecCosineSimilarity(&bv1, NULL);
BitVecDeinit(&bv1);
return true;
}
BitVecPush(&bv2, true);
BitVecDotProduct(NULL, &bv2);
BitVecDeinit(&bv2);
return true;
}
BitVecPush(&bv1, true);
BitVecDotProduct(&bv1, NULL);
BitVecDeinit(&bv1);
return true;
}
BitVecPush(&bv2, true);
BitVecEditDistance(NULL, &bv2);
BitVecDeinit(&bv2);
return true;
}
BitVecPush(&bv1, true);
BitVecEditDistance(&bv1, NULL);
BitVecDeinit(&bv1);
return true;
}
BitVecPush(&bv2, true);
BitVecCorrelation(NULL, &bv2);
BitVecDeinit(&bv2);
return true;
}
BitVecPush(&bv1, true);
BitVecCorrelation(&bv1, NULL);
BitVecDeinit(&bv1);
return true;
}
BitVecPush(&bv2, true);
BitVecAlignmentScore(NULL, &bv2, 1, -1);
BitVecDeinit(&bv2);
return true;
}
BitVecPush(&bv1, true);
BitVecAlignmentScore(&bv1, NULL, 1, -1);
BitVecDeinit(&bv1);
return true;
}
BitVecPush(&bv2, true);
BitVecBestAlignment(NULL, &bv2);
BitVecDeinit(&bv2);
return true;
}
BitVecPush(&bv1, true);
BitVecBestAlignment(&bv1, NULL);
BitVecDeinit(&bv1);
return true;
}
result = result && (index == 1); // Should find pattern at index 1 (101...)
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
// Depending on the exact source pattern, adjust this test
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (index == 2); // Only occurrence at index 2
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (count == 3); // Should find at 0, 3, 6
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (results[0] == 0);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (count > 0); // Should find at least some patterns
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
BitVecFindPattern(NULL, &pattern); // Should cause LOG_FATAL
BitVecDeinit(&pattern);
return true;
}
BitVecFindPattern(&source, NULL); // Should cause LOG_FATAL
BitVecDeinit(&source);
return true;
}
BitVecFindLastPattern(NULL, &pattern); // Should cause LOG_FATAL
BitVecDeinit(&pattern);
return true;
}
BitVecFindLastPattern(&source, NULL); // Should cause LOG_FATAL
BitVecDeinit(&source);
return true;
}
BitVecFindAllPattern(&source, NULL, results, 10); // Should cause LOG_FATAL
BitVecDeinit(&source);
return true;
}
BitVecFindAllPattern(&source, &pattern, NULL, 10); // Should cause LOG_FATAL
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return true;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return true;
}
BitVecFindAllPattern(&source, &pattern, results, 0); // Should cause LOG_FATAL
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return true;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return true;
}
result = result && !BitVecStartsWith(&source, &prefix);
BitVecDeinit(&source);
BitVecDeinit(&prefix);
return result;
BitVecDeinit(&source);
BitVecDeinit(&prefix);
return result;
}
result = result && BitVecStartsWith(&source, &prefix);
BitVecDeinit(&source);
BitVecDeinit(&prefix);
return result;
BitVecDeinit(&source);
BitVecDeinit(&prefix);
return result;
}
result = result && !BitVecEndsWith(&source, &suffix);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
return result;
BitVecDeinit(&source);
BitVecDeinit(&suffix);
return result;
}
result = result && !BitVecEndsWith(&source, &suffix);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
return result;
BitVecDeinit(&source);
BitVecDeinit(&suffix);
return result;
}
result = result && !BitVecContains(&source, &pattern);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && BitVecContainsAt(&source, &pattern, 3); // Should match
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && !BitVecContainsAt(&source, &pattern, 0); // Pattern too long
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (count == 3);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (pos == 3); // Should find at position 3
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && (BitVecGet(&source, 2) == true);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
return result;
}
result = result && (BitVecLen(&source) == 6); // 3 * 2 = 6
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
return result;
}
result = result && BitVecMatches(&source, &pattern, &wildcard);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
return result;
}
result = result && (pos == 0); // Should match 110 with 1 error
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
BitVecDeinit(&source);
BitVecDeinit(&pattern);
return result;
}
result = result && !BitVecRegexMatch(&source, "111");
BitVecDeinit(&source);
return result;
}
for (int i = 0; i < 3; i++) {
BitVecDeinit(&patterns[i]);
}
BitVecDeinit(&source);
BitVecDeinit(&patterns[i]);
}
BitVecDeinit(&source);
return result;
}
for (int i = 0; i < 3; i++) {
BitVecDeinit(&patterns[i]);
}
BitVecDeinit(&source);
BitVecDeinit(&patterns[i]);
}
BitVecDeinit(&source);
return result;
}
BitVecPush(&prefix, true);
BitVecStartsWith(NULL, &prefix);
BitVecDeinit(&prefix);
return true;
}
BitVecPush(&source, true);
BitVecStartsWith(&source, NULL);
BitVecDeinit(&source);
return true;
}
BitVecPush(&suffix, true);
BitVecEndsWith(NULL, &suffix);
BitVecDeinit(&suffix);
return true;
}
BitVecPush(&source, true);
BitVecEndsWith(&source, NULL);
BitVecDeinit(&source);
return true;
}
BitVecPush(&pattern, true);
BitVecContainsAt(NULL, &pattern, 0);
BitVecDeinit(&pattern);
return true;
}
BitVecPush(&source, true);
BitVecContainsAt(&source, NULL, 0);
BitVecDeinit(&source);
return true;
}
BitVecPush(&wildcard, false);
BitVecMatches(NULL, &pattern, &wildcard);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
return true;
BitVecMatches(NULL, &pattern, &wildcard);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
return true;
}
BitVecPush(&source, true);
BitVecRegexMatch(&source, NULL);
BitVecDeinit(&source);
return true;
}
BitVecPush(&patterns[0], true);
BitVecPrefixMatch(NULL, patterns, 1);
BitVecDeinit(&patterns[0]);
return true;
}
BitVecPush(&source, true);
BitVecPrefixMatch(&source, NULL, 1);
BitVecDeinit(&source);
return true;
}
BitVecPush(&patterns[0], true);
BitVecSuffixMatch(NULL, patterns, 1);
BitVecDeinit(&patterns[0]);
return true;
}
BitVecPush(&source, true);
BitVecSuffixMatch(&source, NULL, 1);
BitVecDeinit(&source);
return true;
}
BitVecAnd(NULL, &bv, &bv2);
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
return false;
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
return false;
}
BitVecAnd(NULL, &bv1, &bv2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return false;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return false;
}
BitVecOr(&result, &bv1, NULL);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
return false;
BitVecDeinit(&result);
BitVecDeinit(&bv1);
return false;
}
BitVecXor(&result, NULL, &bv1);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
return false;
BitVecDeinit(&result);
BitVecDeinit(&bv1);
return false;
}
BitVecNot(&result, NULL);
BitVecDeinit(&result);
return false;
}
BitVecRunLengths(&bv, NULL, values, 5);
BitVecDeinit(&bv);
return true; // Should never reach here
}
BitVecRunLengths(&bv, runs, NULL, 5);
BitVecDeinit(&bv);
return true; // Should never reach here
}
BitVecRunLengths(&bv, runs, values, 0);
BitVecDeinit(&bv);
return true; // Should never reach here
}
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
result = result && (BitVecGet(&bv, 999) == (999 % 3 == 0)); // Last
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&bv, 0) == true);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&bv, 0) == true);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecCountZeros(&bv) == 0);
BitVecDeinit(&bv);
return result;
}
}
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&bv, bv.length - 1) == true); // Last bit
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecByteSize(&bv) >= 8); // At least 8 bytes for 64 bits
BitVecDeinit(&bv);
return result;
}
}
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecGet(&bv, 4) == true); // F(4) = 0 XOR 1 = 1
BitVecDeinit(&bv);
return result;
}
BitVecGet(&bv, 0);
BitVecDeinit(&bv);
return false;
}
BitVecSet(&bv, 0, true);
BitVecDeinit(&bv);
return false;
}
BitVecFlip(&bv, 0);
BitVecDeinit(&bv);
return false;
}
BitVecGet(&bv, 1000);
BitVecDeinit(&bv);
return false;
}
BitVecSet(&bv, 500, true);
BitVecDeinit(&bv);
return false;
}
BitVecFlip(&bv, 10);
BitVecDeinit(&bv);
return false;
}
BitVecGet(&bv, SIZE_MAX);
BitVecDeinit(&bv);
return false;
}
result = result && (BitVecFindLast(&bv, false) == SIZE_MAX);
BitVecDeinit(&bv);
return result;
}
result = result && !BitVecNone(&bv, false);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecLongestRun(&bv, false) == 1);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecFindLast(&bv, true) == 999);
BitVecDeinit(&bv);
return result;
}
result = result && BitVecAny(&bv, false);
BitVecDeinit(&bv);
return result;
}
result = result && (BitVecLongestRun(&bv, false) == 1);
BitVecDeinit(&bv);
return result;
}
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&subset);
BitVecDeinit(&superset);
// Clean up
BitVecDeinit(&subset);
BitVecDeinit(&superset);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
return result;
// Clean up
BitVecDeinit(&superset);
BitVecDeinit(&subset);
// Clean up
BitVecDeinit(&superset);
BitVecDeinit(&subset);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
return result;
// Clean up
BitVecDeinit(&bv);
return result;
result = result && BitVecIsSubset(&bv1, &bv2); // Empty is subset of empty
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
result = result && BitVecOverlaps(&bv1, &bv2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return result;
}
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&subset);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&subset);
BitVecDeinit(&superset);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&subset);
BitVecDeinit(&superset);
BitVecDeinit(&bv3);
BitVecDeinit(&subset);
BitVecDeinit(&superset);
return result;
// Clean up
BitVecDeinit(&large1);
BitVecDeinit(&large2);
BitVecDeinit(&pos);
// Clean up
BitVecDeinit(&large1);
BitVecDeinit(&large2);
BitVecDeinit(&pos);
BitVecDeinit(&neg);
BitVecDeinit(&large1);
BitVecDeinit(&large2);
BitVecDeinit(&pos);
BitVecDeinit(&neg);
BitVecDeinit(&large2);
BitVecDeinit(&pos);
BitVecDeinit(&neg);
return result;
BitVecEquals(NULL, &bv);
BitVecDeinit(&bv);
return false;
}
BitVecEqualsRange(NULL, 0, &bv, 0, 1);
BitVecDeinit(&bv);
return false;
}
BitVecEqualsRange(&bv1, 0, &bv2, 0, 5); // Range exceeds length
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return false;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
return false;
}