URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [host/] [infra/] [testsuite/] [cyginfra/] [tassert6.cxx] - Blame information for rev 786

Details | Compare with Previous | View Log


//==========================================================================
//
//      tassert6.cxx
//
//      Assertion test case                                                                
//
//==========================================================================
// ####ECOSHOSTGPLCOPYRIGHTBEGIN####                                        
// -------------------------------------------                              
// This file is part of the eCos host tools.                                
// Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.            
//
// This program is free software; you can redistribute it and/or modify     
// it under the terms of the GNU General Public License as published by     
// the Free Software Foundation; either version 2 or (at your option) any   
// later version.                                                           
//
// This program is distributed in the hope that it will be useful, but      
// WITHOUT ANY WARRANTY; without even the implied warranty of               
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        
// General Public License for more details.                                 
//
// You should have received a copy of the GNU General Public License        
// along with this program; if not, write to the                            
// Free Software Foundation, Inc., 51 Franklin Street,                      
// Fifth Floor, Boston, MA  02110-1301, USA.                                
// -------------------------------------------                              
// ####ECOSHOSTGPLCOPYRIGHTEND####                                          
//==========================================================================
//#####DESCRIPTIONBEGIN####                                             
//
// Author(s):           bartv
// Contributors:        bartv
// Date:                1998-12-22
// Purpose:
// Description:         This routine checks that all the assertions can
//                      be triggered.
//
//####DESCRIPTIONEND####
//==========================================================================
 
 
#define CYG_DECLARE_HOST_ASSERTION_SUPPORT
#define CYGDBG_USE_ASSERTS
#define CYGDBG_INFRA_DEBUG_PRECONDITIONS
#define CYGDBG_INFRA_DEBUG_POSTCONDITIONS
#define CYGDBG_INFRA_DEBUG_LOOP_INVARIANTS
#define CYGDBG_INFRA_DEBUG_INVARIANTS
 
// Also redefine the zeal
#define CYG_ASSERT_CLASS_ZEAL (cyg_extreme)
 
#include <cyg/infra/testcase.h>
#include <cyg/infra/cyg_ass.h>
#include <cstdlib>
#include <csetjmp>
#include <cstring>
 
 
// This is used to "recover" from an assertion failure
static jmp_buf setjmp_buffer;
 
// The number of assertions that have triggered.
static int failed_assertions = 0;
 
// The number of assertions that have been triggered.
static int   counter = 0;
 
static const char message[] = "beware of the leopard";
 
// A dummy class is needed for some of the assertions.
class dummy {
  private:
    int       random;
  public:
    dummy() {
        random = rand();
    }
    ~dummy() {
        random = 0;
    }
    void assertions();
    void invariant1();
    void invariant2();
    static void invariant3(dummy&);
    static void invariant4(dummy&);
    static void invariant5(dummy*);
    static void invariant6(dummy*);
    static void extern_assertions(dummy*);
    bool check_this(cyg_assert_class_zeal) const;
};
 
bool
dummy::check_this(cyg_assert_class_zeal zeal) const
{
    // The default zeal should be cyg_quick.
    switch(zeal) {
    case cyg_extreme:
        return false;
    case cyg_system_test:
    case cyg_thorough:
    case cyg_quick:
    case cyg_trivial:
    case cyg_none:
        CYG_TEST_FAIL_FINISH("incorrect default zeal passed to check_this() member function");
        break;
    default:
        CYG_TEST_FAIL_FINISH("invalid zeal passed to check_this() member function");
        break;
    }
    return false;
}
 
void
dummy::invariant1(void)
{
    CYG_INVARIANT_THIS(dummy, message);
    CYG_TEST_FAIL("CYG_INVARIANT_THIS() did not trigger");
}
 
void
dummy::invariant2(void)
{
    CYG_INVARIANT_THISC(dummy);
    CYG_TEST_FAIL("CYG_INVARIANT_THISC() did not trigger");
}
 
void
dummy::invariant3(dummy& obj)
{
    CYG_INVARIANT_CLASSO(dummy, obj, message);
    CYG_TEST_FAIL("CYG_INVARIANT_CLASSO() did not trigger");
}
 
void
dummy::invariant4(dummy& obj)
{
    CYG_INVARIANT_CLASSOC(dummy, obj);
    CYG_TEST_FAIL("CYG_INVARIANT_CLASSOC() did not trigger");
}
 
void
dummy::invariant5(dummy* obj)
{
    CYG_INVARIANT_CLASS(dummy, obj, message);
    CYG_TEST_FAIL("CYG_INVARIANT_CLASS() did not trigger");
}
 
void
dummy::invariant6(dummy* obj)
{
    CYG_INVARIANT_CLASSC(dummy, obj);
    CYG_TEST_FAIL("CYG_INVARIANT_CLASSC() did not trigger");
}
 
void
dummy::assertions(void)
{
    switch(counter) {
 
    case 33:
        CYG_ASSERT_THIS(message);
        CYG_TEST_FAIL("CYG_ASSERT_THIS() did not trigger");
        break;
 
    case 34:
        CYG_ASSERT_THISC();
        CYG_TEST_FAIL("CYG_ASSERT_THISC() did not trigger");
        break;
 
    case 35:
        CYG_PRECONDITION_THIS(message);
        CYG_TEST_FAIL("CYG_PRECONDITION_THIS() did not trigger");
        break;
 
    case 36:
        CYG_PRECONDITION_THISC();
        CYG_TEST_FAIL("CYG_PRECONDITION_THISC() did not trigger");
        break;
 
    case 37:
        CYG_POSTCONDITION_THIS(message);
        CYG_TEST_FAIL("CYG_POSTCONDITION_THIS() did not trigger");
        break;
 
    case 38:
        CYG_POSTCONDITION_THISC();
        CYG_TEST_FAIL("CYG_POSTCONDITION_THISC() did not trigger");
        break;
 
    case 39:
        CYG_LOOP_INVARIANT_THIS(message);
        CYG_TEST_FAIL("CYG_LOOP_INVARIANT_THIS() did not trigger");
        break;
 
    case 40:
        CYG_LOOP_INVARIANT_THISC();
        CYG_TEST_FAIL("CYG_LOOP_INVARIANT_THISC() did not trigger");
        break;
 
    default:
        CYG_TEST_FAIL("dummy::assertions() invoked for no reason");
        break;
    }
}
 
void
dummy::extern_assertions(dummy* obj)
{
    switch(counter) {
    case 41:
        CYG_ASSERT_ZERO_OR_CLASS(obj, message);
        CYG_TEST_FAIL("CYG_ASSERT_ZERO_OR_CLASS() did not trigger");
        break;
 
    case 42:
        CYG_ASSERT_ZERO_OR_CLASSC(obj);
        CYG_TEST_FAIL("CYG_ASSERT_ZERO_OR_CLASSC() did not trigger");
        break;
 
    case 43:
        CYG_PRECONDITION_ZERO_OR_CLASS(obj, message);
        CYG_TEST_FAIL("CYG_PRECONDITION_ZERO_OR_CLASS() did not trigger");
        break;
 
    case 44:
        CYG_PRECONDITION_ZERO_OR_CLASSC(obj);
        CYG_TEST_FAIL("CYG_PRECONDITION_ZERO_OR_CLASSC() did not trigger");
        break;
 
    case 45:
        CYG_POSTCONDITION_ZERO_OR_CLASS(obj, message);
        CYG_TEST_FAIL("CYG_POSTCONDITION_ZERO_OR_CLASS() did not trigger");
        break;
 
    case 46:
        CYG_POSTCONDITION_ZERO_OR_CLASSC(obj);
        CYG_TEST_FAIL("CYG_POSTCONDITION_ZERO_OR_CLASSC() did not trigger");
        break;
 
    case 47:
        CYG_LOOP_INVARIANT_ZERO_OR_CLASS(obj, message);
        CYG_TEST_FAIL("CYG_LOOP_INVARIANT_ZERO_OR_CLASS() did not trigger");
        break;
 
    case 48:
        CYG_LOOP_INVARIANT_ZERO_OR_CLASSC(obj);
        CYG_TEST_FAIL("CYG_LOOP_INVARIANT_ZERO_OR_CLASSC() did not trigger");
        break;
 
    default:
        CYG_TEST_FAIL("dummy::extern_assertions() invoked for no reason");
        break;
    }
 
}
 
extern "C"
bool
failure_handler(const char* fn, const char* file, cyg_uint32 line, const char* msg)
{
    failed_assertions++;
    counter++;
    longjmp(setjmp_buffer, 1);
    return true;
}
 
int
main(int argc, char** argv)
{
    dummy object;
 
    cyg_assert_install_failure_handler(&failure_handler);
    setjmp(setjmp_buffer);
 
    for ( bool done = false; !done; counter++ ) {
        switch(counter) {
        case 0:
            CYG_ASSERT(false, message);
            CYG_TEST_FAIL("CYG_ASSERT() did not trigger");
            break;
 
        case 1:
            CYG_ASSERTC(false);
            CYG_TEST_FAIL("CYG_ASSERTC() did not trigger");
            break;
 
        case 2:
            CYG_FAIL(message);
            CYG_TEST_FAIL("CYG_FAIL() did not trigger");
            break;
 
        case 3:
            CYG_CHECK_DATA_PTR(0, message);
            CYG_TEST_FAIL("CHECK_CHECK_DATA_PTR() did not trigger");
            break;
 
        case 4:
            CYG_CHECK_DATA_PTRC(0);
            CYG_TEST_FAIL("CHECK_CHECK_DATA_PTRC() did not trigger");
            break;
 
        case 5:
            CYG_CHECK_FUNC_PTR(0, message);
            CYG_TEST_FAIL("CHECK_CHECK_FUNC_PTR() did not trigger");
            break;
 
        case 6:
            CYG_CHECK_DATA_PTRC(0);
            CYG_TEST_FAIL("CHECK_CHECK_FUNC_PTRC() did not trigger");
            break;
 
        case 7:
            CYG_ASSERT_CLASS(&object, message);
            CYG_TEST_FAIL("CYG_ASSERT_CLASS() did not trigger");
            break;
 
        case 8:
            CYG_ASSERT_CLASSC(&object);
            CYG_TEST_FAIL("CYG_ASSERT_CLASSC() did not trigger");
            break;
 
        case 9:
            CYG_ASSERT_CLASSO(object, message);
            CYG_TEST_FAIL("CYG_ASSERT_CLASSO() did not trigger");
            break;
 
        case 10:
            CYG_ASSERT_CLASSOC(object);
            CYG_TEST_FAIL("CYG_ASSERT_CLASSOC() did not trigger");
            break;
 
        case 11:
            CYG_PRECONDITION(false, message);
            CYG_TEST_FAIL("CYG_PRECONDITION() did not trigger");
            break;
 
        case 12:
            CYG_PRECONDITIONC(false);
            CYG_TEST_FAIL("CYG_PRECONDITIONC() did not trigger");
            break;
 
        case 13:
            CYG_PRECONDITION_CLASS(&object, message);
            CYG_TEST_FAIL("CYG_PRECONDITION_CLASS() did not trigger");
            break;
 
        case 14:
            CYG_PRECONDITION_CLASSC(&object);
            CYG_TEST_FAIL("CYG_PRECONDITION_CLASSC() did not trigger");
            break;
 
        case 15:
            CYG_PRECONDITION_CLASSO(object, message);
            CYG_TEST_FAIL("CYG_PRECONDITION_CLASSO() did not trigger");
            break;
 
        case 16:
            CYG_PRECONDITION_CLASSOC(object);
            CYG_TEST_FAIL("CYG_PRECONDITION_CLASSOC() did not trigger");
            break;
 
        case 17:
            CYG_POSTCONDITION(false, message);
            CYG_TEST_FAIL("CYG_POSTCONDITION() did not trigger");
            break;
 
        case 18:
            CYG_POSTCONDITIONC(false);
            CYG_TEST_FAIL("CYG_POSTCONDITIONC() did not trigger");
            break;
 
        case 19:
            CYG_POSTCONDITION_CLASS(&object, message);
            CYG_TEST_FAIL("CYG_POSTCONDITION_CLASS() did not trigger");
            break;
 
        case 20:
            CYG_POSTCONDITION_CLASSC(&object);
            CYG_TEST_FAIL("CYG_POSTCONDITION_CLASSC() did not trigger");
            break;
 
        case 21:
            CYG_POSTCONDITION_CLASSO(object, message);
            CYG_TEST_FAIL("CYG_POSTCONDITION_CLASSO() did not trigger");
            break;
 
        case 22:
            CYG_POSTCONDITION_CLASSOC(object);
            CYG_TEST_FAIL("CYG_POSTCONDITION_CLASSOC() did not trigger");
            break;
 
        case 23:
            CYG_LOOP_INVARIANT(false, message);
            CYG_TEST_FAIL("CYG_LOOP_INVARIANT() did not trigger");
            break;
 
        case 24:
            CYG_LOOP_INVARIANTC(false);
            CYG_TEST_FAIL("CYG_LOOP_INVARIANTC() did not trigger");
            break;
 
        case 25:
            CYG_LOOP_INVARIANT_CLASS(&object, message);
            CYG_TEST_FAIL("CYG_LOOP_INVARIANT_CLASS() did not trigger");
            break;
 
        case 26:
            CYG_LOOP_INVARIANT_CLASSC(&object);
            CYG_TEST_FAIL("CYG_LOOP_INVARIANT_CLASSC() did not trigger");
            break;
 
        case 27:
            CYG_LOOP_INVARIANT_CLASSO(object, message);
            CYG_TEST_FAIL("CYG_LOOP_INVARIANT_CLASSO() did not trigger");
            break;
 
        case 28:
            CYG_LOOP_INVARIANT_CLASSOC(object);
            CYG_TEST_FAIL("CYG_LOOP_INVARIANT_CLASSOC() did not trigger");
            break;
 
        case 29:
            CYG_INVARIANT(false, message);
            CYG_TEST_FAIL("CYG_INVARIANT() did not trigger");
            break;
 
        case 30:
            CYG_INVARIANTC(false);
            CYG_TEST_FAIL("CYG_INVARIANTC() did not trigger");
            break;
 
        case 31:
            object.invariant1();
            break;
 
        case 32:
            object.invariant2();
            break;
 
        case 33:
        case 34:
        case 35:
        case 36:
        case 37:
        case 38:
        case 39:
        case 40:
            object.assertions();
            break;
 
        case 41:
        case 42:
        case 43:
        case 44:
        case 45:
        case 46:
        case 47:
        case 48:
            dummy::extern_assertions(&object);
            break;
 
        case 49:
            dummy::invariant3(object);
            break;
 
        case 50:
            dummy::invariant4(object);
            break;
 
        case 51:
            dummy::invariant5(&object);
            break;
 
        case 52:
            dummy::invariant6(&object);
            break;
 
        default:
            done = true;
            counter--;  // About to get incremented again...
            break;
        }
    }
 
    if (failed_assertions != 53) {
        CYG_TEST_FAIL("Broken test case, not all assertions have been tried");
    }
 
    if (failed_assertions == counter) {
        CYG_TEST_PASS("All assertions trigger successfully");
    } else {
        CYG_TEST_FAIL("Not all assertions trigger");
    }
 
    return 0;
}
 

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [host/] [infra/] [testsuite/] [cyginfra/] [tassert6.cxx] - Blame information for rev 786

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