VecLen
Description
Number of elements currently stored in the vector.
Parameters
| Name | Direction | Description |
|---|---|---|
v |
in | Vector to query. |
Usage example (Cross-references)
Usage examples (Cross-references)
- In
Init.h:83:
#define IterInitFromVec(v) \
{.data = VecBegin(&(v)), \
.length = VecLen(&(v)), \
.pos = 0, \
.alignment = VecAllocator(&(v)) ? AllocatorAlignment(VecAllocator(&(v))) : 1, \- In
Init.h:102:
#define IterInitRevFromVec(v) \
{.data = VecBegin(&(v)), \
.length = VecLen(&(v)), \
.pos = 0, \
.alignment = VecAllocator(&(v)) ? AllocatorAlignment(VecAllocator(&(v))) : 1, \- In
Init.h:181:
#define IterInitFromVecT(i, v) \
((TYPE_OF(i)) {.data = VecBegin(&(v)), \
.length = VecLen(&(v)), \
.pos = 0, \
.alignment = VecAllocator(&(v)) ? AllocatorAlignment(VecAllocator(&(v))) : 1, \- In
Init.h:201:
#define IterInitRevFromVecT(i, v) \
((TYPE_OF(i)) {.data = VecBegin(&(v)), \
.length = VecLen(&(v)), \
.pos = 0, \
.alignment = VecAllocator(&(v)) ? AllocatorAlignment(VecAllocator(&(v))) : 1, \- In
Access.h:154:
/// TAGS: Vec, Empty, Query
///
#define VecEmpty(v) (VecLen(v) == 0)
///
- In
Access.h:27:
/// TAGS: Str, Length, Query
///
#define StrLen(str) VecLen(str)
///
- In
VecInt.c:49:
case VEC_INT_POP_BACK : {
if (VecLen(vec) > 0) {
i32 popped;
VecPopBack(vec, &popped);- In
VecInt.c:57:
case VEC_INT_POP_FRONT : {
if (VecLen(vec) > 0) {
i32 popped;
VecPopFront(vec, &popped);- In
VecInt.c:68:
i32 value = (i32)extract_u32(data, offset, data_size);
if (idx <= VecLen(vec)) {
VecInsert(vec, value, idx);
}- In
VecInt.c:76:
case VEC_INT_REMOVE : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
i32 removed;
VecRemove(vec, &removed, idx);- In
VecInt.c:85:
case VEC_INT_DELETE : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
VecDelete(vec, idx);
}- In
VecInt.c:93:
case VEC_INT_AT : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
volatile i32 value = VecAt(vec, idx);
(void)value; // Prevent optimization
- In
VecInt.c:101:
case VEC_INT_LEN : {
volatile uint64_t len = VecLen(vec);
(void)len;
break;- In
VecInt.c:107:
case VEC_INT_FIRST : {
if (VecLen(vec) > 0) {
volatile i32 first = VecFirst(vec);
(void)first;- In
VecInt.c:115:
case VEC_INT_LAST : {
if (VecLen(vec) > 0) {
volatile i32 last = VecLast(vec);
(void)last;- In
VecInt.c:163:
uint16_t idx2 = extract_u16(data, offset, data_size);
uint64_t len = VecLen(vec);
if (len > 1 && idx1 < len && idx2 < len) {
VecSwapItems(vec, idx1, idx2);- In
VecInt.c:176:
count = count % 16;
if (idx <= VecLen(vec) && count > 0) {
i32 values[16];
for (uint8_t i = 0; i < count && *offset + 4 <= data_size; i++) {- In
VecInt.c:191:
count = count % 16;
uint64_t len = VecLen(vec);
if (len > 0 && start < len && count > 0 && start + count <= len) {
i32 removed_items[16];- In
VecInt.c:204:
count = count % 16;
uint64_t len = VecLen(vec);
if (len > 0 && start < len && count > 0 && start + count <= len) {
VecDeleteRange(vec, start, count);- In
VecInt.c:215:
i32 value = (i32)extract_u32(data, offset, data_size);
if (idx <= VecLen(vec)) {
VecInsertFast(vec, value, idx);
}- In
VecInt.c:223:
case VEC_INT_REMOVE_FAST : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
i32 removed;
VecRemoveFast(vec, &removed, idx);- In
VecInt.c:235:
count = count % 16;
uint64_t len = VecLen(vec);
if (len > 0 && start < len && count > 0 && start + count <= len) {
i32 removed_items[16];- In
VecInt.c:255:
count = count % 16;
uint64_t len = VecLen(vec);
if (len > 0 && start < len && count > 0 && start + count <= len) {
VecDeleteRangeFast(vec, start, count);- In
VecInt.c:325:
case VEC_INT_PTR_AT : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
volatile i32 *ptr = VecPtrAt(vec, idx);
volatile i32 val = *ptr;- In
VecInt.c:353:
count = count % 16;
if (idx <= VecLen(vec) && count > 0) {
i32 values[16];
for (uint8_t i = 0; i < count && *offset + 4 <= data_size; i++) {- In
VecInt.c:365:
case VEC_INT_ALIGNED_OFFSET_AT : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx <= VecLen(vec)) {
volatile uint64_t offset_val = VecAlignedOffsetAt(vec, idx);
(void)offset_val;- In
VecInt.c:373:
case VEC_INT_DELETE_LAST : {
if (VecLen(vec) > 0) {
VecDeleteLast(vec);
}- In
VecInt.c:381:
case VEC_INT_DELETE_FAST : {
uint16_t idx = extract_u16(data, offset, data_size);
if (idx < VecLen(vec)) {
VecDeleteFast(vec, idx);
}- In
VecInt.c:405:
// Foreach operations
case VEC_INT_FOREACH : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeach(vec, item) {- In
VecInt.c:416:
case VEC_INT_FOREACH_IDX : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachIdx(vec, item, idx) {- In
VecInt.c:427:
case VEC_INT_FOREACH_PTR : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachPtr(vec, item_ptr) {- In
VecInt.c:438:
case VEC_INT_FOREACH_PTR_IDX : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachPtrIdx(vec, item_ptr, idx) {- In
VecInt.c:449:
case VEC_INT_FOREACH_REVERSE : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachReverse(vec, item) {- In
VecInt.c:460:
case VEC_INT_FOREACH_REVERSE_IDX : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachReverseIdx(vec, item, idx) {- In
VecInt.c:471:
case VEC_INT_FOREACH_PTR_REVERSE : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachPtrReverse(vec, item_ptr) {- In
VecInt.c:482:
case VEC_INT_FOREACH_PTR_REVERSE_IDX : {
if (VecLen(vec) > 0) {
int sum = 0;
VecForeachPtrReverseIdx(vec, item_ptr, idx) {- In
VecInt.c:493:
case VEC_INT_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecInt.c:494:
case VEC_INT_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecInt.c:495:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
int sum = 0;- In
VecInt.c:508:
case VEC_INT_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecInt.c:509:
case VEC_INT_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecInt.c:510:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
int sum = 0;- In
VecInt.c:523:
case VEC_INT_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecInt.c:524:
case VEC_INT_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecInt.c:525:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
int sum = 0;- In
VecInt.c:538:
case VEC_INT_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecInt.c:539:
case VEC_INT_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecInt.c:540:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
int sum = 0;- In
VecCharPtr.c:75:
case VEC_CHAR_PTR_POP_BACK : {
if (VecLen(vec) > 0) {
char *str;
VecPopBack(vec, &str);- In
VecCharPtr.c:84:
case VEC_CHAR_PTR_POP_FRONT : {
if (VecLen(vec) > 0) {
char *str;
VecPopFront(vec, &str);- In
VecCharPtr.c:94:
case VEC_CHAR_PTR_INSERT : {
if (*offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
char *str = generate_cstring(data, offset, data_size, 32);
if (str) {- In
VecCharPtr.c:105:
case VEC_CHAR_PTR_REMOVE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str;- In
VecCharPtr.c:106:
case VEC_CHAR_PTR_REMOVE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str;
VecRemove(vec, &str, index);- In
VecCharPtr.c:115:
case VEC_CHAR_PTR_DELETE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDelete(vec, index);- In
VecCharPtr.c:116:
case VEC_CHAR_PTR_DELETE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDelete(vec, index);
// char_ptr_deinit is called automatically by the vector
- In
VecCharPtr.c:124:
case VEC_CHAR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str = VecAt(vec, index);- In
VecCharPtr.c:125:
case VEC_CHAR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str = VecAt(vec, index);
(void)str; // Use the result to avoid warnings
- In
VecCharPtr.c:133:
case VEC_CHAR_PTR_LEN : {
size_t len = VecLen(vec);
(void)len; // Use the result to avoid warnings
break;- In
VecCharPtr.c:139:
case VEC_CHAR_PTR_FIRST : {
if (VecLen(vec) > 0) {
char *first = VecFirst(vec);
(void)first; // Use the result to avoid warnings
- In
VecCharPtr.c:147:
case VEC_CHAR_PTR_LAST : {
if (VecLen(vec) > 0) {
char *last = VecLast(vec);
(void)last; // Use the result to avoid warnings
- In
VecCharPtr.c:163:
if (*offset + 4 <= data_size) {
size_t new_size = extract_u32(data, offset, data_size) % 100; // Limit to reasonable size
size_t old_size = VecLen(vec);
// VecResize automatically handles cleanup of removed elements and
- In
VecCharPtr.c:213:
case VEC_CHAR_PTR_SWAP_ITEMS : {
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);- In
VecCharPtr.c:214:
case VEC_CHAR_PTR_SWAP_ITEMS : {
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);
VecSwapItems(vec, i, j);- In
VecCharPtr.c:215:
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);
VecSwapItems(vec, i, j);
}- In
VecCharPtr.c:223:
case VEC_CHAR_PTR_INSERT_RANGE : {
if (*offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
size_t count = extract_u32(data, offset, data_size) % 10; // Limit to reasonable count
- In
VecCharPtr.c:245:
case VEC_CHAR_PTR_REMOVE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecCharPtr.c:246:
case VEC_CHAR_PTR_REMOVE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRange(vec, (char **)NULL, index, count);- In
VecCharPtr.c:247:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRange(vec, (char **)NULL, index, count);
}- In
VecCharPtr.c:254:
case VEC_CHAR_PTR_DELETE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecCharPtr.c:255:
case VEC_CHAR_PTR_DELETE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRange(vec, index, count);- In
VecCharPtr.c:256:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRange(vec, index, count);
}- In
VecCharPtr.c:264:
case VEC_CHAR_PTR_INSERT_FAST : {
if (*offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
char *str = generate_cstring(data, offset, data_size, 32);
if (str) {- In
VecCharPtr.c:275:
case VEC_CHAR_PTR_REMOVE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str;- In
VecCharPtr.c:276:
case VEC_CHAR_PTR_REMOVE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char *str;
VecRemoveFast(vec, &str, index);- In
VecCharPtr.c:285:
case VEC_CHAR_PTR_REMOVE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecCharPtr.c:286:
case VEC_CHAR_PTR_REMOVE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRangeFast(vec, (char **)NULL, index, count);- In
VecCharPtr.c:287:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRangeFast(vec, (char **)NULL, index, count);
}- In
VecCharPtr.c:294:
case VEC_CHAR_PTR_DELETE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecCharPtr.c:295:
case VEC_CHAR_PTR_DELETE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRangeFast(vec, index, count);- In
VecCharPtr.c:296:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRangeFast(vec, index, count);
}- In
VecCharPtr.c:375:
case VEC_CHAR_PTR_BEGIN : {
if (VecLen(vec) > 0) {
char **begin = VecBegin(vec);
(void)begin; // Use the result to avoid warnings
- In
VecCharPtr.c:383:
case VEC_CHAR_PTR_END : {
if (VecLen(vec) > 0) {
char **end = VecEnd(vec);
(void)end; // Use the result to avoid warnings
- In
VecCharPtr.c:391:
case VEC_CHAR_PTR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char **ptr = VecPtrAt(vec, index);- In
VecCharPtr.c:392:
case VEC_CHAR_PTR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
char **ptr = VecPtrAt(vec, index);
(void)ptr; // Use the result to avoid warnings
- In
VecCharPtr.c:424:
case VEC_CHAR_PTR_INSERT_RANGE_FAST : {
if (*offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
size_t count = extract_u32(data, offset, data_size) % 10; // Limit to reasonable count
- In
VecCharPtr.c:446:
case VEC_CHAR_PTR_ALIGNED_OFFSET_AT : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t aligned = VecAlignedOffsetAt(vec, index);- In
VecCharPtr.c:447:
case VEC_CHAR_PTR_ALIGNED_OFFSET_AT : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t aligned = VecAlignedOffsetAt(vec, index);
(void)aligned;- In
VecCharPtr.c:455:
case VEC_CHAR_PTR_DELETE_LAST : {
if (VecLen(vec) > 0) {
VecDeleteLast(vec);
}- In
VecCharPtr.c:462:
case VEC_CHAR_PTR_DELETE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDeleteFast(vec, index);- In
VecCharPtr.c:463:
case VEC_CHAR_PTR_DELETE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDeleteFast(vec, index);
}- In
VecCharPtr.c:494:
// Foreach operations
case VEC_CHAR_PTR_FOREACH : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeach(vec, str) {- In
VecCharPtr.c:505:
case VEC_CHAR_PTR_FOREACH_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachIdx(vec, str, idx) {- In
VecCharPtr.c:516:
case VEC_CHAR_PTR_FOREACH_PTR : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtr(vec, str_ptr) {- In
VecCharPtr.c:527:
case VEC_CHAR_PTR_FOREACH_PTR_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrIdx(vec, str_ptr, idx) {- In
VecCharPtr.c:538:
case VEC_CHAR_PTR_FOREACH_REVERSE : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachReverse(vec, str) {- In
VecCharPtr.c:549:
case VEC_CHAR_PTR_FOREACH_REVERSE_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachReverseIdx(vec, str, idx) {- In
VecCharPtr.c:560:
case VEC_CHAR_PTR_FOREACH_PTR_REVERSE : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrReverse(vec, str_ptr) {- In
VecCharPtr.c:571:
case VEC_CHAR_PTR_FOREACH_PTR_REVERSE_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrReverseIdx(vec, str_ptr, idx) {- In
VecCharPtr.c:582:
case VEC_CHAR_PTR_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecCharPtr.c:583:
case VEC_CHAR_PTR_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecCharPtr.c:584:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecCharPtr.c:597:
case VEC_CHAR_PTR_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecCharPtr.c:598:
case VEC_CHAR_PTR_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecCharPtr.c:599:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecCharPtr.c:612:
case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecCharPtr.c:613:
case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecCharPtr.c:614:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecCharPtr.c:627:
case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecCharPtr.c:628:
case VEC_CHAR_PTR_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecCharPtr.c:629:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecStr.c:100:
case VEC_STR_POP_BACK : {
if (VecLen(vec) > 0) {
Str str;
VecPopBack(vec, &str);- In
VecStr.c:109:
case VEC_STR_POP_FRONT : {
if (VecLen(vec) > 0) {
Str str;
VecPopFront(vec, &str);- In
VecStr.c:119:
case VEC_STR_INSERT : {
if (*offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
Str str = generate_str_from_input(data, offset, data_size, 32, alloc);
VecInsert(vec, str, index);- In
VecStr.c:127:
case VEC_STR_REMOVE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str;- In
VecStr.c:128:
case VEC_STR_REMOVE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str;
VecRemove(vec, &str, index);- In
VecStr.c:137:
case VEC_STR_DELETE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDelete(vec, index);- In
VecStr.c:138:
case VEC_STR_DELETE : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDelete(vec, index);
// StrDeinit is called automatically by the vector
- In
VecStr.c:146:
case VEC_STR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str = VecAt(vec, index);- In
VecStr.c:147:
case VEC_STR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str = VecAt(vec, index);
(void)str; // Use the result to avoid warnings
- In
VecStr.c:155:
case VEC_STR_LEN : {
size_t len = VecLen(vec);
(void)len; // Use the result to avoid warnings
break;- In
VecStr.c:161:
case VEC_STR_FIRST : {
if (VecLen(vec) > 0) {
Str first = VecFirst(vec);
(void)first; // Use the result to avoid warnings
- In
VecStr.c:169:
case VEC_STR_LAST : {
if (VecLen(vec) > 0) {
Str last = VecLast(vec);
(void)last; // Use the result to avoid warnings
- In
VecStr.c:185:
if (*offset + 4 <= data_size) {
size_t new_size = extract_u32(data, offset, data_size) % 100; // Limit to reasonable size
size_t old_size = VecLen(vec);
// VecResize automatically handles cleanup of removed elements and
- In
VecStr.c:227:
case VEC_STR_SWAP_ITEMS : {
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);- In
VecStr.c:228:
case VEC_STR_SWAP_ITEMS : {
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);
VecSwapItems(vec, i, j);- In
VecStr.c:229:
if (VecLen(vec) >= 2 && *offset + 8 <= data_size) {
size_t i = extract_u32(data, offset, data_size) % VecLen(vec);
size_t j = extract_u32(data, offset, data_size) % VecLen(vec);
VecSwapItems(vec, i, j);
}- In
VecStr.c:237:
case VEC_STR_INSERT_RANGE : {
if (*offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
size_t count = extract_u32(data, offset, data_size) % 10; // Limit to reasonable count
- In
VecStr.c:254:
case VEC_STR_REMOVE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecStr.c:255:
case VEC_STR_REMOVE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRange(vec, (Str *)NULL, index, count);- In
VecStr.c:256:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRange(vec, (Str *)NULL, index, count);
}- In
VecStr.c:263:
case VEC_STR_DELETE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecStr.c:264:
case VEC_STR_DELETE_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRange(vec, index, count);- In
VecStr.c:265:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRange(vec, index, count);
}- In
VecStr.c:273:
case VEC_STR_INSERT_FAST : {
if (*offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
Str str = generate_str_from_input(data, offset, data_size, 32, alloc);
VecInsertFast(vec, str, index);- In
VecStr.c:281:
case VEC_STR_REMOVE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str;- In
VecStr.c:282:
case VEC_STR_REMOVE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str str;
VecRemoveFast(vec, &str, index);- In
VecStr.c:291:
case VEC_STR_REMOVE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecStr.c:292:
case VEC_STR_REMOVE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRangeFast(vec, (Str *)NULL, index, count);- In
VecStr.c:293:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecRemoveRangeFast(vec, (Str *)NULL, index, count);
}- In
VecStr.c:300:
case VEC_STR_DELETE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);- In
VecStr.c:301:
case VEC_STR_DELETE_RANGE_FAST : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRangeFast(vec, index, count);- In
VecStr.c:302:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
VecDeleteRangeFast(vec, index, count);
}- In
VecStr.c:363:
case VEC_STR_BEGIN : {
if (VecLen(vec) > 0) {
Str *begin = VecBegin(vec);
(void)begin; // Use the result to avoid warnings
- In
VecStr.c:371:
case VEC_STR_END : {
if (VecLen(vec) > 0) {
Str *end = VecEnd(vec);
(void)end; // Use the result to avoid warnings
- In
VecStr.c:379:
case VEC_STR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str *ptr = VecPtrAt(vec, index);- In
VecStr.c:380:
case VEC_STR_PTR_AT : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
Str *ptr = VecPtrAt(vec, index);
(void)ptr; // Use the result to avoid warnings
- In
VecStr.c:407:
case VEC_STR_INSERT_RANGE_FAST : {
if (*offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
size_t count = extract_u32(data, offset, data_size) % 10; // Limit to reasonable count
- In
VecStr.c:423:
case VEC_STR_ALIGNED_OFFSET_AT : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t aligned = VecAlignedOffsetAt(vec, index);- In
VecStr.c:424:
case VEC_STR_ALIGNED_OFFSET_AT : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
size_t aligned = VecAlignedOffsetAt(vec, index);
(void)aligned;- In
VecStr.c:432:
case VEC_STR_DELETE_LAST : {
if (VecLen(vec) > 0) {
VecDeleteLast(vec);
}- In
VecStr.c:439:
case VEC_STR_DELETE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDeleteFast(vec, index);- In
VecStr.c:440:
case VEC_STR_DELETE_FAST : {
if (VecLen(vec) > 0 && *offset + 4 <= data_size) {
size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
VecDeleteFast(vec, index);
}- In
VecStr.c:472:
// Foreach operations
case VEC_STR_FOREACH : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeach(vec, str) {- In
VecStr.c:483:
case VEC_STR_FOREACH_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachIdx(vec, str, idx) {- In
VecStr.c:494:
case VEC_STR_FOREACH_PTR : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtr(vec, str_ptr) {- In
VecStr.c:505:
case VEC_STR_FOREACH_PTR_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrIdx(vec, str_ptr, idx) {- In
VecStr.c:516:
case VEC_STR_FOREACH_REVERSE : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachReverse(vec, str) {- In
VecStr.c:527:
case VEC_STR_FOREACH_REVERSE_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachReverseIdx(vec, str, idx) {- In
VecStr.c:538:
case VEC_STR_FOREACH_PTR_REVERSE : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrReverse(vec, str_ptr) {- In
VecStr.c:549:
case VEC_STR_FOREACH_PTR_REVERSE_IDX : {
if (VecLen(vec) > 0) {
size_t total_len = 0;
VecForeachPtrReverseIdx(vec, str_ptr, idx) {- In
VecStr.c:560:
case VEC_STR_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecStr.c:561:
case VEC_STR_FOREACH_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecStr.c:562:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecStr.c:575:
case VEC_STR_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecStr.c:576:
case VEC_STR_FOREACH_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecStr.c:577:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecStr.c:590:
case VEC_STR_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecStr.c:591:
case VEC_STR_FOREACH_PTR_IN_RANGE : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecStr.c:592:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
VecStr.c:605:
case VEC_STR_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);- In
VecStr.c:606:
case VEC_STR_FOREACH_PTR_IN_RANGE_IDX : {
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {- In
VecStr.c:607:
if (VecLen(vec) > 0 && *offset + 8 <= data_size) {
size_t start = extract_u32(data, offset, data_size) % VecLen(vec);
size_t end = extract_u32(data, offset, data_size) % (VecLen(vec) + 1);
if (start < end) {
size_t total_len = 0;- In
ArgParse.c:370:
u64 left_w[64];
u64 max_w = 0;
u64 n_specs = VecLen(&self->specs);
if (n_specs > 64)
n_specs = 64;- In
Graph.c:37:
static void graph_validate_slot_limit(const GenericGraph *graph) {
if (VecLen(&graph->slots) > (u64)UINT32_MAX) {
LOG_FATAL("Graph exceeded maximum supported slot count");
}- In
Graph.c:51:
static void graph_validate_node_index_raw(const GenericGraph *graph, u32 index) {
if ((u64)index >= VecLen(&graph->slots)) {
LOG_FATAL("graph node id out of bounds");
}- In
Graph.c:178:
(const u8 *)&index,
sizeof(u32),
VecLen(&graph->free_indices),
1
)) {- In
Graph.c:188:
u32 index;
if (!VecLen(&graph->free_indices)) {
LOG_FATAL("expected at least one free graph slot");
}- In
Graph.c:199:
size idx;
for (idx = 0; idx < VecLen(neighbors); idx++) {
if (VecAt(neighbors, idx) == node_id) {
return true;- In
Graph.c:211:
size idx;
for (idx = 0; idx < VecLen(neighbors); idx++) {
if (VecAt(neighbors, idx) == node_id) {
return idx;- In
Graph.c:223:
size idx;
for (idx = 0; idx < VecLen(&graph->pending_edge_removals); idx++) {
const GraphPendingEdgeRemoval *pending =
VecPtrAt((GraphPendingEdgeRemovals *)&graph->pending_edge_removals, idx);- In
Graph.c:263:
size idx = 0;
while (idx < VecLen(neighbors)) {
GraphNodeId neighbor_id = VecAt(neighbors, idx);
const GenericGraphSlot *slot;- In
Graph.c:288:
GraphNeighbors *neighbors = graph_out_neighbors_ptr(graph, from);
while (VecLen(neighbors)) {
GraphNodeId to = VecLast(neighbors);
if (!graph_remove_edge_now(graph, from, to)) {- In
Graph.c:343:
graph_validate_slot_limit(graph);
if (graph->live_count > VecLen(&graph->slots)) {
LOG_FATAL("Graph live node count exceeds slot count");
}- In
Graph.c:351:
}
if ((graph->live_count + VecLen(&graph->free_indices)) != VecLen(&graph->slots)) {
LOG_FATAL("Graph slot accounting is inconsistent");
}- In
Graph.c:355:
}
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
const GenericGraphSlot *slot = VecPtrAt((GraphSlots *)&graph->slots, slot_index);
GraphNodeId self_id = graph_make_node_id((u32)slot_index, slot->generation);- In
Graph.c:373:
live_count += 1;
out_edge_count += VecLen(&slot->out_neighbors);
in_edge_count += VecLen(&slot->in_neighbors);
marked_count += graph_slot_is_marked(slot) ? 1 : 0;- In
Graph.c:374:
live_count += 1;
out_edge_count += VecLen(&slot->out_neighbors);
in_edge_count += VecLen(&slot->in_neighbors);
marked_count += graph_slot_is_marked(slot) ? 1 : 0;- In
Graph.c:377:
marked_count += graph_slot_is_marked(slot) ? 1 : 0;
for (neighbor_i = 0; neighbor_i < VecLen(&slot->out_neighbors); neighbor_i++) {
GraphNodeId neighbor_id = VecAt(&slot->out_neighbors, neighbor_i);
const GenericGraphSlot *target_slot;- In
Graph.c:388:
}
for (neighbor_i = 0; neighbor_i < VecLen(&slot->in_neighbors); neighbor_i++) {
GraphNodeId predecessor_id = VecAt(&slot->in_neighbors, neighbor_i);
const GenericGraphSlot *source_slot;- In
Graph.c:407:
}
if (VecLen(&slot->out_neighbors) != 0) {
LOG_FATAL("Free graph slot retains outgoing edges");
}- In
Graph.c:411:
}
if (VecLen(&slot->in_neighbors) != 0) {
LOG_FATAL("Free graph slot retains incoming edges");
}- In
Graph.c:417:
}
for (free_index_i = 0; free_index_i < VecLen(&graph->free_indices); free_index_i++) {
u32 index = VecAt(&graph->free_indices, free_index_i);
if ((u64)index >= VecLen(&graph->slots)) {- In
Graph.c:419:
for (free_index_i = 0; free_index_i < VecLen(&graph->free_indices); free_index_i++) {
u32 index = VecAt(&graph->free_indices, free_index_i);
if ((u64)index >= VecLen(&graph->slots)) {
LOG_FATAL("Graph free slot index out of bounds");
}- In
Graph.c:428:
}
for (free_index_i = 0; free_index_i < VecLen(&graph->pending_edge_removals); free_index_i++) {
const GraphPendingEdgeRemoval *pending =
VecPtrAt((GraphPendingEdgeRemovals *)&graph->pending_edge_removals, free_index_i);- In
Graph.c:473:
ValidateGraph(graph);
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot)) {- In
Graph.c:489:
clear_vec(GENERIC_VEC(&graph->free_indices), sizeof(u32));
clear_vec(GENERIC_VEC(&graph->pending_edge_removals), sizeof(GraphPendingEdgeRemoval));
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
u32 index = (u32)slot_index;
graph_push_free_index(graph, index);- In
Graph.c:534:
ValidateGraph(graph);
if (VecLen(&graph->free_indices)) {
slot_index = graph_take_free_index(graph);
slot_ptr = graph_slot_ptr_raw(graph, slot_index);- In
Graph.c:569:
graph_validate_slot_limit(graph);
if (!reserve_graph(graph, item_size, VecLen(&graph->slots) + 1)) {
return 0;
}- In
Graph.c:591:
(const u8 *)&slot,
sizeof(GenericGraphSlot),
VecLen(&graph->slots),
1
)) {- In
Graph.c:600:
}
slot_index = (u32)(VecLen(&graph->slots) - 1);
node_id = graph_make_node_id(slot_index, 1);- In
Graph.c:638:
generation = GraphNodeIdGeneration(node_id);
if (!generation || ((u64)index >= VecLen(&graph->slots))) {
return false;
}- In
Graph.c:680:
size graph_out_degree(GenericGraph *graph, GraphNodeId node_id) {
return VecLen(graph_out_neighbors_ptr(graph, node_id));
}- In
Graph.c:684:
size graph_in_degree(GenericGraph *graph, GraphNodeId node_id) {
return VecLen(graph_in_neighbors_ptr(graph, node_id));
}- In
Graph.c:694:
neighbors = graph_out_neighbors_ptr(graph, from);
if (neighbor_idx >= VecLen(neighbors)) {
LOG_FATAL("graph neighbor index out of bounds");
}- In
Graph.c:708:
neighbors = graph_in_neighbors_ptr(graph, to);
if (predecessor_idx >= VecLen(neighbors)) {
LOG_FATAL("graph predecessor index out of bounds");
}- In
Graph.c:744:
(const u8 *)&to,
sizeof(GraphNodeId),
VecLen(out_neighbors),
1
)) {- In
Graph.c:753:
(const u8 *)&from,
sizeof(GraphNodeId),
VecLen(in_neighbors),
1
)) {- In
Graph.c:756:
1
)) {
remove_range_vec(GENERIC_VEC(out_neighbors), NULL, sizeof(GraphNodeId), VecLen(out_neighbors) - 1, 1);
return false;
}- In
Graph.c:871:
(const u8 *)&pending,
sizeof(GraphPendingEdgeRemoval),
VecLen(&graph->pending_edge_removals),
1
);- In
Graph.c:908:
ValidateGraph(graph);
if (!graph->pending_delete_count && !VecLen(&graph->pending_edge_removals)) {
return 0;
}- In
Graph.c:912:
}
explicit_edge_removal_count = VecLen(&graph->pending_edge_removals);
for (edge_idx = 0; edge_idx < VecLen(&graph->pending_edge_removals); edge_idx++) {
GraphPendingEdgeRemoval *pending = VecPtrAt(&graph->pending_edge_removals, edge_idx);- In
Graph.c:913:
explicit_edge_removal_count = VecLen(&graph->pending_edge_removals);
for (edge_idx = 0; edge_idx < VecLen(&graph->pending_edge_removals); edge_idx++) {
GraphPendingEdgeRemoval *pending = VecPtrAt(&graph->pending_edge_removals, edge_idx);
(void)graph_remove_edge_now(graph, pending->from, pending->to);- In
Graph.c:919:
clear_vec(GENERIC_VEC(&graph->pending_edge_removals), sizeof(GraphPendingEdgeRemoval));
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot) && graph_slot_is_marked(slot)) {- In
Graph.c:927:
}
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot) && !graph_slot_is_marked(slot)) {- In
Graph.c:935:
}
for (slot_index = 0; slot_index < VecLen(&graph->slots); slot_index++) {
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot) && graph_slot_is_marked(slot)) {- In
Graph.c:938:
GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
if (graph_slot_is_occupied(slot) && graph_slot_is_marked(slot)) {
if (VecLen(&slot->out_neighbors) || VecLen(&slot->in_neighbors)) {
LOG_FATAL("Graph marked node retained incident edges before release");
}- In
Graph.c:978:
}
while (iter->slot_index < VecLen(&iter->graph->slots)) {
u32 index = (u32)iter->slot_index;
GenericGraphSlot *slot = VecPtrAt(&iter->graph->slots, iter->slot_index);- In
Graph.c:1026:
neighbors = graph_out_neighbors_ptr(iter->graph, iter->source_id);
while (iter->neighbor_index < VecLen(neighbors)) {
GraphNodeId neighbor_id = VecAt(neighbors, iter->neighbor_index);
iter->neighbor_index += 1;- In
Graph.c:1073:
neighbors = graph_in_neighbors_ptr(iter->graph, iter->target_id);
while (iter->predecessor_index < VecLen(neighbors)) {
GraphNodeId predecessor_id = VecAt(neighbors, iter->predecessor_index);
iter->predecessor_index += 1;- In
Debug.c:210:
static const DebugFreedEntry *debug_freed_find(const DebugAllocator *dbg, void *ptr) {
for (u32 i = 0; i < VecLen(&dbg->freed); i++) {
if (VecPtrAt(&dbg->freed, i)->ptr == ptr)
return VecPtrAt(&dbg->freed, i);- In
Debug.c:526:
if (!self)
return 0;
return VecLen(&self->freed);
}- In
Dir.c:545:
size path_len = ZstrLen(path);
bool trail_sep = (path_len > 0 && path[path_len - 1] == '/');
for (size i = 0; i < VecLen(&dc); ++i) {
DirEntry *e = VecPtrAt(&dc, i);
Zstr entry_nm = StrBegin(&e->name);
static ResolverCacheEntry *resolver_cache_find_or_open(SymbolResolver *self, Zstr path) {
for (u64 i = 0; i < VecLen(&self->cache); ++i) {
ResolverCacheEntry *e = VecPtrAt(&self->cache, i);
if (e->path == path) { return NULL;
}
return VecPtrAt(&self->cache, VecLen(&self->cache) - 1);
} if (!self)
return;
for (u64 i = 0; i < VecLen(&self->cache); ++i) {
ResolverCacheEntry *e = VecPtrAt(&self->cache, i);
#if FEATURE_PARSER_DWARF static const ElfSymbol *resolver_search_symbols(const Elf *elf, const ElfSymbols *syms, u64 vaddr) {
const ElfSymbol *best = NULL;
for (u64 i = 0; i < VecLen(syms); ++i) {
const ElfSymbol *s = VecPtrAt(syms, i);
// Consider only real address symbols. Like llvm-symbolizer, keep
- In
PdbCache.c:94:
// Find an existing entry for `module_path` or create a fresh one.
static PdbCacheEntry *cache_find_or_open(PdbCache *self, Zstr module_path) {
for (size i = 0; i < VecLen(&self->entries); ++i) {
PdbCacheEntry *e = VecPtrAt(&self->entries, i);
if (StrBegin(&e->module_path) && ZstrCompare(StrBegin(&e->module_path), module_path) == 0) {- In
PdbCache.c:111:
return NULL;
}
return VecPtrAt(&self->entries, VecLen(&self->entries) - 1);
}- In
PdbCache.c:121:
if (!self)
return;
for (size i = 0; i < VecLen(&self->entries); ++i) {
PdbCacheEntry *e = VecPtrAt(&self->entries, i);
if (e->pdb_open)- In
Dns.c:530:
u8 resp_buf[1232]; // safe UDP payload (avoids IP fragmentation)
i64 got = udp_round_trip(ns, VecBegin(&query), VecLen(&query), resp_buf, sizeof(resp_buf), self->timeout_ms);
VecDeinit(&query);
if (got <= 0) {- In
Dns.c:595:
// 2. Nameserver query path.
if (VecLen(&self->nameservers) == 0) {
LOG_ERROR("DnsResolve: no nameservers configured (read /etc/resolv.conf at init)");
break;- In
Dns.c:710:
DnsAddrs addrs = VecInitT(addrs, self->allocator);
bool ok = dns_resolve_4_vec_zstr(self, spec, kind, &addrs);
bool have_one = ok && VecLen(&addrs) > 0;
if (have_one) {
*out = VecAt(&addrs, 0);- In
Backtrace.c:274:
if (!out || !frames)
return;
format_walk_win(out, VecBegin(frames), VecLen(frames), alloc);
}- In
Backtrace.c:436:
if (!out || !frames || !alloc)
return;
format_walk_mac(out, VecBegin(frames), VecLen(frames), alloc);
}- In
Backtrace.c:514:
if (!out || !frames || !resolver)
return;
format_walk_with(out, VecBegin(frames), VecLen(frames), resolver);
}- In
Backtrace.c:526:
if (!out || !frames || !alloc)
return;
format_walk_alloc(out, VecBegin(frames), VecLen(frames), alloc);
}- In
MachoCache.c:40:
static MachoCacheEntry *cache_find_or_create(MachoCache *self, Zstr module_path) {
for (size i = 0; i < VecLen(&self->entries); ++i) {
MachoCacheEntry *e = VecPtrAt(&self->entries, i);
if (StrBegin(&e->module_path) && ZstrCompare(StrBegin(&e->module_path), module_path) == 0) {- In
MachoCache.c:57:
return NULL;
}
return VecPtrAt(&self->entries, VecLen(&self->entries) - 1);
}- In
MachoCache.c:133:
if (!self)
return;
for (size i = 0; i < VecLen(&self->entries); ++i) {
MachoCacheEntry *e = VecPtrAt(&self->entries, i);
if (e->fns_built && e->fns_ok)- In
Pe.c:580:
if (!self || !name)
return NULL;
for (size i = 0; i < VecLen(&self->sections); ++i) {
const PeSection *s = VecPtrAt(&self->sections, i);
if (ZstrCompare(s->name, name) == 0) {- In
Pe.c:598:
if (!self || !out_offset)
return false;
for (size i = 0; i < VecLen(&self->sections); ++i) {
const PeSection *s = VecPtrAt(&self->sections, i);
// Compute the section end in u64; u32 + u32 can wrap.
- In
DwarfInfo.c:98:
static void abbrev_table_deinit(AbbrevTable *t) {
for (size i = 0; i < VecLen(t); ++i) {
VecDeinit(&VecPtrAt(t, i)->attrs);
}- In
DwarfInfo.c:160:
static const AbbrevEntry *abbrev_table_find(const AbbrevTable *t, u64 code) {
for (size i = 0; i < VecLen(t); ++i) {
if (VecPtrAt(t, i)->code == code)
return VecPtrAt(t, i);- In
DwarfInfo.c:378:
bool name_from_strp = false;
for (size ai = 0; ai < VecLen(&e->attrs); ++ai) {
const AbbrevAttr *a = VecPtrAt(&e->attrs, ai);
AttrVal v;- In
DwarfInfo.c:609:
// Resolve name_offset_in_pool into char* now that string_pool
// has stopped growing.
for (size i = 0; i < VecLen(&pending); ++i) {
const PendingFn *pf = VecPtrAt(&pending, i);
DwarfFunction f = {- In
DwarfInfo.c:622:
}
// Sort by low_pc to enable binary-search lookup.
if (ok && VecLen(&out->entries) > 1) {
VecSort(&out->entries, cmp_dwarf_function);
}- In
DwarfInfo.c:659:
const DwarfFunction *DwarfFunctionsResolve(const DwarfFunctions *self, u64 vaddr) {
if (!self || VecLen(&self->entries) == 0)
return NULL;
// Binary-search for the largest low_pc <= vaddr.
- In
DwarfInfo.c:662:
return NULL;
// Binary-search for the largest low_pc <= vaddr.
size lo = 0, hi = VecLen(&self->entries);
while (lo < hi) {
size mid = lo + (hi - lo) / 2;- In
Pdb.c:653:
}
if (VecLen(&pending) == 0) {
VecDeinit(&pending);
return true;- In
Pdb.c:664:
// (now-stable) pool buffer, push into self->functions, and fill
// sizes by next-rva diff.
for (size i = 0; i < VecLen(&pending); ++i) {
const PendingPub *pp = VecPtrAt(&pending, i);
PdbFunction f = {- In
Pdb.c:671:
.name = StrBegin(&self->name_pool) + pp->name_offset_in_pool,
};
if (i + 1 < VecLen(&pending)) {
// Although `pending` is sorted ascending by rva, treat the
// u32 subtraction defensively in case a future sort
- In
Pdb.c:778:
const PdbFunction *PdbResolveRva(const Pdb *self, u32 rva) {
if (!self || VecLen(&self->functions) == 0)
return NULL;
// Binary search for the largest rva <= input.
- In
Pdb.c:781:
return NULL;
// Binary search for the largest rva <= input.
size lo = 0, hi = VecLen(&self->functions);
while (lo < hi) {
size mid = lo + (hi - lo) / 2;- In
ProcMaps.c:195:
// Cache the lowest mapped address so callers don't rescan the vector.
for (u64 i = 0; i < VecLen(&out->entries); ++i) {
const ProcMapEntry *e = VecPtrAt(&out->entries, i);
if (i == 0 || e->start < out->min_addr)- In
ProcMaps.c:305:
if (!self)
return NULL;
for (u64 i = 0; i < VecLen(&self->entries); ++i) {
const ProcMapEntry *e = VecPtrAt(&self->entries, i);
if (addr >= e->start && addr < e->end) {- In
Http.c:154:
}
if (VecLen(&req->headers) >= HTTP_REQUEST_HEADERS_MAX) {
LOG_ERROR("http request header count exceeds {} cap", HTTP_REQUEST_HEADERS_MAX);
return in; if (!self)
return NULL;
for (u64 i = 0; i < VecLen(&self->cies); ++i) {
if (VecPtrAt(&self->cies, i)->offset == cie_offset) {
return VecPtrAt(&self->cies, i); return NULL;
// Linear scan -- fine up to a few thousand FDEs.
for (u64 i = 0; i < VecLen(&self->fdes); ++i) {
const DwarfFde *f = VecPtrAt(&self->fdes, i);
if (vaddr >= f->pc_begin && vaddr < f->pc_begin + f->pc_range) {- In
MachO.c:487:
if (!self || !segment || !section)
return NULL;
for (size i = 0; i < VecLen(&self->sections); ++i) {
const MachoSection *s = VecPtrAt(&self->sections, i);
if (ZstrCompare(s->segment, segment) == 0 && ZstrCompare(s->section, section) == 0) {- In
MachO.c:501:
// stab iff any of the high three bits of n_type is set.
const MachoSymbol *MachoResolveAddress(const Macho *self, u64 vaddr) {
if (!self || VecLen(&self->symbols) == 0)
return NULL;
enum {- In
MachO.c:512:
u64 next_value = (u64)-1;
for (size i = 0; i < VecLen(&self->symbols); ++i) {
const MachoSymbol *s = VecPtrAt(&self->symbols, i);
if (s->type & N_STAB_MASK)- In
Elf.c:317:
// associated string table.
u32 strtab_idx = symtab->link;
if (strtab_idx >= VecLen(&self->sections)) {
LOG_ERROR("Elf: symtab link {} out of range", (u32)strtab_idx);
return false;- In
Elf.c:368:
const ElfSection *dynsymtab = NULL;
for (u64 i = 0; i < VecLen(&self->sections); ++i) {
const ElfSection *s = VecPtrAt(&self->sections, i);
if (s->type == ELF_SECTION_TYPE_SYMTAB) {- In
Elf.c:555:
static const ElfSymbol *elf_search_symbols(const ElfSymbols *syms, u64 vaddr) {
const ElfSymbol *best = NULL;
for (u64 i = 0; i < VecLen(syms); ++i) {
const ElfSymbol *s = VecPtrAt(syms, i);
if (s->size == 0) {- In
Elf.c:588:
if (!self || !name)
return NULL;
for (u64 i = 0; i < VecLen(&self->sections); ++i) {
const ElfSection *s = VecPtrAt(&self->sections, i);
if (s->name && ZstrCompare(s->name, name) == 0) {- In
Dwarf.c:314:
u64 file_off = 0;
u64 dir_off = 0;
if (st->file >= 1 && st->file - 1 < VecLen(&cs->file_offsets)) {
file_off = VecAt(&cs->file_offsets, st->file - 1);
u64 dir_idx = VecAt(&cs->file_dir_idx, st->file - 1);- In
Dwarf.c:317:
file_off = VecAt(&cs->file_offsets, st->file - 1);
u64 dir_idx = VecAt(&cs->file_dir_idx, st->file - 1);
if (dir_idx >= 1 && dir_idx - 1 < VecLen(&cs->dir_offsets)) {
dir_off = VecAt(&cs->dir_offsets, dir_idx - 1);
}- In
Dwarf.c:640:
// Resolve offsets -> pointers now that string_pool won't grow.
if (ok) {
for (u64 i = 0; i < VecLen(&out->entries); ++i) {
u64 fo = VecAt(&pending_file_offsets, i);
u64 dofs = VecAt(&pending_dir_offsets, i);- In
Dwarf.c:671:
const DwarfLineEntry *DwarfLinesResolve(const DwarfLines *self, u64 vaddr) {
if (!self || VecLen(&self->entries) == 0)
return NULL;- In
Dwarf.c:680:
const DwarfLineEntry *best = NULL;
const DwarfLineEntry *seq_open = NULL;
for (u64 i = 0; i < VecLen(&self->entries); ++i) {
const DwarfLineEntry *e = VecPtrAt(&self->entries, i);
if (e->end_sequence) {- In
Init.c:30:
GraphNodeId second_id = GraphAddNodeR(&graph, 20);
GraphNodeId third_id = GraphAddNodeR(&graph, 30);
u64 slot_count = VecLen(&graph.slots);
size slot_capacity = VecCapacity(&graph.slots);
u32 first_generation = GraphNodeIdGeneration(first_id);- In
Init.c:54:
// on the graph's private bookkeeping after GraphClear, which the public
// surface does not expose.
result = result && VecLen(&graph.slots) == slot_count && VecLen(&graph.free_indices) == slot_count;
result = result && VecCapacity(&graph.slots) == slot_capacity && VecCapacity(&graph.free_indices) >= slot_count;
result = result && graph.pending_delete_count == 0 && VecLen(&graph.pending_edge_removals) == 0;- In
Init.c:56:
result = result && VecLen(&graph.slots) == slot_count && VecLen(&graph.free_indices) == slot_count;
result = result && VecCapacity(&graph.slots) == slot_capacity && VecCapacity(&graph.free_indices) >= slot_count;
result = result && graph.pending_delete_count == 0 && VecLen(&graph.pending_edge_removals) == 0;
for (slot_index = 0; slot_index < VecLen(&graph.slots); slot_index++) {- In
Init.c:58:
result = result && graph.pending_delete_count == 0 && VecLen(&graph.pending_edge_removals) == 0;
for (slot_index = 0; slot_index < VecLen(&graph.slots); slot_index++) {
// `graph.slots` is the typed `Vec(GraphSlot(int))`, so iterate via
// the runtime-shared layout to avoid an anonymous-struct annotation.
- In
Init.c:65:
result = result && (slot->visit_count == 0);
result = result && (slot->flags == 0);
result = result && (VecLen(&slot->out_neighbors) == 0);
result = result && (VecLen(&slot->in_neighbors) == 0);
}- In
Init.c:66:
result = result && (slot->flags == 0);
result = result && (VecLen(&slot->out_neighbors) == 0);
result = result && (VecLen(&slot->in_neighbors) == 0);
}- In
Type.c:411:
GenericGraph *g = GENERIC_GRAPH(&graph);
// Point the free index exactly one past the last slot.
*VecPtrAt(&g->free_indices, 0) = (u32)VecLen(&g->slots);
MAGIC_MARK_DIRTY(g);- In
Type.c:443:
// free_indices now holds two freed indices; redirect the last to a
// (occupied) so only a loop that reaches the last entry catches it.
*VecPtrAt(&g->free_indices, VecLen(&g->free_indices) - 1) = GraphNodeIdIndex(a);
MAGIC_MARK_DIRTY(g);- In
Ops.c:90:
// Check that the elements are reversed
bool result = true;
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[4 - i]);
}- In
Ops.c:98:
// Check that the elements are back in the original order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Ops.c:113:
// Check that the elements are reversed
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == even_values[3 - i]);
}- In
Ops.c:143:
bool result = true;
int sorted_asc[] = {10, 20, 30, 40, 50};
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == sorted_asc[i]);
}- In
Ops.c:152:
// Check that the elements are sorted in descending order
int sorted_desc[] = {50, 40, 30, 20, 10};
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == sorted_desc[i]);
}- In
Complex.c:187:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL &&
VecCopyInit(&vec) == (GenericCopyInit)ComplexItemCopyInit &&
VecCopyDeinit(&vec) == (GenericCopyDeinit)ComplexItemDeinit);- In
Complex.c:199:
// Check that the vector now has one item
result = result && (VecLen(&vec) == 1);
// Check that the item was copied correctly
- In
Complex.c:243:
// Check vector length
bool result = (VecLen(&vec) == 3);
// Check items order: item2, item1, item3
- In
Complex.c:291:
// Check vector length
bool result = (VecLen(&vec) == 3);
// Check items order: item2, item3, item1
- In
Complex.c:334:
// Check vector lengths
bool result = (VecLen(&vec1) == 3);
result = result && (VecLen(&vec2) == 2); // VecMergeR doesn't modify source vector
- In
Complex.c:335:
// Check vector lengths
bool result = (VecLen(&vec1) == 3);
result = result && (VecLen(&vec2) == 2); // VecMergeR doesn't modify source vector
// Check items in vec1: item1, item2, item3
- In
Complex.c:365:
// Check vector lengths
result = result && (VecLen(&vec3) == 2);
result = result && (VecLen(&vec4) == 0); // VecMergeL resets source vector
result = result && (VecBegin(&vec4) == NULL);- In
Complex.c:366:
// Check vector lengths
result = result && (VecLen(&vec3) == 2);
result = result && (VecLen(&vec4) == 0); // VecMergeL resets source vector
result = result && (VecBegin(&vec4) == NULL);- In
Complex.c:406:
// Check vector length
bool result = (VecLen(&vec) == 3);
// Check items order: val2, val3, val1
- In
Complex.c:420:
// Check vector length
result = result && (VecLen(&vec) == 6);
// Check items: val2, val3, val1, arr[0], arr[1], arr[2]
- In
Complex.c:452:
// Check vector length
bool result = (VecLen(&vec) == 6);
// Check that the element was inserted
- In
Complex.c:463:
// Check vector length
result = result && (VecLen(&vec) == 9);
// Check that the array was inserted
- In
Complex.c:482:
// Ensure we have enough capacity to avoid reallocation during the test
VecReserve(&vec2, VecLen(&vec2) + 10);
// Try inserting just one element first with fast insert
- In
Complex.c:488:
VecInsertFastR(&vec2, single_val, 2);
result = result && (VecLen(&vec2) == 6);
result = result && (VecAt(&vec2, 2) == 42);- In
Complex.c:498:
// Check vector length
result = result && (VecLen(&vec2) == 8);
// Check that the array was inserted
- In
Complex.c:526:
// Check vector length after deletion
bool result = (VecLen(&vec) == 8);
// Check that the element was deleted and elements shifted
- In
Complex.c:537:
// Check vector length after range deletion
result = result && (VecLen(&vec) == 6);
// Check that elements were deleted and remaining elements shifted
- In
Complex.c:557:
// Check vector length after fast deletion
result = result && (VecLen(&vec) == 8);
// Check that the element was deleted and replaced with the last element (90)
- In
Complex.c:569:
// Check vector length after fast range deletion
result = result && (VecLen(&vec) == 6);
// Check that elements were deleted and replaced with elements from the end
- In
Complex.c:590:
// Check vector length after deletion
result = result && (VecLen(&vec) == 8);
// Check that the element was deleted
- In
Complex.c:611:
// Test pushing to empty vector
VecPushBackR(&vec, 10);
bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 10);
// Test pushing with zero count
- In
Complex.c:617:
int small_arr[1] = {42};
VecPushBackArrR(&vec, small_arr, 0);
result = result && (VecLen(&vec) == 1); // Length should not change
// Test inserting at end index
- In
Complex.c:620:
// Test inserting at end index
VecInsertR(&vec, 20, VecLen(&vec));
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 1) == 20);- In
Complex.c:621:
// Test inserting at end index
VecInsertR(&vec, 20, VecLen(&vec));
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 1) == 20);
// Test with large number of elements
- In
Complex.c:633:
}
result = result && (VecLen(&vec) == large_count);
// Verify all elements
- In
Complex.c:655:
// Push an element (should auto-resize)
VecPushBackR(&vec, 42);
result = result && (VecLen(&vec) == 1 && VecAt(&vec, 0) == 42);
// Clean up
- In
Complex.c:774:
int values3[] = {70, 80, 90};
ComplexItem item3 = InitComplexItem("Fast Item 3", values3, 3);
VecInsertFastL(&vec, item3, VecLen(&vec));
// Check that the item was zeroed
- In
Complex.c:782:
// Verify vector integrity - should have 6 items now
result = result && (VecLen(&vec) == 6);
// Clean up the vector
- In
Complex.c:849:
// Check that vec2 is now empty (data has been transferred)
result = result && (VecLen(&vec2) == 0);
result = result && (VecBegin(&vec2) == NULL);- In
Complex.c:918:
// Under the mutant src->length != 0 returns true immediately and dst is
// left empty (length 0).
bool result = (VecLen(&dst) == 3) && (VecAt(&dst, 0) == 1) && (VecAt(&dst, 1) == 2) && (VecAt(&dst, 2) == 3);
VecDeinit(&src);- In
Complex.c:944:
// Real: dst has all 3 elements starting at index 0. Mutant (init 42):
// 42 < 3 is false, loop skipped, dst length 0.
bool result = (VecLen(&dst) == 3) && (VecAt(&dst, 0) == 1);
VecDeinit(&src);- In
Complex.c:969:
// Mutant (i >= length): 0 >= 3 is false, loop never runs, dst empty.
bool result = (VecLen(&dst) == 3);
VecDeinit(&src);- In
Complex.c:994:
// Real: dst length 3, all values present. Mutant (i--): dst length 1.
bool result = (VecLen(&dst) == 3) && (VecAt(&dst, 0) == 1) && (VecAt(&dst, 1) == 2) && (VecAt(&dst, 2) == 3);
VecDeinit(&src);- In
Complex.c:1020:
// Real: cloned true, dst length 3. Mutant: insert expression is 0 so the
// clone returns false with dst empty.
bool result = cloned && (VecLen(&dst) == 3);
VecDeinit(&src);- In
Memory.c:106:
// Capacity should now be closer to the actual length
result = result && (VecCapacity(&vec) < 100) && (VecCapacity(&vec) >= VecLen(&vec));
// Check that the data is still intact
- In
Memory.c:109:
// Check that the data is still intact
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Memory.c:137:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Resize to a smaller length
- In
Memory.c:143:
// Length should now be 3
result = result && (VecLen(&vec) == 3);
// First 3 elements should be unchanged
- In
Memory.c:154:
// Length should now be 8
result = result && (VecLen(&vec) == 8);
// First 3 elements should still be the same
- In
Memory.c:188:
// Length should still be 0
result = result && (VecLen(&vec) == 0);
// Add some data
- In
Memory.c:200:
// Length should now be 5
result = result && (VecLen(&vec) == 5);
// Reserve less space (should be a no-op)
- In
Memory.c:232:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Remember the capacity
- In
Memory.c:241:
// Length should now be 0
result = result && (VecLen(&vec) == 0);
// Capacity should remain the same
- In
Memory.c:275:
bool ok = VecResize(&vec, 100);
bool result = ok && (VecLen(&vec) == 100) && (VecCapacity(&vec) >= 100);
VecDeinit(&vec);- In
Memory.c:298:
VecResize(&vec, 1);
bool result = (VecLen(&vec) == 1) && (g_deinit_count == 3);
VecDeinit(&vec);- In
Memory.c:341:
VecResize(&vec, 50);
bool result = (VecLen(&vec) == 50);
VecDeinit(&vec);- In
Memory.c:358:
VecResize(&vec, 10);
bool result = (VecLen(&vec) == 10) && (VecCapacity(&vec) == 16);
VecDeinit(&vec);- In
Memory.c:389:
// Live data in [0,8); resize re-zeroes only the sentinel slot.
VecResize(&vec, 8);
for (u64 i = 0; i < VecLen(&vec); i++) {
VecAt(&vec, i) = 0x11111111;
}- In
Memory.c:433:
bool ok = VecReserve(&vec, (size)-1 - 1);
bool result = (ok == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Memory.c:500:
VecClear(&vec);
bool result = (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Memory.c:526:
VecClear(&vec);
bool result = (g_deinit_calls == 3) && (VecLen(&vec) == 0);
// Drop the hook so the final teardown does not re-run the counter.
- In
Memory.c:563:
// Real: every element survives the shrink.
bool result = (VecLen(&vec) == N);
for (u32 i = 0; i < N; i++) {
result = result && (VecAt(&vec, i).tag == 100 + i);- In
Memory.c:591:
// Real: length stays 5.
bool result = (VecLen(&vec) == 5);
VecDeinit(&vec);- In
Memory.c:633:
// Real: length 0.
bool result = (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Init.c:65:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 1 &&
VecCopyInit(&vec) == NULL && VecCopyDeinit(&vec) == NULL);- In
Init.c:76:
// Check initial state
result = result && (VecLen(&test_vec) == 0 && VecCapacity(&test_vec) == 0 && VecBegin(&test_vec) == NULL &&
VecAllocator(&test_vec)->alignment == 1 && VecCopyInit(&test_vec) == NULL &&
VecCopyDeinit(&test_vec) == NULL);- In
Init.c:99:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 4 &&
VecCopyInit(&vec) == NULL && VecCopyDeinit(&vec) == NULL);- In
Init.c:110:
// Check initial state
result = result && (VecLen(&test_vec) == 0 && VecCapacity(&test_vec) == 0 && VecBegin(&test_vec) == NULL &&
VecAllocator(&test_vec)->alignment == 16 && VecCopyInit(&test_vec) == NULL &&
VecCopyDeinit(&test_vec) == NULL);- In
Init.c:132:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 1 &&
VecCopyInit(&vec) == (GenericCopyInit)TestItemCopyInit &&
VecCopyDeinit(&vec) == (GenericCopyDeinit)TestItemDeinit);- In
Init.c:154:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 8 &&
VecCopyInit(&vec) == (GenericCopyInit)TestItemCopyInit &&
VecCopyDeinit(&vec) == (GenericCopyDeinit)TestItemDeinit);- In
Init.c:231:
VecInitStack(int, vec, 10) {
// Stack-init: NULL allocator distinguishes from heap-init.
if (VecLen(&vec) != 0 || VecCapacity(&vec) != 10 || VecBegin(&vec) == NULL || VecAllocator(&vec) != NULL) {
result = false;
}- In
Init.c:239:
VecPushBackR(&vec, 30);
if (VecLen(&vec) != 3 || VecAt(&vec, 0) != 10 || VecAt(&vec, 1) != 20 || VecAt(&vec, 2) != 30) {
result = false;
}- In
Init.c:246:
// Test with struct type
VecInitStack(TestItem, test_vec, 5) {
if (VecLen(&test_vec) != 0 || VecCapacity(&test_vec) != 5 || VecBegin(&test_vec) == NULL ||
VecAllocator(&test_vec) != NULL) {
result = false;- In
Init.c:256:
VecPushBackR(&test_vec, item);
if (VecLen(&test_vec) != 1 || VecAt(&test_vec, 0).id != 1 || VecAt(&test_vec, 0).value != 3.14f) {
result = false;
}- In
Init.c:274:
AlignedItem item = {.a = 7, .b = 2.71828};
VecPushBackR(&av, item);
if (VecLen(&av) != 1 || VecAt(&av, 0).a != 7 || VecAt(&av, 0).b != 2.71828) {
result = false;
}- In
Init.c:283:
VecInitStack(int, breakable, 8) {
VecPushBackR(&breakable, 1);
if (VecLen(&breakable) != 1) {
result = false;
}- In
Init.c:309:
// Clone the source vector into the destination
VecPushBackArrR(&clone, VecBegin(&src), VecLen(&src));
// Check that the clone has the same data but different memory
- In
Init.c:313:
// Check that the clone has the same data but different memory
bool result =
(VecLen(&clone) == VecLen(&src) && VecCapacity(&clone) >= VecLen(&src) && VecBegin(&clone) != VecBegin(&src) &&
VecAllocator(&clone)->alignment == VecAllocator(&src)->alignment);- In
Init.c:318:
// Check the actual data
if (result) {
for (size i = 0; i < VecLen(&src); i++) {
if (VecAt(&clone, i) != VecAt(&src, i)) {
result = false;- In
Insert.c:93:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in order
- In
Insert.c:96:
// Check elements in order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Insert.c:121:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in reverse order (since we pushed to front)
- In
Insert.c:124:
// Check elements in reverse order (since we pushed to front)
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[4 - i]);
}- In
Insert.c:146:
// Check first element
bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 10);
// Insert at the end
- In
Insert.c:152:
// Check elements
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 0) == 10 && VecAt(&vec, 1) == 30);
// Insert in the middle
- In
Insert.c:158:
// Check all elements
result = result && (VecLen(&vec) == 3);
result = result && (VecAt(&vec, 0) == 10);
result = result && (VecAt(&vec, 1) == 20);- In
Insert.c:182:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in order
- In
Insert.c:185:
// Check elements in order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Insert.c:194:
// Check length
result = result && (VecLen(&vec) == 8);
// Check all elements
- In
Insert.c:223:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in order
- In
Insert.c:226:
// Check elements in order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Insert.c:235:
// Check length
result = result && (VecLen(&vec) == 8);
// Check all elements
- In
Insert.c:268:
// Check length
bool result = (VecLen(&vec) == 5);
// Expected result: [10, 30, 40, 50, 20]
- In
Insert.c:274:
// Check all elements
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Insert.c:302:
// Insert range in the middle
VecInsertRangeR(&vec, VecBegin(&src), 1, VecLen(&src));
// Check length
- In
Insert.c:305:
// Check length
bool result = (VecLen(&vec) == 6);
// Expected result: [10, 40, 50, 60, 20, 30]
- In
Insert.c:311:
// Check all elements
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Insert.c:345:
// Check lengths
bool result = (VecLen(&vec1) == 6);
result = result && (VecLen(&vec2) == 3); // VecMergeR doesn't modify source vector
- In
Insert.c:346:
// Check lengths
bool result = (VecLen(&vec1) == 6);
result = result && (VecLen(&vec2) == 3); // VecMergeR doesn't modify source vector
// Expected result in vec1: [10, 20, 30, 40, 50, 60]
- In
Insert.c:352:
// Check all elements in vec1
for (size i = 0; i < VecLen(&vec1); i++) {
result = result && (VecAt(&vec1, i) == expected[i]);
}- In
Insert.c:392:
dst.copy_init = src.copy_init;
dst.copy_deinit = src.copy_deinit;
bool cloned = VecPushBackArrR(&dst, VecBegin(&src), VecLen(&src));
bool allocator_matches = VecAllocator(&dst) == VecAllocator(&src);- In
Insert.c:398:
bool result = cloned && VecCopyInit(&dst) == VecCopyInit(&src) && VecCopyDeinit(&dst) == VecCopyDeinit(&src) &&
VecAllocator(&dst)->effort == ALLOCATOR_EFFORT_RETRY_FALLBACK &&
VecAllocator(&dst)->retry_limit == 11 && allocator_matches && VecLen(&src) == 3 &&
VecAt(&src, 0) == 10 && VecAt(&src, 1) == 20 && VecAt(&src, 2) == 30 && VecLen(&dst) == 3 &&
VecAt(&dst, 0) == 10 && VecAt(&dst, 1) == 20 && VecAt(&dst, 2) == 30;- In
Insert.c:399:
VecAllocator(&dst)->effort == ALLOCATOR_EFFORT_RETRY_FALLBACK &&
VecAllocator(&dst)->retry_limit == 11 && allocator_matches && VecLen(&src) == 3 &&
VecAt(&src, 0) == 10 && VecAt(&src, 1) == 20 && VecAt(&src, 2) == 30 && VecLen(&dst) == 3 &&
VecAt(&dst, 0) == 10 && VecAt(&dst, 1) == 20 && VecAt(&dst, 2) == 30;- In
Insert.c:420:
// Check that the element was added
bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 42);
// Test L-value insert operations
- In
Insert.c:427:
// Check that the element was added
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 1) == 100);
// Test R-value insert at index
- In
Insert.c:433:
// Check that the element was inserted
result = result && (VecLen(&vec) == 3);
result = result && (VecAt(&vec, 0) == 42);
result = result && (VecAt(&vec, 1) == 50);- In
Insert.c:443:
// Check that the element was inserted
result = result && (VecLen(&vec) == 4);
result = result && (VecAt(&vec, 0) == 42);
result = result && (VecAt(&vec, 1) == 50);- In
Insert.c:453:
// Check that the element was inserted
result = result && (VecLen(&vec) == 5);
result = result && (VecAt(&vec, 1) == 60);- In
Insert.c:461:
// Check that the element was inserted
result = result && (VecLen(&vec) == 6);
result = result && (VecAt(&vec, 3) == 80);- In
Insert.c:471:
// Check that the elements were added
result = result && (VecLen(&vec) == 9);
result = result && (VecAt(&vec, 6) == 200);
result = result && (VecAt(&vec, 7) == 300);- In
Insert.c:480:
// Check that the elements were added
result = result && (VecLen(&vec) == 12);
result = result && (VecAt(&vec, 0) == 200);
result = result && (VecAt(&vec, 1) == 300);- In
Insert.c:557:
// Check that the source vector is cleared
result = result && (VecLen(&vec2) == 0);
result = result && (VecBegin(&vec2) == NULL);- In
Insert.c:590:
bool result = VecInsertRangeFastR(&vec, new_items, idx, new_count);
result = result && (VecLen(&vec) == orig_count + new_count);
for (size i = 0; i < idx; i++) {- In
Insert.c:603:
// [idx + new_count, new length). Order is intentionally unspecified.
size tail_start = idx + new_count;
size tail_end = VecLen(&vec);
result = result && (tail_end - tail_start == orig_count - idx);
for (size i = idx; i < orig_count; i++) {- In
Insert.c:718:
bool ok = VecInsertRangeFastR(&vec, src, 0, (size)-1);
bool result = (ok == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Insert.c:741:
int add[8] = {100, 101, 102, 103, 104, 105, 106, 107};
bool ok = VecInsertRangeFastR(&vec, add, VecLen(&vec), 8);
// Capacity contract: holding 16 live elements requires the grow to have
- In
Insert.c:746:
// run, so capacity must have expanded past the old value of 8. The mutant
// skips the grow and leaves capacity == 8.
bool result = ok && (VecLen(&vec) == 16) && (VecCapacity(&vec) >= 16);
for (int i = 0; i < 8; i++) {
result = result && (VecAt(&vec, (size)i) == i);- In
Insert.c:754:
for (int v = 100; v < 108; v++) {
bool found = false;
for (size j = 8; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == v) {
found = true;- In
Insert.c:789:
// length 5 + count 5 == capacity 10: the equality boundary.
int add[5] = {100, 101, 102, 103, 104};
bool ok = VecInsertRangeFastR(&vec, add, VecLen(&vec), 5);
// Real code reserves past the old capacity (10 -> 16). The `>` mutant skips
- In
Insert.c:793:
// Real code reserves past the old capacity (10 -> 16). The `>` mutant skips
// the grow and leaves capacity at 10.
bool result = ok && (VecLen(&vec) == 10) && (VecCapacity(&vec) > 10);
for (int i = 0; i < 5; i++) {
result = result && (VecAt(&vec, (size)i) == i);- In
Insert.c:816:
// Holding 8 elements requires growth from capacity 0; the mutant's
// inverted predicate skips it.
bool result = ok && (VecLen(&vec) == 8) && (VecCapacity(&vec) >= 8);
for (size i = 0; i < 8; i++) {
result = result && (VecAt(&vec, i) == add[i]);- In
Insert.c:841:
// replacement makes the call return false. Either way the real growth
// contract (true return, all 10 elements, capacity >= 10) breaks.
bool result = ok && (VecLen(&vec) == 10) && (VecCapacity(&vec) >= 10);
for (size i = 0; i < 10; i++) {
result = result && (VecAt(&vec, i) == add[i]);- In
Insert.c:874:
bool ok = VecInsertRangeFastR(&vec, add, 1, 2);
bool result = ok && (VecLen(&vec) == 6);
// Prefix [0,1) intact, inserted block at [1,3).
result = result && (VecAt(&vec, 0).value == 10);- In
Insert.c:882:
for (int v = 11; v <= 12; v++) {
bool found = false;
for (size j = 3; j < VecLen(&vec); j++) {
if (VecAt(&vec, j).value == v) {
found = true;- In
Insert.c:892:
// Trailing original 13 (never displaced) also survives.
bool found13 = false;
for (size j = 3; j < VecLen(&vec); j++) {
if (VecAt(&vec, j).value == 13) {
found13 = true;- In
Insert.c:937:
bool ok = VecInsertRangeFastR(&vec, VecBegin(&ins), 0, N);
bool result = ok && (VecLen(&vec) == 2 * N);
// The new block occupies the front [0, N).
result = result && (VecAt(&vec, 0).value == 1000000);- In
Insert.c:966:
bool ok = VecInsertRangeFastR(&vec, add, 2, 2);
bool result = ok && (VecLen(&vec) == 6);
// Prefix [0,2) must be the original 10,11.
result = result && (VecAt(&vec, 0).value == 10);- In
Insert.c:996:
bool ok = VecInsertRangeFastR(&vec, add, 2, 2);
bool result = ok && (VecLen(&vec) == 6);
result = result && (VecAt(&vec, 2).value == 100);
result = result && (VecAt(&vec, 3).value == 200);- In
Insert.c:1027:
bool ok = VecInsertRangeFastR(&vec, add, 1, 3);
bool result = ok && (VecLen(&vec) == 5);
result = result && (VecAt(&vec, 1).value == 100);
result = result && (VecAt(&vec, 2).value == 200);- In
Insert.c:1055:
bool ok = VecInsertRangeFastR(&vec, add, 2, 3);
bool result = (ok == false) && (g_deinit_count == 0) && (VecLen(&vec) == 4);
// Originals fully intact after rollback.
result = result && (VecAt(&vec, 0).value == 10);- In
Insert.c:1253:
bool ok = VecInsertRangeFastR(&vec, add, 1, 2);
bool result = (ok == false) && (VecLen(&vec) == 5);
// Original elements must all be present and unchanged after rollback.
for (size i = 0; i < 5; i++) {- In
Insert.c:1282:
bool ok = VecInsertRangeFastR(&vec, add, 1, 2);
bool result = (ok == false) && (VecLen(&vec) == 5);
for (size i = 0; i < 5; i++) {
result = result && (VecAt(&vec, i).value == 20 + (int)i);- In
Insert.c:1314:
bool ok = VecInsertRangeFastR(&vec, add, 1, 3);
bool result = (ok == false) && (VecLen(&vec) == 6);
for (size i = 0; i < 6; i++) {
result = result && (VecAt(&vec, i).value == 30 + (int)i);- In
Insert.c:1407:
for (size i = 0; i < n; i++) {
TrackItem it = {tags[i], NULL};
VecInsertRangeR(&v, &it, VecLen(&v), 1);
}
return v;- In
Insert.c:1421:
bool ret = VecInsertRangeR(&vec, &one, 0, (size)-1);
bool result = (ret == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Insert.c:1439:
bool ret = VecInsertRangeR(&vec, &newv, 0, 1);
bool result = ret && (VecLen(&vec) == 4) && (VecAt(&vec, 0) == 99) && (VecAt(&vec, 1) == 10) &&
(VecAt(&vec, 2) == 20) && (VecAt(&vec, 3) == 30);- In
Insert.c:1459:
// The original at index 0 (11) must survive at index 1 after the insert.
bool result = ret && (VecLen(&vec) == 4) && (VecAt(&vec, 0) == 77) && (VecAt(&vec, 1) == 11);
VecDeinit(&vec);- In
Insert.c:1476:
for (size i = 0; i < N; i++) {
u64 v = (u64)i;
VecInsertRangeR(&vec, &v, VecLen(&vec), 1);
}- In
Insert.c:1482:
bool ret = VecInsertRangeR(&vec, &newv, N - 1, 1); // insert just before the last element
bool result = ret && (VecLen(&vec) == N + 1) && (VecAt(&vec, 0) == 0) && (VecAt(&vec, N - 2) == (u64)(N - 2)) &&
(VecAt(&vec, N - 1) == 999999) && (VecAt(&vec, N) == (u64)(N - 1));- In
Insert.c:1503:
bool ret = VecInsertRangeR(&vec, &it, 0, 1);
bool result = (ret == false) && (ti_deinit_count == 0) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1524:
{102, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 3);
bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);- In
Insert.c:1526:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 3);
bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1546:
{101, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);- In
Insert.c:1548:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1568:
{101, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (g_deinit_saw_zero == false) && (VecLen(&vec) == 3);- In
Insert.c:1570:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (g_deinit_saw_zero == false) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1591:
{102, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 3);
bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);- In
Insert.c:1593:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 3);
bool result = (ret == false) && (ti_deinit_count == 2) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1617:
bool result = (ret == false) && (ti_deinit_count == 2) && deinit_tags_contain(100) && deinit_tags_contain(101) &&
!deinit_tags_contain(1) && (VecLen(&vec) == 1) && (VecAt(&vec, 0).tag == 1);
VecDeinit(&vec);- In
Insert.c:1637:
{101, NULL}
};
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);- In
Insert.c:1639:
bool ret = VecInsertRangeR(&vec, items, VecLen(&vec), 2);
bool result = (ret == false) && (ti_deinit_count == 1) && (VecLen(&vec) == 3);
VecDeinit(&vec);- In
Insert.c:1658:
bool ret = VecInsertRangeR(&vec, &it, 1, 1);
bool result = (ret == false) && (VecLen(&vec) == 3) && (VecAt(&vec, 0).tag == 1) && (VecAt(&vec, 1).tag == 2) &&
(VecAt(&vec, 2).tag == 3);- In
Insert.c:1677:
bool ret = VecInsertRangeR(&vec, &it, 1, 1);
bool result = (ret == false) && (VecLen(&vec) == 3) && (VecAt(&vec, 0).tag == 1) && (VecAt(&vec, 1).tag == 2) &&
(VecAt(&vec, 2).tag == 3);- In
Insert.c:1696:
for (size i = 0; i < N; i++) {
TrackItem it = {(int)(i + 1), NULL};
VecInsertRangeR(&vec, &it, VecLen(&vec), 1);
}- In
Insert.c:1704:
bool ret = VecInsertRangeR(&vec, &it, N - 1, 1);
bool result = (ret == false) && (VecLen(&vec) == N) && (VecAt(&vec, 0).tag == 1) &&
(VecAt(&vec, N - 2).tag == (int)(N - 1)) && (VecAt(&vec, N - 1).tag == (int)N);- In
Insert.c:1724:
bool ret = VecInsertRangeR(&vec, &it, 1, 1);
bool result = (ret == false) && (VecLen(&vec) == 3) && (VecAt(&vec, 0).tag == 1) && (VecAt(&vec, 1).tag == 2) &&
(VecAt(&vec, 2).tag == 3);- In
Insert.c:1748:
bool result =
ok && (VecLen(&vec) == 3) && (VecAt(&vec, 0) == 111u) && (VecAt(&vec, 1) == 222u) && (VecAt(&vec, 2) == 333u);
VecDeinit(&vec);- In
Insert.c:1770:
// check is valid here.
bool result =
ok && (VecLen(&vec) == 3) && (VecAt(&vec, 0) == 444u) && (VecAt(&vec, 1) == 555u) && (VecAt(&vec, 2) == 666u);
VecDeinit(&vec);- In
Insert.c:1789:
bool ok = VecInsertL(&vec, val, 0);
bool result = ok && (VecLen(&vec) == 1) && (VecAt(&vec, 0) == 777u);
VecDeinit(&vec);- In
Insert.c:1851:
// Real: the insert fails, ok == false, nothing landed in the vec.
bool result = (ok == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Insert.c:1880:
// Real: the insert fails, ok == false, nothing landed in the vec.
bool result = (ok == false) && (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Insert.c:1911:
}
size length_before = VecLen(&vec); // 4
// Middle insert at idx 1 of 2 elements; fail on the very first copy_init of
- In
Insert.c:1920:
bool ok = VecInsertRangeR(&vec, add, 1, 2);
bool result = (ok == false) && (VecLen(&vec) == length_before);
// Originals fully intact after rollback.
- In
Insert.c:1956:
}
size length_before = VecLen(&vec); // 4
// Front insert at idx 0 of 2 elements -> displaced = min(length-idx,count)
- In
Insert.c:1965:
bool ok = VecInsertRangeFastR(&vec, add, 0, 2);
bool result = (ok == false) && (VecLen(&vec) == length_before);
// Originals must all still be present (order may differ for the fast path,
- In
Insert.c:1970:
// but a front-insert with displaced==count restores them in place).
bool found100 = false, found101 = false, found102 = false, found103 = false;
for (size i = 0; i < VecLen(&vec); i++) {
u64 v = (u64)VecAt(&vec, i).value;
found100 = found100 || (v == 100);- In
Type.c:31:
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL && VecAllocator(&vec)->alignment == 1 &&
VecCopyInit(&vec) == NULL && VecCopyDeinit(&vec) == NULL);- In
Type.c:42:
// Check initial state
result = result && (VecLen(&test_vec) == 0 && VecCapacity(&test_vec) == 0 && VecBegin(&test_vec) == NULL &&
VecAllocator(&test_vec)->alignment == 1 && VecCopyInit(&test_vec) == NULL &&
VecCopyDeinit(&test_vec) == NULL);- In
Remove.c:132:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Pop from the back
- In
Remove.c:142:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements
- In
Remove.c:145:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Remove.c:156:
// Check new length
result = result && (VecLen(&vec) == 3);
// Clean up
- In
Remove.c:180:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Pop from the front
- In
Remove.c:190:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements
- In
Remove.c:193:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i + 1]);
}- In
Remove.c:204:
// Check new length
result = result && (VecLen(&vec) == 3);
// Clean up
- In
Remove.c:228:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Delete element at index 2 (value 30)
- In
Remove.c:234:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 40, 50])
- In
Remove.c:238:
// Check remaining elements (should be [10, 20, 40, 50])
int expected1[] = {10, 20, 40, 50};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected1[i]);
}- In
Remove.c:246:
// Check new length
result = result && (VecLen(&vec) == 3);
// Check remaining elements (should be [20, 40, 50])
- In
Remove.c:250:
// Check remaining elements (should be [20, 40, 50])
int expected2[] = {20, 40, 50};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected2[i]);
}- In
Remove.c:276:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Delete element at index 1 (value 20) using fast delete
- In
Remove.c:282:
// Check new length
result = result && (VecLen(&vec) == 4);
// With fast delete, the last element is moved to the deleted position
- In
Remove.c:287:
// So the vector should now be [10, 50, 30, 40]
int expected[] = {10, 50, 30, 40};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:313:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Delete range from index 2 to 4 (values 30, 40, 50)
- In
Remove.c:319:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 60, 70])
- In
Remove.c:323:
// Check remaining elements (should be [10, 20, 60, 70])
int expected[] = {10, 20, 60, 70};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:348:
// Initial length should be 10
bool result = (VecLen(&vec) == 10);
// Print before state
- In
Remove.c:352:
// Print before state
WriteFmt("Before fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:364:
int end_values[3];
for (int i = 0; i < count; i++) {
end_values[i] = VecAt(&vec, VecLen(&vec) - count + i);
}- In
Remove.c:371:
// Print after state
WriteFmt("After fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:377:
// Check length after deletion
result = result && (VecLen(&vec) == 7);
// Check that the last 3 elements moved to the deleted positions
- In
Remove.c:386:
// Verify all values that should still be present
bool values_found[10] = {false};
for (u64 i = 0; i < VecLen(&vec); i++) {
int val = VecAt(&vec, i);
int index = val / 10;- In
Remove.c:425:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Delete the last element
- In
Remove.c:431:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements
- In
Remove.c:434:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Remove.c:442:
// Check new length
result = result && (VecLen(&vec) == 3);
// Check remaining elements
- In
Remove.c:445:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Remove.c:470:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Test L-value delete operation
- In
Remove.c:477:
// Check vector after L-value deletion
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 40, 50])
- In
Remove.c:481:
// Check remaining elements (should be [10, 20, 40, 50])
int expected[] = {10, 20, 40, 50};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:506:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Test R-value delete operation
- In
Remove.c:512:
// Check vector after deletion
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 40, 50])
- In
Remove.c:516:
// Check remaining elements (should be [10, 20, 40, 50])
int expected[] = {10, 20, 40, 50};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:541:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Print before state
- In
Remove.c:545:
// Print before state
WriteFmt("Before L-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:553:
int fast_index = 2; // Delete 30
int valueToBeDeleted = VecAt(&vec, fast_index);
int lastValue = VecAt(&vec, VecLen(&vec) - 1); // Should move to deleted position
VecDeleteFast(&vec, fast_index);- In
Remove.c:558:
// Print after state
WriteFmt("After L-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:564:
// Check vector after L-value fast deletion
result = result && (VecLen(&vec) == 4);
// Verify the deleted value is no longer present
- In
Remove.c:568:
// Verify the deleted value is no longer present
bool containsValue = false;
for (u64 i = 0; i < VecLen(&vec); i++) {
if (VecAt(&vec, i) == valueToBeDeleted) {
containsValue = true;- In
Remove.c:589:
for (int i = 0; i < 3; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == expected_values[i]) {
found = true;- In
Remove.c:622:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Print before state
- In
Remove.c:626:
// Print before state
WriteFmt("Before R-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:633:
// Remember the value to be deleted and the last value
int valueToBeDeleted = VecAt(&vec, 2); // 30
int lastValue = VecAt(&vec, VecLen(&vec) - 1); // Should move to deleted position
// Test R-value fast delete operation
- In
Remove.c:640:
// Print after state
WriteFmt("After R-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:646:
// Check length
result = result && (VecLen(&vec) == 4);
// Verify the deleted value is no longer present
- In
Remove.c:650:
// Verify the deleted value is no longer present
bool containsValue = false;
for (u64 i = 0; i < VecLen(&vec); i++) {
if (VecAt(&vec, i) == valueToBeDeleted) {
containsValue = true;- In
Remove.c:666:
for (int i = 0; i < 3; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == expected_values[i]) {
found = true;- In
Remove.c:699:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Test L-value delete range operation
- In
Remove.c:707:
// Check vector after L-value range deletion
result = result && (VecLen(&vec) == 4);
// Expected result: [10, 20, 60, 70]
- In
Remove.c:711:
// Expected result: [10, 20, 60, 70]
int expected[] = {10, 20, 60, 70};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:736:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Test R-value delete range operation
- In
Remove.c:742:
// Check vector after R-value range deletion
result = result && (VecLen(&vec) == 4);
// Expected result: [10, 20, 60, 70]
- In
Remove.c:746:
// Expected result: [10, 20, 60, 70]
int expected[] = {10, 20, 60, 70};
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Remove.c:771:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Print before state
- In
Remove.c:775:
// Print before state
WriteFmt("Before L-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:790:
// Print after state
WriteFmt("After L-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:796:
// Check vector after L-value fast range deletion
result = result && (VecLen(&vec) == 4);
// Verify the deleted values are no longer present
- In
Remove.c:801:
for (int i = 0; i < 3; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == valuesToDelete[i]) {
found = true;- In
Remove.c:817:
for (int i = 0; i < 4; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == remainingValues[i]) {
found = true;- In
Remove.c:850:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Print before state
- In
Remove.c:854:
// Print before state
WriteFmt("Before R-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:867:
// Print after state
WriteFmt("After R-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Remove.c:873:
// Check vector after R-value fast range deletion
result = result && (VecLen(&vec) == 4);
// Verify the deleted values are no longer present
- In
Remove.c:878:
for (int i = 0; i < 3; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == valuesToDelete[i]) {
found = true;- In
Remove.c:894:
for (int i = 0; i < 4; i++) {
bool found = false;
for (u64 j = 0; j < VecLen(&vec); j++) {
if (VecAt(&vec, j) == remainingValues[i]) {
found = true;- In
Remove.c:932:
VecDeleteRangeFast(&vec, 0, 3);
bool result = (VecLen(&vec) == 0);
VecDeinit(&vec);- In
Remove.c:1114:
// Length is now 3; the raw slot at index 4 was part of the vacated tail
// and must read back zero.
bool result = (VecLen(&vec) == 3) && (*VecPtrAt(&vec, 4) == 0);
VecDeinit(&vec);- In
Remove.c:1135:
VecDeleteRangeFast(&vec, 0, 2);
bool result = (VecLen(&vec) == 3) && (*VecPtrAt(&vec, 4) == 0);
VecDeinit(&vec);- In
Remove.c:1160:
VecDeleteRangeFast(&vec, 0, K);
bool result = (VecLen(&vec) == (u64)N - K);
VecDeinit(&vec);- In
Remove.c:1265:
VecDeleteRange(&vec, 20000, 2);
bool result = (VecLen(&vec) == (u64)(N - 2)) && (VecAt(&vec, 0) == 0) && (VecAt(&vec, 19999) == 19999) &&
(VecAt(&vec, 20000) == 20002);- In
Remove.c:1289:
VecDeleteRange(&vec, 0, K);
bool result = (VecLen(&vec) == (u64)N - K) && (VecAt(&vec, 0) == (int)K) && (VecAt(&vec, 19999) == (int)(N - 1));
VecDeinit(&vec);- In
Remove.c:1309:
VecDeleteRange(&vec, 1, 2); // real move ~ (N-3)*4 bytes; mutant ~ (N-3)*42 (~1.5 MB)
bool result = (VecLen(&vec) == (u64)(N - 2)) && (VecAt(&vec, 0) == 0) && (VecAt(&vec, 1) == 3) &&
(VecAt(&vec, (u64)(N - 3)) == (int)(N - 1));- In
Remove.c:1329:
// Dead slot 9 (previously a duplicate of 9) must be zeroed.
bool result = (VecLen(&vec) == 8 && *VecPtrAt(&vec, 9) == 0);
VecDeinit(&vec);- In
Remove.c:1348:
// Dead slot 9 must be zeroed, not left as a stale duplicate.
bool result = (VecLen(&vec) == 8 && *VecPtrAt(&vec, 9) == 0);
VecDeinit(&vec);- In
Remove.c:1372:
VecDeleteRange(&vec, 0, K); // length becomes N-K
bool result = (VecLen(&vec) == (u64)N - K) && (VecAt(&vec, 0) == (int)K);
VecDeinit(&vec);- In
Remove.c:1411:
VecTryReduceSpace(&vec); // capacity := length, buffer := length + 1
size old_len = VecLen(&vec);
// Remove the final element. Real move size = length - (length-1) - 1 = 0.
- In
Remove.c:1417:
VecDeleteRange(&vec, old_len - 1, 1);
bool result = (VecLen(&vec) == old_len - 1);
// Surviving prefix is intact (the real path moved nothing).
result = result && (VecAt(&vec, 0) == 1);- In
Remove.c:1447:
VecTryReduceSpace(&vec); // capacity := length, buffer := length + 1
size old_len = VecLen(&vec);
// Remove all but the last element from the front. Real move size =
- In
Remove.c:1454:
VecDeleteRange(&vec, 0, old_len - 1);
bool result = (VecLen(&vec) == 1);
// The single survivor is the original last element.
result = result && (VecAt(&vec, 0) == (u64)old_len);- In
Foreach.c:59:
// Check that the values in the vector are unchanged (foreach uses value, not reference)
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Foreach.c:126:
// Check that the values in the vector are doubled
bool result = true;
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i] * 2);
}- In
Foreach.c:167:
// Check that the values in the vector are set to their indices
bool result = true;
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == i);
}- In
Foreach.c:261:
int expected[] = {15, 24, 33, 42, 51};
bool result = true;
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Foreach.c:296:
int expected[] = {100, 101, 102, 103, 104};
bool result = true;
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Foreach.c:321:
int iteration_count = 0;
VecForeach(&vec, val) {
WriteFmt("Iteration {} (vec.length={}): {}\n", iteration_count, VecLen(&vec), val);
// After 2nd iteration, shrink the vector dramatically
- In
Foreach.c:326:
if (iteration_count == 2) {
VecResize(&vec, 2); // Shrink to only 2 elements
WriteFmt("Vector resized to length {} during foreach iteration...\n", VecLen(&vec));
}- In
Foreach.c:360:
// VecForeachIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachIdx(&vec, val, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), val);
// When we reach idx=2, drastically shrink the vector to make the current idx invalid
- In
Foreach.c:366:
if (idx == 2) {
VecResize(&vec, 2); // Shrink so that idx=2 becomes out of bounds (valid indices: 0,1)
WriteFmt("Vector resized to length {}, current idx={} is now out of bounds...\n", VecLen(&vec), idx);
}- In
Foreach.c:398:
// VecForeachReverseIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachReverseIdx(&vec, val, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), val);
// When we reach idx=4, drastically shrink the vector
- In
Foreach.c:405:
if (idx == 4) {
VecResize(&vec, 2); // Shrink to only 2 elements
WriteFmt("Vector resized to length {} during reverse iteration...\n", VecLen(&vec));
}- In
Foreach.c:437:
// VecForeachPtrIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachPtrIdx(&vec, val_ptr, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);
// When we reach idx=3, shrink the vector to make the CURRENT idx invalid
- In
Foreach.c:443:
if (idx == 3) {
VecResize(&vec, 3); // Shrink so that idx=3 becomes out of bounds (valid indices: 0,1,2)
WriteFmt("Vector resized to length {}, current idx={} is now out of bounds...\n", VecLen(&vec), idx);
}- In
Foreach.c:475:
// VecForeachPtrReverseIdx has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachPtrReverseIdx(&vec, val_ptr, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);
// When we reach idx=5, shrink the vector significantly
- In
Foreach.c:480:
if (idx == 5) {
VecResize(&vec, 3); // Shrink to only 3 elements
WriteFmt("Vector resized to length {} during reverse ptr iteration...\n", VecLen(&vec));
}- In
Foreach.c:511:
// Use VecForeachPtrInRangeIdx with a fixed range that becomes invalid when we modify the vector
size original_length = VecLen(&vec); // Capture this as 9
VecForeachPtrInRangeIdx(&vec, val_ptr, idx, 0, original_length) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);- In
Foreach.c:513:
size original_length = VecLen(&vec); // Capture this as 9
VecForeachPtrInRangeIdx(&vec, val_ptr, idx, 0, original_length) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), *val_ptr);
// When we reach idx=3, delete several elements
- In
Foreach.c:518:
if (idx == 3) {
VecDeleteRange(&vec, 0, 6); // Remove first 6 elements
WriteFmt("Deleted first 6 elements, new length={}, idx = {}\n", VecLen(&vec), original_length, idx);
}- In
Foreach.c:524:
// loop will automatically terminate
if (idx > VecLen(&vec)) {
LOG_ERROR("Should've terminated");
VecDeinit(&vec);- In
Foreach.c:550:
// Basic VecForeachIdx now has explicit bounds checking: if ((idx) >= (v)->length) LOG_FATAL(...)
VecForeachIdx(&vec, val, idx) {
WriteFmt("Accessing idx {} (vec.length={}): {}\n", idx, VecLen(&vec), val);
// When we reach idx=2, drastically shrink the vector
- In
Foreach.c:556:
if (idx == 2) {
VecResize(&vec, 1); // Shrink to only 1 element
WriteFmt("Vector resized to length {}, current index={}\n", VecLen(&vec), idx);
}- In
Access.c:172:
// Test VecSize and VecLen functions
bool test_vec_size_len(void) {
WriteFmt("Testing VecSize and VecLen\n");
DefaultAllocator alloc = DefaultAllocatorInit();- In
Access.c:183:
// Check initial size and length
size vec_size = VecSize(&vec);
size vec_len = VecLen(&vec);
bool result = (vec_size == 0);
result = result && (vec_len == 0);- In
Access.c:194:
// Check size and length after adding elements
vec_size = VecSize(&vec);
vec_len = VecLen(&vec);
size aligned_offset = VecAlignedOffsetAt(&vec, VecLen(&vec));
result = result && (vec_size == aligned_offset);- In
Access.c:195:
vec_size = VecSize(&vec);
vec_len = VecLen(&vec);
size aligned_offset = VecAlignedOffsetAt(&vec, VecLen(&vec));
result = result && (vec_size == aligned_offset);
result = result && (vec_len == VecLen(&vec));- In
Access.c:197:
size aligned_offset = VecAlignedOffsetAt(&vec, VecLen(&vec));
result = result && (vec_size == aligned_offset);
result = result && (vec_len == VecLen(&vec));
// Clean up
- In
Access.c:213:
// Check size and length
size aligned_vec_size = VecSize(&aligned_vec);
size aligned_vec_len = VecLen(&aligned_vec);
size aligned_offset_at = VecAlignedOffsetAt(&aligned_vec, VecLen(&aligned_vec));
result = result && (aligned_vec_size == aligned_offset_at);- In
Access.c:214:
size aligned_vec_size = VecSize(&aligned_vec);
size aligned_vec_len = VecLen(&aligned_vec);
size aligned_offset_at = VecAlignedOffsetAt(&aligned_vec, VecLen(&aligned_vec));
result = result && (aligned_vec_size == aligned_offset_at);
result = result && (aligned_vec_len == VecLen(&aligned_vec));- In
Access.c:216:
size aligned_offset_at = VecAlignedOffsetAt(&aligned_vec, VecLen(&aligned_vec));
result = result && (aligned_vec_size == aligned_offset_at);
result = result && (aligned_vec_len == VecLen(&aligned_vec));
// Clean up
- In
Access.c:312:
// Store and load both use stride `sizeof(u32)`, so values match.
bool result = (VecLen(&vec) == 4);
for (int i = 0; i < 4; i++) {
result = result && (VecAt(&vec, i) == values[i]);- In
Access.c:343:
// Real: dst == {10,20,30,40}. Mutant (constant offset): every source read
// hits the same element, e.g. dst == {10,10,10,10}.
bool result = (VecLen(&dst) == 4) && (VecAt(&dst, 0) == 10) && (VecAt(&dst, 1) == 20) && (VecAt(&dst, 2) == 30) &&
(VecAt(&dst, 3) == 40); BitVecRuns runs = VecInitT(runs, base);
bool result = BitVecRunLengths(&bv, &runs);
result = result && VecLen(&runs) == 5;
if (result) {
result = result && VecPtrAt(&runs, 0)->length == 3 && VecPtrAt(&runs, 0)->value == true; BitVecMatchIndices matches = VecInitT(matches, base);
result = result && BitVecFindAllPattern(&source, &pattern, &matches);
result = result && VecLen(&matches) == 5;
if (result) {
result = result && VecAt(&matches, 0) == 0; result = result && BitVecFindAllPattern(&source, &pattern, &matches);
// Exact-length match: exactly one hit, at index 0.
result = result && (VecLen(&matches) == 1);
if (result) {
result = result && (VecAt(&matches, 0) == 0);- In
Arena.c:84:
}
ok = ok && VecLen(&v) == 4096 && VecAt(&v, 0) == 0 && VecAt(&v, 4095) == 4095;
VecDeinit(&v);
ArenaAllocatorDeinit(&arena);- In
Page.c:81:
}
ok = ok && (VecLen(&v) == 1024) && (VecAt(&v, 0) == 0) && (VecAt(&v, 1023) == 1023);
VecDeinit(&v);
PageAllocatorDeinit(&alloc);- In
Ops.c:211:
Strs split = StrSplit(&s, ",");
bool result = (VecLen(&split) == 3);
if (VecLen(&split) >= 3) {
result = result && (ZstrCompare(StrBegin(VecPtrAt(&split, 0)), "Hello") == 0);- In
Ops.c:212:
bool result = (VecLen(&split) == 3);
if (VecLen(&split) >= 3) {
result = result && (ZstrCompare(StrBegin(VecPtrAt(&split, 0)), "Hello") == 0);
result = result && (ZstrCompare(StrBegin(VecPtrAt(&split, 1)), "World") == 0);- In
Ops.c:222:
// Test StrSplitToIters
StrIters iters = StrSplitToIters(&s, ",");
result = result && (VecLen(&iters) == 3);
if (VecLen(&iters) >= 3) {- In
Ops.c:224:
result = result && (VecLen(&iters) == 3);
if (VecLen(&iters) >= 3) {
// .length goes through StrIterLength; .data has no accessor
// (the base-pointer of an Iter range is the Iter contract --
- In
Ops.c:488:
StrIters iters = StrSplitToIters(&s, ",");
bool result = (VecLen(&iters) == 3);
if (VecLen(&iters) == 3) {
result = result && (StrIterLength(VecPtrAt(&iters, 0)) == 1);- In
Ops.c:489:
bool result = (VecLen(&iters) == 3);
if (VecLen(&iters) == 3) {
result = result && (StrIterLength(VecPtrAt(&iters, 0)) == 1);
result = result && (StrIterLength(VecPtrAt(&iters, 1)) == 1);- In
Ops.c:515:
Strs split = StrSplit(&s, "abc");
bool result = (VecLen(&split) == 0);
if (!result) {
WriteFmt(" FAIL: Expected 0 split elements, got {}\n", (u64)VecLen(&split));- In
Ops.c:517:
bool result = (VecLen(&split) == 0);
if (!result) {
WriteFmt(" FAIL: Expected 0 split elements, got {}\n", (u64)VecLen(&split));
}- In
Ops.c:538:
Strs split = StrSplit(&s, "abc");
bool result = (VecLen(&split) == 0);
if (!result) {
WriteFmt(" FAIL: Expected 0 split elements, got {}\n", (u64)VecLen(&split));- In
Ops.c:540:
bool result = (VecLen(&split) == 0);
if (!result) {
WriteFmt(" FAIL: Expected 0 split elements, got {}\n", (u64)VecLen(&split));
}- In
Init.c:290:
// Sanity: the split really produced multiple heap-backed elements,
// otherwise the leak would be unobservable.
bool produced = VecLen(&parts) == 4 && DebugAllocatorLiveCount(&dbg) > before;
VecDeinit(&parts); // invokes str_deinit per element on real code.
- In
Type.c:60:
// Check that it behaves like a Vec of Str objects
bool result = (VecLen(&sv) == 2);
// Check the content of the strings
- In
Backtrace.c:75:
StackFrames frames = VecInitT(frames, alloc_base);
bool ok = bt_vec_capture_outer(&frames);
ok = ok && VecLen(&frames) >= 2;
Str rendered = StrInit(alloc_base);- In
SysDns.c:131:
// Compare nameserver `i` formatted as "ip:port" against `expect`.
static bool ns_fmt_is(DnsResolver *r, u64 i, Allocator *a, Zstr expect) {
if (VecLen(&r->nameservers) <= i) {
return false;
}- In
SysDns.c:220:
bool got = DnsResolve(&r, "203.0.113.7:9999", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && VecPtrAt(&out, 0)->family == SOCKET_FAMILY_INET;
if (ok) {
Str s = SocketAddrFormat(VecPtrAt(&out, 0), a);- In
SysDns.c:244:
bool got = DnsResolve(&r, "[::1]:443", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && VecPtrAt(&out, 0)->family == SOCKET_FAMILY_INET6;
if (ok) {
Str s = SocketAddrFormat(VecPtrAt(&out, 0), a);- In
SysDns.c:268:
bool got = DnsResolve(&r, "localhost:53", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) > 0;
if (ok) {
VecForeachPtr(&out, ad) {- In
SysDns.c:320:
bool got = DnsResolve(&r, "localhost", SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:362:
const HostsEntry *e = find_host(&r.hosts, "localhost");
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(e, 127, 0, 0, 1) && ZstrCompare(StrBegin(&e->name), "localhost") == 0;
drop_temp(&path);- In
SysDns.c:380:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 4 && host_v4_is(find_host(&r.hosts, "host.example"), 192, 168, 1, 5) &&
host_v4_is(find_host(&r.hosts, "alias1"), 192, 168, 1, 5) &&
host_v4_is(find_host(&r.hosts, "alias2"), 192, 168, 1, 5) &&- In
SysDns.c:408:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "a"), 10, 0, 0, 1) &&
find_host(&r.hosts, "commented.host") == (const HostsEntry *)0;- In
SysDns.c:427:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "namex"), 10, 0, 0, 2) &&
find_host(&r.hosts, "trailing") == (const HostsEntry *)0 &&
find_host(&r.hosts, "#") == (const HostsEntry *)0;- In
SysDns.c:448:
const HostsEntry *e = find_host(&r.hosts, "namex");
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(e, 10, 0, 0, 2) && ZstrCompare(StrBegin(&e->name), "namex") == 0;
drop_temp(&path);- In
SysDns.c:466:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 2 && host_v4_is(find_host(&r.hosts, "hostt"), 172, 16, 0, 9) &&
host_v4_is(find_host(&r.hosts, "alt"), 172, 16, 0, 9);- In
SysDns.c:486:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "mixedcasehost"), 10, 1, 1, 1) &&
find_host(&r.hosts, "MixedCaseHost") == (const HostsEntry *)0;- In
SysDns.c:508:
const HostsEntry *e = find_host(&r.hosts, "@az[`m");
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(e, 10, 1, 1, 2) && ZstrCompare(StrBegin(&e->name), "@az[`m") == 0;
drop_temp(&path);- In
SysDns.c:527:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 2 && host_v4_is(find_host(&r.hosts, "a"), 10, 0, 0, 1) &&
host_v4_is(find_host(&r.hosts, "dns"), 8, 8, 8, 8);- In
SysDns.c:548:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "a"), 10, 0, 0, 1);
drop_temp(&path);- In
SysDns.c:572:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 3 && host_v4_is(find_host(&r.hosts, "one"), 1, 1, 1, 1) &&
host_v4_is(find_host(&r.hosts, "two"), 2, 2, 2, 2) &&
host_v4_is(find_host(&r.hosts, "three"), 3, 3, 3, 3);- In
SysDns.c:593:
const HostsEntry *e = find_host(&r.hosts, "ip6-localhost");
bool ok = VecLen(&r.hosts) == 1 && e && e->is_ipv6;
if (ok) {
for (int i = 0; i < 15; ++i) {- In
SysDns.c:625:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "realname"), 10, 0, 0, 7) &&
find_host(&r.hosts, "somename") == (const HostsEntry *)0;- In
SysDns.c:648:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "named"), 10, 0, 0, 9);
drop_temp(&path);- In
SysDns.c:679:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "goodname"), 10, 0, 0, 4) &&
find_host(&r.hosts, "spuriousname") == (const HostsEntry *)0;- In
SysDns.c:703:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "realone"), 10, 0, 0, 6) &&
find_host(&r.hosts, "x") == (const HostsEntry *)0;- In
SysDns.c:721:
DnsResolverAddHostsPath(&r, "sysdns_definitely_missing_zzqq", 30);
bool ok = VecLen(&r.hosts) == 0;
DnsResolverDeinit(&r);- In
SysDns.c:747:
DnsResolverAddHostsPath(&r, &path);
bool ok = VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "farhost"), 10, 20, 30, 40);
drop_temp(&path);- In
SysDns.c:778:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 2 && ns_fmt_is(&r, 0, a, "8.8.8.8:53") && ns_fmt_is(&r, 1, a, "1.1.1.1:53");
drop_temp(&path);- In
SysDns.c:796:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 1 && VecPtrAt(&r.nameservers, 0)->family == SOCKET_FAMILY_INET6 &&
ns_fmt_is(&r, 0, a, "[::1]:53");- In
SysDns.c:815:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 0;
drop_temp(&path);- In
SysDns.c:833:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 0;
drop_temp(&path);- In
SysDns.c:851:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 0;
drop_temp(&path);- In
SysDns.c:869:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 0;
drop_temp(&path);- In
SysDns.c:887:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "8.8.4.4:53");
drop_temp(&path);- In
SysDns.c:905:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "8.8.8.8:53");
drop_temp(&path);- In
SysDns.c:923:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 0;
drop_temp(&path);- In
SysDns.c:941:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "8.8.8.8:53");
drop_temp(&path);- In
SysDns.c:959:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 0;
drop_temp(&path);- In
SysDns.c:982:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 3 && ns_fmt_is(&r, 0, a, "10.0.0.1:53") && ns_fmt_is(&r, 1, a, "10.0.0.2:53") &&
ns_fmt_is(&r, 2, a, "10.0.0.3:53");- In
SysDns.c:1001:
DnsResolverAddResolvPath(&r, &path);
bool ok = VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "8.8.8.8:53");
drop_temp(&path);- In
SysDns.c:1027:
bool got = dns_resolve_5_zstr(&r, "A@Z", 80, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "10.0.0.1:80");
VecDeinit(&out);- In
SysDns.c:1047:
bool got = dns_resolve_5_zstr(&r, "HOST...", 80, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "10.0.0.2:80");
VecDeinit(&out);- In
SysDns.c:1067:
bool got = dns_resolve_5_zstr(&r, "A.B.C.", 80, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "10.0.0.3:80");
VecDeinit(&out);- In
SysDns.c:1087:
bool got = dns_resolve_5_zstr(&r, "...", 80, SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1115:
bool got = dns_resolve_5_zstr(&r, "myhost", 0x1234, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1;
if (ok) {
const SocketAddr *ad = VecPtrAt(&out, 0);- In
SysDns.c:1150:
bool got = dns_resolve_5_zstr(&r, "myhost6", 0x1234, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1;
if (ok) {
const SocketAddr *ad = VecPtrAt(&out, 0);- In
SysDns.c:1192:
bool parsed = SocketAddrParse(&ns, "127.0.0.1:5353", SOCKET_KIND_UDP);
u64 before = VecLen(&r.nameservers);
bool added = DnsResolverAddNameserver(&r, ns);- In
SysDns.c:1195:
bool added = DnsResolverAddNameserver(&r, ns);
bool ok = parsed && added && VecLen(&r.nameservers) == before + 1 && ns_fmt_is(&r, before, a, "127.0.0.1:5353");
DnsResolverDeinit(&r);- In
SysDns.c:1228:
bool added = DnsResolverAddHostsPath(&r, &path);
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "hostrow"), 1, 2, 3, 4) &&
VecLen(&r.nameservers) == 0;- In
SysDns.c:1229:
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "hostrow"), 1, 2, 3, 4) &&
VecLen(&r.nameservers) == 0;
drop_temp(&path);- In
SysDns.c:1252:
bool added = DnsResolverAddResolvPath(&r, &path);
bool ok = added && VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "8.8.8.8:53") && VecLen(&r.hosts) == 0;
drop_temp(&path);- In
SysDns.c:1275:
bool added = DnsResolverAddPath(&r, &path);
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "hostrow"), 1, 2, 3, 4) &&
VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "8.8.8.8:53");- In
SysDns.c:1276:
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "hostrow"), 1, 2, 3, 4) &&
VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "8.8.8.8:53");
drop_temp(&path);- In
SysDns.c:1301:
bool added = DnsResolverAddHostsPath(&r, StrBegin(&smeared), plen);
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "lenhost"), 1, 2, 3, 4);
StrDeinit(&smeared);- In
SysDns.c:1349:
bool added = DnsResolverAddHostsPaths(&r, &paths);
bool ok = added && VecLen(&r.hosts) == 2 && host_v4_is(find_host(&r.hosts, "alpha"), 1, 1, 1, 1) &&
host_v4_is(find_host(&r.hosts, "beta"), 2, 2, 2, 2);- In
SysDns.c:1380:
bool added = DnsResolverAddResolvPaths(&r, &paths);
bool ok = added && VecLen(&r.nameservers) == 2 && ns_fmt_is(&r, 0, a, "10.0.0.1:53") &&
ns_fmt_is(&r, 1, a, "10.0.0.2:53");- In
SysDns.c:1411:
bool added = DnsResolverAddPaths(&r, &paths);
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "hh"), 1, 2, 3, 4) &&
VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "9.9.9.9:53");- In
SysDns.c:1412:
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "hh"), 1, 2, 3, 4) &&
VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "9.9.9.9:53");
FileRemove(&p0);- In
SysDns.c:1440:
bool added = DnsResolverAddPath(&r, StrBegin(&path), StrLen(&path));
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "zlhost"), 1, 2, 3, 4) &&
VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "8.8.8.8:53");- In
SysDns.c:1441:
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "zlhost"), 1, 2, 3, 4) &&
VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "8.8.8.8:53");
drop_temp(&path);- In
SysDns.c:1460:
bool added = DnsResolverAddResolvPath(&r, StrBegin(&path), StrLen(&path));
bool ok = added && VecLen(&r.nameservers) == 1 && ns_fmt_is(&r, 0, a, "4.3.2.1:53") && VecLen(&r.hosts) == 0;
drop_temp(&path);- In
SysDns.c:1499:
bool got = dns_resolve_5_zstr(&r, "single", 80, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:80");
VecDeinit(&out);- In
SysDns.c:1517:
bool got = dns_resolve_5_zstr(&r, "multi", 1234, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 2 && v4_is(VecPtrAt(&out, 0), a, "5.6.7.8:1234") &&
v4_is(VecPtrAt(&out, 1), a, "9.10.11.12:1234");- In
SysDns.c:1536:
bool got = dns_resolve_5_zstr(&r, "both", 443, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 2 && v4_is(VecPtrAt(&out, 0), a, "1.1.1.1:443") &&
v6_is(VecPtrAt(&out, 1), a, "[2606::1]:443");- In
SysDns.c:1555:
bool got = dns_resolve_5_zstr(&r, "v6name", 53, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v6_is(VecPtrAt(&out, 0), a, "[::1]:53");
VecDeinit(&out);- In
SysDns.c:1573:
bool got = dns_resolve_5_zstr(&r, "SINGLE.", 80, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:80");
VecDeinit(&out);- In
SysDns.c:1591:
bool got = dns_resolve_5_zstr(&r, "absent", 80, SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1615:
bool got = dns_resolve_5_zstr(&r, longname, 80, SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1639:
bool got = dns_resolve_5_zstr(&r, name, 80, SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1669:
bool got = dns_resolve_5_zstr(&r, name, 80, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:80");
VecDeinit(&out);- In
SysDns.c:1688:
bool got = dns_resolve_5_zstr(&r, "", 80, SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1707:
bool got = dns_resolve_5_str(&r, &name, 7000, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 2 && v4_is(VecPtrAt(&out, 0), a, "5.6.7.8:7000") &&
v4_is(VecPtrAt(&out, 1), a, "9.10.11.12:7000");- In
SysDns.c:1727:
bool got = dns_resolve_4_vec_zstr(&r, "single:80", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:80");
VecDeinit(&out);- In
SysDns.c:1745:
bool got = dns_resolve_4_vec_zstr(&r, "multi:9090", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 2 && v4_is(VecPtrAt(&out, 0), a, "5.6.7.8:9090") &&
v4_is(VecPtrAt(&out, 1), a, "9.10.11.12:9090");- In
SysDns.c:1764:
bool got = dns_resolve_4_vec_zstr(&r, "203.0.113.7:9999", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "203.0.113.7:9999");
VecDeinit(&out);- In
SysDns.c:1782:
bool got = dns_resolve_4_vec_zstr(&r, "single", SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1800:
bool got = dns_resolve_4_vec_zstr(&r, "single:", SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1818:
bool got = dns_resolve_4_vec_zstr(&r, "single:9z9", SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1836:
bool got = dns_resolve_4_vec_zstr(&r, "single:65535", SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 1 && v4_is(VecPtrAt(&out, 0), a, "1.2.3.4:65535");
VecDeinit(&out);- In
SysDns.c:1863:
bool got = dns_resolve_4_vec_zstr(&r, spec, SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1881:
bool got = dns_resolve_4_vec_zstr(&r, "absent:80", SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
SysDns.c:1900:
bool got = dns_resolve_4_vec_str(&r, &spec, SOCKET_KIND_TCP, &out);
bool ok = got && VecLen(&out) == 2 && v4_is(VecPtrAt(&out, 0), a, "5.6.7.8:8080") &&
v4_is(VecPtrAt(&out, 1), a, "9.10.11.12:8080");- In
SysDns.c:2029:
bool ok = dns_resolver_init(&r, a);
bool have_hosts = VecLen(&r.hosts) > 0;
DnsResolverDeinit(&r);- In
SysDns.c:2043:
bool ok = dns_resolver_init(&r, a);
bool have_ns = VecLen(&r.nameservers) > 0;
DnsResolverDeinit(&r);- In
MachoCache.c:665:
// Resolve module A then module B: two distinct entries (0 and 1).
ok = ok && MachoCacheResolve(&cache, bin_a, 0, 0x100000110ull, &name, &off);
ok = ok && VecLen(&cache.entries) == 1;
ok = ok && MachoCacheResolve(&cache, bin_b, 0, 0x100000110ull, &name, &off);
ok = ok && VecLen(&cache.entries) == 2;- In
MachoCache.c:667:
ok = ok && VecLen(&cache.entries) == 1;
ok = ok && MachoCacheResolve(&cache, bin_b, 0, 0x100000110ull, &name, &off);
ok = ok && VecLen(&cache.entries) == 2;
size after_two = DebugAllocatorLiveCount(&dbg);- In
MachoCache.c:677:
// entries vector grows and the live count rises.
ok = ok && MachoCacheResolve(&cache, bin_b, 0, 0x100000110ull, &name, &off);
ok = ok && VecLen(&cache.entries) == 2;
ok = ok && DebugAllocatorLiveCount(&dbg) == after_two;- In
MachoCache.c:682:
// Re-resolve module A (index 0) too: still a hit, no growth.
ok = ok && MachoCacheResolve(&cache, bin_a, 0, 0x100000110ull, &name, &off);
ok = ok && VecLen(&cache.entries) == 2;
ok = ok && DebugAllocatorLiveCount(&dbg) == after_two; ok = ok && MachoCacheResolve(&cache, bin_path, 0, low + 0x30, &name2, &off2);
ok = ok && name2 && ZstrCompare(name2, fn_name) == 0 && off2 == 0x30;
ok = ok && VecLen(&cache.entries) == 1;
MachoCacheDeinit(&cache); bool got = false;
if (ProcMapsLoad(&maps, ALLOCATOR_OF(&a))) {
for (u64 i = 0; i < VecLen(&maps.entries); ++i) {
const ProcMapEntry *m = VecPtrAt(&maps.entries, i);
if (m->path && m->path[0] == '/' && (m->perms & PROC_MAP_PERM_EXEC) &&- In
Bias.c:35:
bool got = false;
if (ProcMapsLoad(&maps, ALLOCATOR_OF(&a))) {
for (u64 i = 0; i < VecLen(&maps.entries); ++i) {
const ProcMapEntry *m = VecPtrAt(&maps.entries, i);
if (m->path && ZstrCompare(m->path, path) == 0 && (m->perms & PROC_MAP_PERM_WRITE) && addr >= m->start &&- In
Pe.c:494:
ok = pe.machine == PE_MACHINE_X86_64 && pe.is_pe32_plus && pe.image_base == 0x140000000ull;
ok = ok && VecLen(&pe.sections) == 1;
ok = ok && ZstrCompare(VecPtrAt(&pe.sections, 0)->name, ".debug") == 0;
ok = ok && VecPtrAt(&pe.sections, 0)->virtual_address == SECTION_VA;- In
Pe.c:1279:
}
bool ok = VecLen(&pe.sections) == 2;
ok = ok && ZstrCompare(VecPtrAt(&pe.sections, 0)->name, ".text") == 0;
ok = ok && ZstrCompare(VecPtrAt(&pe.sections, 1)->name, ".rdata") == 0;- In
Pe.c:1314:
return false;
}
bool ok = VecLen(&pe.sections) == 2;
PeDeinit(&pe);
DefaultAllocatorDeinit(&alloc);- In
Pe.c:1341:
}
const PeSection *s = VecPtrAt(&pe.sections, 0);
bool ok = VecLen(&pe.sections) == 1;
ok = ok && ZstrLen(s->name) == 8;
ok = ok && ZstrCompare(s->name, "ABCDEFGH") == 0;- In
Pe.c:1621:
bool opened = PeOpenFromMemoryCopy(&pe, blob, sizeof(blob), ALLOCATOR_OF(&alloc));
// Real code: rejected AND `out` zeroed by PeDeinit on the fail path.
bool ok = !opened && BufData(&pe.data) == NULL && BufLength(&pe.data) == 0 && VecLen(&pe.sections) == 0;
if (opened)
PeDeinit(&pe);- In
Pe.c:1668:
bool ok = PeOpen(&pe, (Zstr)StrBegin(&path), base);
if (ok) {
ok = pe.machine == PE_MACHINE_X86_64 && VecLen(&pe.sections) == 1 &&
ZstrCompare(VecPtrAt(&pe.sections, 0)->name, ".text") == 0;
PeDeinit(&pe);- In
Dns.c:158:
bool match = ok && resp.id == 0x1234 && resp.is_response && resp.recursion_desired && resp.recursion_avail &&
resp.rcode == DNS_RCODE_NOERROR && VecLen(&resp.answers) == 2;
if (match) {- In
Dns.c:222:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && resp.rcode == DNS_RCODE_NXDOMAIN && VecLen(&resp.answers) == 0;
DnsResponseDeinit(&resp);- In
Dns.c:293:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:564:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:739:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, p, a);
bool match = ok && q2_off == 256 && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:806:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:917:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && resp.id == 0xABCD && VecLen(&resp.answers) == 0 && VecLen(&resp.authority) == 0 &&
VecLen(&resp.additional) == 0;- In
Dns.c:918:
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && resp.id == 0xABCD && VecLen(&resp.answers) == 0 && VecLen(&resp.authority) == 0 &&
VecLen(&resp.additional) == 0;
DnsResponseDeinit(&resp);- In
Dns.c:1080:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 2;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:1108:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:1133:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:1219:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 2;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:1222:
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);
match = r->type == DNS_TYPE_AAAA && r->ttl == 10 && VecLen(&r->target) == 0;
static const u8 ip6[] =
{0x20, 0x01, 0x0d, 0xb8, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb};- In
Dns.c:1304:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 2;
if (match) {
DnsRecord *r0 = VecPtrAt(&resp.answers, 0);- In
Dns.c:1400:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 1 && VecLen(&resp.authority) == 1 && VecLen(&resp.additional) == 1;
if (match) {
DnsRecord *an = VecPtrAt(&resp.answers, 0);- In
Dns.c:1467:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:1519:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:1826:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), a);
bool match = ok && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:2046:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, len, a);
bool match = ok && VecLen(&resp.answers) == 1;
if (match) {
DnsRecord *r = VecPtrAt(&resp.answers, 0);- In
Dns.c:2083:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, sizeof(wire), adbg);
ok = ok && (VecLen(&resp.answers) == 1);
DnsRecord *r = ok ? VecPtrAt(&resp.answers, 0) : NULL;
ok = ok && (r->type == DNS_TYPE_CNAME);- In
Dns.c:2154:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, p, adbg);
ok = ok && (VecLen(&resp.authority) == 1);
ok = ok && (VecLen(&resp.answers) == 0) && (VecLen(&resp.additional) == 0);- In
Dns.c:2155:
bool ok = DnsParseResponse(&resp, wire, p, adbg);
ok = ok && (VecLen(&resp.authority) == 1);
ok = ok && (VecLen(&resp.answers) == 0) && (VecLen(&resp.additional) == 0);
DnsResponseDeinit(&resp);- In
Dns.c:2182:
DnsResponse resp = {0};
bool ok = DnsParseResponse(&resp, wire, p, adbg);
ok = ok && (VecLen(&resp.additional) == 1);
ok = ok && (VecLen(&resp.answers) == 0) && (VecLen(&resp.authority) == 0);- In
Dns.c:2183:
bool ok = DnsParseResponse(&resp, wire, p, adbg);
ok = ok && (VecLen(&resp.additional) == 1);
ok = ok && (VecLen(&resp.answers) == 0) && (VecLen(&resp.authority) == 0);
DnsResponseDeinit(&resp);- In
Pdb.c:296:
}
ok = VecLen(&pdb.functions) == 1;
if (ok) {
const PdbFunction *f = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:442:
}
ok = VecLen(&pdb.functions) == 3;
// Functions are stored sorted by RVA regardless of input order.
- In
Pdb.c:680:
if (!PdbOpenFromMemoryCopy(&pdb, gblob, sizeof(gblob), base))
return -1;
int n = (int)VecLen(&pdb.functions);
if (n >= 1 && out_rva0)
*out_rva0 = ((const PdbFunction *)VecPtrAt(&pdb.functions, 0))->rva;- In
Pdb.c:1682:
// Exactly four function symbols; the non-PUB32 data symbol is excluded.
ok = VecLen(&pdb.functions) == 4;
if (ok) {
const PdbFunction *f0 = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:1696:
// No "data_sym" must ever appear.
if (ok) {
for (size i = 0; i < VecLen(&pdb.functions); ++i) {
const PdbFunction *f = VecPtrAt(&pdb.functions, i);
if (ZstrCompare(f->name, "data_sym") == 0) {- In
Pdb.c:1742:
}
ok = VecLen(&pdb.functions) == 2;
if (ok) {
// sorted: 0x1040 (text) then 0x8010 (rdata)
- In
Pdb.c:1800:
// Only the two segment-1 functions survive.
ok = VecLen(&pdb.functions) == 2;
if (ok) {
const PdbFunction *f0 = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:1808:
}
if (ok) {
for (size i = 0; i < VecLen(&pdb.functions); ++i) {
const PdbFunction *f = VecPtrAt(&pdb.functions, i);
if (ZstrCompare(f->name, "bad_seg_fn") == 0) {- In
Pdb.c:1855:
}
ok = VecLen(&pdb.functions) == 3;
if (ok) {
const PdbFunction *a = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:1922:
}
ok = VecLen(&pdb.functions) == 5;
// Strictly ascending RVAs, despite descending input order.
- In
Pdb.c:1927:
if (ok) {
u32 prev = 0;
for (size i = 0; i < VecLen(&pdb.functions); ++i) {
const PdbFunction *f = VecPtrAt(&pdb.functions, i);
if (i > 0 && !(f->rva > prev)) {- In
Pdb.c:1985:
// Exactly the two well-formed functions survive; the stub is skipped
// (walk did NOT stop at it) and the unterminated-name record is rejected.
ok = VecLen(&pdb.functions) == 2;
if (ok) {
const PdbFunction *f0 = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:1994:
// No all-'A' garbage name leaked in from the unterminated record.
if (ok) {
for (size i = 0; i < VecLen(&pdb.functions); ++i) {
const PdbFunction *f = VecPtrAt(&pdb.functions, i);
if (ZstrCompare(f->name, "AAAAAAAA") == 0) {- In
Pdb.c:2042:
// fn_ovf is dropped; fn_max (exactly 4G-1) and fn_low survive.
ok = VecLen(&pdb.functions) == 2;
if (ok) {
const PdbFunction *f0 = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:2050:
}
if (ok) {
for (size i = 0; i < VecLen(&pdb.functions); ++i) {
const PdbFunction *f = VecPtrAt(&pdb.functions, i);
if (ZstrCompare(f->name, "fn_ovf") == 0) {- In
Pdb.c:2236:
// Both functions must be present, sorted by rva.
ok = VecLen(&pdb.functions) == 2;
if (ok) {
const PdbFunction *f0 = VecPtrAt(&pdb.functions, 0); // rva 0x2000
- In
Pdb.c:2436:
}
// The name pool must be non-trivial (names were stored).
ok = VecLen(&pdb.functions) == 2;
PdbDeinit(&pdb);- In
Pdb.c:2471:
bool ok = PdbOpen(&pdb, X_TMP_VALID, base);
if (ok) {
ok = VecLen(&pdb.functions) == 2 && pdb.info.signature == 0xfeedface;
PdbDeinit(&pdb);
}- In
Pdb.c:2689:
bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
if (ok) {
ok = VecLen(&pdb.functions) == 1;
if (ok) {
const PdbFunction *f = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:2724:
bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
if (ok) {
ok = VecLen(&pdb.functions) == 0;
PdbDeinit(&pdb);
}- In
Pdb.c:2754:
bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
if (ok) {
ok = VecLen(&pdb.functions) == 1;
if (ok) {
const PdbFunction *f = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:2786:
bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
if (ok) {
ok = VecLen(&pdb.functions) == 3;
if (ok) {
const PdbFunction *a = VecPtrAt(&pdb.functions, 0); // alpha 0x1100
- In
Pdb.c:2817:
bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
if (ok) {
ok = VecLen(&pdb.functions) == 1;
if (ok) {
const PdbFunction *f = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:3004:
if (!PdbOpenFromMemoryCopy(&pdb, b->bytes, b->len, base))
return -1;
int n = (int)VecLen(&pdb.functions);
PdbDeinit(&pdb);
return n;- In
Pdb.c:3037:
return false;
}
bool ok = VecLen(&pdb.functions) == 1;
if (ok) {
const PdbFunction *f = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:3077:
Pdb pdb;
bool opened = PdbOpenFromMemoryCopy(&pdb, b.bytes, b.len, base);
bool ok = opened && VecLen(&pdb.functions) == 1 && pdb.num_streams == N;
if (ok) {
const PdbFunction *f = VecPtrAt(&pdb.functions, 0);- In
Pdb.c:3118:
Pdb pdb;
bool opened = PdbOpenFromMemoryCopy(&pdb, b.bytes, b.len, base);
bool ok = opened && VecLen(&pdb.functions) == 1;
if (ok) {
const PdbFunction *f = VecPtrAt(&pdb.functions, 0);- In
ProcMaps.c:36:
// We expect many mappings — at least the binary itself plus libc.
bool ok = VecLen(&maps.entries) > 5;
// At least one entry should be executable (the code section of
- In
ProcMaps.c:41:
// either the test binary or libc).
bool any_exec = false;
for (u64 i = 0; i < VecLen(&maps.entries); ++i) {
if (VecPtrAt(&maps.entries, i)->perms & PROC_MAP_PERM_EXEC) {
any_exec = true;- In
ProcMaps.c:93:
// A live process maps at minimum its own binary, libc, ld, heap,
// stack, vdso/vsyscall -- comfortably more than five regions.
bool ok = VecLen(&maps.entries) > 5;
ProcMapsDeinit(&maps);- In
ProcMaps.c:171:
}
bool ok = VecLen(&maps.entries) > 0;
if (ok) {
// Pick a non-degenerate region and query its exact start.
- In
ProcMaps.c:175:
// Pick a non-degenerate region and query its exact start.
const ProcMapEntry *region = NULL;
for (u64 i = 0; i < VecLen(&maps.entries); ++i) {
const ProcMapEntry *cand = VecPtrAt(&maps.entries, i);
if (cand->end > cand->start) {- In
ProcMaps.c:210:
}
bool ok = VecLen(&maps.entries) > 0;
if (ok) {
// The entry with the highest `end` -- `end` itself maps to nothing.
- In
ProcMaps.c:214:
// The entry with the highest `end` -- `end` itself maps to nothing.
const ProcMapEntry *top = VecPtrAt(&maps.entries, 0);
for (u64 i = 1; i < VecLen(&maps.entries); ++i) {
const ProcMapEntry *cand = VecPtrAt(&maps.entries, i);
if (cand->end > top->end)- In
ProcMaps.c:280:
bool ok = false;
bool found_gap = false;
for (u64 i = 0; i < VecLen(&maps.entries) && !found_gap; ++i) {
u64 hole = VecPtrAt(&maps.entries, i)->end;
// Is `hole` inside any region?
- In
ProcMaps.c:284:
// Is `hole` inside any region?
bool inside = false;
for (u64 j = 0; j < VecLen(&maps.entries); ++j) {
const ProcMapEntry *e = VecPtrAt(&maps.entries, j);
if (hole >= e->start && hole < e->end) {- In
ProcMaps.c:398:
}
bool ok = VecLen(&maps.entries) > 0;
if (ok) {
u64 lowest = VecPtrAt(&maps.entries, 0)->start;- In
ProcMaps.c:401:
if (ok) {
u64 lowest = VecPtrAt(&maps.entries, 0)->start;
for (u64 i = 1; i < VecLen(&maps.entries); ++i) {
u64 start = VecPtrAt(&maps.entries, i)->start;
if (start < lowest)- In
ProcMaps.c:435:
}
bool ok = VecLen(&m.entries) == 1;
if (ok) {
const ProcMapEntry *e = VecPtrAt(&m.entries, 0);- In
ProcMaps.c:460:
}
bool ok = VecLen(&m.entries) == 1;
if (ok) {
const ProcMapEntry *e = VecPtrAt(&m.entries, 0);- In
ProcMaps.c:482:
}
bool ok = VecLen(&m.entries) == 1;
if (ok) {
const ProcMapEntry *e = VecPtrAt(&m.entries, 0);- In
ProcMaps.c:506:
}
bool ok = VecLen(&m.entries) == 0;
ProcMapsDeinit(&m);- In
ProcMaps.c:525:
}
bool ok = VecLen(&m.entries) == 2;
if (ok) {
const ProcMapEntry *e0 = VecPtrAt(&m.entries, 0);- In
ProcMaps.c:550:
}
bool ok = VecLen(&m.entries) == 1;
if (ok) {
const ProcMapEntry *e = VecPtrAt(&m.entries, 0);- In
Http.c:28:
bool ok = (next != raw) && (req.method == HTTP_REQUEST_METHOD_GET) && (StrLen(&req.url) == 11) &&
(ZstrCompare(StrBegin(&req.url), "/index.html") == 0) && (VecLen(&req.headers) == 2) &&
(ZstrCompare(next, "body-bytes") == 0);- In
Http.c:196:
Zstr next = HttpRequestParse(&req, in);
bool ok = (next != in) && (VecLen(&req.headers) == 100);
HttpRequestDeinit(&req);- In
Http.c:304:
bool ok = VecPushBackR(&headers, hh);
ok = ok && (VecLen(&headers) == 1);
// R-push deep-copied into the vec and left `hh` owning its own storage;
// reclaim the source so only the vec's deep copies remain live.
- In
MachO.c:360:
ok = m.cputype == 0x01000007u && m.filetype == MACHO_FILE_TYPE_EXECUTE;
ok = ok && m.has_uuid && MemCompare(m.uuid, kUuid, 16) == 0;
ok = ok && VecLen(&m.segments) == 1;
ok = ok && ZstrCompare(VecPtrAt(&m.segments, 0)->name, "__TEXT") == 0;
ok = ok && VecLen(&m.sections) == 1;- In
MachO.c:362:
ok = ok && VecLen(&m.segments) == 1;
ok = ok && ZstrCompare(VecPtrAt(&m.segments, 0)->name, "__TEXT") == 0;
ok = ok && VecLen(&m.sections) == 1;
ok = ok && ZstrCompare(VecPtrAt(&m.sections, 0)->section, "__text") == 0;
ok = ok && ZstrCompare(VecPtrAt(&m.sections, 0)->segment, "__TEXT") == 0;- In
MachO.c:365:
ok = ok && ZstrCompare(VecPtrAt(&m.sections, 0)->section, "__text") == 0;
ok = ok && ZstrCompare(VecPtrAt(&m.sections, 0)->segment, "__TEXT") == 0;
ok = ok && VecLen(&m.symbols) == 1;
ok = ok && VecPtrAt(&m.symbols, 0)->name && ZstrCompare(VecPtrAt(&m.symbols, 0)->name, "my_function") == 0;
ok = ok && VecPtrAt(&m.symbols, 0)->value == 0x100000010ull;- In
MachO.c:533:
}
bool ok = VecLen(&m.symbols) == 2;
// Inside the first symbol's span [0x10, 0x40): resolves to it.
- In
MachO.c:584:
bool ok = m.filetype == MACHO_FILE_TYPE_EXECUTE;
ok = ok && m.has_uuid;
ok = ok && VecLen(&m.segments) > 0;
ok = ok && MachoFindSection(&m, "__TEXT", "__text") != NULL;
ok = ok && VecLen(&m.symbols) > 0;- In
MachO.c:586:
ok = ok && VecLen(&m.segments) > 0;
ok = ok && MachoFindSection(&m, "__TEXT", "__text") != NULL;
ok = ok && VecLen(&m.symbols) > 0;
MachoDeinit(&m);- In
MachO.c:656:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.symbols) == 1;
if (VecLen(&m.symbols) == 1)
ok = ok && ZstrCompare(VecPtrAt(&m.symbols, 0)->name, "fn_a") == 0;- In
MachO.c:657:
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.symbols) == 1;
if (VecLen(&m.symbols) == 1)
ok = ok && ZstrCompare(VecPtrAt(&m.symbols, 0)->name, "fn_a") == 0;
if (ok)- In
MachO.c:713:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.symbols) == 2;
if (VecLen(&m.symbols) == 2) {
const MachoSymbol *s0 = VecPtrAt(&m.symbols, 0);- In
MachO.c:714:
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.symbols) == 2;
if (VecLen(&m.symbols) == 2) {
const MachoSymbol *s0 = VecPtrAt(&m.symbols, 0);
const MachoSymbol *s1 = VecPtrAt(&m.symbols, 1);- In
MachO.c:745:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.symbols) == 1 && VecPtrAt(&m.symbols, 0)->section_index == 5;
if (ok)
MachoDeinit(&m);- In
MachO.c:775:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc); // real: accepts
ok = ok && VecLen(&m.symbols) == 1 && ZstrCompare(VecPtrAt(&m.symbols, 0)->name, "fit") == 0;
if (ok)
MachoDeinit(&m);- In
MachO.c:802:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.symbols) == 1 && ZstrCompare(VecPtrAt(&m.symbols, 0)->name, "edge") == 0;
if (ok)
MachoDeinit(&m);- In
MachO.c:836:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc); // real accepts
ok = ok && VecLen(&m.symbols) == NSY;
if (ok)
MachoDeinit(&m);- In
MachO.c:927:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.symbols) == 0; // real: symbol skipped
if (ok)
MachoDeinit(&m);- In
MachO.c:957:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.symbols) == 0; // real: skipped (no NUL in range)
if (ok)
MachoDeinit(&m);- In
MachO.c:991:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.symbols) == 1; // real: forward scan finds NUL
if (ok)
MachoDeinit(&m);- In
MachO.c:1101:
Macho m;
bool ok = open_blob(&m, b, BUF, &alloc);
ok = ok && VecLen(&m.sections) == 2;
// The target at index 1 must be found (real ++i reaches it).
const MachoSection *hit = MachoFindSection(&m, "__TEXT", "__cstring");- In
MachO.c:1128:
Macho m;
bool ok = MachoOpenFromMemoryCopy(&m, buf, sizeof(buf), base);
ok = ok && VecLen(&m.segments) == 0 && VecLen(&m.sections) == 0;
ok = ok && m.cputype == 0x01000007u && m.filetype == MACHO_FILE_TYPE_EXECUTE;
if (ok)- In
MachO.c:1164:
Macho m;
bool ok = MachoOpenFromMemoryCopy(&m, buf, sizeof(buf), base);
ok = ok && VecLen(&m.segments) == 1 && VecLen(&m.sections) == 0;
ok = ok && ZstrCompare(VecPtrAt(&m.segments, 0)->name, "__TEXT") == 0;
ok = ok && VecPtrAt(&m.segments, 0)->vmaddr == 0x1000;- In
MachO.c:1196:
Macho m;
bool ok = MachoOpenFromMemoryCopy(&m, buf, sizeof(buf), base);
ok = ok && VecLen(&m.segments) == 1;
ok = ok && ZstrCompare(VecPtrAt(&m.segments, 0)->name, "ABCDEFGHIJKLMNOP") == 0;
if (ok)- In
MachO.c:1217:
Macho m;
bool ok = MachoOpenFromMemoryCopy(&m, buf, len, base);
ok = ok && VecLen(&m.segments) == 1 && VecLen(&m.sections) == 2;
ok = ok && VecPtrAt(&m.sections, 0)->addr == 0x100000000ull;
ok = ok && VecPtrAt(&m.sections, 1)->addr == 0x100001000ull;- In
MachO.c:1258:
Macho m;
bool ok = MachoOpenFromMemoryCopy(&m, buf, sizeof(buf), base);
ok = ok && VecLen(&m.sections) == 1;
ok = ok && ZstrCompare(VecPtrAt(&m.sections, 0)->section, "abcdefghijklmnop") == 0;
ok = ok && ZstrCompare(VecPtrAt(&m.sections, 0)->segment, "QRSTUVWXYZ012345") == 0;- In
MachO.c:1289:
Macho m;
bool ok = MachoOpenFromMemoryCopy(&m, buf, sizeof(buf), base);
ok = ok && VecLen(&m.segments) == 1;
if (ok)
MachoDeinit(&m);- In
MachO.c:1320:
Macho m;
bool ok = MachoOpenFromMemoryCopy(&m, buf, sizeof(buf), base);
ok = ok && VecLen(&m.segments) == 0 && VecLen(&m.sections) == 0;
if (ok)
MachoDeinit(&m);- In
MachO.c:1347:
return false;
}
bool ok = VecLen(&m.symbols) == 2;
// Query above both; correct best is the 0x...40 symbol (max <= vaddr).
- In
MachO.c:1387:
return false;
}
bool ok = VecLen(&m.symbols) == 2;
const MachoSymbol *s = MachoResolveAddress(&m, 0x100000020ull);- In
MachO.c:1429:
Macho m;
bool opened = MachoOpen(&m, &path, base);
ok = ok && opened && VecLen(&m.segments) == 1;
if (opened)
MachoDeinit(&m);- In
Elf.c:264:
bool ok = elf.header.elf_class == ELF_CLASS_64 && elf.header.data == ELF_DATA_LSB &&
(elf.header.type == ELF_TYPE_EXEC || elf.header.type == ELF_TYPE_DYN) && VecLen(&elf.sections) > 0;
// A test binary built with sanitizers should have both static and
- In
Elf.c:268:
// A test binary built with sanitizers should have both static and
// dynamic symbol tables.
ok = ok && VecLen(&elf.symbols) > 0;
ElfDeinit(&elf);- In
Elf.c:323:
bool ok = false;
for (u64 i = 0; i < VecLen(&elf.symbols); ++i) {
const ElfSymbol *s = VecPtrAt(&elf.symbols, i);
if (s->type == ELF_SYMBOL_TYPE_FUNC && s->size > 0 && s->name && s->name[0] != '\0') {- In
Elf.c:361:
// Sections decode in order with correct names.
ok = ok && VecLen(&elf.sections) == N_SECTIONS;
const ElfSection *text = ElfFindSection(&elf, ".text");
ok = ok && text != NULL && text->addr == TEXT_VADDR && text->offset == TEXT_OFF && text->size == TEXT_SIZE &&- In
Elf.c:368:
// The one named function symbol decodes with its value, size, name,
// bind, type, and section index intact.
ok = ok && VecLen(&elf.symbols) == 2; // null sym + my_func
bool found_func = false;
for (u64 i = 0; i < VecLen(&elf.symbols); ++i) {- In
Elf.c:370:
ok = ok && VecLen(&elf.symbols) == 2; // null sym + my_func
bool found_func = false;
for (u64 i = 0; i < VecLen(&elf.symbols); ++i) {
const ElfSymbol *s = VecPtrAt(&elf.symbols, i);
if (s->name && ZstrCompare(s->name, "my_func") == 0) {- In
Elf.c:396:
bool ok = ElfOpenFromMemoryCopy(&elf, elf_blob, sizeof(elf_blob), ALLOCATOR_OF(&alloc));
if (ok) {
ok = VecLen(&elf.segments) == 2;
if (ok) {
const ElfSegment *s0 = VecPtrAt(&elf.segments, 0);- In
Elf.c:752:
}
bool ok = VecLen(&elf.sections) == N_SECTIONS;
// First section is the NULL section (name ""), last is .strtab.
- In
Elf.c:888:
if (ok) {
// Empty shstrtab => every section name decodes to "".
ok = VecLen(&elf.sections) == N_SECTIONS;
ElfDeinit(&elf);
}- In
Elf.c:911:
bool ok = ElfOpenFromMemoryCopy(&elf, bad, sizeof(bad), ALLOCATOR_OF(&alloc));
if (ok) {
ok = VecLen(&elf.sections) == N_SECTIONS;
ElfDeinit(&elf);
}- In
Elf.c:996:
// declared strtab size => real decodes "".
const ElfSection *s1 = VecPtrAt(&elf.sections, 1);
bool ok = VecLen(&elf.sections) == 2 && s1->name != NULL && s1->name[0] == '\0';
ElfDeinit(&elf);- In
Elf.c:1054:
const ElfSection *s1 = VecPtrAt(&elf.sections, 1);
bool ok = VecLen(&elf.sections) == 2 && s1->name != NULL && s1->name[0] == '\0';
ElfDeinit(&elf);- In
Elf.c:1113:
const ElfSection *s1 = VecPtrAt(&elf.sections, 1);
bool ok = VecLen(&elf.sections) == 2 && s1->name != NULL && ZstrCompare(s1->name, "XYZ") == 0;
ElfDeinit(&elf);- In
Elf.c:1194:
ok = ok && elf.header.shnum > 0; // has sections
ok = ok && elf.header.shstrndx < elf.header.shnum; // shstrndx in range
ok = ok && VecLen(&elf.sections) == elf.header.shnum;
ElfDeinit(&elf);- In
Elf.c:1224:
ok = ok && elf.header.shnum == N_SECTIONS;
ok = ok && elf.header.shstrndx == SEC_SHSTRTAB;
ok = ok && VecLen(&elf.sections) == N_SECTIONS;
ElfDeinit(&elf);- In
Elf.c:1268:
Elf elf;
bool opened = ElfOpenFromMemoryCopy(&elf, b, sizeof(b), ALLOCATOR_OF(&alloc));
bool ok = opened && elf.header.shnum == 1 && VecLen(&elf.sections) == 1;
if (opened)
ElfDeinit(&elf);- In
Elf.c:1426:
// struct, so the header and section vector must read back empty.
bool ok = elf.header.machine == 0 && elf.header.shnum == 0 && elf.header.shoff == 0 && elf.header.entry == 0 &&
VecLen(&elf.sections) == 0 && VecLen(&elf.symbols) == 0;
DefaultAllocatorDeinit(&alloc);
return ok;- In
Elf.c:1439:
Elf elf;
bool opened = ElfOpen(&elf, "/proc/self/exe", ALLOCATOR_OF(&alloc));
bool ok = opened && elf.header.machine == ELF_MACHINE_HOST && VecLen(&elf.sections) > 0;
if (opened)
ElfDeinit(&elf);- In
Elf.c:1689:
return false;
}
bool ok = VecLen(&elf.symbols) == 5;
ElfDeinit(&elf);
DefaultAllocatorDeinit(&alloc);- In
Elf.c:1740:
return false;
}
bool ok = VecLen(&elf.dynamic_symbols) == 2;
if (ok) {
const ElfSymbol *d = VecPtrAt(&elf.dynamic_symbols, 1);- In
Stripped.c:82:
bool built = DwarfFunctionsBuildFromElf(&fns, &stripped, base);
bool ok = false;
if (built && VecLen(&fns.entries) > 0) {
const DwarfFunction *f = DwarfFunctionsResolve(&fns, file_relative);
ok = f && f->name && ZstrFindSubstring(f->name, expect_name) != NULL;- In
Dwarf.c:31:
DwarfLines lines;
bool built = DwarfLinesBuildFromElf(&lines, &elf, ALLOCATOR_OF(&alloc));
bool ok = built && VecLen(&lines.entries) > 0;
if (built)- In
Dwarf.c:181:
bool built = DwarfFunctionsBuildFromElf(&fns, &elf, base);
bool ok = false;
if (built && VecLen(&fns.entries) > 0) {
const DwarfFunction *f = DwarfFunctionsResolve(&fns, file_relative);
ok = f != NULL && f->name != NULL && ZstrFindSubstring(f->name, "dwarf_marker_helper") != NULL;- In
Dwarf.c:286:
DwarfFunctions fns;
bool built = DwarfFunctionsBuildFromSlices(&fns, info, info_len, kAbbrev, sizeof(kAbbrev), NULL, 0, base);
bool ok = built && VecLen(&fns.entries) == 1;
if (ok) {- In
Dwarf.c:394:
DwarfFunctions fns;
bool built = DwarfFunctionsBuildFromSlices(&fns, NULL, 0, NULL, 0, NULL, 0, base);
bool ok = built && VecLen(&fns.entries) == 0 && DwarfFunctionsResolve(&fns, 0x4000) == NULL;
if (built)- In
Dwarf.c:587:
if (built) {
// Two real rows plus the end_sequence row.
ok = ok && VecLen(&lines.entries) >= 2;
// Address 0x2000 -> source.c:10
- In
Dwarf.c:642:
// (defensively) it succeeds but yields no usable rows. A caller must
// never get a bogus resolved line from over-read bytes.
bool ok = !built || VecLen(&lines.entries) == 0;
if (built)- In
Dwarf.c:1778:
// Real rows (excluding end_sequence) must be at least one.
u64 real_rows = 0;
for (u64 i = 0; i < VecLen(&lines.entries); ++i) {
const DwarfLineEntry *e = &VecAt(&lines.entries, i);
if (!e->end_sequence)- In
Dwarf.c:2140:
bool ok = true;
// Two real rows + the end_sequence row.
ok = ok && VecLen(&lines.entries) == 3;
const DwarfLineEntry *e = DwarfLinesResolve(&lines, 0x2000);- In
Dwarf.c:2383:
DwarfLines lines;
bool built = lines_from_debug_line(&lines, &elf, dl, dl_len, base);
bool ok = !built || VecLen(&lines.entries) == 0;
if (built)- In
Dwarf.c:2477:
bool ok = built; // 562: `ok=true`->false => built would be false.
if (built) {
ok = ok && VecLen(&lines.entries) >= 2;
const DwarfLineEntry *e = DwarfLinesResolve(&lines, 0x2000);- In
Dwarf.c:3101:
// row and reports its address via *out, returns whether one was found.
static bool first_real_row_address(const DwarfLines *lines, u64 *out) {
for (u64 i = 0; i < VecLen(&lines->entries); ++i) {
const DwarfLineEntry *e = &VecAt(&lines->entries, i);
if (!e->end_sequence) { });
if (VecLen(&languages) != 3) {
WriteFmt("[DEBUG] Languages length check failed: expected 3, got {}\n", VecLen(&languages));
success = false;
if (VecLen(&languages) != 3) {
WriteFmt("[DEBUG] Languages length check failed: expected 3, got {}\n", VecLen(&languages));
success = false;
} }
if (VecLen(&languages) >= 3) {
Str *lang1 = &VecAt(&languages, 0);
Str *lang2 = &VecAt(&languages, 1); }
if (VecLen(&product.tags) != 3) {
WriteFmt("[DEBUG] Product tags length check failed: expected 3, got {}\n", VecLen(&product.tags));
success = false;
if (VecLen(&product.tags) != 3) {
WriteFmt("[DEBUG] Product tags length check failed: expected 3, got {}\n", VecLen(&product.tags));
success = false;
} }
if (VecLen(&product.tags) >= 3) {
Str *tag1 = &VecAt(&product.tags, 0);
Str *tag2 = &VecAt(&product.tags, 1); // Write dynamic key for source function ID
Str source_key = StrInit(&alloc);
u64 source_id = VecLen(&response.data) > 0 ? VecAt(&response.data, 0).source_function_id : 0;
StrAppendFmt(&source_key, "{}", source_id);
JW_OBJ_KV(json, StrBegin(&source_key), {
if (VecLen(&response.data) > 0) {
AnnSymbol *s = &VecAt(&response.data, 0);
Str target_key = StrInit(&alloc); });
if (VecLen(&symbols) != 2) {
WriteFmt("[DEBUG] Symbols length check failed: expected 2, got {}\n", VecLen(&symbols));
success = false;
if (VecLen(&symbols) != 2) {
WriteFmt("[DEBUG] Symbols length check failed: expected 2, got {}\n", VecLen(&symbols));
success = false;
} }
if (VecLen(&symbols) >= 2) {
AnnSymbol *sym1 = &VecAt(&symbols, 0);
AnnSymbol *sym2 = &VecAt(&symbols, 1);
// Debug data length check
if (VecLen(&response.data) != 1) {
WriteFmt("[DEBUG] Data length check failed: expected 1, got {}\n", VecLen(&response.data));
success = false; // Debug data length check
if (VecLen(&response.data) != 1) {
WriteFmt("[DEBUG] Data length check failed: expected 1, got {}\n", VecLen(&response.data));
success = false;
} }
if (VecLen(&response.data) > 0) {
AnnSymbol *sym = &VecAt(&response.data, 0);
VecPushBack(&response.data, sym);
WriteFmt("[DEBUG] Added symbol to vector, length now: {}\n", VecLen(&response.data));
});
}); });
WriteFmt("[DEBUG] Finished parsing, response.data length = {}\n", VecLen(&response.data));
// Debug checks
}
if (VecLen(&response.data) != 1) {
WriteFmt("[DEBUG] Data length check failed: expected 1, got {}\n", VecLen(&response.data));
success = false;
if (VecLen(&response.data) != 1) {
WriteFmt("[DEBUG] Data length check failed: expected 1, got {}\n", VecLen(&response.data));
success = false;
} }
if (VecLen(&response.data) > 0) {
AnnSymbol *sym = &VecAt(&response.data, 0);
VecPushBack(&response.data, sym);
WriteFmt("[DEBUG] Added symbol to vector, length now: {}\n", VecLen(&response.data));
});
}); });
WriteFmt("[DEBUG] Finished parsing, response.data length = {}\n", VecLen(&response.data));
// Debug checks
}
if (VecLen(&response.data) != 1) {
WriteFmt("[DEBUG] Data length check failed: expected 1, got {}\n", VecLen(&response.data));
success = false;
if (VecLen(&response.data) != 1) {
WriteFmt("[DEBUG] Data length check failed: expected 1, got {}\n", VecLen(&response.data));
success = false;
} }
if (VecLen(&response.data) > 0) {
AnnSymbol *sym = &VecAt(&response.data, 0); });
if (VecLen(&items) == 0) {
WriteFmtLn("[DEBUG] Empty array test passed - no items added");
} else { WriteFmtLn("[DEBUG] Empty array test passed - no items added");
} else {
WriteFmtLn("[DEBUG] Empty array test FAILED - {} items found", VecLen(&items));
success = false;
} });
if (VecLen(&data) == 0) {
WriteFmtLn("[DEBUG] Empty array with whitespace test passed");
} else { });
if (obj.x_value == 1 && VecLen(&obj.filled_items) == 2 && VecAt(&obj.filled_items, 0) == 1 &&
VecAt(&obj.filled_items, 1) == 2) {
WriteFmt( "[DEBUG] Mixed empty and filled test passed - x: {}, items: {}\n",
obj.x_value,
VecLen(&obj.filled_items)
);
} else { "[DEBUG] Mixed empty and filled test FAILED - x: {}, items: {}\n",
obj.x_value,
VecLen(&obj.filled_items)
);
if (VecLen(&obj.filled_items) > 0) { VecLen(&obj.filled_items)
);
if (VecLen(&obj.filled_items) > 0) {
WriteFmt("[DEBUG] First item: {}\n", VecAt(&obj.filled_items, 0));
}- In
RoundTrip.c:75:
bool compare_configs(const TestConfig *a, const TestConfig *b) {
if (a->debug_mode != b->debug_mode || a->timeout != b->timeout ||
StrCmp((Str *)&a->log_level, (Str *)&b->log_level) != 0 || VecLen(&a->features) != VecLen(&b->features)) {
return false;
}- In
RoundTrip.c:79:
}
for (size i = 0; i < VecLen(&a->features); i++) {
if (StrCmp((Str *)&VecAt(&a->features, i), (Str *)&VecAt(&b->features, i)) != 0) {
return false;- In
RoundTrip.c:415:
// Compare arrays
bool numbers_match = (VecLen(&original_numbers) == VecLen(&parsed_numbers));
if (numbers_match) {
for (size i = 0; i < VecLen(&original_numbers); i++) {- In
RoundTrip.c:417:
bool numbers_match = (VecLen(&original_numbers) == VecLen(&parsed_numbers));
if (numbers_match) {
for (size i = 0; i < VecLen(&original_numbers); i++) {
if (VecAt(&original_numbers, i) != VecAt(&parsed_numbers, i)) {
numbers_match = false;- In
RoundTrip.c:425:
}
bool strings_match = (VecLen(&original_strings) == VecLen(&parsed_strings));
if (strings_match) {
for (size i = 0; i < VecLen(&original_strings); i++) {- In
RoundTrip.c:427:
bool strings_match = (VecLen(&original_strings) == VecLen(&parsed_strings));
if (strings_match) {
for (size i = 0; i < VecLen(&original_strings); i++) {
if (StrLen(VecPtrAt(&original_strings, i)) != StrLen(VecPtrAt(&parsed_strings, i)) ||
(StrLen(VecPtrAt(&original_strings, i)) &&- In
RoundTrip.c:444:
"[DEBUG] Numbers match: {} (orig {}, parsed {})\n",
numbers_match ? "true" : "false",
VecLen(&original_numbers),
VecLen(&parsed_numbers)
);- In
RoundTrip.c:445:
numbers_match ? "true" : "false",
VecLen(&original_numbers),
VecLen(&parsed_numbers)
);
WriteFmtLn(- In
RoundTrip.c:450:
"[DEBUG] Strings match: {} (orig {}, parsed {})\n",
strings_match ? "true" : "false",
VecLen(&original_strings),
VecLen(&parsed_strings)
);- In
RoundTrip.c:451:
strings_match ? "true" : "false",
VecLen(&original_strings),
VecLen(&parsed_strings)
);
success = false;- In
RoundTrip.c:626:
bool config_match = compare_configs(&original.config, &parsed.config);
bool numbers_match = (VecLen(&original.numbers) == VecLen(&parsed.numbers));
if (numbers_match) {
for (size i = 0; i < VecLen(&original.numbers); i++) {- In
RoundTrip.c:628:
bool numbers_match = (VecLen(&original.numbers) == VecLen(&parsed.numbers));
if (numbers_match) {
for (size i = 0; i < VecLen(&original.numbers); i++) {
if (VecAt(&original.numbers, i) != VecAt(&parsed.numbers, i)) {
numbers_match = false;- In
RoundTrip.c:636:
}
bool flags_match = (VecLen(&original.flags) == VecLen(&parsed.flags));
if (flags_match) {
for (size i = 0; i < VecLen(&original.flags); i++) {- In
RoundTrip.c:638:
bool flags_match = (VecLen(&original.flags) == VecLen(&parsed.flags));
if (flags_match) {
for (size i = 0; i < VecLen(&original.flags); i++) {
if (VecAt(&original.flags, i) != VecAt(&parsed.flags, i)) {
flags_match = false;- In
RoundTrip.c:716:
// Compare empty containers
if (StrLen(&parsed_str) == 0 && VecLen(&parsed_numbers) == 0 && VecLen(&parsed_strings) == 0 &&
!found_empty_object) { // Empty object should not execute the content
WriteFmtLn("[DEBUG] Empty containers round-trip test passed");- In
RoundTrip.c:724:
"[DEBUG] String length: {}, numbers: {}, strings: {}, found_obj: {}\n",
StrLen(&parsed_str),
VecLen(&parsed_numbers),
VecLen(&parsed_strings),
found_empty_object ? "true" : "false"- In
RoundTrip.c:725:
StrLen(&parsed_str),
VecLen(&parsed_numbers),
VecLen(&parsed_strings),
found_empty_object ? "true" : "false"
);
Last updated on