Hojun-Cho
d2e54b7efa
The three must-abort runs (u32n/u64n zero, decodedsize unaligned) move into the owning lib suites as test.expectabort rows; the five normal-return controls already live in the r989_libprecond_* fixtures. wwstage parity rides the lib-wide cs==ww byte identity gate.
201 lines
6.6 KiB
Plaintext
201 lines
6.6 KiB
Plaintext
// base64_test — exercises lib/encoding/base64's io-streaming surface.
|
|
// Run with `out/bin/ww run lib/encoding/base64/base64_test.ww`. Mirrors
|
|
// Hare's base64 @test fns (ref/hare/encoding/base64/base64.ha:315,514,
|
|
// 601) over the RFC 4648 §10 vectors, table-driven (parallel arrays;
|
|
// tuple-row arrays are blocked by #111). A failing row aborts via the
|
|
// assert/abort builtin (task #5 @test conversion).
|
|
//
|
|
// The streaming decoder (newdecoder) is deferred (#247-sibling), so the
|
|
// decode side is exercised through decodestr only.
|
|
|
|
package base64_test;
|
|
|
|
import base64;
|
|
import bytes;
|
|
import errors;
|
|
import io;
|
|
import memio;
|
|
import strings;
|
|
import test;
|
|
|
|
|
|
fn streq(a: str, b: str) bool = {
|
|
if (a.len != b.len) { return false; };
|
|
let i: i32 = 0;
|
|
for (i < a.len) {
|
|
if (a[i] != b[i]) { return false; };
|
|
i += 1;
|
|
};
|
|
return true;
|
|
};
|
|
|
|
// enc_check — encode `raw` two ways (the io.handle sink via base64.encode
|
|
// and the string form via base64.encodestr) and assert both equal
|
|
// `expect`. ref/hare/encoding/base64/base64.ha:315.
|
|
fn enc_check(enc: *base64.encoding, raw: []u8, expect: str) void = {
|
|
let out: memio.stream = memio.dynamic();
|
|
match (base64.encode(&out.vt, enc, raw)) {
|
|
case let n: size => { assert(!(n: i32 != raw.len)); };
|
|
case let e: io.error => abort();
|
|
};
|
|
assert(!(!streq(memio.string(&out), expect)));
|
|
assert(!(!streq(base64.encodestr(enc, raw), expect)));
|
|
};
|
|
|
|
// dec_check — decodestr(`encoded`) must round-trip back to `raw`.
|
|
// ref/hare/encoding/base64/base64.ha:514.
|
|
fn dec_check(enc: *base64.encoding, encoded: str, raw: []u8) void = {
|
|
match (base64.decodestr(enc, encoded)) {
|
|
case let b: []u8 => { assert(!(!bytes.equal(b, raw))); };
|
|
case let e: errors.invalid => abort();
|
|
};
|
|
};
|
|
|
|
// inval_check — decodestr(`encoded`) must report errors.invalid.
|
|
// ref/hare/encoding/base64/base64.ha:525.
|
|
fn inval_check(enc: *base64.encoding, encoded: str) void = {
|
|
match (base64.decodestr(enc, encoded)) {
|
|
case let b: []u8 => abort();
|
|
case let e: errors.invalid => void;
|
|
};
|
|
};
|
|
|
|
// ---- RFC 4648 §10 vectors, encode + decodestr round-trip ----
|
|
//
|
|
// Inputs are the prefixes of "foobar". The §10 expected encodings
|
|
// contain no '+' / '/', so std and base64url agree on these vectors —
|
|
// both alphabets are driven over the same table here; the std-vs-url
|
|
// distinctness chars are covered separately by urlsafe_distinct().
|
|
|
|
@test fn rfc4648_std() void = {
|
|
let foobar: [6]u8 = ['f', 'o', 'o', 'b', 'a', 'r'];
|
|
let exp: [7]str = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==",
|
|
"Zm9vYmE=", "Zm9vYmFy"];
|
|
let i: i32 = 0;
|
|
for (i <= 6) {
|
|
enc_check(&base64.std_encoding, foobar[0:i], exp[i]);
|
|
dec_check(&base64.std_encoding, exp[i], foobar[0:i]);
|
|
i += 1;
|
|
};
|
|
};
|
|
|
|
@test fn rfc4648_url() void = {
|
|
let foobar: [6]u8 = ['f', 'o', 'o', 'b', 'a', 'r'];
|
|
let exp: [7]str = ["", "Zg==", "Zm8=", "Zm9v", "Zm9vYg==",
|
|
"Zm9vYmE=", "Zm9vYmFy"];
|
|
let i: i32 = 0;
|
|
for (i <= 6) {
|
|
enc_check(&base64.url_encoding, foobar[0:i], exp[i]);
|
|
dec_check(&base64.url_encoding, exp[i], foobar[0:i]);
|
|
i += 1;
|
|
};
|
|
};
|
|
|
|
// ---- std vs base64url alphabet distinctness ----
|
|
//
|
|
// [0xFB, 0xFF, 0xBF] hits the 62/63 alphabet slots: std emits '+'/'/',
|
|
// url emits '-'/'_'. The two encodings must differ, each round-trips
|
|
// under its own alphabet, and each is INVALID under the other (std
|
|
// decmap marks '-'/'_' 0xff and url marks '+'/'/' 0xff).
|
|
|
|
@test fn urlsafe_distinct() void = {
|
|
let raw: [3]u8 = [0xFBu8, 0xFFu8, 0xBFu8];
|
|
let s_std: str = base64.encodestr(&base64.std_encoding, raw[0:3]);
|
|
let s_url: str = base64.encodestr(&base64.url_encoding, raw[0:3]);
|
|
assert(!(streq(s_std, s_url)));
|
|
|
|
dec_check(&base64.std_encoding, s_std, raw[0:3]);
|
|
dec_check(&base64.url_encoding, s_url, raw[0:3]);
|
|
|
|
// cross-alphabet decode must reject the foreign chars.
|
|
inval_check(&base64.std_encoding, s_url);
|
|
inval_check(&base64.url_encoding, s_std);
|
|
};
|
|
|
|
// ---- decodestr error cases ---- ref/hare/encoding/base64/base64.ha:525
|
|
//
|
|
// Table-driven (parallel-array idiom; tuple rows blocked by #111). Each
|
|
// row exercises one malformed class the hand-written validation in
|
|
// decodestr must reject. Cross-alphabet chars are covered separately by
|
|
// urlsafe_distinct(); Hare's all-padding-but-not-multiple-of-4 rows
|
|
// ("=", "===", "=====", base64.ha:527-531) collapse onto the length
|
|
// guard here, so this table pins the multiple-of-4 survivors of every
|
|
// class instead.
|
|
|
|
@test fn decode_invalid() void = {
|
|
let bad: [10]str = [
|
|
"Z", // len % 4 == 1 (lone trailing char)
|
|
"Zg", // len % 4 == 2
|
|
"Zm9", // len % 4 == 3
|
|
"Z@==", // non-alphabet char in data region
|
|
"@Zg=", // bad leading char
|
|
"====", // all padding (no data)
|
|
"A===", // excess '=' (3 pads in the final quad)
|
|
"Z=g=", // '=' not in the trailing position
|
|
"Zg==Zg==", // data after padding (embedded '=')
|
|
"Zm8=Zm8=", // data after padding (embedded '=')
|
|
];
|
|
let i: i32 = 0;
|
|
for (i < len(bad)) {
|
|
inval_check(&base64.std_encoding, bad[i]);
|
|
i += 1;
|
|
};
|
|
};
|
|
|
|
// ---- size calc ---- ref/hare/encoding/base64/base64.ha:601
|
|
|
|
@test fn sizes() void = {
|
|
assert(!(base64.encodedsize(0) != 0));
|
|
assert(!(base64.encodedsize(1) != 4));
|
|
assert(!(base64.encodedsize(2) != 4));
|
|
assert(!(base64.encodedsize(3) != 4));
|
|
assert(!(base64.encodedsize(4) != 8));
|
|
assert(!(base64.encodedsize(10) != 16));
|
|
assert(!(base64.encodedsize(119) != 160));
|
|
assert(!(base64.encodedsize(120) != 160));
|
|
assert(!(base64.encodedsize(121) != 164));
|
|
assert(!(base64.encodedsize(122) != 164));
|
|
assert(!(base64.encodedsize(123) != 164));
|
|
assert(!(base64.decodedsize(0) != 0));
|
|
assert(!(base64.decodedsize(4) != 3));
|
|
assert(!(base64.decodedsize(8) != 6));
|
|
assert(!(base64.decodedsize(160) != 120));
|
|
assert(!(base64.decodedsize(164) != 123));
|
|
};
|
|
|
|
// A non-multiple-of-4 input is out of domain and must abort loudly,
|
|
// never return garbage. Pins the restored Hare precondition
|
|
// (ref/hare/encoding/base64/base64.ha:597, assert(sz % 4 == 0)).
|
|
|
|
@test fn decodedsize_unaligned_aborts() void = {
|
|
test.expectabort();
|
|
base64.decodedsize(5i32);
|
|
};
|
|
|
|
// ---- round-trip every byte value 0..255 (std + url) ----
|
|
|
|
@test fn roundtrip_all_bytes() void = {
|
|
let src: [256]u8;
|
|
let i: i32 = 0;
|
|
for (i < 256) {
|
|
src[i] = i: u8;
|
|
i += 1;
|
|
};
|
|
let s: str = base64.encodestr(&base64.std_encoding, src[0:256]);
|
|
match (base64.decodestr(&base64.std_encoding, s)) {
|
|
case let b: []u8 => {
|
|
assert(!(b.len != 256));
|
|
assert(!(!bytes.equal(b, src[0:256])));
|
|
};
|
|
case let e: errors.invalid => abort();
|
|
};
|
|
let u: str = base64.encodestr(&base64.url_encoding, src[0:256]);
|
|
match (base64.decodestr(&base64.url_encoding, u)) {
|
|
case let b: []u8 => {
|
|
assert(!(b.len != 256));
|
|
assert(!(!bytes.equal(b, src[0:256])));
|
|
};
|
|
case let e: errors.invalid => abort();
|
|
};
|
|
};
|