gclib/tophat_cpp/assert_helpers.h

#ifndef ASSERT_HELPERS_H_
#define ASSERT_HELPERS_H_

#include <stdexcept>
#include <string>
#include <cassert>
#include <iostream>

/**
 * Assertion for release-enabled assertions
 */
class ReleaseAssertException : public std::runtime_error {
public:
        ReleaseAssertException(const std::string& msg = "") : std::runtime_error(msg) {}
};

/**
 * Macros for release-enabled assertions, and helper macros to make
 * all assertion error messages more helpful.
 */
#ifndef NDEBUG
#define ASSERT_ONLY(x...) x
#else
#define ASSERT_ONLY(x...)
#endif

#define rt_assert(b)  \
        if(!(b)) { \
                std::cout << "rt_assert at " << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(); \
        }
#define rt_assert_msg(b,msg)  \
        if(!(b)) { \
                std::cout << msg <<  " at " << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(msg); \
        }

#define rt_assert_eq(ex,ac)  \
        if(!((ex) == (ac))) { \
                std::cout << "rt_assert_eq: expected (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(); \
        }
#define rt_assert_eq_msg(ex,ac,msg)  \
        if(!((ex) == (ac))) { \
                std::cout << "rt_assert_eq: " << msg <<  ": (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(msg); \
        }

#ifndef NDEBUG
#define assert_eq(ex,ac)  \
        if(!((ex) == (ac))) { \
                std::cout << "assert_eq: expected (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#define assert_eq_msg(ex,ac,msg)  \
        if(!((ex) == (ac))) { \
                std::cout << "assert_eq: " << msg <<  ": (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#else
#define assert_eq(ex,ac)
#define assert_eq_msg(ex,ac,msg)
#endif

#define rt_assert_neq(ex,ac)  \
        if(!((ex) != (ac))) { \
                std::cout << "rt_assert_neq: expected not (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(); \
        }
#define rt_assert_neq_msg(ex,ac,msg)  \
        if(!((ex) != (ac))) { \
                std::cout << "rt_assert_neq: " << msg << ": (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(msg); \
        }

#ifndef NDEBUG
#define assert_neq(ex,ac)  \
        if(!((ex) != (ac))) { \
                std::cout << "assert_neq: expected not (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#define assert_neq_msg(ex,ac,msg)  \
        if(!((ex) != (ac))) { \
                std::cout << "assert_neq: " << msg << ": (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#else
#define assert_neq(ex,ac)
#define assert_neq_msg(ex,ac,msg)
#endif

#define rt_assert_gt(a,b) \
        if(!((a) > (b))) { \
                std::cout << "rt_assert_gt: expected (" << (a) << ") > (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(); \
        }
#define rt_assert_gt_msg(a,b,msg) \
        if(!((a) > (b))) { \
                std::cout << "rt_assert_gt: " << msg << ": (" << (a) << ") > (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(msg); \
        }

#ifndef NDEBUG
#define assert_gt(a,b) \
        if(!((a) > (b))) { \
                std::cout << "assert_gt: expected (" << (a) << ") > (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#define assert_gt_msg(a,b,msg) \
        if(!((a) > (b))) { \
                std::cout << "assert_gt: " << msg << ": (" << (a) << ") > (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#else
#define assert_gt(a,b)
#define assert_gt_msg(a,b,msg)
#endif

#define rt_assert_geq(a,b) \
        if(!((a) >= (b))) { \
                std::cout << "rt_assert_geq: expected (" << (a) << ") >= (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(); \
        }
#define rt_assert_geq_msg(a,b,msg) \
        if(!((a) >= (b))) { \
                std::cout << "rt_assert_geq: " << msg << ": (" << (a) << ") >= (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(msg); \
        }

#ifndef NDEBUG
#define assert_geq(a,b) \
        if(!((a) >= (b))) { \
                std::cout << "assert_geq: expected (" << (a) << ") >= (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#define assert_geq_msg(a,b,msg) \
        if(!((a) >= (b))) { \
                std::cout << "assert_geq: " << msg << ": (" << (a) << ") >= (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#else
#define assert_geq(a,b)
#define assert_geq_msg(a,b,msg)
#endif

#define rt_assert_lt(a,b) \
        if(!(a < b)) { \
                std::cout << "rt_assert_lt: expected (" << a << ") < (" << b << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(); \
        }
#define rt_assert_lt_msg(a,b,msg) \
        if(!(a < b)) { \
                std::cout << "rt_assert_lt: " << msg << ": (" << a << ") < (" << b << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(msg); \
        }

#ifndef NDEBUG
#define assert_lt(a,b) \
        if(!(a < b)) { \
                std::cout << "assert_lt: expected (" << a << ") < (" << b << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#define assert_lt_msg(a,b,msg) \
        if(!(a < b)) { \
                std::cout << "assert_lt: " << msg << ": (" << a << ") < (" << b << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#else
#define assert_lt(a,b)
#define assert_lt_msg(a,b,msg)
#endif

#define rt_assert_leq(a,b) \
        if(!((a) <= (b))) { \
                std::cout << "rt_assert_leq: expected (" << (a) << ") <= (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(); \
        }
#define rt_assert_leq_msg(a,b,msg) \
        if(!((a) <= (b))) { \
                std::cout << "rt_assert_leq: " << msg << ": (" << (a) << ") <= (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                throw ReleaseAssertException(msg); \
        }

#ifndef NDEBUG
#define assert_leq(a,b) \
        if(!((a) <= (b))) { \
                std::cout << "assert_leq: expected (" << (a) << ") <= (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#define assert_leq_msg(a,b,msg) \
        if(!((a) <= (b))) { \
                std::cout << "assert_leq: " << msg << ": (" << (a) << ") <= (" << (b) << ")" << std::endl; \
                std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
                assert(0); \
        }
#else
#define assert_leq(a,b)
#define assert_leq_msg(a,b,msg)
#endif

#endif /*ASSERT_HELPERS_H_*/
Revision:	29
Committed:	Tue Aug 2 21:24:54 2011 UTC (13 years, 1 month ago) by gpertea
File size:	7754 byte(s)
Log Message:	adding tophat source work
Line	File contents
1	#ifndef ASSERT_HELPERS_H_
2	#define ASSERT_HELPERS_H_
3
4	#include <stdexcept>
5	#include <string>
6	#include <cassert>
7	#include <iostream>
8
9	/**
10	* Assertion for release-enabled assertions
11	*/
12	class ReleaseAssertException : public std::runtime_error {
13	public:
14	ReleaseAssertException(const std::string& msg = "") : std::runtime_error(msg) {}
15	};
16
17	/**
18	* Macros for release-enabled assertions, and helper macros to make
19	* all assertion error messages more helpful.
20	*/
21	#ifndef NDEBUG
22	#define ASSERT_ONLY(x...) x
23	#else
24	#define ASSERT_ONLY(x...)
25	#endif
26
27	#define rt_assert(b) \
28	if(!(b)) { \
29	std::cout << "rt_assert at " << __FILE__ << ":" << __LINE__ << std::endl; \
30	throw ReleaseAssertException(); \
31	}
32	#define rt_assert_msg(b,msg) \
33	if(!(b)) { \
34	std::cout << msg << " at " << __FILE__ << ":" << __LINE__ << std::endl; \
35	throw ReleaseAssertException(msg); \
36	}
37
38	#define rt_assert_eq(ex,ac) \
39	if(!((ex) == (ac))) { \
40	std::cout << "rt_assert_eq: expected (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
41	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
42	throw ReleaseAssertException(); \
43	}
44	#define rt_assert_eq_msg(ex,ac,msg) \
45	if(!((ex) == (ac))) { \
46	std::cout << "rt_assert_eq: " << msg << ": (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
47	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
48	throw ReleaseAssertException(msg); \
49	}
50
51	#ifndef NDEBUG
52	#define assert_eq(ex,ac) \
53	if(!((ex) == (ac))) { \
54	std::cout << "assert_eq: expected (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
55	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
56	assert(0); \
57	}
58	#define assert_eq_msg(ex,ac,msg) \
59	if(!((ex) == (ac))) { \
60	std::cout << "assert_eq: " << msg << ": (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
61	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
62	assert(0); \
63	}
64	#else
65	#define assert_eq(ex,ac)
66	#define assert_eq_msg(ex,ac,msg)
67	#endif
68
69	#define rt_assert_neq(ex,ac) \
70	if(!((ex) != (ac))) { \
71	std::cout << "rt_assert_neq: expected not (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
72	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
73	throw ReleaseAssertException(); \
74	}
75	#define rt_assert_neq_msg(ex,ac,msg) \
76	if(!((ex) != (ac))) { \
77	std::cout << "rt_assert_neq: " << msg << ": (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
78	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
79	throw ReleaseAssertException(msg); \
80	}
81
82	#ifndef NDEBUG
83	#define assert_neq(ex,ac) \
84	if(!((ex) != (ac))) { \
85	std::cout << "assert_neq: expected not (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
86	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
87	assert(0); \
88	}
89	#define assert_neq_msg(ex,ac,msg) \
90	if(!((ex) != (ac))) { \
91	std::cout << "assert_neq: " << msg << ": (" << (ex) << ", 0x" << std::hex << (ex) << std::dec << ") got (" << (ac) << ", 0x" << std::hex << (ac) << std::dec << ")" << std::endl; \
92	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
93	assert(0); \
94	}
95	#else
96	#define assert_neq(ex,ac)
97	#define assert_neq_msg(ex,ac,msg)
98	#endif
99
100	#define rt_assert_gt(a,b) \
101	if(!((a) > (b))) { \
102	std::cout << "rt_assert_gt: expected (" << (a) << ") > (" << (b) << ")" << std::endl; \
103	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
104	throw ReleaseAssertException(); \
105	}
106	#define rt_assert_gt_msg(a,b,msg) \
107	if(!((a) > (b))) { \
108	std::cout << "rt_assert_gt: " << msg << ": (" << (a) << ") > (" << (b) << ")" << std::endl; \
109	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
110	throw ReleaseAssertException(msg); \
111	}
112
113	#ifndef NDEBUG
114	#define assert_gt(a,b) \
115	if(!((a) > (b))) { \
116	std::cout << "assert_gt: expected (" << (a) << ") > (" << (b) << ")" << std::endl; \
117	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
118	assert(0); \
119	}
120	#define assert_gt_msg(a,b,msg) \
121	if(!((a) > (b))) { \
122	std::cout << "assert_gt: " << msg << ": (" << (a) << ") > (" << (b) << ")" << std::endl; \
123	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
124	assert(0); \
125	}
126	#else
127	#define assert_gt(a,b)
128	#define assert_gt_msg(a,b,msg)
129	#endif
130
131	#define rt_assert_geq(a,b) \
132	if(!((a) >= (b))) { \
133	std::cout << "rt_assert_geq: expected (" << (a) << ") >= (" << (b) << ")" << std::endl; \
134	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
135	throw ReleaseAssertException(); \
136	}
137	#define rt_assert_geq_msg(a,b,msg) \
138	if(!((a) >= (b))) { \
139	std::cout << "rt_assert_geq: " << msg << ": (" << (a) << ") >= (" << (b) << ")" << std::endl; \
140	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
141	throw ReleaseAssertException(msg); \
142	}
143
144	#ifndef NDEBUG
145	#define assert_geq(a,b) \
146	if(!((a) >= (b))) { \
147	std::cout << "assert_geq: expected (" << (a) << ") >= (" << (b) << ")" << std::endl; \
148	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
149	assert(0); \
150	}
151	#define assert_geq_msg(a,b,msg) \
152	if(!((a) >= (b))) { \
153	std::cout << "assert_geq: " << msg << ": (" << (a) << ") >= (" << (b) << ")" << std::endl; \
154	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
155	assert(0); \
156	}
157	#else
158	#define assert_geq(a,b)
159	#define assert_geq_msg(a,b,msg)
160	#endif
161
162	#define rt_assert_lt(a,b) \
163	if(!(a < b)) { \
164	std::cout << "rt_assert_lt: expected (" << a << ") < (" << b << ")" << std::endl; \
165	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
166	throw ReleaseAssertException(); \
167	}
168	#define rt_assert_lt_msg(a,b,msg) \
169	if(!(a < b)) { \
170	std::cout << "rt_assert_lt: " << msg << ": (" << a << ") < (" << b << ")" << std::endl; \
171	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
172	throw ReleaseAssertException(msg); \
173	}
174
175	#ifndef NDEBUG
176	#define assert_lt(a,b) \
177	if(!(a < b)) { \
178	std::cout << "assert_lt: expected (" << a << ") < (" << b << ")" << std::endl; \
179	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
180	assert(0); \
181	}
182	#define assert_lt_msg(a,b,msg) \
183	if(!(a < b)) { \
184	std::cout << "assert_lt: " << msg << ": (" << a << ") < (" << b << ")" << std::endl; \
185	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
186	assert(0); \
187	}
188	#else
189	#define assert_lt(a,b)
190	#define assert_lt_msg(a,b,msg)
191	#endif
192
193	#define rt_assert_leq(a,b) \
194	if(!((a) <= (b))) { \
195	std::cout << "rt_assert_leq: expected (" << (a) << ") <= (" << (b) << ")" << std::endl; \
196	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
197	throw ReleaseAssertException(); \
198	}
199	#define rt_assert_leq_msg(a,b,msg) \
200	if(!((a) <= (b))) { \
201	std::cout << "rt_assert_leq: " << msg << ": (" << (a) << ") <= (" << (b) << ")" << std::endl; \
202	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
203	throw ReleaseAssertException(msg); \
204	}
205
206	#ifndef NDEBUG
207	#define assert_leq(a,b) \
208	if(!((a) <= (b))) { \
209	std::cout << "assert_leq: expected (" << (a) << ") <= (" << (b) << ")" << std::endl; \
210	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
211	assert(0); \
212	}
213	#define assert_leq_msg(a,b,msg) \
214	if(!((a) <= (b))) { \
215	std::cout << "assert_leq: " << msg << ": (" << (a) << ") <= (" << (b) << ")" << std::endl; \
216	std::cout << __FILE__ << ":" << __LINE__ << std::endl; \
217	assert(0); \
218	}
219	#else
220	#define assert_leq(a,b)
221	#define assert_leq_msg(a,b,msg)
222	#endif
223
224	#endif /ASSERT_HELPERS_H_/