test.um

// testing the test framework //
// so meta                    //

import ( "std.um"; "toast.um" )

fn alwaysPass(T: ^toast::Context) {
    if !T.assert.isTrue(1 + 2 == 3, "math doesn't work") { return }
}

fn alwaysFail(T: ^toast::Context) {
    if !T.assert.isTrue(false, "logic works") { return }
}

fn failOnNonExistentFile(T: ^toast::Context) {
    f, e := std::fopen("AJHSKJHDSKhdksjhdsjhsd.txt", "rb")

    msg := "couldn't open non-existent file (as it's supposed to do)"
    if !T.assert.isOk(e, msg) { return }
}

fn passOnExistentFile(T: ^toast::Context) {
    f, e := std::fopen("toast.um", "rb")

    if !T.assert.isOk(e, "this should NOT HAPPEN") { return }

    std::fclose(f)
}

fn assertEqual(T: ^toast::Context, a, b: int): bool {
    T.startCustom()
    return T.endCustom(T.assert.isTrue(
        a == b, "expected a and b to be equal"
    ))
}

fn customAssert(T: ^toast::Context) {
    if !assertEqual(T, 1, 1) { return }
}

fn assertSquare(T: ^toast::Context, n, s: int): bool {
    T.startCustom()

    if n * n != s {
        return T.endCustom(T.fail(sprintf("%v squared does not equal %v", n, s)))
    }

    return T.endCustom(true)
}

fn customLogic(T: ^toast::Context) {
    if !assertSquare(T, 3, 9 ) { return }
    if !assertSquare(T, 3, 10) { return }
}

fn assertTypes(T: ^toast::Context) {
    if !T.assert.sameType(42, 90)           { return }
    if !T.assert.sameType("hello", "world") { return }
}

fn testToast(T: ^toast::Context) {
    expected := map[str]bool{
        "always pass": true,
        "always fail": false,
        "fake file": false,
        "real file": true,
        "custom assertion": true,
        "custom logic": false,
        "assert types": true
    }

    U := toast::newContext()
    U.printWithColor = true
    U.registerTests({
        { name: "always pass",      func: alwaysPass            },
        { name: "always fail",      func: alwaysFail            },
        { name: "fake file",        func: failOnNonExistentFile },
        { name: "real file",        func: passOnExistentFile    },
        { name: "custom assertion", func: customAssert          },
        { name: "custom logic",     func: customLogic           },
        { name: "assert types",     func: assertTypes           }
    })
    U.run(false)
    fprintf(std::stderr(), "\n")

    for _, r in U.tests {
        n := r.name
        state := (r.result.code == 0)
        if state != expected[n] {
            s := sprintf(
                "expected '%s' to %s, but it %s",
                n, expected[n] ? "pass" : "fail",
                state ? "passed": "failed"
            )
            T.fail(s)
            return
        }
    }
}

fn main() {
    T := toast::newContext()

    T.compactOutput = false
    T.printWithColor = true

    T.registerTest("toast itself", testToast)
    T.run()
}