Completed implementation of check_pack

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

diff --git a/check/src/check.c b/check/src/check.c
index b204c9a475a8c67bc5c09bb992c5c695739f8096..000ee9c3e0428276cb43e8049ddfa25482f27f04 100644 (file)
--- a/check/src/check.c
+++ b/check/src/check.c
@@ -264,6 +264,20 @@ static int non_pass (int val)
   return val != CK_PASS;
 }
 
+TestResult *tr_create(void)
+{
+  TestResult *tr;
+
+  tr = emalloc (sizeof(TestResult));
+
+  tr->ctx = -1;
+  tr->line = -1;
+  tr->rtype = -1;
+  tr->msg = tr->file = tr->tcname = NULL;
+  return tr;
+}
+
+
 char *tr_msg (TestResult *tr)
 {
   return tr->msg;
@@ -284,6 +298,11 @@ int tr_rtype (TestResult *tr)
   return tr->rtype;
 }
 
+enum ck_result_ctx tr_ctx (TestResult *tr)
+{
+  return tr->ctx;
+}
+
 char *tr_tcname (TestResult *tr)
 {
   return tr->tcname;

diff --git a/check/src/check.h b/check/src/check.h
index b434214e17cd60055284b55d12a8a9a3d3cf5b30..e5acd361f01273909233fa0b53245bfce6fd8d69 100644 (file)
--- a/check/src/check.h
+++ b/check/src/check.h
@@ -196,8 +196,16 @@ typedef struct TestResult TestResult;
 
 /* accessors for tr fields */
 
+ enum ck_result_ctx {
+  CK_CTX_SETUP,
+  CK_CTX_TEST,
+  CK_CTX_TEARDOWN
+};
+
 /* Type of result */
 int tr_rtype (TestResult *tr);
+/* Context in which the result occurred */ 
+enum ck_result_ctx tr_ctx (TestResult *tr); 
 /* Failure message */
 char *tr_msg (TestResult *tr);
 /* Line number at which failure occured */

diff --git a/check/src/check_impl.h b/check/src/check_impl.h
index 43875407c62b7ac2ab96062356916ec4ba13d5a5..0286726e6a9f1c080620bb2dd26a711f0964b6fe 100644 (file)
--- a/check/src/check_impl.h
+++ b/check/src/check_impl.h
@@ -68,12 +68,15 @@ typedef struct TestStats {
 
 struct TestResult {
   enum test_result rtype;     /* Type of result */
+  enum ck_result_ctx ctx;     /* When the result occurred */
   char *file;    /* File where the test occured */
   int line;      /* Line number where the test occurred */
   char *tcname;  /* Test case that generated the result */
   char *msg;     /* Failure message */
 };
 
+TestResult *tr_create(void);
+
 enum cl_event {
   CLSTART_SR,
   CLSTART_S,

diff --git a/check/src/check_pack.c b/check/src/check_pack.c
index 7bb09045ed0697085bc41de64fe18287e89afd0a..edffc3f2aa7094f517fe4f9c94909326321aa231 100644 (file)
--- a/check/src/check_pack.c
+++ b/check/src/check_pack.c
@@ -19,10 +19,14 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <unistd.h>
 
+#include "list.h"
 #include "error.h"
-#include "check_pack.h"
+#include "check.h"
 #include "check_magic.h"
+#include "check_impl.h"
+#include "check_pack.h"
 
 
 static void pack_int (char **buf, int val);
@@ -41,6 +45,9 @@ static void check_type (int type, char *file, int line);
 static enum ck_msg_type upack_type (char **buf);
 static void pack_type (char **buf, enum ck_msg_type type);
 
+static int read_buf (int fdes, char **buf);
+static int get_result (char *buf, TestResult *tr);
+
 typedef void (*pfun) (char **, void *);
 
 static pfun pftab [] = {
@@ -58,6 +65,7 @@ static pfun upftab [] = {
 int pack (enum ck_msg_type type, char *buf, void *data)
 {
   char *obuf;
+  int nread;
   
   if (buf == NULL)
     return -1;
@@ -71,20 +79,28 @@ int pack (enum ck_msg_type type, char *buf, void *data)
   
   pftab[type] (&buf, data);
 
-  return buf - obuf;
+  nread = buf - obuf;
+  return nread;
 }
 
-enum ck_msg_type upack (char *buf, void *data)
+int upack (char *buf, void *data, enum ck_msg_type *type)
 {
-  enum ck_msg_type type;
+  char *obuf;
+  int nread;
 
-  type = upack_type (&buf);
+  if (buf == NULL)
+    return -1;
 
-  check_type(type, __FILE__, __LINE__);
+  obuf = buf;
+
+  *type = upack_type (&buf);
+
+  check_type(*type, __FILE__, __LINE__);
   
-  upftab[type] (&buf, data);
+  upftab[*type] (&buf, data);
 
-  return type;
+  nread = buf - obuf;
+  return nread;
 }
 
 static void pack_int (char **buf, int val)
@@ -202,3 +218,99 @@ static void check_type (int type, char *file, int line)
     eprintf ("%s:%d:Bad message type arg", file, line);
 }
 
+void ppack (int fdes, enum ck_msg_type type, void *data)
+{
+  char *buf;
+  int n;
+  ssize_t r;
+
+  buf = emalloc (CK_MAXMSGBUF);
+  n = pack(type, buf, data);
+  r = write (fdes, buf, n);
+  if (r == -1)
+    eprintf("Error in ppack:");
+
+  free(buf);
+}
+
+static int read_buf (int fdes, char **buf)
+{
+  char *readloc;
+  int n;
+  int nread = 0;
+  int mul;
+  
+  *buf = emalloc(CK_MAXMSGBUF);
+  readloc = *buf;
+  mul = 2;
+  while (1) {
+    n = read(fdes,readloc,CK_MAXMSGBUF);
+    if (n == 0)
+      break;
+    if (n == -1)
+      eprintf("Error in read_buf:");
+
+    nread += n;
+    *buf = erealloc(*buf,CK_MAXMSGBUF * mul);
+    mul++;
+    readloc += CK_MAXMSGBUF;
+  }
+  return nread;
+}    
+
+static int get_result (char *buf, TestResult *tr)
+{
+  enum ck_msg_type type;
+  void *data;
+  int n;
+
+  data = emalloc(CK_MAXMSGBUF);
+  
+  n = upack(buf,data,&type);
+  
+  if (type == CK_MSG_CTX) {
+    tr->ctx = ((CtxMsg *) data)->ctx;
+  } else if (type == CK_MSG_LOC) {
+    LocMsg *lmsg = data;
+    tr->line = lmsg->line;
+    tr->file = emalloc(strlen(lmsg->file) + 1);
+    strcpy(tr->file, lmsg->file);
+  } else if (type == CK_MSG_FAIL) {      
+    FailMsg *fmsg = data;
+    tr->msg = emalloc (strlen(fmsg->msg) + 1);
+    strcpy(tr->msg, fmsg->msg);
+  } else
+    check_type(type, __FILE__, __LINE__);
+
+  free(data);
+  return n;
+  
+}
+
+
+TestResult *punpack(int fdes)
+{
+  int nread, n;
+  char *buf;
+  char *obuf;
+  TestResult *tr;
+  
+  nread = read_buf (fdes, &buf);
+  obuf = buf;
+  tr = tr_create();
+  
+  while (nread > 0) {
+    n = get_result(buf, tr);
+    nread -= n;
+    buf += n;
+  }
+
+  free(obuf);
+  if (tr->ctx == -1) {
+    free (tr);
+    tr = NULL;
+  }
+
+  return tr;
+}
+

diff --git a/check/src/check_pack.h b/check/src/check_pack.h
index 02fffb795267ac65f5dcc792c15c1510fc2e269d..6f0079386174578a7833a0d654121868290b609d 100644 (file)
--- a/check/src/check_pack.h
+++ b/check/src/check_pack.h
@@ -27,15 +27,10 @@ enum ck_msg_type {
   CK_MSG_LAST
 };
 
-enum ck_msg_context {
-  CK_CTX_SETUP,
-  CK_CTX_TEST,
-  CK_CTX_TEARDOWN
-};
 
 typedef struct CtxMsg
 {
-  enum ck_msg_context ctx;
+  enum ck_result_ctx ctx;
 } CtxMsg;
 
 typedef struct LocMsg 
@@ -51,6 +46,10 @@ typedef struct FailMsg
 
   
 int pack (enum ck_msg_type type, char *buf, void *data);
-enum ck_msg_type upack (char *buf, void *data);
+int upack (char *buf, void *data, enum ck_msg_type *type);
+
+void ppack (int fdes, enum ck_msg_type type, void *data);
+TestResult *punpack(int fdes);
+
 
 #endif /*CHECK_PACK_H */

diff --git a/check/tests/check_check_pack.c b/check/tests/check_check_pack.c
index 7fe33526181868cbae6327ce39ba855cab3eebce..b9d40140e4393c0d18d70b6709161c927824d04c 100644 (file)
--- a/check/tests/check_check_pack.c
+++ b/check/tests/check_check_pack.c
@@ -1,5 +1,6 @@
 #include <stdlib.h>
 #include <stdio.h>
+#include <unistd.h>
 
 #include <check.h>
 #include "check_magic.h"
@@ -19,7 +20,7 @@ START_TEST(test_pack_fmsg)
 
   pack (CK_MSG_FAIL, buf, fmsg);
   fmsg->msg = "";
-  type = upack (buf, fmsg);
+  upack (buf, fmsg, &type);
 
   fail_unless (type == CK_MSG_FAIL,
               "Bad type unpacked for FailMsg");
@@ -53,7 +54,7 @@ START_TEST(test_pack_loc)
   pack (CK_MSG_LOC, buf, lmsg);
   lmsg->file = "";
   lmsg->line = 0;
-  type = upack (buf, lmsg);
+  upack (buf, lmsg, &type);
 
   fail_unless (type == CK_MSG_LOC,
               "Bad type unpacked for LocMsg");
@@ -82,30 +83,29 @@ END_TEST
 
 START_TEST(test_pack_ctx)
 {
-  CtxMsg *cmsg;
+  CtxMsg cmsg;
   char *buf;
   enum ck_msg_type type;
+  int npk, nupk;
 
-  cmsg = emalloc (sizeof(CtxMsg));
   buf = emalloc (CK_MAXMSGBUF);
-  cmsg->ctx = CK_CTX_SETUP;
+  cmsg.ctx = CK_CTX_SETUP;
 
-  pack (CK_MSG_CTX, buf, cmsg);
-  cmsg->ctx = CK_CTX_TEARDOWN;
-  type = upack (buf, cmsg);
+  npk = pack (CK_MSG_CTX, buf, &cmsg);
+  cmsg.ctx = CK_CTX_TEARDOWN;
+  nupk = upack (buf, &cmsg, &type);
 
   fail_unless (type == CK_MSG_CTX,
               "Bad type unpacked for CtxMsg");
 
-  if (cmsg->ctx != CK_CTX_SETUP) {
+  if (cmsg.ctx != CK_CTX_SETUP) {
     char *errm = emalloc (CK_MAXMSG);
     snprintf(errm, CK_MAXMSG,
             "CtxMsg ctx got %d, expected %d",
-            cmsg->ctx, CK_CTX_SETUP);
+            cmsg.ctx, CK_CTX_SETUP);
     fail (errm);
   }
 
-  free (cmsg);
   free (buf);
     
 }
@@ -116,6 +116,7 @@ START_TEST(test_pack_len)
   CtxMsg cmsg;
   char *buf;
   int n = 0;
+  enum ck_msg_type type;
 
   buf = emalloc (CK_MAXMSGBUF);
   cmsg.ctx = CK_CTX_TEST;
@@ -124,7 +125,14 @@ START_TEST(test_pack_len)
 
   /* Value below may change with different implementations of pack */
   fail_unless (n == 4, "Return val from pack not correct");
-
+  n = 0;
+  n = upack(buf,&cmsg,&type);
+  if (n != 4) {
+    char *msg = emalloc (CK_MAXMSG);
+    snprintf(msg,CK_MAXMSG, "%d bytes read from upack, should be 4",n);
+    fail (msg);
+  }
+  
   free(buf);
 }
 END_TEST
@@ -148,11 +156,12 @@ START_TEST(test_pack_fail_limit)
   FailMsg fmsg;
   FailMsg *fmsgp = NULL;
   char *buf;
+  enum ck_msg_type type;
 
   buf = emalloc (CK_MAXMSGBUF);
   fmsg.msg = "";
   pack(CK_MSG_FAIL,buf,&fmsg);
-  (void) upack(buf,&fmsg);
+  upack(buf,&fmsg,&type);
   fail_unless (strcmp(fmsg.msg, "") == 0, "Empty string not handled properly");
   free(fmsg.msg);
   fmsg.msg = NULL;
@@ -166,12 +175,13 @@ START_TEST(test_pack_loc_limit)
   LocMsg lmsg;
   LocMsg *lmsgp = NULL;
   char *buf;
+  enum ck_msg_type type;
 
   buf = emalloc (CK_MAXMSGBUF);
   lmsg.file = "";
   lmsg.line = 0;
   pack(CK_MSG_LOC,buf,&lmsg);
-  (void) upack(buf,&lmsg);
+  upack(buf,&lmsg,&type);
   fail_unless (strcmp(lmsg.file, "") == 0,
               "Empty string not handled properly");
   free(lmsg.file);
@@ -181,6 +191,84 @@ START_TEST(test_pack_loc_limit)
 }
 END_TEST
 
+START_TEST(test_ppack)
+{
+  int filedes[2];
+  CtxMsg cmsg;
+  LocMsg lmsg;
+  FailMsg fmsg;
+  TestResult *tr;
+
+  cmsg.ctx = CK_CTX_TEST;
+  lmsg.file = "abc123.c";
+  lmsg.line = 10;
+  fmsg.msg = "oops";
+  pipe(filedes);
+  ppack(filedes[1],CK_MSG_CTX, &cmsg);
+  ppack(filedes[1],CK_MSG_LOC, &lmsg);
+  ppack(filedes[1],CK_MSG_FAIL, &fmsg);
+  close(filedes[1]);
+  tr = punpack(filedes[0]);
+
+  fail_unless (tr_ctx(tr) == CK_CTX_TEST,
+              "Bad rtype from ppunpack");
+  fail_unless (tr_lno(tr) == 10,
+              "Bad loc line number from ppunpack");
+  fail_unless (strcmp(tr_lfile(tr), "abc123.c") == 0,
+              "Bad loc filename from ppunpack");
+  fail_unless (strcmp(tr_msg(tr), "oops") == 0,
+              "Bad msg from ppunpack");
+
+  free(tr);
+}
+END_TEST
+
+START_TEST(test_ppack_noctx)
+{
+  int filedes[2];
+  LocMsg lmsg;
+  FailMsg fmsg;
+  TestResult *tr;
+
+  lmsg.file = "abc123.c";
+  lmsg.line = 10;
+  fmsg.msg = "oops";
+  pipe(filedes);
+  ppack(filedes[1],CK_MSG_LOC, &lmsg);
+  ppack(filedes[1],CK_MSG_FAIL, &fmsg);
+  close(filedes[1]);
+  tr = punpack(filedes[0]);
+
+  fail_unless (tr == NULL,
+              "Result should be NULL with no CTX");
+
+  if (tr != NULL)
+    free(tr);
+}
+END_TEST
+
+START_TEST(test_ppack_onlyctx)
+{
+  int filedes[2];
+  CtxMsg cmsg;
+  TestResult *tr;
+
+  cmsg.ctx = CK_CTX_SETUP;
+  pipe(filedes);
+  ppack(filedes[1],CK_MSG_CTX, &cmsg);
+  close(filedes[1]);
+  tr = punpack(filedes[0]);
+
+  fail_unless (tr_msg(tr) == NULL,
+              "Result message should be NULL with only CTX");
+  fail_unless (tr_lno(tr) == -1,
+              "Result loc line should be -1 with only CTX");
+
+  if (tr != NULL)
+    free(tr);
+}
+END_TEST
+
 Suite *make_pack_suite(void)
 {
 
@@ -197,6 +285,9 @@ Suite *make_pack_suite(void)
   tcase_add_test(tc_core, test_pack_loc);
   tcase_add_test(tc_core, test_pack_ctx);
   tcase_add_test(tc_core, test_pack_len);
+  tcase_add_test(tc_core, test_ppack);
+  tcase_add_test(tc_core, test_ppack_noctx);
+  tcase_add_test(tc_core, test_ppack_onlyctx);
   suite_add_tcase(s, tc_limit);
   tcase_add_test(tc_limit, test_pack_ctx_limit);
   tcase_add_test(tc_limit, test_pack_fail_limit);