Testing and bench

Tests and benchmarks live in the file they are about. vyrn run and vyrn build strip them.

test blocks

A test block sits beside the code it tests. vyrn test <file> runs the blocks and reports each one; --name selects a subset. assert and assertEq exist inside a test block and nowhere else.

A file can hold tests and a main at once. The tests are checked, then stripped, so the program is unchanged by having them.

site/guide/tests.vyrnBuilt

// A `test` block lives beside the code it tests. `vyrn run` and `vyrn build`
// strip them; `vyrn test` runs them.
import { joinWith } from "std/strings"

fn clamp(x: Int64, lo: Int64, hi: Int64) -> Int64 {
    if x < lo {
        return lo
    }
    if x > hi {
        return hi
    }
    return x
}

test "clamp holds the bounds" {
    assertEq(clamp(5, 0, 10), 5)
    assertEq(clamp(0 - 3, 0, 10), 0)
    assertEq(clamp(99, 0, 10), 10)
}

test "clamp leaves a value inside them alone" {
    assert(clamp(7, 0, 10) == 7)
}

export fn demo() -> String {
    return joinWith(["clamp(5) is \{clamp(5, 0, 10)}", "clamp(99) is \{clamp(99, 0, 10)}"], "\n")
}

fn main() -> Int64 {
    print(demo())
    return 0
}

// A `test` block lives beside the code it tests. `vyrn run` and `vyrn build`
// strip them; `vyrn test` runs them.
import { joinWith } from "std/strings"

fn clamp(x: Int64, lo: Int64, hi: Int64) -> Int64 {
    if x < lo {
        return lo
    }
    if x > hi {
        return hi
    }
    return x
}

test "clamp holds the bounds" {
    assertEq(clamp(5, 0, 10), 5)
    assertEq(clamp(0 - 3, 0, 10), 0)
    assertEq(clamp(99, 0, 10), 10)
}

test "clamp leaves a value inside them alone" {
    assert(clamp(7, 0, 10) == 7)
}

export fn demo() -> String {
    return joinWith(["clamp(5) is \{clamp(5, 0, 10)}", "clamp(99) is \{clamp(99, 0, 10)}"], "\n")
}

fn main() -> Int64 {
    print(demo())
    return 0
}

clamp(5) is 5 clamp(99) is 10

bench blocks

A bench block is a body the timer runs. vyrn bench reports the minimum, median and mean over many samples. It uses the native build, because that is what a shipped program is.

blackBox hides a value from the optimizer. Around the input it stops the compiler from precomputing the answer; around the result it keeps the work live. vyrn bench --check runs each body once, compiled, which is what CI does.

site/guide/benches.vyrnBuilt

// A `bench` block is a body the timer runs. `blackBox` hides a value from the
// optimizer, so the work is done rather than folded away.
fn hashTo(n: Int64) -> Int64 {
    let mut h = 0
    let mut i = 0
    while i < n {
        h = (h * 31 + i) % 1000000007
        i = i + 1
    }
    return h
}

bench "hash to 1000" {
    blackBox(hashTo(blackBox(1000)))
}

export fn demo() -> String {
    return "hashTo(1000) is \{hashTo(1000)}"
}

fn main() -> Int64 {
    print(demo())
    return 0
}

// A `bench` block is a body the timer runs. `blackBox` hides a value from the
// optimizer, so the work is done rather than folded away.
fn hashTo(n: Int64) -> Int64 {
    let mut h = 0
    let mut i = 0
    while i < n {
        h = (h * 31 + i) % 1000000007
        i = i + 1
    }
    return h
}

bench "hash to 1000" {
    blackBox(hashTo(blackBox(1000)))
}

export fn demo() -> String {
    return "hashTo(1000) is \{hashTo(1000)}"
}

fn main() -> Int64 {
    print(demo())
    return 0
}

hashTo(1000) is 691508967