hos/src/hulk/test.d

/**
 * Kernel tests.
 */
module hulk.test;

import hulk.klog;
import hulk.list;
import hulk.time;
import hulk.hurl.a1;

struct Test
{
    /**
     * Run tests.
     */
    public static void run()
    {
        Klog.writefln("\a3Running kernel tests");
        test_pit();
        test_list();
        Klog.writefln("\a3Kernel tests complete");
    }

    private static void test_pit()
    {
        Klog.writefln("Testing PIT...");
        /* Check that PIT millisecond interrupt is firing. */
        size_t uptime = Time.uptime();
        while (Time.uptime() <= uptime)
        {
        }
    }

    private static void test_list()
    {
        Klog.writefln("Testing list...");

        struct S
        {
            size_t v;
            mixin List!S;
            void initialize()
            {
                list_init();
            }
        }

        S * s1 = A1.allocate!S();
        s1.initialize();
        s1.v = 33;
        assert_eq(1, s1.list_count);
        S * s2 = A1.allocate!S();
        s2.initialize();
        s2.v = 42;
        s2.list_insert_after(s1);
        S * s3 = A1.allocate!S();
        s3.initialize();
        s3.v = 55;
        s3.list_insert_before(s1);
        size_t count;
        assert_eq(3, s1.list_count);
        assert_eq(3, s2.list_count);
        assert_eq(3, s3.list_count);
        foreach (entry; *s1)
        {
            switch (count)
            {
            case 0:
                assert_eq(33, entry.v);
                break;
            case 1:
                assert_eq(42, entry.v);
                break;
            case 2:
                assert_eq(55, entry.v);
                break;
            case 3:
                assert_eq(0, 1);
                break;
            default:
                break;
            }
            count++;
        }
        foreach (entry; *s3)
        {
            if (entry.v == 33)
            {
                entry.list_remove();
            }
        }
        assert_eq(2, s3.list_count);
        count = 0;
        foreach (entry; *s3)
        {
            switch (count)
            {
            case 0:
                assert_eq(55, entry.v);
                break;
            case 1:
                assert_eq(42, entry.v);
                break;
            case 2:
                assert_eq(0, 1);
                break;
            default:
                break;
            }
            count++;
        }
        foreach (entry; *s2)
        {
            if (entry.v == 42)
            {
                entry.list_remove();
            }
        }
        assert_eq(1, s2.list_count);
        assert_eq(1, s3.list_count);
    }

    private static void assert_eq(T)(T first, T second, size_t line_number = __LINE__)
    {
        if (first != second)
        {
            Klog.fatal_error("Assertion failed! %x != %x (line %u)", first, second, line_number);
        }
    }

    private static void assert_neq(T)(T first, T second, size_t line_number = __LINE__)
    {
        if (first == second)
        {
            Klog.fatal_error("Assertion failed! %x == %x (line %u)", first, second, line_number);
        }
    }
}