void test_set_remove (void) {
Set* set;
char buf[10];
int i;
unsigned int num_entries;
set = generate_set();
num_entries = set_num_entries (set);
assert (num_entries == 10000);
/* Remove some entries */
for (i = 4000; i < 6000; ++i) {
sprintf (buf, "%i", i);
/* Check this is in the set */
assert (set_query (set, buf) != 0);
/* Remove it */
assert (set_remove (set, buf) != 0);
/* Check the number of entries decreases */
assert (set_num_entries (set) == num_entries - 1);
/* Check it is no longer in the set */
assert (set_query (set, buf) == 0);
--num_entries;
}
/* Try to remove some invalid entries */
for (i = -1000; i < -500; ++i) {
sprintf (buf, "%i", i);
assert (set_remove (set, buf) == 0);
assert (set_num_entries (set) == num_entries);
}
for (i = 50000; i < 51000; ++i) {
sprintf (buf, "%i", i);
assert (set_remove (set, buf) == 0);
assert (set_num_entries (set) == num_entries);
}
set_free (set);
}
struct set *generate_sets(struct passed_args *args) {
/*
Function to generate all cache sets
*/
int number_of_sets = get_number_of_sets(args->set_index_bits_num);
struct set *sets = malloc(number_of_sets * sizeof(struct set));
int i = 0;
for (i = 0; i < number_of_sets; i++) {
generate_set(args, &sets[i], i);
}
return sets;
}
int generate_code_file(struct TestSet *set, FILE *file_out)
{
// set file-wide out file pointer
fout = file_out;
// XXX look for this file and emit it if not present
fputs(module_code, fout);
int set_i = 0;
if (generate_set(set, &set_i))
return -1;
set_i = 0;
generate_main(set, &set_i);
return 0;
}
static int generate_set(struct TestSet *set, int *set_i)
{
int test_i;
if (set->next)
generate_set(set->next, set_i);
tolerance = (set->tolerance > 0.0) ? set->tolerance : DEFAULT_TOLERANCE;
(*set_i)++;
fprintf(fout, "subroutine funit_set%i\n", *set_i);
fputs(" use funit\n", fout);
if (set->mods)
print_use(set->mods);
fputs("\n", fout);
fputs(" implicit none\n\n", fout);
fputs(" character*1024 :: funit_message_\n", fout);
fputs(" logical :: funit_passed_\n\n", fout);
if (set->code)
generate_code(set->code);
if (set->tests) {
size_t max_name = max_test_name_width(set->tests);
test_i = 0;
generate_test_call(set, set->tests, &test_i, max_name);
}
fputs("contains\n\n", fout);
if (set->setup)
generate_support(set->setup, "setup");
if (set->teardown)
generate_support(set->setup, "teardown");
if (set->tests) {
test_i = 0;
if (generate_test(set->tests, &test_i))
return -1;
}
fprintf(fout, "end subroutine funit_set%i\n", *set_i);
return 0;
}
void test_set_query (void) {
Set* set;
char buf[10];
int i;
set = generate_set();
/* Test all values */
for (i = 0; i < 10000; ++i) {
sprintf (buf, "%i", i);
assert (set_query (set, buf) != 0);
}
/* Test invalid values returning zero */
assert (set_query (set, "-1") == 0);
assert (set_query (set, "100001") == 0);
set_free (set);
}
void test_set_iterating_remove (void) {
Set* set;
SetIterator iterator;
int count;
unsigned int removed;
char* value;
set = generate_set();
count = 0;
removed = 0;
/* Iterate over all values in the set */
set_iterate (set, &iterator);
while (set_iter_has_more (&iterator)) {
value = set_iter_next (&iterator);
if ( (atoi (value) % 100) == 0) {
/* Remove this value */
set_remove (set, value);
++removed;
}
++count;
}
/* Check final counts */
assert (count == 10000);
assert (removed == 100);
assert (set_num_entries (set) == 10000 - removed);
set_free (set);
}
void test_set_iterating (void) {
Set* set;
SetIterator iterator;
int count;
set = generate_set();
/* Iterate over all values in the set */
count = 0;
set_iterate (set, &iterator);
while (set_iter_has_more (&iterator)) {
set_iter_next (&iterator);
++count;
}
/* Test iter_next after iteration has completed. */
assert (set_iter_next (&iterator) == NULL);
/* Check final count */
assert (count == 10000);
set_free (set);
/* Test iterating over an empty set */
set = set_new (int_hash, int_equal);
set_iterate (set, &iterator);
assert (set_iter_has_more (&iterator) == 0);
set_free (set);
}
