rework test_brandt

1 files changed, 117 insertions, 120 deletions

diff --git a/test_brandt.c b/test_brandt.c
index a386124..ee53a0d 100644
--- a/test_brandt.c
+++ b/test_brandt.c
@@ -36,42 +36,39 @@ struct msg {
         size_t   buf_len;
 };
 
-
-struct test {
-        uint16_t ret;
-        uint16_t m;
-        uint16_t outcome_public;
+struct testcase {
+        uint16_t              n;
+        uint16_t              k;
+        uint16_t              *bids;
+        uint16_t              m;
+        uint16_t              outcome_public;
+        uint16_t              ret;
+        struct BRANDT_Auction **ad;
+        uint16_t              *id;
+        uint16_t              *result_called;
 };
 
 
-static uint16_t              *id;
-static uint16_t              *result_called;
-static struct BRANDT_Auction **ad;
-static uint16_t              unexpected_result;
-
-/* TEST CONFIGURATION */
-static const uint16_t bidders = 4;
-static const uint16_t prizes = 3;
-static const uint16_t bids[] = { 1, 2, 0, 2 };
+static struct testcase tcase;
 
 
 static struct BRANDT_Result *
-expected_outcome (uint16_t m, uint16_t outcome_public, uint16_t i)
+expected_outcome (uint16_t i)
 {
         int32_t              highest_bidder = -1;
         int32_t              highest_bid = -1;
         struct BRANDT_Result *ret;
 
-        for (uint16_t i = 0; i < bidders; i++)
+        for (uint16_t h = 0; h < tcase.n; h++)
         {
-                if (bids[i] > highest_bid)
+                if (tcase.bids[h] > highest_bid)
                 {
-                        highest_bid = bids[i];
-                        highest_bidder = i;
+                        highest_bid = tcase.bids[h];
+                        highest_bidder = h;
                 }
         }
 
-        if (!outcome_public && !(i == highest_bidder || i == bidders))
+        if (!tcase.outcome_public && !(i == highest_bidder || i == tcase.n))
                 return NULL;
 
         ret = GNUNET_new (struct BRANDT_Result);
@@ -88,7 +85,7 @@ bidder_start (void *arg)
         uint16_t i = *(uint16_t *)arg;
 
         weprintf ("starting bidder %d", i);
-        BRANDT_bidder_start (ad[i], i, bidders);
+        BRANDT_bidder_start (tcase.ad[i], i, tcase.n);
 }
 
 
@@ -100,8 +97,9 @@ transfer_message (void *arg)
 
         weprintf ("xfer msg %d %x from %d to %d", ntohl (
                       h->msg_type), arg, m->sender, m->receiver);
-        BRANDT_got_message (ad[m->receiver], m->sender, m->buf, m->buf_len);
-        free (arg);
+        BRANDT_got_message (tcase.ad[m->receiver], m->sender, m->buf, m->buf_len);
+        GNUNET_free (m->buf);
+        GNUNET_free (m);
 }
 
 
@@ -110,16 +108,16 @@ cb_start (void *auction_closure)
 {
         uint16_t *s = (uint16_t *)auction_closure;
 
-        if (!s || bidders != *s)
+        if (tcase.n != *s)
         {
                 weprintf ("start callback called from bidder");
                 _exit (1);
         }
 
-        for (uint16_t i = 0; i < bidders; i++)
-                GNUNET_SCHEDULER_add_now (&bidder_start, &id[i]);
+        for (uint16_t i = 0; i < tcase.n; i++)
+                GNUNET_SCHEDULER_add_now (&bidder_start, &tcase.id[i]);
 
-        return bidders;
+        return tcase.n;
 }
 
 
@@ -131,7 +129,7 @@ cb_broadcast (void       *auction_closure,
         uint16_t   *s = (uint16_t *)auction_closure;
         struct msg *m;
 
-        for (uint16_t i = 0; i <= bidders; i++)
+        for (uint16_t i = 0; i <= tcase.n; i++)
         {
                 if (i == *s)
                         continue;
@@ -157,7 +155,7 @@ cb_unicast (void       *auction_closure,
 
         m = GNUNET_new (struct msg);
         m->sender = *s;
-        m->receiver = bidders; /* == seller */
+        m->receiver = tcase.n; /* == seller */
         m->buf = GNUNET_new_array (msg_len, unsigned char);
         memcpy (m->buf, msg, msg_len);
         m->buf_len = msg_len;
@@ -173,157 +171,156 @@ cb_result (void                 *auction_closure,
            uint16_t             results_len)
 {
         uint16_t             *s = (uint16_t *)auction_closure;
-        struct BRANDT_Result *must = expected_outcome (ad[*s]->m,
-                                                       ad[*s]->outcome_public,
-                                                       *s);
+        struct BRANDT_Result *must = expected_outcome (*s);
 
         if (0 == results_len)
         {
-                weprintf ("result from agent %d: %p", *s, must);
-                weprintf ("expected result is: (nil)");
+                weprintf ("expected result is: %p", must);
+                weprintf ("computed result is: (nil) (from agent %d)", *s);
 
                 if (NULL != must)
-                        unexpected_result = 1;
+                        tcase.ret = 1;
         }
 
         for (uint16_t i = 0; i < results_len; i++)
         {
-                weprintf ("result from agent %d: bidder %d got status %d with price %d",
-                          *s,
-                          results[i].bidder,
-                          results[i].status,
-                          results[i].price);
                 weprintf ("expected result is: bidder %d got status %d with price %d",
                           must[i].bidder,
                           must[i].status,
                           must[i].price);
+                weprintf (
+                    "computed result is: bidder %d got status %d with price %d (from agent %d)",
+                    results[i].bidder,
+                    results[i].status,
+                    results[i].price,
+                    *s);
 
                 if (NULL == must ||
                     must[i].bidder != results[i].bidder ||
                     must[i].status != results[i].status ||
                     must[i].price != results[i].price)
-                        unexpected_result = 1;
+                        tcase.ret = 1;
         }
-        result_called[*s] = 1;
+
+        tcase.result_called[*s] = 1;
+        if (must)
+                GNUNET_free (must);
 }
 
 
 static void
 run_auction (void *arg)
 {
-        struct test *asetup = arg;
-        const char  description[] = "test description for test_auctions";
-        void        *desc;
-        size_t      desc_len;
-
-        ad = GNUNET_new_array (bidders + 1, struct BRANDT_Auction *);
-
-        ad[bidders] = BRANDT_new (&cb_result,
-                                  &cb_broadcast,
-                                  &cb_start,
-                                  &id[bidders],
-                                  &desc,
-                                  &desc_len,
-                                  description,
-                                  sizeof (description),
-                                  GNUNET_TIME_absolute_get (),
-                                  GNUNET_TIME_UNIT_MINUTES,
-                                  prizes,                    /* number of prizes */
-                                  asetup->m,                 /* m */
-                                  asetup->outcome_public);   /* outcome public */
-        if (!ad[bidders])
+        const char description[] = "test description for test_auction";
+        void       *desc;
+        size_t     desc_len;
+
+        tcase.ad[tcase.n] = BRANDT_new (&cb_result,
+                                        &cb_broadcast,
+                                        &cb_start,
+                                        &tcase.id[tcase.n],
+                                        &desc,
+                                        &desc_len,
+                                        description,
+                                        sizeof (description),
+                                        GNUNET_TIME_absolute_get (),
+                                        GNUNET_TIME_UNIT_MINUTES,
+                                        tcase.k,               /* number of prizes */
+                                        tcase.m,               /* m */
+                                        tcase.outcome_public); /* outcome public */
+        if (!tcase.ad[tcase.n])
         {
                 weprintf ("BRANDT_new() failed.");
                 _exit (1);
         }
 
-        for (uint16_t i = 0; i < bidders; i++)
+        for (uint16_t i = 0; i < tcase.n; i++)
         {
-                ad[i] = BRANDT_join (&cb_result,
-                                     &cb_broadcast,
-                                     &cb_unicast,
-                                     &id[i],
-                                     desc,
-                                     desc_len,
-                                     description,
-                                     sizeof (description),
-                                     bids[i]);      /* bid */
-                if (!ad[i])
+                tcase.ad[i] = BRANDT_join (&cb_result,
+                                           &cb_broadcast,
+                                           &cb_unicast,
+                                           &tcase.id[i],
+                                           desc,
+                                           desc_len,
+                                           description,
+                                           sizeof (description),
+                                           tcase.bids[i]); /* bid */
+                if (!tcase.ad[i])
                 {
                         weprintf ("BRANDT_join() failed.");
-                        _exit (1);
+                        tcase.ret = 1;
+                        return;
                 }
 
-                if (ad[bidders]->k != ad[i]->k ||
-                    ad[bidders]->m != ad[i]->m ||
-                    ad[bidders]->outcome_public != ad[i]->outcome_public ||
-                    ad[bidders]->time_start.abs_value_us
-                    != ad[i]->time_start.abs_value_us ||
-                    ad[bidders]->time_round.rel_value_us
-                    != ad[i]->time_round.rel_value_us ||
-                    !ad[bidders]->seller_mode || /* todo: split out */
-                    ad[i]->seller_mode)
+                if (tcase.ad[tcase.n]->k != tcase.ad[i]->k ||
+                    tcase.ad[tcase.n]->m != tcase.ad[i]->m ||
+                    tcase.ad[tcase.n]->outcome_public != tcase.ad[i]->outcome_public ||
+                    tcase.ad[tcase.n]->time_start.abs_value_us
+                    != tcase.ad[i]->time_start.abs_value_us ||
+                    tcase.ad[tcase.n]->time_round.rel_value_us
+                    != tcase.ad[i]->time_round.rel_value_us ||
+                    !tcase.ad[tcase.n]->seller_mode || /* todo: split out */
+                    tcase.ad[i]->seller_mode)
                 {
                         weprintf ("error/mismatch in basic auction data");
-                        _exit (1);
+                        tcase.ret = 1;
+                        return;
                 }
         }
 }
 
 
 static int
-test_auctions ()
+test_auction (uint16_t n,
+              uint16_t k,
+              uint16_t *bids,
+              uint16_t m,
+              uint16_t outcome_public)
 {
-        id = GNUNET_new_array (bidders + 1, uint16_t);
-        for (uint16_t i = 0; i <= bidders; i++)
-                id[i] = i;
-
-        for (size_t atype = 0; atype < auction_last; atype++)
+        tcase.n = n;
+        tcase.k = k;
+        tcase.bids = bids;
+        tcase.m = m;
+        tcase.outcome_public = outcome_public;
+        tcase.ret = 0;
+
+        tcase.ad = GNUNET_new_array (tcase.n + 1, struct BRANDT_Auction *);
+        tcase.id = GNUNET_new_array (tcase.n + 1, uint16_t);
+        for (uint16_t i = 0; i <= tcase.n; i++)
+                tcase.id[i] = i;
+        tcase.result_called = GNUNET_new_array (tcase.n + 1, uint16_t);
+
+        GNUNET_SCHEDULER_run (&run_auction, NULL);
+
+        for (uint16_t i = 0; i <= tcase.n; i++)
         {
-                if (auction_firstPrice != atype) /* others not yet implemented */
-                        continue;
-
-                for (size_t oc = 0; oc < outcome_last; oc++)
+                BRANDT_destroy (tcase.ad[i]);
+                if (!tcase.result_called[i])
                 {
-                        struct test asetup;
-
-                        result_called = GNUNET_new_array (bidders + 1, uint16_t);
-                        unexpected_result = 0;
-                        asetup.ret = 0;
-                        asetup.m = atype;
-                        asetup.outcome_public = oc;
-                        GNUNET_SCHEDULER_run (&run_auction, &asetup);
-
-                        for (uint16_t i = 0; i <= bidders; i++)
-                        {
-                                BRANDT_destroy (ad[i]);
-                                if (!result_called[i])
-                                {
-                                        weprintf ("result callback not called for bidder %d", i);
-                                        unexpected_result = 1;
-                                }
-                        }
-
-                        if (unexpected_result)
-                                return 0;
+                        weprintf ("result callback not called for bidder %d", i);
+                        tcase.ret = 1;
                 }
         }
 
-        return 1;
+        GNUNET_free (tcase.ad);
+        GNUNET_free (tcase.id);
+        GNUNET_free (tcase.result_called);
+
+        return tcase.ret;
 }
 
 
 int
 main (int argc, char *argv[])
 {
-        int ret = 0;
+        int                                 ret = 0;
         struct GNUNET_CRYPTO_EccDlogContext *edc;
 
         edc = GNUNET_CRYPTO_ecc_dlog_prepare (1024, 16);
         BRANDT_init (edc);
 
-        if (!test_auctions())
-                ret = 1;
+        ret |= test_auction (4, 3, (uint16_t[]) { 1, 2, 0, 2 }, 0, 1) ||
+               test_auction (4, 3, (uint16_t[]) { 1, 2, 0, 2 }, 0, 0);
 
         GNUNET_CRYPTO_ecc_dlog_release (edc);
         return ret;