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
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
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
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
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
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);
}
static ResolverCacheEntry *resolver_cache_find_or_open(SymbolResolver *self, Zstr path, u64 load_base) {
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- In
ProcMaps.c:251:
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
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);- 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
Dns.c:449:
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:514:
// 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:629:
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
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;- 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:267:
// 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:318:
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:506:
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:539:
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
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; 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
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
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
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; });
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));
} // 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(&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);- In
RoundTrip.c:76:
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:80:
}
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:416:
// 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:418:
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:426:
}
bool strings_match = (VecLen(&original_strings) == VecLen(&parsed_strings));
if (strings_match) {
for (size i = 0; i < VecLen(&original_strings); i++) {- In
RoundTrip.c:428:
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:445:
"[DEBUG] Numbers match: {} (orig {}, parsed {})\n",
numbers_match ? "true" : "false",
VecLen(&original_numbers),
VecLen(&parsed_numbers)
);- In
RoundTrip.c:446:
numbers_match ? "true" : "false",
VecLen(&original_numbers),
VecLen(&parsed_numbers)
);
WriteFmtLn(- In
RoundTrip.c:451:
"[DEBUG] Strings match: {} (orig {}, parsed {})\n",
strings_match ? "true" : "false",
VecLen(&original_strings),
VecLen(&parsed_strings)
);- In
RoundTrip.c:452:
strings_match ? "true" : "false",
VecLen(&original_strings),
VecLen(&parsed_strings)
);
success = false;- In
RoundTrip.c:627:
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:629:
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:637:
}
bool flags_match = (VecLen(&original.flags) == VecLen(&parsed.flags));
if (flags_match) {
for (size i = 0; i < VecLen(&original.flags); i++) {- In
RoundTrip.c:639:
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:717:
// 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:725:
"[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:726:
StrLen(&parsed_str),
VecLen(&parsed_numbers),
VecLen(&parsed_strings),
found_empty_object ? "true" : "false"
);- In
Http.c:24:
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
Str.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
Str.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
Str.Ops.c:222:
// Test StrSplitToIters
StrIters iters = StrSplitToIters(&s, ",");
result = result && (VecLen(&iters) == 3);
if (VecLen(&iters) >= 3) {- In
Str.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
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); }
ok = ok && (VecLen(&v) == 1024) && (VecAt(&v, 0) == 0) && (VecAt(&v, 1023) == 1023);
VecDeinit(&v);
PageAllocatorDeinit(&alloc);- In
Vec.Ops.c:84:
// 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
Vec.Ops.c:92:
// 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
Vec.Ops.c:107:
// Check that the elements are reversed
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == even_values[3 - i]);
}- In
Vec.Ops.c:137:
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
Vec.Ops.c:146:
// 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
MachO.c:135:
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:137:
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:140:
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:226:
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:228:
ok = ok && VecLen(&m.segments) > 0;
ok = ok && MachoFindSection(&m, "__TEXT", "__text") != NULL;
ok = ok && VecLen(&m.symbols) > 0;
MachoDeinit(&m);- In
Elf.c:21:
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:25:
// 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:80:
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
SysDns.c:91:
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:115:
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:141:
// Sanity: each returned address should format with ":53" suffix.
bool ok = got && VecLen(&out) > 0;
if (ok) {
VecForeachPtr(&out, ad) {- In
SysDns.c:194:
bool got = DnsResolve(&r, "localhost", SOCKET_KIND_TCP, &out);
bool ok = !got && VecLen(&out) == 0;
VecDeinit(&out);- In
Vec.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]);
} // 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);
} // 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);
} 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]);
} 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]);
} int iteration_count = 0;
VecForeach(&vec, val) {
WriteFmt("Iteration {} (vec.length={}): {}\n", iteration_count, VecLen(&vec), val);
// After 2nd iteration, shrink the vector dramatically
if (iteration_count == 2) {
VecResize(&vec, 2); // Shrink to only 2 elements
WriteFmt("Vector resized to length {} during foreach iteration...\n", VecLen(&vec));
} // 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
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);
} // 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
if (idx == 4) {
VecResize(&vec, 2); // Shrink to only 2 elements
WriteFmt("Vector resized to length {} during reverse iteration...\n", VecLen(&vec));
} // 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
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);
} // 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
if (idx == 5) {
VecResize(&vec, 3); // Shrink to only 3 elements
WriteFmt("Vector resized to length {} during reverse ptr iteration...\n", VecLen(&vec));
}
// 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); 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
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);
} // loop will automatically terminate
if (idx > VecLen(&vec)) {
LOG_ERROR("Should've terminated");
VecDeinit(&vec); // 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
if (idx == 2) {
VecResize(&vec, 1); // Shrink to only 1 element
WriteFmt("Vector resized to length {}, current index={}\n", VecLen(&vec), idx);
} BitVecMatchIndices matches = VecInitT(matches, base);
result = result && BitVecFindAllPattern(&source, &pattern, &matches);
result = result && VecLen(&matches) == 5;
if (result) {
result = result && VecAt(&matches, 0) == 0;- In
Dwarf.c:28:
DwarfLines lines;
bool built = DwarfLinesBuildFromElf(&lines, &elf, ALLOCATOR_OF(&alloc));
bool ok = built && VecLen(&lines.entries) > 0;
if (built)- In
Dwarf.c:171:
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
ProcMaps.c:17:
// 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:22:
// 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; }
ok = ok && VecLen(&v) == 4096 && VecAt(&v, 0) == 0 && VecAt(&v, 4095) == 4095;
VecDeinit(&v);
ArenaAllocatorDeinit(&arena);- In
Graph.Init.c:25:
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
Graph.Init.c:49:
// 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
Graph.Init.c:51:
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
Graph.Init.c:53:
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
Graph.Init.c:60:
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
Graph.Init.c:61:
result = result && (slot->flags == 0);
result = result && (VecLen(&slot->out_neighbors) == 0);
result = result && (VecLen(&slot->in_neighbors) == 0);
} 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
Vec.Init.c:52:
// 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
Vec.Init.c:64:
// 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
Vec.Init.c:86:
// 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
Vec.Init.c:98:
// 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
Vec.Init.c:120:
// 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
Vec.Init.c:142:
// 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
Vec.Init.c:219:
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
Vec.Init.c:228:
VecPushBackR(&vec, 30);
if (VecLen(&vec) != 3 || VecAt(&vec, 0) != 10 || VecAt(&vec, 1) != 20 || VecAt(&vec, 2) != 30) {
result = false;
}- In
Vec.Init.c:235:
// 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
Vec.Init.c:245:
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
Vec.Init.c:263:
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
Vec.Init.c:272:
VecInitStack(int, breakable, 8) {
VecPushBackR(&breakable, 1);
if (VecLen(&breakable) != 1) {
result = false;
}- In
Vec.Init.c:298:
// 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
Vec.Init.c:302:
// 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
Vec.Init.c:307:
// Check the actual data
if (result) {
for (size i = 0; i < VecLen(&src); i++) {
if (VecAt(&clone, i) != VecAt(&src, i)) {
result = false;- In
Vec.Memory.c:41:
// 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
Vec.Memory.c:44:
// Check that the data is still intact
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Vec.Memory.c:72:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Resize to a smaller length
- In
Vec.Memory.c:78:
// Length should now be 3
result = result && (VecLen(&vec) == 3);
// First 3 elements should be unchanged
- In
Vec.Memory.c:89:
// Length should now be 8
result = result && (VecLen(&vec) == 8);
// First 3 elements should still be the same
- In
Vec.Memory.c:123:
// Length should still be 0
result = result && (VecLen(&vec) == 0);
// Add some data
- In
Vec.Memory.c:135:
// Length should now be 5
result = result && (VecLen(&vec) == 5);
// Reserve less space (should be a no-op)
- In
Vec.Memory.c:167:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Remember the capacity
- In
Vec.Memory.c:176:
// Length should now be 0
result = result && (VecLen(&vec) == 0);
// Capacity should remain the same
- In
Vec.Remove.c:45:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Pop from the back
- In
Vec.Remove.c:55:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements
- In
Vec.Remove.c:58:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Vec.Remove.c:69:
// Check new length
result = result && (VecLen(&vec) == 3);
// Clean up
- In
Vec.Remove.c:93:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Pop from the front
- In
Vec.Remove.c:103:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements
- In
Vec.Remove.c:106:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i + 1]);
}- In
Vec.Remove.c:117:
// Check new length
result = result && (VecLen(&vec) == 3);
// Clean up
- In
Vec.Remove.c:141:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Delete element at index 2 (value 30)
- In
Vec.Remove.c:147:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 40, 50])
- In
Vec.Remove.c:151:
// 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
Vec.Remove.c:159:
// Check new length
result = result && (VecLen(&vec) == 3);
// Check remaining elements (should be [20, 40, 50])
- In
Vec.Remove.c:163:
// 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
Vec.Remove.c:189:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Delete element at index 1 (value 20) using fast delete
- In
Vec.Remove.c:195:
// Check new length
result = result && (VecLen(&vec) == 4);
// With fast delete, the last element is moved to the deleted position
- In
Vec.Remove.c:200:
// 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
Vec.Remove.c:226:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Delete range from index 2 to 4 (values 30, 40, 50)
- In
Vec.Remove.c:232:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 60, 70])
- In
Vec.Remove.c:236:
// 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
Vec.Remove.c:261:
// Initial length should be 10
bool result = (VecLen(&vec) == 10);
// Print before state
- In
Vec.Remove.c:265:
// Print before state
WriteFmt("Before fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:277:
int end_values[3];
for (int i = 0; i < count; i++) {
end_values[i] = VecAt(&vec, VecLen(&vec) - count + i);
}- In
Vec.Remove.c:284:
// Print after state
WriteFmt("After fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:290:
// Check length after deletion
result = result && (VecLen(&vec) == 7);
// Check that the last 3 elements moved to the deleted positions
- In
Vec.Remove.c:299:
// 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
Vec.Remove.c:338:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Delete the last element
- In
Vec.Remove.c:344:
// Check new length
result = result && (VecLen(&vec) == 4);
// Check remaining elements
- In
Vec.Remove.c:347:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Vec.Remove.c:355:
// Check new length
result = result && (VecLen(&vec) == 3);
// Check remaining elements
- In
Vec.Remove.c:358:
// Check remaining elements
for (u64 i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Vec.Remove.c:383:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Test L-value delete operation
- In
Vec.Remove.c:390:
// Check vector after L-value deletion
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 40, 50])
- In
Vec.Remove.c:394:
// 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
Vec.Remove.c:419:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Test R-value delete operation
- In
Vec.Remove.c:425:
// Check vector after deletion
result = result && (VecLen(&vec) == 4);
// Check remaining elements (should be [10, 20, 40, 50])
- In
Vec.Remove.c:429:
// 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
Vec.Remove.c:454:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Print before state
- In
Vec.Remove.c:458:
// Print before state
WriteFmt("Before L-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:466:
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
Vec.Remove.c:471:
// Print after state
WriteFmt("After L-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:477:
// Check vector after L-value fast deletion
result = result && (VecLen(&vec) == 4);
// Verify the deleted value is no longer present
- In
Vec.Remove.c:481:
// 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
Vec.Remove.c:502:
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
Vec.Remove.c:535:
// Initial length should be 5
bool result = (VecLen(&vec) == 5);
// Print before state
- In
Vec.Remove.c:539:
// Print before state
WriteFmt("Before R-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:546:
// 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
Vec.Remove.c:553:
// Print after state
WriteFmt("After R-value fast delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:559:
// Check length
result = result && (VecLen(&vec) == 4);
// Verify the deleted value is no longer present
- In
Vec.Remove.c:563:
// 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
Vec.Remove.c:579:
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
Vec.Remove.c:612:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Test L-value delete range operation
- In
Vec.Remove.c:620:
// Check vector after L-value range deletion
result = result && (VecLen(&vec) == 4);
// Expected result: [10, 20, 60, 70]
- In
Vec.Remove.c:624:
// 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
Vec.Remove.c:649:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Test R-value delete range operation
- In
Vec.Remove.c:655:
// Check vector after R-value range deletion
result = result && (VecLen(&vec) == 4);
// Expected result: [10, 20, 60, 70]
- In
Vec.Remove.c:659:
// 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
Vec.Remove.c:684:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Print before state
- In
Vec.Remove.c:688:
// Print before state
WriteFmt("Before L-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:703:
// Print after state
WriteFmt("After L-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:709:
// Check vector after L-value fast range deletion
result = result && (VecLen(&vec) == 4);
// Verify the deleted values are no longer present
- In
Vec.Remove.c:714:
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
Vec.Remove.c:730:
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
Vec.Remove.c:763:
// Initial length should be 7
bool result = (VecLen(&vec) == 7);
// Print before state
- In
Vec.Remove.c:767:
// Print before state
WriteFmt("Before R-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:780:
// Print after state
WriteFmt("After R-value fast range delete: ");
for (u64 i = 0; i < VecLen(&vec); i++) {
WriteFmt("{} ", VecAt(&vec, i));
}- In
Vec.Remove.c:786:
// Check vector after R-value fast range deletion
result = result && (VecLen(&vec) == 4);
// Verify the deleted values are no longer present
- In
Vec.Remove.c:791:
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
Vec.Remove.c:807:
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; 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;- In
Str.Type.c:60:
// Check that it behaves like a Vec of Str objects
bool result = (VecLen(&sv) == 2);
// Check the content of the strings
// Check initial state
bool result =
(VecLen(&vec) == 0 && VecCapacity(&vec) == 0 && VecBegin(&vec) == NULL &&
VecCopyInit(&vec) == (GenericCopyInit)ComplexItemCopyInit &&
VecCopyDeinit(&vec) == (GenericCopyDeinit)ComplexItemDeinit);
// Check that the vector now has one item
result = result && (VecLen(&vec) == 1);
// Check that the item was copied correctly
// Check vector length
bool result = (VecLen(&vec) == 3);
// Check items order: item2, item1, item3
// Check vector length
bool result = (VecLen(&vec) == 3);
// Check items order: item2, item3, item1
// Check vector lengths
bool result = (VecLen(&vec1) == 3);
result = result && (VecLen(&vec2) == 2); // VecMergeR doesn't modify source vector
// 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
// Check vector lengths
result = result && (VecLen(&vec3) == 2);
result = result && (VecLen(&vec4) == 0); // VecMergeL resets source vector
result = result && (VecBegin(&vec4) == NULL); // Check vector lengths
result = result && (VecLen(&vec3) == 2);
result = result && (VecLen(&vec4) == 0); // VecMergeL resets source vector
result = result && (VecBegin(&vec4) == NULL);
// Check vector length
bool result = (VecLen(&vec) == 3);
// Check items order: val2, val3, val1
// Check vector length
result = result && (VecLen(&vec) == 6);
// Check items: val2, val3, val1, arr[0], arr[1], arr[2]
// Check vector length
bool result = (VecLen(&vec) == 6);
// Check that the element was inserted
// Check vector length
result = result && (VecLen(&vec) == 9);
// Check that the array was inserted
// 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
VecInsertFastR(&vec2, single_val, 2);
result = result && (VecLen(&vec2) == 6);
result = result && (VecAt(&vec2, 2) == 42);
// Check vector length
result = result && (VecLen(&vec2) == 8);
// Check that the array was inserted
// Check vector length after deletion
bool result = (VecLen(&vec) == 8);
// Check that the element was deleted and elements shifted
// Check vector length after range deletion
result = result && (VecLen(&vec) == 6);
// Check that elements were deleted and remaining elements shifted
// Check vector length after fast deletion
result = result && (VecLen(&vec) == 8);
// Check that the element was deleted and replaced with the last element (90)
// Check vector length after fast range deletion
result = result && (VecLen(&vec) == 6);
// Check that elements were deleted and replaced with elements from the end
// Check vector length after deletion
result = result && (VecLen(&vec) == 8);
// Check that the element was deleted
// Test pushing to empty vector
VecPushBackR(&vec, 10);
bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 10);
// Test pushing with zero count
int small_arr[1] = {42};
VecPushBackArrR(&vec, small_arr, 0);
result = result && (VecLen(&vec) == 1); // Length should not change
// Test inserting at end index
// Test inserting at end index
VecInsertR(&vec, 20, VecLen(&vec));
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 1) == 20); // 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
}
result = result && (VecLen(&vec) == large_count);
// Verify all elements
// Push an element (should auto-resize)
VecPushBackR(&vec, 42);
result = result && (VecLen(&vec) == 1 && VecAt(&vec, 0) == 42);
// Clean up
int values3[] = {70, 80, 90};
ComplexItem item3 = InitComplexItem("Fast Item 3", values3, 3);
VecInsertFastL(&vec, item3, VecLen(&vec));
// Check that the item was zeroed
// Verify vector integrity - should have 6 items now
result = result && (VecLen(&vec) == 6);
// Clean up the vector
// Check that vec2 is now empty (data has been transferred)
result = result && (VecLen(&vec2) == 0);
result = result && (VecBegin(&vec2) == NULL);- In
Vec.Access.c:168:
// Test VecSize and VecLen functions
bool test_vec_size_len(void) {
WriteFmt("Testing VecSize and VecLen\n");
DefaultAllocator alloc = DefaultAllocatorInit();- In
Vec.Access.c:179:
// 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
Vec.Access.c:190:
// 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
Vec.Access.c:191:
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
Vec.Access.c:193:
size aligned_offset = VecAlignedOffsetAt(&vec, VecLen(&vec));
result = result && (vec_size == aligned_offset);
result = result && (vec_len == VecLen(&vec));
// Clean up
- In
Vec.Access.c:208:
// Check size and length with alignment
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
Vec.Access.c:209:
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
Vec.Access.c:211:
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
Pdb.c:293:
}
ok = VecLen(&pdb.functions) == 1;
if (ok) {
const PdbFunction *f = VecPtrAt(&pdb.functions, 0);- In
Vec.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
Vec.Type.c:43:
// 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
Vec.Insert.c:40:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in order
- In
Vec.Insert.c:43:
// Check elements in order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Vec.Insert.c:68:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in reverse order (since we pushed to front)
- In
Vec.Insert.c:71:
// 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
Vec.Insert.c:93:
// Check first element
bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 10);
// Insert at the end
- In
Vec.Insert.c:99:
// Check elements
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 0) == 10 && VecAt(&vec, 1) == 30);
// Insert in the middle
- In
Vec.Insert.c:105:
// Check all elements
result = result && (VecLen(&vec) == 3);
result = result && (VecAt(&vec, 0) == 10);
result = result && (VecAt(&vec, 1) == 20);- In
Vec.Insert.c:129:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in order
- In
Vec.Insert.c:132:
// Check elements in order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Vec.Insert.c:141:
// Check length
result = result && (VecLen(&vec) == 8);
// Check all elements
- In
Vec.Insert.c:170:
// Check length
bool result = (VecLen(&vec) == 5);
// Check elements in order
- In
Vec.Insert.c:173:
// Check elements in order
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == values[i]);
}- In
Vec.Insert.c:182:
// Check length
result = result && (VecLen(&vec) == 8);
// Check all elements
- In
Vec.Insert.c:215:
// Check length
bool result = (VecLen(&vec) == 5);
// Expected result: [10, 30, 40, 50, 20]
- In
Vec.Insert.c:221:
// Check all elements
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Vec.Insert.c:249:
// Insert range in the middle
VecInsertRangeR(&vec, VecBegin(&src), 1, VecLen(&src));
// Check length
- In
Vec.Insert.c:252:
// Check length
bool result = (VecLen(&vec) == 6);
// Expected result: [10, 40, 50, 60, 20, 30]
- In
Vec.Insert.c:258:
// Check all elements
for (size i = 0; i < VecLen(&vec); i++) {
result = result && (VecAt(&vec, i) == expected[i]);
}- In
Vec.Insert.c:292:
// Check lengths
bool result = (VecLen(&vec1) == 6);
result = result && (VecLen(&vec2) == 3); // VecMergeR doesn't modify source vector
- In
Vec.Insert.c:293:
// 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
Vec.Insert.c:299:
// Check all elements in vec1
for (size i = 0; i < VecLen(&vec1); i++) {
result = result && (VecAt(&vec1, i) == expected[i]);
}- In
Vec.Insert.c:339:
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
Vec.Insert.c:345:
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
Vec.Insert.c:346:
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
Vec.Insert.c:367:
// Check that the element was added
bool result = (VecLen(&vec) == 1 && VecAt(&vec, 0) == 42);
// Test L-value insert operations
- In
Vec.Insert.c:374:
// Check that the element was added
result = result && (VecLen(&vec) == 2 && VecAt(&vec, 1) == 100);
// Test R-value insert at index
- In
Vec.Insert.c:380:
// Check that the element was inserted
result = result && (VecLen(&vec) == 3);
result = result && (VecAt(&vec, 0) == 42);
result = result && (VecAt(&vec, 1) == 50);- In
Vec.Insert.c:390:
// Check that the element was inserted
result = result && (VecLen(&vec) == 4);
result = result && (VecAt(&vec, 0) == 42);
result = result && (VecAt(&vec, 1) == 50);- In
Vec.Insert.c:400:
// Check that the element was inserted
result = result && (VecLen(&vec) == 5);
result = result && (VecAt(&vec, 1) == 60);- In
Vec.Insert.c:408:
// Check that the element was inserted
result = result && (VecLen(&vec) == 6);
result = result && (VecAt(&vec, 3) == 80);- In
Vec.Insert.c:418:
// Check that the elements were added
result = result && (VecLen(&vec) == 9);
result = result && (VecAt(&vec, 6) == 200);
result = result && (VecAt(&vec, 7) == 300);- In
Vec.Insert.c:427:
// Check that the elements were added
result = result && (VecLen(&vec) == 12);
result = result && (VecAt(&vec, 0) == 200);
result = result && (VecAt(&vec, 1) == 300);- In
Vec.Insert.c:504:
// Check that the source vector is cleared
result = result && (VecLen(&vec2) == 0);
result = result && (VecBegin(&vec2) == NULL);- In
Vec.Insert.c:537:
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
Vec.Insert.c:550:
// [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
Dns.c:156:
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:221:
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:292:
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
Pe.c:169:
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
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:164:
/// TAGS: Vec, Empty, Query
///
#define VecEmpty(v) (VecLen(v) == 0)
///
- In
Access.h:27:
/// TAGS: Str, Length, Query
///
#define StrLen(str) VecLen(str)
///
Last updated on