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(&<