ctdb-tests: Improve code coverage in tests

Signed-off-by: Amitay Isaacs <amitay@gmail.com>
Reviewed-by: Martin Schwenke <martin@meltin.net>

diff --git a/ctdb/tests/src/db_hash_test.c b/ctdb/tests/src/db_hash_test.c
index cc8a689dba81c872011041d3b9d1989aa92ced79..3627616313a3d264454438d5a8ff7024fc5d0699 100644 (file)
--- a/ctdb/tests/src/db_hash_test.c
+++ b/ctdb/tests/src/db_hash_test.c
@@ -23,13 +23,36 @@
 
 #include "common/db_hash.c"
 
+static int record_parser(uint8_t *keybuf, size_t keylen,
+                        uint8_t *databuf, size_t datalen,
+                        void *private_data)
+{
+       int *count = (int *)private_data;
+
+       (*count) += 1;
+       return 0;
+}
+
 static void do_test(enum db_hash_type type)
 {
-       struct db_hash_context *dh;
+       struct db_hash_context *dh = NULL;
        TALLOC_CTX *mem_ctx = talloc_new(NULL);
        uint8_t key[] = "This is a long key";
        uint8_t value[] = "This is a long value";
        int ret;
+       int count = 0;
+
+       ret = db_hash_insert(dh, key, sizeof(key), value, sizeof(value));
+       assert(ret == EINVAL);
+
+       ret = db_hash_add(dh, key, sizeof(key), value, sizeof(value));
+       assert(ret == EINVAL);
+
+       ret = db_hash_exists(dh, key, sizeof(key));
+       assert(ret == EINVAL);
+
+       ret = db_hash_delete(dh, key, sizeof(key));
+       assert(ret == EINVAL);
 
        ret = db_hash_init(mem_ctx, "foobar", 1024, type, &dh);
        assert(ret == 0);
@@ -40,6 +63,13 @@ static void do_test(enum db_hash_type type)
        ret = db_hash_exists(dh, key, sizeof(key));
        assert(ret == 0);
 
+       ret = db_hash_fetch(dh, key, sizeof(key), NULL, NULL);
+       assert(ret = EINVAL);
+
+       ret = db_hash_fetch(dh, key, sizeof(key), record_parser, &count);
+       assert(ret == 0);
+       assert(count == 1);
+
        ret = db_hash_insert(dh, key, sizeof(key), value, sizeof(value));
        assert(ret == EEXIST);
 
@@ -67,12 +97,15 @@ static void do_test(enum db_hash_type type)
 
 static void do_traverse_test(enum db_hash_type type)
 {
-       struct db_hash_context *dh;
+       struct db_hash_context *dh = NULL;
        TALLOC_CTX *mem_ctx = talloc_new(NULL);
        char key[] = "keyXXXX";
        char value[] = "This is some test value";
        int count, ret, i;
 
+       ret = db_hash_traverse(dh, NULL, NULL, &count);
+       assert(ret == EINVAL);
+
        ret = db_hash_init(mem_ctx, "foobar", 1024, type, &dh);
        assert(ret == 0);
 
@@ -87,6 +120,10 @@ static void do_traverse_test(enum db_hash_type type)
        assert(ret == 0);
        assert(count == 2000);
 
+       ret = db_hash_traverse(dh, record_parser, &count, NULL);
+       assert(ret == 0);
+       assert(count == 4000);
+
        talloc_free(dh);
        talloc_free(mem_ctx);
 }

diff --git a/ctdb/tests/src/pkt_read_test.c b/ctdb/tests/src/pkt_read_test.c
index 7e089ec2541d8dfc0f4ca64a16b18019b6dbe556..2e4d37934aaebda735d8c44b09230870e7e23db5 100644 (file)
--- a/ctdb/tests/src/pkt_read_test.c
+++ b/ctdb/tests/src/pkt_read_test.c
@@ -55,7 +55,8 @@ static void writer(int fd)
 struct reader_state {
        struct tevent_context *ev;
        int fd;
-       uint8_t buf[1024];
+       uint8_t *buf;
+       size_t buflen;
        struct tevent_req *subreq;
 };
 
@@ -64,7 +65,8 @@ static void reader_done(struct tevent_req *subreq);
 
 static struct tevent_req *reader_send(TALLOC_CTX *mem_ctx,
                                      struct tevent_context *ev,
-                                     int fd)
+                                     int fd, uint8_t *buf,
+                                     size_t buflen)
 {
        struct tevent_req *req, *subreq;
        struct reader_state *state;
@@ -76,9 +78,11 @@ static struct tevent_req *reader_send(TALLOC_CTX *mem_ctx,
 
        state->ev = ev;
        state->fd = fd;
+       state->buf = buf;
+       state->buflen = buflen;
 
        subreq = pkt_read_send(state, state->ev, state->fd, 4,
-                              state->buf, 1024, reader_more, NULL);
+                              state->buf, state->buflen, reader_more, NULL);
        if (tevent_req_nomem(subreq, req)) {
                tevent_req_post(req, ev);
        }
@@ -128,7 +132,7 @@ static void reader_done(struct tevent_req *subreq)
        }
 
        subreq = pkt_read_send(state, state->ev, state->fd, 4,
-                              state->buf, 1024, reader_more, NULL);
+                              state->buf, state->buflen, reader_more, NULL);
        if (tevent_req_nomem(subreq, req)) {
                return;
        }
@@ -167,13 +171,15 @@ static void reader_handler(struct tevent_context *ev, struct tevent_fd *fde,
        pkt_read_handler(ev, fde, flags, state->subreq);
 }
 
-static void reader(int fd)
+static void reader(int fd, bool fixed)
 {
        TALLOC_CTX *mem_ctx;
        struct tevent_context *ev;
        struct tevent_fd *fde;
        struct tevent_req *req;
        int err;
+       uint8_t *buf = NULL;
+       size_t buflen = 0;
 
        mem_ctx = talloc_new(NULL);
        assert(mem_ctx != NULL);
@@ -181,7 +187,13 @@ static void reader(int fd)
        ev = tevent_context_init(mem_ctx);
        assert(ev != NULL);
 
-       req = reader_send(mem_ctx, ev, fd);
+       if (fixed) {
+               buflen = 1024;
+               buf = talloc_size(mem_ctx, buflen);
+               assert(buf != NULL);
+       }
+
+       req = reader_send(mem_ctx, ev, fd, buf, buflen);
        assert(req != NULL);
 
        fde = tevent_add_fd(ev, mem_ctx, fd, TEVENT_FD_READ,
@@ -212,7 +224,7 @@ static bool set_nonblocking(int fd)
        return true;
 }
 
-int main(void)
+static void reader_test(bool fixed)
 {
        int fd[2];
        int ret;
@@ -236,7 +248,13 @@ int main(void)
                exit(1);
        }
 
-       reader(fd[0]);
+       reader(fd[0], fixed);
+}
+
+int main(void)
+{
+       reader_test(true);
+       reader_test(false);
 
        return 0;
 }

diff --git a/ctdb/tests/src/srvid_test.c b/ctdb/tests/src/srvid_test.c
index f5e94ac3d036b5d94842973a4b3a39c11df89d5c..b979c19c2f58b11f501130b3747104e9138907b7 100644 (file)
--- a/ctdb/tests/src/srvid_test.c
+++ b/ctdb/tests/src/srvid_test.c
@@ -24,7 +24,7 @@
 #include "common/db_hash.c"
 #include "common/srvid.c"
 
-#define TEST_SRVID     0xFE11223344556677
+#define TEST_SRVID     0xBE11223344556677
 
 static void test_handler(uint64_t srvid, TDB_DATA data, void *private_data)
 {
@@ -34,15 +34,21 @@ static void test_handler(uint64_t srvid, TDB_DATA data, void *private_data)
 
 int main(void)
 {
-       struct srvid_context *srv;
+       struct srvid_context *srv = NULL;
        TALLOC_CTX *mem_ctx = talloc_new(NULL);
        TALLOC_CTX *tmp_ctx = talloc_new(NULL);
        int ret;
        int count = 0;
 
+       ret = srvid_register(srv, tmp_ctx, TEST_SRVID, test_handler, &count);
+       assert(ret == EINVAL);
+
        ret = srvid_init(mem_ctx, &srv);
        assert(ret == 0);
 
+       ret = srvid_deregister(srv, TEST_SRVID, &count);
+       assert(ret == ENOENT);
+
        ret = srvid_register(srv, tmp_ctx, TEST_SRVID, test_handler, &count);
        assert(ret == 0);
 
@@ -53,6 +59,10 @@ int main(void)
        assert(ret == 0);
        assert(count == 1);
 
+       ret = srvid_dispatch(srv, 0, TEST_SRVID, tdb_null);
+       assert(ret == 0);
+       assert(count == 2);
+
        ret = srvid_deregister(srv, TEST_SRVID, NULL);
        assert(ret == ENOENT);
 
@@ -69,8 +79,17 @@ int main(void)
        ret = srvid_dispatch(srv, TEST_SRVID, 0, tdb_null);
        assert(ret == ENOENT);
 
+       tmp_ctx = talloc_new(NULL);
+       assert(tmp_ctx != NULL);
+
+       ret = srvid_register(srv, tmp_ctx, TEST_SRVID, test_handler, NULL);
+       assert(ret == 0);
+       ret = srvid_register(srv, tmp_ctx, TEST_SRVID, test_handler, &count);
+       assert(ret == 0);
+
        talloc_free(srv);
        assert(talloc_get_size(mem_ctx) == 0);
+       assert(talloc_get_size(tmp_ctx) == 0);
 
        talloc_free(mem_ctx);