StrDeinit
Description
Release the backing storage of str through its inline allocator and zero the handle so a later double-Deinit is a no-op.
Success
Returns to the caller. *str is zeroed.
Failure
Function cannot fail. NULL str is a no-op.
Usage example (Cross-references)
Usage examples (Cross-references)
- In
Log.h:46:
StrAppendFmt(&UNPL(m), __VA_ARGS__); \
LogWrite(LOG_MESSAGE_TYPE_FATAL, __func__, __LINE__, StrBegin(&UNPL(m))); \
StrDeinit(&UNPL(m)); \
HeapAllocatorDeinit(&UNPL(log_alloc)); \
Abort(); \
- In
Log.h:70:
StrAppendFmt(&UNPL(m), __VA_ARGS__); \
LogWrite(LOG_MESSAGE_TYPE_ERROR, __func__, __LINE__, StrBegin(&UNPL(m))); \
StrDeinit(&UNPL(m)); \
HeapAllocatorDeinit(&UNPL(log_alloc)); \
} while (0)- In
Log.h:93:
StrAppendFmt(&UNPL(m), __VA_ARGS__); \
LogWrite(LOG_MESSAGE_TYPE_INFO, __func__, __LINE__, StrBegin(&UNPL(m))); \
StrDeinit(&UNPL(m)); \
HeapAllocatorDeinit(&UNPL(log_alloc)); \
} while (0)- In
Log.h:132:
} \
LogWrite(LOG_MESSAGE_TYPE_FATAL, __func__, __LINE__, StrBegin(&UNPL(m))); \
StrDeinit(&UNPL(m)); \
HeapAllocatorDeinit(&UNPL(log_alloc)); \
Abort(); \
- In
Log.h:161:
} \
LogWrite(LOG_MESSAGE_TYPE_ERROR, __func__, __LINE__, StrBegin(&UNPL(m))); \
StrDeinit(&UNPL(m)); \
HeapAllocatorDeinit(&UNPL(log_alloc)); \
} while (0)- In
Log.h:189:
} \
LogWrite(LOG_MESSAGE_TYPE_INFO, __func__, __LINE__, StrBegin(&UNPL(m))); \
StrDeinit(&UNPL(m)); \
HeapAllocatorDeinit(&UNPL(log_alloc)); \
} while (0)- In
PdbCache.h:34:
typedef struct PdbCacheEntry {
Str module_path; // owned; cleaned via StrDeinit
Pe pe;
Pdb pdb;- In
Proc.h:290:
Zstr UNPL(in) = StrBegin(&UNPL(buf)); \
StrReadFmt(UNPL(in), __VA_ARGS__); \
StrDeinit(&UNPL(buf)); \
} while (0)- In
Proc.h:317:
Zstr UNPL(in) = StrBegin(&UNPL(buf)); \
StrReadFmt(UNPL(in), __VA_ARGS__); \
StrDeinit(&UNPL(buf)); \
} while (0)- In
Proc.h:343:
StrAppendFmt(&UNPL(buf), __VA_ARGS__); \
ProcWriteToStdin((p), &UNPL(buf)); \
StrDeinit(&UNPL(buf)); \
} while (0)- In
Proc.h:369:
StrPushBackR(&UNPL(buf), '\n'); \
ProcWriteToStdin((p), &UNPL(buf)); \
StrDeinit(&UNPL(buf)); \
} while (0)- In
JSON.h:576:
if (StrIterIndex(&UNPL(read_si)) == StrIterIndex(&si)) { \
LOG_ERROR("Failed to read string key in object. Invalid JSON"); \
StrDeinit(&key); \
UNPL(failed) = true; \
si = UNPL(saved_si); \
- In
JSON.h:588:
if (!StrIterPeek(&si, &UNPL(jr_c)) || UNPL(jr_c) != ':') { \
LOG_ERROR("Expected ':' after key string. Failed to read JSON"); \
StrDeinit(&key); \
UNPL(failed) = true; \
si = UNPL(saved_si); \
- In
JSON.h:610:
if (StrIterIndex(&UNPL(read_si)) == StrIterIndex(&si)) { \
LOG_ERROR("Failed to parse value. Invalid JSON."); \
StrDeinit(&key); \
UNPL(failed) = true; \
si = UNPL(saved_si); \
- In
JSON.h:619:
si = UNPL(read_si); \
} \
StrDeinit(&key); \
si = JSkipWhitespace(si); \
\
- In
VecStr.c:460:
Str str = generate_str_from_input(data, offset, data_size, 16, alloc);
VecPushBack(&temp, str);
StrDeinit(&str);
}- In
Log.c:72:
FormatStackTrace(&trace, frames, n, ALLOCATOR_OF(&h));
(void)FileWrite(&out, StrBegin(&trace), StrLen(&trace));
StrDeinit(&trace);
}
#else- In
Log.c:87:
#endif
StrDeinit(&full);
HeapAllocatorDeinit(&h);
}- In
ArgParse.c:361:
FWriteFmtLn(&err, "{}", usage);
StrDeinit(&usage);
FWriteFmtLn(&err, "");- In
ArgParse.c:414:
for (u64 i = 0; i < n_specs; ++i) {
StrDeinit(&left_col[i]);
}
}- In
Io.c:514:
}
}
StrDeinit(&tmp);
DefaultAllocatorDeinit(&scratch);
return ok;- In
Io.c:553:
}
StrDeinit(&out);
DefaultAllocatorDeinit(&scratch);
return ok;- In
Io.c:1121:
}
}
StrDeinit(&tmp);
DefaultAllocatorDeinit(&scratch);
return ok;- In
Io.c:1158:
if (end_pos < 0) {
LOG_ERROR("FileSeek(END) failed during f_read_fmt");
StrDeinit(&buffer);
DefaultAllocatorDeinit(&scratch);
return;- In
Io.c:1170:
if (got < 0) {
LOG_ERROR("FileRead failed during f_read_fmt");
StrDeinit(&buffer);
DefaultAllocatorDeinit(&scratch);
return;- In
Io.c:1190:
}
StrDeinit(&buffer);
DefaultAllocatorDeinit(&scratch);
}- In
Io.c:1413:
}
StrDeinit(&canonical);
*out = result;
return true;- In
Io.c:1438:
}
StrDeinit(&canonical);
*out = result;
return true;- In
Io.c:1444:
fail:
StrDeinit(&canonical);
StrDeinit(&result);
return false;- In
Io.c:1445:
fail:
StrDeinit(&canonical);
StrDeinit(&result);
return false;
}- In
Io.c:1496:
goto fail;
}
StrDeinit(&digits);
*out = result;
return true;- In
Io.c:1533:
goto fail;
}
StrDeinit(&digits);
*out = result;
return true;- In
Io.c:1538:
fail:
StrDeinit(&digits);
StrDeinit(&result);
return false;- In
Io.c:1539:
fail:
StrDeinit(&digits);
StrDeinit(&result);
return false;
}- In
Io.c:2280:
if (!StrMerge(o, &temp)) {
StrDeinit(&temp);
return false;
}- In
Io.c:2283:
return false;
}
StrDeinit(&temp);
if (fmt_info->width > 0) {- In
Io.c:2397:
char c = ZstrProcessEscape(&curr);
if (c == 0) {
StrDeinit(s);
return NULL;
}- In
Io.c:2436:
char c = ZstrProcessEscape(&curr);
if (c == 0) {
StrDeinit(s);
return NULL;
}- In
Io.c:2463:
if (quote) {
LOG_ERROR("Unterminated quoted string");
StrDeinit(s);
return NULL;
}- In
Io.c:2686:
// the digit-by-digit scan below.
if (StrToF64(&temp, v, NULL)) {
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return StrIterDataAt(&si, StrIterIndex(&si));- In
Io.c:2690:
return StrIterDataAt(&si, StrIterIndex(&si));
}
StrDeinit(&temp);
si = saved;- In
Io.c:2743:
if (!is_valid_numeric_string(&temp, true)) {
LOG_ERROR("Invalid floating point format");
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start;- In
Io.c:2750:
if (!StrToF64(&temp, v, NULL)) {
LOG_ERROR("Failed to parse f64");
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start;- In
Io.c:2755:
}
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start + pos;- In
Io.c:2809:
StrBegin(&temp)[1] == 'B' || StrBegin(&temp)[1] == 'o' || StrBegin(&temp)[1] == 'O')) {
LOG_ERROR("Incomplete number format");
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start;- In
Io.c:2816:
if (!is_valid_numeric_string(&temp, false)) {
LOG_ERROR("Invalid numeric format");
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start;- In
Io.c:2827:
if (!StrToU64(&temp, &val, NULL)) {
LOG_ERROR("Failed to parse u8");
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start;- In
Io.c:2834:
if (val > UINT8_MAX) {
LOG_ERROR("Value {} exceeds u8 maximum ({})", val, UINT8_MAX);
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start;- In
Io.c:2840:
*v = (u8)val;
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start + pos;- In
Io.c:2916:
StrBegin(&temp)[1] == 'B' || StrBegin(&temp)[1] == 'o' || StrBegin(&temp)[1] == 'O')) { \
LOG_ERROR("Incomplete number format"); \
StrDeinit(&temp); \
DefaultAllocatorDeinit(&scratch); \
return start; \
- In
Io.c:2923:
if (!is_valid_numeric_string(&temp, false)) { \
LOG_ERROR("Invalid numeric format"); \
StrDeinit(&temp); \
DefaultAllocatorDeinit(&scratch); \
return start; \
- In
Io.c:2931:
if (!PARSER(&temp, &val, NULL)) { \
LOG_ERROR("Failed to parse " #NAME); \
StrDeinit(&temp); \
DefaultAllocatorDeinit(&scratch); \
return start; \
- In
Io.c:2939:
\
*v = (T)val; \
StrDeinit(&temp); \
DefaultAllocatorDeinit(&scratch); \
return start + pos; \
- In
Io.c:2948:
if (val > UMAX) { \
LOG_ERROR("Value {} exceeds " #NAME " maximum ({})", val, UMAX); \
StrDeinit(&temp); \
DefaultAllocatorDeinit(&scratch); \
return start; \
- In
Io.c:2957:
if (val > IMAX || val < IMIN) { \
LOG_ERROR("Value {} outside " #NAME " range ({} to {})", val, IMIN, IMAX); \
StrDeinit(&temp); \
DefaultAllocatorDeinit(&scratch); \
return start; \
- In
Io.c:3014:
next = _read_Str(i, &default_fmt, &temp);
if (next == i) {
StrDeinit(&temp);
return i;
}- In
Io.c:3024:
if (!result) {
LOG_ERROR("Failed to allocate memory for string");
StrDeinit(&temp);
return i;
}- In
Io.c:3033:
*out = result;
StrDeinit(&temp);
return next;
}- In
Io.c:3093:
}
if (!StrMerge(o, &bit_str)) {
StrDeinit(&bit_str);
return false;
}- In
Io.c:3096:
return false;
}
StrDeinit(&bit_str);
}
}- In
Io.c:3159:
if (!StrMerge(o, &temp)) {
StrDeinit(&temp);
return false;
}- In
Io.c:3162:
return false;
}
StrDeinit(&temp);
if (fmt_info->width > 0) {- In
Io.c:3229:
if (!StrToU64(&hex_str, &value, &config)) {
LOG_ERROR("Failed to parse hex value");
StrDeinit(&hex_str);
return start;
}- In
Io.c:3241:
*bv = BitVecFromInteger(value, bit_len, BitVecAllocator(bv));
StrDeinit(&hex_str);
return StrIterDataAt(&si, StrIterIndex(&si));
}- In
Io.c:3270:
if (!StrToU64(&oct_str, &value, &config)) {
LOG_ERROR("Failed to parse octal value");
StrDeinit(&oct_str);
return start;
}- In
Io.c:3279:
*bv = BitVecFromInteger(value, bit_len, BitVecAllocator(bv));
StrDeinit(&oct_str);
return StrIterDataAt(&si, StrIterIndex(&si));
}- In
Io.c:3303:
*bv = BitVecFromStr(StrBegin(&bin_str), BitVecAllocator(bv));
StrDeinit(&bin_str);
return StrIterDataAt(&si, StrIterIndex(&si));
}- In
Io.c:3383:
if (!ok) {
StrDeinit(&temp);
return start;
}- In
Io.c:3390:
*value = parsed;
StrDeinit(&temp);
return StrIterDataAt(&si, StrIterIndex(&si));
}- In
Io.c:3411:
if (float_fmt_uses_unsupported_flags(fmt_info)) {
LOG_ERROR("Float only supports decimal and scientific reading");
StrDeinit(&temp);
FloatDeinit(&parsed);
return i;- In
Io.c:3427:
if (!StrIterRemainingLength(&si)) {
LOG_ERROR("Failed to parse Float: empty input");
StrDeinit(&temp);
FloatDeinit(&parsed);
return StrIterDataAt(&si, StrIterIndex(&si));- In
Io.c:3437:
if (token_len == 0) {
LOG_ERROR("Failed to parse Float");
StrDeinit(&temp);
FloatDeinit(&parsed);
return start;- In
Io.c:3442:
}
StrDeinit(&temp);
temp = StrInitFromCstr(start, token_len, FloatAllocator(value));
if (!FloatTryFromStr(&parsed, StrBegin(&temp))) {- In
Io.c:3445:
temp = StrInitFromCstr(start, token_len, FloatAllocator(value));
if (!FloatTryFromStr(&parsed, StrBegin(&temp))) {
StrDeinit(&temp);
FloatDeinit(&parsed);
return start;- In
Io.c:3453:
*value = parsed;
StrDeinit(&temp);
return start + token_len;
}- In
Io.c:3507:
if (StrToF64(&temp, &val, NULL)) {
*v = (f32)val;
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return StrIterDataAt(&si, StrIterIndex(&si));- In
Io.c:3511:
return StrIterDataAt(&si, StrIterIndex(&si));
}
StrDeinit(&temp);
si = saved;- In
Io.c:3561:
if (!is_valid_numeric_string(&temp, true)) {
LOG_ERROR("Invalid floating point format");
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start;- In
Io.c:3571:
if (!StrToF64(&temp, &val, NULL)) {
LOG_ERROR("Failed to parse f32");
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start;- In
Io.c:3577:
*v = (f32)val;
StrDeinit(&temp);
DefaultAllocatorDeinit(&scratch);
return start + pos;- In
Str.c:154:
}
void StrDeinit(Str *copy) {
ValidateStr(copy);
deinit_vec(GENERIC_VEC(copy), sizeof(char));- In
Str.c:161:
void str_deinit(void *copy, const Allocator *alloc) {
(void)alloc;
StrDeinit((Str *)copy);
}- In
Int.c:797:
IntDeinit(&remainder);
IntDeinit(¤t);
StrDeinit(&result);
return false;
}- In
Int.c:810:
IntDeinit(&remainder);
IntDeinit(¤t);
StrDeinit(&result);
return false;
}- In
Int.c:824:
IntDeinit(&remainder);
IntDeinit(¤t);
StrDeinit(&result);
return false;
}- In
Float.c:596:
result.exponent = explicit_exp - fractional;
StrDeinit(&digits);
float_normalize(&result);
FloatDeinit(out);- In
Float.c:603:
fail:
StrDeinit(&digits);
FloatDeinit(&result);
return false;- In
Float.c:709:
}
StrDeinit(&digits);
*out = result;
return true;- In
Float.c:714:
fail:
StrDeinit(&digits);
StrDeinit(&result);
return false;- In
Float.c:715:
fail:
StrDeinit(&digits);
StrDeinit(&result);
return false;
}- In
BitVec.c:905:
char bit_char = BitVecGet(bv, i) ? '1' : '0';
if (!StrPushBackR(out, bit_char)) {
StrDeinit(out);
*out = StrInit(alloc);
return false;- In
BitVec.c:1921:
}
StrDeinit(&bv_str);
return result;
}- In
BitVec.c:1938:
}
StrDeinit(&bv_str);
return result;
}- In
Debug.c:299:
#endif
LOG_ERROR(" {} trace:\n{}", label, rendered);
StrDeinit(&rendered);
}- In
Dir.c:57:
}
StrDeinit(©->name);
copy->type = 0; if (sys_path_exists(StrBegin(&path)) && ElfOpen(out, &path, alloc)) {
if (sidecar_matches(main, out, /*by_build_id*/ true)) {
StrDeinit(&path);
return true;
} if (sys_path_exists(StrBegin(&path)) && ElfOpen(out, &path, alloc)) {
if (sidecar_matches(main, out, /*by_build_id*/ false)) {
StrDeinit(&path);
return true;
} if (sys_path_exists(StrBegin(&path)) && ElfOpen(out, &path, alloc)) {
if (sidecar_matches(main, out, /*by_build_id*/ false)) {
StrDeinit(&path);
return true;
} if (sys_path_exists(StrBegin(&path)) && ElfOpen(out, &path, alloc)) {
if (sidecar_matches(main, out, /*by_build_id*/ false)) {
StrDeinit(&path);
return true;
} }
StrDeinit(&path);
return false;
}- In
PdbCache.c:71:
Str pdb_path = StrInit(alloc);
if (!find_pdb(&entry->pe, StrBegin(&entry->module_path), &pdb_path)) {
StrDeinit(&pdb_path);
return false;
}- In
PdbCache.c:75:
}
bool ok = PdbOpen(&entry->pdb, &pdb_path, alloc);
StrDeinit(&pdb_path);
if (!ok)
return false;- In
PdbCache.c:108:
if (!VecPushBackR(&self->entries, entry)) {
StrDeinit(&entry.module_path);
return NULL;
}- In
PdbCache.c:127:
if (e->pe_open)
PeDeinit(&e->pe);
StrDeinit(&e->module_path);
}
VecDeinit(&self->entries);- In
Dns.c:157:
Str buf = StrInit(alloc);
if (!slurp_file(path, &buf)) {
StrDeinit(&buf);
return;
}- In
Dns.c:230:
// failure ownership of `e.name` stays with us. Release
// it to avoid leaking the cstr allocation.
StrDeinit(&e.name);
break;
}- In
Dns.c:239:
}
StrDeinit(&buf);
}- In
Dns.c:252:
Str buf = StrInit(alloc);
if (!slurp_file(path, &buf)) {
StrDeinit(&buf);
return;
}- In
Dns.c:303:
}
StrDeinit(&buf);
}- In
Dns.c:346:
StrPushBackMany(&buf, path, len);
bool ok = dns_add_path(self, StrBegin(&buf), do_hosts, do_resolv);
StrDeinit(&buf);
return ok;
}- In
Dns.c:419:
if (VecBegin(&self->hosts)) {
VecForeachPtr(&self->hosts, e) {
StrDeinit(&e->name);
}
VecDeinit(&self->hosts);- In
MachoCache.c:54:
if (!VecPushBackR(&self->entries, entry)) {
StrDeinit(&entry.module_path);
return NULL;
}- In
MachoCache.c:85:
Str path = StrInit(alloc);
if (!compose_dsym_path(StrBegin(&e->module_path), &path)) {
StrDeinit(&path);
return false;
}- In
MachoCache.c:89:
}
if (!sys_path_exists(StrBegin(&path)) || !MachoOpen(&e->dsym, &path, alloc)) {
StrDeinit(&path);
return false;
}- In
MachoCache.c:92:
return false;
}
StrDeinit(&path);
if (!MachoHasUuid(&e->dsym) || MemCompare(MachoUuid(&e->dsym), MachoUuid(&e->main), 16) != 0) {- In
MachoCache.c:141:
if (e->main_open)
MachoDeinit(&e->main);
StrDeinit(&e->module_path);
}
VecDeinit(&self->entries);- In
Proc.c:233:
if (!CreateProcessA(NULL, StrBegin(&cmdline), NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) {
LOG_ERROR("CreateProcessA() failed (GetLastError={})", (i32)GetLastError());
StrDeinit(&cmdline);
CloseHandle(hStdinRead);
CloseHandle(hStdinWrite);- In
Proc.c:242:
return proc;
}
StrDeinit(&cmdline);
CloseHandle(hStdinRead);- In
DwarfInfo.c:684:
VecDeinit(&self->entries);
if (StrAllocator(&self->string_pool))
StrDeinit(&self->string_pool);
MemSet(self, 0, sizeof(*self));
}- In
Dns.c:299:
Str dummy = StrInit(alloc);
if (!decode_name(&it, &dummy)) {
StrDeinit(&dummy);
return false;
}- In
Dns.c:302:
return false;
}
StrDeinit(&dummy);
u16 qtype, qclass;
if (!BufReadFmt(&it, "{>2r}{>2r}", qtype, qclass)) {- In
Dns.c:324:
return;
}
StrDeinit(&self->name);
StrDeinit(&self->target);
VecDeinit(&self->rdata);- In
Dns.c:325:
}
StrDeinit(&self->name);
StrDeinit(&self->target);
VecDeinit(&self->rdata);
}- In
KvConfig.c:215:
if (StrLen(value) > 0) {
Str stripped = StrStrip(value, NULL);
StrDeinit(value);
*value = stripped;
}- In
KvConfig.c:306:
if (!StrIterPeek(&si, &c)) {
StrDeinit(&key);
StrDeinit(&value);
break;- In
KvConfig.c:307:
if (!StrIterPeek(&si, &c)) {
StrDeinit(&key);
StrDeinit(&value);
break;
}- In
KvConfig.c:313:
if (kvconfig_is_comment_start(c)) {
si = KvConfigSkipLine(si);
StrDeinit(&key);
StrDeinit(&value);
continue;- In
KvConfig.c:314:
si = KvConfigSkipLine(si);
StrDeinit(&key);
StrDeinit(&value);
continue;
}- In
KvConfig.c:320:
read_si = KvConfigReadPair(si, &key, &value);
if (StrIterIndex(&read_si) == StrIterIndex(&si)) {
StrDeinit(&key);
StrDeinit(&value);
return saved_si;- In
KvConfig.c:321:
if (StrIterIndex(&read_si) == StrIterIndex(&si)) {
StrDeinit(&key);
StrDeinit(&value);
return saved_si;
}- In
KvConfig.c:326:
MapSetOnlyL(cfg, key, value);
StrDeinit(&key);
StrDeinit(&value);
si = read_si;- In
KvConfig.c:327:
MapSetOnlyL(cfg, key, value);
StrDeinit(&key);
StrDeinit(&value);
si = read_si;
}- In
KvConfig.c:351:
lookup = StrInitFromCstr(key, ZstrLen(key), MapAllocator(cfg));
value = kvconfig_get_ptr_str(cfg, &lookup);
StrDeinit(&lookup);
return value;
}- In
Pdb.c:771:
AllocatorFree(alloc, self->stream_block_counts);
}
StrDeinit(&self->name_pool);
VecDeinit(&self->functions);
BufDeinit(&self->data);- In
ProcMaps.c:297:
if (!self)
return;
StrDeinit(&self->raw);
VecDeinit(&self->entries);
MemSet(self, 0, sizeof(*self));- In
Http.c:23:
LOG_FATAL("invalid arguments");
}
StrDeinit(&header->key);
StrDeinit(&header->value);
MemSet(header, 0, sizeof(*header));- In
Http.c:24:
}
StrDeinit(&header->key);
StrDeinit(&header->value);
MemSet(header, 0, sizeof(*header));
}- In
Http.c:31:
(void)alloc; // each Str carries its own allocator handle
HttpHeader *header = (HttpHeader *)header_ptr;
StrDeinit(&header->key);
StrDeinit(&header->value);
MemSet(header, 0, sizeof(*header));- In
Http.c:32:
HttpHeader *header = (HttpHeader *)header_ptr;
StrDeinit(&header->key);
StrDeinit(&header->value);
MemSet(header, 0, sizeof(*header));
}- In
Http.c:47:
if (!StrInitCopy(&dst->key, &src->key)) {
StrDeinit(&dst->key);
return false;
}- In
Http.c:51:
}
if (!StrInitCopy(&dst->value, &src->value)) {
StrDeinit(&dst->key);
StrDeinit(&dst->value);
return false;- In
Http.c:52:
if (!StrInitCopy(&dst->value, &src->value)) {
StrDeinit(&dst->key);
StrDeinit(&dst->value);
return false;
}- In
Http.c:121:
if (cursor == in) {
LOG_ERROR("http request parse failed: invalid request line");
StrDeinit(&method);
StrDeinit(&version);
return in;- In
Http.c:122:
LOG_ERROR("http request parse failed: invalid request line");
StrDeinit(&method);
StrDeinit(&version);
return in;
}- In
Http.c:128:
if (0 != ZstrCompareN(StrBegin(&version), "HTTP/1.1", 8)) {
LOG_ERROR("invalid/unsupported HTTP version");
StrDeinit(&method);
StrDeinit(&version);
return in;- In
Http.c:129:
LOG_ERROR("invalid/unsupported HTTP version");
StrDeinit(&method);
StrDeinit(&version);
return in;
}- In
Http.c:132:
return in;
}
StrDeinit(&version);
req->method = http_request_method_from_str(&method);- In
Http.c:135:
req->method = http_request_method_from_str(&method);
StrDeinit(&method);
if (req->method == HTTP_REQUEST_METHOD_UNKNOWN) {
LOG_ERROR("invalid http request method");- In
Http.c:191:
LOG_FATAL("invalid arguments");
}
StrDeinit(&req->url);
VecDeinit(&req->headers);
MemSet(req, 0, sizeof(*req));- In
Http.c:414:
response->status_code = status;
response->content_type = HTTP_CONTENT_TYPE_TEXT_HTML;
StrDeinit(&response->body);
response->body = StrDup(html, response->allocator);
return response;- In
Http.c:431:
response->status_code = status;
response->content_type = content_type;
StrDeinit(&response->body);
response->body = StrInit(response->allocator);
if (FileReadAndClose(filepath, &response->body) < 0) {- In
Http.c:490:
if (!StrPushBackMany(&out, StrBegin(&response->body), StrLen(&response->body))) {
LOG_ERROR("HttpResponseSerialize: failed to append body");
StrDeinit(&out);
return StrInit(alloc);
}- In
Http.c:501:
LOG_FATAL("invalid arguments");
}
StrDeinit(&response->body);
VecDeinit(&response->headers);
MemSet(response, 0, sizeof(*response));- In
JSON.c:60:
if (StrIterIndex(&read_si) == StrIterIndex(&si)) {
LOG_ERROR("Failed to read string key in object. Invalid JSON");
StrDeinit(&key);
DefaultAllocatorDeinit(&scratch);
return saved_si;- In
JSON.c:69:
if (!StrIterPeek(&si, &c) || c != ':') {
LOG_ERROR("Expected ':' after key string. Failed to read JSON");
StrDeinit(&key);
DefaultAllocatorDeinit(&scratch);
return saved_si;- In
JSON.c:82:
if (StrIterIndex(&read_si) == StrIterIndex(&si)) {
LOG_ERROR("Failed to parse value. Invalid JSON.");
StrDeinit(&key);
DefaultAllocatorDeinit(&scratch);
return saved_si;- In
JSON.c:89:
LOG_INFO("User skipped reading of '{}' field in JSON object.", key);
StrDeinit(&key);
si = read_si;
si = JSkipWhitespace(si);- In
JSON.c:331:
if (has_exp) {
LOG_ERROR("Invalid number. Multiple exponent indicators.");
StrDeinit(&ns);
DefaultAllocatorDeinit(&scratch);
return saved_si;- In
JSON.c:344:
if (is_flt) {
LOG_ERROR("Invalid number. Multiple decimal indicators.");
StrDeinit(&ns);
DefaultAllocatorDeinit(&scratch);
return saved_si;- In
JSON.c:375:
"must appear after exponent 'E' or 'e' indicator."
);
StrDeinit(&ns);
DefaultAllocatorDeinit(&scratch);
return saved_si;- In
JSON.c:384:
"Expected only once after 'e' or 'E'."
);
StrDeinit(&ns);
DefaultAllocatorDeinit(&scratch);
return saved_si;- In
JSON.c:401:
if (!StrLen(&ns)) {
LOG_ERROR("Failed to parse number. '{.8}'", LVAL(StrIterDataAt(&saved_si, StrIterIndex(&saved_si))));
StrDeinit(&ns);
DefaultAllocatorDeinit(&scratch);
return saved_si;- In
JSON.c:415:
if (end == StrBegin(&ns)) {
LOG_ERROR("Failed to convert string to number.");
StrDeinit(&ns);
DefaultAllocatorDeinit(&scratch);
return saved_si;- In
JSON.c:436:
num->is_float = is_flt;
StrDeinit(&ns);
DefaultAllocatorDeinit(&scratch);
return si;- In
JSON.c:639:
Str s = StrInit(&scratch);
si = JReadString(si, &s);
StrDeinit(&s);
DefaultAllocatorDeinit(&scratch);- In
Dwarf.c:662:
return;
VecDeinit(&self->entries);
StrDeinit(&self->string_pool);
MemSet(self, 0, sizeof(*self));
}- In
Resolve.c:54:
}
WriteFmtLn("{}", s);
StrDeinit(&s);
}- In
Beam.c:293:
}
HttpRequestDeinit(&req);
StrDeinit(&raw);
}
}- In
Beam.c:352:
LOG_ERROR("failed to dial upstream for client [{}]", peer_str);
SocketClose(client);
StrDeinit(&peer_str);
return;
}- In
Beam.c:362:
SocketClose(&upstream);
SocketClose(client);
StrDeinit(&peer_str);
return;
}- In
Beam.c:379:
SocketClose(&upstream);
SocketClose(client);
StrDeinit(&peer_str);
}- In
File.c:25:
if (!ok) {
FileRemove(out_path);
StrDeinit(out_path);
}
return ok;- In
File.c:45:
if (!FileIsOpen(&f)) {
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return false;- In
File.c:57:
ZstrCompare(StrBegin(&body), "hello from file") == 0;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:59:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return result;- In
File.c:79:
if (!FileIsOpen(&f)) {
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return false;- In
File.c:92:
ZstrCompare(StrBegin(&body), expected) == 0 && StrCapacity(&body) >= StrLen(&body) + 1;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:94:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return result;- In
File.c:129:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:159:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:204:
FileClose(&f);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:239:
FileClose(&f);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:272:
ok = ok && (got == 3) && (StrLen(&body) == 3) && ZstrCompare(StrBegin(&body), "new") == 0;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:274:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:306:
ok = ok && (got == 8) && ZstrCompare(StrBegin(&body), "headtail") == 0;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:308:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:342:
ok = ok && (got == (i64)n) && (StrLen(&body) == (size)n) && ZstrCompare(StrBegin(&body), payload) == 0;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:344:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:371:
bool ok = (got == -1);
StrDeinit(&body);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);- In
File.c:372:
StrDeinit(&body);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:403:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:436:
ok = ok && (got == 10) && ZstrCompare(StrBegin(&body), "AAA3456789") == 0;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:438:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:471:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:532:
ok = ok && (got == 10) && ZstrCompare(StrBegin(&body), "helloworld") == 0;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:534:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:564:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:591:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:625:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:653:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:693:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:723:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:760:
ok = ok && (got == 6) && (StrLen(&body) == 6) && ZstrCompare(StrBegin(&body), "ABCDEF") == 0;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:762:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:792:
ZstrCompare(StrBegin(&body), payload) == 0;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:794:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:841:
BufDeinit(&dst);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:877:
ok = ok && (got == (i64)n) && (StrLen(&body) == (size)n) && ZstrCompare(StrBegin(&body), payload) == 0;
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:879:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:907:
ok = ok && (got == 0) && (StrLen(&body) == 0);
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:909:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:941:
ok = ok && (got == 5) && ZstrCompare(StrBegin(&body), "12345") == 0;
StrDeinit(&body);
BufDeinit(&in);
FileRemove(&path);- In
File.c:944:
BufDeinit(&in);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:975:
ok = ok && (got == (i64)StrLen(&in)) && ZstrCompare(StrBegin(&body), "string-content") == 0;
StrDeinit(&body);
StrDeinit(&in);
FileRemove(&path);- In
File.c:976:
StrDeinit(&body);
StrDeinit(&in);
FileRemove(&path);
StrDeinit(&path);- In
File.c:978:
StrDeinit(&in);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:1009:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:1045:
ok = ok && (FileReadAndClose(&p2, &b2) == 6) && ZstrCompare(StrBegin(&b2), "twotwo") == 0;
StrDeinit(&b1);
StrDeinit(&b2);
FileRemove(&p1);- In
File.c:1046:
StrDeinit(&b1);
StrDeinit(&b2);
FileRemove(&p1);
FileRemove(&p2);- In
File.c:1049:
FileRemove(&p1);
FileRemove(&p2);
StrDeinit(&p1);
StrDeinit(&p2);
DefaultAllocatorDeinit(&alloc);- In
File.c:1050:
FileRemove(&p2);
StrDeinit(&p1);
StrDeinit(&p2);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:1081:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:1111:
// Unreachable on real code.
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return true;- In
File.c:1172:
ok = ok && (got == 0) && (StrLen(&body) == 0);
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);- In
File.c:1174:
StrDeinit(&body);
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
File.c:1203:
FileClose(&a);
FileRemove(&pa);
StrDeinit(&pa);
}
if (FileIsOpen(&b)) {- In
File.c:1208:
FileClose(&b);
FileRemove(&pb);
StrDeinit(&pb);
}
DefaultAllocatorDeinit(&alloc);- In
File.c:1234:
FileRemove(&pb);
FileRemove(&pc);
StrDeinit(&pa);
StrDeinit(&pb);
StrDeinit(&pc);- In
File.c:1235:
FileRemove(&pc);
StrDeinit(&pa);
StrDeinit(&pb);
StrDeinit(&pc);
DefaultAllocatorDeinit(&alloc);- In
File.c:1236:
StrDeinit(&pa);
StrDeinit(&pb);
StrDeinit(&pc);
DefaultAllocatorDeinit(&alloc);
return ok && reuse;- In
AllocDebug.c:132:
ok = ok && (ZstrFindSubstring(StrBegin(&out), "40 bytes") != NULL);
StrDeinit(&out);
HeapAllocatorDeinit(&scratch);
if (p1) ok = ok && (ZstrFindSubstring(StrBegin(&out), "#0") != NULL);
StrDeinit(&out);
HeapAllocatorDeinit(&scratch);
if (p) ok = ok && (ZstrFindSubstring(StrBegin(&out), "#1 ") != NULL);
StrDeinit(&out);
HeapAllocatorDeinit(&scratch);
if (p) ok = ok && (ZstrFindSubstring(StrBegin(&out), StrBegin(&ns)) == NULL);
StrDeinit(&ns);
StrDeinit(&out);
HeapAllocatorDeinit(&scratch);
StrDeinit(&ns);
StrDeinit(&out);
HeapAllocatorDeinit(&scratch);
if (p)- In
ArgParse.c:263:
bool ok = (rc == ARG_RUN_OK) && StrLen(&name) == 5 && StrBegin(&name)[0] == 'a' && StrBegin(&name)[4] == 'e';
ArgParseDeinit(&p);
StrDeinit(&name);
DefaultAllocatorDeinit(&a);
return ok;- In
ArgParse.c:618:
Str tmp_path = StrInit(p->alloc);
File tmp = FileOpenTemp(&tmp_path, p->alloc);
StrDeinit(&tmp_path);
if (!FileIsOpen(&tmp))
LOG_FATAL("capture_help: FileOpenTemp failed");- In
ArgParse.c:645:
WriteFmt("---- actual ({} bytes) ----\n{}\n", StrLen(&out), StrBegin(&out));
}
StrDeinit(&out);
DefaultAllocatorDeinit(&a);
return ok;- In
ArgParse.c:861:
WriteFmt("[a1] render cap: window wrong\n{}\n", StrBegin(&out));
}
StrDeinit(&out);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a2);- In
ArgParse.c:889:
Str tmp_path = StrInit(p->alloc);
File tmp = FileOpenTemp(&tmp_path, p->alloc);
StrDeinit(&tmp_path);
if (!FileIsOpen(&tmp))
return false;- In
ArgParse.c:1156:
bool ok = (rc == ARG_RUN_OK) && (StrLen(&name) == 3) && (StrBegin(&name)[0] == 'b') && (StrBegin(&name)[2] == 'b');
ArgParseDeinit(&p);
StrDeinit(&name);
DefaultAllocatorDeinit(&a);
return ok;- In
ArgParse.c:1274:
bool got = capture_help_file(&p, &help);
bool ok = got && str_contains(&help, "<LISTEN>");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1290:
bool got = capture_help_file(&p, &help);
bool ok = got && str_contains(&help, "<READ_ONLY>");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1307:
// The metavar is "<PORT>", never "<__PORT>".
bool ok = got && str_contains(&help, "<PORT>") && !str_contains(&help, "__PORT");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1322:
bool got = capture_help_file(&p, &help);
bool ok = got && str_contains(&help, "<VALUE>");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1338:
bool got = capture_help_file(&p, &help);
bool ok = got && str_contains(&help, "<IP6>");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1356:
// "gzip" -> "GZIP": the trailing 'z' in the middle must be upper.
bool ok = got && str_contains(&help, "<GZIP>") && !str_contains(&help, "GzIP");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1372:
bool got = capture_help_file(&p, &help);
bool ok = got && str_contains(&help, "<ABC>");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1391:
bool got = capture_help_file(&p, &help);
bool ok = got && str_contains(&help, "<source>");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1406:
bool got = capture_help_file(&p, &help);
bool ok = got && str_contains(&help, "-l, --listen");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1424:
// long, " <LISTEN>".
bool ok = got && str_contains(&help, " -l, --listen <LISTEN>");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1441:
// No short form: rendered as four spaces then the long name.
bool ok = got && str_contains(&help, " --timeout <TIMEOUT>");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1457:
// The verbose flag must appear but with no "<VERBOSE>" metavar.
bool ok = got && str_contains(&help, "-v, --verbose") && !str_contains(&help, "<VERBOSE>");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1485:
bool ok = got && str_contains(&help, "--a-very-long-option-name") && str_contains(&help, "AAA") &&
str_contains(&help, " AAA");
StrDeinit(&help);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1776:
Str tmp_path = StrInit(p->alloc);
File tmp = FileOpenTemp(&tmp_path, p->alloc);
StrDeinit(&tmp_path);
if (!FileIsOpen(&tmp))
LOG_FATAL("capture_run: FileOpenTemp failed");- In
ArgParse.c:1829:
bool ok =
(rc == ARG_RUN_ERROR) && str_has(&out, "unexpected positional argument") && !str_has(&out, "internal error");
StrDeinit(&out);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1854:
bool ok = (rc == ARG_RUN_ERROR) && str_has(&out, "missing required option") &&
!str_has(&out, "missing required positional");
StrDeinit(&out);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
ArgParse.c:1896:
bool ok = (rc == ARG_RUN_ERROR) && str_has(&out, "flag name too long");
StrDeinit(&out);
ArgParseDeinit(&p);
DefaultAllocatorDeinit(&a);- In
DateTime.c:150:
StrAppendFmt(&s, "{}", d);
bool ok = ZstrCompare(StrBegin(&s), "2021-01-01T00:00:00Z") == 0;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
DateTime.c:161:
StrAppendFmt(&s, "{}", d);
bool ok = ZstrCompare(StrBegin(&s), "2021-01-01T05:30:00+05:30") == 0;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
DateTime.c:172:
StrAppendFmt(&s, "{}", d);
bool ok = ZstrCompare(StrBegin(&s), "2021-01-01T00:00:00.123456789Z") == 0;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
DateTime.c:190:
bool ok = DateTimeCompare(a, b) == 0 && b.utc_offset_seconds == MST && b.nanosecond == 123456789u &&
b.year == a.year && b.month == a.month && b.day == a.day && b.hour == a.hour;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Init.c:97:
ZstrCompare(StrBegin(stored_name), "alpha") == 0 && StrBegin(stored_name) != StrBegin(&name);
StrDeinit(&name);
GraphDeinit(&graph);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:113:
result = result && !city_reachable(&graph, &index, &s_unknown, &s_alpha);
StrDeinit(&s_alpha);
StrDeinit(&s_beta);
StrDeinit(&s_gamma);- In
Foreach.c:114:
StrDeinit(&s_alpha);
StrDeinit(&s_beta);
StrDeinit(&s_gamma);
StrDeinit(&s_delta);- In
Foreach.c:115:
StrDeinit(&s_alpha);
StrDeinit(&s_beta);
StrDeinit(&s_gamma);
StrDeinit(&s_delta);
StrDeinit(&s_echo);- In
Foreach.c:116:
StrDeinit(&s_beta);
StrDeinit(&s_gamma);
StrDeinit(&s_delta);
StrDeinit(&s_echo);
StrDeinit(&s_unknown);- In
Foreach.c:117:
StrDeinit(&s_gamma);
StrDeinit(&s_delta);
StrDeinit(&s_echo);
StrDeinit(&s_unknown);- In
Foreach.c:118:
StrDeinit(&s_delta);
StrDeinit(&s_echo);
StrDeinit(&s_unknown);
city_reset_visits(&graph);- In
Type.c:64:
result = result && !FloatEQ(&clone, &original);
StrDeinit(&text);
FloatDeinit(&original);
FloatDeinit(&clone);- In
Type.c:214:
bool right = ok && (ZstrCompare(StrBegin(&text), "5") == 0);
StrDeinit(&text);
IntDeinit(&result);
IntDeinit(&value.significand);- In
Type.c:235:
bool right = ok && (ZstrCompare(StrBegin(&text), "120") == 0);
StrDeinit(&text);
IntDeinit(&result);
FloatDeinit(&value);- In
Type.c:294:
bool result = ok && (ZstrCompare(StrBegin(&text), "100") == 0);
StrDeinit(&text);
FloatDeinit(&f);
DefaultAllocatorDeinit(&alloc);- In
Type.c:340:
result = result && (ZstrCompare(StrBegin(&text), "1152921504606846976") == 0);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Type.c:359:
bool ok = ZstrCompare(StrBegin(&t), "100.1") == 0;
StrDeinit(&t);
FloatDeinit(&a);
FloatDeinit(&b);- In
Type.c:381:
bool ok = ZstrCompare(StrBegin(&t), "12.5") == 0;
StrDeinit(&t);
FloatDeinit(&a);
FloatDeinit(&z);- In
Math.c:84:
bool result = ZstrCompare(StrBegin(&text), "-12.5") == 0;
StrDeinit(&text);
FloatAbs(&value);
text = FloatToStr(&value);- In
Math.c:89:
result = result && (ZstrCompare(StrBegin(&text), "12.5") == 0);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Math.c:110:
bool result = ZstrCompare(StrBegin(&text), "1.23") == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:133:
bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_THREES) == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:156:
bool result = ZstrCompare(StrBegin(&text), "2") == 0;
StrDeinit(&text);
FloatAdd(&result_value, &a, &whole);
text = FloatToStr(&result_value);- In
Math.c:161:
result = result && (ZstrCompare(StrBegin(&text), "3.25") == 0);
StrDeinit(&text);
FloatAdd(&result_value, &a, 2u);
text = FloatToStr(&result_value);- In
Math.c:166:
result = result && (ZstrCompare(StrBegin(&text), "3.25") == 0);
StrDeinit(&text);
FloatAdd(&result_value, &a, -1);
text = FloatToStr(&result_value);- In
Math.c:171:
result = result && (ZstrCompare(StrBegin(&text), "0.25") == 0);
StrDeinit(&text);
FloatAdd(&result_value, &a, 0.75f);
text = FloatToStr(&result_value);- In
Math.c:176:
result = result && (ZstrCompare(StrBegin(&text), "2") == 0);
StrDeinit(&text);
FloatAdd(&result_value, &a, 0.75);
text = FloatToStr(&result_value);- In
Math.c:185:
IntDeinit(&whole);
FloatDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:205:
bool result = ZstrCompare(StrBegin(&text), "-0.5") == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:228:
bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_TWOS) == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:251:
bool result = ZstrCompare(StrBegin(&text), "5") == 0;
StrDeinit(&text);
FloatSub(&result_value, &a, &whole);
text = FloatToStr(&result_value);- In
Math.c:256:
result = result && (ZstrCompare(StrBegin(&text), "3.5") == 0);
StrDeinit(&text);
FloatSub(&result_value, &a, 2u);
text = FloatToStr(&result_value);- In
Math.c:261:
result = result && (ZstrCompare(StrBegin(&text), "3.5") == 0);
StrDeinit(&text);
FloatSub(&result_value, &a, -2);
text = FloatToStr(&result_value);- In
Math.c:266:
result = result && (ZstrCompare(StrBegin(&text), "7.5") == 0);
StrDeinit(&text);
FloatSub(&result_value, &a, 0.5f);
text = FloatToStr(&result_value);- In
Math.c:275:
IntDeinit(&whole);
FloatDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:295:
bool result = ZstrCompare(StrBegin(&text), "-2.5") == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:318:
bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_TWOS) == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:341:
bool result = ZstrCompare(StrBegin(&text), "3") == 0;
StrDeinit(&text);
FloatMul(&result_value, &a, &whole);
text = FloatToStr(&result_value);- In
Math.c:346:
result = result && (ZstrCompare(StrBegin(&text), "3") == 0);
StrDeinit(&text);
FloatMul(&result_value, &a, 2u);
text = FloatToStr(&result_value);- In
Math.c:351:
result = result && (ZstrCompare(StrBegin(&text), "3") == 0);
StrDeinit(&text);
FloatMul(&result_value, &a, -2);
text = FloatToStr(&result_value);- In
Math.c:356:
result = result && (ZstrCompare(StrBegin(&text), "-3") == 0);
StrDeinit(&text);
FloatMul(&result_value, &a, 0.5f);
text = FloatToStr(&result_value);- In
Math.c:365:
IntDeinit(&whole);
FloatDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:385:
bool result = ZstrCompare(StrBegin(&text), "0.125") == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:408:
bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_ONES) == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:431:
bool result = ZstrCompare(StrBegin(&text), "3") == 0;
StrDeinit(&text);
FloatDiv(&result_value, &a, &whole, 1);
text = FloatToStr(&result_value);- In
Math.c:436:
result = result && (ZstrCompare(StrBegin(&text), "2.5") == 0);
StrDeinit(&text);
FloatDiv(&result_value, &a, 3u, 1);
text = FloatToStr(&result_value);- In
Math.c:441:
result = result && (ZstrCompare(StrBegin(&text), "2.5") == 0);
StrDeinit(&text);
FloatDiv(&result_value, &a, -3, 1);
text = FloatToStr(&result_value);- In
Math.c:446:
result = result && (ZstrCompare(StrBegin(&text), "-2.5") == 0);
StrDeinit(&text);
FloatDiv(&result_value, &a, 0.5f, 1);
text = FloatToStr(&result_value);- In
Math.c:451:
result = result && (ZstrCompare(StrBegin(&text), "15") == 0);
StrDeinit(&text);
FloatDiv(&result_value, &a, 0.5, 1);
text = FloatToStr(&result_value);- In
Math.c:460:
IntDeinit(&whole);
FloatDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:506:
bool result = ZstrCompare(StrBegin(&text), "3") == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:534:
bool result = ZstrCompare(StrBegin(&text), "-3") == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:560:
bool result = ZstrCompare(StrBegin(&text), "0.75") == 0;
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:866:
bool result = ok && (ZstrCompare(StrBegin(&text), "5") == 0);
StrDeinit(&text);
FloatDeinit(&f);
DefaultAllocatorDeinit(&alloc);- In
Math.c:888:
bool result = ok && (ZstrCompare(StrBegin(&text), "19") == 0);
StrDeinit(&text);
FloatDeinit(&f);
DefaultAllocatorDeinit(&alloc);- In
Math.c:908:
bool result = ok && (ZstrCompare(StrBegin(&text), "2") == 0);
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&b);- In
Math.c:977:
ok = ok && (ZstrCompare(StrBegin(&text), "2.5") == 0);
StrDeinit(&text);
FloatDeinit(&a);
FloatDeinit(&r);- In
Convert.c:59:
result = result && !FloatIsNegative(&value);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:76:
result = result && FloatIsNegative(&value);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:94:
IntDeinit(&integer);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:115:
FloatDeinit(&value);
IntDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:164:
bool result = ZstrCompare(StrBegin(&text), "-123.45") == 0;
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:191:
(StrAllocator(&text)->retry_limit == alloc.base.retry_limit);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:207:
bool result = ZstrCompare(StrBegin(&text), FLOAT_TEST_VERY_LARGE_ONES) == 0;
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:223:
bool result = ZstrCompare(StrBegin(&text), "1230") == 0;
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:337:
result = result && (FloatCompare(&value, &whole) == 0);
StrDeinit(&text);
IntDeinit(&whole);
FloatDeinit(&value);- In
Convert.c:364:
result = result && (FloatExponent(&value) == 3);
StrDeinit(&text);
IntDeinit(&whole);
FloatDeinit(&value);- In
Convert.c:393:
bool ok = ZstrCompare(StrBegin(&text), "100") == 0;
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:424:
FloatDeinit(&value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Convert.c:441:
ok = ok && (ZstrCompare(StrBegin(&printed), "3.14") == 0);
StrDeinit(&printed);
FloatDeinit(&value);
StrDeinit(&text);- In
Convert.c:443:
StrDeinit(&printed);
FloatDeinit(&value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Convert.c:464:
bool result = (ZstrCompare(StrBegin(&text), "3.14") == 0) && (StrLen(&text) == 4);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:486:
bool result = (ZstrCompare(StrBegin(&text), "0.001") == 0) && (StrLen(&text) == 5);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:505:
bool result = (ZstrCompare(StrBegin(&text), "100") == 0) && (StrLen(&text) == 3);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:609:
ok = ok && (ZstrCompare(StrBegin(&text), "1") == 0);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:651:
bool result = (ZstrCompare(StrBegin(&text), "4503599627370496") == 0) && (StrLen(&text) == 16);
StrDeinit(&text);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:832:
FloatDeinit(&v);
StrDeinit(&out);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Convert.c:847:
FloatDeinit(&v);
StrDeinit(&out);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Memory.c:457:
bool result = (StrLen(&s) == 0) && (ZstrCompare(StrBegin(&s), "") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&local);
return result;- In
Memory.c:475:
bool result = (StrLen(&s) == 0) && (ZstrCompare(StrBegin(&s), "") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&local);
return result; result = result && BitVecRegexMatch(&source, &pat_yes);
StrDeinit(&pat_no);
StrDeinit(&pat_yes);
BitVecDeinit(&source);
StrDeinit(&pat_no);
StrDeinit(&pat_yes);
BitVecDeinit(&source);
DefaultAllocatorDeinit(&alloc); bool ok = (matched == true);
StrDeinit(&pattern);
BitVecDeinit(&bv);- In
Convert.c:63:
// Clean up
StrDeinit(&str);
BitVecDeinit(&bv);- In
Convert.c:288:
(ZstrCompare(StrBegin(&str), "101001") == 0);
StrDeinit(&str);
BitVecDeinit(&bv);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:324:
Str str_obj = BitVecToStr(&bv);
result = result && (StrLen(&str_obj) == 0);
StrDeinit(&str_obj);
// Test converting single bit
- In
Convert.c:331:
result = result && (StrLen(&str_obj) == 1);
result = result && (StrCmp(&str_obj, "1", 1) == 0);
StrDeinit(&str_obj);
// Test large conversions
- In
Convert.c:340:
str_obj = BitVecToStr(&bv);
result = result && (StrLen(&str_obj) == 1000);
StrDeinit(&str_obj);
BitVecDeinit(&bv);- In
Convert.c:458:
result = result && (ZstrCompare(StrBegin(&str), patterns[i]) == 0);
StrDeinit(&str);
BitVecDeinit(&bv);
}- In
Convert.c:535:
Str empty_str = BitVecToStr(&empty);
result = result && (StrLen(&empty_str) == 0);
StrDeinit(&empty_str);
u64 empty_value = BitVecToInteger(&empty);- In
Convert.c:581:
Str str = BitVecToStr(&bv);
result = result && (ZstrCompare(StrBegin(&str), test_cases[i].pattern) == 0);
StrDeinit(&str);
// Integer conversion is deterministic LSB-first (bit[i] -> 1<<i),
- In
Convert.c:622:
result = result && (ZstrCompare(StrBegin(&str2), StrBegin(&str3)) == 0);
StrDeinit(&str1);
StrDeinit(&str2);
StrDeinit(&str3);- In
Convert.c:623:
StrDeinit(&str1);
StrDeinit(&str2);
StrDeinit(&str3);
BitVecDeinit(&bv1);- In
Convert.c:624:
StrDeinit(&str1);
StrDeinit(&str2);
StrDeinit(&str3);
BitVecDeinit(&bv1);
BitVecDeinit(&bv2);- In
Convert.c:666:
result = result && pattern_correct;
StrDeinit(&large_str);
// Test byte conversion
- In
Convert.c:907:
BitVecDeinit(&bv);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:122:
result = result && (ZstrCompare(StrBegin(&text), "100000000") == 0);
StrDeinit(&text);
IntDeinit(&a);
IntDeinit(&b);- In
Math.c:158:
IntDeinit(&result_value);
IntDeinit(&huge);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:215:
IntDeinit(&preserved);
IntDeinit(&huge);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:275:
IntDeinit(&value);
IntDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:333:
bool result = ZstrCompare(StrBegin(&text), "79792266297612001") == 0;
StrDeinit(&text);
IntPow(&result_value, &base, &exponent);
text = IntToStr(&result_value);- In
Math.c:341:
IntDeinit(&exponent);
IntDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:362:
result = result && (IntToU64(&remainder) == 3);
StrDeinit(&qtext);
IntDeinit(÷nd);
IntDeinit("ient);- In
Math.c:403:
IntDeinit(÷nd);
IntDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:446:
IntDeinit("ient);
IntDeinit(&remainder);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:914:
IntDeinit(&value);
IntDeinit(&next);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Math.c:1935:
result = result && (ZstrCompare(StrBegin(&bits), "10000000") == 0);
StrDeinit(&bits);
IntDeinit(&ones);
IntDeinit(&one);- In
Math.c:2456:
result = result && (IntToU64(&remainder) == 3u);
StrDeinit(&qtext);
IntDeinit(÷nd);
IntDeinit("ient);- In
Math.c:2486:
result = result && (IntToU64(&remainder) == 1u);
StrDeinit(&qtext);
IntDeinit(÷nd);
IntDeinit("ient);- In
Math.c:3166:
result = result && (ZstrCompare(StrBegin(&rtext), "833333448067901235") == 0);
StrDeinit(&qtext);
StrDeinit(&rtext);
IntDeinit(÷nd);- In
Math.c:3167:
StrDeinit(&qtext);
StrDeinit(&rtext);
IntDeinit(÷nd);
IntDeinit(&divisor);- In
Convert.c:105:
result = result && (ZstrCompare(StrBegin(&text), "1101") == 0);
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:126:
result = result && (ZstrCompare(StrBegin(&text), "cdef1234") == 0);
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:147:
result = result && (ZstrCompare(StrBegin(&text), "12345678") == 0);
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:164:
result = result && (ZstrCompare(StrBegin(&text), "1011") == 0);
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:181:
bool result = ZstrCompare(StrBegin(&text), digits) == 0;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:198:
result = result && (ZstrCompare(StrBegin(&text), "zz") == 0);
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:214:
bool result = ZstrCompare(StrBegin(&text), "BEEF") == 0;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:241:
(StrAllocator(&text)->retry_limit == alloc.base.retry_limit);
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:279:
result = result && (ZstrCompare(StrBegin(&text), "0") == 0);
StrDeinit(&text);
IntDeinit(&zero);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:311:
result = result && (ZstrCompare(StrBegin(&text), "755") == 0);
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:328:
bool result = ZstrCompare(StrBegin(&text), hex) == 0;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:455:
bool result = StrLen(&text) == 0;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:736:
bool result = ok && (IntToU64(&out) == 5u);
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:763:
bool result = ok && (IntToU64(&out) == 5u);
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:790:
bool result = ok && (IntToU64(&out) == 13u);
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:824:
bool result = ok && (IntToU64(&out) == 15u);
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:850:
bool result = ok && (IntToU64(&out) == 15u);
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:875:
bool result = ok && (IntToU64(&out) == 15u);
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:904:
result = result && (ZstrCompare(StrBegin(&dec_big), "123456789012345678901234567890") == 0);
StrDeinit(&dec_small);
StrDeinit(&hex_mid);
StrDeinit(&hex_mid_u);- In
Convert.c:905:
StrDeinit(&dec_small);
StrDeinit(&hex_mid);
StrDeinit(&hex_mid_u);
StrDeinit(&dec_big);- In
Convert.c:906:
StrDeinit(&dec_small);
StrDeinit(&hex_mid);
StrDeinit(&hex_mid_u);
StrDeinit(&dec_big);
IntDeinit(&small);- In
Convert.c:907:
StrDeinit(&hex_mid);
StrDeinit(&hex_mid_u);
StrDeinit(&dec_big);
IntDeinit(&small);
IntDeinit(&mid);- In
Convert.c:933:
result = result && (ZstrCompare(StrBegin(&back_hex), "deadbeef") == 0);
StrDeinit(&back_dec);
StrDeinit(&back_hex);
IntDeinit(&parsed_dec);- In
Convert.c:934:
StrDeinit(&back_dec);
StrDeinit(&back_hex);
IntDeinit(&parsed_dec);
IntDeinit(&parsed_hex);- In
Convert.c:1011:
IntDeinit(&out);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1042:
IntDeinit(&out);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1067:
IntDeinit(&value);
StrDeinit(&digits);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1095:
IntDeinit(&value);
StrDeinit(&digits);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1463:
IntDeinit(&value);
StrDeinit(&digits);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1484:
IntDeinit(&value);
StrDeinit(&digits);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1510:
result = result && (IntToU64(&value) == 255u);
StrDeinit(&hex);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:1535:
result = result && IntIsZero(&value);
StrDeinit(&hex);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:1584:
ok = ok && int_mod_u64(&v, 100u) == 67u;
StrDeinit(&s);
IntDeinit(&v);
ok = ok && LEAK_CLEAN(dbg);- In
Convert.c:1630:
bool ok = IntCompare(&value, &parsed) == 0;
StrDeinit(&hex);
IntDeinit(&value);
IntDeinit(&parsed);- In
UserTypes.c:137:
ok = ok && (ZstrCompare(StrBegin(&out), "(3, 4)") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
UserTypes.c:153:
ok = ok && (ZstrCompare(StrBegin(&out), "got 7 hits at (-1, 2)") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
UserTypes.c:183:
ok = ok && (dst.x == src.x) && (dst.y == src.y);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
UserTypes.c:201:
ok = ok && (ZstrCompare(StrBegin(&out), "[(0, 0)..(10, 20)]") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
UserTypes.c:225:
ok = ok && (dst.max.x == src.max.x) && (dst.max.y == src.max.y);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
UserTypes.c:244:
ok = ok && (ZstrCompare(StrBegin(&out), "42:[(0, 0)..(100, 50)]@(50, 25)") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
UserTypes.c:271:
ok = ok && (dst.centroid.x == src.centroid.x) && (dst.centroid.y == src.centroid.y);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
UserTypes.c:298:
ok = ok && (ZstrCompare(StrBegin(&out), "score=1.5 region=7:[(1, 2)..(3, 4)]@(2, 3) origin=(0, 0)") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:60:
success = success && (ZstrCompare(StrBegin(&output), "{{") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:98:
StrAppendFmt(&output, "{}", s);
success = success && (ZstrCompare(StrBegin(&output), "World") == 0);
StrDeinit(&s);
StrDeinit(&output);- In
Write.c:100:
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:172:
success = success && (ZstrCompare(StrBegin(&output), "0") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:193:
success = success && (ZstrCompare(StrBegin(&output), "0xDEADBEEF") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:210:
success = success && (ZstrCompare(StrBegin(&output), "0b10100101") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:227:
success = success && (ZstrCompare(StrBegin(&output), "0o777") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:249:
success = success && (ZstrCompare(StrBegin(&output), "2.718280") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:275:
success = success && (ZstrCompare(StrBegin(&output), "3.1415926536") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:302:
success = success && (ZstrCompare(StrBegin(&output), "nan") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:340:
success = success && (ZstrCompare(StrBegin(&output), " abc ") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:364:
success = success && (ZstrCompare(StrBegin(&output), "3.140000 Hello 42") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:522:
StrBegin(&output)[5] == 'Z' && StrBegin(&output)[6] == '1' && StrBegin(&output)[7] == '2');
StrDeinit(&output);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Write.c:523:
StrDeinit(&output);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:587:
BitVecDeinit(&bv3);
BitVecDeinit(&bv_zero);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:633:
IntDeinit(&bin_val);
IntDeinit(&oct_val);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:672:
FloatDeinit(&sci);
FloatDeinit(&short_v);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:686:
StrWriteFmt(&s, "fresh {}", LVAL(42));
bool ok = (StrLen(&s) == 8) && (StrBegin(&s)[0] == 'f') && (StrBegin(&s)[StrLen(&s) - 1] == '2');
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:711:
ok = ok && StrBegin(&s)[6] == 'A' && StrBegin(&s)[7] == 'A';
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:729:
BufDeinit(&b);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:769:
ok = ok && (ZstrCompare(StrBegin(&out), "\\xab") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:934:
ok = ok && ZstrCompare(StrBegin(&s), "2021-01-01T00:00:00.123456789Z") == 0;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:983:
FileClose(f);
FileRemove(path);
StrDeinit(path);
}- In
Write.c:1002:
bool ok = (ZstrCompare(StrBegin(&text), expected) == 0);
StrDeinit(&text);
FloatDeinit(&f);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1016:
FileRead(&f, &back);
ok = (ZstrCompare(StrBegin(&back), expect) == 0);
StrDeinit(&back);
FileClose(&f);
}- In
Write.c:1090:
bool ok = (out != NULL) && (StrLen(&s) == 50);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1199:
ok = ok && (ZstrCompare(StrBegin(&output), " ABxyz") == 0);
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1200:
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1217:
ok = ok && (ZstrCompare(StrBegin(&output), "hi ") == 0);
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1218:
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1238:
ok = ok && (ZstrCompare(StrBegin(&output), "0x0F") == 0);
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1239:
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1258:
ok = ok && (ZstrCompare(StrBegin(&output), "0x0f") == 0);
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1259:
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1281:
ok = ok && (ZstrCompare(StrBegin(&output), "0x01 0x02") == 0);
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1282:
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1301:
ok = ok && (ZstrCompare(StrBegin(&output), "0x05") == 0);
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1302:
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1319:
ok = ok && (ZstrCompare(StrBegin(&output), "hel") == 0);
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1320:
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1337:
ok = ok && (StrLen(&output) == 0);
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Write.c:1338:
StrDeinit(&s);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1525:
bool ok = (ZstrCompare(StrBegin(&output), "0x41 0x42") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1541:
bool ok = (ZstrCompare(StrBegin(&output), "0x5a") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1558:
bool ok = (ZstrCompare(StrBegin(&output), "0xab") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1575:
bool ok = (ZstrCompare(StrBegin(&output), "0xAB") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1591:
bool ok = (ZstrCompare(StrBegin(&output), "0x05") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1606:
bool ok = (ZstrCompare(StrBegin(&output), "0xfe") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1622:
bool ok = (ZstrCompare(StrBegin(&output), "Hel") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1638:
bool ok = (ZstrCompare(StrBegin(&output), "Hi") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1655:
bool ok = (StrLen(&output) == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1671:
bool ok = (ZstrCompare(StrBegin(&output), "H") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1690:
bool ok = (ZstrCompare(StrBegin(&output), " abcHi") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1705:
bool ok = (ZstrCompare(StrBegin(&output), "xyHi ") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1720:
bool ok = (ZstrCompare(StrBegin(&output), " ") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:1987:
FloatDeinit(&v);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2007:
FloatDeinit(&v);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2029:
FloatDeinit(&v);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2050:
FloatDeinit(&v);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2074:
FloatDeinit(&v);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2396:
Str text = FloatToStr(&val);
success = success && (ZstrCompare(StrBegin(&text), "3.5") == 0);
StrDeinit(&text);
FloatDeinit(&val);- In
Write.c:2424:
Str text = FloatToStr(&val);
success = success && (ZstrCompare(StrBegin(&text), "12.25") == 0);
StrDeinit(&text);
FloatDeinit(&val);- In
Write.c:2451:
Str text = FloatToStr(&val);
success = success && (ZstrCompare(StrBegin(&text), "150") == 0);
StrDeinit(&text);
FloatDeinit(&val);- In
Write.c:2476:
Str text = FloatToStr(&val);
success = success && (ZstrCompare(StrBegin(&text), "-0.25") == 0);
StrDeinit(&text);
FloatDeinit(&val);- In
Write.c:2564:
ok = ok && (StrLen(&out) == 5);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2586:
ok = ok && (StrLen(&out) == 5);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2612:
ok = ok && (StrLen(&out) == 6);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2640:
ok = ok && (ZstrCompare(StrBegin(&out), "00042") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2669:
ok = ok && (StrLen(&out) == 8);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2694:
ok = ok && (StrLen(&out) == 16);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2719:
success = success && float_try_to_decimal_str(&out, &val, 3, true, alloc_base);
success = success && (ZstrCompare(StrBegin(&out), "12.000") == 0);
StrDeinit(&out);
FloatDeinit(&val);- In
Write.c:2741:
success = success && float_try_to_decimal_str(&out, &val, 0, true, alloc_base);
success = success && (ZstrCompare(StrBegin(&out), "12") == 0);
StrDeinit(&out);
FloatDeinit(&val);- In
Write.c:2764:
success = success && float_try_to_decimal_str(&out, &val, 3, true, alloc_base);
success = success && (ZstrCompare(StrBegin(&out), "1.500") == 0);
StrDeinit(&out);
FloatDeinit(&val);- In
Write.c:2786:
success = success && float_try_to_decimal_str(&out, &val, 0, true, alloc_base);
success = success && (ZstrCompare(StrBegin(&out), "1") == 0);
StrDeinit(&out);
FloatDeinit(&val);- In
Write.c:2808:
success = success && float_try_to_decimal_str(&out, &val, 1, true, alloc_base);
success = success && (ZstrCompare(StrBegin(&out), "1.2") == 0);
StrDeinit(&out);
FloatDeinit(&val);- In
Write.c:2830:
ok = ok && (ZstrCompare(StrBegin(&output), "1.500000") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2850:
ok = ok && (ZstrCompare(StrBegin(&output), "1.500000e+00") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2868:
ok = ok && (ZstrCompare(StrBegin(&output), "1.500000E+00") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2891:
ok = ok && (StrLen(&output) == 12);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2915:
ok = ok && (ZstrCompare(StrBegin(&output), " XYZ1.500000") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2934:
ok = ok && (StrLen(&output) == 12);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2957:
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2977:
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:2996:
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3087:
bool ok = (ZstrCompare(StrBegin(&out), "0xff") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3101:
bool ok = (ZstrCompare(StrBegin(&out), "0xFF") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3114:
bool ok = (ZstrCompare(StrBegin(&out), "0b101") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3127:
bool ok = (ZstrCompare(StrBegin(&out), "0o10") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3141:
bool ok = (ZstrCompare(StrBegin(&out), "-42") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3154:
bool ok = (ZstrCompare(StrBegin(&out), " X42") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3170:
bool ok = (ZstrCompare(StrBegin(&out), "X00042") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3236:
IntDeinit(&a);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:3255:
IntDeinit(&a);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:3281:
IntDeinit(&seven);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return success;- In
Write.c:3299:
bool ok = !StrAppendFmt(&out, "{", v); // unclosed -> must return false
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3318:
ok = ok && (ZstrCompare(StrBegin(&out), "200") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3338:
ok = ok && (ZstrCompare(StrBegin(&out), "258") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3358:
ok = ok && (ZstrCompare(StrBegin(&out), "65538") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3378:
ok = ok && (ZstrCompare(StrBegin(&out), "4294967298") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3397:
ok = ok && (ZstrCompare(StrBegin(&out), "4294967298") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3416:
ok = ok && (StrLen(&out) > 0); // returns false under the mutant
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3444:
ok = ok && (ZstrCompare(StrBegin(&out), " X:255") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3465:
ok = ok && (ZstrCompare(StrBegin(&out), "7 ") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3483:
ok = ok && (ZstrCompare(StrBegin(&out), "p00042") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3639:
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3658:
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3684:
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3724:
BitVecDeinit(&bv);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3758:
bool ok = (r == false) && (ZstrCompare(StrBegin(&o), "-----") == 0);
StrDeinit(&o);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3774:
bool ok = (r == true) && (ZstrCompare(StrBegin(&o), "hello") == 0);
StrDeinit(&o);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3790:
bool ok = (r == true) && (ZstrCompare(StrBegin(&o), "12345") == 0);
StrDeinit(&o);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3828:
bool ok = (ZstrCompare(StrBegin(&oct_text), "7") == 0);
StrDeinit(&oct_text);
IntDeinit(&oct);
DefaultAllocatorDeinit(&alloc);- In
Write.c:3847:
bool ok = (ZstrCompare(StrBegin(&output), "hello") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3863:
bool ok = (StrLen(&output) == 1) && (StrBegin(&output)[0] == 'Q');
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3884:
bool ok = (StrLen(&output) == 4) && (ZstrCompare(StrBegin(&output), "BCDE") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:3978:
ok = ok && (ZstrCompare(StrBegin(&out), "\\xa1") == 0);
StrDeinit(&src);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Write.c:3979:
StrDeinit(&src);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4011:
FloatDeinit(&f);
FloatDeinit(&g);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4039:
ok = ok && (ZstrCompare(StrBegin(&out), "0255") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4074:
ok = ok && (ZstrCompare(StrBegin(&out), " abc") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4123:
ok = ok && StrBegin(&s)[2] == '1' && StrBegin(&s)[5] == '4';
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4146:
ok = ok && (ZstrCompare(StrBegin(&out), "hello") == 0);
StrDeinit(&s);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Write.c:4147:
StrDeinit(&s);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4174:
ok = ok && (ZstrCompare(StrBegin(&out), "3.14") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4661:
ok = ok && (ZstrCompare(StrBegin(&out), "00007") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4681:
ok = ok && (ZstrCompare(StrBegin(&out), "0000003") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4698:
ok = ok && (ZstrCompare(StrBegin(&out), "000000003") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4721:
ok = ok && (StrLen(&out) == 9);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4747:
ok = ok && (ZstrCompare(StrBegin(&out), "Hello") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4783:
#define LEAK_WRITE_EPILOGUE() \
StrDeinit(&out); \
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0); \
DebugAllocatorDeinit(&dbg); \- In
Write.c:4794:
// Tear down `out`, then assert no scratch leaked, then deinit the allocator.
static bool dbg_no_leak(DebugAllocator *dbg, Str *out) {
StrDeinit(out);
bool ok = (DebugAllocatorLiveCount(dbg) == 0);
DebugAllocatorDeinit(dbg);- In
Write.c:4810:
StrAppendFmt(&out, "{05}", v);
bool ok = (ZstrCompare(StrBegin(&out), "00007") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4828:
StrAppendFmt(&out, "{12}", s);
ok = ok && (ZstrCompare(StrBegin(&out), " ab") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4847:
StrAppendFmt(&out, "{.4}", v);
ok = ok && (ZstrCompare(StrBegin(&out), "3.1416") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4862:
// Real: false; output keeps only the prior "literal" (append stopped).
bool ok = (rc == false) && (ZstrCompare(StrBegin(&out), "literal") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4878:
StrAppendFmt(&out, "{05}", v);
bool ok = (ZstrCompare(StrBegin(&out), "-0007") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4898:
StrAppendFmt(&out, "{05}", v);
ok = ok && (ZstrCompare(StrBegin(&out), "00123") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4914:
StrAppendFmt(&out, "{5}", s);
ok = ok && (ZstrCompare(StrBegin(&out), " abc") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4926:
StrAppendFmt(&out, "a{{b");
bool ok = (ZstrCompare(StrBegin(&out), "a{b") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4937:
StrAppendFmt(&out, "a}}b");
bool ok = (ZstrCompare(StrBegin(&out), "a}b") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4950:
StrAppendFmt(&out, "{x}", v);
bool ok = (ZstrCompare(StrBegin(&out), "0xab") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4966:
bool rc = StrAppendFmt(&out, "{<2r}", v);
bool ok = rc && (ZstrCompare(StrBegin(&out), "4660") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:4979:
bool rc = StrAppendFmt(&out, "{>8r}", v);
bool ok = rc && (ZstrCompare(StrBegin(&out), "72623859790382856") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5001:
FileRead(&r, &back);
ok = ok && (ZstrCompare(StrBegin(&back), "n=42\n") == 0);
StrDeinit(&back);
FileClose(&r);
} else {- In
Write.c:5008:
FileRemove(&path);
}
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5032:
FileRead(&r, &back);
ok = ok && (ZstrCompare(StrBegin(&back), "X") == 0);
StrDeinit(&back);
FileClose(&r);
} else {- In
Write.c:5039:
FileRemove(&path);
}
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5071:
StrAppendFmt(&out, "{x}", s);
bool ok = (ZstrCompare(StrBegin(&out), "0x01 0x4f") == 0);
StrDeinit(&s);
return ok && dbg_no_leak(&dbg, &out);
}- In
Write.c:5083:
StrAppendFmt(&out, "{x}", s);
bool ok = (ZstrCompare(StrBegin(&out), "0x05") == 0);
StrDeinit(&s);
return ok && dbg_no_leak(&dbg, &out);
}- In
Write.c:5115:
StrAppendFmt(&out, "{5}", s);
ok = ok && (ZstrCompare(StrBegin(&out), " hi") == 0);
StrDeinit(&s);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Write.c:5116:
ok = ok && (ZstrCompare(StrBegin(&out), " hi") == 0);
StrDeinit(&s);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5130:
StrAppendFmt(&out, "{5}", s);
ok = ok && (ZstrCompare(StrBegin(&out), " hi") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5165:
StrAppendFmt(&out, "{6}", v);
ok = ok && (ZstrCompare(StrBegin(&out), " 42") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5179:
StrAppendFmt(&out, "{6}", v);
ok = ok && (ZstrCompare(StrBegin(&out), " -42") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5196:
StrAppendFmt(&out, "{c}", v);
bool ok = (ZstrCompare(StrBegin(&out), "ABCDEFGH") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5212:
StrAppendFmt(&out, "{}", pinf);
ok = ok && (ZstrCompare(StrBegin(&out), "inf") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5231:
StrAppendFmt(&out, "{.2}", v);
ok = ok && (ZstrCompare(StrBegin(&out), "1.50") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5255:
StrAppendFmt(&out, "{6.1}", v);
ok = ok && (ZstrCompare(StrBegin(&out), " 1.5") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5275:
FloatDeinit(&v);
FloatDeinit(&w);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5294:
bool ok = (ZstrCompare(StrBegin(&out), "1e+00") == 0);
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5309:
bool ok = (ZstrCompare(StrBegin(&out), "2e+00") == 0);
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5339:
ok = ok && (ZstrCompare(StrBegin(&out), "3.14159000") == 0);
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5354:
bool ok = (ZstrCompare(StrBegin(&out), "5.000") == 0);
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5381:
ok = ok && (ZstrCompare(StrBegin(&out), " 1.5") == 0);
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5398:
bool ok = (ZstrCompare(StrBegin(&out), " AB1.5") == 0);
FloatDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5427:
ok = ok && (ZstrCompare(StrBegin(&out), " 101") == 0);
BitVecDeinit(&bv);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5456:
ok = ok && (ZstrCompare(StrBegin(&out), " 42") == 0);
IntDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Write.c:5474:
Str out = StrInit(ALLOCATOR_OF(&dbg));
bool ok = StrAppendFmt(&out, "{x}", s) && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Write.c:5477:
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);
StrDeinit(&s);
HeapAllocatorDeinit(&sa);
return ok;- In
Write.c:5495:
LEAK_WRITE_PRELUDE();
ok = ok && StrAppendFmt(&out, "{}", f) && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Write.c:5523:
ok = ok && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);- In
Write.c:5549:
ok = ok && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);- In
Write.c:5575:
ok = ok && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);- In
Write.c:5602:
ok = ok && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);- In
Write.c:5629:
ok = ok && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);- In
Write.c:5653:
ok = ok && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);- In
Write.c:5679:
LEAK_WRITE_PRELUDE();
ok = ok && StrAppendFmt(&out, "{}", s) && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Write.c:5682:
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);
StrDeinit(&s);
HeapAllocatorDeinit(&va);
return ok;- In
Write.c:5692:
LEAK_WRITE_PRELUDE();
ok = ok && StrAppendFmt(&out, "{}", v) && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Write.c:5705:
LEAK_WRITE_PRELUDE();
ok = ok && StrAppendFmt(&out, "{}", v) && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Write.c:5719:
LEAK_WRITE_PRELUDE();
ok = ok && StrAppendFmt(&out, "{}", v) && (StrLen(&out) > 0);
StrDeinit(&out);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Read.c:51:
FileClose(f);
FileRemove(path);
StrDeinit(path);
}- In
Read.c:357:
Str expected = StrInitFromZstr("Hello", &alloc);
success = success && (StrCmp(&s, &expected) == 0);
StrDeinit(&expected);
StrClear(&s);- In
Read.c:365:
expected = StrInitFromZstr("Hello, World!", &alloc);
success = success && (StrCmp(&s, &expected) == 0);
StrDeinit(&expected);
{- In
Read.c:380:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Read.c:404:
Str expected = StrInitFromZstr("Alice", &alloc);
success = success && (StrCmp(&name, &expected) == 0);
StrDeinit(&expected);
StrClear(&name);- In
Read.c:415:
expected = StrInitFromZstr("Bob", &alloc);
success = success && (StrCmp(&name, &expected) == 0);
StrDeinit(&expected);
StrDeinit(&name);- In
Read.c:417:
StrDeinit(&expected);
StrDeinit(&name);
DefaultAllocatorDeinit(&alloc);- In
Read.c:610:
WriteFmt("str_val test: comparing with 'Hello', pass = {}\n", str_pass ? "true" : "false");
success = success && str_pass;
StrDeinit(&expected);
StrDeinit(&str_val);- In
Read.c:611:
success = success && str_pass;
StrDeinit(&expected);
StrDeinit(&str_val);
str_val = StrInit(&alloc);- In
Read.c:620:
WriteFmt("quoted str_val test: comparing with 'World', pass = {}\n", quoted_str_pass ? "true" : "false");
success = success && quoted_str_pass;
StrDeinit(&expected);
StrDeinit(&str_val);- In
Read.c:621:
success = success && quoted_str_pass;
StrDeinit(&expected);
StrDeinit(&str_val);
WriteFmt("Overall success: {}\n", success ? "true" : "false");- In
Read.c:658:
success = success && test1_pass;
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:659:
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:683:
success = success && test1_pass;
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:684:
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:708:
success = success && test2_pass;
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:709:
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:729:
success = success && test2_pass;
StrDeinit(&result1);
StrDeinit(&result2);
}- In
Read.c:730:
StrDeinit(&result1);
StrDeinit(&result2);
}- In
Read.c:752:
success = success && test2_pass;
StrDeinit(&result1);
StrDeinit(&result2);
}- In
Read.c:753:
StrDeinit(&result1);
StrDeinit(&result2);
}- In
Read.c:777:
success = success && test3_pass;
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:778:
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:802:
success = success && test4_pass;
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:803:
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:827:
success = success && test5_pass;
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:828:
StrDeinit(&expected);
StrDeinit(&result);
}- In
Read.c:856:
(ZstrCompare(StrBegin(&result1), "10110") == 0) ? "true" : "false"
);
StrDeinit(&result1);
BitVecDeinit(&bv1);- In
Read.c:885:
(ZstrCompare(StrBegin(&result4), "1101") == 0) ? "true" : "false"
);
StrDeinit(&result4);
BitVecDeinit(&bv4);- In
Read.c:898:
(ZstrCompare(StrBegin(&result5), "0") == 0) ? "true" : "false"
);
StrDeinit(&result5);
BitVecDeinit(&bv5);- In
Read.c:945:
success = success && (ZstrCompare(StrBegin(&oct_text), "755") == 0);
StrDeinit(&dec_text);
StrDeinit(&hex_text);
StrDeinit(&bin_text);- In
Read.c:946:
StrDeinit(&dec_text);
StrDeinit(&hex_text);
StrDeinit(&bin_text);
StrDeinit(&oct_text);- In
Read.c:947:
StrDeinit(&dec_text);
StrDeinit(&hex_text);
StrDeinit(&bin_text);
StrDeinit(&oct_text);
IntDeinit(&dec);- In
Read.c:948:
StrDeinit(&hex_text);
StrDeinit(&bin_text);
StrDeinit(&oct_text);
IntDeinit(&dec);
IntDeinit(&hex);- In
Read.c:990:
success = success && (ZstrCompare(StrBegin(&neg_text), "-0.00125") == 0);
StrDeinit(&dec_text);
StrDeinit(&sci_text);
StrDeinit(&neg_text);- In
Read.c:991:
StrDeinit(&dec_text);
StrDeinit(&sci_text);
StrDeinit(&neg_text);
FloatDeinit(&dec);- In
Read.c:992:
StrDeinit(&dec_text);
StrDeinit(&sci_text);
StrDeinit(&neg_text);
FloatDeinit(&dec);
FloatDeinit(&sci);- In
Read.c:1438:
ok = ok && (ZstrCompare(StrBegin(&out), "}") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1570:
bool ok = (ZstrCompare(StrBegin(&output), "\\x1a\\xe0") == 0);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1729:
bool ok = (StrLen(&s) == 3) && (StrCmp(&s, &expected) == 0);
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Read.c:1730:
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1750:
bool ok = (StrLen(&s) == 1) && (StrCmp(&s, &expected) == 0);
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Read.c:1751:
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1771:
bool ok = (StrLen(&s) == 1) && (StrCmp(&s, &expected) == 0);
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Read.c:1772:
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1795:
bool ok = (StrLen(&s) == 3) && (StrCmp(&s, &expected) == 0);
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Read.c:1796:
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1815:
bool ok = (StrLen(&s) == 1) && (StrCmp(&s, &expected) == 0);
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Read.c:1816:
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1835:
bool ok = (StrLen(&s) == 1) && (StrCmp(&s, &expected) == 0);
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Read.c:1836:
StrDeinit(&expected);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1860:
ok = ok && (ZstrCompare(StrBegin(&out), "\\x12") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1878:
ok = ok && (ZstrCompare(StrBegin(&out), "\\x90") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1899:
ok = ok && (ZstrCompare(StrBegin(&out), "\\xab") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1919:
ok = ok && (ZstrCompare(StrBegin(&out), "\\xcd") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1939:
ok = ok && (ZstrCompare(StrBegin(&out), "\\xAB") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1957:
ok = ok && (ZstrCompare(StrBegin(&out), "\\xCD") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:1981:
ok = ok && (ZstrCompare(StrBegin(&out), "\\xb1") == 0);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:2048:
StrReadFmt(p, "{}#", out);
bool ok = (StrLen(&out) == 2) && (StrBegin(&out)[0] == '\n') && (StrBegin(&out)[1] == '\n');
StrDeinit(&out);
DefaultAllocatorDeinit(&a);
return ok;- In
Read.c:2089:
StrReadFmt(p, "{s}", out);
bool ok = (StrLen(&out) == 50);
StrDeinit(&out);
DefaultAllocatorDeinit(&a);
return ok;- In
Read.c:2119:
Str t = FloatToStr(&f);
bool ok = (ZstrCompare(StrBegin(&t), expect) == 0);
StrDeinit(&t);
FloatDeinit(&f);
DefaultAllocatorDeinit(&alloc);- In
Read.c:2162:
Zstr out = READ1(in, "{s}", TO_TYPE_SPECIFIC_IO(Str, &s));
bool ok = (out != NULL) && (StrLen(&s) == 50);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:2570:
Str t = IntToStr(&v);
bool ok = (ZstrCompare(StrBegin(&t), "12345") == 0);
StrDeinit(&t);
IntDeinit(&v);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);- In
Read.c:2585:
Str t = IntToStr(&v);
bool ok = (ZstrCompare(StrBegin(&t), "99") == 0);
StrDeinit(&t);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);- In
Read.c:2601:
Str t = IntToStr(&v);
bool ok = (ZstrCompare(StrBegin(&t), "255") == 0);
StrDeinit(&t);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);- In
Read.c:2619:
Str t = IntToStr(&v);
bool ok = (out == NULL) && (ZstrCompare(StrBegin(&t), "777") == 0);
StrDeinit(&t);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);- In
Read.c:2637:
Str t = FloatToStr(&f);
bool ok = (ZstrCompare(StrBegin(&t), "3.14159") == 0);
StrDeinit(&t);
FloatDeinit(&f);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);- In
Read.c:2654:
Str t = FloatToStr(&f);
bool ok = (out == NULL) && (ZstrCompare(StrBegin(&t), "42") == 0);
StrDeinit(&t);
FloatDeinit(&f);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);- In
Read.c:2694:
FileRemove(&path);
}
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.c:2719:
FileRemove(&path);
}
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Ops.c:51:
result = result && (cmp5 != 0);
StrDeinit(&s1);
StrDeinit(&s2);
StrDeinit(&s3);- In
Ops.c:52:
StrDeinit(&s1);
StrDeinit(&s2);
StrDeinit(&s3);
StrDeinit(&s4);- In
Ops.c:53:
StrDeinit(&s1);
StrDeinit(&s2);
StrDeinit(&s3);
StrDeinit(&s4);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:54:
StrDeinit(&s2);
StrDeinit(&s3);
StrDeinit(&s4);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:90:
result = result && (found5 != NULL && ZstrCompareN(found5, "World", 3) == 0);
StrDeinit(&haystack);
StrDeinit(&needle1);
StrDeinit(&needle2);- In
Ops.c:91:
StrDeinit(&haystack);
StrDeinit(&needle1);
StrDeinit(&needle2);
StrDeinit(&needle3);- In
Ops.c:92:
StrDeinit(&haystack);
StrDeinit(&needle1);
StrDeinit(&needle2);
StrDeinit(&needle3);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:93:
StrDeinit(&needle1);
StrDeinit(&needle2);
StrDeinit(&needle3);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:118:
result = result && (StrIndexOf(&haystack, "") == 0);
StrDeinit(&haystack);
StrDeinit(&needle);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:119:
StrDeinit(&haystack);
StrDeinit(&needle);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:156:
result = result && !StrEndsWith(&s, "ello", 4);
StrDeinit(&s);
StrDeinit(&prefix);
StrDeinit(&suffix);- In
Ops.c:157:
StrDeinit(&s);
StrDeinit(&prefix);
StrDeinit(&suffix);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:158:
StrDeinit(&s);
StrDeinit(&prefix);
StrDeinit(&suffix);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:175:
// Test multiple replacements
StrDeinit(&s1);
s1 = StrInitFromZstr("Hello Hello Hello", &alloc);
StrReplace(&s1, "Hello", "Hi", 2);- In
Ops.c:181:
// Test Cstr-form (fixed-length views) - use the full "World" string instead of just "Wo"
StrDeinit(&s1);
s1 = StrInitFromZstr("Hello World", &alloc);
StrReplace(&s1, "World", 5, "Universe", 8, 1);- In
Ops.c:187:
// Test Str-form
StrDeinit(&s1);
s1 = StrInitFromZstr("Hello World", &alloc);
Str find = StrInitFromZstr("World", &alloc);- In
Ops.c:194:
result = result && (ZstrCompare(StrBegin(&s1), "Hello Universe") == 0);
StrDeinit(&s1);
StrDeinit(&find);
StrDeinit(&replace);- In
Ops.c:195:
StrDeinit(&s1);
StrDeinit(&find);
StrDeinit(&replace);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:196:
StrDeinit(&s1);
StrDeinit(&find);
StrDeinit(&replace);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:245:
VecDeinit(&iters);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:260:
Str stripped = StrLStrip(&s1, NULL);
bool result = (ZstrCompare(StrBegin(&stripped), "Hello ") == 0);
StrDeinit(&stripped);
// Test StrRStrip
- In
Ops.c:265:
stripped = StrRStrip(&s1, NULL);
result = result && (ZstrCompare(StrBegin(&stripped), " Hello") == 0);
StrDeinit(&stripped);
// Test StrStrip
- In
Ops.c:270:
stripped = StrStrip(&s1, NULL);
result = result && (ZstrCompare(StrBegin(&stripped), "Hello") == 0);
StrDeinit(&stripped);
// Test with custom strip characters
- In
Ops.c:273:
// Test with custom strip characters
StrDeinit(&s1);
s1 = StrInitFromZstr("***Hello***", &alloc);- In
Ops.c:278:
stripped = StrLStrip(&s1, "*");
result = result && (ZstrCompare(StrBegin(&stripped), "Hello***") == 0);
StrDeinit(&stripped);
stripped = StrRStrip(&s1, "*");- In
Ops.c:282:
stripped = StrRStrip(&s1, "*");
result = result && (ZstrCompare(StrBegin(&stripped), "***Hello") == 0);
StrDeinit(&stripped);
stripped = StrStrip(&s1, "*");- In
Ops.c:286:
stripped = StrStrip(&s1, "*");
result = result && (ZstrCompare(StrBegin(&stripped), "Hello") == 0);
StrDeinit(&stripped);
StrDeinit(&s1);- In
Ops.c:288:
StrDeinit(&stripped);
StrDeinit(&s1);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:326:
ok = ok && StrCmpIgnoreCase(&non_ascii_a, &non_ascii_b) == 0;
StrDeinit(&hello_lc);
StrDeinit(&hello_uc);
StrDeinit(&hello_mc);- In
Ops.c:327:
StrDeinit(&hello_lc);
StrDeinit(&hello_uc);
StrDeinit(&hello_mc);
StrDeinit(&world);- In
Ops.c:328:
StrDeinit(&hello_lc);
StrDeinit(&hello_uc);
StrDeinit(&hello_mc);
StrDeinit(&world);
StrDeinit(&hello_x);- In
Ops.c:329:
StrDeinit(&hello_uc);
StrDeinit(&hello_mc);
StrDeinit(&world);
StrDeinit(&hello_x);
StrDeinit(&non_ascii_a);- In
Ops.c:330:
StrDeinit(&hello_mc);
StrDeinit(&world);
StrDeinit(&hello_x);
StrDeinit(&non_ascii_a);
StrDeinit(&non_ascii_b);- In
Ops.c:331:
StrDeinit(&world);
StrDeinit(&hello_x);
StrDeinit(&non_ascii_a);
StrDeinit(&non_ascii_b);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:332:
StrDeinit(&hello_x);
StrDeinit(&non_ascii_a);
StrDeinit(&non_ascii_b);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Ops.c:364:
bool result = match && (no_match == false);
StrDeinit(&s);
StrDeinit(&suffix);
StrDeinit(&nonsuffix);- In
Ops.c:365:
StrDeinit(&s);
StrDeinit(&suffix);
StrDeinit(&nonsuffix);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:366:
StrDeinit(&s);
StrDeinit(&suffix);
StrDeinit(&nonsuffix);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:385:
bool result = (StrLen(&stripped) == 0);
StrDeinit(&stripped);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:386:
StrDeinit(&stripped);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:402:
bool result = (StrLen(&stripped) == 0);
StrDeinit(&stripped);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:403:
StrDeinit(&stripped);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:419:
bool result = (StrLen(&stripped) == 1) && (ZstrCompare(StrBegin(&stripped), "x") == 0);
StrDeinit(&stripped);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:420:
StrDeinit(&stripped);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:436:
bool result = (StrContains(&haystack, &needle) == false);
StrDeinit(&needle);
StrDeinit(&haystack);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:437:
StrDeinit(&needle);
StrDeinit(&haystack);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:455:
bool result = (StrContains(&haystack, &present) == true) && (StrContains(&haystack, &absent) == false);
StrDeinit(&absent);
StrDeinit(&present);
StrDeinit(&haystack);- In
Ops.c:456:
StrDeinit(&absent);
StrDeinit(&present);
StrDeinit(&haystack);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:457:
StrDeinit(&absent);
StrDeinit(&present);
StrDeinit(&haystack);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:472:
bool result = (StrContains(&haystack, "missing") == false);
StrDeinit(&haystack);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:496:
VecDeinit(&iters);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:521:
VecDeinit(&split);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:544:
VecDeinit(&split);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:563:
}
StrDeinit(&hello);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:583:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:602:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:642:
}
StrDeinit(&a);
StrDeinit(&b);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:643:
StrDeinit(&a);
StrDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:665:
}
StrDeinit(&s);
StrDeinit(&prefix);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:666:
StrDeinit(&s);
StrDeinit(&prefix);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:687:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Ops.c:842:
Str stripped = StrStrip(&s, NULL);
StrDeinit(&stripped);
GENERIC_VEC(&s)->__magic ^= 0x1;
StrDeinit(&s);- In
Ops.c:844:
StrDeinit(&stripped);
GENERIC_VEC(&s)->__magic ^= 0x1;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Ops.c:861:
GENERIC_VEC(&key)->__magic ^= 0x1;
StrDeinit(&key);
StrDeinit(&haystack);
DefaultAllocatorDeinit(&alloc);- In
Ops.c:862:
GENERIC_VEC(&key)->__magic ^= 0x1;
StrDeinit(&key);
StrDeinit(&haystack);
DefaultAllocatorDeinit(&alloc);
return false;- In
Ops.c:879:
VecDeinit(&iters);
GENERIC_VEC(&s)->__magic ^= 0x1;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Ops.c:907:
GENERIC_VEC(&s)->__magic ^= 0x1;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Ops.c:937:
GENERIC_VEC(VecPtrAt(&strs, 0))->__magic ^= 0x1;
VecDeinit(&strs);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Ops.c:1023:
(void)str_compare(&a, &b); // expected to abort on real code via ValidateStr(a)
StrDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return false;- In
Ops.c:1040:
(void)str_compare(&a, &b);
StrDeinit(&a);
DefaultAllocatorDeinit(&alloc);
return false;- In
Ops.c:1057:
(void)StrCmpIgnoreCase(&s, &other);
StrDeinit(&other);
DefaultAllocatorDeinit(&alloc);
return false;- In
Ops.c:1074:
(void)StrCmpIgnoreCase(&s, &other);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Ops.c:1091:
(void)StrStartsWith(&s, &prefix);
StrDeinit(&prefix);
DefaultAllocatorDeinit(&alloc);
return false;- In
Memory.c:40:
result = result && (StrCapacity(&s) < 100) && (StrCapacity(&s) >= StrLen(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:65:
result = result && (StrBegin(&s)[1] == 'l' && StrBegin(&s)[2] == 'e');
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:94:
result = result && (StrLen(&s) == 8) && (ZstrCompareN(StrBegin(&s), "Hel", 3) == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:122:
result = result && (StrCapacity(&s) >= 100);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:147:
result = result && (StrBegin(&s) != NULL);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Memory.c:167:
// Test with an even-length string
StrDeinit(&s);
s = StrInitFromZstr("abcd", &alloc);- In
Memory.c:177:
// Test with a single-character string
StrDeinit(&s);
s = StrInitFromZstr("a", &alloc);- In
Memory.c:187:
// Test with an empty string
StrDeinit(&s);
s = StrInit(&alloc);- In
Memory.c:196:
result = result && (StrLen(&s) == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:38:
bool result = (StrLen(&s) == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:59:
bool result = (StrLen(&s) == len && ZstrCompareN(StrBegin(&s), test_str, len) == 0 && StrBegin(&s)[len] == '\0');
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:79:
bool result = (StrLen(&s) == ZstrLen(test_str) && ZstrCompare(StrBegin(&s), test_str) == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:97:
bool result = (StrLen(&s) == ZstrLen(test_str) && ZstrCompare(StrBegin(&s), test_str) == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:118:
bool result = (StrLen(&dst) == StrLen(&src) && ZstrCompare(StrBegin(&dst), StrBegin(&src)) == 0);
StrDeinit(&src);
StrDeinit(&dst);
DefaultAllocatorDeinit(&alloc);- In
Init.c:119:
StrDeinit(&src);
StrDeinit(&dst);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:140:
bool result = (StrLen(&dst) == StrLen(&src) && ZstrCompare(StrBegin(&dst), StrBegin(&src)) == 0);
StrDeinit(&src);
StrDeinit(&dst);
DefaultAllocatorDeinit(&alloc);- In
Init.c:141:
StrDeinit(&src);
StrDeinit(&dst);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:161:
bool result = (ZstrCompare(StrBegin(&s), "Hello, World!") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:213:
bool result = (success && StrLen(&dst) == StrLen(&src) && ZstrCompare(StrBegin(&dst), StrBegin(&src)) == 0);
StrDeinit(&src);
StrDeinit(&dst);
DefaultAllocatorDeinit(&alloc);- In
Init.c:214:
StrDeinit(&src);
StrDeinit(&dst);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:242:
ZstrCompare(StrBegin(&dst), StrBegin(&src)) == 0 && dup_allocator_matches && dst_allocator_matches;
StrDeinit(&src);
StrDeinit(&dup);
StrDeinit(&dst);- In
Init.c:243:
StrDeinit(&src);
StrDeinit(&dup);
StrDeinit(&dst);
DefaultAllocatorDeinit(&alloc);- In
Init.c:244:
StrDeinit(&src);
StrDeinit(&dup);
StrDeinit(&dst);
DefaultAllocatorDeinit(&alloc);
return result;- In
Init.c:251:
// Test StrDeinit function
bool test_str_deinit(void) {
WriteFmt("Testing StrDeinit\n");
DefaultAllocator alloc = DefaultAllocatorInit();- In
Init.c:261:
// Deinit the string
StrDeinit(&s);
// Check that the string is deinited correctly
- In
Init.c:299:
bool pass = produced && after == before;
StrDeinit(&s);
DebugAllocatorDeinit(&dbg);
return pass;- In
Init.c:309:
// under the mutant (Str.Mutants7).
static bool test_deinit_frees_buffer(void) {
WriteFmt("Testing StrDeinit releases the backing allocation\n");
DebugAllocator dbg = DebugAllocatorInit();
Allocator *adbg = ALLOCATOR_OF(&dbg);- In
Init.c:314:
Str s = StrInitFromZstr("hello world", adbg);
StrDeinit(&s);
bool result = (DebugAllocatorLiveCount(&dbg) == 0);- In
Init.c:318:
bool result = (DebugAllocatorLiveCount(&dbg) == 0);
if (!result) {
WriteFmt(" FAIL: Expected 0 live allocations after StrDeinit\n");
}- In
Insert.c:53:
result = result && (ZstrCompare(StrBegin(&s), "?He!llo.") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:72:
bool result = (ZstrCompare(StrBegin(&s), "He Worldllo") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:92:
bool result = (ZstrCompare(StrBegin(&s), "He Worldllo") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:111:
bool result = (ZstrCompare(StrBegin(&s), "He Worldllo") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:130:
bool result = (ZstrCompare(StrBegin(&s), "He Worldllo") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:149:
bool result = (ZstrCompare(StrBegin(&s), "Hello World") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:168:
bool result = (ZstrCompare(StrBegin(&s), "Hello World") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:187:
bool result = (ZstrCompare(StrBegin(&s), "Hello World") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:206:
bool result = (ZstrCompare(StrBegin(&s), "Hello World") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:230:
bool result = (ZstrCompare(StrBegin(&s), "Hello World") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:254:
bool result = (ZstrCompare(StrBegin(&s), "Hello World") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:281:
result = result && (StrLen(&s2) == 0 && StrBegin(&s2) == NULL);
StrDeinit(&s1);
StrDeinit(&s2);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:282:
StrDeinit(&s1);
StrDeinit(&s2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:305:
result = result && (StrLen(&s2) == 6 && ZstrCompare(StrBegin(&s2), " World") == 0);
StrDeinit(&s1);
StrDeinit(&s2);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:306:
StrDeinit(&s1);
StrDeinit(&s2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:329:
result = result && (StrLen(&s2) == 0 && StrBegin(&s2) == NULL);
StrDeinit(&s1);
StrDeinit(&s2);
DefaultAllocatorDeinit(&alloc);- In
Insert.c:330:
StrDeinit(&s1);
StrDeinit(&s2);
DefaultAllocatorDeinit(&alloc);
return result;- In
Insert.c:350:
bool result = (ZstrCompare(StrBegin(&s), "Hello World 2023") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Type.c:38:
bool result = (StrLen(&s) == 5 && ZstrCompare(StrBegin(&s), "Hello") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Type.c:50:
// Create a Strs object (vector of strings)
Strs sv = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
// Add some strings
- In
Type.c:71:
}
VecDeinit(&sv); // This should call StrDeinit on each element
DefaultAllocatorDeinit(&alloc);
return result;- In
Type.c:94:
bool result = true; // If we got here, the validation didn't crash
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:42:
result = result && (ZstrCompare(StrBegin(&s), "Hel") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:69:
result = result && (ZstrCompare(StrBegin(&s), "llo") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:96:
result = result && (ZstrCompare(StrBegin(&s), "Hlo") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:126:
result = result && (ZstrCompare(StrBegin(&s), "Hell") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:151:
result = result && (ZstrCompare(StrBegin(&s), "Hel") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:176:
result = result && (ZstrCompare(StrBegin(&s), "Hlo") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Remove.c:201:
result = result && (ZstrCompare(StrBegin(&s), "Heo") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:90:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:149:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:233:
result = result && (ZstrCompare(StrBegin(&s), "nan") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:251:
// Test hexadecimal conversion with explicit base
StrDeinit(&s);
s = StrInitFromZstr("ABCD", &alloc); // No 0x prefix when base is explicitly 16
StrParseConfig config = {.base = 16};- In
Convert.c:258:
// Test hexadecimal conversion (auto-detect base with 0)
StrDeinit(&s);
s = StrInitFromZstr("0xABCD", &alloc);
success = StrToU64(&s, &value, NULL);- In
Convert.c:264:
// Test binary conversion
StrDeinit(&s);
s = StrInitFromZstr("0b101010", &alloc);
success = StrToU64(&s, &value, NULL);- In
Convert.c:270:
// Test octal conversion
StrDeinit(&s);
s = StrInitFromZstr("0o52", &alloc);
success = StrToU64(&s, &value, NULL);- In
Convert.c:276:
// Test zero
StrDeinit(&s);
s = StrInitFromZstr("0", &alloc);
success = StrToU64(&s, &value, NULL);- In
Convert.c:282:
// Test invalid input
StrDeinit(&s);
s = StrInitFromZstr("not a number", &alloc);
success = StrToU64(&s, &value, NULL);- In
Convert.c:288:
// Test negative number (should fail for unsigned)
StrDeinit(&s);
s = StrInitFromZstr("-123", &alloc);
success = StrToU64(&s, &value, NULL);- In
Convert.c:293:
result = result && (!success);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:311:
// Test negative decimal conversion
StrDeinit(&s);
s = StrInitFromZstr("-12345", &alloc);
success = StrToI64(&s, &value, NULL);- In
Convert.c:317:
// Test hexadecimal conversion
StrDeinit(&s);
s = StrInitFromZstr("0xABCD", &alloc);
success = StrToI64(&s, &value, NULL);- In
Convert.c:323:
// Test binary conversion
StrDeinit(&s);
s = StrInitFromZstr("0b101010", &alloc);
success = StrToI64(&s, &value, NULL);- In
Convert.c:329:
// Test zero
StrDeinit(&s);
s = StrInitFromZstr("0", &alloc);
success = StrToI64(&s, &value, NULL);- In
Convert.c:335:
// Test invalid input
StrDeinit(&s);
s = StrInitFromZstr("not a number", &alloc);
success = StrToI64(&s, &value, NULL);- In
Convert.c:340:
result = result && (!success);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:358:
// Test fractional conversion
StrDeinit(&s);
s = StrInitFromZstr("123.456", &alloc);
success = StrToF64(&s, &value, NULL);- In
Convert.c:364:
// Test negative number
StrDeinit(&s);
s = StrInitFromZstr("-123.456", &alloc);
success = StrToF64(&s, &value, NULL);- In
Convert.c:370:
// Test scientific notation
StrDeinit(&s);
s = StrInitFromZstr("1.23e2", &alloc);
success = StrToF64(&s, &value, NULL);- In
Convert.c:376:
// Test zero
StrDeinit(&s);
s = StrInitFromZstr("0", &alloc);
success = StrToF64(&s, &value, NULL);- In
Convert.c:382:
// Test infinity
StrDeinit(&s);
s = StrInitFromZstr("inf", &alloc);
success = StrToF64(&s, &value, NULL);- In
Convert.c:388:
// Test negative infinity
StrDeinit(&s);
s = StrInitFromZstr("-inf", &alloc);
success = StrToF64(&s, &value, NULL);- In
Convert.c:394:
// Test NaN
StrDeinit(&s);
s = StrInitFromZstr("nan", &alloc);
success = StrToF64(&s, &value, NULL);- In
Convert.c:400:
// Test invalid input
StrDeinit(&s);
s = StrInitFromZstr("not a number", &alloc);
success = StrToF64(&s, &value, NULL);- In
Convert.c:405:
result = result && (!success);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:452:
result = result && success && (recovered_u64 == u64_values[i]);
StrDeinit(&s);
}- In
Convert.c:465:
result = result && success && (recovered_i64 == i64_values[i]);
StrDeinit(&s);
}- In
Convert.c:484:
result = result && success && (F64Abs(recovered_f64 - f64_values[i]) < tolerance);
StrDeinit(&s);
}
}- In
Convert.c:514:
result = result && success && (recovered == base);
StrDeinit(&s);
}- In
Convert.c:551:
result = result && success && (recovered_large > 1e299);
StrDeinit(&s);
// Test prefix handling
- In
Convert.c:573:
bool success = StrToU64(&test_str, &value, prefix_tests[i].base == 0 ? NULL : &config);
result = result && success && (value == prefix_tests[i].expected);
StrDeinit(&test_str);
}- In
Convert.c:605:
}
StrDeinit(&s);
}- In
Convert.c:627:
result = result && has_E;
StrDeinit(&s);
}- In
Convert.c:643:
result = result && success && (recovered == large_value);
StrDeinit(&s);
}- In
Convert.c:676:
result = result && success && (recovered == test_value);
StrDeinit(&s);
}- In
Convert.c:692:
result = result && success && (recovered == test_value);
StrDeinit(&s);
}- In
Convert.c:711:
result = result && success && (recovered == test_values[i]);
StrDeinit(&s);
if (!result)- In
Convert.c:743:
result = result && success && (recovered == test_value);
StrDeinit(&s);
if (!result)- In
Convert.c:768:
result = result && success && (F64Abs(recovered - test_value) < tolerance);
StrDeinit(&s);
if (!result)- In
Convert.c:787:
result = result && (success || !success); // Either succeeds or fails gracefully
StrDeinit(&long_str);
DefaultAllocatorDeinit(&alloc);- In
Convert.c:849:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64Abs(value - 1.5) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:862:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64Abs(value - 1.0) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:876:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64IsNan(value);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:889:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64IsInf(value) && value > 0;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:944:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64Abs(value - (-5.0)) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:957:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64Abs(value - 5.0) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:970:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64Abs(value - 42.0) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:983:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64Abs(value - 0.5) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:997:
bool ok = StrToF64(&s, &value, NULL); // non-strict default
bool pass = ok && F64Abs(value - 5.0) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1010:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64Abs(value - 0.01) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1023:
bool ok = StrToF64(&s, &value, NULL);
bool pass = ok && F64Abs(value - 100000.0) < 1e-6;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1038:
bool ok = StrToF64(&s, &value, &config);
bool pass = ok && F64Abs(value - 5.0) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1053:
bool ok = StrToF64(&s, &value, &config);
bool pass = ok && F64Abs(value - 5.0) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1068:
bool ok = StrToF64(&s, &value, &config);
bool pass = ok && F64Abs(value - 5.0) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1082:
bool ok = StrToF64(&s, &value, &config);
bool pass = ok && F64Abs(value - 42.0) < 1e-9;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1104:
bool result = (!ok);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1122:
bool result = (ok && value == 255);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1139:
bool result = (ok && value == 42);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1156:
bool result = (ok && value == 42);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1174:
bool result = (ok && value == 5);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1191:
bool result = (!ok);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1208:
bool result = (!ok);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1225:
bool result = (ok && value == 42);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1243:
bool result = (ok && value == 42);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1261:
bool result = (ok && value == 42);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1279:
bool result = (!ok);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1297:
bool result = (ok && value == 42);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1333:
WriteFmt(" FAIL: expected len 3 \"nan\", got len {} \"{}\"\n", StrLen(&s), StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1352:
WriteFmt(" FAIL: expected len 3 \"inf\", got len {} \"{}\"\n", StrLen(&s), StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1372:
WriteFmt(" FAIL: expected \"0.000100\", got \"{}\"\n", StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1392:
WriteFmt(" FAIL: expected \"1.00e+07\", got \"{}\"\n", StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1412:
WriteFmt(" FAIL: expected \"5e+00\", got \"{}\"\n", StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1431:
WriteFmt(" FAIL: expected \"5.00e+00\", got \"{}\"\n", StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1452:
WriteFmt(" FAIL: expected handle + \"1.23e+02\", got null={} \"{}\"\n", (r == NULL), StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1472:
WriteFmt(" FAIL: expected handle + \"123.00\", got null={} \"{}\"\n", (r == NULL), StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1492:
WriteFmt(" FAIL: expected \"123\", got \"{}\"\n", StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1512:
WriteFmt(" FAIL: expected \"123.456\", got \"{}\"\n", StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1533:
WriteFmt(" FAIL: expected \"0.124\", got \"{}\"\n", StrBegin(&s));
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1566:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 31;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1581:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 5;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1596:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 5;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1609:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 1;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1623:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 1;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1636:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 7;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1649:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 7;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1662:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 7;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1675:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 31;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1688:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 31;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1701:
bool ok = StrToU64(&s, &out, &cfg);
bool pass = ok && out == 31;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Convert.c:1720:
bool result = success && (value == -5);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1737:
bool result = success && (value == 5);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1753:
bool result = success && (value == -5);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1769:
bool result = success && (value == 5);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1793:
bool result = success && (value == 0) && (StrLen(&s) == 43);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1810:
bool result = success && (value == INT64_MIN);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1830:
bool result = (success == false);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1869:
bool result = (ZstrCompare(StrBegin(&s), "-9223372036854775808") == 0);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1892:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1912:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1937:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1962:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:1995:
}
StrDeinit(&s);
BudgetAllocatorDeinit(&bp);
return result;- In
Convert.c:2029:
}
StrDeinit(&s);
BudgetAllocatorDeinit(&bp);
return result;- In
Convert.c:2065:
}
StrDeinit(&s);
BudgetAllocatorDeinit(&bp);
return result;- In
Convert.c:2087:
bool result = ok && (value == 5);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Convert.c:2108:
bool result = (ok == false);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Foreach.c:50:
bool success = (ZstrCompare(StrBegin(&result), "H0e1l2l3o4") == 0);
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:51:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:75:
WriteFmt(" (Index 0 was processed)\n");
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:76:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:107:
success = success && (ZstrCompare(StrBegin(&s), "HELLO") == 0);
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:108:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:139:
WriteFmt(" (Index 0 was processed)\n");
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:140:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:163:
bool success = (ZstrCompare(StrBegin(&result), "Hello") == 0);
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:164:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:197:
}
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:198:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:229:
success = success && (ZstrCompare(StrBegin(&s), "HELLO") == 0);
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:230:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:271:
}
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:272:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:305:
success = success && (StrLen(&empty_result) == 0);
StrDeinit(&s);
StrDeinit(&result);
StrDeinit(&empty_result);- In
Foreach.c:306:
StrDeinit(&s);
StrDeinit(&result);
StrDeinit(&empty_result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:307:
StrDeinit(&s);
StrDeinit(&result);
StrDeinit(&empty_result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:340:
success = success && (ZstrCompare(StrBegin(&end_result), "World") == 0);
StrDeinit(&s);
StrDeinit(&result);
StrDeinit(&end_result);- In
Foreach.c:341:
StrDeinit(&s);
StrDeinit(&result);
StrDeinit(&end_result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:342:
StrDeinit(&s);
StrDeinit(&result);
StrDeinit(&end_result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:373:
success = success && (ZstrCompare(StrBegin(&s), "Hello WORLD") == 0);
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:374:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:405:
success = success && (ZstrCompare(StrBegin(&s), "HELLO World") == 0);
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Foreach.c:406:
StrDeinit(&s);
StrDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return success;- In
Foreach.c:437:
if (idx > 4) {
LOG_ERROR("Should've terminated");
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Foreach.c:443:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return true;- In
Foreach.c:474:
if (idx >= 5) {
LOG_ERROR("Should've terminated");
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Foreach.c:480:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return true;- In
Foreach.c:509:
if (idx < 10) {
LOG_ERROR("Should've terminated");
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Foreach.c:515:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return true;- In
Foreach.c:544:
if (idx > 4) {
LOG_ERROR("Should've terminated");
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Foreach.c:550:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return true;- In
Foreach.c:578:
if (idx < 12) {
LOG_ERROR("Should've terminated");
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Foreach.c:584:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return true;- In
Foreach.c:613:
if (idx >= StrLen(&s)) {
LOG_ERROR("Should've terminated");
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Foreach.c:619:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return true;- In
Foreach.c:652:
if (idx > 3) {
LOG_ERROR("Should've terminated");
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return false;- In
Foreach.c:658:
}
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return true;- In
Access.c:39:
result = result && StrEmpty(&s);
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Access.c:58:
bool result = (first == 'H');
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Access.c:77:
bool result = (last == 'o');
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Access.c:96:
bool result = (*begin == 'H');
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Access.c:116:
bool result = (*end == '\0');
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Access.c:140:
bool result = (c0 == 'H' && c1 == 'e' && c2 == 'l' && c3 == 'l' && c4 == 'o');
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result;- In
Access.c:164:
bool result = (*p0 == 'H' && *p1 == 'e' && *p2 == 'l' && *p3 == 'l' && *p4 == 'o');
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);
return result; if (StrIterIndex(&UNPL(read_si)) == StrIterIndex(&si)) { \
LOG_ERROR("Failed to read string key in object. Invalid JSON"); \
StrDeinit(&key); \
UNPL(failed) = true; \
si = UNPL(saved_si); \
if (!StrIterPeek(&si, &UNPL(jr_c)) || UNPL(jr_c) != ':') { \
LOG_ERROR("Expected ':' after key string. Failed to read JSON"); \
StrDeinit(&key); \
UNPL(failed) = true; \
si = UNPL(saved_si); \
if (StrIterIndex(&UNPL(skip_si)) == StrIterIndex(&si)) { \
LOG_ERROR("Failed to parse value. Invalid JSON."); \
StrDeinit(&key); \
UNPL(failed) = true; \
si = UNPL(saved_si); \
si = UNPL(skip_si); \
} \
StrDeinit(&key); \
si = JSkipWhitespace(si); \
UNPL(expect_comma) = true; \
- In
Backtrace.c:51:
#endif
StrDeinit(&rendered);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Backtrace.c:84:
ok = ok && ZstrFindSubstring(StrBegin(&rendered), "bt_vec_capture_outer") != NULL;
StrDeinit(&rendered);
VecDeinit(&frames);
DefaultAllocatorDeinit(&alloc);- In
Backtrace.c:113:
bool ok = StrLen(&out) > 0 && ZstrFindSubstring(StrBegin(&out), "bt_capture_with_helper") != NULL;
StrDeinit(&out);
SymbolResolverDeinit(&res);
DefaultAllocatorDeinit(&alloc);- In
Backtrace.c:157:
ok = ok && ZstrFindSubstring(StrBegin(&rendered), "cfi_capture_outer") != NULL;
StrDeinit(&rendered);
SymbolResolverDeinit(&res);
DefaultAllocatorDeinit(&alloc);- In
SysDns.c:82:
Str s = SocketAddrFormat(ad, a);
bool ok = (StrLen(&s) > 0) && ZstrCompare(StrBegin(&s), expect) == 0;
StrDeinit(&s);
return ok;
}- In
SysDns.c:92:
Str s = SocketAddrFormat(ad, a);
bool ok = (StrLen(&s) > 0) && ZstrCompare(StrBegin(&s), expect) == 0;
StrDeinit(&s);
return ok;
}- In
SysDns.c:113:
static void drop_temp(Str *path) {
FileRemove(path);
StrDeinit(path);
}- In
SysDns.c:136:
Str s = SocketAddrFormat(VecPtrAt(&r->nameservers, i), a);
bool ok = (StrLen(&s) > 0) && ZstrCompare(StrBegin(&s), expect) == 0;
StrDeinit(&s);
return ok;
}- In
SysDns.c:224:
Str s = SocketAddrFormat(VecPtrAt(&out, 0), a);
ok = (StrLen(&s) > 0) && ZstrCompare(StrBegin(&s), "203.0.113.7:9999") == 0;
StrDeinit(&s);
}- In
SysDns.c:248:
Str s = SocketAddrFormat(VecPtrAt(&out, 0), a);
ok = (StrLen(&s) > 0) && ZstrCompare(StrBegin(&s), "[::1]:443") == 0;
StrDeinit(&s);
}- In
SysDns.c:276:
ok = false;
}
StrDeinit(&s);
}
}- In
SysDns.c:301:
Str s = SocketAddrFormat(&one, a);
ok = (StrLen(&s) > 0) && ZstrCompare(StrBegin(&s), "127.0.0.1:80") == 0;
StrDeinit(&s);
}- In
SysDns.c:750:
drop_temp(&path);
StrDeinit(&body);
DnsResolverDeinit(&r);
DefaultAllocatorDeinit(&alloc);- In
SysDns.c:1303:
bool ok = added && VecLen(&r.hosts) == 1 && host_v4_is(find_host(&r.hosts, "lenhost"), 1, 2, 3, 4);
StrDeinit(&smeared);
drop_temp(&path);
DnsResolverDeinit(&r);- In
SysDns.c:1355:
FileRemove(&p1);
VecForeachPtr(&paths, p) {
StrDeinit(p);
}
VecDeinit(&paths);- In
SysDns.c:1386:
FileRemove(&p1);
VecForeachPtr(&paths, p) {
StrDeinit(p);
}
VecDeinit(&paths);- In
SysDns.c:1417:
FileRemove(&p1);
VecForeachPtr(&paths, p) {
StrDeinit(p);
}
VecDeinit(&paths);- In
SysDns.c:1710:
v4_is(VecPtrAt(&out, 1), a, "9.10.11.12:7000");
StrDeinit(&name);
VecDeinit(&out);
DnsResolverDeinit(&r);- In
SysDns.c:1903:
v4_is(VecPtrAt(&out, 1), a, "9.10.11.12:8080");
StrDeinit(&spec);
VecDeinit(&out);
DnsResolverDeinit(&r);- In
SysDns.c:1974:
bool ok = got && v4_is(&one, a, "5.6.7.8:80");
StrDeinit(&spec);
DnsResolverDeinit(&r);
DefaultAllocatorDeinit(&alloc);- In
Socket.c:49:
SocketAddr connect_addr;
bool parsed = SocketAddrParse(&connect_addr, (Zstr)StrBegin(&local_str), SOCKET_KIND_TCP);
StrDeinit(&local_str);
if (!parsed) {
ListenerClose(&listener);- In
Socket.c:104:
Str rendered = SocketAddrFormat(&addr, alloc_base);
ok = ok && StrLen(&rendered) > 0 && ZstrCompare(StrBegin(&rendered), "127.0.0.1:8080") == 0;
StrDeinit(&rendered);
}- In
Socket.c:115:
Str rendered = SocketAddrFormat(&addr, alloc_base);
ok = ok && StrLen(&rendered) > 0 && ZstrCompare(StrBegin(&rendered), "[::1]:8080") == 0;
StrDeinit(&rendered);
}- In
Socket.c:167:
SocketAddr connect_addr;
bool parsed = SocketAddrParse(&connect_addr, (Zstr)StrBegin(&local_str), SOCKET_KIND_TCP);
StrDeinit(&local_str);
if (!parsed) {
ListenerClose(&p.listener);- In
Socket.c:648:
Str r = SocketAddrFormat(&addr, a);
ok = StrLen(&r) > 0 && ZstrCompare(StrBegin(&r), expect) == 0;
StrDeinit(&r);
}- In
Socket.c:787:
Str s = SocketAddrFormat(&addr, a);
ok = ok && StrLen(&s) > 0 && ZstrCompare(StrBegin(&s), "1.2.3.4:80") == 0;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Socket.c:804:
Str s = SocketAddrFormat(&addr, a);
ok = ok && StrLen(&s) > 0 && ZstrCompare(StrBegin(&s), "10.0.0.1:4660") == 0;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Socket.c:833:
Str s = SocketAddrFormat(&addr, a);
ok = ok && StrLen(&s) > 0 && ZstrCompare(StrBegin(&s), "[2001:db8::1]:443") == 0;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Socket.c:850:
Str s = SocketAddrFormat(&addr, a);
ok = ok && StrLen(&s) > 0 && ZstrCompare(StrBegin(&s), "[::1]:8080") == 0;
StrDeinit(&s);
DefaultAllocatorDeinit(&alloc);- In
Socket.c:936:
Str s = SocketAddrFormat(&local, a);
ok = ok && StrLen(&s) > 0 && ZstrCompare(StrBegin(&s), "127.0.0.1:4660") == 0;
StrDeinit(&s);
ListenerClose(&listener);- In
Socket.c:976:
ok = ok && ZstrCompare(rendered, "127.0.0.1:0") != 0;
}
StrDeinit(&s);
ListenerClose(&listener);- In
Socket.c:1011:
SocketAddr connect_addr;
bool parsed = SocketAddrParse(&connect_addr, (Zstr)StrBegin(&local_str), SOCKET_KIND_TCP);
StrDeinit(&local_str);
if (!parsed) {
ListenerClose(&listener);- In
Socket.c:1119:
SocketAddr connect_addr;
bool parsed = SocketAddrParse(&connect_addr, (Zstr)StrBegin(&local_str), SOCKET_KIND_TCP);
StrDeinit(&local_str);
if (!parsed) {
ListenerClose(listener);- In
Socket.c:1173:
Zstr p = StrBegin(&peer);
ok = ok && StrLen(&peer) > 0 && p[0] == '1' && p[1] == '2' && p[2] == '7' && p[3] == '.';
StrDeinit(&peer);
}- In
Socket.c:1271:
Zstr r = StrBegin(&rendered);
ok = ok && r[0] == '1' && r[1] == '2' && r[2] == '7' && r[3] == '.';
StrDeinit(&rendered);
SocketClose(&server);- In
Socket.c:1485:
Str r = SocketAddrFormat(&addr, a);
ok = ok && ZstrCompare(StrBegin(&r), "127.0.0.1:65535") == 0;
StrDeinit(&r);
}
}- In
Socket.c:1497:
Str r = SocketAddrFormat(&addr, a);
ok = ok && ZstrCompare(StrBegin(&r), "127.0.0.1:0") == 0;
StrDeinit(&r);
}
}- In
Socket.c:1509:
Str r = SocketAddrFormat(&addr, a);
ok = ok && ZstrCompare(StrBegin(&r), "1.2.3.4:4660") == 0;
StrDeinit(&r);
}
}- In
Socket.c:1549:
Str r = SocketAddrFormat(&addr, a);
ok = ok && ZstrCompare(StrBegin(&r), "1.2.3.4:4660") == 0;
StrDeinit(&r);
}
StrDeinit(&spec);- In
Socket.c:1551:
StrDeinit(&r);
}
StrDeinit(&spec);
// NULL spec -> rejected, out zeroed.
- In
Socket.c:1579:
Str r = SocketAddrFormat(&empty, a);
ok = ok && StrLen(&r) == 0;
StrDeinit(&r);
}- In
Socket.c:1590:
Str r = SocketAddrFormat(&addr, a);
ok = ok && ZstrCompare(StrBegin(&r), "[::1]:4660") == 0;
StrDeinit(&r);
}
}- In
Socket.c:1617:
Str r = SocketAddrFormat(&addr, a);
ok = StrLen(&r) > 0 && ZstrCompare(StrBegin(&r), expect) == 0;
StrDeinit(&r);
}- In
Socket.c:1676:
Str s = SocketAddrFormat(&local, a);
ok = ok && StrLen(&s) > 0 && ZstrCompareN(StrBegin(&s), "127.0.0.1:", 10u) == 0;
StrDeinit(&s);
ListenerClose(&listener);- In
MachoCache.c:883:
ok = ok && !MachoCacheResolve(&cache, &mod, 0, 0xdeadbeefull, &name, &off);
StrDeinit(&mod);
MachoCacheDeinit(&cache);
FileRemove(bin_path);- In
Pe.c:1653:
File f = FileOpenTemp(&path, base);
if (!FileIsOpen(&f)) {
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return false;- In
Pe.c:1660:
if (FileWriteAndClose((Zstr)StrBegin(&path), blob, sizeof(blob)) < 0) {
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return false;- In
Pe.c:1674:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Pe.c:1695:
File f = FileOpenTemp(&path, base);
if (!FileIsOpen(&f)) {
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return false;- In
Pe.c:1702:
if (FileWriteAndClose((Zstr)StrBegin(&path), junk, sizeof(junk)) < 0) {
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return false;- In
Pe.c:1713:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return !opened;- In
Dns.c:486:
VecDeinit(&buf);
StrDeinit(&name);
DefaultAllocatorDeinit(&alloc);
return match;- In
ProcMaps.c:593:
if (!wrote_ok) {
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return false;- In
ProcMaps.c:601:
if (!FileIsOpen(&rf)) {
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return false;- In
ProcMaps.c:621:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Http.c:47:
StrAppendFmt(&body, "<h1>hi</h1>");
HttpRespondWithHtml(&response, HTTP_RESPONSE_CODE_OK, &body);
StrDeinit(&body);
Str wire = HttpResponseSerialize(&response, alloc_base);- In
Http.c:61:
ZstrFindSubstring(StrBegin(&wire), "\r\n\r\n<h1>hi</h1>") != NULL;
StrDeinit(&wire);
HttpResponseDeinit(&response);
DefaultAllocatorDeinit(&alloc);- In
Http.c:173:
HttpRequestDeinit(&req);
StrDeinit(&raw);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Http.c:199:
HttpRequestDeinit(&req);
StrDeinit(&raw);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Http.c:230:
FileRemove(StrBegin(&path));
StrDeinit(&path);
HttpResponseDeinit(&response);
DefaultAllocatorDeinit(&alloc);- In
Http.c:255:
FileRemove(StrBegin(&path));
StrDeinit(&path);
HttpResponseDeinit(&response);
DefaultAllocatorDeinit(&alloc);- In
Http.c:361:
HttpRespondWithHtml(&response, HTTP_RESPONSE_CODE_OK, &second);
StrDeinit(&first);
StrDeinit(&second);
HttpResponseDeinit(&response);- In
Http.c:362:
StrDeinit(&first);
StrDeinit(&second);
HttpResponseDeinit(&response);
bool ok = (DebugAllocatorLiveCount(&dbg) == 0);- In
Http.c:384:
HttpResponse response = HttpResponseInit(adbg);
HttpRespondWithHtml(&response, HTTP_RESPONSE_CODE_OK, &first);
StrDeinit(&first);
// Create a temp file with content.
- In
Http.c:400:
FileRemove(StrBegin(&path));
StrDeinit(&path);
HttpResponseDeinit(&response);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);- In
MachO.c:1434:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
MachO.c:1471:
FileRemove(&path);
StrDeinit(&path);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Read.Simple.c:38:
// Cleanup functions
void PersonDeinit(Person *person) {
StrDeinit(&person->name);
}- In
Read.Simple.c:42:
void ConfigDeinit(Config *config) {
StrDeinit(&config->log_level);
}- In
Read.Simple.c:46:
void SimpleProductDeinit(SimpleProduct *product) {
StrDeinit(&product->name);
VecDeinit(&product->tags);
}- In
Read.Simple.c:96:
}
StrDeinit(&json);
StrDeinit(&name);
StrDeinit(&city);- In
Read.Simple.c:97:
StrDeinit(&json);
StrDeinit(&name);
StrDeinit(&city);
DefaultAllocatorDeinit(&alloc);- In
Read.Simple.c:98:
StrDeinit(&json);
StrDeinit(&name);
StrDeinit(&city);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
PersonDeinit(&person);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
ConfigDeinit(&config);
DefaultAllocatorDeinit(&alloc); StrIter si = StrIterFromStr(json);
Vec(Str) languages = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
JR_OBJ(si, { }
StrDeinit(&json);
VecDeinit(&languages);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
StrDeinit(&data.user.name);
StrDeinit(&data.user.email);
StrDeinit(&json);
StrDeinit(&data.user.name);
StrDeinit(&data.user.email);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&data.user.name);
StrDeinit(&data.user.email);
DefaultAllocatorDeinit(&alloc);
return success; SimpleProduct product = {0};
product.name = StrInit(&alloc);
product.tags = VecInitWithDeepCopyT(product.tags, NULL, StrDeinit, &alloc);
JR_OBJ(si, { }
StrDeinit(&json);
SimpleProductDeinit(&product);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&expected_str);
StrDeinit(&output_clean);
StrDeinit(&expected_clean);
StrDeinit(&expected_str);
StrDeinit(&output_clean);
StrDeinit(&expected_clean);
return result; StrDeinit(&expected_str);
StrDeinit(&output_clean);
StrDeinit(&expected_clean);
return result;
} }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success;
Vec(i32) empty_numbers = VecInit(&alloc);
Vec(Str) empty_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
JW_OBJ(json, { }
StrDeinit(&json);
VecDeinit(&empty_numbers);
VecDeinit(&empty_strings); }
StrDeinit(&json);
StrDeinit(&empty_name);
StrDeinit(&empty_desc);
StrDeinit(&json);
StrDeinit(&empty_name);
StrDeinit(&empty_desc);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&empty_name);
StrDeinit(&empty_desc);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; WriteFmtLn("[DEBUG] Large numbers JSON: {}", json);
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit(&path);
StrDeinit(&message);
StrDeinit(&json);
StrDeinit(&path);
StrDeinit(&message);
StrDeinit(&data); StrDeinit(&json);
StrDeinit(&path);
StrDeinit(&message);
StrDeinit(&data);
DefaultAllocatorDeinit(&alloc); StrDeinit(&path);
StrDeinit(&message);
StrDeinit(&data);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit("es);
StrDeinit(&backslash);
StrDeinit(&json);
StrDeinit("es);
StrDeinit(&backslash);
StrDeinit(&newline); StrDeinit(&json);
StrDeinit("es);
StrDeinit(&backslash);
StrDeinit(&newline);
StrDeinit(&tab); StrDeinit("es);
StrDeinit(&backslash);
StrDeinit(&newline);
StrDeinit(&tab);
DefaultAllocatorDeinit(&alloc); StrDeinit(&backslash);
StrDeinit(&newline);
StrDeinit(&tab);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
VecDeinit(&empty_list);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
VecDeinit(&empty_arr);
VecDeinit(&filled_arr); }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; success = false;
StrDeinit(&json1);
StrDeinit(&json2);
StrDeinit(&json3);
StrDeinit(&json1);
StrDeinit(&json2);
StrDeinit(&json3);
StrDeinit(&json4); StrDeinit(&json1);
StrDeinit(&json2);
StrDeinit(&json3);
StrDeinit(&json4);
StrDeinit(&single_str); StrDeinit(&json2);
StrDeinit(&json3);
StrDeinit(&json4);
StrDeinit(&single_str);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json3);
StrDeinit(&json4);
StrDeinit(&single_str);
DefaultAllocatorDeinit(&alloc);
return success; // Cleanup functions
void AnnSymbolDeinit(AnnSymbol *sym) {
StrDeinit(&sym->analysis_name);
StrDeinit(&sym->function_name);
StrDeinit(&sym->sha256); void AnnSymbolDeinit(AnnSymbol *sym) {
StrDeinit(&sym->analysis_name);
StrDeinit(&sym->function_name);
StrDeinit(&sym->sha256);
StrDeinit(&sym->function_mangled_name); StrDeinit(&sym->analysis_name);
StrDeinit(&sym->function_name);
StrDeinit(&sym->sha256);
StrDeinit(&sym->function_mangled_name);
} StrDeinit(&sym->function_name);
StrDeinit(&sym->sha256);
StrDeinit(&sym->function_mangled_name);
}
void FunctionInfoDeinit(FunctionInfo *info) {
StrDeinit(&info->name);
}
void SearchResultDeinit(SearchResult *result) {
StrDeinit(&result->binary_name);
StrDeinit(&result->sha256);
VecDeinit(&result->tags); void SearchResultDeinit(SearchResult *result) {
StrDeinit(&result->binary_name);
StrDeinit(&result->sha256);
VecDeinit(&result->tags);
StrDeinit(&result->created_at); StrDeinit(&result->sha256);
VecDeinit(&result->tags);
StrDeinit(&result->created_at);
StrDeinit(&result->model_name);
StrDeinit(&result->owned_by); VecDeinit(&result->tags);
StrDeinit(&result->created_at);
StrDeinit(&result->model_name);
StrDeinit(&result->owned_by);
} StrDeinit(&result->created_at);
StrDeinit(&result->model_name);
StrDeinit(&result->owned_by);
} }
StrDeinit(&expected_str);
StrDeinit(&output_clean);
StrDeinit(&expected_clean);
StrDeinit(&expected_str);
StrDeinit(&output_clean);
StrDeinit(&expected_clean);
return result; StrDeinit(&expected_str);
StrDeinit(&output_clean);
StrDeinit(&expected_clean);
return result;
} }
StrDeinit(&json);
StrDeinit(&data.user.profile.name);
StrDeinit(&data.status);
StrDeinit(&json);
StrDeinit(&data.user.profile.name);
StrDeinit(&data.status);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&data.user.profile.name);
StrDeinit(&data.status);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit(&data.company.departments.engineering.head);
StrDeinit(&data.company.name);
StrDeinit(&json);
StrDeinit(&data.company.departments.engineering.head);
StrDeinit(&data.company.name);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&data.company.departments.engineering.head);
StrDeinit(&data.company.name);
DefaultAllocatorDeinit(&alloc);
return success; });
StrDeinit(&target_key);
}
}); });
StrDeinit(&source_key);
});
}); }
StrDeinit(&json);
StrDeinit(&response.message);
VecDeinit(&response.data);
StrDeinit(&json);
StrDeinit(&response.message);
VecDeinit(&response.data);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
VecDeinit(&functions);
DefaultAllocatorDeinit(&alloc); result.analysis_id = 999;
result.sha256 = StrInitFromZstr("abc123", &alloc);
result.tags = VecInitWithDeepCopyT(result.tags, NULL, StrDeinit, &alloc);
// Create strings and push them properly
}
StrDeinit(&json);
SearchResultDeinit(&result);
DefaultAllocatorDeinit(&alloc); });
StrDeinit(&target_key);
}); });
StrDeinit(&source_key);
}
}); }
StrDeinit(&json);
VecDeinit(&symbols);
return success; }
StrDeinit(&json);
StrDeinit(&deep_message);
StrDeinit(&test_name);
StrDeinit(&json);
StrDeinit(&deep_message);
StrDeinit(&test_name);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&deep_message);
StrDeinit(&test_name);
DefaultAllocatorDeinit(&alloc);
return success; VecPushBack(&numbers, num3);
Vec(Str) strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
// Create strings and push them properly
}
StrDeinit(&json);
VecDeinit(&numbers);
VecDeinit(&strings);- In
Read.Nested.c:37:
void AnnSymbolDeinit(AnnSymbol *sym) {
StrDeinit(&sym->analysis_name);
StrDeinit(&sym->function_name);
StrDeinit(&sym->sha256);- In
Read.Nested.c:38:
void AnnSymbolDeinit(AnnSymbol *sym) {
StrDeinit(&sym->analysis_name);
StrDeinit(&sym->function_name);
StrDeinit(&sym->sha256);
StrDeinit(&sym->function_mangled_name);- In
Read.Nested.c:39:
StrDeinit(&sym->analysis_name);
StrDeinit(&sym->function_name);
StrDeinit(&sym->sha256);
StrDeinit(&sym->function_mangled_name);
}- In
Read.Nested.c:40:
StrDeinit(&sym->function_name);
StrDeinit(&sym->sha256);
StrDeinit(&sym->function_mangled_name);
}- In
Read.Nested.c:75:
void FunctionInfoDeinit(FunctionInfo *info) {
StrDeinit(&info->name);
}- In
Read.Nested.c:79:
void ModelInfoDeinit(ModelInfo *info) {
StrDeinit(&info->name);
}- In
Read.Nested.c:83:
void SearchResultDeinit(SearchResult *result) {
StrDeinit(&result->binary_name);
StrDeinit(&result->sha256);
VecForeach(&result->tags, tag) {- In
Read.Nested.c:84:
void SearchResultDeinit(SearchResult *result) {
StrDeinit(&result->binary_name);
StrDeinit(&result->sha256);
VecForeach(&result->tags, tag) {
StrDeinit(&tag);- In
Read.Nested.c:86:
StrDeinit(&result->sha256);
VecForeach(&result->tags, tag) {
StrDeinit(&tag);
}
VecDeinit(&result->tags);- In
Read.Nested.c:89:
}
VecDeinit(&result->tags);
StrDeinit(&result->created_at);
StrDeinit(&result->model_name);
StrDeinit(&result->owned_by);- In
Read.Nested.c:90:
VecDeinit(&result->tags);
StrDeinit(&result->created_at);
StrDeinit(&result->model_name);
StrDeinit(&result->owned_by);
}- In
Read.Nested.c:91:
StrDeinit(&result->created_at);
StrDeinit(&result->model_name);
StrDeinit(&result->owned_by);
} }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit(&data.name);
DefaultAllocatorDeinit(&alloc);
StrDeinit(&json);
StrDeinit(&data.name);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit(&data.user.profile.name);
StrDeinit(&data.status);
StrDeinit(&json);
StrDeinit(&data.user.profile.name);
StrDeinit(&data.status);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&data.user.profile.name);
StrDeinit(&data.status);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit(&data.company.departments.engineering.head);
StrDeinit(&data.company.name);
StrDeinit(&json);
StrDeinit(&data.company.departments.engineering.head);
StrDeinit(&data.company.name);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&data.company.departments.engineering.head);
StrDeinit(&data.company.name);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
VecDeinit(&symbols);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
StrDeinit(&response.message);
VecDeinit(&response.data);
StrDeinit(&json);
StrDeinit(&response.message);
VecDeinit(&response.data);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
StrDeinit(&info.name);
DefaultAllocatorDeinit(&alloc);
StrDeinit(&json);
StrDeinit(&info.name);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit(&info.name);
DefaultAllocatorDeinit(&alloc);
StrDeinit(&json);
StrDeinit(&info.name);
DefaultAllocatorDeinit(&alloc);
return success; result.binary_name = StrInit(&alloc);
result.sha256 = StrInit(&alloc);
result.tags = VecInitWithDeepCopyT(result.tags, NULL, StrDeinit, &alloc);
result.created_at = StrInit(&alloc);
result.model_name = StrInit(&alloc); }
StrDeinit(&json);
SearchResultDeinit(&result);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
StrDeinit(&response.message);
VecDeinit(&response.data);
StrDeinit(&json);
StrDeinit(&response.message);
VecDeinit(&response.data);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
StrDeinit(&response.message);
VecDeinit(&response.data);
StrDeinit(&json);
StrDeinit(&response.message);
VecDeinit(&response.data);
DefaultAllocatorDeinit(&alloc); // Cleanup functions
void PersonDeinit(Person *person) {
StrDeinit(&person->name);
}
void ConfigDeinit(Config *config) {
StrDeinit(&config->log_level);
}
void SimpleProductDeinit(SimpleProduct *product) {
StrDeinit(&product->name);
VecDeinit(&product->tags);
} }
StrDeinit(&expected_str);
StrDeinit(&output_clean);
StrDeinit(&expected_clean);
StrDeinit(&expected_str);
StrDeinit(&output_clean);
StrDeinit(&expected_clean);
return result; StrDeinit(&expected_str);
StrDeinit(&output_clean);
StrDeinit(&expected_clean);
return result;
} }
StrDeinit(&json);
StrDeinit(&name);
StrDeinit(&city);
StrDeinit(&json);
StrDeinit(&name);
StrDeinit(&city);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&name);
StrDeinit(&city);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
PersonDeinit(&person);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
ConfigDeinit(&config);
DefaultAllocatorDeinit(&alloc); Str json = StrInit(&alloc);
Vec(Str) languages = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
// Create strings and push them properly
}
StrDeinit(&json);
VecDeinit(&languages);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
StrDeinit(&data.user.name);
StrDeinit(&data.user.email);
StrDeinit(&json);
StrDeinit(&data.user.name);
StrDeinit(&data.user.email);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&data.user.name);
StrDeinit(&data.user.email);
DefaultAllocatorDeinit(&alloc);
return success; product.name = StrInitFromZstr("Laptop", &alloc);
product.price = 999.99;
product.tags = VecInitWithDeepCopyT(product.tags, NULL, StrDeinit, &alloc);
// Create strings and push them properly
}
StrDeinit(&json);
SimpleProductDeinit(&product);
DefaultAllocatorDeinit(&alloc);
void EdgeCaseDataDeinit(EdgeCaseData *data) {
StrDeinit(&data->empty_string);
VecDeinit(&data->empty_array);
VecDeinit(&data->numbers); }
StrDeinit(&json1);
StrDeinit(&json2);
DefaultAllocatorDeinit(&alloc);
StrDeinit(&json1);
StrDeinit(&json2);
DefaultAllocatorDeinit(&alloc);
return success; StrIter si2 = StrIterFromStr(json2);
Vec(Str) data = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
JR_OBJ(si2, { }
StrDeinit(&json1);
StrDeinit(&json2);
VecDeinit(&items);
StrDeinit(&json1);
StrDeinit(&json2);
VecDeinit(&items);
VecDeinit(&data); }
StrDeinit(&json);
StrDeinit(&obj.name);
StrDeinit(&obj.description);
StrDeinit(&json);
StrDeinit(&obj.name);
StrDeinit(&obj.description);
DefaultAllocatorDeinit(&alloc); StrDeinit(&json);
StrDeinit(&obj.name);
StrDeinit(&obj.description);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit(&obj.path);
StrDeinit(&obj.message);
StrDeinit(&json);
StrDeinit(&obj.path);
StrDeinit(&obj.message);
StrDeinit(&obj.data); StrDeinit(&json);
StrDeinit(&obj.path);
StrDeinit(&obj.message);
StrDeinit(&obj.data);
DefaultAllocatorDeinit(&alloc); StrDeinit(&obj.path);
StrDeinit(&obj.message);
StrDeinit(&obj.data);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit(&obj.quote);
StrDeinit(&obj.backslash);
StrDeinit(&json);
StrDeinit(&obj.quote);
StrDeinit(&obj.backslash);
StrDeinit(&obj.slash); StrDeinit(&json);
StrDeinit(&obj.quote);
StrDeinit(&obj.backslash);
StrDeinit(&obj.slash);
StrDeinit(&obj.backspace); StrDeinit(&obj.quote);
StrDeinit(&obj.backslash);
StrDeinit(&obj.slash);
StrDeinit(&obj.backspace);
StrDeinit(&obj.formfeed); StrDeinit(&obj.backslash);
StrDeinit(&obj.slash);
StrDeinit(&obj.backspace);
StrDeinit(&obj.formfeed);
StrDeinit(&obj.newline); StrDeinit(&obj.slash);
StrDeinit(&obj.backspace);
StrDeinit(&obj.formfeed);
StrDeinit(&obj.newline);
StrDeinit(&obj.carriage); StrDeinit(&obj.backspace);
StrDeinit(&obj.formfeed);
StrDeinit(&obj.newline);
StrDeinit(&obj.carriage);
StrDeinit(&obj.tab); StrDeinit(&obj.formfeed);
StrDeinit(&obj.newline);
StrDeinit(&obj.carriage);
StrDeinit(&obj.tab);
DefaultAllocatorDeinit(&alloc); StrDeinit(&obj.newline);
StrDeinit(&obj.carriage);
StrDeinit(&obj.tab);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
StrDeinit(&obj.name);
DefaultAllocatorDeinit(&alloc);
StrDeinit(&json);
StrDeinit(&obj.name);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
VecDeinit(&obj.filled_items);
DefaultAllocatorDeinit(&alloc); }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; success = false;
}
StrDeinit(&j);
}
{ success = false;
}
StrDeinit(&j);
}
// Input too short to spell a bool -- must fail (the >= length guard).
success = false;
}
StrDeinit(&j);
}
// JReadNull on a 'n...' token that isn't "null".
success = false;
}
StrDeinit(&j);
} success = false;
}
StrDeinit(&j);
}
{ success = false;
}
StrDeinit(&j);
}
{ success = false;
}
StrDeinit(&j);
} success = false;
}
StrDeinit(&j);
}
{ success = false;
}
StrDeinit(&j);
}
{ success = false;
}
StrDeinit(&j);
} success = false;
}
StrDeinit(&out);
StrDeinit(&j);
} }
StrDeinit(&out);
StrDeinit(&j);
} success = false;
}
StrDeinit(&out);
StrDeinit(&j);
} }
StrDeinit(&out);
StrDeinit(&j);
} success = false;
}
StrDeinit(&out);
StrDeinit(&j);
} }
StrDeinit(&out);
StrDeinit(&j);
} }
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&json);
} success = false;
}
StrDeinit(&j);
}
{ success = false;
}
StrDeinit(&j);
}
{ success = false;
}
StrDeinit(&j);
} }
StrDeinit(&j);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&j);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&j);
DefaultAllocatorDeinit(&alloc);
return success; }
StrDeinit(&j);
DefaultAllocatorDeinit(&alloc);
return success;- In
RoundTrip.c:40:
// Cleanup functions
void TestPersonDeinit(TestPerson *person) {
StrDeinit(&person->name);
}- In
RoundTrip.c:44:
void TestConfigDeinit(TestConfig *config) {
StrDeinit(&config->log_level);
VecDeinit(&config->features);
}- In
RoundTrip.c:153:
}
StrDeinit(&json);
StrDeinit(&original.message);
StrDeinit(&parsed.message);- In
RoundTrip.c:154:
StrDeinit(&json);
StrDeinit(&original.message);
StrDeinit(&parsed.message);
DefaultAllocatorDeinit(&alloc);- In
RoundTrip.c:155:
StrDeinit(&json);
StrDeinit(&original.message);
StrDeinit(&parsed.message);
DefaultAllocatorDeinit(&alloc);
return success;- In
RoundTrip.c:230:
}
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success;- In
RoundTrip.c:285:
}
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success;- In
RoundTrip.c:347:
// Cleanup
StrDeinit(&json);
StrDeinit(&original.empty);
StrDeinit(&original.simple);- In
RoundTrip.c:348:
// Cleanup
StrDeinit(&json);
StrDeinit(&original.empty);
StrDeinit(&original.simple);
StrDeinit(&original.with_spaces);- In
RoundTrip.c:349:
StrDeinit(&json);
StrDeinit(&original.empty);
StrDeinit(&original.simple);
StrDeinit(&original.with_spaces);
StrDeinit(&original.with_special);- In
RoundTrip.c:350:
StrDeinit(&original.empty);
StrDeinit(&original.simple);
StrDeinit(&original.with_spaces);
StrDeinit(&original.with_special);
StrDeinit(&parsed.empty);- In
RoundTrip.c:351:
StrDeinit(&original.simple);
StrDeinit(&original.with_spaces);
StrDeinit(&original.with_special);
StrDeinit(&parsed.empty);
StrDeinit(&parsed.simple);- In
RoundTrip.c:352:
StrDeinit(&original.with_spaces);
StrDeinit(&original.with_special);
StrDeinit(&parsed.empty);
StrDeinit(&parsed.simple);
StrDeinit(&parsed.with_spaces);- In
RoundTrip.c:353:
StrDeinit(&original.with_special);
StrDeinit(&parsed.empty);
StrDeinit(&parsed.simple);
StrDeinit(&parsed.with_spaces);
StrDeinit(&parsed.with_special);- In
RoundTrip.c:354:
StrDeinit(&parsed.empty);
StrDeinit(&parsed.simple);
StrDeinit(&parsed.with_spaces);
StrDeinit(&parsed.with_special);
DefaultAllocatorDeinit(&alloc);- In
RoundTrip.c:355:
StrDeinit(&parsed.simple);
StrDeinit(&parsed.with_spaces);
StrDeinit(&parsed.with_special);
DefaultAllocatorDeinit(&alloc);
return success;- In
RoundTrip.c:370:
// Original data
Vec(i32) original_numbers = VecInit(&alloc);
Vec(Str) original_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
// Populate arrays
- In
RoundTrip.c:398:
// Read back from JSON
Vec(i32) parsed_numbers = VecInit(&alloc);
Vec(Str) parsed_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
StrIter si = StrIterFromStr(json);- In
RoundTrip.c:457:
// Cleanup
StrDeinit(&json);
VecDeinit(&original_numbers);
VecDeinit(&original_strings);- In
RoundTrip.c:512:
// Cleanup
StrDeinit(&json);
TestPersonDeinit(&original_person);
TestPersonDeinit(&parsed_person);- In
RoundTrip.c:538:
original.config.timeout = 30;
original.config.log_level = StrInitFromZstr("INFO", &alloc);
original.config.features = VecInitWithDeepCopyT(original.config.features, NULL, StrDeinit, &alloc);
// Create strings and push them properly
- In
RoundTrip.c:587:
parsed.config.timeout = 0;
parsed.config.log_level = StrInit(&alloc);
parsed.config.features = VecInitWithDeepCopyT(parsed.config.features, NULL, StrDeinit, &alloc);
parsed.numbers = VecInitT(parsed.numbers, &alloc);
parsed.flags = VecInitT(parsed.flags, &alloc);- In
RoundTrip.c:658:
// Cleanup
StrDeinit(&json);
ComplexDataDeinit(&original);
ComplexDataDeinit(&parsed);- In
RoundTrip.c:675:
// Original empty data
Vec(i32) empty_numbers = VecInit(&alloc);
Vec(Str) empty_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
Str empty_str = StrInit(&alloc);- In
RoundTrip.c:695:
// Read back from JSON
Vec(i32) parsed_numbers = VecInit(&alloc);
Vec(Str) parsed_strings = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
Str parsed_str = StrInit(&alloc);
bool found_empty_object = false;- In
RoundTrip.c:732:
// Cleanup
StrDeinit(&json);
StrDeinit(&empty_str);
StrDeinit(&parsed_str);- In
RoundTrip.c:733:
// Cleanup
StrDeinit(&json);
StrDeinit(&empty_str);
StrDeinit(&parsed_str);
VecDeinit(&empty_numbers);- In
RoundTrip.c:734:
StrDeinit(&json);
StrDeinit(&empty_str);
StrDeinit(&parsed_str);
VecDeinit(&empty_numbers);
VecDeinit(&empty_strings);- In
RoundTrip.c:802:
}
StrDeinit(&json);
DefaultAllocatorDeinit(&alloc);
return success;- In
Parse.c:25:
ok = got && (StrCmp(got, expect) == 0);
StrDeinit(&text);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:51:
result = result && (v == true);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:74:
result = result && StrIterPeek(&si, &c) && (c == 'Z');
StrDeinit(&src);
DefaultAllocatorDeinit(&alloc);
return result;- In
Parse.c:96:
result = result && StrIterPeek(&si, &c) && (c == '\n');
StrDeinit(&src);
DefaultAllocatorDeinit(&alloc);
return result;- In
Parse.c:119:
result = result && KvConfigGetI64(&cfg, "b", &b) && (b == 2);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:180:
result = result && v && (StrLen(v) == 0);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:210:
result = result && KvConfigGetI64(&cfg, "b", &b) && (b == 2);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:233:
result = result && !KvConfigContains(&cfg, "k");
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:257:
result = result && v && (StrCmp(v, "v") == 0);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:282:
result = result && v && (StrCmp(v, "v") == 0);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:303:
result = result && KvConfigContains(&cfg, "k");
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:332:
result = result && KvConfigGetBool(&cfg, "debug", &debug) && debug;
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:366:
result = result && empty && (StrLen(empty) == 0);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:398:
result = result && (StrCmp(stored_host, "localhost") == 0);
StrDeinit(&host_copy);
StrDeinit(&src);
MapDeinit(&cfg);- In
Parse.c:399:
StrDeinit(&host_copy);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:433:
result = result && !KvConfigGetF64(&cfg, "missing", &pi);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:457:
result = result && !KvConfigContains(&cfg, "later");
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:500:
result = result && !KvConfigGetBool(&cfg, "bad", &v);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:537:
Str got = KvConfigGet(&cfg, &k_name);
result = result && (StrCmp(&got, "misra") == 0);
StrDeinit(&got);
// typed accessors via Str*
- In
Parse.c:547:
result = result && KvConfigGetBool(&cfg, &k_enabled, &en) && en;
StrDeinit(&k_name);
StrDeinit(&k_missing);
StrDeinit(&k_workers);- In
Parse.c:548:
StrDeinit(&k_name);
StrDeinit(&k_missing);
StrDeinit(&k_workers);
StrDeinit(&k_ratio);- In
Parse.c:549:
StrDeinit(&k_name);
StrDeinit(&k_missing);
StrDeinit(&k_workers);
StrDeinit(&k_ratio);
StrDeinit(&k_enabled);- In
Parse.c:550:
StrDeinit(&k_missing);
StrDeinit(&k_workers);
StrDeinit(&k_ratio);
StrDeinit(&k_enabled);
StrDeinit(&src);- In
Parse.c:551:
StrDeinit(&k_workers);
StrDeinit(&k_ratio);
StrDeinit(&k_enabled);
StrDeinit(&src);
MapDeinit(&cfg);- In
Parse.c:552:
StrDeinit(&k_ratio);
StrDeinit(&k_enabled);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:585:
result = result && c && (StrCmp(c, "no-trailing-space") == 0);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:619:
result = result && KvConfigGetI64(&cfg, "port", &port) && (port == 8080);
StrDeinit(&src);
MapDeinit(&cfg);
DefaultAllocatorDeinit(&alloc);- In
Parse.c:648:
(void)KvConfigParse(input, &cfg);
StrDeinit(&text);
MapDeinit(&cfg);- In
Parse.c:713:
bool ok = got && (StrCmp(got, "spaced-out-value-here") == 0);
StrDeinit(&text);
MapDeinit(&cfg);- In
Parse.c:744:
bool ok = got && (StrCmp(got, "v") == 0);
StrDeinit(&text);
MapDeinit(&cfg);- In
Parse.c:774:
bool ok = got && (StrCmp(got, "a-reasonably-long-config-value") == 0);
StrDeinit(&text);
MapDeinit(&cfg);- In
Parse.c:815:
ok = ok && (KvConfigGetPtr(&cfg, "absent-config-key-0003") == NULL);
StrDeinit(&text);
MapDeinit(&cfg);
Last updated on