source: SVN/cambria/redboot/host/infra/testsuite/cyginfra/tassert6.cxx @ 1

Last change on this file since 1 was 1, checked in by Tim Harvey, 2 years ago

restored latest version of files from server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 13.3 KB
Line 
1//==========================================================================
2//
3//      tassert6.cxx
4//
5//      Assertion test case                                                               
6//
7//==========================================================================
8//####COPYRIGHTBEGIN####
9//                                                                         
10// ----------------------------------------------------------------------------
11// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
12//
13// This file is part of the eCos host tools.
14//
15// This program is free software; you can redistribute it and/or modify it
16// under the terms of the GNU General Public License as published by the Free
17// Software Foundation; either version 2 of the License, or (at your option)
18// any later version.
19//
20// This program is distributed in the hope that it will be useful, but WITHOUT
21// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
22// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
23// more details.
24//
25// You should have received a copy of the GNU General Public License along with
26// this program; if not, write to the Free Software Foundation, Inc.,
27// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
28//
29// ----------------------------------------------------------------------------
30//                                                                         
31//####COPYRIGHTEND####
32//==========================================================================
33//#####DESCRIPTIONBEGIN####                                             
34//
35// Author(s):           bartv
36// Contributors:        bartv
37// Date:                1998-12-22
38// Purpose:
39// Description:         This routine checks that all the assertions can
40//                      be triggered.
41//
42//####DESCRIPTIONEND####
43//==========================================================================
44
45
46#define CYG_DECLARE_HOST_ASSERTION_SUPPORT
47#define CYGDBG_USE_ASSERTS
48#define CYGDBG_INFRA_DEBUG_PRECONDITIONS
49#define CYGDBG_INFRA_DEBUG_POSTCONDITIONS
50#define CYGDBG_INFRA_DEBUG_LOOP_INVARIANTS
51#define CYGDBG_INFRA_DEBUG_INVARIANTS
52
53// Also redefine the zeal
54#define CYG_ASSERT_CLASS_ZEAL (cyg_extreme)
55
56#include <cyg/infra/testcase.h>
57#include <cyg/infra/cyg_ass.h>
58#include <cstdlib>
59#include <csetjmp>
60#include <cstring>
61
62
63// This is used to "recover" from an assertion failure
64static jmp_buf setjmp_buffer;
65
66// The number of assertions that have triggered.
67static int failed_assertions = 0;
68
69// The number of assertions that have been triggered.
70static int   counter = 0;
71
72static const char message[] = "beware of the leopard";
73
74// A dummy class is needed for some of the assertions.
75class dummy {
76  private:
77    int       random;
78  public:
79    dummy() {
80        random = rand();
81    }
82    ~dummy() {
83        random = 0;
84    }
85    void assertions();
86    void invariant1();
87    void invariant2();
88    static void invariant3(dummy&);
89    static void invariant4(dummy&);
90    static void invariant5(dummy*);
91    static void invariant6(dummy*);
92    static void extern_assertions(dummy*);
93    bool check_this(cyg_assert_class_zeal) const;
94};
95
96bool
97dummy::check_this(cyg_assert_class_zeal zeal) const
98{
99    // The default zeal should be cyg_quick.
100    switch(zeal) {
101    case cyg_extreme:
102        return false;
103    case cyg_system_test:
104    case cyg_thorough:
105    case cyg_quick:
106    case cyg_trivial:
107    case cyg_none:
108        CYG_TEST_FAIL_FINISH("incorrect default zeal passed to check_this() member function");
109        break;
110    default:
111        CYG_TEST_FAIL_FINISH("invalid zeal passed to check_this() member function");
112        break;
113    }
114    return false;
115}
116
117void
118dummy::invariant1(void)
119{
120    CYG_INVARIANT_THIS(dummy, message);
121    CYG_TEST_FAIL("CYG_INVARIANT_THIS() did not trigger");
122}
123
124void
125dummy::invariant2(void)
126{
127    CYG_INVARIANT_THISC(dummy);
128    CYG_TEST_FAIL("CYG_INVARIANT_THISC() did not trigger");
129}
130
131void
132dummy::invariant3(dummy& obj)
133{
134    CYG_INVARIANT_CLASSO(dummy, obj, message);
135    CYG_TEST_FAIL("CYG_INVARIANT_CLASSO() did not trigger");
136}
137
138void
139dummy::invariant4(dummy& obj)
140{
141    CYG_INVARIANT_CLASSOC(dummy, obj);
142    CYG_TEST_FAIL("CYG_INVARIANT_CLASSOC() did not trigger");
143}
144
145void
146dummy::invariant5(dummy* obj)
147{
148    CYG_INVARIANT_CLASS(dummy, obj, message);
149    CYG_TEST_FAIL("CYG_INVARIANT_CLASS() did not trigger");
150}
151
152void
153dummy::invariant6(dummy* obj)
154{
155    CYG_INVARIANT_CLASSC(dummy, obj);
156    CYG_TEST_FAIL("CYG_INVARIANT_CLASSC() did not trigger");
157}
158
159void
160dummy::assertions(void)
161{
162    switch(counter) {
163
164    case 33:
165        CYG_ASSERT_THIS(message);
166        CYG_TEST_FAIL("CYG_ASSERT_THIS() did not trigger");
167        break;
168
169    case 34:
170        CYG_ASSERT_THISC();
171        CYG_TEST_FAIL("CYG_ASSERT_THISC() did not trigger");
172        break;
173
174    case 35:
175        CYG_PRECONDITION_THIS(message);
176        CYG_TEST_FAIL("CYG_PRECONDITION_THIS() did not trigger");
177        break;
178
179    case 36:
180        CYG_PRECONDITION_THISC();
181        CYG_TEST_FAIL("CYG_PRECONDITION_THISC() did not trigger");
182        break;
183
184    case 37:
185        CYG_POSTCONDITION_THIS(message);
186        CYG_TEST_FAIL("CYG_POSTCONDITION_THIS() did not trigger");
187        break;
188
189    case 38:
190        CYG_POSTCONDITION_THISC();
191        CYG_TEST_FAIL("CYG_POSTCONDITION_THISC() did not trigger");
192        break;
193
194    case 39:
195        CYG_LOOP_INVARIANT_THIS(message);
196        CYG_TEST_FAIL("CYG_LOOP_INVARIANT_THIS() did not trigger");
197        break;
198
199    case 40:
200        CYG_LOOP_INVARIANT_THISC();
201        CYG_TEST_FAIL("CYG_LOOP_INVARIANT_THISC() did not trigger");
202        break;
203
204    default:
205        CYG_TEST_FAIL("dummy::assertions() invoked for no reason");
206        break;
207    }
208}
209
210void
211dummy::extern_assertions(dummy* obj)
212{
213    switch(counter) {
214    case 41:
215        CYG_ASSERT_ZERO_OR_CLASS(obj, message);
216        CYG_TEST_FAIL("CYG_ASSERT_ZERO_OR_CLASS() did not trigger");
217        break;
218
219    case 42:
220        CYG_ASSERT_ZERO_OR_CLASSC(obj);
221        CYG_TEST_FAIL("CYG_ASSERT_ZERO_OR_CLASSC() did not trigger");
222        break;
223
224    case 43:
225        CYG_PRECONDITION_ZERO_OR_CLASS(obj, message);
226        CYG_TEST_FAIL("CYG_PRECONDITION_ZERO_OR_CLASS() did not trigger");
227        break;
228
229    case 44:
230        CYG_PRECONDITION_ZERO_OR_CLASSC(obj);
231        CYG_TEST_FAIL("CYG_PRECONDITION_ZERO_OR_CLASSC() did not trigger");
232        break;
233
234    case 45:
235        CYG_POSTCONDITION_ZERO_OR_CLASS(obj, message);
236        CYG_TEST_FAIL("CYG_POSTCONDITION_ZERO_OR_CLASS() did not trigger");
237        break;
238
239    case 46:
240        CYG_POSTCONDITION_ZERO_OR_CLASSC(obj);
241        CYG_TEST_FAIL("CYG_POSTCONDITION_ZERO_OR_CLASSC() did not trigger");
242        break;
243
244    case 47:
245        CYG_LOOP_INVARIANT_ZERO_OR_CLASS(obj, message);
246        CYG_TEST_FAIL("CYG_LOOP_INVARIANT_ZERO_OR_CLASS() did not trigger");
247        break;
248
249    case 48:
250        CYG_LOOP_INVARIANT_ZERO_OR_CLASSC(obj);
251        CYG_TEST_FAIL("CYG_LOOP_INVARIANT_ZERO_OR_CLASSC() did not trigger");
252        break;
253
254    default:
255        CYG_TEST_FAIL("dummy::extern_assertions() invoked for no reason");
256        break;
257    }
258   
259}
260
261extern "C"
262bool
263failure_handler(const char* fn, const char* file, cyg_uint32 line, const char* msg)
264{
265    failed_assertions++;
266    counter++;
267    longjmp(setjmp_buffer, 1);
268    return true;
269}
270
271int
272main(int argc, char** argv)
273{
274    dummy object;
275
276    cyg_assert_install_failure_handler(&failure_handler);
277    setjmp(setjmp_buffer);
278   
279    for ( bool done = false; !done; counter++ ) {
280        switch(counter) {
281        case 0:
282            CYG_ASSERT(false, message);
283            CYG_TEST_FAIL("CYG_ASSERT() did not trigger");
284            break;
285
286        case 1:
287            CYG_ASSERTC(false);
288            CYG_TEST_FAIL("CYG_ASSERTC() did not trigger");
289            break;
290
291        case 2:
292            CYG_FAIL(message);
293            CYG_TEST_FAIL("CYG_FAIL() did not trigger");
294            break;
295
296        case 3:
297            CYG_CHECK_DATA_PTR(0, message);
298            CYG_TEST_FAIL("CHECK_CHECK_DATA_PTR() did not trigger");
299            break;
300
301        case 4:
302            CYG_CHECK_DATA_PTRC(0);
303            CYG_TEST_FAIL("CHECK_CHECK_DATA_PTRC() did not trigger");
304            break;
305
306        case 5:
307            CYG_CHECK_FUNC_PTR(0, message);
308            CYG_TEST_FAIL("CHECK_CHECK_FUNC_PTR() did not trigger");
309            break;
310
311        case 6:
312            CYG_CHECK_DATA_PTRC(0);
313            CYG_TEST_FAIL("CHECK_CHECK_FUNC_PTRC() did not trigger");
314            break;
315
316        case 7:
317            CYG_ASSERT_CLASS(&object, message);
318            CYG_TEST_FAIL("CYG_ASSERT_CLASS() did not trigger");
319            break;
320
321        case 8:
322            CYG_ASSERT_CLASSC(&object);
323            CYG_TEST_FAIL("CYG_ASSERT_CLASSC() did not trigger");
324            break;
325
326        case 9:
327            CYG_ASSERT_CLASSO(object, message);
328            CYG_TEST_FAIL("CYG_ASSERT_CLASSO() did not trigger");
329            break;
330
331        case 10:
332            CYG_ASSERT_CLASSOC(object);
333            CYG_TEST_FAIL("CYG_ASSERT_CLASSOC() did not trigger");
334            break;
335
336        case 11:
337            CYG_PRECONDITION(false, message);
338            CYG_TEST_FAIL("CYG_PRECONDITION() did not trigger");
339            break;
340
341        case 12:
342            CYG_PRECONDITIONC(false);
343            CYG_TEST_FAIL("CYG_PRECONDITIONC() did not trigger");
344            break;
345
346        case 13:
347            CYG_PRECONDITION_CLASS(&object, message);
348            CYG_TEST_FAIL("CYG_PRECONDITION_CLASS() did not trigger");
349            break;
350
351        case 14:
352            CYG_PRECONDITION_CLASSC(&object);
353            CYG_TEST_FAIL("CYG_PRECONDITION_CLASSC() did not trigger");
354            break;
355
356        case 15:
357            CYG_PRECONDITION_CLASSO(object, message);
358            CYG_TEST_FAIL("CYG_PRECONDITION_CLASSO() did not trigger");
359            break;
360
361        case 16:
362            CYG_PRECONDITION_CLASSOC(object);
363            CYG_TEST_FAIL("CYG_PRECONDITION_CLASSOC() did not trigger");
364            break;
365           
366        case 17:
367            CYG_POSTCONDITION(false, message);
368            CYG_TEST_FAIL("CYG_POSTCONDITION() did not trigger");
369            break;
370
371        case 18:
372            CYG_POSTCONDITIONC(false);
373            CYG_TEST_FAIL("CYG_POSTCONDITIONC() did not trigger");
374            break;
375
376        case 19:
377            CYG_POSTCONDITION_CLASS(&object, message);
378            CYG_TEST_FAIL("CYG_POSTCONDITION_CLASS() did not trigger");
379            break;
380
381        case 20:
382            CYG_POSTCONDITION_CLASSC(&object);
383            CYG_TEST_FAIL("CYG_POSTCONDITION_CLASSC() did not trigger");
384            break;
385
386        case 21:
387            CYG_POSTCONDITION_CLASSO(object, message);
388            CYG_TEST_FAIL("CYG_POSTCONDITION_CLASSO() did not trigger");
389            break;
390
391        case 22:
392            CYG_POSTCONDITION_CLASSOC(object);
393            CYG_TEST_FAIL("CYG_POSTCONDITION_CLASSOC() did not trigger");
394            break;
395
396        case 23:
397            CYG_LOOP_INVARIANT(false, message);
398            CYG_TEST_FAIL("CYG_LOOP_INVARIANT() did not trigger");
399            break;
400
401        case 24:
402            CYG_LOOP_INVARIANTC(false);
403            CYG_TEST_FAIL("CYG_LOOP_INVARIANTC() did not trigger");
404            break;
405
406        case 25:
407            CYG_LOOP_INVARIANT_CLASS(&object, message);
408            CYG_TEST_FAIL("CYG_LOOP_INVARIANT_CLASS() did not trigger");
409            break;
410
411        case 26:
412            CYG_LOOP_INVARIANT_CLASSC(&object);
413            CYG_TEST_FAIL("CYG_LOOP_INVARIANT_CLASSC() did not trigger");
414            break;
415
416        case 27:
417            CYG_LOOP_INVARIANT_CLASSO(object, message);
418            CYG_TEST_FAIL("CYG_LOOP_INVARIANT_CLASSO() did not trigger");
419            break;
420
421        case 28:
422            CYG_LOOP_INVARIANT_CLASSOC(object);
423            CYG_TEST_FAIL("CYG_LOOP_INVARIANT_CLASSOC() did not trigger");
424            break;
425
426        case 29:
427            CYG_INVARIANT(false, message);
428            CYG_TEST_FAIL("CYG_INVARIANT() did not trigger");
429            break;
430
431        case 30:
432            CYG_INVARIANTC(false);
433            CYG_TEST_FAIL("CYG_INVARIANTC() did not trigger");
434            break;
435
436        case 31:
437            object.invariant1();
438            break;
439           
440        case 32:
441            object.invariant2();
442            break;
443           
444        case 33:
445        case 34:
446        case 35:
447        case 36:
448        case 37:
449        case 38:
450        case 39:
451        case 40:
452            object.assertions();
453            break;
454
455        case 41:
456        case 42:
457        case 43:
458        case 44:
459        case 45:
460        case 46:
461        case 47:
462        case 48:
463            dummy::extern_assertions(&object);
464            break;
465
466        case 49:
467            dummy::invariant3(object);
468            break;
469           
470        case 50:
471            dummy::invariant4(object);
472            break;
473           
474        case 51:
475            dummy::invariant5(&object);
476            break;
477           
478        case 52:
479            dummy::invariant6(&object);
480            break;
481           
482        default:
483            done = true;
484            counter--;  // About to get incremented again...
485            break;
486        }
487    }
488
489    if (failed_assertions != 53) {
490        CYG_TEST_FAIL("Broken test case, not all assertions have been tried");
491    }
492   
493    if (failed_assertions == counter) {
494        CYG_TEST_PASS("All assertions trigger successfully");
495    } else {
496        CYG_TEST_FAIL("Not all assertions trigger");
497    }
498   
499    return 0;
500}
501
Note: See TracBrowser for help on using the repository browser.