BitVecDeinit
Description
Release all storage owned by bv and reset it to the zeroed state.
Parameters
| Name | Direction | Description |
|---|---|---|
bv |
in,out | Bitvector to deinitialize. Must not be used until reinitialized. |
Success
Backing buffer freed; bv left with NULL data, zero length, zero capacity.
Failure
Function cannot fail; aborts on a corrupted magic via the validator.
Usage example (Cross-references)
Usage examples (Cross-references)
- In
Init.h:45:
/// TAGS: Int, Deinit, Memory
///
#define IntDeinit(value) BitVecDeinit(&(value)->bits)
///
- In
BitVec.c:111:
}
void BitVecDeinit(BitVec *bitvec) {
ValidateBitVec(bitvec);
if (bitvec->data) {- In
BitVec.c:255:
if (!BitVecReserve(out, bv->length) || !BitVecResize(out, bv->length)) {
BitVecDeinit(out);
*out = BitVecInit(bv->allocator);
return false;- In
BitVec.c:944:
if (str[i] == '1') {
if (!BitVecPush(out, true)) {
BitVecDeinit(out);
*out = BitVecInit(alloc);
return false;- In
BitVec.c:950:
} else if (str[i] == '0') {
if (!BitVecPush(out, false)) {
BitVecDeinit(out);
*out = BitVecInit(alloc);
return false;- In
BitVec.c:1038:
if (!BitVecReserve(out, bit_len) || !BitVecResize(out, bit_len)) {
BitVecDeinit(out);
*out = BitVecInit(alloc);
return false;- In
BitVec.c:1096:
if (!BitVecReserve(out, bits) || !BitVecResize(out, bits)) {
BitVecDeinit(out);
*out = BitVecInit(alloc);
return false;- In
BitVec.c:1176:
BitVec temp = BitVecClone(bv);
if (temp.length != bv->length) {
BitVecDeinit(&temp);
return;
}- In
BitVec.c:1186:
}
BitVecDeinit(&temp);
}- In
BitVec.c:1202:
BitVec temp = BitVecClone(bv);
if (temp.length != bv->length) {
BitVecDeinit(&temp);
return;
}- In
BitVec.c:1212:
}
BitVecDeinit(&temp);
}- In
Memory.c:69:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Memory.c:109:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Memory.c:127:
result = result && (BitVecLen(&bv) == 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:141:
bool result = (BitVecByteSize(&bv) == 8);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:186:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Memory.c:187:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Memory.c:236:
// Clean up
BitVecDeinit(&original);
BitVecDeinit(&clone);- In
Memory.c:237:
// Clean up
BitVecDeinit(&original);
BitVecDeinit(&clone);
DefaultAllocatorDeinit(&alloc);- In
Memory.c:273:
BitVecGet(&clone, 0) == true && BitVecGet(&clone, 1) == false && BitVecGet(&clone, 2) == true;
BitVecDeinit(&original);
BitVecDeinit(&clone);
DefaultAllocatorDeinit(&alloc);- In
Memory.c:274:
BitVecDeinit(&original);
BitVecDeinit(&clone);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:309:
result = result && (BitVecLen(&bv) == 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:344:
result = result && (BitVecCapacity(&bv) >= 10000);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:387:
result = result && (BitVecLen(&bv1) == 2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Memory.c:388:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:404:
BitVec clone1 = BitVecClone(&bv);
result = result && (BitVecLen(&clone1) == 0);
BitVecDeinit(&clone1);
// Test clone single element
- In
Memory.c:411:
result = result && (BitVecLen(&clone2) == 1);
result = result && (BitVecGet(&clone2, 0) == true);
BitVecDeinit(&clone2);
// Test clone large data
- In
Memory.c:431:
result = result && (BitVecGet(&clone3, 0) != BitVecGet(&bv, 0));
BitVecDeinit(&clone3);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Memory.c:432:
BitVecDeinit(&clone3);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:467:
}
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&clone);- In
Memory.c:468:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&clone);
}- In
Memory.c:469:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&clone);
}- In
Memory.c:497:
BitVecSwap(NULL, &bv);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Memory.c:544:
result = result && (BitVecGet(&bv, 7) == false);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:565:
result = result && (BitVecLen(&bv) == 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:621:
}
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:649:
result = result && (BitVecCountOnes(&bv) == BitVecCountOnes(&bv));
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:683:
result = result && (BitVecGet(&small, 0) == true);
BitVecDeinit(&small);
BitVecDeinit(&large);
DefaultAllocatorDeinit(&alloc);- In
Memory.c:684:
BitVecDeinit(&small);
BitVecDeinit(&large);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:38:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Init.c:49:
DefaultAllocator alloc = DefaultAllocatorInit();
WriteFmt("Testing BitVecDeinit\n");
BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));- In
Init.c:62:
// Deinitialize
BitVecDeinit(&bv);
// After deinitialization, the bitvector should be in a safe state
- In
Init.c:107:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Init.c:146:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Init.c:191:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Init.c:213:
// Clean up all
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Init.c:214:
// Clean up all
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Init.c:215:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
DefaultAllocatorDeinit(&alloc);- In
Init.c:248:
result = result && (BitVecCapacity(&bv) == cap_before);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:287:
result = result && (BitVecLen(&bv) == 10);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:321:
result = result && (BitVecLen(&bv) == 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:343:
result = result && (BitVecLen(&bv) == (size)(cycle % 10));
BitVecDeinit(&bv);
}- In
Init.c:359:
// Test NULL bitvec pointer - should abort
BitVecDeinit(NULL);
// If we reach here, validation didn't work as expected
- In
Init.c:378:
// If we reach here, validation didn't work as expected
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Init.c:396:
// If we reach here, validation didn't work as expected
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false; BitVecGet(&bv, 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false; BitVecSet(&bv, 0, true);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false; BitVecFlip(&bv, 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false; BitVecGet(&bv, 1000);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false; BitVecSet(&bv, 500, true);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false; BitVecFlip(&bv, 10);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false; BitVecGet(&bv, SIZE_MAX);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:86:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Compare.c:87:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Compare.c:88:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:127:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Compare.c:128:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:165:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Compare.c:166:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:205:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Compare.c:206:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:245:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Compare.c:246:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:292:
// Clean up
BitVecDeinit(&subset);
BitVecDeinit(&superset);- In
Compare.c:293:
// Clean up
BitVecDeinit(&subset);
BitVecDeinit(&superset);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:338:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Compare.c:339:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Compare.c:340:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:386:
// Clean up
BitVecDeinit(&superset);
BitVecDeinit(&subset);- In
Compare.c:387:
// Clean up
BitVecDeinit(&superset);
BitVecDeinit(&subset);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:431:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Compare.c:432:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:479:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Compare.c:480:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:525:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Compare.c:526:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:576:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Compare.c:577:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:619:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Compare.c:620:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Compare.c:621:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:669:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:710:
result = result && BitVecIsSubset(&bv1, &bv2); // Empty is subset of empty
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:711:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:744:
result = result && BitVecOverlaps(&bv1, &bv2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:745:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:814:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Compare.c:815:
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&subset);- In
Compare.c:816:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&subset);
BitVecDeinit(&superset);- In
Compare.c:817:
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&subset);
BitVecDeinit(&superset);- In
Compare.c:818:
BitVecDeinit(&bv3);
BitVecDeinit(&subset);
BitVecDeinit(&superset);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:882:
// Clean up
BitVecDeinit(&large1);
BitVecDeinit(&large2);
BitVecDeinit(&pos);- In
Compare.c:883:
// Clean up
BitVecDeinit(&large1);
BitVecDeinit(&large2);
BitVecDeinit(&pos);
BitVecDeinit(&neg);- In
Compare.c:884:
BitVecDeinit(&large1);
BitVecDeinit(&large2);
BitVecDeinit(&pos);
BitVecDeinit(&neg);- In
Compare.c:885:
BitVecDeinit(&large2);
BitVecDeinit(&pos);
BitVecDeinit(&neg);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:903:
BitVecEquals(NULL, &bv);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:927:
BitVecEqualsRange(NULL, 0, &bv, 0, 1);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:949:
BitVecEqualsRange(&bv1, 0, &bv2, 0, 5); // Range exceeds length
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:950:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:984:
result = result && (bitvec_hash(&empty1, 0) == bitvec_hash(&empty2, 0));
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&empty1);- In
Compare.c:985:
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&empty1);
BitVecDeinit(&empty2);- In
Compare.c:986:
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&empty1);
BitVecDeinit(&empty2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:987:
BitVecDeinit(&b);
BitVecDeinit(&empty1);
BitVecDeinit(&empty2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1022:
result = result && (bitvec_hash(&a, 0) != bitvec_hash(&c, 0));
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&c);- In
Compare.c:1023:
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&c);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1024:
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&c);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1067:
result = result && (MapPairCount(&counts) == 2);
BitVecDeinit(&k1);
BitVecDeinit(&k2);
BitVecDeinit(&probe);- In
Compare.c:1068:
BitVecDeinit(&k1);
BitVecDeinit(&k2);
BitVecDeinit(&probe);
BitVecDeinit(&missing);- In
Compare.c:1069:
BitVecDeinit(&k1);
BitVecDeinit(&k2);
BitVecDeinit(&probe);
BitVecDeinit(&missing);
MapDeinit(&counts);- In
Compare.c:1070:
BitVecDeinit(&k2);
BitVecDeinit(&probe);
BitVecDeinit(&missing);
MapDeinit(&counts);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1103:
result = result && (cmp(&a, &a) == 0);
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&c);- In
Compare.c:1104:
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&c);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1105:
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&c);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1127:
BitVecEquals(&bv1, &bad);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1145:
BitVecEqualsRange(&bv1, 0, &bad, 0, 0);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1171:
bool result = (bitvec_hash(&a, 0) != bitvec_hash(&b, 0));
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1172:
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1196:
bool result = (bitvec_hash(&a, 0) != bitvec_hash(&b, 0));
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1197:
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1225:
bool result = (bitvec_hash(&a, 0) != bitvec_hash(&b, 0));
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1226:
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1248:
BitVecCompare(NULL, &bv); // must abort
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1263:
BitVecCompare(&bv, NULL); // must abort
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1278:
BitVecCompareRange(NULL, 0, &bv, 0, 1); // must abort
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1293:
BitVecCompareRange(&bv, 0, NULL, 0, 1); // must abort
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1309:
BitVecNumericalCompare(NULL, &bv); // must abort
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1334:
bool result = (BitVecNumericalCompare(&bv1, &bv2) > 0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1335:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1355:
bool result = (BitVecSignedCompare(&neg, &empty) < 0);
BitVecDeinit(&neg);
BitVecDeinit(&empty);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1356:
BitVecDeinit(&neg);
BitVecDeinit(&empty);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1375:
bool result = (BitVecSignedCompare(&empty, &neg) > 0);
BitVecDeinit(&empty);
BitVecDeinit(&neg);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1376:
BitVecDeinit(&empty);
BitVecDeinit(&neg);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1397:
bool result = (BitVecSignedCompare(&neg, &pos) < 0);
BitVecDeinit(&neg);
BitVecDeinit(&pos);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1398:
BitVecDeinit(&neg);
BitVecDeinit(&pos);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1418:
bool result = (BitVecSignedCompare(&empty, &neg) > 0);
BitVecDeinit(&empty);
BitVecDeinit(&neg);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1419:
BitVecDeinit(&empty);
BitVecDeinit(&neg);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1439:
bool result = (BitVecSignedCompare(&neg, &empty) < 0);
BitVecDeinit(&neg);
BitVecDeinit(&empty);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1440:
BitVecDeinit(&neg);
BitVecDeinit(&empty);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1463:
bool result = (BitVecSignedCompare(&a, &b) == 0);
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1464:
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1490:
bool result = (BitVecSignedCompare(&a, &b) < 0);
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1491:
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1508:
BitVecNumericalCompare(&bv, NULL); // must abort
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1524:
BitVecSignedCompare(NULL, &bv); // must abort
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1540:
BitVecSignedCompare(&bv, NULL); // must abort
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1556:
BitVecIsSubset(NULL, &bv); // must abort
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1582:
bool result = (BitVecIsSubset(&bv1, &bv2) == false);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1583:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1613:
bool result = (BitVecIsSubset(&bv1, &bv2) == true);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1614:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1644:
bool result = (BitVecIsSubset(&bv1, &bv2) == true);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1645:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1675:
bool result = (BitVecDisjoint(&bv1, &bv2) == false);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1676:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Compare.c:1695:
BitVecIsSubset(&bv1, NULL);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1714:
BitVecDisjoint(NULL, &bv2);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1733:
BitVecDisjoint(&bv1, NULL);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return false;- In
Compare.c:1785:
bool result = (ha == exp_a) && (hb == exp_b);
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);- In
Compare.c:1786:
BitVecDeinit(&a);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:53:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:92:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:123:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:160:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&source);- In
Insert.c:161:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:209:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&bv2);- In
Insert.c:210:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:244:
result = result && (BitVecGet(&bv, 999) == true);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:278:
result = result && (BitVecGet(&bv, 500) == false);
BitVecDeinit(&bv);
BitVecDeinit(&empty);
BitVecDeinit(&source);- In
Insert.c:279:
BitVecDeinit(&bv);
BitVecDeinit(&empty);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:280:
BitVecDeinit(&bv);
BitVecDeinit(&empty);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:308:
result = result && (BitVecGet(&bv, 1) == true); // Second bit
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:333:
BitVecInsertRange(&bv, SIZE_MAX, 1, true);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Insert.c:374:
result = result && (BitVecGet(&bv, 5) == true); // shifted orig[3]
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:408:
result = result && (BitVecGet(&bv, 4) == true); // shifted orig[2]
BitVecDeinit(&bv);
BitVecDeinit(&other);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:409:
BitVecDeinit(&bv);
BitVecDeinit(&other);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:437:
// If we reach here, validation did not abort.
BitVecDeinit(&other);
DefaultAllocatorDeinit(&alloc);
return false;- In
Insert.c:454:
// If we reach here, validation did not abort.
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false; BitVecFindPattern(NULL, &pattern); // Should cause LOG_FATAL
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecFindPattern(&source, NULL); // Should cause LOG_FATAL
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; BitVecFindLastPattern(NULL, &pattern); // Should cause LOG_FATAL
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecFindLastPattern(&source, NULL); // Should cause LOG_FATAL
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; BitVecFindAllPattern(&source, NULL, results, 10); // Should cause LOG_FATAL
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; BitVecFindAllPattern(&source, &pattern, NULL, 10); // Should cause LOG_FATAL
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecFindAllPattern(&source, &pattern, results, 0); // Should cause LOG_FATAL
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecPush(&prefix, true);
BitVecStartsWith(NULL, &prefix);
BitVecDeinit(&prefix);
DefaultAllocatorDeinit(&alloc);
return true; BitVecPush(&source, true);
BitVecStartsWith(&source, NULL);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; BitVecPush(&suffix, true);
BitVecEndsWith(NULL, &suffix);
BitVecDeinit(&suffix);
DefaultAllocatorDeinit(&alloc);
return true; BitVecPush(&source, true);
BitVecEndsWith(&source, NULL);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; BitVecPush(&pattern, true);
BitVecContainsAt(NULL, &pattern, 0);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecPush(&source, true);
BitVecContainsAt(&source, NULL, 0);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; BitVecPush(&wildcard, false);
BitVecMatches(NULL, &pattern, &wildcard);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
DefaultAllocatorDeinit(&alloc); BitVecMatches(NULL, &pattern, &wildcard);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
DefaultAllocatorDeinit(&alloc);
return true; BitVecPush(&source, true);
BitVecRegexMatch(&source, (Zstr)NULL);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; DefaultAllocator alloc = DefaultAllocatorInit();
WriteFmt("Testing BitVecPrefixMatch(NULL, patterns, 1) - should fatal\n");
BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
BitVecPush(VecPtrAt(&vp, 0), true);
BitVecPrefixMatch(NULL, &vp); BitVecPush(&source, true);
BitVecPrefixMatch(&source, NULL);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; DefaultAllocator alloc = DefaultAllocatorInit();
WriteFmt("Testing BitVecSuffixMatch(NULL, patterns, 1) - should fatal\n");
BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
BitVecPush(VecPtrAt(&vp, 0), true);
BitVecSuffixMatch(NULL, &vp); BitVecPush(&source, true);
BitVecSuffixMatch(&source, NULL);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; BitVecCountPattern(NULL, &pattern); // Should LOG_FATAL
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecCountPattern(&source, NULL); // Should LOG_FATAL
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; BitVecRFindPattern(NULL, &pattern, 0); // Should LOG_FATAL
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecRFindPattern(&source, NULL, 0); // Should LOG_FATAL
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return true; BitVecReplace(&source, &old_pattern, NULL); // real: LOG_FATAL
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecReplaceAll(&bad, &old_pattern, &new_pattern); // real: LOG_FATAL
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecReplaceAll(&source, NULL, &new_pattern); // real: LOG_FATAL
BitVecDeinit(&source);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecReplaceAll(&source, &old_pattern, NULL); // real: LOG_FATAL
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
DefaultAllocatorDeinit(&alloc);
return true; BitVecMatches(&source, NULL, &wildcard); // must abort
BitVecDeinit(&source);
BitVecDeinit(&wildcard);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&wildcard);
DefaultAllocatorDeinit(&alloc);
return false; BitVecMatches(&source, &pattern, NULL); // must abort
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return false; BitVecFuzzyMatch(NULL, &pattern, 0); // must abort
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return false; BitVecFuzzyMatch(&source, NULL, 0); // must abort
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return false; WriteFmt("Testing BitVecPrefixMatch(NULL, empty) - should fatal\n");
BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
// Empty patterns: with validation present this aborts on the NULL bv;
WriteFmt("Testing BitVecSuffixMatch(NULL, empty) - should fatal\n");
BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
// Empty patterns: with validation present this aborts on the NULL bv;
BitVecRunLengths(&bv, NULL, values, 5);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return true; // Should never reach here
BitVecRunLengths(&bv, runs, NULL, 5);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return true; // Should never reach here
BitVecRunLengths(&bv, runs, values, 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return true; // Should never reach here
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc); result = result && (count == 1000);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; }
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; }
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (count == 2); // Should iterate over indices 8,9
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (count4 == sz);
BitVecDeinit(&bv);
} }
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;
VecDeinit(&runs);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
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);
DefaultAllocatorDeinit(&alloc); result = result && (count == 8);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; }
BitVecDeinit(&large_bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Type.c:31:
// Clean up
BitVecDeinit(&bitvec);
DefaultAllocatorDeinit(&alloc);- In
Type.c:50:
// Clean up
BitVecDeinit(&bitvec);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result); // Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result); BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result); // Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result); BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result); // Clean up
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result); BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&result); // Clean up
BitVecDeinit(&bv);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc); result = result && (BitVecLen(&bv) == 1000);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecLen(&bv) == 2);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&result_bv, 0) == false);
BitVecDeinit(&result_bv);
BitVecDeinit(&bv1); BitVecDeinit(&result_bv);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&bv, 1) == false);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; }
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return test_result; result = result && (BitVecGet(&bv, 2) == true); // original bit 0
BitVecDeinit(&bv);
BitVecDeinit(&original);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&bv);
BitVecDeinit(&original);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&bv, 4) == false);
BitVecDeinit(&bv);
BitVecDeinit(&original);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&bv);
BitVecDeinit(&original);
DefaultAllocatorDeinit(&alloc);
return result; test_result = test_result && or_ones;
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc);
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);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&bv2);
BitVecDeinit(&result1);
BitVecDeinit(&result2);
DefaultAllocatorDeinit(&alloc);
return test_result; }
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return test_result; ok = ok && (BitVecGet(&result, 3) == false);
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&result);
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc); ok = ok && (BitVecGet(&result, 3) == false);
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&result);
BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&a);
BitVecDeinit(&b);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc); bool result = (BitVecLen(&bv) == 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&bv, 7) == false);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; }
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; ok = ok && (BitVecGet(&bv, 3) == true);
BitVecDeinit(&bv);
// Real code frees the temp clone inside rotate; with the Deinit
ok = ok && (BitVecGet(&bv, 3) == false);
BitVecDeinit(&bv);
// Real code frees the temp clone inside rotate; with the Deinit
BitVecAnd(NULL, &bv, &bv2);
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return false; BitVecAnd(NULL, &bv1, &bv2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return false; BitVecOr(&result, &bv1, NULL);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return false; BitVecXor(&result, NULL, &bv1);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&result);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return false; BitVecNot(&result, NULL);
BitVecDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return false; BitVecAnd(&result, &a, &bad);
BitVecDeinit(&result);
BitVecDeinit(&a);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&result);
BitVecDeinit(&a);
DefaultAllocatorDeinit(&alloc);
return false; BitVecAnd(&result, &bad, &b);
BitVecDeinit(&result);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&result);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return false; BitVecOr(&result, &bad, &b);
BitVecDeinit(&result);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&result);
BitVecDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return false; BitVecXor(&result, &a, &bad);
BitVecDeinit(&result);
BitVecDeinit(&a);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&result);
BitVecDeinit(&a);
DefaultAllocatorDeinit(&alloc);
return false; result = result && (index == 1); // Should find pattern at index 1 (101...)
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; // Depending on the exact source pattern, adjust this test
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (index == 2); // Only occurrence at index 2
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (count == 3); // Should find at 0, 3, 6
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result;
VecDeinit(&matches);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc); VecDeinit(&matches);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (results[0] == 0);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; }
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && !BitVecStartsWith(&source, &prefix);
BitVecDeinit(&source);
BitVecDeinit(&prefix);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&prefix);
DefaultAllocatorDeinit(&alloc);
return result; result = result && BitVecStartsWith(&source, &prefix);
BitVecDeinit(&source);
BitVecDeinit(&prefix);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&prefix);
DefaultAllocatorDeinit(&alloc);
return result; result = result && !BitVecEndsWith(&source, &suffix);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
DefaultAllocatorDeinit(&alloc);
return result; result = result && !BitVecEndsWith(&source, &suffix);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecFindPattern(&source, &pattern) == SIZE_MAX);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && BitVecContainsAt(&source, &pattern, 3); // Should match
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && !BitVecContainsAt(&source, &pattern, 0); // Pattern too long
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (count == 3);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (pos == 3); // Should find at position 3
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&source, 2) == true);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc);
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);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && BitVecMatches(&source, &pattern, &wildcard);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (pos == 0); // Should match 110 with 1 error
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && !BitVecRegexMatch(&source, "111");
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return result;
BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
bool result = true;
VecDeinit(&patterns);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return result;
BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
bool result = true;
VecDeinit(&patterns);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (index == 0);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result;
VecDeinit(&matches);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc); VecDeinit(&matches);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; bool result = BitVecEndsWith(&source, &suffix);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&suffix);
DefaultAllocatorDeinit(&alloc);
return result; bool result = (BitVecCountPattern(&source, &pattern) == 1);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; bool result = (BitVecRFindPattern(&source, &pattern, 2) == 0);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (pos == SIZE_MAX);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (pos == SIZE_MAX);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (pos == SIZE_MAX);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (pos == 6);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (pos == SIZE_MAX);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&source, 3) == false);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecLen(&source) == 4); // 5 - 3 + 2
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&source);
BitVecDeinit(&old_pattern);
BitVecDeinit(&new_pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&source, i) == false);
BitVecDeinit(&source);
BitVecDeinit(&old);
BitVecDeinit(&neww);
BitVecDeinit(&source);
BitVecDeinit(&old);
BitVecDeinit(&neww);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&source);
BitVecDeinit(&old);
BitVecDeinit(&neww);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&source, 1) == true);
BitVecDeinit(&source);
BitVecDeinit(&old);
BitVecDeinit(&neww);
BitVecDeinit(&source);
BitVecDeinit(&old);
BitVecDeinit(&neww);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&source);
BitVecDeinit(&old);
BitVecDeinit(&neww);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecMatches(&source, &pattern, &wild_all) == true);
BitVecDeinit(&wild_all);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wild_all);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard); BitVecDeinit(&wild_all);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
DefaultAllocatorDeinit(&alloc); BitVecDeinit(&source);
BitVecDeinit(&pattern);
BitVecDeinit(&wildcard);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecFuzzyMatch(&source, &pattern, 0) == 0);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecFuzzyMatch(&source, &pattern, 0) == 5);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; bool result = (BitVecFuzzyMatch(&source, &pattern, 0) == SIZE_MAX);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
BitVecDeinit(&source);
BitVecDeinit(&pattern);
DefaultAllocatorDeinit(&alloc);
return result; StrDeinit(&pat_no);
StrDeinit(&pat_yes);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc);
return result; bool ok = (matched == true);
BitVecDeinit(&bv);
// The rendered bv_str borrows bv's DebugAllocator. Real code frees it;
StrDeinit(&pattern);
BitVecDeinit(&bv);
// bv_str (the render of bv) borrows bv's DebugAllocator. Real code
- In
Math.c:114:
result = result && (distance == 1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:115:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:147:
result = result && (distance == 2); // Length of bv1
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:148:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:199:
result = result && (F64Abs(similarity - 0.5) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:200:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:228:
result = result && (F64Abs(similarity - 1.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:229:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:266:
result = result && (F64Abs(similarity - 0.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:267:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:299:
result = result && (similarity == 0.0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:300:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:339:
result = result && (product == 0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:340:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:369:
result = result && (product == 1); // Only first position counts
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:370:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:416:
result = result && (distance == 1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:417:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:447:
result = result && (distance == 2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:448:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:486:
result = result && (F64Abs(correlation + 1.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:487:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:517:
result = result && (correlation == 0.0); // No variance
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:518:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:550:
result = result && (entropy == 0.0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:573:
result = result && (entropy == 0.0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:608:
result = result && (score == -3); // 3 mismatches * -1
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:609:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:638:
result = result && (score == 2); // 2 matches
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:639:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:671:
result = result && (best_pos == 0 || best_pos == 4);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:672:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:699:
result = result && (best_pos == 0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:700:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:754:
result = result && (edit_dist < 100);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&small1);- In
Math.c:755:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&small1);
BitVecDeinit(&small2);- In
Math.c:756:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&small1);
BitVecDeinit(&small2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:757:
BitVecDeinit(&bv2);
BitVecDeinit(&small1);
BitVecDeinit(&small2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:771:
BitVecPush(&bv2, true);
BitVecHammingDistance(NULL, &bv2);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:783:
BitVecPush(&bv1, true);
BitVecHammingDistance(&bv1, NULL);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:795:
BitVecPush(&bv2, true);
BitVecJaccardSimilarity(NULL, &bv2);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:807:
BitVecPush(&bv1, true);
BitVecJaccardSimilarity(&bv1, NULL);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:819:
BitVecPush(&bv2, true);
BitVecCosineSimilarity(NULL, &bv2);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:831:
BitVecPush(&bv1, true);
BitVecCosineSimilarity(&bv1, NULL);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:843:
BitVecPush(&bv2, true);
BitVecDotProduct(NULL, &bv2);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:855:
BitVecPush(&bv1, true);
BitVecDotProduct(&bv1, NULL);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:867:
BitVecPush(&bv2, true);
BitVecEditDistance(NULL, &bv2);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:879:
BitVecPush(&bv1, true);
BitVecEditDistance(&bv1, NULL);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:891:
BitVecPush(&bv2, true);
BitVecCorrelation(NULL, &bv2);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:903:
BitVecPush(&bv1, true);
BitVecCorrelation(&bv1, NULL);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:921:
BitVecPush(&bv2, true);
BitVecAlignmentScore(NULL, &bv2, 1, -1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:933:
BitVecPush(&bv1, true);
BitVecAlignmentScore(&bv1, NULL, 1, -1);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:945:
BitVecPush(&bv2, true);
BitVecBestAlignment(NULL, &bv2);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:957:
BitVecPush(&bv1, true);
BitVecBestAlignment(&bv1, NULL);
BitVecDeinit(&bv1);
DefaultAllocatorDeinit(&alloc);
return true;- In
Math.c:986:
result = result && (F64Abs(s2 - 0.0) < 0.001);
BitVecDeinit(&empty);
BitVecDeinit(&one);
DefaultAllocatorDeinit(&alloc);- In
Math.c:987:
BitVecDeinit(&empty);
BitVecDeinit(&one);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1012:
bool result = (F64Abs(s - 1.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1013:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1038:
bool result = (F64Abs(s - 1.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1039:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1066:
bool result = (F64Abs(s - 0.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1067:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1091:
bool result = (dist == 1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1092:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1116:
bool result = (dist == 1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1117:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1147:
}
(void)BitVecEditDistance(&warm_a, &warm_b);
BitVecDeinit(&warm_a);
BitVecDeinit(&warm_b);- In
Math.c:1148:
(void)BitVecEditDistance(&warm_a, &warm_b);
BitVecDeinit(&warm_a);
BitVecDeinit(&warm_b);
BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
- In
Math.c:1159:
bool result = (dist == 5);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1160:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1185:
}
(void)BitVecEditDistance(&warm_a, &warm_b);
BitVecDeinit(&warm_a);
BitVecDeinit(&warm_b);- In
Math.c:1186:
(void)BitVecEditDistance(&warm_a, &warm_b);
BitVecDeinit(&warm_a);
BitVecDeinit(&warm_b);
BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
- In
Math.c:1197:
bool result = (dist == 4);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1198:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1225:
bool result = (dist == 2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1226:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1246:
BitVecJaccardSimilarity(&empty, &bad);
BitVecDeinit(&empty);
DefaultAllocatorDeinit(&alloc);
return false;- In
Math.c:1277:
result = result && (correlation >= -1.0 && correlation <= 1.0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1278:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1307:
result = result && (correlation >= -1.0 && correlation <= 1.0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1308:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1335:
result = result && (F64Abs(entropy - 0.811278) < 0.01);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1374:
result = result && (best_offset == 3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1375:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1402:
result = result && (F64Abs(similarity - 1.0) < 0.001);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1403:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1430:
result = result && (F64Abs(entropy - 0.8112782517394319) < 0.001);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1456:
result = result && (F64Abs(entropy - 0.8112781245) < 0.001);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1480:
bool result = (BitVecBestAlignment(&bv1, &bv2) == 2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1481:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1501:
bool result = (BitVecBestAlignment(&bv1, &bv2) == 1);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1502:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1520:
bool result = (BitVecBestAlignment(&bv1, &bv2) == 0);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1521:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1541:
bool result = (BitVecBestAlignment(&bv1, &bv2) == 2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1542:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1561:
bool result = (BitVecBestAlignment(&bv1, &bv2) == 2);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Math.c:1562:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:64:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Remove.c:104:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Remove.c:137:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Remove.c:178:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Remove.c:220:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Remove.c:261:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Remove.c:292:
}
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:320:
result = result && (BitVecLen(&bv) == 999);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:353:
result = result && (BitVecLen(&bv) == 5); // Should have 5 elements left
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:392:
result = result && (found == true) && (BitVecLen(&bv) == 999);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:430:
result = result && (count == 500) && (BitVecLen(&bv) == 500);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:464:
BitVecRemoveRange(&bv, SIZE_MAX, 1);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Remove.c:479:
BitVecPop(&bv);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Remove.c:494:
BitVecRemove(&bv, 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Remove.c:509:
BitVecRemoveRange(&bv, 0, 1);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Remove.c:537:
result = result && (BitVecGet(&bv, 1) == true);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:568:
result = result && (BitVecGet(&bv, 1) == true);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:602:
result = result && (BitVecGet(&bv, 6) == false); // orig[9]
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:633:
// If we reach here, validation did not abort.
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return false;- In
Convert.c:64:
// Clean up
StrDeinit(&str);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:94:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&empty_bv);- In
Convert.c:95:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&empty_bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:130:
result = result && (bytes[0] == 0xCD);
}
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:169:
// Clean up
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:207:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&bv2);- In
Convert.c:208:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&bv2);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:260:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&zero_bv);- In
Convert.c:261:
// Clean up
BitVecDeinit(&bv);
BitVecDeinit(&zero_bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:289:
StrDeinit(&str);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:305:
BitVec empty_bv = BitVecFromBytes(dummy_bytes, 0, ALLOCATOR_OF(&alloc));
bool result = (BitVecLen(&empty_bv) == 0);
BitVecDeinit(&empty_bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:342:
StrDeinit(&str_obj);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:357:
BitVec bv1 = BitVecFromStr("", ALLOCATOR_OF(&alloc));
result = result && (BitVecLen(&bv1) == 0);
BitVecDeinit(&bv1);
// Test single character
- In
Convert.c:363:
result = result && (BitVecLen(&bv2) == 1);
result = result && (BitVecGet(&bv2, 0) == true);
BitVecDeinit(&bv2);
// Test long string
- In
Convert.c:376:
result = result && (BitVecGet(&bv3, 0) == true);
result = result && (BitVecGet(&bv3, 1) == false);
BitVecDeinit(&bv3);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:400:
BitVec bv2 = BitVecFromBytes(empty_bytes, 0, ALLOCATOR_OF(&alloc)); // 0 bits
result = result && (BitVecLen(&bv2) == 0);
BitVecDeinit(&bv2);
// Test single byte
- In
Convert.c:406:
BitVec bv3 = BitVecFromBytes(single_byte, 8, ALLOCATOR_OF(&alloc)); // 8 bits from 1 byte
result = result && (BitVecLen(&bv3) == 8);
BitVecDeinit(&bv3);
BitVecDeinit(&bv);- In
Convert.c:408:
BitVecDeinit(&bv3);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:428:
BitVec bv2 = BitVecFromInteger(0, 8, ALLOCATOR_OF(&alloc)); // 8 bits for zero
result = result && (BitVecLen(&bv2) == 8); // Should be 8 bits
BitVecDeinit(&bv2);
// Test large integer
- In
Convert.c:433:
BitVec bv3 = BitVecFromInteger(UINT64_MAX, 64, ALLOCATOR_OF(&alloc)); // 64 bits for max value
result = result && (BitVecLen(&bv3) == 64);
BitVecDeinit(&bv3);
BitVecDeinit(&bv);- In
Convert.c:435:
BitVecDeinit(&bv3);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:459:
StrDeinit(&str);
BitVecDeinit(&bv);
}- In
Convert.c:480:
result = result && (recovered == value);
BitVecDeinit(&bv);
}
}- In
Convert.c:495:
result = result && (recovered_byte == test_bytes[i]);
BitVecDeinit(&bv);
}- In
Convert.c:517:
u64 large_value = BitVecToInteger(&large_bv);
result = result && (large_value == 0xFFFFFFFFFFFFFFFF);
BitVecDeinit(&large_bv);
// Test oversized bitvec to integer (should handle gracefully)
- In
Convert.c:528:
// 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
- In
Convert.c:545:
result = result && (empty_bytes[0] == 0xFF); // Should be unchanged
BitVecDeinit(&empty);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:597:
}
BitVecDeinit(&bv);
}- In
Convert.c:625:
StrDeinit(&str2);
StrDeinit(&str3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Convert.c:626:
StrDeinit(&str3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Convert.c:627:
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:689:
result = result && recovered_pattern_correct;
BitVecDeinit(&large_bv);
BitVecDeinit(&recovered_bv);- In
Convert.c:690:
BitVecDeinit(&large_bv);
BitVecDeinit(&recovered_bv);
// Test string to bitvec with large patterns
- In
Convert.c:714:
result = result && large_pattern_correct;
BitVecDeinit(&large_from_str);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:734:
BitVecToBytes(&bv, small_buffer, 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:803:
bool result = ok && (BitVecLen(&bv) == 64);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:835:
bool result = (written == 1) && (bytes[0] == 0x0D);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:869:
bool result = (written == 1) && (bytes[1] == 0xEE);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:906:
}
BitVecDeinit(&bv);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc); (BitVecGet(&bv, 3) == false);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; (BitVecGet(&bv, 3) == false);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; (BitVecGet(&bv, 3) == false); // unchanged
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecCapacity(&bv) >= 100);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; bool result = (BitVecCountOnes(&bv) == 3) && (BitVecCountZeros(&bv) == 2);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&bv, 63) == false); // 63 % 2 == 1, so i%2==0 is false for i=63
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&bv, 0) == false);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecGet(&bv, 0) == false);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecCountZeros(&bv) == 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecCountZeros(&bv) == 0);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecCountZeros(&bv) == 500);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecCountZeros(&bv) == 1);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; }
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; }
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecFindLast(&bv, false) == SIZE_MAX);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && !BitVecNone(&bv, false);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecLongestRun(&bv, false) == 1);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecFindLast(&bv, true) == 999);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && BitVecAny(&bv, false);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (BitVecLongestRun(&bv, false) == 1);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return result;- In
Write.c:582:
StrClear(&output);
BitVecDeinit(&bv1);
BitVecDeinit(&bv_empty);
BitVecDeinit(&bv2);- In
Write.c:583:
BitVecDeinit(&bv1);
BitVecDeinit(&bv_empty);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);- In
Write.c:584:
BitVecDeinit(&bv1);
BitVecDeinit(&bv_empty);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv_zero);- In
Write.c:585:
BitVecDeinit(&bv_empty);
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv_zero);
StrDeinit(&output);- In
Write.c:586:
BitVecDeinit(&bv2);
BitVecDeinit(&bv3);
BitVecDeinit(&bv_zero);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1419:
bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 4);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1437:
bool ok = (BitVecToInteger(&bv) == 0xDEAD) && (BitVecLen(&bv) == 16);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1453:
bool ok = (BitVecToInteger(&bv) == 0xDEAD) && (*z == '\0');
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1472:
bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 3);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1491:
bool ok = (BitVecToInteger(&bv) == 8) && (*z == '\0');
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1508:
bool ok = (BitVecToInteger(&bv) == 0755) && (BitVecLen(&bv) == 9);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2496:
bool ok = (BitVecLen(&bv) == 10) && (BitVecToInteger(&bv) == 0x3ff);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2515:
bool ok = (BitVecLen(&bv) == 8) && (BitVecToInteger(&bv) == 0xff);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2534:
bool ok = (BitVecLen(&bv) == 17) && (BitVecToInteger(&bv) == 0x10000);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3723:
bool ok = (StrLen(&out) == 7) && (ZstrCompare(StrBegin(&out), " XX1") == 0);
BitVecDeinit(&bv);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Write.c:5411:
StrAppendFmt(&out, "{}", bv);
bool ok = (ZstrCompare(StrBegin(&out), "10110") == 0);
BitVecDeinit(&bv);
return ok && dbg_no_leak(&dbg, &out);
}- In
Write.c:5426:
StrAppendFmt(&out, "{6}", bv);
ok = ok && (ZstrCompare(StrBegin(&out), " 101") == 0);
BitVecDeinit(&bv);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Write.c:5722:
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);
BitVecDeinit(&v);
HeapAllocatorDeinit(&va);
return ok;- In
Read.c:857:
);
StrDeinit(&result1);
BitVecDeinit(&bv1);
BitVec bv2 = BitVecInit(alloc_base);- In
Read.c:865:
success = success && (value2 == 0xDEAD);
WriteFmt("Test 2 - Hex: {}, Success: {}\n", value2, (value2 == 0xDEAD) ? "true" : "false");
BitVecDeinit(&bv2);
BitVec bv3 = BitVecInit(alloc_base);- In
Read.c:873:
success = success && (value3 == 0755);
WriteFmt("Test 3 - Octal: {}, Success: {}\n", value3, (value3 == 0755) ? "true" : "false");
BitVecDeinit(&bv3);
BitVec bv4 = BitVecInit(alloc_base);- In
Read.c:886:
);
StrDeinit(&result4);
BitVecDeinit(&bv4);
BitVec bv5 = BitVecInit(alloc_base);- In
Read.c:899:
);
StrDeinit(&result5);
BitVecDeinit(&bv5);
WriteFmt("Overall BitVec reading success: {}\n", success ? "true" : "false");- In
Read.c:2517:
StrReadFmt(z, "{}", bv);
bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 4); // min-width clamp
BitVecDeinit(&bv);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Read.c:2530:
StrReadFmt(z, "{}", bv);
bool ok = (BitVecToInteger(&bv) == 0xDEAD) && (BitVecLen(&bv) == 16);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:2542:
StrReadFmt(z, "{}", bv);
bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 3);
BitVecDeinit(&bv);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Read.c:2555:
StrReadFmt(z, "{}", bv);
bool ok = (BitVecLen(&bv) == 5) && (BitVecToInteger(&bv) == 13);
BitVecDeinit(&bv);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Read.c:2746:
Zstr p = input;
StrReadFmt(p, "{}", bv);
BitVecDeinit(&bv);
bool ok = (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);
Last updated on