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

lib misc+ww tests: hand-main plumbing -> assert (@test conversion B7)

Browse Source 
toktest documents the per-row signalled pinpoint loss.
This commit is contained in:
Hojun-Cho
2026-06-10 18:52:53 +09:00
parent eb891f4007
commit 3e2bf0612e
8 changed files with 797 additions and 858 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
lib/ww/asttest.ww
View File

@@ -3,108 +3,105 @@
// `ww run lib/ww/asttest.ww`.
//
// nkname is checked against every nkind value (the full ladder the
// switch replaced) plus the out-of-band fallback ("?"). A non-zero
// exit pinpoints the failing row (signalled + 10), same convention as
// toktest. `package main` + bare `import ast` mirrors wwdump (the
// external astprint consumer).
// switch replaced) plus the out-of-band fallback ("?"). A failing row
// aborts via the assert/abort builtin (task #5 @test conversion).
// `package main` + bare `import ast` mirrors wwdump (the external
// astprint consumer).
package main;
import os;
import ast;
let signalled: i32 = 0;
fn fail() void = { os.exit(signalled + 10); };
fn checkname(k: nkind, want: str) void = {
if (nkname(k) != want) { fail(); };
assert(!(nkname(k) != want));
};
// One row per nkind value — same string the if-ladder returned. The
// final row pins the unknown-kind fallback ("?").
@test fn nkname_cases() void = {
signalled = 100; checkname(nkind.N_NONE, "none");
signalled = 101; checkname(nkind.N_INTLIT, "int");
signalled = 102; checkname(nkind.N_FLOATLIT, "float");
signalled = 103; checkname(nkind.N_STRLIT, "str");
signalled = 104; checkname(nkind.N_RUNELIT, "rune");
signalled = 105; checkname(nkind.N_TRUE, "true");
signalled = 106; checkname(nkind.N_FALSE, "false");
signalled = 107; checkname(nkind.N_NIL, "nil");
signalled = 108; checkname(nkind.N_IDENT, "id");
checkname(nkind.N_NONE, "none");
checkname(nkind.N_INTLIT, "int");
checkname(nkind.N_FLOATLIT, "float");
checkname(nkind.N_STRLIT, "str");
checkname(nkind.N_RUNELIT, "rune");
checkname(nkind.N_TRUE, "true");
checkname(nkind.N_FALSE, "false");
checkname(nkind.N_NIL, "nil");
checkname(nkind.N_IDENT, "id");
signalled = 109; checkname(nkind.N_BIN, "bin");
signalled = 110; checkname(nkind.N_UN, "un");
signalled = 111; checkname(nkind.N_CALL, "call");
signalled = 112; checkname(nkind.N_INDEX, "index");
signalled = 113; checkname(nkind.N_DOT, "dot");
signalled = 114; checkname(nkind.N_CAST, "cast");
signalled = 115; checkname(nkind.N_STRUCTLIT, "structlit");
signalled = 116; checkname(nkind.N_ARRLIT, "arrlit");
signalled = 117; checkname(nkind.N_FIELD, "field");
signalled = 118; checkname(nkind.N_ASSIGN, "assign");
signalled = 119; checkname(nkind.N_ALLOC, "alloc");
signalled = 120; checkname(nkind.N_FREE, "free");
signalled = 121; checkname(nkind.N_RECV, "recv");
signalled = 122; checkname(nkind.N_SLICE, "slice");
signalled = 123; checkname(nkind.N_SPREAD, "spread");
checkname(nkind.N_BIN, "bin");
checkname(nkind.N_UN, "un");
checkname(nkind.N_CALL, "call");
checkname(nkind.N_INDEX, "index");
checkname(nkind.N_DOT, "dot");
checkname(nkind.N_CAST, "cast");
checkname(nkind.N_STRUCTLIT, "structlit");
checkname(nkind.N_ARRLIT, "arrlit");
checkname(nkind.N_FIELD, "field");
checkname(nkind.N_ASSIGN, "assign");
checkname(nkind.N_ALLOC, "alloc");
checkname(nkind.N_FREE, "free");
checkname(nkind.N_RECV, "recv");
checkname(nkind.N_SLICE, "slice");
checkname(nkind.N_SPREAD, "spread");
signalled = 124; checkname(nkind.N_BLOCK, "block");
signalled = 125; checkname(nkind.N_EXPRSTMT, "exprstmt");
signalled = 126; checkname(nkind.N_LET, "let");
signalled = 127; checkname(nkind.N_RETURN, "return");
signalled = 128; checkname(nkind.N_IF, "if");
signalled = 129; checkname(nkind.N_FOR, "for");
signalled = 130; checkname(nkind.N_FORRANGE, "forrange");
signalled = 131; checkname(nkind.N_DEFER, "defer");
signalled = 132; checkname(nkind.N_BREAK, "break");
signalled = 133; checkname(nkind.N_CONTINUE, "continue");
signalled = 134; checkname(nkind.N_SWITCH, "switch");
signalled = 135; checkname(nkind.N_CASE, "case");
checkname(nkind.N_BLOCK, "block");
checkname(nkind.N_EXPRSTMT, "exprstmt");
checkname(nkind.N_LET, "let");
checkname(nkind.N_RETURN, "return");
checkname(nkind.N_IF, "if");
checkname(nkind.N_FOR, "for");
checkname(nkind.N_FORRANGE, "forrange");
checkname(nkind.N_DEFER, "defer");
checkname(nkind.N_BREAK, "break");
checkname(nkind.N_CONTINUE, "continue");
checkname(nkind.N_SWITCH, "switch");
checkname(nkind.N_CASE, "case");
signalled = 136; checkname(nkind.N_FILE, "file");
signalled = 137; checkname(nkind.N_USE, "use");
signalled = 138; checkname(nkind.N_DEF, "def");
signalled = 139; checkname(nkind.N_TYPEDECL, "typedecl");
signalled = 140; checkname(nkind.N_FNDECL, "fn");
signalled = 141; checkname(nkind.N_PARAM, "param");
checkname(nkind.N_FILE, "file");
checkname(nkind.N_USE, "use");
checkname(nkind.N_DEF, "def");
checkname(nkind.N_TYPEDECL, "typedecl");
checkname(nkind.N_FNDECL, "fn");
checkname(nkind.N_PARAM, "param");
signalled = 142; checkname(nkind.N_TNAME, "tname");
signalled = 143; checkname(nkind.N_TPTR, "tptr");
signalled = 144; checkname(nkind.N_TSLICE, "tslice");
signalled = 145; checkname(nkind.N_TARRAY, "tarray");
signalled = 146; checkname(nkind.N_TFN, "tfn");
signalled = 147; checkname(nkind.N_TSTRUCT, "tstruct");
signalled = 148; checkname(nkind.N_TFIELD, "tfield");
signalled = 149; checkname(nkind.N_TCHAN, "tchan");
checkname(nkind.N_TNAME, "tname");
checkname(nkind.N_TPTR, "tptr");
checkname(nkind.N_TSLICE, "tslice");
checkname(nkind.N_TARRAY, "tarray");
checkname(nkind.N_TFN, "tfn");
checkname(nkind.N_TSTRUCT, "tstruct");
checkname(nkind.N_TFIELD, "tfield");
checkname(nkind.N_TCHAN, "tchan");
signalled = 150; checkname(nkind.N_ATTR, "attr");
signalled = 151; checkname(nkind.N_TTUPLE, "ttuple");
signalled = 152; checkname(nkind.N_TTAGGED, "ttagged");
signalled = 153; checkname(nkind.N_TUPLE, "tuple");
signalled = 154; checkname(nkind.N_MATCH, "match");
signalled = 155; checkname(nkind.N_MCASE, "mcase");
signalled = 156; checkname(nkind.N_TRYPROP, "tryprop");
signalled = 157; checkname(nkind.N_TRYUNW, "tryunw");
signalled = 158; checkname(nkind.N_MLET, "mlet");
signalled = 159; checkname(nkind.N_MASSIGN, "massign");
checkname(nkind.N_ATTR, "attr");
checkname(nkind.N_TTUPLE, "ttuple");
checkname(nkind.N_TTAGGED, "ttagged");
checkname(nkind.N_TUPLE, "tuple");
checkname(nkind.N_MATCH, "match");
checkname(nkind.N_MCASE, "mcase");
checkname(nkind.N_TRYPROP, "tryprop");
checkname(nkind.N_TRYUNW, "tryunw");
checkname(nkind.N_MLET, "mlet");
checkname(nkind.N_MASSIGN, "massign");
signalled = 160; checkname(nkind.N_TYPETEST, "typetest");
signalled = 161; checkname(nkind.N_TYPEASSERT, "typeassert");
signalled = 162; checkname(nkind.N_VOIDLIT, "voidlit");
signalled = 163; checkname(nkind.N_TBANG, "tbang");
signalled = 164; checkname(nkind.N_YIELD, "yield");
signalled = 165; checkname(nkind.N_TENUM, "tenum");
signalled = 166; checkname(nkind.N_TENUMMEMBER, "tenummember");
signalled = 167; checkname(nkind.N_TPARAM, "tparam");
signalled = 168; checkname(nkind.N_LAST, "last");
checkname(nkind.N_TYPETEST, "typetest");
checkname(nkind.N_TYPEASSERT, "typeassert");
checkname(nkind.N_VOIDLIT, "voidlit");
checkname(nkind.N_TBANG, "tbang");
checkname(nkind.N_YIELD, "yield");
checkname(nkind.N_TENUM, "tenum");
checkname(nkind.N_TENUMMEMBER, "tenummember");
checkname(nkind.N_TPARAM, "tparam");
checkname(nkind.N_LAST, "last");
// Unknown kind → the post-switch fallback. N_LAST is the highest
// named value (68); 69 is out of band, exercising the "?" tail.
signalled = 169; checkname(69: nkind, "?");
checkname(69: nkind, "?");
};
export fn main() i32 = {
signalled = 1; nkname_cases();
nkname_cases();
return 0;
};

263
lib/ww/lex/toktest.ww
View File

@@ -13,9 +13,11 @@
// \r, the c<0x20 and c==0x7f \xNN arms, and the printable tail) —
// branches the 990_selfhost corpus does not exercise (source tokens
// hold raw `\`+`n`, never a literal control byte).
// A non-zero exit pinpoints the failing row (signalled + 10), same
// convention as asciitest. `package main` + bare `import tok/lex`
// mirrors wwdump (the only other external lex consumer).
// A failing row aborts via the assert/abort builtin (task #5 @test
// conversion); per-row exit-code pinpoint is intentionally dropped (the
// abort reports the file, not the row; drew-t2-conversion-spec sec.5).
// `package main` + bare `import tok/lex` mirrors wwdump (the only other
// external lex consumer).
package main;
@@ -23,129 +25,126 @@ import os;
import tok;
import lex;
let signalled: i32 = 0;
fn fail() void = { os.exit(signalled + 10); };
fn checkname(k: tkind, want: str) void = {
if (tokname(k) != want) { fail(); };
assert(!(tokname(k) != want));
};
// One row per tkind value — same string the if-ladder returned. The
// final row pins the unknown-kind fallback ("<?>").
@test fn tokname_cases() void = {
signalled = 100; checkname(tkind.TK_NONE, "<none>");
signalled = 101; checkname(tkind.TK_EOF, "EOF");
signalled = 102; checkname(tkind.TK_ERR, "ERR");
signalled = 103; checkname(tkind.TK_IDENT, "IDENT");
signalled = 104; checkname(tkind.TK_INT, "INT");
signalled = 105; checkname(tkind.TK_FLOAT, "FLOAT");
signalled = 106; checkname(tkind.TK_RUNE, "RUNE");
signalled = 107; checkname(tkind.TK_STR, "STR");
checkname(tkind.TK_NONE, "<none>");
checkname(tkind.TK_EOF, "EOF");
checkname(tkind.TK_ERR, "ERR");
checkname(tkind.TK_IDENT, "IDENT");
checkname(tkind.TK_INT, "INT");
checkname(tkind.TK_FLOAT, "FLOAT");
checkname(tkind.TK_RUNE, "RUNE");
checkname(tkind.TK_STR, "STR");
signalled = 108; checkname(tkind.TK_FN, "fn");
signalled = 109; checkname(tkind.TK_LET, "let");
signalled = 110; checkname(tkind.TK_DEF, "def");
signalled = 111; checkname(tkind.TK_IF, "if");
signalled = 112; checkname(tkind.TK_ELSE, "else");
signalled = 113; checkname(tkind.TK_FOR, "for");
signalled = 114; checkname(tkind.TK_SWITCH, "switch");
signalled = 115; checkname(tkind.TK_CASE, "case");
signalled = 116; checkname(tkind.TK_RETURN, "return");
signalled = 117; checkname(tkind.TK_USE, "import");
signalled = 118; checkname(tkind.TK_TYPE, "type");
signalled = 119; checkname(tkind.TK_STRUCT, "struct");
signalled = 120; checkname(tkind.TK_DEFER, "defer");
signalled = 121; checkname(tkind.TK_BREAK, "break");
signalled = 122; checkname(tkind.TK_CONTINUE, "continue");
signalled = 123; checkname(tkind.TK_EXPORT, "export");
signalled = 124; checkname(tkind.TK_PROC, "proc");
signalled = 125; checkname(tkind.TK_CHAN, "chan");
signalled = 126; checkname(tkind.TK_NIL, "nil");
signalled = 127; checkname(tkind.TK_TRUE, "true");
signalled = 128; checkname(tkind.TK_FALSE, "false");
signalled = 129; checkname(tkind.TK_AS, "as");
signalled = 130; checkname(tkind.TK_IS, "is");
signalled = 131; checkname(tkind.TK_VOID, "void");
signalled = 132; checkname(tkind.TK_YIELD, "yield");
signalled = 133; checkname(tkind.TK_STATIC, "static");
signalled = 134; checkname(tkind.TK_MATCH, "match");
signalled = 135; checkname(tkind.TK_CONST, "const");
signalled = 136; checkname(tkind.TK_UNDER, "_");
signalled = 137; checkname(tkind.TK_ENUM, "enum");
signalled = 138; checkname(tkind.TK_MODULE, "package");
checkname(tkind.TK_FN, "fn");
checkname(tkind.TK_LET, "let");
checkname(tkind.TK_DEF, "def");
checkname(tkind.TK_IF, "if");
checkname(tkind.TK_ELSE, "else");
checkname(tkind.TK_FOR, "for");
checkname(tkind.TK_SWITCH, "switch");
checkname(tkind.TK_CASE, "case");
checkname(tkind.TK_RETURN, "return");
checkname(tkind.TK_USE, "import");
checkname(tkind.TK_TYPE, "type");
checkname(tkind.TK_STRUCT, "struct");
checkname(tkind.TK_DEFER, "defer");
checkname(tkind.TK_BREAK, "break");
checkname(tkind.TK_CONTINUE, "continue");
checkname(tkind.TK_EXPORT, "export");
checkname(tkind.TK_PROC, "proc");
checkname(tkind.TK_CHAN, "chan");
checkname(tkind.TK_NIL, "nil");
checkname(tkind.TK_TRUE, "true");
checkname(tkind.TK_FALSE, "false");
checkname(tkind.TK_AS, "as");
checkname(tkind.TK_IS, "is");
checkname(tkind.TK_VOID, "void");
checkname(tkind.TK_YIELD, "yield");
checkname(tkind.TK_STATIC, "static");
checkname(tkind.TK_MATCH, "match");
checkname(tkind.TK_CONST, "const");
checkname(tkind.TK_UNDER, "_");
checkname(tkind.TK_ENUM, "enum");
checkname(tkind.TK_MODULE, "package");
signalled = 139; checkname(tkind.TK_LPAREN, "(");
signalled = 140; checkname(tkind.TK_RPAREN, ")");
signalled = 141; checkname(tkind.TK_LBRACE, "{");
signalled = 142; checkname(tkind.TK_RBRACE, "}");
signalled = 143; checkname(tkind.TK_LBRACK, "[");
signalled = 144; checkname(tkind.TK_RBRACK, "]");
signalled = 145; checkname(tkind.TK_COMMA, ",");
signalled = 146; checkname(tkind.TK_SEMI, ";");
signalled = 147; checkname(tkind.TK_COLON, ":");
signalled = 148; checkname(tkind.TK_DOT, ".");
signalled = 149; checkname(tkind.TK_ELLIPSIS, "...");
signalled = 150; checkname(tkind.TK_DOTDOT, "..");
signalled = 151; checkname(tkind.TK_AT, "@");
signalled = 152; checkname(tkind.TK_QUESTION, "?");
checkname(tkind.TK_LPAREN, "(");
checkname(tkind.TK_RPAREN, ")");
checkname(tkind.TK_LBRACE, "{");
checkname(tkind.TK_RBRACE, "}");
checkname(tkind.TK_LBRACK, "[");
checkname(tkind.TK_RBRACK, "]");
checkname(tkind.TK_COMMA, ",");
checkname(tkind.TK_SEMI, ";");
checkname(tkind.TK_COLON, ":");
checkname(tkind.TK_DOT, ".");
checkname(tkind.TK_ELLIPSIS, "...");
checkname(tkind.TK_DOTDOT, "..");
checkname(tkind.TK_AT, "@");
checkname(tkind.TK_QUESTION, "?");
signalled = 153; checkname(tkind.TK_ASSIGN, "=");
signalled = 154; checkname(tkind.TK_PLUSEQ, "+=");
signalled = 155; checkname(tkind.TK_MINUSEQ, "-=");
signalled = 156; checkname(tkind.TK_STAREQ, "*=");
signalled = 157; checkname(tkind.TK_SLASHEQ, "/=");
signalled = 158; checkname(tkind.TK_PERCENTEQ, "%=");
signalled = 159; checkname(tkind.TK_AMPEQ, "&=");
signalled = 160; checkname(tkind.TK_PIPEEQ, "|=");
signalled = 161; checkname(tkind.TK_CARETEQ, "^=");
signalled = 162; checkname(tkind.TK_LSHIFTEQ, "<<=");
signalled = 163; checkname(tkind.TK_RSHIFTEQ, ">>=");
checkname(tkind.TK_ASSIGN, "=");
checkname(tkind.TK_PLUSEQ, "+=");
checkname(tkind.TK_MINUSEQ, "-=");
checkname(tkind.TK_STAREQ, "*=");
checkname(tkind.TK_SLASHEQ, "/=");
checkname(tkind.TK_PERCENTEQ, "%=");
checkname(tkind.TK_AMPEQ, "&=");
checkname(tkind.TK_PIPEEQ, "|=");
checkname(tkind.TK_CARETEQ, "^=");
checkname(tkind.TK_LSHIFTEQ, "<<=");
checkname(tkind.TK_RSHIFTEQ, ">>=");
signalled = 164; checkname(tkind.TK_PLUS, "+");
signalled = 165; checkname(tkind.TK_MINUS, "-");
signalled = 166; checkname(tkind.TK_STAR, "*");
signalled = 167; checkname(tkind.TK_SLASH, "/");
signalled = 168; checkname(tkind.TK_PERCENT, "%");
signalled = 169; checkname(tkind.TK_AMP, "&");
signalled = 170; checkname(tkind.TK_PIPE, "|");
signalled = 171; checkname(tkind.TK_CARET, "^");
signalled = 172; checkname(tkind.TK_TILDE, "~");
signalled = 173; checkname(tkind.TK_LSHIFT, "<<");
signalled = 174; checkname(tkind.TK_RSHIFT, ">>");
checkname(tkind.TK_PLUS, "+");
checkname(tkind.TK_MINUS, "-");
checkname(tkind.TK_STAR, "*");
checkname(tkind.TK_SLASH, "/");
checkname(tkind.TK_PERCENT, "%");
checkname(tkind.TK_AMP, "&");
checkname(tkind.TK_PIPE, "|");
checkname(tkind.TK_CARET, "^");
checkname(tkind.TK_TILDE, "~");
checkname(tkind.TK_LSHIFT, "<<");
checkname(tkind.TK_RSHIFT, ">>");
signalled = 175; checkname(tkind.TK_EQ, "==");
signalled = 176; checkname(tkind.TK_NEQ, "!=");
signalled = 177; checkname(tkind.TK_LT, "<");
signalled = 178; checkname(tkind.TK_LE, "<=");
signalled = 179; checkname(tkind.TK_GT, ">");
signalled = 180; checkname(tkind.TK_GE, ">=");
checkname(tkind.TK_EQ, "==");
checkname(tkind.TK_NEQ, "!=");
checkname(tkind.TK_LT, "<");
checkname(tkind.TK_LE, "<=");
checkname(tkind.TK_GT, ">");
checkname(tkind.TK_GE, ">=");
signalled = 181; checkname(tkind.TK_AND, "&&");
signalled = 182; checkname(tkind.TK_OR, "||");
signalled = 183; checkname(tkind.TK_NOT, "!");
checkname(tkind.TK_AND, "&&");
checkname(tkind.TK_OR, "||");
checkname(tkind.TK_NOT, "!");
signalled = 184; checkname(tkind.TK_LARROW, "<-");
signalled = 185; checkname(tkind.TK_ARROW, "->");
signalled = 186; checkname(tkind.TK_FATARROW, "=>");
checkname(tkind.TK_LARROW, "<-");
checkname(tkind.TK_ARROW, "->");
checkname(tkind.TK_FATARROW, "=>");
signalled = 187; checkname(tkind.TK_MODRESET, "//ww:module-reset");
signalled = 188; checkname(tkind.TK_LAST, "<last>");
checkname(tkind.TK_MODRESET, "//ww:module-reset");
checkname(tkind.TK_LAST, "<last>");
// Unknown kind → the post-switch fallback. TK_LAST is the highest
// named value (88); 89 is out of band, exercising the "<?>" tail.
signalled = 189; checkname(89: tkind, "<?>");
checkname(89: tkind, "<?>");
};
fn checkkw(s: str, want: tkind) void = {
if (kwlookup(s.ptr, s.len) != want) { fail(); };
assert(!(kwlookup(s.ptr, s.len) != want));
};
// Table-driven (parallel-array idiom; tuple rows blocked by #111). The
// kw rows pin all 30 keywords kwlookup recognises, 1:1 with the
// kwnames/kwkinds table (and cmd/wcc/tok.c:18-47), incl. the two remaps
// import->TK_USE and package->TK_MODULE. The nk rows pin the
// fall-through to TK_NONE. signalled = base + row keeps a failure
// pinpointable. Explicit dims, NOT [_]: [_] static-init silently
// fall-through to TK_NONE. Explicit dims, NOT [_]: [_] static-init silently
// miscompiles to a zero-length array in-tree (probe, cc69daf), which
// would void the loop body — the very hole a table test must not have.
@test fn kwlookup_cases() void = {
@@ -167,7 +166,6 @@ fn checkkw(s: str, want: tkind) void = {
];
let i: i32 = 0;
for (i < len(kwin)) {
signalled = 200 + i;
checkkw(kwin[i], kwexp[i]);
i += 1;
};
@@ -200,7 +198,6 @@ fn checkkw(s: str, want: tkind) void = {
];
let j: i32 = 0;
for (j < len(nk)) {
signalled = 230 + j;
checkkw(nk[j], tkind.TK_NONE);
j += 1;
};
@@ -211,17 +208,17 @@ fn checkkw(s: str, want: tkind) void = {
// before each write so earlier (possibly longer) content past want.len
// is irrelevant — only want.len bytes from offset 0 are compared.
fn checkprint(fd: i32, t: *tok, want: str) void = {
if (os.lseek(fd, 0i64, os.whence.SET) != 0i64) { fail(); };
assert(!(os.lseek(fd, 0i64, os.whence.SET) != 0i64));
tokprint(fd, t);
if (os.lseek(fd, 0i64, os.whence.SET) != 0i64) { fail(); };
assert(!(os.lseek(fd, 0i64, os.whence.SET) != 0i64));
let rbuf: [256]u8;
let z: i32 = 0;
for (z < 256) { rbuf[z] = 0u8; z += 1; };
let rd: i64 = os.read(fd, &rbuf[0], want.len: u64);
if (rd != want.len: i64) { fail(); };
assert(!(rd != want.len: i64));
let j: i32 = 0;
for (j < want.len) {
if (rbuf[j] != want.ptr[j]) { fail(); };
assert(!(rbuf[j] != want.ptr[j]));
j += 1;
};
};
@@ -232,45 +229,39 @@ fn checkprint(fd: i32, t: *tok, want: str) void = {
@test fn tokprint_cases() void = {
let flags: os.flag = os.flag.RDWR | os.flag.CREATE | os.flag.TRUNC;
let fd: i32 = os.open("/tmp/ww_s9_tok.tmp", flags, 384i32);
if (fd < 0) { fail(); };
assert(!(fd < 0));
let t: tok;
t.file = "t";
t.line = 1;
t.col = 1;
signalled = 300;
t.kind = tkind.TK_STR;
t.text = "\\\"\n\t\r\x01\x7fA";
checkprint(fd, &t, "t:1:1 STR \"\\\\\\\"\\n\\t\\r\\x01\\x7fA\"\n");
signalled = 301;
t.kind = tkind.TK_IDENT;
t.text = "name";
checkprint(fd, &t, "t:1:1 IDENT \"name\"\n");
signalled = 302;
t.kind = tkind.TK_ERR;
t.text = "oops";
checkprint(fd, &t, "t:1:1 ERR \"oops\"\n");
signalled = 303;
t.kind = tkind.TK_INT;
t.uval = 42u64;
checkprint(fd, &t, "t:1:1 INT 42\n");
signalled = 304;
t.kind = tkind.TK_RUNE;
t.uval = 65u64;
checkprint(fd, &t, "t:1:1 RUNE 65\n");
// Default arm: a kind outside the switch appends no value.
signalled = 305;
t.kind = tkind.TK_NONE;
checkprint(fd, &t, "t:1:1 <none>\n");
if (os.close(fd) != 0) { fail(); };
if (os.remove("/tmp/ww_s9_tok.tmp") != 0) { fail(); };
assert(!(os.close(fd) != 0));
assert(!(os.remove("/tmp/ww_s9_tok.tmp") != 0));
};
fn checkfloat(src: str, want: u64) void = {
@@ -278,8 +269,8 @@ fn checkfloat(src: str, want: u64) void = {
lexinit(&l, "t", src.ptr, src.len: u64);
let t: tok;
lexnext(&l, &t);
if (t.kind != tkind.TK_FLOAT) { fail(); };
if (t.uval != want) { fail(); };
assert(!(t.kind != tkind.TK_FLOAT));
assert(!(t.uval != want));
};
// #62 pin: lexnum's float fold routes through strconv.stof64 and must
@@ -293,42 +284,34 @@ fn checkfloat(src: str, want: u64) void = {
// boundary (tie rounds to even, tie+1 rounds up — also the only
// >19-digit FRACTION rows), and an exact power of two.
@test fn floatfold_cases() void = {
signalled = 400; checkfloat("1.0000000000000002", 0x3FF0000000000001u64);
signalled = 401; checkfloat("9007199254740993.0", 0x4340000000000000u64);
signalled = 402; checkfloat("1.2345e67", 0x4DDD4E421712C0B7u64);
signalled = 403; checkfloat("0.1", 0x3FB999999999999Au64);
signalled = 404; checkfloat("1.1", 0x3FF199999999999Au64);
signalled = 405;
checkfloat("1.0000000000000002", 0x3FF0000000000001u64);
checkfloat("9007199254740993.0", 0x4340000000000000u64);
checkfloat("1.2345e67", 0x4DDD4E421712C0B7u64);
checkfloat("0.1", 0x3FB999999999999Au64);
checkfloat("1.1", 0x3FF199999999999Au64);
checkfloat("123456789012345678901234567890.0", 0x45F8EE90FF6C373Eu64);
signalled = 406;
checkfloat("2.2250738585072014e-308", 0x0010000000000000u64);
signalled = 407; checkfloat("0.3", 0x3FD3333333333333u64);
signalled = 408; checkfloat("3.141592653589793", 0x400921FB54442D18u64);
signalled = 409;
checkfloat("0.3", 0x3FD3333333333333u64);
checkfloat("3.141592653589793", 0x400921FB54442D18u64);
checkfloat("1.7976931348623157e308", 0x7FEFFFFFFFFFFFFFu64);
signalled = 410;
checkfloat("1.7976931348623158e308", 0x7FEFFFFFFFFFFFFFu64);
signalled = 411; checkfloat("7.2057594037927933e16", 0x4370000000000000u64);
signalled = 412;
checkfloat("7.2057594037927933e16", 0x4370000000000000u64);
checkfloat("1000000000000000000000.0", 0x444B1AE4D6E2EF50u64);
signalled = 413; checkfloat("1_000.5", 0x408F440000000000u64);
signalled = 414;
checkfloat("1_000.5", 0x408F440000000000u64);
checkfloat("1.00000000000000011102230246251565404236316680908203125",
0x3FF0000000000000u64);
signalled = 415;
checkfloat("1.00000000000000011102230246251565404236316680908203126",
0x3FF0000000000001u64);
signalled = 416; checkfloat("4503599627370497.5", 0x4330000000000002u64);
signalled = 417; checkfloat("0.5", 0x3FE0000000000000u64);
signalled = 418; checkfloat("1.0e308", 0x7FE1CCF385EBC8A0u64);
signalled = 419;
checkfloat("4503599627370497.5", 0x4330000000000002u64);
checkfloat("0.5", 0x3FE0000000000000u64);
checkfloat("1.0e308", 0x7FE1CCF385EBC8A0u64);
checkfloat("2.225073858507202e-308", 0x0010000000000001u64);
};
export fn main() i32 = {
signalled = 1; tokname_cases();
signalled = 2; kwlookup_cases();
signalled = 3; tokprint_cases();
signalled = 4; floatfold_cases();
tokname_cases();
kwlookup_cases();
tokprint_cases();
floatfold_cases();
return 0;
};