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  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 {
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 
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 {
419  virtual ~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 
512  fprintf(stderr, "-------------------- [Debugging expectations for '%s']\n", get_code());
513  expect_that();
514  expect_broken();
516  }
517  };
518 
519  // ----------------------------------------
520  // matchable + matcher (abstract)
521 
522  struct matchable {
523  virtual ~matchable() {}
525 
526  virtual const char *name() const = 0;
527  virtual const char *readable_value() const = 0;
528  };
529 
530  struct matcher {
531  virtual ~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 {
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  {}
552  : thing(other.thing->clone()),
553  condition(other.condition->clone())
554  {}
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 
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) {}
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 {
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 {
696  matchable_value<T> expected;
697  public:
698  value_matcher(const matchable_value<T>& expected_) : expected(expected_) {}
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);
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  {}
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 {
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  }
795  for (int i = 0; i<count; ++i) {
796  delete depend_on[i];
797  }
798  }
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);
844  printed = true;
845  }
846  print(')');
847  }
848  };
849 
850  struct group_match {
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("'");
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 {
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 
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),
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
static void is(int a)
Definition: test_unit.h:869
virtual const char * name() const =0
const char * name() const OVERRIDE
Definition: test_unit.h:651
#define arb_assert(cond)
Definition: arb_assert.h:245
#define MAKE_CLONABLE(type)
Definition: test_unit.h:413
const expectation & dependent(int i) const
Definition: test_unit.h:810
const char * GB_ERROR
Definition: arb_core.h:25
string result
match_expectation reports_error(const char *error)
Definition: test_unit.h:1093
virtual ~matchable()
can be matched with corresponding matcher.
Definition: test_unit.h:523
predicate(FUNC pred_, const char *name, const char *inverse)
Definition: test_unit.h:620
group_matcher all()
Definition: test_unit.h:1000
virtual ~asserter()
Definition: test_unit.h:446
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:607
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:403
const char * name() const OVERRIDE
Definition: test_unit.h:803
void explain(int indent) const OVERRIDE
Definition: test_unit.h:564
const char * readable_value() const OVERRIDE
Definition: test_unit.h:652
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:947
MAKE_CLONABLE(predicate_matcher)
match_expectation doesnt_report_error(const char *error)
Definition: test_unit.h:1094
char * GBT_tree_2_newick(const TreeNode *tree, NewickFormat format, bool compact)
Definition: adtree.cxx:1353
char * val2hex(int i)
Definition: test_unit.h:270
~value_matcher() OVERRIDE
Definition: test_unit.h:699
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:1095
predicate_description(const char *primary_)
Definition: test_unit.h:601
virtual const char * relation(bool isMatch) const =0
copy< T > make_copy(const T &t)
Definition: test_unit.h:321
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:791
#define VCOMPILERMSG(msgtype, format)
Definition: test_unit.h:126
void expect_broken() const
Definition: test_unit.h:458
const char * get_code() const
Definition: test_unit.h:448
void dump_brief_description(const matchable &thing) const OVERRIDE
Definition: test_unit.h:729
bool exists() const
Definition: test_unit.h:116
static char static char vstrf_buf[max_vstrf_size]
Definition: test_unit.h:244
predicate< FUNC > make_predicate(FUNC func, const char *primary, const char *inverse)
Definition: test_unit.h:626
virtual ~matcher()
can match things.
Definition: test_unit.h:531
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:706
value_matcher(const matchable_value< T > &expected_)
Definition: test_unit.h:698
char(& yes)[1]
Definition: downcast.h:30
int count_fulfilled() const
Definition: test_unit.h:812
expectation_group(const expectation &e1, const expectation &e2)
Definition: test_unit.h:785
#define cb(action)
matchable_value(copy< T > val_, const char *nontemp_code)
Definition: test_unit.h:643
#define FINAL_OVERRIDE
Definition: cxxforward.h:95
DECLARE_ASSIGNMENT_OPERATOR(match_expectation)
virtual const char * readable_value() const =0
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:441
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:806
MAKE_CLONABLE(expectation_group)
match_expectation ofgroup(const expectation_group &group)
Definition: test_unit.h:964
void dump(const expectation_group &group, int indent) const
Definition: test_unit.h:880
match_expectation wrong(const expectation &e)
Definition: test_unit.h:1006
debug_asserter(const expectation &e, const char *code_, const char *file, int line)
Definition: test_unit.h:507
GB_ERROR deliver() const
Definition: arb_error.h:114
virtual ~expectation()
something expected. can be fulfilled or not (and can explain why/not)
Definition: test_unit.h:419
bool operator()(const double &d1, const double &d2) const
Definition: test_unit.h:370
void dump_expectation(const matchable &thing, int indent) const OVERRIDE
Definition: test_unit.h:711
predicate_description(const predicate_description &other)
Definition: test_unit.h:604
DECLARE_ASSIGNMENT_OPERATOR(predicate_description)
bool more(const copy< T > &t1, const copy< T > &t2)
Definition: test_unit.h:635
match_expectation of(const expectation &e1, const expectation &e2, const expectation &e3) const
Definition: test_unit.h:957
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:749
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:668
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:634
match_expectation of(const expectation &e) const
Definition: test_unit.h:951
fputc('\n', stderr)
bool unfulfilled() const
Definition: test_unit.h:563
virtual void dump_brief_description() const =0
expectation_group & add(const expectation &e)
Definition: test_unit.h:801
bool GBK_running_on_valgrind(void)
Definition: arb_signal.cxx:98
char * str
Definition: defines.h:20
#define that(thing)
Definition: test_unit.h:1032
predicate(FUNC pred_, const char *name)
Definition: test_unit.h:619
void expect_brokenif(bool condition, const char *condcode)
Definition: test_unit.h:484
bool exists() const
Definition: test_unit.h:142
static group_matcher exactly(int amount)
Definition: test_unit.h:948
const char * relation(bool isMatch) const OVERRIDE
Definition: test_unit.h:757
bool operator!=(const copy< T > &v1, const copy< T > &v2)
Definition: test_unit.h:338
match_expectation(const matchable &thing_, const matcher &condition_)
Definition: test_unit.h:547
NewickFormat
Definition: arbdb_base.h:68
copy(const T &t_)
Definition: test_unit.h:307
#define does_differ_from_NULL()
Definition: test_unit.h:1018
int required(int what) const
Definition: test_unit.h:857
const char * value() const
Definition: test_unit.h:118
expectation_group(const expectation_group &other)
Definition: test_unit.h:789
void expect_that() const
Definition: test_unit.h:450
void nl()
Definition: test_unit.h:404
static group_matcher none()
Definition: test_unit.h:945
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:837
str readableHex(const copy< T > &v)
Definition: test_unit.h:335
bool matches(const matchable &thing) const OVERRIDE
Definition: test_unit.h:933
char * gen_description() const
Definition: test_unit.h:649
#define is_equal_to(val)
Definition: test_unit.h:1014
void dump_brief_description(const matchable &thing) const OVERRIDE
Definition: test_unit.h:968
group_matcher none()
Definition: test_unit.h:1001
void select_spaced(bool first, const char *singular, const char *plural)
Definition: test_unit.h:409
predicate_description(const char *primary_, const char *inverse_)
Definition: test_unit.h:602
const int MAX_GROUP_SIZE
Definition: test_unit.h:772
group_match(const expectation_group &egroup, int min, int max)
Definition: test_unit.h:858
const int count
result of matching an expectation_group with a group_matcher
Definition: test_unit.h:851
void spaced(const char *word)
Definition: test_unit.h:408
fputs(TRACE_PREFIX, stderr)
void print_pair(T1 t1, T2 t2)
Definition: test_unit.h:355
#define textfiles_have_difflines(f1, f2, ed)
Definition: test_unit.h:1409
virtual void dump_expectation(const matchable &thing, int indent) const =0
bool operator()(const char *str, const char *part) const
Definition: test_unit.h:383
group_matcher exactly(int amount)
Definition: test_unit.h:1004
group_matcher atleast(int min)
Definition: test_unit.h:1002
#define textfiles_have_difflines_ignoreDates(f1, f2, ed)
Definition: test_unit.h:1410
const char * plural(int val)
HASTOBE_CLONABLE(matchable)
xml element
char * val2readable(bool b)
Definition: test_unit.h:267
str readable(const copy< T > &v)
Definition: test_unit.h:334
const char * describe(bool expected, bool got) const
Definition: test_unit.h:623
#define memory_is_equal(m1, m2, size)
Definition: test_unit.h:1407
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:633
void expect_wanted_behavior() const
Definition: test_unit.h:471
Definition: output.h:122
#define OVERRIDE
Definition: cxxforward.h:93
void dump_brief_description() const OVERRIDE
Definition: test_unit.h:565
static void printf(const char *format,...) __attribute__((format(printf
const matchable_value< T > & get_expected() const
Definition: test_unit.h:704
static char * readable_string(const char *s)
Definition: test_unit.h:189
match_expectation(const match_expectation &other)
Definition: test_unit.h:551
#define files_are_equal(f1, f2)
Definition: test_unit.h:1408
void dump_some_expectations(int indent, bool fulfilled, bool unfulfilled) const
Definition: test_unit.h:819
matchable_value(const matchable_value< T > &other)
Definition: test_unit.h:644
static int line
Definition: arb_a2ps.c:296
#define NULp
Definition: cxxforward.h:97
static void print_readable_string(const char *s, FILE *out)
Definition: test_unit.h:240
int get_line() const
Definition: test_unit.h:145
void dump_expectation(const matchable &thing, int indent) const OVERRIDE
Definition: test_unit.h:937
bool operator==(const copy< T > &v1, const copy< T > &v2)
Definition: test_unit.h:337
#define TEST_EXPECTATION__BROKEN_AT_LOC(WANTED, GOT, FILE, LINE)
Definition: test_unit.h:1039
void print_indent(int indent)
Definition: test_unit.h:406
Definition: trnsprob.h:20
expectation_group(const expectation &e)
Definition: test_unit.h:782
bool matches(const copy< T > &v1, const copy< T > &v2) const
Definition: test_unit.h:622
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:960
const copy< T > & value() const
Definition: test_unit.h:648
bool matches(const copy< T > &v1, const copy< T > &v2) const OVERRIDE
Definition: test_unit.h:756
GB_transaction ta(gb_var)
memcpy(result, vstrf_buf, printed)
void destroy(TreeNode *that)
Definition: TreeNode.h:559
GBDATA * gb_main
Definition: adname.cxx:33
void print_hex(const T &t)
Definition: test_unit.h:353
static group_matcher all()
Definition: test_unit.h:944
group_matcher atmost(int max)
Definition: test_unit.h:1003
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:873
static group_matcher atleast(int min_)
Definition: test_unit.h:946
const matchable_value< T > CREATE_matchable(const copy< T > &val, const char *code)
Definition: test_unit.h:998
virtual void explain(int indent) const =0
bool fulfilled() const OVERRIDE
Definition: test_unit.h:562
epsilon_similar(double epsilon_)
Definition: test_unit.h:369
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:360
static void VPRINTFORMAT(format)
static void amountzero(int a, const char *zero)
Definition: test_unit.h:871
void print(const T &t)
Definition: test_unit.h:348
static void was(int a)
Definition: test_unit.h:870
match_expectation of(const expectation &e1, const expectation &e2) const
Definition: test_unit.h:954
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:1278
#define max(a, b)
Definition: f2c.h:154
GB_write_int const char s
Definition: AW_awar.cxx:156