path: root/test_brandt.c

/* This file is part of libbrandt.
 * Copyright (C) 2016 GNUnet e.V.
 *
 * libbrandt is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * libbrandt is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * libbrandt.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * @file test_brandt.c
 * @brief testing API functions.
 * @author Markus Teich
 */

#include "platform.h"

#include <gnunet/gnunet_util_lib.h>

#include "brandt.h"
#include "crypto.h"
#include "util.h"

#define MIN(A, B) ((A) < (B) ? (A) : (B))

struct msg {
	uint16_t sender;
	uint16_t receiver;
	void     *buf;
	size_t   buf_len;
};

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 struct testcase tcase;


static struct BRANDT_Result *
expected_outcome (uint16_t i)
{
	struct BRANDT_Result *ret = NULL;
	int32_t              highest_bidder = -1;
	int32_t              highest_bid = -1;
	int32_t              mpf_highest_bidder;
	int32_t              mpf_highest_bid = -1;
	int32_t              prev_mpf_highest_bidder = -1;
	uint16_t             winners = MIN (tcase.m, tcase.n);
	uint16_t             cur_winner = 0;

	if (0 == tcase.n)
		return NULL;

	if (0 == tcase.m)
	{
		for (uint16_t h = 0; h < tcase.n; h++)
			if (tcase.bids[h] > highest_bid)
				highest_bid = tcase.bids[highest_bidder = h];

		if (!tcase.outcome_public && !(i == highest_bidder || i == tcase.n))
			return NULL;

		ret = GNUNET_new (struct BRANDT_Result);
		ret->bidder = highest_bidder;
		ret->price = highest_bid;
		ret->status = BRANDT_bidder_won;
		return ret;
	}

	/* fewer bidders than needed -> everyone wins with lowest price */
	if (tcase.n <= tcase.m)
	{
		if (tcase.outcome_public || i == tcase.n)
		{
			ret = GNUNET_new_array (tcase.n, struct BRANDT_Result);
			for (uint16_t h = 0; h < tcase.n; h++)
			{
				ret[h].bidder = h;
				ret[h].price = 0;
				ret[h].status = BRANDT_bidder_won;
			}
		}
		else
		{
			ret = GNUNET_new (struct BRANDT_Result);
			ret->bidder = i;
			ret->price = 0;
			ret->status = BRANDT_bidder_won;
		}
		return ret;
	}

	/* find M+1st highest bidder to determine selling price */
	for (uint16_t h = 0; h < tcase.n; h++)
		if (tcase.bids[h] > mpf_highest_bid)
			mpf_highest_bid = tcase.bids[prev_mpf_highest_bidder = h];
	for (uint16_t m = 0; m < MIN (tcase.m, tcase.n - 1); m++)
	{
		mpf_highest_bidder = -1;
		mpf_highest_bid = -1;
		for (uint16_t h = 0; h < tcase.n; h++)
		{
			if (tcase.bids[h] > mpf_highest_bid &&
			    (tcase.bids[h] < tcase.bids[prev_mpf_highest_bidder] ||
			     (tcase.bids[h] == tcase.bids[prev_mpf_highest_bidder] &&
			      h > prev_mpf_highest_bidder)))
			{
				mpf_highest_bid = tcase.bids[mpf_highest_bidder = h];
			}
		}
		prev_mpf_highest_bidder = mpf_highest_bidder;
	}

	/* for simplicity always locate the big block if we need to report at
	 * least one winner. with private outcome for losing bidders or winners
	 * only none or one element will be used respectively. */
	if (tcase.outcome_public || i == tcase.n ||
	    tcase.bids[i] > mpf_highest_bid ||
	    (tcase.bids[i] == mpf_highest_bid && i < mpf_highest_bidder))
		ret = GNUNET_new_array (winners, struct BRANDT_Result);

	/* report winners */
	for (uint16_t h = 0; h < tcase.n; h++)
	{
		if (((tcase.bids[h] == mpf_highest_bid && h < mpf_highest_bidder) ||
		     tcase.bids[h] > mpf_highest_bid) &&              /* h is a winner */
		    (tcase.outcome_public || i == h || i == tcase.n)) /* needs report */
		{
			if (cur_winner >= winners)
			{
				weprintf ("got too many winners");
				_exit (1);
			}
			ret[cur_winner].bidder = h;
			ret[cur_winner].price = mpf_highest_bid;
			ret[cur_winner].status = BRANDT_bidder_won;
			cur_winner++;
		}
	}
	return ret;
}


static void
bidder_start (void *arg)
{
	uint16_t i = *(uint16_t *)arg;

	weprintf ("starting bidder %d", i);
	BRANDT_bidder_start (tcase.ad[i], i, tcase.n);
}


static void
transfer_message (void *arg)
{
	struct msg      *m = (struct msg *)arg;
	struct msg_head *h = (struct msg_head *)m->buf;

	weprintf ("xfer msg %d %x from %d to %d", ntohl (
	              h->msg_type), arg, m->sender, m->receiver);
	BRANDT_got_message (tcase.ad[m->receiver], m->sender, m->buf, m->buf_len);
	GNUNET_free (m->buf);
	GNUNET_free (m);
}


static uint16_t
cb_start (void *auction_closure)
{
	uint16_t *s = (uint16_t *)auction_closure;

	if (tcase.n != *s)
	{
		weprintf ("start callback called from bidder");
		_exit (1);
	}

	for (uint16_t i = 0; i < tcase.n; i++)
		GNUNET_SCHEDULER_add_now (&bidder_start, &tcase.id[i]);

	return tcase.n;
}


static int
cb_broadcast (void       *auction_closure,
              const void *msg,
              size_t     msg_len)
{
	uint16_t   *s = (uint16_t *)auction_closure;
	struct msg *m;

	for (uint16_t i = 0; i <= tcase.n; i++)
	{
		if (i == *s)
			continue;
		m = GNUNET_new (struct msg);
		m->sender = *s;
		m->receiver = i;
		m->buf = GNUNET_new_array (msg_len, unsigned char);
		memcpy (m->buf, msg, msg_len);
		m->buf_len = msg_len;
		GNUNET_SCHEDULER_add_now (&transfer_message, m);
	}
	return 0;
}


static int
cb_unicast (void       *auction_closure,
            const void *msg,
            size_t     msg_len)
{
	uint16_t   *s = (uint16_t *)auction_closure;
	struct msg *m;

	m = GNUNET_new (struct msg);
	m->sender = *s;
	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;
	GNUNET_SCHEDULER_add_now (&transfer_message, m);

	return 0;
}


static void
cb_result (void                 *auction_closure,
           struct BRANDT_Result results[],
           uint16_t             results_len)
{
	uint16_t             *s = (uint16_t *)auction_closure;
	struct BRANDT_Result *must = expected_outcome (*s);

	if (0 == results_len)
	{
		weprintf ("expected result is: %p", must);
		weprintf ("computed result is: (nil) (by agent %d)", *s);

		if (NULL != must)
			tcase.ret = 1;
	}

	for (uint16_t i = 0; i < results_len; i++)
	{
		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 (by 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)
			tcase.ret = 1;
	}

	tcase.result_called[*s] = 1;
	if (must)
		GNUNET_free (must);
}


static void
run_auction (void *arg)
{
	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 < tcase.n; 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.");
			tcase.ret = 1;
			return;
		}

		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");
			tcase.ret = 1;
			return;
		}
	}
}


static int
test_auction (uint16_t n,
              uint16_t k,
              uint16_t *bids,
              uint16_t m,
              uint16_t outcome_public)
{
	tcase.n = n;
	tcase.k = k;
	tcase.bids = bids;
	tcase.m = m;
	tcase.outcome_public = outcome_public;
	tcase.ret = 0;

	weprintf ("######################################");
	weprintf ("testing %s auction with m = %d and %s outcome",
	          tcase.m > 0 ? "M+1ST PRICE" : "FIRST PRICE",
	          tcase.m,
	          tcase.outcome_public ? "PUBLIC" : "PRIVATE");
	/** \todo: output bids when migrating to GNUNET_log */
	weprintf ("######################################");
	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++)
	{
		BRANDT_destroy (tcase.ad[i]);
		if (!tcase.result_called[i])
		{
			weprintf ("result callback not called for bidder %d", i);
			tcase.ret = 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;
	struct GNUNET_CRYPTO_EccDlogContext *edc;

	edc = GNUNET_CRYPTO_ecc_dlog_prepare (1024, 16);
	BRANDT_init (edc);

	ret |= 0 ||
	       test_auction (0, 2, NULL, 0, 0) ||
	       test_auction (0, 2, NULL, 0, 1) ||
	       test_auction (0, 2, NULL, 1, 0) ||
	       test_auction (0, 2, NULL, 2, 0) ||
	       test_auction (1, 2, (uint16_t[]) { 1 }, 1, 0) ||
	       test_auction (1, 2, (uint16_t[]) { 0 }, 2, 0) ||
	       test_auction (2, 2, (uint16_t[]) { 1, 0 }, 2, 0) ||
	       test_auction (2, 2, (uint16_t[]) { 1, 0 }, 1, 0) ||
	       test_auction (3, 2, (uint16_t[]) { 0, 0, 1 }, 2, 0) ||
	       test_auction (3, 2, (uint16_t[]) { 0, 1, 1 }, 0, 0) ||
	       test_auction (3, 2, (uint16_t[]) { 0, 1, 1 }, 0, 1) ||
	       0;

	GNUNET_CRYPTO_ecc_dlog_release (edc);
	return ret;
}