Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lib/io tests: hand-main plumbing -> assert (@test conversion B5)

Browse Source
This commit is contained in:
Hojun-Cho
2026-06-10 18:52:53 +09:00
parent 612e6d149c
commit e8096e68e1
5 changed files with 492 additions and 531 deletions
Download Patch File Download Diff File Expand all files Collapse all files

378
lib/fmt/fmttest.ww
View File

@@ -14,12 +14,6 @@ import io;
import memio;
import os;
// signalled — bumped before each scenario so a failing exit code
// pinpoints the offending case.
let signalled: i32 = 0;
fn fail() void = { os.exit(signalled + 10); };
fn streq(a: str, b: str) bool = {
if (a.len != b.len) { return false; };
let i: i32 = 0;
@@ -56,13 +50,13 @@ fn errsource() io.stream = {
let r: (size | io.error) = fmt.fprint(s, "hello");
match (r) {
case let n: size => { if (n: i32 != 5) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 5)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "hello")) { fail(); };
assert(!(!streq(memio.string(&mem), "hello")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// ---- fprint: int + str mix, space-separated ----------------------------
@@ -73,13 +67,13 @@ fn errsource() io.stream = {
let r: (size | io.error) = fmt.fprint(s, 42i64, "x");
match (r) {
case let n: size => { if (n: i32 != 4) { fail(); }; }; // "42 x"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 4)); }; // "42 x"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "42 x")) { fail(); };
assert(!(!streq(memio.string(&mem), "42 x")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// ---- fprint: bool + rune renders as "true A" --------------------------
@@ -90,13 +84,13 @@ fn errsource() io.stream = {
let r: (size | io.error) = fmt.fprint(s, true, 'A': rune);
match (r) {
case let n: size => { if (n: i32 != 6) { fail(); }; }; // "true A"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 6)); }; // "true A"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "true A")) { fail(); };
assert(!(!streq(memio.string(&mem), "true A")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// ---- fprint: zero args returns 0, no bytes written --------------------
@@ -107,13 +101,13 @@ fn errsource() io.stream = {
let r: (size | io.error) = fmt.fprint(s);
match (r) {
case let n: size => { if (n: i32 != 0) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 0)); };
case let eioe: io.error => abort();
};
if (memio.string(&mem).len != 0) { fail(); };
assert(!(memio.string(&mem).len != 0));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// ---- fprintln: multi-arg, trailing '\n' --------------------------------
@@ -124,13 +118,13 @@ fn errsource() io.stream = {
let r: (size | io.error) = fmt.fprintln(s, "a", 1i64, false);
match (r) {
case let n: size => { if (n: i32 != 10) { fail(); }; }; // "a 1 false\n"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 10)); }; // "a 1 false\n"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "a 1 false\n")) { fail(); };
assert(!(!streq(memio.string(&mem), "a 1 false\n")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// ---- fprintln: zero args writes just the newline ----------------------
@@ -141,13 +135,13 @@ fn errsource() io.stream = {
let r: (size | io.error) = fmt.fprintln(s);
match (r) {
case let n: size => { if (n: i32 != 1) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 1)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "\n")) { fail(); };
assert(!(!streq(memio.string(&mem), "\n")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// ---- fprint over a fixed stream: short writes return partial count ----
@@ -163,13 +157,13 @@ fn errsource() io.stream = {
let r: (size | io.error) = fmt.fprint(s, "hello");
match (r) {
case let n: size => { if (n: i32 != 3) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 3)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "hel")) { fail(); };
assert(!(!streq(memio.string(&mem), "hel")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// ---- fprint over a closed stream surfaces io.error -------------------
@@ -183,7 +177,7 @@ fn errsource() io.stream = {
let r: (size | io.error) = fmt.fprint(s, "x");
match (r) {
case let n: size => fail();
case let n: size => abort();
case let eioe: io.error => {};
};
};
@@ -198,12 +192,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "hello {} {}", "world", 42i64);
match (r) {
case let n: size => { if (n: i32 != 14) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 14)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "hello world 42")) { fail(); };
assert(!(!streq(memio.string(&mem), "hello world 42")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_indexed() void = {
@@ -211,12 +205,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{1} {0} {1}", "hello", "world");
match (r) {
case let n: size => { if (n: i32 != 17) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 17)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "world hello world")) { fail(); };
assert(!(!streq(memio.string(&mem), "world hello world")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_literal_braces() void = {
@@ -224,12 +218,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{{ {} }}", 1i64);
match (r) {
case let n: size => { if (n: i32 != 5) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 5)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "{ 1 }")) { fail(); };
assert(!(!streq(memio.string(&mem), "{ 1 }")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_width_right() void = {
@@ -237,12 +231,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:5}", 42i64);
match (r) {
case let n: size => { if (n: i32 != 5) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 5)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), " 42")) { fail(); };
assert(!(!streq(memio.string(&mem), " 42")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_width_left() void = {
@@ -250,12 +244,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:-5}", 42i64);
match (r) {
case let n: size => { if (n: i32 != 5) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 5)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "42 ")) { fail(); };
assert(!(!streq(memio.string(&mem), "42 ")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_width_center() void = {
@@ -263,12 +257,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:=5}", "hi");
match (r) {
case let n: size => { if (n: i32 != 5) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 5)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), " hi ")) { fail(); };
assert(!(!streq(memio.string(&mem), " hi ")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_pad_underscore() void = {
@@ -276,12 +270,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:_05}", "hi");
match (r) {
case let n: size => { if (n: i32 != 5) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 5)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "000hi")) { fail(); };
assert(!(!streq(memio.string(&mem), "000hi")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_base_hex() void = {
@@ -289,12 +283,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:x} {:X}", 48879i64, 61453i64);
match (r) {
case let n: size => { if (n: i32 != 9) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 9)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "beef F00D")) { fail(); };
assert(!(!streq(memio.string(&mem), "beef F00D")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_base_oct_bin() void = {
@@ -302,12 +296,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:o} {:b}", 493i64, 27i64);
match (r) {
case let n: size => { if (n: i32 != 9) { fail(); }; }; // "755 11011"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 9)); }; // "755 11011"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "755 11011")) { fail(); };
assert(!(!streq(memio.string(&mem), "755 11011")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_prec_int() void = {
@@ -315,12 +309,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:.5}", 42i64);
match (r) {
case let n: size => { if (n: i32 != 5) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 5)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "00042")) { fail(); };
assert(!(!streq(memio.string(&mem), "00042")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_prec_str_trunc() void = {
@@ -328,12 +322,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:.3}", "hello");
match (r) {
case let n: size => { if (n: i32 != 3) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 3)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "hel")) { fail(); };
assert(!(!streq(memio.string(&mem), "hel")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_sign_neg() void = {
@@ -341,12 +335,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{} {:+} {: }", -7i64, 7i64, 7i64);
match (r) {
case let n: size => { if (n: i32 != 8) { fail(); }; }; // "-7 +7 7"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 8)); }; // "-7 +7 7"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "-7 +7 7")) { fail(); };
assert(!(!streq(memio.string(&mem), "-7 +7 7")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintfln_basic() void = {
@@ -354,19 +348,19 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintfln(s, "x={}", 9i64);
match (r) {
case let n: size => { if (n: i32 != 4) { fail(); }; }; // "x=9\n"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 4)); }; // "x=9\n"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "x=9\n")) { fail(); };
assert(!(!streq(memio.string(&mem), "x=9\n")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_closed() void = {
let s: io.stream = errsource();
let r: (size | io.error) = fmt.fprintf(s, "hello {}", 1i64);
match (r) {
case let n: size => fail();
case let n: size => abort();
case let eioe: io.error => {};
};
};
@@ -375,8 +369,8 @@ fn errsource() io.stream = {
let buf: [16]u8;
let r: (str | io.error) = fmt.bsprintf(buf[0:16], "{} {}", "hi", 42i64);
match (r) {
case let s: str => { if (!streq(s, "hi 42")) { fail(); }; };
case let eioe: io.error => fail();
case let s: str => { assert(!(!streq(s, "hi 42"))); };
case let eioe: io.error => abort();
};
};
@@ -390,12 +384,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{} {}", true, 'A': rune);
match (r) {
case let n: size => { if (n: i32 != 6) { fail(); }; }; // "true A"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 6)); }; // "true A"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "true A")) { fail(); };
assert(!(!streq(memio.string(&mem), "true A")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// Verifies bsprintf's documented truncation contract — short writes
@@ -406,8 +400,8 @@ fn errsource() io.stream = {
let buf: [3]u8;
let r: (str | io.error) = fmt.bsprintf(buf[0:3], "{} {}", "hi", 42i64);
match (r) {
case let s: str => { if (!streq(s, "hi ")) { fail(); }; };
case let eioe: io.error => fail();
case let s: str => { assert(!(!streq(s, "hi "))); };
case let eioe: io.error => abort();
};
};
@@ -420,8 +414,8 @@ fn errsource() io.stream = {
let buf: [3]u8;
let r: (str | io.error) = fmt.bsprintf(buf[0:3], "{:5}", 42i64);
match (r) {
case let s: str => { if (!streq(s, " ")) { fail(); }; };
case let eioe: io.error => fail();
case let s: str => { assert(!(!streq(s, " "))); };
case let eioe: io.error => abort();
};
};
@@ -430,7 +424,7 @@ fn errsource() io.stream = {
@test fn asprintf_basic() void = {
let r: str = fmt.asprintf("{} {}", "hi", 42i64);
if (!streq(r, "hi 42")) { fail(); };
assert(!(!streq(r, "hi 42")));
os.free(r.ptr: *void, r.len: u64);
};
@@ -438,7 +432,7 @@ fn errsource() io.stream = {
// double-and-copy grow path; 34B target traverses 8→16→32→64.
@test fn asprintf_growth() void = {
let r: str = fmt.asprintf("hello {} world {} value {}", "alpha", "beta", "gamma");
if (!streq(r, "hello alpha world beta value gamma")) { fail(); };
assert(!(!streq(r, "hello alpha world beta value gamma")));
os.free(r.ptr: *void, r.len: u64);
};
@@ -448,7 +442,7 @@ fn errsource() io.stream = {
// strings.dup empty-input contract.
@test fn asprintf_empty() void = {
let r: str = fmt.asprintf("");
if (r.len != 0) { fail(); };
assert(!(r.len != 0));
};
// Indexed placeholder + modifier through asprintf — confirms the full
@@ -456,7 +450,7 @@ fn errsource() io.stream = {
// the memio.fixed (bsprintf) and memio.dynamic-via-fprintf paths.
@test fn asprintf_indexed_mods() void = {
let r: str = fmt.asprintf("{1:_05}", "zzz", 42i64);
if (!streq(r, "00042")) { fail(); };
assert(!(!streq(r, "00042")));
os.free(r.ptr: *void, r.len: u64);
};
@@ -476,12 +470,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{}", 1.5);
match (r) {
case let n: size => { if (n: i32 != 3) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 3)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "1.5")) { fail(); };
assert(!(!streq(memio.string(&mem), "1.5")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_f64_int_valued() void = {
@@ -489,12 +483,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{}", 1.0);
match (r) {
case let n: size => { if (n: i32 != 1) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 1)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "1")) { fail(); };
assert(!(!streq(memio.string(&mem), "1")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_f64_neg() void = {
@@ -502,12 +496,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{}", -2.5);
match (r) {
case let n: size => { if (n: i32 != 4) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 4)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "-2.5")) { fail(); };
assert(!(!streq(memio.string(&mem), "-2.5")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_f64_zero() void = {
@@ -515,12 +509,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{}", 0.0);
match (r) {
case let n: size => { if (n: i32 != 1) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 1)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "0")) { fail(); };
assert(!(!streq(memio.string(&mem), "0")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_f64_small_frac() void = {
@@ -528,12 +522,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{}", 0.05);
match (r) {
case let n: size => { if (n: i32 != 4) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 4)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "0.05")) { fail(); };
assert(!(!streq(memio.string(&mem), "0.05")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// Pins a large magnitude through the fmt dispatch — post-Ryū-graduation
@@ -544,12 +538,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{}", 9.5e18);
match (r) {
case let n: size => { if (n: i32 != 6) { fail(); }; }; // "9.5e18"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 6)); }; // "9.5e18"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "9.5e18")) { fail(); };
assert(!(!streq(memio.string(&mem), "9.5e18")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// Sign-mod fold: '+' on positive, '-' still wins on negative (the
@@ -559,12 +553,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:+} {:+}", 1.5, -1.5);
match (r) {
case let n: size => { if (n: i32 != 9) { fail(); }; }; // "+1.5 -1.5"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 9)); }; // "+1.5 -1.5"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "+1.5 -1.5")) { fail(); };
assert(!(!streq(memio.string(&mem), "+1.5 -1.5")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_f64_sign_space() void = {
@@ -572,12 +566,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{: }", 1.5);
match (r) {
case let n: size => { if (n: i32 != 4) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 4)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), " 1.5")) { fail(); };
assert(!(!streq(memio.string(&mem), " 1.5")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// Width + alignment round-trip through rawlenf64 (sign-aware len count).
@@ -586,12 +580,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:8}", 1.5);
match (r) {
case let n: size => { if (n: i32 != 8) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 8)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), " 1.5")) { fail(); };
assert(!(!streq(memio.string(&mem), " 1.5")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn fprintf_f64_width_left() void = {
@@ -599,12 +593,12 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprintf(s, "{:-8}", 1.5);
match (r) {
case let n: size => { if (n: i32 != 8) { fail(); }; };
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 8)); };
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "1.5 ")) { fail(); };
assert(!(!streq(memio.string(&mem), "1.5 ")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
// Legacy fprint variadic — covers the non-printf surface arm (where
@@ -614,73 +608,73 @@ fn errsource() io.stream = {
let s: io.stream = &mem.vt;
let r: (size | io.error) = fmt.fprint(s, 1.5, "x");
match (r) {
case let n: size => { if (n: i32 != 5) { fail(); }; }; // "1.5 x"
case let eioe: io.error => fail();
case let n: size => { assert(!(n: i32 != 5)); }; // "1.5 x"
case let eioe: io.error => abort();
};
if (!streq(memio.string(&mem), "1.5 x")) { fail(); };
assert(!(!streq(memio.string(&mem), "1.5 x")));
let c: (void | io.error) = io.close(s);
match (c) { case void => {}; case let eioe: io.error => fail(); };
match (c) { case void => {}; case let eioe: io.error => abort(); };
};
@test fn bsprintf_f64() void = {
let buf: [16]u8;
let r: (str | io.error) = fmt.bsprintf(buf[0:16], "x={}", 1.5);
match (r) {
case let s: str => { if (!streq(s, "x=1.5")) { fail(); }; };
case let eioe: io.error => fail();
case let s: str => { assert(!(!streq(s, "x=1.5"))); };
case let eioe: io.error => abort();
};
};
// Heap sink + both signs.
@test fn asprintf_f64() void = {
let r: str = fmt.asprintf("{} {}", 1.5, -2.5);
if (!streq(r, "1.5 -2.5")) { fail(); };
assert(!(!streq(r, "1.5 -2.5")));
os.free(r.ptr: *void, r.len: u64);
};
export fn main() i32 = {
signalled = 1; fprintbarestr();
signalled = 2; fprintintstr();
signalled = 3; fprintboolrune();
signalled = 4; fprintempty();
signalled = 5; fprintlnmulti();
signalled = 6; fprintlnempty();
signalled = 7; fprintfixedshort();
signalled = 8; fprintclosed();
signalled = 9; fprintf_implicit();
signalled = 10; fprintf_indexed();
signalled = 11; fprintf_literal_braces();
signalled = 12; fprintf_width_right();
signalled = 13; fprintf_width_left();
signalled = 14; fprintf_width_center();
signalled = 15; fprintf_pad_underscore();
signalled = 16; fprintf_base_hex();
signalled = 17; fprintf_base_oct_bin();
signalled = 18; fprintf_prec_int();
signalled = 19; fprintf_prec_str_trunc();
signalled = 20; fprintf_sign_neg();
signalled = 21; fprintfln_basic();
signalled = 22; fprintf_closed();
signalled = 23; bsprintf_basic();
signalled = 24; fprintf_bool_rune();
signalled = 25; bsprintf_trunc();
signalled = 26; bsprintf_width_trunc();
signalled = 27; asprintf_basic();
signalled = 28; asprintf_growth();
signalled = 29; asprintf_empty();
signalled = 30; asprintf_indexed_mods();
signalled = 31; fprintf_f64_basic();
signalled = 32; fprintf_f64_int_valued();
signalled = 33; fprintf_f64_neg();
signalled = 34; fprintf_f64_zero();
signalled = 35; fprintf_f64_small_frac();
signalled = 36; fprintf_f64_huge();
signalled = 37; fprintf_f64_sign_plus();
signalled = 38; fprintf_f64_sign_space();
signalled = 39; fprintf_f64_width_right();
signalled = 40; fprintf_f64_width_left();
signalled = 41; fprint_f64_variadic();
signalled = 42; bsprintf_f64();
signalled = 43; asprintf_f64();
fprintbarestr();
fprintintstr();
fprintboolrune();
fprintempty();
fprintlnmulti();
fprintlnempty();
fprintfixedshort();
fprintclosed();
fprintf_implicit();
fprintf_indexed();
fprintf_literal_braces();
fprintf_width_right();
fprintf_width_left();
fprintf_width_center();
fprintf_pad_underscore();
fprintf_base_hex();
fprintf_base_oct_bin();
fprintf_prec_int();
fprintf_prec_str_trunc();
fprintf_sign_neg();
fprintfln_basic();
fprintf_closed();
bsprintf_basic();
fprintf_bool_rune();
bsprintf_trunc();
bsprintf_width_trunc();
asprintf_basic();
asprintf_growth();
asprintf_empty();
asprintf_indexed_mods();
fprintf_f64_basic();
fprintf_f64_int_valued();
fprintf_f64_neg();
fprintf_f64_zero();
fprintf_f64_small_frac();
fprintf_f64_huge();
fprintf_f64_sign_plus();
fprintf_f64_sign_space();
fprintf_f64_width_right();
fprintf_f64_width_left();
fprint_f64_variadic();
bsprintf_f64();
asprintf_f64();
return 0;
};