ww/lib/encoding/base64/base64_test.ww

// 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). Same signalled-then-fail()-
// with-+10 pattern as the rest of the 9xx stdlib tests; non-zero exit
// pinpoints the failing scenario.
//
// The streaming decoder (newdecoder) is deferred (#247-sibling), so the
// decode side is exercised through decodestr only.

package base64;

import base64;
import bytes;
import errors;
import io;
import memio;
import os;
import strings;

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;
	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 => { if (n: i32 != raw.len) { fail(); }; };
	case let e: io.error => fail();
	};
	if (!streq(memio.string(&out), expect)) { fail(); };
	if (!streq(base64.encodestr(enc, raw), expect)) { fail(); };
};

// 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 => { if (!bytes.equal(b, raw)) { fail(); }; };
	case let e: errors.invalid => fail();
	};
};

// 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 => fail();
	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]);
	if (streq(s_std, s_url)) { fail(); };

	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
//
// Wrong length, bad char, embedded / excess padding all → invalid.

@test fn decode_invalid() void = {
	inval_check(&base64.std_encoding, "Zg");        // not a multiple of 4
	inval_check(&base64.std_encoding, "Z@==");      // '@' not in alphabet
	inval_check(&base64.std_encoding, "====");      // all padding
	inval_check(&base64.std_encoding, "Zg==Zg==");  // data after padding
	inval_check(&base64.std_encoding, "Zm8=Zm8=");  // data after padding
	inval_check(&base64.std_encoding, "@Zg=");      // bad leading char
};

// ---- size calc ---- ref/hare/encoding/base64/base64.ha:601

@test fn sizes() void = {
	if (base64.encodedsize(0)   != 0)   { fail(); };
	if (base64.encodedsize(1)   != 4)   { fail(); };
	if (base64.encodedsize(2)   != 4)   { fail(); };
	if (base64.encodedsize(3)   != 4)   { fail(); };
	if (base64.encodedsize(4)   != 8)   { fail(); };
	if (base64.encodedsize(10)  != 16)  { fail(); };
	if (base64.encodedsize(119) != 160) { fail(); };
	if (base64.encodedsize(120) != 160) { fail(); };
	if (base64.encodedsize(121) != 164) { fail(); };
	if (base64.encodedsize(122) != 164) { fail(); };
	if (base64.encodedsize(123) != 164) { fail(); };
	if (base64.decodedsize(0)   != 0)   { fail(); };
	if (base64.decodedsize(4)   != 3)   { fail(); };
	if (base64.decodedsize(8)   != 6)   { fail(); };
	if (base64.decodedsize(160) != 120) { fail(); };
	if (base64.decodedsize(164) != 123) { fail(); };
};

// ---- 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 => {
		if (b.len != 256) { fail(); };
		if (!bytes.equal(b, src[0:256])) { fail(); };
	};
	case let e: errors.invalid => fail();
	};
	let u: str = base64.encodestr(&base64.url_encoding, src[0:256]);
	match (base64.decodestr(&base64.url_encoding, u)) {
	case let b: []u8 => {
		if (b.len != 256) { fail(); };
		if (!bytes.equal(b, src[0:256])) { fail(); };
	};
	case let e: errors.invalid => fail();
	};
};

export fn main() i32 = {
	signalled = 1;  rfc4648_std();
	signalled = 2;  rfc4648_url();
	signalled = 3;  urlsafe_distinct();
	signalled = 4;  decode_invalid();
	signalled = 5;  sizes();
	signalled = 6;  roundtrip_all_bytes();
	return 0;
};