assert

import a::b;
import a::b::{ X, Y };
import a::b as c;
import a::b::*;

Brings a module, or selected items from it, into scope. One path per declaration: use the brace form for several items, as to alias, and * for everything public (prefer the brace form; wildcards invite name collisions).

namespace std;

std: the Cryo standard library.

namespace std::test;

test: Cryo's built-in unit-test framework.

namespace std::test::assert;

Assertion helpers for ![test] functions.

type enum Result<T, E> {
    Ok(T);
    Err(E);
}

Result: a value that may be an error.

primitive ()

The unit type: a value that carries no information, and the empty tuple. Distinct from void, which is the absence of a value - Result<(), E> succeeds with nothing to return. 0 bytes.

type enum TestError {
    Failed(String);
    Other(String);
}

Why a test failed. The runner prints the variant's message verbatim to stderr from the child process before exiting non-zero, so the parent can show the failing message in the test summary.

function expect(condition: boolean, message: Str) -> Result<(), TestError>

Return Ok(()) if condition is true, Err(TestError::Failed(msg)) otherwise. The cheap, no-format assertion.

function expect_true(condition: boolean, message: Str) -> Result<(), TestError>

Same as expect. Exists so the spelling at the call site matches the intent ("is this true?") rather than mentioning the word expect twice in a row.

function expect_false(condition: boolean, message: Str) -> Result<(), TestError>

Mirror of expect_true. expect_false(condition, msg) is clearer than expect(!condition, msg) at a call site dominated by negative assertions.

function expect_eq<T>(a: T, b: T) -> Result<(), TestError>
where T: Eq + Display

Ok(()) if a.equals(&b), otherwise Err carrying a multi-line "assertion left == right failed" message that Display-formats both values. Allocates the message on the heap; on allocation failure during message building, returns a generic fallback message.

function expect_ne<T>(a: T, b: T) -> Result<(), TestError>
where T: Eq + Display

Ok(()) if !a.equals(&b), otherwise Err carrying a multi-line "assertion left != right failed" message that Display-formats both values. Allocates as expect_eq does.

type trait Eq {
    equals(&this, other: &This) -> boolean;
}

Types that support value equality. equals(a, b) must be reflexive, symmetric, and transitive.

type trait Display {
    fmt<W>(&this, f: mut &Formatter<W>) -> Result<(), FmtError>
    where W: FmtWrite;
}

Display / Debug / Formatter.

function expect_close_f64(a: f64, b: f64, tolerance: f64) -> Result<(), TestError>

Ok(()) if |a - b| <= tolerance. Use this in place of expect_eq whenever floats are involved; expect_eq would route through f64::equals, which is exact-bit comparison and disagrees with every useful definition of "approximately the same".

function expect_some<T>(opt: &Option<T>, message: Str) -> Result<(), TestError>

Ok(()) if opt is Some(_). Takes a borrow so the test still owns the option afterwards; important for Option<T> where T: Drop, because the test author is responsible for dropping it.

function expect_none<T>(opt: &Option<T>, message: Str) -> Result<(), TestError>

Ok(()) if opt is None.

function expect_ok<T, E>(r: &Result<T, E>, message: Str) -> Result<(), TestError>

Ok(()) if r is Ok(_). Takes a borrow so the caller still owns the result.

function expect_err<T, E>(r: &Result<T, E>, message: Str) -> Result<(), TestError>

Ok(()) if r is Err(_).

function bail(message: Str) -> Result<(), TestError>

Always return Err(TestError::Failed(message)). Use this when the failure condition is implicit in reaching this code path.

function bail_other(message: Str) -> Result<(), TestError>

Same as bail but produces a TestError::Other, for non-assertion failures (I/O setup, environment problems, etc.) that the runner should display under "test error" rather than "assertion failed".

function name<T>(param: Type) -> Ret { ... }

Declares a function. Parameters are written name: Type and are never inferred; the return type follows -> and defaults to void. Declaration order does not matter: every signature is collected before any body is checked, so functions may call each other freely and recurse.

function expect(condition: boolean, message: Str) -> Result<(), TestError>

Return Ok(()) if condition is true, Err(TestError::Failed(msg)) otherwise. The cheap, no-format assertion.

primitive boolean

true / false. Not interchangeable with integers. 1 byte.

type struct Str {
    bytes: u8*;
    length: u64;
}

Str: a borrowed UTF-8 string slice.

TestError::Failed(String)

A user assertion failed. Carries the assertion message.

function expect_true(condition: boolean, message: Str) -> Result<(), TestError>

Same as expect. Exists so the spelling at the call site matches the intent ("is this true?") rather than mentioning the word expect twice in a row.

function expect_false(condition: boolean, message: Str) -> Result<(), TestError>

Mirror of expect_true. expect_false(condition, msg) is clearer than expect(!condition, msg) at a call site dominated by negative assertions.

function expect_eq<T>(a: T, b: T) -> Result<(), TestError>
where T: Eq + Display

Ok(()) if a.equals(&b), otherwise Err carrying a multi-line "assertion left == right failed" message that Display-formats both values. Allocates the message on the heap; on allocation failure during message building, returns a generic fallback message.

type parameter T

where T: Eq + Display

where T: Ord + Clone, U: Hash

Constrains generic parameters to types that implement the listed traits, which is what makes those traits' methods callable on T. Bounds on one parameter join with +; parameters separate with ,. A where on a single method narrows the type's parameter for that method only.

function expect_ne<T>(a: T, b: T) -> Result<(), TestError>
where T: Eq + Display

Ok(()) if !a.equals(&b), otherwise Err carrying a multi-line "assertion left != right failed" message that Display-formats both values. Allocates as expect_eq does.

function expect_close_f64(a: f64, b: f64, tolerance: f64) -> Result<(), TestError>

Ok(()) if |a - b| <= tolerance. Use this in place of expect_eq whenever floats are involved; expect_eq would route through f64::equals, which is exact-bit comparison and disagrees with every useful definition of "approximately the same".

primitive f64

Double-precision IEEE 754 float.

f64::equals(&this, other: &f64) -> boolean

via trait Eq

function expect_some<T>(opt: &Option<T>, message: Str) -> Result<(), TestError>

Ok(()) if opt is Some(_). Takes a borrow so the test still owns the option afterwards; important for Option<T> where T: Drop, because the test author is responsible for dropping it.

type enum Option<T> {
    Some(T);
    None;
}

Option: a value that may be absent.

type trait Drop {
    drop(mut &this) -> void;
}

Drop: explicit destructor.

function expect_none<T>(opt: &Option<T>, message: Str) -> Result<(), TestError>

Ok(()) if opt is None.

function expect_ok<T, E>(r: &Result<T, E>, message: Str) -> Result<(), TestError>

Ok(()) if r is Ok(_). Takes a borrow so the caller still owns the result.

function expect_err<T, E>(r: &Result<T, E>, message: Str) -> Result<(), TestError>

Ok(()) if r is Err(_).

function bail(message: Str) -> Result<(), TestError>

Always return Err(TestError::Failed(message)). Use this when the failure condition is implicit in reaching this code path.

function bail_other(message: Str) -> Result<(), TestError>

Same as bail but produces a TestError::Other, for non-assertion failures (I/O setup, environment problems, etc.) that the runner should display under "test error" rather than "assertion failed".

TestError::Other(String)

Any other reason a test could not produce a definitive result: I/O error during setup, environment problem, etc.