/*
* Individual unit tests
*/
static void
attachversion(isc_assertioncallback_t callback) {
isc_result_t result;
dns_dbversion_t *v = NULL;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
isc_assertion_setcallback(callback);
dns_db_attachversion(db1, VERSION(callback), &v);
if (callback != NULL)
atf_tc_fail("dns_db_attachversion did not assert");
ATF_REQUIRE_EQ(v, v1);
dns_db_closeversion(db1, &v, ISC_FALSE);
ATF_REQUIRE_EQ(v, NULL);
close_db();
dns_test_end();
}
static void
addrdataset(isc_assertioncallback_t callback) {
isc_result_t result;
dns_rdataset_t rdataset;
dns_fixedname_t fixed;
dns_dbnode_t *node = NULL;
dns_rdatalist_t rdatalist;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
dns_rdataset_init(&rdataset);
dns_rdatalist_init(&rdatalist);
dns_fixedname_init(&fixed);
rdatalist.rdclass = dns_rdataclass_in;
result = dns_rdatalist_tordataset(&rdatalist, &rdataset);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_assertion_setcallback(callback);
result = dns_db_addrdataset(db1, node, VERSION(callback), 0, &rdataset,
0, NULL);
if (callback != NULL)
atf_tc_fail("dns_db_adddataset did not assert");
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
dns_db_detachnode(db1, &node);
ATF_REQUIRE_EQ(node, NULL);
close_db();
dns_test_end();
}
static void
resigned(isc_assertioncallback_t callback) {
isc_result_t result;
dns_rdataset_t rdataset, added;
dns_dbnode_t *node = NULL;
dns_rdatalist_t rdatalist;
dns_rdata_rrsig_t rrsig;
dns_rdata_t rdata = DNS_RDATA_INIT;
isc_buffer_t b;
unsigned char buf[1024];
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
/*
* Create a dummy RRSIG record and set a resigning time.
*/
dns_rdataset_init(&added);
dns_rdataset_init(&rdataset);
dns_rdatalist_init(&rdatalist);
isc_buffer_init(&b, buf, sizeof(buf));
DNS_RDATACOMMON_INIT(&rrsig, dns_rdatatype_rrsig, dns_rdataclass_in);
rrsig.covered = dns_rdatatype_a;
rrsig.algorithm = 100;
rrsig.labels = 0;
rrsig.originalttl = 0;
rrsig.timeexpire = 3600;
rrsig.timesigned = 0;
rrsig.keyid = 0;
dns_name_init(&rrsig.signer, NULL);
dns_name_clone(dns_rootname, &rrsig.signer);
rrsig.siglen = 0;
rrsig.signature = NULL;
result = dns_rdata_fromstruct(&rdata, dns_rdataclass_in,
dns_rdatatype_rrsig, &rrsig, &b);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
rdatalist.rdclass = dns_rdataclass_in;
rdatalist.type = dns_rdatatype_rrsig;
ISC_LIST_APPEND(rdatalist.rdata, &rdata, link);
result = dns_rdatalist_tordataset(&rdatalist, &rdataset);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
rdataset.attributes |= DNS_RDATASETATTR_RESIGN;
rdataset.resign = 7200;
result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = dns_db_addrdataset(db1, node, v1, 0, &rdataset, 0, &added);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
dns_db_detachnode(db1, &node);
ATF_REQUIRE_EQ(node, NULL);
isc_assertion_setcallback(callback);
dns_db_resigned(db1, &added, VERSION(callback));
if (callback != NULL)
atf_tc_fail("dns_db_resigned did not assert");
dns_rdataset_disassociate(&added);
close_db();
dns_test_end();
}
/*
* This subroutine is called during pass1 to create a directory info
* entry. During pass1, the passed-in parent is 0; it will get filled
* in during pass2.
*/
void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent)
{
struct dir_info_db *db;
struct dir_info *dir, ent, *old_array;
int i, j;
errcode_t retval;
unsigned long old_size;
#ifdef DIRINFO_DEBUG
printf("add_dir_info for inode (%lu, %lu)...\n", ino, parent);
#endif
if (!ctx->dir_info)
setup_db(ctx);
db = ctx->dir_info;
if (ctx->dir_info->count >= ctx->dir_info->size) {
old_size = ctx->dir_info->size * sizeof(struct dir_info);
ctx->dir_info->size += 10;
old_array = ctx->dir_info->array;
retval = ext2fs_resize_mem(old_size, ctx->dir_info->size *
sizeof(struct dir_info),
&ctx->dir_info->array);
if (retval) {
fprintf(stderr, "Couldn't reallocate dir_info "
"structure to %d entries\n",
ctx->dir_info->size);
fatal_error(ctx, 0);
ctx->dir_info->size -= 10;
return;
}
if (old_array != ctx->dir_info->array)
ctx->dir_info->last_lookup = NULL;
}
ent.ino = ino;
ent.parent = parent;
ent.dotdot = parent;
if (db->tdb) {
e2fsck_put_dir_info(ctx, &ent);
return;
}
/*
* Normally, add_dir_info is called with each inode in
* sequential order; but once in a while (like when pass 3
* needs to recreate the root directory or lost+found
* directory) it is called out of order. In those cases, we
* need to move the dir_info entries down to make room, since
* the dir_info array needs to be sorted by inode number for
* get_dir_info()'s sake.
*/
if (ctx->dir_info->count &&
ctx->dir_info->array[ctx->dir_info->count-1].ino >= ino) {
for (i = ctx->dir_info->count-1; i > 0; i--)
if (ctx->dir_info->array[i-1].ino < ino)
break;
dir = &ctx->dir_info->array[i];
if (dir->ino != ino)
for (j = ctx->dir_info->count++; j > i; j--)
ctx->dir_info->array[j] = ctx->dir_info->array[j-1];
} else
dir = &ctx->dir_info->array[ctx->dir_info->count++];
dir->ino = ino;
dir->dotdot = parent;
dir->parent = parent;
}
/**
* Main run function.
*
* @param cls NULL
* @param args arguments passed to GNUNET_PROGRAM_run
* @param cfgfile the path to configuration file
* @param cfg the configuration file handle
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *config)
{
const char *dbfile;
const char *topology_string;
unsigned int arg_uint1;
unsigned int arg_uint2;
const char *arg_str1;
const char *value;
unsigned int argc;
argc = 0;
arg_uint1 = 0; /* make compilers happy */
arg_uint2 = 0; /* make compilers happy */
if (NULL == args)
{
LOG_ERROR (_("Need at least 2 arguments\n"));
return;
}
if (NULL == (dbfile = args[argc++]))
{
LOG_ERROR (_("Database filename missing\n"));
return;
}
if (GNUNET_OK != setup_db (dbfile))
return;
if (NULL == (topology_string = args[argc++]))
{
LOG_ERROR (_("Topology string missing\n"));
return;
}
if (GNUNET_YES != GNUNET_TESTBED_topology_get_ (&topology, topology_string))
{
LOG_ERROR (_("Invalid topology: %s\n"), topology_string);
return;
}
arg_str1 = NULL;
/* parse for first TOPOOPT. This can either be arg_uint1 or arg_str1 */
switch (topology)
{
case GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI:
case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING:
case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD:
case GNUNET_TESTBED_TOPOLOGY_SCALE_FREE:
if (NULL == (value = args[argc++]))
{
LOG_ERROR (_("An argument is missing for given topology `%s'\n"),
topology_string);
return;
}
if (-1 == SSCANF (value, "%u", &arg_uint1))
{
LOG_ERROR (_("Invalid argument `%s' given as topology argument\n"),
value);
return;
}
break;
case GNUNET_TESTBED_TOPOLOGY_FROM_FILE:
if (NULL == (arg_str1 = args[argc++]))
{
LOG_ERROR (_("Filename argument missing for topology `%s'\n"),
topology_string);
return;
}
break;
default:
break;
}
/* parse for second TOPOOPT. Only required for SCALE_FREE topology */
switch (topology)
{
case GNUNET_TESTBED_TOPOLOGY_SCALE_FREE:
if (NULL == (value = args[argc++]))
{
LOG_ERROR (_("Second argument for topology `%s' is missing\n"),
topology_string);
return;
}
if (-1 == SSCANF (value, "%u", &arg_uint2))
{
LOG_ERROR (_("Invalid argument `%s'; expecting unsigned int\n"), value);
return;
}
break;
default:
break;
}
/* contruct topologies */
switch (topology)
{
case GNUNET_TESTBED_TOPOLOGY_LINE:
case GNUNET_TESTBED_TOPOLOGY_RING:
case GNUNET_TESTBED_TOPOLOGY_CLIQUE:
case GNUNET_TESTBED_TOPOLOGY_2D_TORUS:
GNUNET_TESTBED_underlay_construct_ (num_peers, link_processor, NULL,
topology);
break;
case GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI:
case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING:
case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD:
GNUNET_TESTBED_underlay_construct_ (num_peers, link_processor, NULL,
topology,
arg_uint1);
break;
case GNUNET_TESTBED_TOPOLOGY_FROM_FILE:
GNUNET_TESTBED_underlay_construct_ (num_peers, link_processor, NULL,
topology,
arg_str1);
break;
case GNUNET_TESTBED_TOPOLOGY_SCALE_FREE:
GNUNET_TESTBED_underlay_construct_ (num_peers, link_processor, NULL,
topology,
arg_uint1,
arg_uint2);
break;
default:
GNUNET_assert (0);
}
}
void MapDrawingArea::after_change()
{
setup_projection();
setup_db();
redraw_from_db();
}
END_TEST
//--------------------
START_TEST (test_iter_db)
{
GlyrQuery q;
setup (&q,GLYR_GET_LYRICS,10);
glyr_opt_artist (&q,"Equi");
glyr_opt_title (&q,"lala");
GlyrDatabase * db = setup_db();
GlyrQuery nugget;
setup (&nugget,GLYR_GET_COVERART,40);
glyr_opt_artist (&nugget,"A very special artist");
glyr_opt_album (&nugget,"A very special album");
GTimer * insert_time = g_timer_new();
const int N = 5000;
for (int i = 0; i < N; i++)
{
GlyrMemCache * ct = glyr_cache_new();
glyr_cache_set_data (ct,g_strdup_printf ("test# %d",i+1),-1);
ct->dsrc = g_strdup_printf ("Dummy url %d",i+1);
if (i % 2)
ct->rating = N ;
else
ct->rating = N ;
if (i % 23)
glyr_db_insert (db,&q,ct);
else
glyr_db_insert (db,&nugget,ct);
glyr_cache_free (ct);
}
g_timer_stop (insert_time);
g_message ("Used %.5f seconds to insert..",g_timer_elapsed (insert_time,NULL) );
/* Check if N items are in DB */
int cdb = count_db_items (db);
g_message ("Counted %d items",cdb);
fail_unless (cdb == N, NULL);
/* Test if case-insensitivity works */
glyr_opt_artist (&q,"eQuI");
glyr_opt_title (&q,"LALA");
float fine_grained = 0.0;
GTimer * grain_time = g_timer_new();
g_timer_start (insert_time);
GlyrMemCache * c, * ptr;
for (int i = 1; i <= N/10; i++)
{
g_timer_start (grain_time);
/* Get a list of the caches */
if (i % 10)
c = glyr_db_lookup (db,&q);
else
c = glyr_db_lookup (db,&nugget);
g_timer_stop (grain_time);
fine_grained += g_timer_elapsed (grain_time,NULL);
ptr = c;
fail_if (ptr == NULL);
int last_rating = INT_MAX;
int ctr = 0;
while (ptr)
{
ctr++;
fail_unless (last_rating >= ptr->rating);
last_rating = ptr->rating;
ptr = ptr->next;
}
glyr_free_list (c);
/* Test if we got exactly 10 or 42 items, (honoring number setting) */
if (i % 10)
fail_unless (ctr == 10);
else
fail_unless (ctr == 40);
}
g_timer_stop (insert_time);
g_message ("Used %.5f seconds to lookup..",g_timer_elapsed (insert_time,NULL) );
g_message ("Used %.5f for actual lookup..",fine_grained);
glyr_db_destroy (db);
glyr_query_destroy (&q);
glyr_query_destroy (&nugget);
g_timer_destroy (insert_time);
g_timer_destroy (grain_time);
}
