44079d5cbb
The lowest possible price from the price map will be the price each bidder has to pay. Since the seller can define the price map, he can set the lowest price to the lowest he is willing to sell one item at.
425 lines
11 KiB
C
425 lines
11 KiB
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;
|
|
}
|