37 |
37 |
38 void no_assertion_text_disable() { |
38 void no_assertion_text_disable() { |
39 LEMON_ASSERT(true, "This is a fault message"); |
39 LEMON_ASSERT(true, "This is a fault message"); |
40 } |
40 } |
41 |
41 |
42 void no_assertion_exception_disable() { |
|
43 LEMON_ASSERT(true, Exception()); |
|
44 } |
|
45 |
|
46 void assertion_text_disable() { |
42 void assertion_text_disable() { |
47 LEMON_ASSERT(false, "This is a fault message"); |
43 LEMON_ASSERT(false, "This is a fault message"); |
48 } |
|
49 |
|
50 void assertion_exception_disable() { |
|
51 LEMON_ASSERT(false, Exception()); |
|
52 } |
44 } |
53 |
45 |
54 void fixme_disable() { |
46 void fixme_disable() { |
55 LEMON_FIXME("fixme_disable() is fixme!"); |
47 LEMON_FIXME("fixme_disable() is fixme!"); |
56 } |
48 } |
57 |
49 |
58 void check_assertion_disable() { |
50 void check_assertion_disable() { |
59 no_assertion_text_disable(); |
51 no_assertion_text_disable(); |
60 no_assertion_exception_disable(); |
|
61 assertion_exception_disable(); |
|
62 assertion_text_disable(); |
52 assertion_text_disable(); |
63 fixme_disable(); |
53 fixme_disable(); |
64 } |
54 } |
65 #undef LEMON_DISABLE_ASSERTS |
55 #undef LEMON_DISABLE_ASSERTS |
66 |
|
67 |
|
68 #define LEMON_ASSERT_ERROR |
|
69 #include <lemon/assert.h> |
|
70 |
|
71 void no_assertion_text_error() { |
|
72 LEMON_ASSERT(true, "This is a fault message"); |
|
73 } |
|
74 |
|
75 void no_assertion_exception_error() { |
|
76 LEMON_ASSERT(true, Exception()); |
|
77 } |
|
78 |
|
79 void assertion_text_error() { |
|
80 LEMON_ASSERT(false, "This is a fault message"); |
|
81 } |
|
82 |
|
83 void assertion_exception_error() { |
|
84 LEMON_ASSERT(false, Exception()); |
|
85 } |
|
86 |
|
87 void fixme_error() { |
|
88 LEMON_FIXME("fixme_error() is fixme!"); |
|
89 } |
|
90 |
|
91 void check_assertion_error() { |
|
92 no_assertion_text_error(); |
|
93 no_assertion_exception_error(); |
|
94 try { |
|
95 assertion_exception_error(); |
|
96 check(false, "Assertion error"); |
|
97 } catch (const AssertionFailedError& e) { |
|
98 } |
|
99 |
|
100 try { |
|
101 assertion_text_error(); |
|
102 check(false, "Assertion error"); |
|
103 } catch (const AssertionFailedError& e) { |
|
104 } |
|
105 |
|
106 try { |
|
107 fixme_error(); |
|
108 check(false, "Assertion error"); |
|
109 } catch (const AssertionFailedError& e) { |
|
110 } |
|
111 } |
|
112 #undef LEMON_ASSERT_ERROR |
|
113 |
|
114 #define LEMON_ASSERT_EXCEPTION |
|
115 #include <lemon/assert.h> |
|
116 |
|
117 void no_assertion_text_exception() { |
|
118 LEMON_ASSERT(true, "This is a fault message"); |
|
119 } |
|
120 |
|
121 void no_assertion_exception_exception() { |
|
122 LEMON_ASSERT(true, Exception()); |
|
123 } |
|
124 |
|
125 void assertion_text_exception() { |
|
126 LEMON_ASSERT(false, "This is a fault message"); |
|
127 } |
|
128 |
|
129 void assertion_exception_exception() { |
|
130 LEMON_ASSERT(false, Exception()); |
|
131 } |
|
132 |
|
133 void fixme_exception() { |
|
134 LEMON_FIXME("fixme_exception() is fixme!"); |
|
135 } |
|
136 |
|
137 void check_assertion_exception() { |
|
138 no_assertion_text_exception(); |
|
139 no_assertion_exception_exception(); |
|
140 try { |
|
141 assertion_exception_exception(); |
|
142 check(false, "Assertion error"); |
|
143 } catch (const Exception& e) { |
|
144 } |
|
145 |
|
146 try { |
|
147 assertion_text_exception(); |
|
148 check(false, "Assertion error"); |
|
149 } catch (const AssertionFailedError& e) { |
|
150 } |
|
151 |
|
152 try { |
|
153 assertion_text_exception(); |
|
154 check(false, "Assertion error"); |
|
155 } catch (const AssertionFailedError& e) { |
|
156 } |
|
157 |
|
158 try { |
|
159 fixme_exception(); |
|
160 check(false, "Assertion error"); |
|
161 } catch (const AssertionFailedError& e) { |
|
162 } |
|
163 } |
|
164 #undef LEMON_ASSERT_EXCEPTION |
|
165 |
|
166 #define LEMON_ASSERT_LOG |
|
167 |
|
168 #include <lemon/assert.h> |
|
169 |
|
170 void no_assertion_text_log() { |
|
171 LEMON_ASSERT(true, "This is a fault message"); |
|
172 } |
|
173 |
|
174 void no_assertion_exception_log() { |
|
175 LEMON_ASSERT(true, Exception()); |
|
176 } |
|
177 |
|
178 void assertion_text_log() { |
|
179 LEMON_ASSERT(false, "This is a fault message"); |
|
180 } |
|
181 |
|
182 void assertion_exception_log() { |
|
183 LEMON_ASSERT(false, Exception()); |
|
184 } |
|
185 |
|
186 void fixme_log() { |
|
187 LEMON_FIXME("fixme_log() is fixme!"); |
|
188 } |
|
189 |
|
190 void check_assertion_log() { |
|
191 no_assertion_text_log(); |
|
192 no_assertion_exception_log(); |
|
193 std::cerr << "The next 3 failure messages are expected: " << std::endl; |
|
194 assertion_exception_log(); |
|
195 assertion_text_log(); |
|
196 fixme_log(); |
|
197 std::cerr << "End of expected error messages" << std::endl; |
|
198 } |
|
199 #undef LEMON_ASSERT_LOG |
|
200 |
56 |
201 #define LEMON_ASSERT_CUSTOM |
57 #define LEMON_ASSERT_CUSTOM |
202 |
58 |
203 static int cnt = 0; |
59 static int cnt = 0; |
204 void my_assert_handler(const char*, int, const char*, |
60 void my_assert_handler(const char*, int, const char*, |
205 const char*, const char*) { |
61 const char*, const char*) { |
206 ++cnt; |
62 ++cnt; |
207 } |
63 } |
208 |
64 |
209 void my_assert_handler(const char*, int, const char*, |
|
210 const std::exception&, const char*) { |
|
211 ++cnt; |
|
212 } |
|
213 |
|
214 void my_assert_handler(const char*, int, const char*, |
|
215 const std::string&, const char*) { |
|
216 ++cnt; |
|
217 } |
|
218 |
|
219 |
|
220 #define LEMON_CUSTOM_ASSERT_HANDLER my_assert_handler |
65 #define LEMON_CUSTOM_ASSERT_HANDLER my_assert_handler |
221 #include <lemon/assert.h> |
66 #include <lemon/assert.h> |
222 |
67 |
223 void no_assertion_text_custom() { |
68 void no_assertion_text_custom() { |
224 LEMON_ASSERT(true, "This is a fault message"); |
69 LEMON_ASSERT(true, "This is a fault message"); |
225 } |
70 } |
226 |
71 |
227 void no_assertion_exception_custom() { |
|
228 LEMON_ASSERT(true, Exception()); |
|
229 } |
|
230 |
|
231 void assertion_text_custom() { |
72 void assertion_text_custom() { |
232 LEMON_ASSERT(false, "This is a fault message"); |
73 LEMON_ASSERT(false, "This is a fault message"); |
233 } |
|
234 |
|
235 void assertion_exception_custom() { |
|
236 LEMON_ASSERT(false, Exception()); |
|
237 } |
74 } |
238 |
75 |
239 void fixme_custom() { |
76 void fixme_custom() { |
240 LEMON_FIXME("fixme_custom() is fixme!"); |
77 LEMON_FIXME("fixme_custom() is fixme!"); |
241 } |
78 } |
242 |
79 |
243 void check_assertion_custom() { |
80 void check_assertion_custom() { |
244 no_assertion_text_custom(); |
81 no_assertion_text_custom(); |
245 no_assertion_exception_custom(); |
|
246 assertion_exception_custom(); |
|
247 assertion_text_custom(); |
82 assertion_text_custom(); |
248 fixme_custom(); |
83 fixme_custom(); |
249 check(cnt == 3, "The custom assert handler does not work"); |
84 check(cnt == 2, "The custom assert handler does not work"); |
250 } |
85 } |
251 |
86 |
252 #undef LEMON_ASSERT_CUSTOM |
87 #undef LEMON_ASSERT_CUSTOM |
253 |
88 |
254 |
89 |
255 int main() { |
90 int main() { |
256 check_assertion_disable(); |
91 check_assertion_disable(); |
257 check_assertion_error(); |
|
258 check_assertion_exception(); |
|
259 check_assertion_log(); |
|
260 check_assertion_custom(); |
92 check_assertion_custom(); |
261 |
93 |
262 return 0; |
94 return 0; |
263 } |
95 } |