// ostest — exercises lib/os surface that doesn't have a dedicated
// test elsewhere. Covers [[os.getenv]] (against env state pre-
// arranged by test/wcc/974_getenv_run.c) and a direct
// [[os.alloc]] / [[os.free]] roundtrip. memio's tests indirectly
// cover alloc/free; the direct row here pins the FFI shape under
// lib/os itself so future bindings refactors can't quietly drift.
//
// Hand-rolled @test fns dispatched from `main()` in source order; a
// failing case aborts via the assert/abort builtin (task #5 @test
// conversion).
//
// Pre-arranged env state (set by 974_getenv_run.c via setenv/unsetenv
// before exec'ing `ww run lib/os/ostest.ww`):
//
//   WW_TEST_GETENV     = "hello-world"
//   WW_TEST_EMPTY      = ""           (set, but value is empty)
//   WW_TEST_NOT_SET    unset
//
// Don't `use io;` here — lib/os and lib/io both export read/write/
// close as C symbols that collide under the driver's flat-scope
// concat (task #17). os alone is sufficient: getenv + alloc/free are
// the only primitives needed.

package os_test;

import os;
import rt;



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;
};

// ---- getenv: set var → matching value -------------------------------

@test fn test_getenv_set() void = {
	let r = os.getenv("WW_TEST_GETENV");
	match (r) {
	case void => abort();
	case let s: str => {
		assert(!(!streq(s, "hello-world")));
	};
	};
};

// ---- getenv: empty value (set but zero-length) ----------------------
//
// POSIX permits an env var with an empty value (`name=` in environ).
// getenv must return the empty str, NOT void — void is reserved for
// "name not present at all". This row exercises the boundary.

@test fn test_getenv_empty() void = {
	let r = os.getenv("WW_TEST_EMPTY");
	match (r) {
	case void => abort();
	case let s: str => {
		assert(!(s.len != 0));
	};
	};
};

// ---- getenv: unset var → void ---------------------------------------

@test fn test_getenv_unset() void = {
	let r = os.getenv("WW_TEST_NOT_SET");
	match (r) {
	case void => {};
	case let s: str => abort();
	};
};

// ---- getenv: prefix-collision guard ---------------------------------
//
// Probes that "WW_TEST_GETEN" (a prefix of WW_TEST_GETENV) doesn't
// match. Without the explicit `entry[name.len] == '='` check in
// getenv, a naive prefix matcher would return the value of any
// longer-named var that starts with the queried name.

@test fn test_getenv_prefix_no_match() void = {
	let r = os.getenv("WW_TEST_GETEN");
	match (r) {
	case void => {};
	case let s: str => abort();
	};
};

// ---- getenvs: direct non-vacuous coverage of the []str shape --------
//
// getenvs() is public API (task #28) and the single env walker getenv
// routes through. getenv's cases exercise the walk transitively, but
// none asserts the []str RETURN shape — its count or "NAME=VALUE" entry
// text. This row pins both: the slice must be non-empty, and every
// expected entry must appear verbatim (name, '=', value duped intact).
// Fails if getenvs miscounts (len 0 → the inner search finds nothing)
// or dups the wrong bytes (off-by-one truncation → no streq match).
// The "WW_TEST_EMPTY=" row also pins the empty-value entry text.

@test fn test_getenvs_entries() void = {
	let env: []str = os.getenvs();
	assert(!(env.len == 0));
	let want: [2]str = ["WW_TEST_GETENV=hello-world", "WW_TEST_EMPTY="];
	let w: i32 = 0;
	for (w < 2) {
		let found: bool = false;
		let i: i32 = 0;
		for (i < env.len) {
			if (streq(env[i], want[w])) { found = true; };
			i += 1;
		};
		assert(found);
		w += 1;
	};
};

// ---- alloc/free: mmap-backed runtime allocator ----------------------
//
// Direct round-trip. Write-then-read-back proves the returned page is
// dereferenceable. A miscompiled binding (wrong arg order, wrong ABI,
// etc.) would either fault or return zero here.

@test fn test_alloc_free_roundtrip() void = {
	let p: []u8 = alloc([], 4096u64)!;
	p.len = 4096;
	p[0] = 90u8;		// 0x5a
	p[4095] = 165u8;	// 0xa5
	assert(!(p[0] != 90u8));
	assert(!(p[4095] != 165u8));
	os.free(p.ptr: *void, 4096u64);
};