Update unit tests

diff --git a/src/rtr/rtr.c b/src/rtr/rtr.c
index 2d6b790fb9d2d250e5b01295a29d799f588bd0a0..0ccea902bd763123df0a66279b72ee6b7f8d3917 100644 (file)
--- a/src/rtr/rtr.c
+++ b/src/rtr/rtr.c
@@ -399,8 +399,13 @@ handle_clients(void *arg)
 
                mutex_unlock(&lock);
 
+               pr_op_debug("RTR worker thread: Claimed client %s",
+                   client->addr);
+
                do {
                        if (!pdustream_parse(client, &reqs)) {
+                               pr_op_debug("RTR worker thread: %s errored.",
+                                   client->addr);
                                rtreqlist_clear(&reqs);
                                mutex_lock(&lock);
                                PS_DISABLE(client, CLAIMED);
@@ -409,6 +414,8 @@ handle_clients(void *arg)
                        }
 
                        if (TAILQ_EMPTY(&reqs.nodes)) {
+                               pr_op_debug("RTR worker thread: %s done.",
+                                   client->addr);
                                mutex_lock(&lock);
                                PS_DISABLE(client, CLAIMED);
                                break;

diff --git a/test/rtr/pdu_handler_test.c b/test/rtr/pdu_handler_test.c
index 73d46a7b658d606e474409e0af65a592f0f336db..46ad4be61782bc71f6b64da12651fd345d6fba9b 100644 (file)
--- a/test/rtr/pdu_handler_test.c
+++ b/test/rtr/pdu_handler_test.c
@@ -252,6 +252,12 @@ rcv_reset_query(void)
        struct rtr_request req = { 0 };
        unsigned char raw[8] = { 0 };
 
+       stream.fd = -1;
+       stream.flags = PSF_CLAIMED;
+       stream.rtr_version = -1;
+       stream.session = -1;
+       stream.start = stream.end = stream.buffer;
+
        req.fd = -1;
        req.stream = &stream;
        req.pdu.rtr_version = RTR_V2;
@@ -275,6 +281,12 @@ rcv_serial_query(uint16_t session, serial_t serial)
        struct rtr_request req = { 0 };
        unsigned char raw[12] = { 0 };
 
+       stream.fd = -1;
+       stream.flags = PSF_CLAIMED;
+       stream.rtr_version = -1;
+       stream.session = -1;
+       stream.start = stream.end = stream.buffer;
+
        req.fd = -1;
        req.pdu.rtr_version = RTR_V2;
        req.stream = &stream;

diff --git a/test/rtr/pdu_stream_test.c b/test/rtr/pdu_stream_test.c
index a4b4682732070240b9393e0719c70881d81aeca6..a921fc915094b7b1f66e6931cbf6a9fbb8ca70bd 100644 (file)
--- a/test/rtr/pdu_stream_test.c
+++ b/test/rtr/pdu_stream_test.c
@@ -81,19 +81,6 @@ START_TEST(test_pdu_header_from_stream)
 }
 END_TEST
 
-static struct rtr_request *
-pop_request(struct pdu_stream *stream)
-{
-       struct rtr_request *request;
-
-       request = TAILQ_FIRST(&stream->requests);
-       ck_assert_ptr_ne(NULL, request);
-       TAILQ_REMOVE(&stream->requests, request, lh);
-       stream->reqcount--;
-
-       return request;
-}
-
 START_TEST(test_serial_query_from_stream)
 {
        unsigned char input[] = {
@@ -103,15 +90,17 @@ START_TEST(test_serial_query_from_stream)
                14, 15, 16, 17,
        };
        struct pdu_stream *stream;
+       struct rtr_request_list reqs;
        struct rtr_request *request;
-       bool wakeup;
+
+       TAILQ_INIT(&reqs.nodes);
+       reqs.count = 0;
 
        stream = create_stream_fd(input, sizeof(input), RTR_V1);
-       wakeup = false;
-       ck_assert_uint_eq(false, pdustream_parse(stream, &wakeup));
-       ck_assert_int_eq(true, wakeup);
+       ck_assert_uint_eq(false, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(1u, reqs.count);
 
-       request = pop_request(stream);
+       request = rtreqlist_pop(&reqs);
        ck_assert_int_eq(stream->fd, request->fd);
        ck_assert_str_eq(stream->addr, request->client_addr);
        ck_assert_uint_eq(RTR_V1, request->pdu.rtr_version);
@@ -120,9 +109,10 @@ START_TEST(test_serial_query_from_stream)
        ck_assert_uint_eq(0x0708, request->pdu.obj.sq.session_id);
        ck_assert_uint_eq(12, request->pdu.raw.bytes_len);
        ck_assert(memcmp(input, request->pdu.raw.bytes, 12) == 0);
-       ck_assert_ptr_eq(NULL, TAILQ_NEXT(request, lh));
-
        rtreq_destroy(request);
+
+       ck_assert_ptr_eq(NULL, rtreqlist_pop(&reqs));
+
        pdustream_destroy(stream);
 }
 END_TEST
@@ -134,24 +124,27 @@ START_TEST(test_reset_query_from_stream)
                /* Garbage */ 18, 19,
        };
        struct pdu_stream *stream;
+       struct rtr_request_list reqs;
        struct rtr_request *request;
-       bool wakeup;
+
+       TAILQ_INIT(&reqs.nodes);
+       reqs.count = 0;
 
        stream = create_stream_fd(input, sizeof(input), RTR_V0);
-       wakeup = false;
-       ck_assert_uint_eq(false, pdustream_parse(stream, &wakeup));
-       ck_assert_int_eq(true, wakeup);
+       ck_assert_uint_eq(false, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(1u, reqs.count);
 
-       request = pop_request(stream);
+       request = rtreqlist_pop(&reqs);
        ck_assert_int_eq(stream->fd, request->fd);
        ck_assert_str_eq(stream->addr, request->client_addr);
        ck_assert_uint_eq(RTR_V0, request->pdu.rtr_version);
        ck_assert_uint_eq(PDU_TYPE_RESET_QUERY, request->pdu.type);
        ck_assert_uint_eq(8, request->pdu.raw.bytes_len);
        ck_assert(memcmp(input, request->pdu.raw.bytes, 8) == 0);
-       ck_assert_ptr_eq(NULL, TAILQ_NEXT(request, lh));
        rtreq_destroy(request);
 
+       ck_assert_ptr_eq(NULL, rtreqlist_pop(&reqs));
+
        pdustream_destroy(stream);
 }
 END_TEST
@@ -173,14 +166,16 @@ START_TEST(test_error_report_from_stream)
                1, 2, 3, 4,
        };
        struct pdu_stream *stream;
-       bool wakeup;
+       struct rtr_request_list reqs;
+
+       TAILQ_INIT(&reqs.nodes);
+       reqs.count = 0;
 
        stream = create_stream_fd(input, sizeof(input), RTR_V1);
-       wakeup = false;
-       ck_assert_uint_eq(false, pdustream_parse(stream, &wakeup));
+       ck_assert_uint_eq(false, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(0, reqs.count);
 
-       ck_assert_int_eq(false, wakeup);
-       ck_assert_ptr_eq(NULL, TAILQ_FIRST(&stream->requests));
+       ck_assert_ptr_eq(NULL, rtreqlist_pop(&reqs));
 
        pdustream_destroy(stream);
 }
@@ -209,10 +204,13 @@ START_TEST(test_multiple_pdus)
                /* reset query */       1, 2, 6, 7, 0, 0, 0, 8,
        };
        struct pdu_stream *stream;
+       struct rtr_request_list reqs;
        struct rtr_request *request;
-       bool wakeup;
        int pipes[2];
 
+       TAILQ_INIT(&reqs.nodes);
+       reqs.count = 0;
+
        setup_pipes(pipes);
 
        stream = pdustream_create(pipes[0], "192.0.2.1");
@@ -220,11 +218,10 @@ START_TEST(test_multiple_pdus)
        /* Input 1 */
 
        ck_assert_int_eq(32, write(pipes[1], input1, sizeof(input1)));
-       wakeup = false;
-       ck_assert_uint_eq(true, pdustream_parse(stream, &wakeup));
-       ck_assert_int_eq(true, wakeup);
+       ck_assert_uint_eq(true, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(3u, reqs.count);
 
-       request = pop_request(stream);
+       request = rtreqlist_pop(&reqs);
        ck_assert_int_eq(stream->fd, request->fd);
        ck_assert_str_eq(stream->addr, request->client_addr);
        ASSERT_RQ(request, RTR_V1);
@@ -232,7 +229,7 @@ START_TEST(test_multiple_pdus)
        ck_assert(memcmp(input1, request->pdu.raw.bytes, 8) == 0);
        rtreq_destroy(request);
 
-       request = pop_request(stream);
+       request = rtreqlist_pop(&reqs);
        ck_assert_int_eq(stream->fd, request->fd);
        ck_assert_str_eq(stream->addr, request->client_addr);
        ASSERT_SQ(request, RTR_V1, 0x0607, 0x01020304);
@@ -240,23 +237,23 @@ START_TEST(test_multiple_pdus)
        ck_assert(memcmp(input1 + 8, request->pdu.raw.bytes, 12) == 0);
        rtreq_destroy(request);
 
-       request = pop_request(stream);
+       request = rtreqlist_pop(&reqs);
        ck_assert_int_eq(stream->fd, request->fd);
        ck_assert_str_eq(stream->addr, request->client_addr);
        ASSERT_RQ(request, RTR_V1);
        ck_assert_uint_eq(8, request->pdu.raw.bytes_len);
        ck_assert(memcmp(input1 + 20, request->pdu.raw.bytes, 8) == 0);
-       ck_assert_ptr_eq(NULL, TAILQ_NEXT(request, lh));
        rtreq_destroy(request);
 
+       ck_assert_ptr_eq(NULL, rtreqlist_pop(&reqs));
+
        /* Input 2 */
 
        ck_assert_int_eq(12, write(pipes[1], input2, sizeof(input2)));
-       wakeup = false;
-       ck_assert_uint_eq(true, pdustream_parse(stream, &wakeup));
-       ck_assert_int_eq(true, wakeup);
+       ck_assert_uint_eq(true, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(2u, reqs.count);
 
-       request = pop_request(stream);
+       request = rtreqlist_pop(&reqs);
        ck_assert_int_eq(stream->fd, request->fd);
        ck_assert_str_eq(stream->addr, request->client_addr);
        ASSERT_RQ(request, RTR_V1);
@@ -264,22 +261,22 @@ START_TEST(test_multiple_pdus)
        ck_assert(memcmp(input1 + 20,  request->pdu.raw.bytes, 8) == 0);
        rtreq_destroy(request);
 
-       request = pop_request(stream);
+       request = rtreqlist_pop(&reqs);
        ck_assert_int_eq(stream->fd, request->fd);
        ck_assert_str_eq(stream->addr, request->client_addr);
        ASSERT_RQ(request, RTR_V1);
        ck_assert_uint_eq(8, request->pdu.raw.bytes_len);
        ck_assert(memcmp(input2 + 4, request->pdu.raw.bytes, 8) == 0);
-       ck_assert_ptr_eq(NULL, TAILQ_NEXT(request, lh));
        rtreq_destroy(request);
 
+       ck_assert_ptr_eq(NULL, rtreqlist_pop(&reqs));
+
        /* Input 3 */
 
        close(pipes[1]);
-       wakeup = false;
-       ck_assert_uint_eq(false, pdustream_parse(stream, &wakeup));
-       ck_assert_int_eq(false, wakeup);
-       ck_assert_ptr_eq(NULL, TAILQ_FIRST(&stream->requests));
+       ck_assert_uint_eq(false, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(0, reqs.count);
+       ck_assert_ptr_eq(NULL, rtreqlist_pop(&reqs));
 
        /* Clean up */
 
@@ -290,13 +287,11 @@ END_TEST
 static unsigned char reset_query[] = { 1, 2, 0, 0, 0, 0, 0, 8, };
 
 static void
-ck_one_reset_query(struct pdu_stream *stream)
+ck_one_reset_query(struct rtr_request_list *list)
 {
        struct rtr_request *request;
 
-       request = pop_request(stream);
-       ck_assert_int_eq(stream->fd, request->fd);
-       ck_assert_str_eq(stream->addr, request->client_addr);
+       request = rtreqlist_pop(list);
        ASSERT_RQ(request, RTR_V1);
        ck_assert_uint_eq(8, request->pdu.raw.bytes_len);
        ck_assert(memcmp(reset_query, request->pdu.raw.bytes, 8) == 0);
@@ -306,10 +301,13 @@ ck_one_reset_query(struct pdu_stream *stream)
 START_TEST(test_too_many_pdus)
 {
        struct pdu_stream *stream;
+       struct rtr_request_list reqs;
        struct rtr_request *request;
-       bool wakeup;
        int pipes[2];
 
+       TAILQ_INIT(&reqs.nodes);
+       reqs.count = 0;
+
        setup_pipes(pipes);
 
        stream = pdustream_create(pipes[0], "192.0.2.1");
@@ -318,27 +316,25 @@ START_TEST(test_too_many_pdus)
        ck_assert_int_eq(8, write(pipes[1], reset_query, sizeof(reset_query)));
        ck_assert_int_eq(8, write(pipes[1], reset_query, sizeof(reset_query)));
        ck_assert_int_eq(8, write(pipes[1], reset_query, sizeof(reset_query)));
-       wakeup = false;
-       ck_assert_uint_eq(true, pdustream_parse(stream, &wakeup));
-       ck_assert_int_eq(true, wakeup);
+       ck_assert_uint_eq(true, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(4u, reqs.count);
 
-       ck_one_reset_query(stream);
+       ck_one_reset_query(&reqs);
+       ck_assert_uint_eq(3u, reqs.count);
 
        ck_assert_int_eq(8, write(pipes[1], reset_query, sizeof(reset_query)));
-       wakeup = false;
-       ck_assert_uint_eq(true, pdustream_parse(stream, &wakeup));
-       ck_assert_int_eq(true, wakeup);
+       ck_assert_uint_eq(true, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(4u, reqs.count);
 
        ck_assert_int_eq(8, write(pipes[1], reset_query, sizeof(reset_query)));
-       wakeup = false;
-       ck_assert_uint_eq(false, pdustream_parse(stream, &wakeup));
-       ck_assert_int_eq(false, wakeup);
+       ck_assert_uint_eq(false, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(4u, reqs.count);
 
-       ck_one_reset_query(stream);
-       ck_one_reset_query(stream);
-       ck_one_reset_query(stream);
-       ck_one_reset_query(stream);
-       ck_assert_ptr_eq(NULL, TAILQ_FIRST(&stream->requests));
+       ck_one_reset_query(&reqs);
+       ck_one_reset_query(&reqs);
+       ck_one_reset_query(&reqs);
+       ck_one_reset_query(&reqs);
+       ck_assert_ptr_eq(NULL, rtreqlist_pop(&reqs));
 
        close(pipes[1]);
        pdustream_destroy(stream);
@@ -349,15 +345,16 @@ START_TEST(test_interrupted)
 {
        unsigned char input[] = { 0, 1 };
        struct pdu_stream *stream;
-       bool wakeup;
+       struct rtr_request_list reqs;
+
+       TAILQ_INIT(&reqs.nodes);
+       reqs.count = 0;
 
        stream = create_stream_fd(input, sizeof(input), RTR_V1);
-       wakeup = false;
 
-       /* XXX WTF? */
-       ck_assert_uint_eq(false, pdustream_parse(stream, &wakeup));
-       ck_assert_int_eq(false, wakeup);
-       ck_assert_ptr_eq(NULL, TAILQ_FIRST(&stream->requests));
+       ck_assert_uint_eq(false, pdustream_parse(stream, &reqs));
+       ck_assert_uint_eq(0, reqs.count);
+       ck_assert_ptr_eq(NULL, rtreqlist_pop(&reqs));
 
        pdustream_destroy(stream);
 }