source: src/tests/except-0.c@ fd062a66

// Draft of tests for exception handling.
// Outdated: The integer constant exceptions need to be replaced with virtual
// exceptions for the new system.

// ERROR: exceptions do not interact with ^?{} properly.

#include <stdio.h>
#include <stdbool.h>

#include "except-mac.h"
TRIVIAL_EXCEPTION(yin)
TRIVIAL_EXCEPTION(yang)
TRIVIAL_EXCEPTION(zen)


// Local type to mark exits from scopes. (see ERROR)
struct signal_exit {
        const char * area;
};

void ?{}(signal_exit * this, const char * area) {
        this->area = area;
}

void ^?{}(signal_exit * this) {
        printf("Exiting: %s\n", this->area);
//      sout | "Exiting:" | this->area | endl;
}


// Mark throws: make sure to only pass in exception types.
forall(dtype T)
void terminate(T * except_value) {
        signal_exit a = {"terminate function"};
        THROW(except_value);
        printf("terminate returned\n");
}

forall(dtype T)
void resume(T * except_value) {
        signal_exit a = {"resume function"};
        THROW_RESUME(except_value);
        printf("resume returned\n");
}

// Termination Test: Two handlers: no catch, catch
void bar() {
        signal_exit a = {"bar function"};
        try {
                terminate(&(zen){});
        } catch (yin * error) {
                printf("bar caught exception yin.\n");
        }
}

void foo() {
        signal_exit a = {"foo function"};
        try {
                bar();
        } catch (yang * error) {
                printf("foo caught exception yang.\n");
        } catch (zen * error) {
                printf("foo caught exception zen.\n");
        }
}

// Resumption Two Handler Test: no catch, catch.
void beta() {
        signal_exit a = {"beta function"};
        try {
                zen x;
                resume(&x);
        } catchResume (yin * error) {
                printf("beta caught exception yin\n");
        }
}

void alpha() {
        signal_exit a = {"alpha function"};
        try {
                beta();
        } catchResume (yang * error) {
                printf("alpha caught exception yang\n");
        } catchResume (zen * error) {
                printf("alpha caught exception zen\n");
        }
}

// Finally Test:
void farewell(bool jump) {
        try {
                if (jump) {
                        printf("jump out of farewell\n");
                        goto endoffunction;
                } else {
                        printf("walk out of farewell\n");
                }
        } finally {
                printf("See you next time\n");
        }
        endoffunction:
        printf("leaving farewell\n");
}

// Resume-to-Terminate Test:
void fallback() {
        try {
                zen x;
                resume(&x);
        } catch (zen * error) {
                printf("fallback caught termination zen\n");
        }
}

// Terminate Throw New Exception:
void terminate_swap() {
        signal_exit a = {"terminate_swap"};
        try {
                yin x;
                terminate(&x);
        } catch (yin * error) {
                yang y;
                terminate(&y);
        }
}

void terminate_swapped() {
        signal_exit a = {"terminate_swapped"};
        try {
                terminate_swap();
        } catch (yang * error) {
                printf("terminate_swapped caught exception yang\n");
        }
}

// Resume Throw New Exception:
void resume_swap() {
        signal_exit a = {"resume_swap"};
        try {
                yin x;
                resume(&x);
        } catchResume (yin * error) {
                yang y;
                resume(&y);
        }
}

void resume_swapped() {
        try {
                resume_swap();
        } catchResume (yang * error) {
                printf("resume_swapped caught exception yang\n");
        }
}

// Terminate Rethrow:
void reterminate() {
        try {
                try {
                        zen x;
                        terminate(&x);
                } catch (zen * error) {
                        printf("reterminate zen caught and "
                               "will rethrow exception zen\n");
                        throw;
                }
        } catch (zen * error) {
                printf("reterminate 1 caught exception zen\n");
        }
}

// Resume Rethrow:
void reresume() {
        try {
                try {
                        zen x;
                        resume(&x);
                } catchResume (zen * error) {
                        printf("reresume zen caught and rethrows exception zen\n");
                        throwResume;
                }
        } catchResume (zen * error) {
                printf("reresume 1 caught exception zen\n");
        }
}

// Terminate-Resume interaction:
void fum() {
        // terminate block, call resume
        try {
                zen x;
                resume(&x);
        } catch (zen * error) {
                printf("fum caught exception zen\n");
        }
}

void foe() {
        // resume block, call terminate
        try {
                zen y;
                terminate(&y);
        } catchResume (zen * error) {
                printf("foe caught exception zen\n");
        }
}

void fy() {
        // terminate block calls fum, call foe
        try {
                foe();
        } catch (zen * error) {
                printf("fy caught exception zen\n");
                fum();
        }
}

void fee() {
        // resume block, call fy
        try {
                fy();
        } catchResume (zen * error) {
                printf("fee caught exception zen\n");
        }
}


// main: choose which tests to run
int main(int argc, char * argv[]) {
        signal_exit a = {"main function"};

        foo(); printf("\n");
        alpha(); printf("\n");
        farewell(false); printf("\n");
        farewell(true); printf("\n");
        fallback(); printf("\n");
        terminate_swapped(); printf("\n");
        resume_swapped(); printf("\n");
        reterminate(); printf("\n");
        reresume(); printf("\n");
        fee(); printf("\n");

        // Uncaught termination test.
        printf("Throw uncaught.\n");
        yang z;
        terminate(&z);
}