From: amalec Date: Thu, 4 Oct 2001 21:55:29 +0000 (+0000) Subject: Completed implementation of check_pack X-Git-Tag: 0.10.0~1049 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=d8c2b72f37f1efb5d23d8dd7d0c353acc430b46d;p=check 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 b204c9a..000ee9c 100644 --- 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 b434214..e5acd36 100644 --- 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 4387540..0286726 100644 --- 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 7bb0904..edffc3f 100644 --- a/check/src/check_pack.c +++ b/check/src/check_pack.c @@ -19,10 +19,14 @@ #include #include #include +#include +#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 02fffb7..6f00793 100644 --- 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 7fe3352..b9d4014 100644 --- a/check/tests/check_check_pack.c +++ b/check/tests/check_check_pack.c @@ -1,5 +1,6 @@ #include #include +#include #include #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);