source: tests/exceptions/terminate.cfa@ f03e11d

// Termination Exception Tests

#include <exception.hfa>
#include "except-io.hfa"

TRIVIAL_EXCEPTION(yin);
TRIVIAL_EXCEPTION(yang);
TRIVIAL_EXCEPTION(zen);
TRIVIAL_EXCEPTION(moment_of, zen);

void in_void(void);

int main(int argc, char * argv[]) {
        // The simple throw catch test.
        try {
                loud_exit a = "simple try clause";
                printf("simple throw\n");
                throw (zen){};
                printf("end of try clause\n");
        } catch (zen * error) {
                loud_exit a = "simple catch clause";
                printf("simple catch\n");
        }
        printf("\n");

        // Throw catch-all test.
        try {
                throw (zen){};
        } catch (exception_t * error) {
                printf("catch-all\n");
        }
        printf("\n");

        // Catch a parent of the given exception.
        try {
                printf("throwing child exception\n");
                throw (moment_of){};
        } catch (zen *) {
                printf("inner parent match\n");
        } catch (moment_of *) {
                printf("outer exact match\n");
        }
        printf("\n");

        // Don't catch if handler does not match exception.
        try {
                try {
                        throw (yin){};
                } catch (zen *) {
                        printf("caught yin as zen\n");
                }
        } catch (yang *) {
                printf("caught yin as yang\n");
        } catch (yin *) {
                printf("caught yin as yin\n");
        }
        printf("\n");

        // Test rethrowing an exception.
        try {
                try {
                        loud_exit a = "rethrow inner try";
                        printf("rethrow inner try\n");
                        throw (zen){};
                } catch (zen *) {
                        loud_exit a = "rethrowing catch clause";
                        printf("caught throw, will rethrow\n");
                        throw;
                }
        } catch (zen *) {
                loud_exit a = "rethrow catch clause";
                printf("caught rethrow\n");
        }
        printf("\n");

        // Throw a different exception in a catch.
        try {
                try {
                        throw (yin){};
                } catch (yin *) {
                        printf("caught yin, will throw yang\n");
                        throw (yang){};
                } catch (yang *) {
                        printf("caught exception from same try\n");
                }
        } catch (yang *) {
                printf("caught yang\n");
        }
        printf("\n");

        // Another throw in the catch does not interfere.
        try {
                try {
                        printf("throwing first exception\n");
                        throw (yin){};
                } catch (yin *) {
                        printf("caught first exception\n");
                        try {
                                printf("throwing second exception\n");
                                throw (yang){};
                        } catch (yang *) {
                                printf("caught second exception\n");
                        }
                        throw;
                }
        } catch (yin *) {
                printf("recaught first exception\n");
        } catch (yang *) {
                printf("caught second exception (bad location)\n");
        }
        printf("\n");

        // Check successive operations.
        try {
                try {
                        throw (zen){};
                        throw (zen){};
                } catch (zen *) {
                        printf("inner catch\n");
                }
                throw (zen){};
        } catch (zen *) {
                printf("outer catch\n");
        }
        printf("\n");

        in_void();
}

// Do a throw and rethrow in a void function.
void in_void(void) {
        try {
                try {
                        printf("throw\n");
                        throw (zen){};
                } catch (zen *) {
                        printf("rethrow\n");
                        throw;
                }
        } catch (zen *) {
                printf("handle\n");
        }
}