std/testing

struct TestOs {
  net: FakeNet
  fs: MemFs
  clock: FakeClock
  rand: Rand
  env: FakeEnv
  stdio: FakeStdio
  proc: FakeProc
  tasks: task.Group
}

struct Expect[T] {}

struct FakeNet {}

fn (n: FakeNet) listen(addr: Str) -> Listener ! NetErr uses net.listen

fn (n: FakeNet) dial(addr: Str) -> Conn ! NetErr uses net.dial

fn (n: FakeNet) dial_timeout(addr: Str, d: Duration) -> Conn ! NetErr uses net.dial

fn (n: FakeNet) lookup_host(host: Str) -> List[Str] ! NetErr uses net.dial

fn (n: FakeNet) interfaces() -> List[NetInterface] ! NetErr uses net.listen

fn (n: FakeNet) only(hosts: List[Str]) -> Net

fn (n: FakeNet) handle(pattern: Str, h: fn(http.Request) -> http.Response)

fn (n: FakeNet) handle_tls(pattern: Str, cert: tls.TlsCert, h: fn(http.Request) -> http.Response)

fn (n: FakeNet) fail(pattern: Str, err: http.ClientErr)

fn (n: FakeNet) fail_next(pattern: Str, err: http.ClientErr)

fn (n: FakeNet) clear_failures()

fn (n: FakeNet) requests() -> List[http.Request]

struct FakeClock {}

fn (c: FakeClock) now() -> Time uses clock

fn (c: FakeClock) sleep(d: Duration) uses clock

fn (c: FakeClock) sleep_or_cancel(d: Duration) -> () ! ClockErr uses clock

fn (c: FakeClock) since(t: Time) -> Duration uses clock

fn (c: FakeClock) advance(d: Duration)

fn (c: FakeClock) set(t: Time)

fn (c: FakeClock) sleeps() -> List[Duration]

enum FsOp {
  Read
  Write
  Rename
  Remove
  CreateDir
  ReadDir
}

struct MemFs {}

fn (f: MemFs) sub(dir: Str) -> Fs

fn (f: MemFs) cwd() -> Fs

fn (f: MemFs) cwd_path() -> Str ! FsErr

fn (f: MemFs) read_only() -> Fs

fn (f: MemFs) write_only() -> Fs

fn (f: MemFs) case_sensitive() -> Bool

fn (f: MemFs) stat(path: Str) -> FileInfo? ! FsErr uses fs.read

fn (f: MemFs) exists(path: Str) -> Bool ! FsErr uses fs.read

fn (f: MemFs) disk_usage(path: Str) -> DiskUsage ! FsErr uses fs.read

fn (f: MemFs) read(path: Str) -> Bytes ! FsErr uses fs.read

fn (f: MemFs) read_text(path: Str) -> Str ! FsErr uses fs.read

fn (f: MemFs) read_dir(dir: Str) -> List[FileInfo] ! FsErr uses fs.read

fn (f: MemFs) walk(dir: Str) -> List[FileInfo] ! FsErr uses fs.read

fn (f: MemFs) write(path: Str, data: Bytes) -> () ! FsErr uses fs.write

fn (f: MemFs) create_temp(dir: Str, prefix: Str) -> Str ! FsErr uses fs.write

fn (f: MemFs) rename(from: Str, to: Str) -> () ! FsErr uses fs.write

fn (f: MemFs) remove(path: Str) -> () ! FsErr uses fs.write

fn (f: MemFs) remove_all(path: Str) -> () ! FsErr uses fs.write

fn (f: MemFs) create_dir_all(dir: Str) -> () ! FsErr uses fs.write

fn (f: MemFs) set_modified(path: Str, t: Time) -> () ! FsErr uses fs.write

fn (f: MemFs) open(path: Str) -> File ! FsErr uses fs.read

fn (f: MemFs) create(path: Str) -> File ! FsErr uses fs.write

fn (f: MemFs) open_append(path: Str) -> File ! FsErr uses fs.write

fn (f: MemFs) open_rw(path: Str) -> File ! FsErr uses fs.write

fn (f: MemFs) create_new(path: Str) -> File ! FsErr uses fs.write

fn (f: MemFs) append(path: Str, data: Bytes) -> () ! FsErr uses fs.write

fn (f: MemFs) copy(from: Str, to: Str) -> () ! FsErr uses fs

fn (f: MemFs) mode(path: Str) -> Int ! FsErr uses fs.read

fn (f: MemFs) set_mode(path: Str, mode: Int) -> () ! FsErr uses fs.write

fn (f: MemFs) symlink(target: Str, link: Str) -> () ! FsErr uses fs.write

fn (f: MemFs) read_link(path: Str) -> Str? ! FsErr uses fs.read

fn (f: MemFs) glob(pattern: Str) -> List[Str] ! FsErr uses fs.read

fn (f: MemFs) lock(path: Str) -> FileLock ! FsErr uses fs.write

fn (f: MemFs) try_lock(path: Str) -> FileLock? ! FsErr uses fs.write

fn (f: MemFs) fail_next(op: FsOp, path: Str, err: FsErr)

fn (f: MemFs) set_case_sensitive(on: Bool)

fn (f: MemFs) set_disk_usage(u: DiskUsage)

fn (f: MemFs) files() -> Map[Str, Bytes]

struct FakeEnv {}

fn (e: FakeEnv) get(name: Str) -> Str? uses env

fn (e: FakeEnv) vars() -> Map[Str, Str] uses env

fn (e: FakeEnv) args() -> List[Str] uses env

fn (e: FakeEnv) program() -> Str uses env

fn (e: FakeEnv) home() -> Str ! EnvErr uses env

fn (e: FakeEnv) only(names: List[Str]) -> Env

fn (e: FakeEnv) config_dir() -> Str ! EnvErr uses env

fn (e: FakeEnv) cache_dir() -> Str ! EnvErr uses env

fn (e: FakeEnv) hostname() -> Str uses env

fn (e: FakeEnv) set(name: Str, value: Str)

fn (e: FakeEnv) set_args(args: List[Str])

struct FakeStdio {}

fn (s: FakeStdio) print(text: Str) uses stdio

fn (s: FakeStdio) println(text: Str) uses stdio

fn (s: FakeStdio) eprint(text: Str) uses stdio

fn (s: FakeStdio) eprintln(text: Str) uses stdio

fn (s: FakeStdio) write(data: Bytes) -> () ! IoErr uses stdio

fn (s: FakeStdio) read_line() -> Str? ! IoErr uses stdio

fn (s: FakeStdio) read_all() -> Str ! IoErr uses stdio

fn (s: FakeStdio) lines() -> List[Str] ! IoErr uses stdio

fn (s: FakeStdio) stdin_is_tty() -> Bool uses stdio

fn (s: FakeStdio) stdout_is_tty() -> Bool uses stdio

fn (s: FakeStdio) stderr_is_tty() -> Bool uses stdio

fn (s: FakeStdio) width() -> Int? uses stdio

fn (s: FakeStdio) read_secret(prompt: Str) -> Str? ! IoErr uses stdio

fn (s: FakeStdio) read_bytes(max: Int) -> Bytes? ! IoErr uses stdio

fn (s: FakeStdio) read_all_bytes() -> Bytes ! IoErr uses stdio

fn (s: FakeStdio) set_input(text: Str)

fn (s: FakeStdio) set_tty(width: Int)

fn (s: FakeStdio) set_input_bytes(data: Bytes)

fn (s: FakeStdio) output() -> Str

fn (s: FakeStdio) errors() -> Str

struct FakeProc {}

fn (p: FakeProc) exit(code: Int) -> Never uses proc

fn (p: FakeProc) set_grace(d: Duration) uses proc

fn (p: FakeProc) run(cmd: Str, args: List[Str]) -> ProcOutput ! ProcErr uses proc

fn (p: FakeProc) only(cmds: List[Str]) -> Proc

fn (p: FakeProc) cmd(name: Str, args: List[Str] = []) -> Cmd

fn (p: FakeProc) pipeline(cmds: List[Cmd]) -> ProcOutput ! ProcErr uses proc

fn (p: FakeProc) exit_code() -> Int?

fn (p: FakeProc) signal_after(d: Duration)

fn (p: FakeProc) on_run(cmd: Str, out: ProcOutput)

fn (p: FakeProc) kill(pid: Int, signal: Str = "TERM") -> () ! ProcErr uses proc

fn (p: FakeProc) notify(signals: List[Signal]) -> Chan[Signal] uses proc

fn (p: FakeProc) stop_notify(c: Chan[Signal]) uses proc

fn (p: FakeProc) request_stop() uses proc

fn (p: FakeProc) pid() -> Int uses proc

fn (p: FakeProc) ppid() -> Int uses proc

fn (p: FakeProc) usage() -> ProcUsage uses proc

fn (p: FakeProc) children_usage() -> ProcUsage uses proc

fn (p: FakeProc) killed() -> List[Str]

fn expect[T](x: T) -> Expect[T]

fn gen[T](seed: Int) -> T

fn logs() -> List[log.Record]

fn fake_db(schema: Str) -> sql.Db ! sql.SqlErr

fn run_main[fx: Effects](main: fn(Os) -> () ! Error uses fx, os: TestOs, args: List[Str] = []) -> Int uses fx