Implemented nofork mode

git-svn-id: svn+ssh://svn.code.sf.net/p/check/code/trunk@92 64e312b2-a51f-0410-8e61-82d0ca0eb02a

diff --git a/check/src/check_impl.h b/check/src/check_impl.h
index a0a70418918a9c361efb2f27bde47bf39812f176..1041178f909713ae166591e5acd82d45727dd55c 100644 (file)
--- a/check/src/check_impl.h
+++ b/check/src/check_impl.h
@@ -82,12 +82,14 @@ typedef struct Log {
 } Log;
 
 struct SRunner {
-  List *slst;
-  TestStats *stats;
-  List *resultlst;
-  char *log_fname;
-  List *loglst;
-  enum fork_status fstat;
+  List *slst; /* List of Suite objects */
+  TestStats *stats; /* Run statistics */
+  List *resultlst; /* List of unit test results */
+  char *log_fname; /* name of log file */
+  List *loglst; /* list of Log objects */
+  enum fork_status fstat; /* controls if suites are forked or not
+                            NOTE: Don't use this value directly,
+                            instead use srunner_fork_status */
 };
 
 

diff --git a/check/src/check_msg.c b/check/src/check_msg.c
index 58522430a4e7b7a3ccb0ea14caaa19a384a4d70b..fbe9e1aa822feaa5b4af27f7cd39b3fe94a79c35 100644 (file)
--- a/check/src/check_msg.c
+++ b/check/src/check_msg.c
@@ -48,6 +48,8 @@ struct MsgSys
   int msqid;
 };
 
+static int _fstat = CK_FORK;
+
 enum {
   LASTLOCMSG = 1,
   FAILUREMSG = 2
@@ -61,6 +63,10 @@ static int init_key (void);
 static int send_key (void);
 static int recv_key (void);
 
+void set_fork_status (enum fork_status fstat)
+{
+  _fstat = fstat;
+}
 
 static FailureMsg *create_failure_msg (char *msg)
 {
@@ -195,6 +201,7 @@ Loc *receive_last_loc_msg (MsgSys *msgsys)
 {
   LastLocMsg *lmsg;
   Loc *loc;
+  int got_msg = 0;
 
   lmsg = emalloc(sizeof(LastLocMsg)); /* caller responsible for freeing */
   while (1) {
@@ -206,12 +213,18 @@ Loc *receive_last_loc_msg (MsgSys *msgsys)
        break;
       eprintf ("receive_last_loc_msg:Failed to receive message:");
     }
+    got_msg = 1;
   }
-  loc = emalloc(sizeof(Loc));
-  loc->file = last_loc_file(lmsg);
-  loc->line = last_loc_line(lmsg);
-  free(lmsg);
   
+  if (got_msg) {
+    loc = emalloc(sizeof(Loc));
+    loc->file = last_loc_file(lmsg);
+    loc->line = last_loc_line(lmsg);
+  } else {
+    loc = NULL;
+  }
+  
+  free(lmsg);
   return loc;
 }
   
@@ -242,7 +255,16 @@ int init_key(void)
 
 int send_key(void)
 {
-  return getppid();
+  int key;
+  
+  if (_fstat == CK_FORK)
+    key = (int) getppid();
+  else if (_fstat == CK_NOFORK)
+    key = (int) getpid();
+  else
+    key = -1, eprintf ("Bad _fstat");
+
+  return key;
 }
 
 int recv_key(void)

diff --git a/check/src/check_msg.h b/check/src/check_msg.h
index 078f379913ca74f3a8d01c1bc56116408765032b..86d9eba96953748f269d00533b0dbe9a9d4b9429 100644 (file)
--- a/check/src/check_msg.h
+++ b/check/src/check_msg.h
@@ -41,7 +41,7 @@ void send_last_loc_msg (MsgSys *msgsys, char * file, int line);
 char *receive_failure_msg (MsgSys *msgsys);
 Loc *receive_last_loc_msg (MsgSys *msgsys);
 
-
+void set_fork_status(enum fork_status fstat);
 MsgSys *init_msgsys (void);
 void delete_msgsys (void);
 

diff --git a/check/src/check_run.c b/check/src/check_run.c
index dc938320d5b6b269884479064e118136a4b0eb65..e316eb16ec2afe8ac966af00d281d246f326f5d1 100644 (file)
--- a/check/src/check_run.c
+++ b/check/src/check_run.c
@@ -30,15 +30,21 @@
 #include "check_msg.h"
 #include "check_log.h"
 
+enum {
+  CK_FORK_UNSPECIFIED = -1
+};
 
 static void srunner_run_init (SRunner *sr, enum print_output print_mode);
 static void srunner_run_end (SRunner *sr, enum print_output print_mode);
 static void srunner_iterate_suites (SRunner *sr,
                                    enum print_output print_mode);
 static void srunner_run_tcase (SRunner *sr, TCase *tc);
+static void srunner_iterate_tcase_tfuns (SRunner *sr, TCase *tc);
 static void srunner_add_failure (SRunner *sr, TestResult *tf);
 static TestResult *tfun_run (char *tcname, TF *tf);
+static TestResult *tfun_run_nofork (char *tcname, TF *tf);
 static TestResult *receive_result_info (MsgSys *msgsys, int status, char *tcname);
+static TestResult *receive_result_info_nofork (MsgSys *msgsys, char *tcname);
 static void receive_last_loc_info (MsgSys *msgsys, TestResult *tr);
 static void receive_failure_info (MsgSys *msgsys, int status, TestResult *tr);
 static List *srunner_resultlst (SRunner *sr);
@@ -58,7 +64,7 @@ SRunner *srunner_create (Suite *s)
   sr->resultlst = list_create();
   sr->log_fname = NULL;
   sr->loglst = NULL;
-  sr->fstat = CK_FORK;
+  sr->fstat = CK_FORK_UNSPECIFIED;
   return sr;
 }
 
@@ -92,15 +98,16 @@ void srunner_free (SRunner *sr)
 
 static void srunner_run_init (SRunner *sr, enum print_output print_mode)
 {
+  set_fork_status(srunner_fork_status(sr));
   srunner_init_logging (sr, print_mode);
   log_srunner_start (sr);
 }
 
 static void srunner_run_end (SRunner *sr, enum print_output print_mode)
 {
-
   log_srunner_end (sr);
   srunner_end_logging (sr);
+  set_fork_status(CK_FORK);  
 }
 
 static void srunner_iterate_suites (SRunner *sr,
@@ -156,26 +163,42 @@ static void srunner_add_failure (SRunner *sr, TestResult *tr)
   }
 }
 
-  
-static void srunner_run_tcase (SRunner *sr, TCase *tc)
+static void srunner_iterate_tcase_tfuns (SRunner *sr, TCase *tc)
 {
   List *tfl;
   TF *tfun;
-  TestResult *tr;
-  MsgSys *msgsys;
-
-  msgsys = init_msgsys();
+  TestResult *tr = NULL;
 
-  if (tc->setup)
-    tc->setup();
   tfl = tc->tflst;
   
   for (list_front(tfl); !list_at_end (tfl); list_advance (tfl)) {
     tfun = list_val (tfl);
-    tr = tfun_run (tc->name, tfun);
+    switch (srunner_fork_status(sr)) {
+    case CK_FORK:
+      tr = tfun_run (tc->name, tfun);
+      break;
+    case CK_NOFORK:
+      tr = tfun_run_nofork (tc->name, tfun);
+      break;
+    default:
+      eprintf("Bad fork status in SRunner");
+    }
     srunner_add_failure (sr, tr);
     log_test_end(sr, tr);
   }
+}
+  
+static void srunner_run_tcase (SRunner *sr, TCase *tc)
+{
+  MsgSys *msgsys;
+
+  msgsys = init_msgsys();
+
+  if (tc->setup)
+    tc->setup();
+  
+  srunner_iterate_tcase_tfuns(sr,tc);
+  
   if (tc->teardown)
     tc->teardown();
   delete_msgsys();
@@ -185,9 +208,16 @@ static void receive_last_loc_info (MsgSys *msgsys, TestResult *tr)
 {
   Loc *loc;
   loc = receive_last_loc_msg (msgsys);
-  tr->file = loc->file;
-  tr->line = loc->line;
-  free (loc);
+  if (loc == NULL) {
+    char *s = emalloc (strlen ("unknown") + 1);
+    strcpy(s,"unknown");
+    tr->file = s;
+    tr->line = -1;
+  } else {
+    tr->file = loc->file;
+    tr->line = loc->line;
+    free (loc);
+  }
 }  
 
 static void receive_failure_info (MsgSys *msgsys, int status, TestResult *tr)
@@ -231,13 +261,48 @@ static TestResult *receive_result_info (MsgSys *msgsys, int status, char *tcname
 {
   TestResult *tr = emalloc (sizeof(TestResult));
 
-  msgsys = get_recv_msgsys();
   tr->tcname = tcname;
   receive_last_loc_info (msgsys, tr);
   receive_failure_info (msgsys, status, tr);
   return tr;
 }
 
+static TestResult *receive_result_info_nofork (MsgSys *msgsys, char *tcname)
+{
+  /*TODO: lots of overlap with receive_failure_info
+    Find a way to generalize */
+
+  char *fmsg;
+  TestResult *tr = emalloc (sizeof(TestResult));
+
+  tr->tcname = tcname;
+  
+  receive_last_loc_info (msgsys, tr);
+  fmsg = receive_failure_msg (msgsys);
+  
+  if (fmsg == NULL) { /* we got through the procedure */
+    tr->rtype = CRPASS;
+    tr->msg = "Test passed";
+  }
+  else {
+    tr->rtype = CRFAILURE;
+    tr->msg = emalloc(strlen(fmsg) + 1);
+    strcpy (tr->msg, fmsg);
+    free (fmsg);
+  }
+  return tr;
+}
+
+static TestResult *tfun_run_nofork (char *tcname, TF *tfun)
+{
+  MsgSys  *msgsys;
+
+  msgsys = get_recv_msgsys();
+  tfun->fn();
+  return receive_result_info_nofork (msgsys, tcname);
+}
+
+  
 static TestResult *tfun_run (char *tcname, TF *tfun)
 {
   pid_t pid;
@@ -352,7 +417,16 @@ static int non_pass (int val)
 
 enum fork_status srunner_fork_status (SRunner *sr)
 {
-  return sr->fstat;
+  if (sr->fstat == CK_FORK_UNSPECIFIED) {
+    char *env = getenv("CK_FORK");
+    if (env == NULL)
+      return CK_FORK;
+    if (strcmp(env,"no") == 0)
+      return CK_NOFORK;
+    else
+      return CK_FORK;
+  } else
+    return sr->fstat;
 }
 
 void srunner_set_fork_status (SRunner *sr, enum fork_status fstat)