source: tests/exceptions/resume.cfa

Last change on this file was 3bf9d10, checked in by Peter A. Buhr <pabuhr@…>, 10 months ago

change printf to sout

  • Property mode set to 100644
File size: 2.7 KB
Line 
1// Resumption Exception Tests
2
3#include <fstream.hfa>
4#include "except-io.hfa"
5
6exception yin {};
7exception yang {};
8exception zen {};
9
10vtable(yin) yin_vt;
11vtable(yang) yang_vt;
12vtable(zen) zen_vt;
13
14void in_void(void);
15
16int main(int argc, char * argv[]) {
17        yin a_yin = {&yin_vt};
18        yang a_yang = {&yang_vt};
19        zen a_zen = {&zen_vt};
20
21        // The simple throw catchResume test.
22        try {
23                loud_exit a = "simple try clause";
24                sout | "simple throw";
25                throwResume a_zen;
26                sout | "end of try clause";
27        } catchResume (zen * error) {
28                loud_exit a = "simple catch clause";
29                sout | "simple catch";
30        }
31        sout | nl;
32
33        // Throw catch-all test.
34        try {
35                throwResume a_zen;
36        } catchResume (exception_t * error) {
37                sout | "catch-all";
38        }
39        sout | nl;
40
41        // Don't catch if handler does not match exception.
42        try {
43                try {
44                        throwResume a_yin;
45                } catchResume (zen *) {
46                        sout | "caught yin as zen";
47                }
48        } catchResume (yang *) {
49                sout | "caught yin as yang";
50        } catchResume (yin *) {
51                sout | "caught yin as yin";
52        }
53        sout | nl;
54
55        // Test rethrowing an exception.
56        try {
57                try {
58                        loud_exit a = "rethrow inner try";
59                        sout | "rethrow inner try";
60                        throwResume a_zen;
61                } catchResume (zen *) {
62                        loud_exit a = "rethrowing catch clause";
63                        sout | "caught throw, will rethrow";
64                        throwResume;
65                }
66        } catchResume (zen *) {
67                loud_exit a = "rethrow catch clause";
68                sout | "caught rethrow";
69        }
70        sout | nl;
71
72        // Throw a different exception in a catch.
73        try {
74                try {
75                        throwResume a_yin;
76                } catchResume (yin *) {
77                        sout | "caught yin, will throw yang";
78                        throwResume a_yang;
79                } catchResume (yang *) {
80                        sout | "caught exception from same try";
81                }
82        } catchResume (yang *) {
83                sout | "caught yang";
84        }
85        sout | nl;
86
87        // Another throw in the catch does not interfere.
88        try {
89                try {
90                        sout | "throwing first exception";
91                        throwResume a_yin;
92                } catchResume (yin *) {
93                        sout | "caught first exception";
94                        try {
95                                sout | "throwing second exception";
96                                throwResume a_yang;
97                        } catchResume (yang *) {
98                                sout | "caught second exception";
99                        }
100                        throwResume;
101                }
102        } catchResume (yin *) {
103                sout | "recaught first exception";
104        } catchResume (yang *) {
105                sout | "caught second exception (bad location)";
106        }
107        sout | nl;
108
109        // Check successive operations.
110        try {
111                try {
112                        throwResume a_zen;
113                        throwResume a_zen;
114                } catchResume (zen *) {
115                        sout | "inner catch";
116                }
117                throwResume a_zen;
118        } catchResume (zen *) {
119                sout | "outer catch";
120        }
121        sout | nl;
122
123        in_void();
124}
125
126// Do a throw and rethrow in a void function.
127void in_void(void) {
128    zen a_zen = {&zen_vt};
129        try {
130                try {
131                        sout | "throw";
132                        throwResume a_zen;
133                } catchResume (zen *) {
134                        sout | "rethrow";
135                        throwResume;
136                }
137        } catchResume (zen *) {
138                sout | "handle";
139        }
140}
Note: See TracBrowser for help on using the repository browser.