Context Navigation

source: branches/help/UNIT_TESTER/test_unit.h

Visit:

Last change on this file was 18311, checked in by westram, 5 years ago
reintegrates 'saicalc' into 'trunk' implements #730 adds: log:branches/saicalc@18141:18310
File size: 66.7 KB

Line
1	// ================================================================ //
2	// //
3	// File : test_unit.h //
4	// Purpose : include into test code //
5	// //
6	// Coded by Ralf Westram (coder@reallysoft.de) in February 2010 //
7	// Institute of Microbiology (Technical University Munich) //
8	// http://www.arb-home.de/ //
9	// //
10	// ================================================================ //
11
12	#ifndef TEST_UNIT_H
13	#define TEST_UNIT_H
14
15	#ifndef ARB_ASSERT_H
16	#include <arb_assert.h>
17	#endif
18	#ifndef ARBTOOLS_H
19	#include <arbtools.h>
20	#endif
21	#ifndef _GLIBCXX_CSTDARG
22	#include <cstdarg>
23	#endif
24	#ifndef _CPP_CSTDLIB
25	#include <cstdlib>
26	#endif
27	#ifndef ERRNO_H
28	#include <errno.h>
29	#endif
30	#ifndef DUPSTR_H
31	#include <dupstr.h>
32	#endif
33
34	#if defined(_GLIBCXX_STRING) \|\| defined(_LIBCPP_STRING)
35	#define TESTS_KNOW_STRING
36	#endif
37	#ifdef ARBDB_BASE_H
38	#define TESTS_KNOW_ARBDB
39	#endif
40	#ifdef ARB_ERROR_H
41	#define TESTS_KNOW_ARB_ERROR
42	#endif
43
44
45	#define ENABLE_CRASH_TESTS // comment out this line to get rid of provoked SEGVs (e.g. while debugging test-code)
46	// (Note: another way to get rid of these tests is to RESTRICT_FUN='!crashtest' via Makefile.setup.local)
47
48	/* Note:
49	* This file should not generate any static code.
50	* Only place define's or inline functions here.
51	*
52	* All macros named 'XXX__BROKEN' are intended to be used, when a
53	* test is known to fail, but cannot be fixed atm for some reason
54	*
55	* Recommended test-assertion is TEST_EXPECTATION(that(..).xxx())
56	* see examples in test-unit-tests in ../CORE/arb_string.cxx@UNIT_TESTS
57	*/
58
59	// --------------------------------------------------------------------------------
60	// reduce build-time by disabling some optimizations for selected function (see #770)
61	// The attributes here - opposed to global attributes defined in ../TEMPLATES/attributes.h
62	// are only made available inside unit-test-sections!
63	//
64	// Good candidates for __ATTR__REDUCED_OPTIMIZE are TEST_xxx() functions for which
65	// you encounter the following compiler warning:
66	// warning: PRE disabled
67	//
68	// Good candidates for __ATTR__NO_GCSE_OPTIMIZE are TEST_xxx() functions for which
69	// you encounter the following compiler warnings:
70	// warning: const/copy propagation disabled
71	// warning: GCSE disabled
72
73	#if (GCC_PATCHLEVEL_CODE >= 40603)
74	# define __ATTR__NOVARTRACK __ATTR__OPTIMIZE("no-var-tracking") __ATTR__OPTIMIZE("no-var-tracking-assignments")
75	// #define __ATTR__REDUCED_OPTIMIZE // [*1]
76	// #define __ATTR__REDUCED_OPTIMIZE __ATTR__NOVARTRACK // [2] duration compared to [1]: 40-70% (40% for gcc 7.1)
77	#define __ATTR__REDUCED_OPTIMIZE __ATTR__NOVARTRACK __ATTR__OPTIMIZE("s") // [3] duration compared to [1]: ~30%
78	#define __ATTR__NO_GCSE_OPTIMIZE __ATTR__OPTIMIZE("no-gcse")
79	#else
80	// (some) gcc versions prior to 4.6.3 have problems if single optimizations are disabled on function-basis
81	// (e.g. 4.4.3 crashes with internal compiler error if __ATTR__OPTIMIZE("s") is used)
82	// -> do not reduce optimization (#770 was not a problem with older versions anyway)
83	# define __ATTR__REDUCED_OPTIMIZE
84	# define __ATTR__NO_GCSE_OPTIMIZE
85	#endif
86
87	// for functions with both warning-types:
88	# define __ATTR__REDUCED_OPTIMIZE__NO_GCSE __ATTR__REDUCED_OPTIMIZE __ATTR__NO_GCSE_OPTIMIZE
89
90	// --------------------------------------------------------------------------------
91
92
93	#define ANY_SETUP "any_env_setup"
94
95	namespace arb_test {
96
97	// -------------
98	// str
99
100	class str {
101	char *s;
102	public:
103	str() : s(NULp) {}
104	str(const str& other) : s(nulldup(other.s)) {}
105	explicit str(char *S) : s(S) {}
106	str& operator = (const str& other) {
107	freedup(s, other.s);
108	return *this;
109	}
110	str& operator = (char *S) {
111	freeset(s, S);
112	return *this;
113	}
114	~str() { free(s); }
115
116	bool exists() const { return s; }
117	void assign(char *S) { s = S; }
118	const char *value() const { return s; }
119	};
120
121	// -----------------------
122	// location info
123
124	#define WITHVALISTFROM(format,CODE) do { va_list parg; va_start(parg, format); CODE; va_end(parg); } while(0)
125	#define VPRINTFORMAT(format) WITHVALISTFROM(format, vfprintf(stderr, format, parg))
126	#define VCOMPILERMSG(msgtype,format) WITHVALISTFROM(format, vcompiler_msg(msgtype, format, parg))
127
128	class locinfo { //! stores source code location
129	const char *file;
130	int line;
131
132	__attribute__((format(__printf__, 2, 0))) void vcompiler_msg(const char message_type, const char format, va_list parg) const {
133	fprintf(stderr, "%s:%i: ", file, line);
134	if (message_type) fprintf(stderr, "%s: ", message_type);
135	vfprintf(stderr, format, parg);
136	}
137
138	public:
139	locinfo() : file(NULp), line(0) {}
140	locinfo(const char *file_, int line_) : file(file_), line(line_) {}
141
142	bool exists() const { return file; }
143
144	const char *get_file() const { return file; }
145	int get_line() const { return line; }
146
147	__attribute__((format(printf, 2, 3))) bool warningf(const char *format, ...) const {
148	GlobalTestData& global = test_data();
149	if (global.show_warnings) {
150	FlushedOutput yes;
151	VCOMPILERMSG("Warning", format);
152	GlobalTestData::print_annotation();
153	global.warnings++;
154	}
155	return global.show_warnings;
156	}
157
158	__attribute__((format(printf, 3, 4))) void errorf(bool fail, const char *format, ...) const {
159	{
160	FlushedOutput yes;
161	VCOMPILERMSG("Error", format);
162	GlobalTestData::print_annotation();
163	}
164	if (fail) TRIGGER_ASSERTION(false); // fake an assertion failure
165	}
166	__attribute__((format(printf, 3, 4))) void ioerrorf(bool fail, const char *format, ...) const {
167	{
168	FlushedOutput yes;
169	VCOMPILERMSG("Error", format);
170	fprintf(stderr, " (errno=%i='%s')", errno, strerror(errno));
171	GlobalTestData::print_annotation();
172	}
173	if (fail) TRIGGER_ASSERTION(false); // fake an assertion failure
174	}
175	};
176
177	// --------------------
178	// StaticCode
179
180	struct StaticCode {
181	static void printf(const char *format, ...) __attribute__((format(printf, 1, 2))) {
182	FlushedOutputNoLF yes;
183	VPRINTFORMAT(format);
184	}
185	#undef VPRINTFORMAT
186	#undef VCOMPILERMSG
187	#undef WITHVALISTFROM
188
189	static char readable_string(const char s) {
190	// quote like C does!
191	if (s) {
192	size_t len = strlen(s)*4;
193	char res = (char)malloc(len+2+1);
194	bool needSep = false;
195	int j = 0;
196
197	res[j++] = '\"';
198	for (int i = 0; s[i]; ++i) {
199	unsigned char c = static_cast<unsigned char>(s[i]);
200	char esc = 0;
201	switch (c) {
202	case '\a': esc = 'a'; break;
203	case '\b': esc = 'b'; break;
204	case '\f': esc = 'f'; break;
205	case '\n': esc = 'n'; break;
206	case '\r': esc = 'r'; break;
207	case '\t': esc = 't'; break;
208	case '\v': esc = 'v'; break;
209	case '\"': esc = '\"'; break;
210	case '\\': esc = '\\'; break;
211	}
212	if (esc) {
213	res[j++] = '\\';
214	res[j++] = esc;
215	needSep = false;
216	}
217	else {
218	if (c >= 32 && c<127) {
219	if (needSep && strchr("0123456789abcdefABCDEF", c)) {
220	res[j++] = '\"'; // break string
221	res[j++] = '\"';
222	}
223	res[j++] = c;
224	needSep = false;
225	}
226	else {
227	j += sprintf(res+j, "\\x%02x", int(c));
228	needSep = true; // need to break string if next char is a hex-digit
229	}
230	}
231	}
232	res[j++] = '\"';
233	res[j++] = 0;
234	return res;
235	}
236	else {
237	return strdup("(null)");
238	}
239	}
240	static void print_readable_string(const char s, FILE out) {
241	fputs(str(readable_string(s)).value(), out);
242	}
243
244	static char vstrf(const char format, va_list& parg) __attribute__((format(__printf__, 1, 0))) {
245	static const size_t max_vstrf_size = 10000;
246	static char vstrf_buf[max_vstrf_size];
247
248	int printed = vsnprintf(vstrf_buf, max_vstrf_size, format, parg);
249	arb_assert(printed >= 0 && size_t(printed)<max_vstrf_size);
250
251	char result = (char)malloc(printed+1);
252	memcpy(result, vstrf_buf, printed);
253	result[printed] = 0;
254	return result;
255	}
256
257	static char strf(const char format, ...) __attribute__((format(__printf__, 1, 2))) {
258	va_list parg;
259	va_start(parg, format);
260	char *result = vstrf(format, parg);
261	va_end(parg);
262	return result;
263	}
264
265	};
266
267	inline char *val2readable(bool b) { return strdup(b ? "true" : "false"); }
268
269	inline char *val2readable(int i) { return StaticCode::strf("%i", i); }
270	inline char *val2hex(int i) { return StaticCode::strf("0x%x", i); }
271
272	inline char *val2readable(long L) { return StaticCode::strf("%li", L); }
273	inline char *val2hex(long L) { return StaticCode::strf("0x%lx", L); }
274
275	inline char *val2readable(size_t z) { return StaticCode::strf("%zu", z); }
276	inline char *val2hex(size_t z) { return StaticCode::strf("0x%zx", z); }
277
278	// dont dup size_t:
279	#ifdef ARB_64
280	inline char *val2readable(unsigned u) { return StaticCode::strf("%u", u); }
281	inline char *val2hex(unsigned u) { return StaticCode::strf("0x%x", u); }
282	#else
283	inline char *val2readable(long unsigned u) { return StaticCode::strf("%lu", u); }
284	inline char *val2hex(long unsigned u) { return StaticCode::strf("0x%lx", u); }
285	#endif
286
287	inline char *val2readable(double d) { return StaticCode::strf("%f", d); }
288
289	inline char *val2readable(unsigned char c) { return c<32 ? StaticCode::strf(" ^%c (=0x%02x)", c+'A'-1, int(c)) : StaticCode::strf("'%c' (=0x%02x)", c, int(c)); }
290	inline char val2readable(const char s) { return StaticCode::readable_string(s); }
291
292	#ifdef TESTS_KNOW_STRING
293	inline char *val2readable(const std::string& s) { return StaticCode::readable_string(s.c_str()); }
294	#endif
295	#if defined(TESTS_KNOW_ARBDB)
296	inline char val2readable(const GBDATA gbd) { return StaticCode::strf("%p", gbd); }
297	#endif
298
299	// ------------------
300	// copy
301
302
303	template <typename T>
304	class copy { //! makes char* copyable, so it can be handled like most other types
305	T t;
306	public:
307	copy(const T& t_) : t(t_) {}
308	operator const T&() const { return t; }
309	};
310
311	template <>
312	class copy<const char *> {
313	str t;
314	public:
315	copy(const char *t_) : t(str(t_ ? strdup(t_) : NULp)) {}
316	operator const char *() const { return t.value(); }
317	};
318
319	template <typename T> class copy< copy<T> > { copy(const copy<T>& t_); }; // avoid copies of copies
320
321	template <typename T> inline copy<T> make_copy(const T& t) { return copy<T>(t); }
322
323	inline copy<const char > make_copy(const char p) { return copy<const char *>(p); }
324	inline copy<const char > make_copy(char p) { return copy<const char *>(p); }
325	inline copy<const char > make_copy(const unsigned char p) { return copy<const char >(reinterpret_cast<const char >(p)); }
326	inline copy<const char > make_copy(unsigned char p) { return copy<const char >(reinterpret_cast<const char >(p)); }
327	inline copy<const char > make_copy(const signed char p) { return copy<const char >(reinterpret_cast<const char >(p)); }
328	inline copy<const char > make_copy(signed char p) { return copy<const char >(reinterpret_cast<const char >(p)); }
329
330	inline copy<unsigned char> make_copy(char p) { return copy<unsigned char>(p); }
331	inline copy<unsigned char> make_copy(unsigned char p) { return copy<unsigned char>(p); }
332	inline copy<unsigned char> make_copy(signed char p) { return copy<unsigned char>(p); }
333
334	template <typename T> str readable(const copy<T>& v) { return str(val2readable(v)); }
335	template <typename T> str readableHex(const copy<T>& v) { return str(val2readableHex(v)); }
336
337	template <typename T> bool operator == (const copy<T>& v1, const copy<T>& v2) { return static_cast<const T&>(v1) == static_cast<const T&>(v2); }
338	template <typename T> bool operator != (const copy<T>& v1, const copy<T>& v2) { return !(v1 == v2); }
339
340	template <> inline bool operator == <const char >(const copy<const char >& v1, const copy<const char *>& v2) {
341	const char *val1 = v1;
342	const char *val2 = v2;
343
344	return (val1 == val2) \|\| (val1 && val2 && (strcmp(val1, val2) == 0));
345	}
346
347
348	template <typename T> inline void print(const T& t) {
349	char *r = val2readable(make_copy(t));
350	fputs(r, stderr);
351	free(r);
352	}
353	template <typename T> inline void print_hex(const T& t) { fputs(val2hex(make_copy(t)), stderr); }
354
355	template <typename T1, typename T2> inline void print_pair(T1 t1, T2 t2) {
356	print(t1);
357	fputs(",", stderr);
358	print(t2);
359	}
360	template <typename T1, typename T2> inline void print_hex_pair(T1 t1, T2 t2) {
361	print_hex(t1);
362	fputc(',', stderr);
363	print_hex(t2);
364	}
365
366	class epsilon_similar {
367	double epsilon;
368	public:
369	epsilon_similar(double epsilon_) : epsilon(epsilon_) { arb_assert(epsilon>0.0); }
370	bool operator()(const double& d1, const double& d2) const {
371	double diff = d1-d2;
372	if (diff<0.0) diff = -diff; // do not use fabs() here
373	return diff <= epsilon;
374	}
375	};
376
377	class containing {
378	static bool not_empty(const char *part) { arb_assert(part); return part[0]; }
379	#if defined(TESTS_KNOW_STRING)
380	static bool not_empty(const std::string& part) { return !part.empty(); }
381	#endif
382	public:
383	bool operator()(const char str, const char part) const {
384	arb_assert(str); // NULp str will crash strstr
385	arb_assert(not_empty(part)); // do NOT call with empty part - will always report true.
386	return not_empty(part) && strstr(str, part); // return false if part is empty (=safety fallback)
387	}
388	#if defined(TESTS_KNOW_STRING)
389	bool operator()(const std::string& str, const std::string& part) const {
390	arb_assert(not_empty(part)); // see above
391	return not_empty(part) && strstr(str.c_str(), part.c_str());
392	}
393	#endif
394	};
395
396	// -------------------------------
397	// some output functions
398
399	inline void print(const char *s) { fputs(s, stderr); }
400	inline void print(char c) { fputc(c, stderr); }
401	inline void print(int i) { fprintf(stderr, "%i", i); }
402
403	inline void space() { print(' '); }
404	inline void nl() { print('\n'); }
405
406	inline void print_indent(int indent) { while (indent--) space(); }
407
408	inline void spaced(const char *word) { space(); print(word); space(); }
409	inline void select_spaced(bool first, const char singular, const char plural) { spaced(first ? singular : plural); }
410
411
412	#define HASTOBE_CLONABLE(type) virtual type *clone() const = 0
413	#define MAKE_CLONABLE(type) type clone() const OVERRIDE { return new type(this); }
414
415	// ------------------------------
416	// abstract expectation
417
418	struct expectation { //! something expected. can be fulfilled or not (and can explain why/not)
419	virtual ~expectation() {}
420	HASTOBE_CLONABLE(expectation);
421
422	virtual bool fulfilled() const = 0;
423	virtual void explain(int indent) const = 0;
424	virtual void dump_brief_description() const = 0;
425	};
426
427	// -------------------
428	// asserters
429
430	class asserter : virtual Noncopyable {
431	expectation *expected;
432	locinfo loc;
433	const char *code;
434
435	virtual void announce_failure() const { TRIGGER_ASSERTION(false); }
436
437	void err(const char *format) const { loc.errorf(false, format, code); }
438	bool warn(const char *format) const { return loc.warningf(format, code); }
439
440	public:
441	asserter(const expectation& e, const char nontmp_code, const char file, int line)
442	: expected(e.clone()),
443	loc(file, line),
444	code(nontmp_code)
445	{}
446	virtual ~asserter() { delete expected; }
447
448	const char *get_code() const { return code; }
449
450	void expect_that() const {
451	if (!expected->fulfilled()) {
452	err("Failed expectation '%s'");
453	print("expectation fails because\n");
454	expected->explain(2); print('\n');
455	announce_failure();
456	}
457	}
458	void expect_broken() const {
459	if (expected->fulfilled()) {
460	err("Previously broken expectation '%s' succeeds");
461	announce_failure();
462	}
463	else {
464	if (warn("Expectation '%s' known as broken (accepted until fixed)")) {
465	print("Broken because\n");
466	expected->explain(2); print('\n');
467	}
468	}
469	}
470
471	void expect_wanted_behavior() const {
472	if (expected->fulfilled()) {
473	err("Wanted behavior '%s' reached");
474	announce_failure();
475	}
476	else {
477	if (warn("Wanted behavior: '%s'")) {
478	print("Unsatisfied because\n");
479	expected->explain(2); print('\n');
480	}
481	}
482	}
483
484	void expect_brokenif(bool condition, const char *condcode) {
485	GlobalTestData& global = test_data();
486
487	char *old_annotation = nulldup(global.get_annotation());
488	char *new_annotation = StaticCode::strf("when (%s) is %s; %s",
489	condcode,
490	str(val2readable(condition)).value(),
491	null2empty(old_annotation));
492
493	global.annotate(new_annotation);
494	if (condition) expect_broken(); else expect_that();
495	global.annotate(old_annotation);
496
497	free(new_annotation);
498	free(old_annotation);
499	}
500	};
501
502	class debug_asserter : public asserter {
503	void announce_failure() const OVERRIDE {
504	print("<<< would trigger assertion now! >>>\n");
505	}
506	public:
507	debug_asserter(const expectation& e, const char code_, const char file, int line)
508	: asserter(e, code_, file, line)
509	{}
510
511	void debug_expectations() {
512	fprintf(stderr, "-------------------- [Debugging expectations for '%s']\n", get_code());
513	expect_that();
514	expect_broken();
515	expect_wanted_behavior();
516	}
517	};
518
519	// ----------------------------------------
520	// matchable + matcher (abstract)
521
522	struct matchable { //! can be matched with corresponding matcher.
523	virtual ~matchable() {}
524	HASTOBE_CLONABLE(matchable);
525
526	virtual const char *name() const = 0;
527	virtual const char *readable_value() const = 0;
528	};
529
530	struct matcher { //! can match things.
531	virtual ~matcher() {}
532	HASTOBE_CLONABLE(matcher);
533
534	virtual bool matches(const matchable& thing) const = 0;
535	virtual void dump_expectation(const matchable& thing, int indent) const = 0;
536	virtual void dump_brief_description(const matchable& thing) const = 0;
537	};
538
539	// ----------------------------------------------
540	// expectation from matchable + matcher
541
542
543	class match_expectation : public expectation { //! expectation composed from matcher and corresponding matchable.
544	matchable *thing;
545	matcher *condition;
546	public:
547	match_expectation(const matchable& thing_, const matcher& condition_)
548	: thing(thing_.clone()),
549	condition(condition_.clone())
550	{}
551	match_expectation(const match_expectation& other)
552	: thing(other.thing->clone()),
553	condition(other.condition->clone())
554	{}
555	DECLARE_ASSIGNMENT_OPERATOR(match_expectation);
556	MAKE_CLONABLE(match_expectation);
557	~match_expectation() OVERRIDE {
558	delete thing;
559	delete condition;
560	}
561
562	bool fulfilled() const OVERRIDE { return condition->matches(*thing); }
563	bool unfulfilled() const { return !fulfilled(); }
564	void explain(int indent) const OVERRIDE { condition->dump_expectation(*thing, indent); }
565	void dump_brief_description() const OVERRIDE { condition->dump_brief_description(*thing); }
566	};
567
568	// -------------------
569	// predicate
570
571
572	class predicate_description {
573	const char *primary;
574	const char *inverse;
575	mutable str tmp;
576
577	void erase_last_from_tmp() const {
578	char t = const_cast<char>(tmp.value());
579	int len = strlen(t);
580	t[len-1] = 0;
581	}
582
583	static bool ends_with_s(const char *s) {
584	int len = strlen(s);
585	return s[len-1] == 's';
586	}
587
588	const char make(const char desc, bool got) const {
589	if (ends_with_s(desc)) {
590	if (got) return desc;
591	tmp = StaticCode::strf("doesnt %s", desc);
592	erase_last_from_tmp();
593	}
594	else {
595	tmp = StaticCode::strf("%s %s", got ? "is" : "isnt", desc);
596	}
597	return tmp.value();
598	}
599
600	public:
601	predicate_description(const char *primary_) : primary(primary_), inverse(NULp) {}
602	predicate_description(const char primary_, const char inverse_) : primary(primary_), inverse(inverse_) {}
603	// cppcheck-suppress uninitMemberVar (fails to detect default ctor of 'str')
604	predicate_description(const predicate_description& other) : primary(other.primary), inverse(other.inverse) {}
605	DECLARE_ASSIGNMENT_OPERATOR(predicate_description);
606
607	const char *make(bool expected, bool got) const {
608	if (expected) return make(primary, got);
609	if (inverse) return make(inverse, !got);
610	return make(primary, got);
611	}
612	};
613
614	template <typename FUNC>
615	class predicate {
616	FUNC pred;
617	predicate_description description;
618	public:
619	predicate(FUNC pred_, const char *name) : pred(pred_), description(name) {}
620	predicate(FUNC pred_, const char name, const char inverse) : pred(pred_), description(name, inverse) {}
621
622	template <typename T> bool matches(const copy<T>& v1, const copy<T>& v2) const { return pred(v1, v2); }
623	const char *describe(bool expected, bool got) const { return description.make(expected, got); }
624	};
625
626	template <typename FUNC> predicate<FUNC> make_predicate(FUNC func, const char primary, const char inverse) {
627	return predicate<FUNC>(func, primary, inverse);
628	}
629
630	// ------------------------------------------
631	// matchable + matcher (for values)
632
633	template <typename T> inline bool equals(const copy<T>& t1, const copy<T>& t2) { return t1 == t2; }
634	template <typename T> inline bool less(const copy<T>& t1, const copy<T>& t2) { return t1 < t2; }
635	template <typename T> inline bool more(const copy<T>& t1, const copy<T>& t2) { return t1 > t2; }
636
637	template <typename T>
638	class matchable_value FINAL_TYPE : public matchable { //! matchable for values
639	copy<T> val;
640	mutable str readable;
641	const char * code;
642	public:
643	matchable_value(copy<T> val_, const char *nontemp_code) : val(val_), code(nontemp_code) {}
644	matchable_value(const matchable_value<T>& other) : val(other.val), readable(other.readable), code(other.code) {}
645	DECLARE_ASSIGNMENT_OPERATOR(matchable_value);
646	MAKE_CLONABLE(matchable_value<T>);
647
648	const copy<T>& value() const { return val; }
649	char *gen_description() const { return StaticCode::strf("%s (=%s)", code, val.readable()); }
650
651	const char *name() const OVERRIDE { return code; }
652	const char *readable_value() const OVERRIDE {
653	if (!readable.exists()) readable = arb_test::readable(val);
654	return readable.value();
655	}
656
657	template <typename U> inline match_expectation equals_expectation(bool invert, const U& other, const char *code) const;
658	template <typename U> inline match_expectation lessThan_expectation(bool invert, const U& other, const char *code) const;
659	template <typename U> inline match_expectation moreThan_expectation(bool invert, const U& other, const char *code) const;
660
661	inline match_expectation null_expectation(bool wantNULL) const;
662
663	template <typename FUNC> inline match_expectation predicate_expectation(bool wanted, predicate<FUNC> pred, matchable_value<T> arg) const;
664	template <typename U, typename FUNC> inline match_expectation predicate_expectation(bool wanted, FUNC pred, const char pred_code, const U& arg, const char arg_code) const;
665	};
666
667	template <typename T, typename U>
668	inline const matchable_value<T> make_matchable_value(const U& other, const char *code_) {
669	return matchable_value<T>(T(other), code_);
670	}
671	#if defined(TESTS_KNOW_STRING)
672	template<>
673	inline const matchable_value<const char> make_matchable_value<const char , std::string>(const std::string& other, const char *code_) {
674	return matchable_value<const char *>(other.c_str(), code_);
675	}
676	#endif
677	template <typename T> template <typename U>
678	inline match_expectation matchable_value<T>::equals_expectation(bool wanted, const U& other, const char *code_) const {
679	return predicate_expectation(wanted, make_predicate(equals<T>, "equals", "differs"), make_matchable_value<T,U>(other, code_));
680	}
681	template <typename T> template <typename U>
682	inline match_expectation matchable_value<T>::lessThan_expectation(bool wanted, const U& other, const char *code_) const {
683	return predicate_expectation(wanted, make_predicate(less<T>, "less than", "more or equal"), make_matchable_value<T,U>(other, code_));
684	}
685	template <typename T> template <typename U>
686	inline match_expectation matchable_value<T>::moreThan_expectation(bool wanted, const U& other, const char *code_) const {
687	return predicate_expectation(wanted, make_predicate(more<T>, "more than", "less or equal"), make_matchable_value<T,U>(other, code_));
688	}
689	template <typename T>
690	inline match_expectation matchable_value<T>::null_expectation(bool wantNULL) const {
691	return equals_expectation(wantNULL, (T)NULp, "NULp");
692	}
693
694	template <typename T>
695	class value_matcher : public matcher { //! matcher for values
696	matchable_value<T> expected;
697	public:
698	value_matcher(const matchable_value<T>& expected_) : expected(expected_) {}
699	~value_matcher() OVERRIDE {}
700
701	virtual bool matches(const copy<T>& v1, const copy<T>& v2) const = 0;
702	virtual const char *relation(bool isMatch) const = 0;
703
704	const matchable_value<T>& get_expected() const { return expected; }
705
706	bool matches(const matchable& thing) const FINAL_OVERRIDE {
707	const matchable_value<T>& value_thing = dynamic_cast<const matchable_value<T>&>(thing);
708	return matches(value_thing.value(), expected.value());
709	}
710
711	void dump_expectation(const matchable& thing, int indent) const OVERRIDE {
712	bool isMatch = matches(thing);
713	print_indent(indent);
714	fprintf(stderr, "'%s' %s '%s'", thing.name(), relation(isMatch), expected.name());
715
716	const matchable_value<T>& value_thing = dynamic_cast<const matchable_value<T>&>(thing);
717	if (equals<T>(value_thing.value(), expected.value())) {
718	fprintf(stderr, " (both are %s)", value_thing.readable_value());
719	}
720	else {
721	int diff = strlen(thing.name())-strlen(expected.name());
722
723	print(", where\n");
724	indent += 2;;
725	print_indent(indent); fprintf(stderr, "'%s'%*s is %s, and\n", thing.name(), (diff>0 ? 0 : -diff), "", thing.readable_value());
726	print_indent(indent); fprintf(stderr, "'%s'%*s is %s", expected.name(), (diff<0 ? 0 : diff), "", expected.readable_value());
727	}
728	}
729	void dump_brief_description(const matchable& thing) const OVERRIDE {
730	print(thing.name());
731	print('.');
732	print(relation(true));
733	print('('); print(expected.name()); print(')');
734	}
735
736	};
737
738	// ---------------------------
739	// predicate_matcher
740
741
742	template <typename T, typename FUNC>
743	// cppcheck-suppress noConstructor (fails to detect template ctor)
744	class predicate_matcher : public value_matcher<T> {
745	predicate<FUNC> pred;
746	bool expected_result;
747
748	public:
749	predicate_matcher(bool wanted, predicate<FUNC> pred_, const matchable_value<T>& arg)
750	: value_matcher<T>(arg),
751	pred(pred_),
752	expected_result(wanted)
753	{}
754	MAKE_CLONABLE(predicate_matcher);
755
756	bool matches(const copy<T>& v1, const copy<T>& v2) const OVERRIDE { return correlated(pred.matches(v1, v2), expected_result); }
757	const char *relation(bool isMatch) const OVERRIDE { return pred.describe(expected_result, correlated(isMatch, expected_result)); }
758	};
759
760	template <typename T> template <typename FUNC>
761	inline match_expectation matchable_value<T>::predicate_expectation(bool wanted, predicate<FUNC> pred, matchable_value<T> arg) const {
762	return match_expectation(*this, predicate_matcher<T,FUNC>(wanted, pred, arg));
763	}
764	template <typename T> template <typename U, typename FUNC>
765	inline match_expectation matchable_value<T>::predicate_expectation(bool wanted, FUNC pred, const char pred_code, const U& arg, const char arg_code) const {
766	return match_expectation(*this, predicate_matcher<T,FUNC>(wanted, predicate<FUNC>(pred, pred_code), make_matchable_value<T,U>(arg, arg_code)));
767	}
768
769	// ------------------------------------------------
770	// matchable + matcher (for expectations)
771
772	const int MAX_GROUP_SIZE = 5;
773	class expectation_group : public matchable { //! group of expectation. matchable with group_matcher
774	int count;
775	expectation *depend_on[MAX_GROUP_SIZE];
776
777	expectation_group& operator = (const expectation_group&); // forbidden
778	protected:
779
780	public:
781	expectation_group() : count(0) { depend_on[0] = NULp; }
782	expectation_group(const expectation& e) : count(1) {
783	depend_on[0] = e.clone();
784	}
785	expectation_group(const expectation& e1, const expectation& e2) : count(2) {
786	depend_on[0] = e1.clone();
787	depend_on[1] = e2.clone();
788	}
789	expectation_group(const expectation_group& other) : count(other.count) {
790	for (int i = 0; i<count; ++i) {
791	depend_on[i] = other.depend_on[i]->clone();
792	}
793	}
794	~expectation_group() OVERRIDE {
795	for (int i = 0; i<count; ++i) {
796	delete depend_on[i];
797	}
798	}
799	MAKE_CLONABLE(expectation_group);
800
801	expectation_group& add(const expectation& e) { depend_on[count++] = e.clone(); arb_assert(count <= MAX_GROUP_SIZE); return *this; }
802
803	const char *name() const OVERRIDE {
804	return "<expectation_group>";
805	}
806	const char *readable_value() const OVERRIDE {
807	return "<value of expectation_group>";
808	}
809
810	const expectation& dependent(int i) const { arb_assert(i<count); return *depend_on[i]; }
811	int size() const { return count; }
812	int count_fulfilled() const {
813	int ff = 0;
814	for (int i = 0; i<count; ++i) {
815	ff += dependent(i).fulfilled();
816	}
817	return ff;
818	}
819	void dump_some_expectations(int indent, bool fulfilled, bool unfulfilled) const {
820	if (fulfilled\|\|unfulfilled) {
821	bool all = fulfilled && unfulfilled;
822	bool wanted = fulfilled;
823
824	bool printed = false;
825	for (int i = 0; i<size(); ++i) {
826	const expectation& e = dependent(i);
827
828	bool is_fulfilled = e.fulfilled();
829	if (all \|\| is_fulfilled == wanted) {
830	if (printed) print('\n');
831	e.explain(indent);
832	printed = true;
833	}
834	}
835	}
836	}
837	void dump_brief_description() const {
838	print("of(");
839	bool printed = false;
840	for (int i = 0; i<size(); ++i) {
841	if (printed) print(", ");
842	const expectation& e = dependent(i);
843	e.dump_brief_description();
844	printed = true;
845	}
846	print(')');
847	}
848	};
849
850	struct group_match { //! result of matching an expectation_group with a group_matcher
851	const int count;
852	const int fulfilled;
853	const int min_req;
854	const int max_req;
855	const int diff;
856
857	int required(int what) const { return what == -1 ? count : what; }
858	group_match(const expectation_group& egroup, int min, int max)
859	: count(egroup.size()),
860	fulfilled(egroup.count_fulfilled()),
861	min_req(required(min)),
862	max_req(required(max)),
863	diff(fulfilled<min_req
864	? fulfilled-min_req
865	: (fulfilled>max_req ? fulfilled-max_req : 0))
866	{}
867
868
869	inline static void is(int a) { select_spaced(a == 1, "is", "are"); }
870	inline static void was(int a) { select_spaced(a < 2, "was", "were"); }
871	inline static void amountzero(int a, const char *zero) { a ? print(a) : print(zero); }
872
873	void dump_num_of(int amount, const char *thing) const {
874	amountzero(amount, "no");
875	space();
876	print(thing);
877	if (amount != 1) print('s');
878	}
879
880	void dump(const expectation_group& group, int indent) const {
881	print_indent(indent);
882	if (count == 1) {
883	print("expectation ");
884	print("'");
885	group.dependent(0).dump_brief_description();
886	print("' ");
887	print(fulfilled ? "fulfilled" : "fails");
888	print(diff ? " unexpectedly" : " as expected");
889	}
890	else {
891	print("expected ");
892	int that_many;
893	if (min_req == max_req) {
894	if (diff>0 && min_req>0) print("only ");
895	that_many = min_req;
896	}
897	else {
898	if (diff) {
899	print("at"); select_spaced(diff<0, "least", "most");
900	that_many = diff<0 ? min_req : max_req;
901	}
902	else {
903	fprintf(stderr, "%i-", min_req);
904	that_many = max_req;
905	}
906	}
907	dump_num_of(that_many, "fulfilled expectation");
908	space();
909	group.dump_brief_description();
910	nl();
911
912	indent += 2;
913	print_indent(indent);
914	if (diff == 0) print("and "); else print("but ");
915
916	if (diff<0 && fulfilled>0) print("only ");
917	amountzero(fulfilled, "none"); is(fulfilled); print("fulfilled");
918	}
919
920	print(", because\n");
921	bool show_fulfilled = diff >= 0;
922	bool show_unfulfilled = diff <= 0;
923	group.dump_some_expectations(indent+2, show_fulfilled, show_unfulfilled);
924	}
925	};
926
927	class group_matcher FINAL_TYPE : public matcher { //! matches expectation_group for degree of fulfilledness
928	int min, max;
929	group_matcher(int min_, int max_) : min(min_), max(max_) {}
930	public:
931	MAKE_CLONABLE(group_matcher);
932
933	bool matches(const matchable& thing) const OVERRIDE {
934	return group_match(dynamic_cast<const expectation_group&>(thing), min, max).diff == 0;
935	}
936
937	void dump_expectation(const matchable& thing, int indent) const OVERRIDE {
938	const expectation_group& group = dynamic_cast<const expectation_group&>(thing);
939	group_match matching(group, min, max);
940	matching.dump(group, indent);
941	}
942
943	// factories
944	static group_matcher all() { return group_matcher(-1, -1); }
945	static group_matcher none() { return group_matcher(0, 0); }
946	static group_matcher atleast(int min_) { return group_matcher(min_, -1); }
947	static group_matcher atmost(int max_) { return group_matcher(0, max_); }
948	static group_matcher exactly(int amount) { return group_matcher(amount, amount); }
949
950	// match_expectation factories
951	match_expectation of(const expectation& e) const {
952	return match_expectation(expectation_group(e), *this);
953	}
954	match_expectation of(const expectation& e1, const expectation& e2) const {
955	return match_expectation(expectation_group(e1, e2), *this);
956	}
957	match_expectation of(const expectation& e1, const expectation& e2, const expectation& e3) const {
958	return match_expectation(expectation_group(e1, e2).add(e3), *this);
959	}
960	match_expectation of(const expectation& e1, const expectation& e2, const expectation& e3, const expectation& e4) const {
961	return match_expectation(expectation_group(e1, e2).add(e3).add(e4), *this);
962	}
963
964	match_expectation ofgroup(const expectation_group& group) {
965	return match_expectation(group, *this);
966	}
967
968	void dump_brief_description(const matchable& thing) const OVERRIDE {
969	if (max == -1) {
970	if (min == -1) {
971	print("all");
972	}
973	else {
974	fprintf(stderr, "atleast(%i)", min);
975	}
976	}
977	else if (max == 0) {
978	print("none");
979	}
980	else if (min == max) {
981	fprintf(stderr, "exactly(%i)", min);
982	}
983	else {
984	fprintf(stderr, "[%i-%i]", min, max);
985	}
986
987	print('.');
988
989	const expectation_group& group = dynamic_cast<const expectation_group&>(thing);
990	group.dump_brief_description();
991	}
992	};
993
994	// --------------------------
995	// helper functions
996
997
998	template <typename T> const matchable_value<T> CREATE_matchable(const copy<T>& val, const char *code) { return matchable_value<T>(val, code); }
999
1000	inline group_matcher all() { return group_matcher::all(); }
1001	inline group_matcher none() { return group_matcher::none(); }
1002	inline group_matcher atleast(int min) { return group_matcher::atleast(min); }
1003	inline group_matcher atmost(int max) { return group_matcher::atmost(max); }
1004	inline group_matcher exactly(int amount) { return group_matcher::exactly(amount); }
1005
1006	inline match_expectation wrong(const expectation& e) { return none().of(e); }
1007	};
1008
1009	// --------------------------------------------------------------------------------
1010
1011	#define MATCHABLE_ARGS_UNTYPED(val) val, #val
1012	#define MATCHABLE_ARGS_TYPED(val) make_copy(val), #val
1013
1014	#define is_equal_to(val) equals_expectation(true, MATCHABLE_ARGS_UNTYPED(val))
1015	#define does_differ_from(val) equals_expectation(false, MATCHABLE_ARGS_UNTYPED(val))
1016
1017	#define is_equal_to_NULL() null_expectation(true)
1018	#define does_differ_from_NULL() null_expectation(false)
1019
1020	#define is_less_than(val) lessThan_expectation(true, MATCHABLE_ARGS_UNTYPED(val))
1021	#define is_more_than(val) moreThan_expectation(true, MATCHABLE_ARGS_UNTYPED(val))
1022
1023	#define is_less_or_equal(val) moreThan_expectation(false, MATCHABLE_ARGS_UNTYPED(val))
1024	#define is_more_or_equal(val) lessThan_expectation(false, MATCHABLE_ARGS_UNTYPED(val))
1025
1026	#define fulfills(pred,arg) predicate_expectation(true, MATCHABLE_ARGS_UNTYPED(pred), MATCHABLE_ARGS_UNTYPED(arg))
1027	#define contradicts(pred,arg) predicate_expectation(false, MATCHABLE_ARGS_UNTYPED(pred), MATCHABLE_ARGS_UNTYPED(arg))
1028
1029	#define does_contain(val) fulfills(containing(),val)
1030	#define doesnt_contain(val) contradicts(containing(),val)
1031
1032	#define that(thing) CREATE_matchable(MATCHABLE_ARGS_TYPED(thing))
1033	// Warning: make sure you use 'that(xxx)' only once per macro!
1034	// (otherwise unwanted double evaluation takes place; see TEST_EXPECT_EQUAL__BROKEN for howto avoid it)
1035
1036
1037	#define TEST_EXPECTATION(EXPCTN) do { using namespace arb_test; asserter(EXPCTN, #EXPCTN, __FILE__, __LINE__).expect_that(); } while(0)
1038	#define TEST_EXPECTATION__BROKEN_SIMPLE(EXPCTN) do { using namespace arb_test; asserter(EXPCTN, #EXPCTN, __FILE__, __LINE__).expect_broken(); } while(0)
1039	#define TEST_EXPECTATION__BROKEN_AT_LOC(WANTED,GOT,FILE,LINE) do { using namespace arb_test; asserter(WANTED, #WANTED, FILE, LINE).expect_broken(); asserter(GOT, #GOT, FILE, LINE).expect_that(); } while(0)
1040	#define TEST_EXPECTATION__BROKEN(WANTED,GOT) TEST_EXPECTATION__BROKEN_AT_LOC(WANTED, GOT, __FILE__, __LINE__)
1041	#define TEST_EXPECTATION__WANTED(EXPCTN) do { using namespace arb_test; asserter(EXPCTN, #EXPCTN, __FILE__, __LINE__).expect_wanted_behavior(); } while(0)
1042
1043	#define TEST_EXPECTATION__BROKENIF(COND,EXPCTN) do { using namespace arb_test; asserter(EXPCTN, #EXPCTN, __FILE__, __LINE__).expect_brokenif(COND,#COND); } while(0)
1044
1045	#define DEBUG_TEST_EXPECTATION(EXPCTN) do { \
1046	using namespace arb_test; \
1047	debug_asserter(EXPCTN, #EXPCTN, __FILE__, __LINE__). \
1048	debug_expectations(); \
1049	debug_asserter(wrong(EXPCTN), "wrong(" #EXPCTN ")", __FILE__, __LINE__). \
1050	debug_expectations(); \
1051	} while(0)
1052
1053	// --------------------------------------------------------------------------------
1054
1055	#define HERE arb_test::locinfo(__FILE__, __LINE__)
1056
1057	#define TEST_WARNING(format,strarg) HERE.warningf(format, (strarg))
1058	#define TEST_WARNING2(format,strarg1,strarg2) HERE.warningf(format, (strarg1), (strarg2))
1059	#define TEST_ERROR(format,strarg) HERE.errorf(true, format, (strarg))
1060	#define TEST_ERROR2(format,strarg1,strarg2) HERE.errorf(true, format, (strarg1), (strarg2))
1061	#define TEST_IOERROR(format,strarg) HERE.ioerrorf(true, format, (strarg))
1062
1063	// --------------------------------------------------------------------------------
1064
1065	#define TEST_FAILS_INSIDE_VALGRIND(THETEST) do { \
1066	if (!GBK_running_on_valgrind()) { \
1067	THETEST; \
1068	TEST_WARNING("valgrind fails for '%s'", #THETEST); \
1069	} \
1070	} while(0)
1071
1072	// --------------------------------------------------------------------------------
1073
1074	#define TEST_EXPECT_ZERO(cond) TEST_EXPECT_EQUAL(cond, 0)
1075	#define TEST_EXPECT_ZERO__BROKEN(cond,got) TEST_EXPECT_EQUAL__BROKEN(cond, 0, got)
1076	#define TEST_REJECT_ZERO(cond) TEST_EXPECTATION(that(cond).does_differ_from(0))
1077	#define TEST_REJECT_ZERO__BROKEN(cond) TEST_EXPECTATION__BROKEN_SIMPLE(that(cond).does_differ_from(0))
1078
1079	#define TEST_EXPECT_ZERO_OR_SHOW_ERRNO(iocond) \
1080	do { \
1081	if ((iocond)) \
1082	TEST_IOERROR("I/O-failure in '%s'", #iocond); \
1083	} while(0)
1084
1085	// --------------------------------------------------------------------------------
1086
1087	#define MISSING_TEST(description) \
1088	TEST_WARNING("Missing test '%s'", #description)
1089
1090	// --------------------------------------------------------------------------------
1091
1092	namespace arb_test {
1093	inline match_expectation reports_error(const char *error) { return that(error).does_differ_from_NULL(); }
1094	inline match_expectation doesnt_report_error(const char *error) { return that(error).is_equal_to_NULL(); }
1095	inline match_expectation reported_error_contains(const char error, const char part) { return error ? that(error).does_contain(part) : that(error).does_differ_from_NULL(); }
1096	#if defined(TESTS_KNOW_ARB_ERROR)
1097	inline match_expectation reports_error(ARB_ERROR error) { return reports_error(error.deliver()); }
1098	inline match_expectation doesnt_report_error(ARB_ERROR error) { return doesnt_report_error(error.deliver()); }
1099	inline match_expectation reported_error_contains(ARB_ERROR error, const char *part) { return reported_error_contains(error.deliver(), part); }
1100	#endif
1101	};
1102
1103	#define TEST_EXPECT_ERROR_CONTAINS(call,part) TEST_EXPECTATION (reported_error_contains(call, part))
1104	#define TEST_EXPECT_ERROR_CONTAINS__BROKEN(call,part) TEST_EXPECTATION__BROKEN_SIMPLE(reported_error_contains(call, part))
1105	#define TEST_EXPECT_ANY_ERROR(call) TEST_EXPECTATION (reports_error(call))
1106	#define TEST_EXPECT_ANY_ERROR__BROKEN(call) TEST_EXPECTATION__BROKEN_SIMPLE(reports_error(call))
1107	#define TEST_EXPECT_NO_ERROR(call) TEST_EXPECTATION (doesnt_report_error(call))
1108	#define TEST_EXPECT_NO_ERROR__BROKEN(call) TEST_EXPECTATION__BROKEN_SIMPLE(doesnt_report_error(call))
1109
1110	// --------------------------------------------------------------------------------
1111
1112	#ifdef ARB_MSG_H
1113
1114	namespace arb_test {
1115	inline match_expectation no_forgotten_error_exported() { return that(GB_incur_error()).is_equal_to_NULL(); }
1116
1117	class calling {
1118	bool result;
1119	GB_ERROR error;
1120	public:
1121	calling(bool call)
1122	: result(call),
1123	error(GB_incur_error())
1124	{}
1125
1126	// functions below try to make failing expectations more readable
1127	match_expectation returns_result() const { return that(result).is_equal_to(true); }
1128	match_expectation doesnt_return_result() const { return that(result).is_equal_to(false); }
1129	match_expectation exports_error() const { return that(error).does_differ_from_NULL(); }
1130	match_expectation doesnt_export_error() const { return that(error).is_equal_to_NULL(); }
1131	match_expectation exports_error_containing(const char *expected_part) const {
1132	return error ? that(error).does_contain(expected_part) : exports_error();
1133	}
1134
1135	match_expectation either_result_or_error() const { return exactly(1).of(returns_result(), exports_error()); }
1136
1137	match_expectation does_neither_return_result_nor_export_error() const {
1138	return all().of(doesnt_return_result(),
1139	doesnt_export_error());
1140	}
1141	match_expectation returns_result_and_doesnt_export_error() const {
1142	return all().of(either_result_or_error(),
1143	returns_result(),
1144	doesnt_export_error());
1145	}
1146	match_expectation doesnt_return_result_but_exports_error_containing(const char *expected_part) const {
1147	return all().of(either_result_or_error(),
1148	doesnt_return_result(),
1149	exports_error_containing(expected_part));
1150	}
1151	};
1152	};
1153
1154	#define TEST_EXPECT_ERROR_CLEAR() TEST_EXPECTATION(no_forgotten_error_exported())
1155
1156	#define TEST_EXPECT_RESULT__NOERROREXPORTED(create_result) do { TEST_EXPECT_ERROR_CLEAR(); TEST_EXPECTATION (calling((create_result)).returns_result_and_doesnt_export_error()); } while(0)
1157	#define TEST_EXPECT_RESULT__NOERROREXPORTED__BROKEN(create_result) do { TEST_EXPECT_ERROR_CLEAR(); TEST_EXPECTATION__BROKEN_SIMPLE(calling((create_result)).returns_result_and_doesnt_export_error()); } while(0)
1158	#define TEST_EXPECT_NORESULT__ERROREXPORTED_CONTAINS(create_result,expected_part) do { TEST_EXPECT_ERROR_CLEAR(); TEST_EXPECTATION (calling((create_result)).doesnt_return_result_but_exports_error_containing(expected_part)); } while(0)
1159	#define TEST_EXPECT_NORESULT__ERROREXPORTED_CONTAINS__BROKEN(create_result,expected_part) do { TEST_EXPECT_ERROR_CLEAR(); TEST_EXPECTATION__BROKEN_SIMPLE(calling((create_result)).doesnt_return_result_but_exports_error_containing(expected_part)); } while(0)
1160	#define TEST_EXPECT_NORESULT__NOERROREXPORTED(create_result) do { TEST_EXPECT_ERROR_CLEAR(); TEST_EXPECTATION (calling((create_result)).does_neither_return_result_nor_export_error()); } while(0)
1161	#define TEST_EXPECT_NORESULT__NOERROREXPORTED__BROKEN(create_result) do { TEST_EXPECT_ERROR_CLEAR(); TEST_EXPECTATION__BROKEN_SIMPLE(calling((create_result)).does_neither_return_result_nor_export_error()); } while(0)
1162
1163	#define TEST_EXPECT_EQUAL_STRINGCOPY__NOERROREXPORTED(create_strcopy,expected_result) do { \
1164	char *result; \
1165	TEST_EXPECT_RESULT__NOERROREXPORTED(result = create_strcopy); \
1166	TEST_EXPECT_EQUAL(result, expected_result); \
1167	free(result); \
1168	} while(0)
1169
1170	#define TEST_EXPECT_EQUAL_STRINGCOPY__NOERROREXPORTED__BROKEN(create_strcopy,wanted,got) do { \
1171	char *result; \
1172	TEST_EXPECT_RESULT__NOERROREXPORTED(result = create_strcopy); \
1173	TEST_EXPECT_EQUAL__BROKEN(result, wanted, got); \
1174	free(result); \
1175	} while(0)
1176
1177	#endif
1178	// --------------------------------------------------------------------------------
1179	// TEST_EXPECT_SEGFAULT and TEST_EXPECT_CODE_ASSERTION_FAILS
1180	// only work if binary is linked with ARBDB
1181
1182	#ifdef ENABLE_CRASH_TESTS
1183	# ifdef ARB_CORE_H
1184
1185	const bool DOES_SEGFAULT = true;
1186	const bool DOESNT_SEGFAULT = false;
1187	const bool CALL_WILL_SEGFAULT = true;
1188	const bool CALL_WONT_SEGFAULT = false;
1189	const bool FAILS_ASSERTION = true;
1190	const bool FULFILLS_ASSERTIONS = false;
1191
1192	# ifdef ASSERTION_USED
1193	inline arb_test::match_expectation expect_callback(void (*cb)(), bool expect_SEGV, bool expect_assert_fail, bool call_would_SEGV) {
1194	using namespace arb_test;
1195
1196	bool& assertion_failed = test_data().assertion_failed;
1197	bool old_state = assertion_failed;
1198
1199	expectation_group expected;
1200	if (call_would_SEGV && GBK_running_on_valgrind()) {
1201	// don't provoke a SEGV when valgrinding
1202	expected.add(that(call_would_SEGV).is_equal_to(expect_SEGV));
1203	}
1204	else {
1205	expected.add(that(GBK_raises_SIGSEGV(cb)).is_equal_to(expect_SEGV));
1206	expected.add(that(assertion_failed).is_equal_to(expect_assert_fail));
1207	}
1208
1209	assertion_failed = old_state;
1210	return all().ofgroup(expected);
1211	}
1212	# else
1213	inline arb_test::match_expectation expect_callback(void (*cb)(), bool expect_SEGV, bool call_would_SEGV) {
1214	using namespace arb_test;
1215	if (call_would_SEGV && GBK_running_on_valgrind()) {
1216	// don't provoke a SEGV when valgrinding
1217	return that(call_would_SEGV).is_equal_to(expect_SEGV);
1218	}
1219	return that(GBK_raises_SIGSEGV(cb)).is_equal_to(expect_SEGV);
1220	}
1221	# endif
1222	# endif
1223
1224	// Note: Please toggle all permutations of
1225	// * ../ARBDB/adstring.cxx@TEST_TEST_MACROS
1226	// * Makefile.local.setup@VALGRIND
1227	// * and DEBUG/NDEBUG mode in ../config.makefile@DEBUG
1228	// and run tests in adstring.cxx whenever you change the macros below!
1229	//
1230	// Note for callers:
1231	//
1232	// These tests will normally not fail under valgrind. If CALL_WILL_SEGFAULT,
1233	// then the 'cb' will not be called (to avoid valgrind fails).
1234	// Should be no problem, because normally valgrinded unittests run
1235	// ADDITIONALLY to not-valgrinded unittests (where tests WILL fail in case).
1236
1237	# ifdef ASSERTION_USED
1238
1239	# define TEST_EXPECT_NO_SEGFAULT(cb) TEST_EXPECTATION(expect_callback(cb, DOESNT_SEGFAULT, FULFILLS_ASSERTIONS, CALL_WONT_SEGFAULT))
1240	# define TEST_EXPECT_NO_SEGFAULT__WANTED(cb) TEST_EXPECTATION__WANTED(expect_callback(cb, DOESNT_SEGFAULT, FULFILLS_ASSERTIONS, CALL_WILL_SEGFAULT))
1241	# define TEST_EXPECT_CODE_ASSERTION_FAILS(cb) TEST_EXPECTATION(expect_callback(cb, DOES_SEGFAULT, FAILS_ASSERTION, CALL_WILL_SEGFAULT))
1242	# define TEST_EXPECT_CODE_ASSERTION_FAILS__WANTED(cb) TEST_EXPECTATION__WANTED(expect_callback(cb, DOES_SEGFAULT, FAILS_ASSERTION, CALL_WONT_SEGFAULT))
1243	# define TEST_EXPECT_CODE_ASSERTION_FAILS__UNWANTED(cb) TEST_EXPECT_NO_SEGFAULT__WANTED(cb)
1244	# define TEST_EXPECT_SEGFAULT(cb) TEST_EXPECTATION(expect_callback(cb, DOES_SEGFAULT, FULFILLS_ASSERTIONS, CALL_WILL_SEGFAULT))
1245	# define TEST_EXPECT_SEGFAULT__WANTED(cb) TEST_EXPECTATION__WANTED(expect_callback(cb, DOES_SEGFAULT, FULFILLS_ASSERTIONS, CALL_WONT_SEGFAULT))
1246	# define TEST_EXPECT_SEGFAULT__UNWANTED(cb) TEST_EXPECT_NO_SEGFAULT__WANTED(cb)
1247
1248	# else // ENABLE_CRASH_TESTS but no ASSERTION_USED (test segfaults in NDEBUG mode)
1249
1250	# define TEST_EXPECT_NO_SEGFAULT(cb) TEST_EXPECTATION(expect_callback(cb, DOESNT_SEGFAULT, CALL_WONT_SEGFAULT))
1251	# define TEST_EXPECT_NO_SEGFAULT__WANTED(cb) TEST_EXPECTATION__WANTED(expect_callback(cb, DOESNT_SEGFAULT, CALL_WILL_SEGFAULT))
1252	# define TEST_EXPECT_CODE_ASSERTION_FAILS(cb)
1253	# define TEST_EXPECT_CODE_ASSERTION_FAILS__WANTED(cb)
1254	# define TEST_EXPECT_CODE_ASSERTION_FAILS__UNWANTED(cb)
1255	# define TEST_EXPECT_SEGFAULT(cb) TEST_EXPECTATION(expect_callback(cb, DOES_SEGFAULT, CALL_WILL_SEGFAULT))
1256	# define TEST_EXPECT_SEGFAULT__WANTED(cb) TEST_EXPECTATION__WANTED(expect_callback(cb, DOES_SEGFAULT, CALL_WONT_SEGFAULT))
1257	# define TEST_EXPECT_SEGFAULT__UNWANTED(cb) TEST_EXPECT_NO_SEGFAULT__WANTED(cb)
1258
1259	# endif
1260
1261	#else // not ENABLE_CRASH_TESTS (i.e. skip these tests completely)
1262
1263	# define TEST_EXPECT_NO_SEGFAULT(cb)
1264	# define TEST_EXPECT_NO_SEGFAULT__WANTED(cb)
1265	# define TEST_EXPECT_CODE_ASSERTION_FAILS(cb)
1266	# define TEST_EXPECT_CODE_ASSERTION_FAILS__WANTED(cb)
1267	# define TEST_EXPECT_CODE_ASSERTION_FAILS__UNWANTED(cb)
1268	# define TEST_EXPECT_SEGFAULT(cb)
1269	# define TEST_EXPECT_SEGFAULT__WANTED(cb)
1270	# define TEST_EXPECT_SEGFAULT__UNWANTED(cb)
1271
1272	#endif
1273
1274	// --------------------------------------------------------------------------------
1275
1276	namespace arb_test {
1277	template <typename T, typename U, typename V>
1278	inline void expect_broken(const arb_test::matchable_value<T>& That, const U& want, const V& got, const char *file, int line) {
1279	TEST_EXPECTATION__BROKEN_AT_LOC(That.is_equal_to(want), That.is_equal_to(got), file, line);
1280	}
1281	};
1282
1283	#define TEST_EXPECT_EQUAL(expr,want) TEST_EXPECTATION(that(expr).is_equal_to(want))
1284	#define TEST_EXPECT_EQUAL__BROKEN(expr,want,got) do{ using namespace arb_test; expect_broken(that(expr), want, got, __FILE__, __LINE__); }while(0)
1285	#define TEST_EXPECT_EQUAL__IGNARG(expr,want,ign) TEST_EXPECTATION(that(expr).is_equal_to(want))
1286
1287	#define TEST_EXPECT_SIMILAR(expr,want,epsilon) TEST_EXPECTATION(that(expr).fulfills(epsilon_similar(epsilon), want))
1288	#define TEST_EXPECT_SIMILAR__BROKEN(expr,want,epsilon) TEST_EXPECTATION__BROKEN_SIMPLE(that(expr).fulfills(epsilon_similar(epsilon), want))
1289
1290	#define TEST_EXPECT_DIFFERENT(expr,want) TEST_EXPECTATION(that(expr).does_differ_from(want));
1291	#define TEST_EXPECT_DIFFERENT__BROKEN(expr,want) TEST_EXPECTATION__BROKEN_SIMPLE(that(expr).does_differ_from(want));
1292
1293	#define TEST_EXPECT_LESS(val,ref) TEST_EXPECTATION(that(val).is_less_than(ref))
1294	#define TEST_EXPECT_MORE(val,ref) TEST_EXPECTATION(that(val).is_more_than(ref))
1295	#define TEST_EXPECT_LESS_EQUAL(val,ref) TEST_EXPECTATION(that(val).is_less_or_equal(ref))
1296	#define TEST_EXPECT_MORE_EQUAL(val,ref) TEST_EXPECTATION(that(val).is_more_or_equal(ref))
1297
1298	#define TEST_EXPECT_IN_RANGE(val,lower,higher) TEST_EXPECTATION(all().of(that(val).is_more_or_equal(lower), that(val).is_less_or_equal(higher)))
1299	#define TEST_EXPECT_IN_RANGE__BROKEN(val,lower,higher) TEST_EXPECTATION__BROKEN_SIMPLE(all().of(that(val).is_more_or_equal(lower), that(val).is_less_or_equal(higher)))
1300
1301	#define TEST_EXPECT_CONTAINS(str,part) TEST_EXPECTATION(that(str).does_contain(part))
1302	#define TEST_EXPECT_CONTAINS__BROKEN(str,part) TEST_EXPECTATION__BROKEN_SIMPLE(that(str).does_contain(part))
1303
1304	#define TEST_EXPECT_DOESNT_CONTAIN(str,part) TEST_EXPECTATION(that(str).doesnt_contain(part))
1305	#define TEST_EXPECT_DOESNT_CONTAIN__BROKEN(str,part) TEST_EXPECTATION__BROKEN_SIMPLE(that(str).doesnt_contain(part))
1306
1307	#define TEST_EXPECT_NULL(n) TEST_EXPECT_EQUAL(n, (typeof(n))NULp)
1308	#define TEST_EXPECT_NULL__BROKEN(n,got) TEST_EXPECT_EQUAL__BROKEN(n, (typeof(n))NULp, got)
1309	#define TEST_EXPECT_NULL__BROKEN_SIMPLE(n) TEST_EXPECTATION__BROKEN_SIMPLE(that(n).is_equal_to((typeof(n))NULp))
1310	#define TEST_REJECT_NULL(n) TEST_EXPECT_DIFFERENT(n, (typeof(n))NULp)
1311	#define TEST_REJECT_NULL__BROKEN(n) TEST_EXPECT_DIFFERENT__BROKEN(n, (typeof(n))NULp)
1312
1313	#define TEST_EXPECT(cond) TEST_EXPECTATION(that(cond).is_equal_to(true))
1314	#define TEST_EXPECT__BROKEN(cond) TEST_EXPECTATION__BROKEN_SIMPLE(that(cond).is_equal_to(true))
1315	#define TEST_REJECT(cond) TEST_EXPECTATION(that(cond).is_equal_to(false))
1316	#define TEST_REJECT__BROKEN(cond) TEST_EXPECTATION__BROKEN_SIMPLE(that(cond).is_equal_to(false))
1317
1318	// test class Validity:
1319	#define TEST_VALIDITY(valid) TEST_EXPECT_NULL((valid).why_not())
1320	#define TEST_VALIDITY__BROKEN(valid,why) TEST_EXPECT_NULL__BROKEN((valid).why_not(),why)
1321
1322	// --------------------------------------------------------------------------------
1323	// the following macros only work when
1324	// - tested module depends on ARBDB and
1325	// - some ARBDB header has been included
1326	// Otherwise the section is skipped completely.
1327	//
1328	// @@@ ARBDB->ARBCORE later
1329
1330	#ifdef ARB_DIFF_H
1331
1332	namespace arb_test {
1333	inline bool memory_is_equal(const void mem1, const void mem2, size_t size) {
1334	FlushedOutputNoLF yes;
1335	return ARB_test_mem_equal(reinterpret_cast<const unsigned char *>(mem1),
1336	reinterpret_cast<const unsigned char *>(mem2), size, 0) == size;
1337	}
1338	inline bool files_are_equal(const char file1, const char file2) {
1339	FlushedOutputNoLF yes;
1340	return ARB_files_are_equal(file1, file2);
1341	}
1342	inline bool files_differ(const char file1, const char file2) {
1343	FlushedOutputNoLF yes;
1344	return ARB_files_differ(file1, file2);
1345	}
1346	inline bool textfiles_have_difflines(const char fgot, const char fwant, int expected_difflines) {
1347	FlushedOutputNoLF yes;
1348	return ARB_textfiles_have_difflines(fwant, fgot, expected_difflines, TDM_DIFF_LINECOUNT);
1349	}
1350	inline bool textfiles_dont_have_difflines(const char fgot, const char fwant, int unexpected_difflines) {
1351	FlushedOutputNoLF yes;
1352	return ARB_textfiles_have_difflines(fwant, fgot, unexpected_difflines, TDM_NOT_DIFF_LINECOUNT);
1353	}
1354	inline bool textfiles_have_difflines_ignoreDates(const char fgot, const char fwant, int expected_difflines) {
1355	FlushedOutputNoLF yes;
1356	return ARB_textfiles_have_difflines(fwant, fgot, expected_difflines, TDM_IGNORE_TIMESTAMPS);
1357	}
1358	};
1359
1360	#define TEST_COPY_FILE(src, dst) TEST_EXPECT_NO_ERROR(GB_copy_file(src, dst))
1361	#define TEST_DUMP_FILE(src, dst) TEST_EXPECT(system(GBS_global_string("hexdump -C '%s' > '%s'", src, dst)) == 0)
1362
1363	// Note: parameter order convention for the following calls is: 'createdresultfile, expectedresultfile, ...'
1364
1365	#define TEST_EXPECT_TEXTFILE_DIFFLINES(fgot,fwant,diff) TEST_EXPECT(arb_test::textfiles_have_difflines(fgot,fwant, diff))
1366	#define TEST_EXPECT_TEXTFILE_DIFFLINES__BROKEN(fgot,fwant,diff) TEST_EXPECT__BROKEN(arb_test::textfiles_have_difflines(fgot,fwant, diff))
1367
1368	#define TEST_EXPECT_TEXTFILE_DIFFLINES_IGNORE_DATES(fgot,fwant,diff) TEST_EXPECT(arb_test::textfiles_have_difflines_ignoreDates(fgot,fwant, diff))
1369	#define TEST_EXPECT_TEXTFILE_DIFFLINES_IGNORE_DATES__BROKEN(fgot,fwant,diff) TEST_EXPECT__BROKEN(arb_test::textfiles_have_difflines_ignoreDates(fgot,fwant, diff))
1370
1371	#define TEST_EXPECT_FILES_EQUAL(f1,f2) TEST_EXPECT(arb_test::files_are_equal(f1,f2))
1372	#define TEST_EXPECT_FILES_EQUAL__BROKEN(f1,f2) TEST_EXPECT__BROKEN(arb_test::files_are_equal(f1,f2))
1373	#define TEST_EXPECT_TEXTFILES_EQUAL(fgot,fwant) TEST_EXPECT_TEXTFILE_DIFFLINES(fgot,fwant,0)
1374	#define TEST_EXPECT_TEXTFILES_EQUAL__BROKEN(fgot,fwant) TEST_EXPECT_TEXTFILE_DIFFLINES__BROKEN(fgot,fwant,0)
1375
1376	#define TEST_EXPECT_FILES_DIFFER(f1,f2) TEST_EXPECT(arb_test::files_differ(f1,f2))
1377	#define TEST_EXPECT_FILES_DIFFER__BROKEN(f1,f2) TEST_EXPECT__BROKEN(arb_test::files_differ(f1,f2))
1378	#define TEST_EXPECT_TEXTFILES_DIFFER(fgot,fwant) TEST_EXPECT(arb_test::textfiles_dont_have_difflines(fgot,fwant,0))
1379	#define TEST_EXPECT_TEXTFILES_DIFFER__BROKEN(fgot,fwant) TEST_EXPECT__BROKEN(arb_test::textfiles_dont_have_difflines(fgot,fwant,0))
1380
1381	#define TEST_EXPECT_MEM_EQUAL(m1,m2,size) TEST_EXPECT(arb_test::memory_is_equal(m1,m2,size))
1382	#define TEST_EXPECT_MEM_EQUAL__BROKEN(m1,m2,size) TEST_EXPECT__BROKEN(arb_test::memory_is_equal(m1,m2,size))
1383
1384	#else
1385
1386	#define WARN_MISS_ARBDIFF() need_include__arb_diff_h__BEFORE__test_unit_h
1387
1388	#define TEST_EXPECT_TEXTFILE_DIFFLINES(fgot,fwant,diff) WARN_MISS_ARBDIFF()
1389	#define TEST_EXPECT_TEXTFILE_DIFFLINES__BROKEN(fgot,fwant,diff) WARN_MISS_ARBDIFF()
1390
1391	#define TEST_EXPECT_TEXTFILE_DIFFLINES_IGNORE_DATES(fgot,fwant,diff) WARN_MISS_ARBDIFF()
1392	#define TEST_EXPECT_TEXTFILE_DIFFLINES_IGNORE_DATES__BROKEN(fgot,fwant,diff) WARN_MISS_ARBDIFF()
1393
1394	#define TEST_EXPECT_FILES_EQUAL(f1,f2) WARN_MISS_ARBDIFF()
1395	#define TEST_EXPECT_FILES_EQUAL__BROKEN(f1,f2) WARN_MISS_ARBDIFF()
1396	#define TEST_EXPECT_TEXTFILES_EQUAL(fgot,fwant) WARN_MISS_ARBDIFF()
1397	#define TEST_EXPECT_TEXTFILES_EQUAL__BROKEN(fgot,fwant) WARN_MISS_ARBDIFF()
1398
1399	#define TEST_EXPECT_FILES_DIFFER(f1,f2) WARN_MISS_ARBDIFF()
1400	#define TEST_EXPECT_FILES_DIFFER__BROKEN(f1,f2) WARN_MISS_ARBDIFF()
1401	#define TEST_EXPECT_TEXTFILES_DIFFER(fgot,fwant) WARN_MISS_ARBDIFF()
1402	#define TEST_EXPECT_TEXTFILES_DIFFER__BROKEN(fgot,fwant) WARN_MISS_ARBDIFF()
1403
1404	#define TEST_EXPECT_MEM_EQUAL(m1,m2,size) WARN_MISS_ARBDIFF()
1405	#define TEST_EXPECT_MEM_EQUAL__BROKEN(m1,m2,size) WARN_MISS_ARBDIFF()
1406
1407	#define memory_is_equal(m1,m2,size) WARN_MISS_ARBDIFF()
1408	#define files_are_equal(f1,f2) WARN_MISS_ARBDIFF()
1409	#define textfiles_have_difflines(f1,f2,ed) WARN_MISS_ARBDIFF()
1410	#define textfiles_have_difflines_ignoreDates(f1,f2,ed) WARN_MISS_ARBDIFF()
1411
1412	#endif // ARB_DIFF_H
1413
1414	// --------------------------------------------------------------------------------
1415
1416	#ifdef TREENODE_H
1417
1418	namespace arb_test {
1419	inline match_expectation expect_newick_equals(NewickFormat format, const TreeNode tree, const char expected_newick) {
1420	char *newick = GBT_tree_2_newick(tree, format, false);
1421	match_expectation expected = that(newick).is_equal_to(expected_newick);
1422	free(newick);
1423	return expected;
1424	}
1425	inline match_expectation saved_newick_equals(NewickFormat format, GBDATA gb_main, const char treename, const char *expected_newick) {
1426	expectation_group expected;
1427	GB_transaction ta(gb_main);
1428	TreeNode *tree = GBT_read_tree(gb_main, treename, new SimpleRoot);
1429
1430	expected.add(that(tree).does_differ_from_NULL());
1431	if (tree) {
1432	expected.add(expect_newick_equals(format, tree, expected_newick));
1433	destroy(tree);
1434	}
1435	return all().ofgroup(expected);
1436	}
1437	};
1438
1439	#define TEST_EXPECT_NEWICK(format,tree,expected_newick) TEST_EXPECTATION(arb_test::expect_newick_equals(format, tree, expected_newick))
1440	#define TEST_EXPECT_NEWICK__BROKEN(format,tree,expected_newick) TEST_EXPECTATION__BROKEN_SIMPLE(arb_test::expect_newick_equals(format, tree, expected_newick))
1441
1442	#define TEST_EXPECT_SAVED_NEWICK(format,gb_main,treename,expected_newick) TEST_EXPECTATION(arb_test::saved_newick_equals(format, gb_main, treename, expected_newick))
1443	#define TEST_EXPECT_SAVED_NEWICK__BROKEN(format,gb_main,treename,expected_newick) TEST_EXPECTATION__BROKEN_SIMPLE(arb_test::saved_newick_equals(format, gb_main, treename, expected_newick))
1444
1445	#else
1446
1447	#define WARN_MISS_ADTREE() need_include__TreeNode_h__BEFORE__test_unit_h
1448
1449	#define TEST_EXPECT_NEWICK(format,tree,expected_newick) WARN_MISS_ADTREE()
1450	#define TEST_EXPECT_NEWICK__BROKEN(format,tree,expected_newick) WARN_MISS_ADTREE()
1451
1452	#define TEST_EXPECT_SAVED_NEWICK(format,gb_main,treename,expected_newick) WARN_MISS_ADTREE()
1453	#define TEST_EXPECT_SAVED_NEWICK__BROKEN(format,gb_main,treename,expected_newick) WARN_MISS_ADTREE()
1454
1455	#endif
1456
1457	// --------------------------------------------------------------------------------
1458
1459	#define TEST_SETUP_GLOBAL_ENVIRONMENT(modulename) do { \
1460	arb_test::test_data().raiseLocalFlag(ANY_SETUP); \
1461	TEST_EXPECT_NO_ERROR(GBK_system(GBS_global_string("../test_environment setup %s", (modulename)))); \
1462	} while(0)
1463	// cleanup is done (by Makefile.suite) after all unit tests have been run
1464
1465	// --------------------------------------------------------------------------------
1466	// Some functions do not export information about their source location (esp. when
1467	// stabs-format is used).
1468	// If that happens the test will fail and print 'INVALID' as result.
1469	//
1470	// Fix that problem by writing
1471	// TEST_PUBLISH(TEST_something)
1472	// just behind the function TEST_something.
1473	//
1474	// If it cannot be fixed by that use
1475	//
1476	// void TEST_something(); // prototype
1477	// TEST_PUBLISH(TEST_something);
1478	// TEST_something() {
1479	// ...
1480	// }
1481
1482	#if defined(DEBUG)
1483	#define TEST_PUBLISH(testfunction) void publish##testfunction() { testfunction(); }
1484	#else // NDEBUG
1485	#define TEST_PUBLISH(testfunction)
1486	#endif
1487
1488	// --------------------------------------------------------------------------------
1489
1490	#else
1491	#error test_unit.h included twice
1492	#endif // TEST_UNIT_H

Note: See TracBrowser for help on using the repository browser.

Download in other formats: