ARB
TestEnvironment.cxx
Go to the documentation of this file.
1 // ================================================================= //
2 // //
3 // File : TestEnvironment.cxx //
4 // Purpose : Global! setup/cleanup for tests //
5 // //
6 // Coded by Ralf Westram (coder@reallysoft.de) in September 2010 //
7 // Institute of Microbiology (Technical University Munich) //
8 // http://www.arb-home.de/ //
9 // //
10 // ================================================================= //
11 
12 #include <arb_simple_assert.h>
13 
14 #include <arb_defs.h>
15 #include <arb_str.h>
16 #include <arb_file.h>
17 #include <arb_diff.h>
18 
19 #include <arbdb.h>
20 #include <PT_com.h>
21 #include <client.h>
22 #include <servercntrl.h>
23 
24 #include "test_unit.h"
25 #include "UnitTester.hxx"
26 
27 #include <string>
28 #include <set>
29 #include <unistd.h>
30 
31 #include <sys/stat.h>
32 #include <sys/time.h>
33 
34 #include "../SOURCE_TOOLS/arb_main.h"
35 
36 #define env_assert(cond) arb_assert(cond)
37 
38 // #define SIMULATE_ENVSETUP_TIMEOUT // makes tests fail
39 // #define SIMULATE_ENVSETUP_SLOW_OVERTIME // should not make tests fail
40 
41 using namespace arb_test;
42 using namespace std;
43 
44 enum Mode { UNKNOWN, SETUP, CLEAN };
45 static const char *mode_command[] = { NULp, "setup", "clean" }; // same order as in enum Mode
46 static Mode other_mode[] = { UNKNOWN, CLEAN, SETUP };
47 
48 typedef SmartCharPtr Error;
49 
50 static const char *upcase(const char *str) {
51  char *upstr = strdup(str);
52  ARB_strupper(upstr);
53  RETURN_LOCAL_ALLOC(upstr);
54 }
55 
56 #define WARN_NOT_IMPLEMENTED(fun,mode) TEST_WARNING2("%s(%s) does nothing", #fun, upcase(mode_command[mode]));
57 
58 static const char *unitTesterDir() {
60 }
61 static const char *flagDir() {
63 }
64 static const char *runDir() {
66 }
67 static const char *mutexDir(const char *name) {
68  return GB_concat_full_path(flagDir(), GBS_global_string("mutex_%s", name));
69 }
70 
71 #if defined(DEBUG)
72 // #define DUMP_MUTEX_ACCESS
73 #endif
74 
75 
76 class Mutex : virtual Noncopyable {
77  string name;
78  string mutexdir;
79 
80  bool mutexdir_exists() const { return GB_is_directory(mutexdir.c_str()); }
81 
82  static const char *now() {
83  static char buf[100];
84  timeval t;
85  gettimeofday(&t, NULp);
86  sprintf(buf, "%li.%li", t.tv_sec, t.tv_usec);
87  return buf;
88  }
89 
90  static set<string> known_mutexes;
91 
92 public:
93  Mutex(const char *mutex_name)
94  : name(mutex_name)
95  {
96  mutexdir = mutexDir(mutex_name);
97 
98  bool gotMutex = false;
99  int maxwait = MAX_EXEC_MS_SLOW-5; // seconds
100  int wait = 0;
101 
102  arb_assert(maxwait>0);
103 
104  test_data().entered_mutex_loop = true; // avoid race-condition
105  while (!gotMutex) {
106  if (mutexdir_exists()) {
107  if (wait>maxwait && mutexdir_exists()) {
108  GBK_terminatef("[%s] Failed to get mutex for more than %i seconds", now(), maxwait);
109  }
110  printf("[%s] mutex '%s' exists.. sleeping\n", now(), name.c_str());
111  sleepms(1000);
112  wait++;
113  }
114  else {
115  int res = mkdir(mutexdir.c_str(), S_IRWXU);
116  if (res == 0) {
117 #if defined(DUMP_MUTEX_ACCESS)
118  printf("[%s] allocated mutex '%s'\n", now(), name.c_str());
119 #endif
120  gotMutex = true;
121  }
122  else {
123  wait = 0; // reset timeout
124  printf("[%s] lost race for mutex '%s'\n", now(), name.c_str());
125  }
126  }
127  }
128  known_mutexes.insert(name);
129  }
130  ~Mutex() {
131  if (!mutexdir_exists()) {
132  printf("[%s] Strange - mutex '%s' has vanished\n", now(), name.c_str());
133  }
134  else {
135  if (rmdir(mutexdir.c_str()) != 0) {
136  const char *error = GB_IO_error("remove", mutexdir.c_str());
137  GBK_terminatef("[%s] Failed to release mutex dir (%s)", now(), error);
138  }
139  else {
140 #if defined(DUMP_MUTEX_ACCESS)
141  printf("[%s] released mutex '%s'\n", now(), mutexdir.c_str());
142 #endif
143  }
144  }
145  known_mutexes.erase(name);
146  }
147 
148  static bool owned(const char *mutex_name) {
149  return known_mutexes.find(mutex_name) != known_mutexes.end();
150  }
151 
152  static void own_or_terminate(const char *mutex_name) {
153  if (!Mutex::owned(mutex_name)) {
154  GBK_terminatef("Expected to own mutex '%s'", mutex_name);
155  }
156  }
157 };
158 
159 set<string> Mutex::known_mutexes;
160 
161 // -----------------------
162 // PersistantFlag
163 
164 static const char *FLAG_MUTEX = "flag_access";
165 
167  // persistant flags keep their value even if the program is restarted(!)
168 
169  string name;
170  mutable bool value; // has to be mutable to support volatile behavior
171  bool is_volatile;
172 
173  const char *flagFileName() const {
174  return GB_concat_full_path(flagDir(), GBS_global_string("%s." FLAGS_EXT, name.c_str()));
175  }
176 
177  bool flagFileExists() const {
178  Mutex::own_or_terminate(FLAG_MUTEX);
179  return GB_is_regularfile(flagFileName());
180  }
181 
182  void createFlagFile() const {
183  Mutex::own_or_terminate(FLAG_MUTEX);
184  const char *flagfile = flagFileName();
185  FILE *fp = fopen(flagfile, "w");
186  if (!fp) {
187  GB_ERROR error = GB_IO_error("creating flag", flagfile);
188  HERE.errorf(true, "%s\n", error);
189  }
190  else {
191  fclose(fp);
192  }
193  env_assert(flagFileExists());
194  }
195  void removeFlagFile() const {
196  const char *flagfile = flagFileName();
197  StaticCode::printf("flagfile='%s'\n", flagfile);
198  if (!flagFileExists()) {
199  GBK_dump_backtrace(stderr, "tried to remove non-existing flagfile");
200  }
201  int res = unlink(flagfile);
202  if (res != 0) {
203  GB_ERROR error = GB_IO_error("unlinking", flagfile);
204  HERE.errorf(true, "%s\n", error);
205  }
206  env_assert(!flagFileExists());
207  }
208  void updateFlagFile() const {
209  if (value) createFlagFile();
210  else removeFlagFile();
211  }
212 
213 public:
214  PersistantFlag(const string& name_)
215  : name(name_),
216  value(flagFileExists()),
217  is_volatile(false)
218  {}
219  PersistantFlag(const string& name_, bool is_volatile_)
220  : name(name_),
221  value(flagFileExists()),
222  is_volatile(is_volatile_)
223  {}
225  if (flagFileExists() != bool(*this)) {
226  StaticCode::printf("Mismatch between internal value(=%i) and flagfile='%s'\n", int(value), name.c_str());
227  }
228  env_assert(flagFileExists() == value);
229  }
230  operator bool() const {
231  if (is_volatile) value = flagFileExists();
232  return value;
233  }
234 
235  PersistantFlag& operator = (bool b) {
236  if (b != bool(*this)) {
237  StaticCode::printf("Changing flag '%s' to %i\n", name.c_str(), int(b));
238  value = b;
239  updateFlagFile();
240  }
241  return *this;
242  }
243 };
244 
246  // wrapper for PersistantFlag - instanciates on r/w access
247 
249 
250  string name;
251  bool will_be_volatile;
252 
253  void instanciate() {
254  flag = new PersistantFlag(name, will_be_volatile);
255  }
256  void instanciate_on_demand() const {
257  if (flag.isNull()) {
258  const_cast<LazyPersistantFlag*>(this)->instanciate();
259  }
260  }
261 
262 public:
263  LazyPersistantFlag(const char *name_) : name(name_), will_be_volatile(false) {}
264  LazyPersistantFlag(const char *name_, bool is_volatile_) : name(name_), will_be_volatile(is_volatile_) {}
265 
266  operator bool() const {
267  instanciate_on_demand();
268  return *flag;
269  }
270 
271  LazyPersistantFlag& operator = (bool b) {
272  instanciate_on_demand();
273  *flag = b;
274  return *this;
275  }
276 
277  void get_lazy_again() { flag.setNull(); }
278 };
279 
280 
281 // --------------------------------------------------------------------------------
282 // add environment setup/cleanup functions here (and add name to environments[] below)
283 //
284 // each environment
285 // - is setup on client-request (using TEST_SETUP_GLOBAL_ENVIRONMENT)
286 // - is cleaned up after ALL unit tests were executed (only if it has been setup)
287 //
288 // Functions start in same directory where tests starts.
289 //
290 // Note: you cannot simply share data between different modes since they are
291 // executed in different instances of the executable 'test_environment'!
292 //
293 // Use 'PersistantFlag' to share bools between instances.
294 // --------------------------------------------------------------------------------
295 
296 // -----------------
297 // ptserver
298 
299 static void test_ptserver_activate(bool start, int serverid) {
300  const char *server_tag = GBS_ptserver_tag(serverid);
301  if (start) {
303  }
304  else { // stop
305  GB_ERROR kill_error = arb_look_and_kill_server(AISC_MAGIC_NUMBER, server_tag);
306  if (kill_error) TEST_EXPECT_EQUAL(kill_error, "Server is not running");
307  }
308 }
309 
310 // to activate INDEX_HEXDUMP uncomment TEST_AUTO_UPDATE and INDEX_HEXDUMP once (before modifying index),
311 // then comment out TEST_AUTO_UPDATE again
312 //
313 // #define TEST_AUTO_UPDATE
314 // #define INDEX_HEXDUMP
315 
316 static Error ptserver(Mode mode) {
317  // test-ptserver is restarted and rebuild.
318  // This is done only once in the complete test suite.
319  //
320  // every unit-test using the test-ptserver should simply call
321  // TEST_SETUP_GLOBAL_ENVIRONMENT("ptserver");
322 
323  Error error;
324  switch (mode) {
325  case SETUP: {
326  test_ptserver_activate(false, TEST_SERVER_ID); // first kill pt-server (otherwise we may test an outdated pt-server)
327  TEST_EXPECT_NO_ERROR(GBK_system("cp TEST_pt_src.arb TEST_pt.arb")); // force rebuild
328  test_ptserver_activate(true, TEST_SERVER_ID);
329 #if defined(INDEX_HEXDUMP)
330  TEST_DUMP_FILE("TEST_pt.arb.pt", "TEST_pt.arb.pt.dump");
331 #endif
332 
333 #if defined(TEST_AUTO_UPDATE)
334  TEST_COPY_FILE("TEST_pt.arb.pt", "TEST_pt.arb.pt.expected");
335 # if defined(INDEX_HEXDUMP)
336  TEST_COPY_FILE("TEST_pt.arb.pt.dump", "TEST_pt.arb.pt.dump.expected");
337 # endif
338 #else // !defined(TEST_AUTO_UPDATE)
339 # if defined(INDEX_HEXDUMP)
340  TEST_EXPECT_TEXTFILES_EQUAL("TEST_pt.arb.pt.dump.expected", "TEST_pt.arb.pt.dump");
341 # endif
342  TEST_EXPECT_FILES_EQUAL("TEST_pt.arb.pt.expected", "TEST_pt.arb.pt");
343 #endif
344  TEST_EXPECT_LESS_EQUAL(GB_time_of_file("TEST_pt.arb"), GB_time_of_file("TEST_pt.arb.pt"));
345  break;
346  }
347  case CLEAN: {
348  test_ptserver_activate(false, TEST_SERVER_ID);
349  TEST_EXPECT_ZERO_OR_SHOW_ERRNO(unlink("TEST_pt.arb.pt"));
350 #if defined(INDEX_HEXDUMP)
351  TEST_EXPECT_ZERO_OR_SHOW_ERRNO(unlink("TEST_pt.arb.pt.dump"));
352 #endif
353  break;
354  }
355  case UNKNOWN:
356  env_assert(0);
357  break;
358  }
359 
360  return error;
361 }
362 
363 static Error ptserver_gene(Mode mode) {
364  // test-gene-ptserver is restarted and rebuild.
365  // This is done only once in the complete test suite.
366  //
367  // every unit-test using the test-gene-ptserver should simply call
368  // TEST_SETUP_GLOBAL_ENVIRONMENT("ptserver_gene");
369 
370  Error error;
371  switch (mode) {
372  case SETUP: {
373  test_ptserver_activate(false, TEST_GENESERVER_ID); // first kill pt-server (otherwise we may test an outdated pt-server)
374  TEST_EXPECT_NO_ERROR(GBK_system("arb_gene_probe TEST_gpt_src.arb TEST_gpt.arb")); // prepare gene-ptserver-db (forcing rebuild)
375 
376  // GBK_terminatef("test-crash of test_environment");
377 
378 #if defined(TEST_AUTO_UPDATE)
379  TEST_COPY_FILE("TEST_gpt.arb", "TEST_gpt.arb.expected");
380 #else // !defined(TEST_AUTO_UPDATE)
381  TEST_EXPECT_FILES_EQUAL("TEST_gpt.arb.expected", "TEST_gpt.arb");
382 #endif
383 
384  test_ptserver_activate(true, TEST_GENESERVER_ID);
385 #if defined(INDEX_HEXDUMP)
386  TEST_DUMP_FILE("TEST_gpt.arb.pt", "TEST_gpt.arb.pt.dump");
387 #endif
388 
389 #if defined(TEST_AUTO_UPDATE)
390  TEST_COPY_FILE("TEST_gpt.arb.pt", "TEST_gpt.arb.pt.expected");
391 # if defined(INDEX_HEXDUMP)
392  TEST_COPY_FILE("TEST_gpt.arb.pt.dump", "TEST_gpt.arb.pt.dump.expected");
393 # endif
394 #else // !defined(TEST_AUTO_UPDATE)
395 # if defined(INDEX_HEXDUMP)
396  TEST_EXPECT_TEXTFILES_EQUAL("TEST_gpt.arb.pt.dump.expected", "TEST_gpt.arb.pt.dump");
397 # endif
398  TEST_EXPECT_FILES_EQUAL("TEST_gpt.arb.pt.expected", "TEST_gpt.arb.pt");
399 #endif
400 
401  TEST_EXPECT_LESS_EQUAL(GB_time_of_file("TEST_gpt.arb"), GB_time_of_file("TEST_gpt.arb.pt"));
402  break;
403  }
404  case CLEAN: {
405  test_ptserver_activate(false, TEST_GENESERVER_ID);
406  TEST_EXPECT_ZERO_OR_SHOW_ERRNO(unlink("TEST_gpt.arb.pt"));
407 #if defined(INDEX_HEXDUMP)
408  TEST_EXPECT_ZERO_OR_SHOW_ERRNO(unlink("TEST_gpt.arb.pt.dump"));
409 #endif
410  break;
411  }
412  case UNKNOWN:
413  env_assert(0);
414  break;
415  }
416 
417  return error;
418 }
419 
420 #undef TEST_AUTO_UPDATE
421 
422 // --------------------------------------------------------------------------------
423 
424 typedef Error (*Environment_cb)(Mode mode);
425 
428 static SmartCharPtr wrapped_error;
429 
431 
432 class FunInfo {
434  string name;
435  LazyPersistantFlag is_setup;
436  LazyPersistantFlag changing; // some process is currently setting up/cleaning the environment
437  LazyPersistantFlag failed; // some process failed to setup the environment
438 
439  void all_get_lazy_again() {
440  changing.get_lazy_again();
441  is_setup.get_lazy_again();
442  failed.get_lazy_again();
443  }
444 
445  Error set_to(Mode mode) {
446  StaticCode::printf("[%s environment '%s' START]\n", mode_command[mode], get_name());
447 
448  wrapped_cb = cb;
449  wrapped_mode = mode;
450  wrapped_error.setNull();
451 
452  Error error;
453  if (chdir(runDir()) != 0) {
454  error = strdup(GB_IO_error("changing dir to", runDir()));
455  }
456  else {
457  long duration;
458  UnitTestResult guard_says = execute_guarded(wrapped, &duration, MAX_EXEC_MS_ENV, false); // <-- call environment state-changer
459 
460  switch (guard_says) {
461  case TEST_OK:
462  if (wrapped_error.isSet()) {
463  error = GBS_global_string_copy("returns error: %s", &*wrapped_error);
464  }
465  break;
466 
467  case TEST_TRAPPED:
468  case TEST_INTERRUPTED: {
469  const char *what_happened = guard_says == TEST_TRAPPED
470  ? "trapped"
471  : "has been interrupted (might be a deadlock)";
472 
473  error = GBS_global_string_copy("%s%s",
474  what_happened,
475  wrapped_error.isSet() ? GBS_global_string(" (wrapped_error='%s')", &*wrapped_error) : "");
476  break;
477  }
478  case TEST_THREW:
479  error = strdup("has thrown an exception");
480  break;
481 
482  case TEST_INVALID:
483  error = strdup("is invalid");
484  break;
485 
487  case TEST_UNKNOWN_RESULT:
488  env_assert(0); // should not happen here
489  break;
490  }
491  if (error.isSet()) {
492  error = GBS_global_string_copy("%s(%s) %s", name.c_str(), upcase(mode_command[mode]), &*error);
493  }
494  else {
495  Mutex m(FLAG_MUTEX);
496 
497  env_assert(changing);
498  is_setup = (mode == SETUP);
499 #if defined(SIMULATE_ENVSETUP_TIMEOUT)
500  if (mode == SETUP) {
501  StaticCode::printf("[simulating a timeout during SETUP]\n");
502  sleepms(MAX_EXEC_MS_ENV+MAX_EXEC_MS_SLOW+100); // simulate a timeout
503  }
504 #endif
505 #if defined(SIMULATE_ENVSETUP_SLOW_OVERTIME)
506  if (mode == SETUP) {
507  StaticCode::printf("[simulating overtime during SETUP]\n");
508  sleepms(MAX_EXEC_MS_SLOW+100); // simulate overtime
509  }
510 #endif
511  changing = false;
512  all_get_lazy_again();
513  }
514  }
515 
516  StaticCode::printf("[%s environment '%s' END]\n", mode_command[mode], get_name());
517  return error;
518  }
519 
520 public:
521 
522  FunInfo(Environment_cb cb_, const char *name_)
523  : cb(cb_),
524  name(name_),
525  is_setup(name_),
526  changing(GBS_global_string("changing_%s", name_)),
527  failed(GBS_global_string("failed_%s", name_))
528  {}
529 
530  Error switch_to(Mode mode) { // @@@ need to return allocated msg (it gets overwritten)
531  Error error;
532  bool want_setup = (mode == SETUP);
533 
534  bool perform_change = false;
535  bool wait_for_change = false;
536  {
537  Mutex m(FLAG_MUTEX);
538 
539  if (changing) { // somebody is changing the environment state
540  if (is_setup == want_setup) { // wanted state was reached, but somebody is altering it
541  error = GBS_global_string_copy("[environment '%s' was %s, but somebody is changing it to %s]",
542  get_name(), mode_command[mode], mode_command[other_mode[mode]]);
543  }
544  else { // the somebody is changing to my wanted state
545  wait_for_change = true;
546  }
547  }
548  else {
549  if (is_setup == want_setup) {
550  StaticCode::printf("[environment '%s' already was %s]\n", get_name(), mode_command[mode]);
551  }
552  else {
553  changing = perform_change = true;
554  }
555  }
556 
557  all_get_lazy_again();
558  }
559 
560  env_assert(!(perform_change && wait_for_change));
561 
562  if (perform_change) {
563  error = set_to(mode);
564  if (error.isSet()) {
565  {
566  Mutex m(FLAG_MUTEX);
567  failed = true;
568  all_get_lazy_again();
569  }
570  Error clean_error = set_to(CLEAN);
571  if (clean_error.isSet()) {
572  StaticCode::printf("[environment '%s' failed to reach '%s' after failure (Reason: %s)]\n",
573  get_name(), mode_command[CLEAN], &*clean_error);
574  }
575  }
576  }
577 
578  if (wait_for_change) {
579  bool reached = false;
580  while (!reached && !error.isSet()) {
581  StaticCode::printf("[waiting until environment '%s' reaches '%s']\n", get_name(), mode_command[mode]);
582  sleepms(1000);
583  {
584  Mutex m(FLAG_MUTEX);
585  if (!changing && is_setup == want_setup) reached = true;
586  if (failed) {
587  error = GBS_global_string_copy("[environment '%s' failed to reach '%s' (in another process)]", get_name(), mode_command[mode]);
588  }
589  all_get_lazy_again();
590  }
591  }
592  if (reached) StaticCode::printf("[environment '%s' has reached '%s']\n", get_name(), mode_command[mode]);
593  }
594 
595  return error;
596  }
597 
598  const char *get_name() const { return name.c_str(); }
599  bool has_name(const char *oname) const { return name == oname; }
600 };
601 
602 #define FUNINFO(fun) FunInfo(fun,#fun)
603 
604 static FunInfo modules[] = { // ExistingEnvironments
605  FUNINFO(ptserver),
607 };
608 
609 const size_t MODULES = ARRAY_ELEMS(modules);
610 
611 static FunInfo *find_module(const char *moduleName) {
612  for (size_t e = 0; e<MODULES; ++e) {
613  if (modules[e].has_name(moduleName)) {
614  return &modules[e];
615  }
616  }
617  return NULp;
618 }
619 
621  Error error;
622  for (size_t e = 0; error.isNull() && e<MODULES; ++e) {
623  error = modules[e].switch_to(mode);
624  }
625  return error;
626 }
627 
628 static const char *known_modules(char separator) {
629  const char *mods = NULp;
630  for (size_t i = 0; i<MODULES; ++i) {
631  mods = mods
632  ? GBS_global_string("%s%c%s", mods, separator, modules[i].get_name())
633  : modules[i].get_name();
634  }
635  return mods;
636 }
637 static const char *known_modes(char separator) {
638  const char *modes = NULp;
639  for (size_t i = 0; i<ARRAY_ELEMS(mode_command); ++i) {
640  if (mode_command[i]) {
641  modes = modes
642  ? GBS_global_string("%s%c%s", modes, separator, mode_command[i])
643  : mode_command[i];
644  }
645  }
646  return modes;
647 }
648 
649 
650 int main(int argc, char* argv[]) {
651  start_of_main();
652 
653  Error error;
654  bool showUsage = true;
655 
656  if (argc<2 || argc>3) error = strdup("Wrong number of arguments");
657  else {
658  const char *modearg = argv[1];
659  Mode mode = UNKNOWN;
660 
661  for (size_t i = 0; i<ARRAY_ELEMS(mode_command); ++i) {
662  if (mode_command[i] && strcmp(modearg, mode_command[i]) == 0) mode = (Mode)i;
663  }
664 
665  if (mode == UNKNOWN) {
666  error = GBS_global_string_copy("unknown argument '%s' (known modes are: %s)", modearg, known_modes(' '));
667  }
668  else {
669  if (argc == 2) {
670  error = set_all_modules_to(mode);
671  showUsage = false;
672  }
673  else {
674  const char *modulearg = argv[2];
675  FunInfo *module = find_module(modulearg);
676 
677  if (!module) {
678  error = GBS_global_string_copy("unknown argument '%s' (known modules are: %s)", modulearg, known_modules(' '));
679  }
680  else {
681  error = module->switch_to(mode);
682  showUsage = false;
683  }
684  }
685  }
686  }
687 
688  if (error.isSet()) {
689  const char *exename = argv[0];
690  StaticCode::printf("Error in %s: %s\n", exename, &*error);
691  if (showUsage) StaticCode::printf("Usage: %s [%s] [%s]\n", exename, known_modes('|'), known_modules('|'));
692  return EXIT_FAILURE;
693  }
694 
695  return EXIT_SUCCESS;
696 }
697 
SmartCharPtr Error
GB_ERROR GBK_system(const char *system_command)
Definition: arb_msg.cxx:519
#define arb_assert(cond)
Definition: arb_assert.h:245
static Environment_cb wrapped_cb
static void own_or_terminate(const char *mutex_name)
int main(int argc, char *argv[])
char * oname
Definition: readseq.c:463
#define HERE
Definition: test_unit.h:1055
static Mode wrapped_mode
static const char * FLAG_MUTEX
static const char * known_modes(char separator)
static Mode other_mode[]
static Error ptserver_gene(Mode mode)
GB_ERROR GB_IO_error(const char *action, const char *filename)
Definition: arb_msg.cxx:293
GB_ERROR arb_look_and_start_server(long magic_number, const char *arb_tcp_env)
GB_ERROR arb_look_and_kill_server(int magic_number, const char *arb_tcp_env)
const char * GBS_global_string(const char *templat,...)
Definition: arb_msg.cxx:204
void GBK_terminatef(const char *templat,...)
Definition: arb_msg.cxx:477
static const char * known_modules(char separator)
STL namespace.
#define TEST_EXPECT_LESS_EQUAL(val, ref)
Definition: test_unit.h:1295
FunInfo(Environment_cb cb_, const char *name_)
bool isNull() const
test if SmartPtr is NULp
Definition: smartptr.h:248
#define env_assert(cond)
#define EXIT_SUCCESS
Definition: arb_a2ps.c:154
static const char * mode_command[]
#define ARRAY_ELEMS(array)
Definition: arb_defs.h:19
void setNull()
set SmartPtr to NULp
Definition: smartptr.h:251
GB_CSTR GB_getenvARBHOME(void)
Definition: adsocket.cxx:565
#define cb(action)
static const char * runDir()
static FunInfo modules[]
static HelixNrInfo * start
static const char * mutexDir(const char *name)
const size_t MODULES
Error(* Environment_cb)(Mode mode)
static Error set_all_modules_to(Mode mode)
static const char * flagDir()
unsigned long GB_time_of_file(const char *path)
Definition: arb_file.cxx:44
#define false
Definition: ureadseq.h:13
UnitTestResult execute_guarded(UnitTest_function fun, long *duration_usec, long max_allowed_duration_ms, bool detect_environment_calls)
Definition: UnitTester.cxx:403
static SmartCharPtr wrapped_error
static void error(const char *msg)
Definition: mkptypes.cxx:96
static void test_ptserver_activate(bool start, int serverid)
LazyPersistantFlag(const char *name_)
Error switch_to(Mode mode)
#define RETURN_ONETIME_ALLOC(allocated)
Definition: smartptr.h:315
#define RETURN_LOCAL_ALLOC(mallocation)
Definition: smartptr.h:310
#define TEST_EXPECT_ZERO_OR_SHOW_ERRNO(iocond)
Definition: test_unit.h:1079
char * ARB_strupper(char *s)
Definition: arb_str.h:63
#define EXIT_FAILURE
Definition: arb_a2ps.c:157
const long MAX_EXEC_MS_SLOW
Definition: UnitTester.hxx:69
PersistantFlag(const string &name_, bool is_volatile_)
static const char * unitTesterDir()
LazyPersistantFlag(const char *name_, bool is_volatile_)
long int flag
Definition: f2c.h:39
GB_CSTR GB_concat_full_path(const char *anypath_left, const char *anypath_right)
Definition: adsocket.cxx:1071
#define AISC_MAGIC_NUMBER
Definition: client_privat.h:51
static const char * upcase(const char *str)
const long MAX_EXEC_MS_ENV
Definition: UnitTester.hxx:70
static Error ptserver(Mode mode)
PersistantFlag(const string &name_)
bool GB_is_directory(const char *path)
Definition: arb_file.cxx:176
#define FLAGS_DIR
Definition: UnitTester.hxx:76
#define TEST_EXPECT_FILES_EQUAL(f1, f2)
Definition: test_unit.h:1394
static void printf(const char *format,...) __attribute__((format(printf
void sleepms(long ms)
Definition: UnitTester.cxx:354
UnitTestResult
Definition: UnitTester.hxx:24
void GBK_dump_backtrace(FILE *out, const char *message)
Definition: arb_msg.cxx:428
#define TEST_EXPECT_NO_ERROR(call)
Definition: test_unit.h:1107
#define FUNINFO(fun)
static void start_of_main()
Definition: arb_main.h:16
#define NULp
Definition: cxxforward.h:97
bool GB_is_regularfile(const char *path)
Definition: arb_file.cxx:76
#define FLAGS_EXT
Definition: UnitTester.hxx:77
bool has_name(const char *oname) const
Mutex(const char *mutex_name)
static FunInfo * find_module(const char *moduleName)
const char * GBS_ptserver_tag(int id)
Definition: adtcp.cxx:312
#define TEST_EXPECT_TEXTFILES_EQUAL(fgot, fwant)
Definition: test_unit.h:1396
static void wrapped()
#define TEST_EXPECT_EQUAL(expr, want)
Definition: test_unit.h:1283
static bool owned(const char *mutex_name)
char * GBS_global_string_copy(const char *templat,...)
Definition: arb_msg.cxx:195
const char * get_name() const