Proposal: stating point of a testing library

[seymourpoler]

First of all many thanks, for all you effort. I think that this language has a great future. To me this programming language is very interesting.
I've noticed that there is no testing library (I could be wrong). Nowadays most of the modern languages have one (or more than one), for example go, zig, rust, ...

This proposal is heavily inspired in jasmine and the javascript testing ecosystem.
It looks lke this:

import fmt;

fn main():void {  
    describe("when summatory is requested", fn() {
        it("should add two numbers correctly", fn() {
            const sumExpected = 5;
            
            var sum = add(2, 3);

            expect(sum, sumExpected);
        });
    });
}

fn describe(string name, fn():void function): void {
    fmt.printf("Running test: %s\n", name);
    function();
}

fn it(string name,   fn():void function): void {
    fmt.printf(" - %s\n", name);
    function();
}

fn expect<T, U>(T actual, U expected): void {
    if(actual == expected) {
        fmt.printf("   ✔ Test passed\n");
    } else {
        fmt.printf("   ✘ Test failed: expected %v but got %v\n", expected, actual);
    }
}

fn add(int a, int b): int {
    return a + b;
}

the outcome of the test above

Running test: when summatory is requested
 - should add two numbers correctly
   ✔ Test passed

It is only a starting point and a proposal for a testing library.

Many thanks!!!!

[weiwenhao]

Currently, there is indeed no testing workflow in place. The reason for this absence is that I perceive the overall testing process to be quite complex, and I hope to develop a more innovative design. However, if it's merely a testing library, it doesn't seem overly complicated and could be added promptly.

Whenever I add a new feature or standard library, I research implementations in common programming languages. Languages like Go, Rust, Swift, Kotlin, Zig, Python, and JavaScript are my primary references and areas of investigation.

The API design for this testing library appears exceptionally elegant.

---

Additionally, in the recommended formatting style for nature source code, the semicolon ; is not mandatory.

[arjendevos]

I think we can improve on that syntax even more.

Let's consider the example you gave:

fn main():void {  
    describe("when summatory is requested", fn() {
        it("should add two numbers correctly", fn() {
            const sumExpected = 5;
            var sum = add(2, 3);

            expect(sum, sumExpected);
        });
    });
}

We have a few levels of nested function calls here. Where only at the 3rd level do we have the actual test code. Another issue is that "describe" and "it" are not really descriptive of what they do. If you are not familiar with the JS testing frameworks, you might be confused about what they do. I have the following proposals:

Tests are located in a tests/ folder (to prevent mixing test code with production code like Go does).

1. Use a test suite with setup and teardown functions:

import test

fn beforeAll(fn():void):void
fn afterAll(fn():void):void
fn beforeEach(fn():void):void
fn afterEach(fn():void):void
fn test_{name}(fn():void):void

2. Building on the previous proposal, we can use function tags to describe tests:

import test

#describe "The user controller must return the correct user data"
fn test_user_controller() {}

I think neither of these proposals are perfect and I would like more proposals and feedback from the community.