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