static void test_equal(struct cag_test_series *tests)
{
complex_array l1, l2;
new_complex_array(&l1);
new_complex_array(&l2);
CAG_TEST(*tests,
equal_range_complex_array(beg_complex_array(&l1),
end_complex_array(&l1),
beg_complex_array(&l2)) == CAG_TRUE,
"cag_array: equal empty arrays");
populate_array(&l1, 0, 5, 1);
populate_array(&l2, 0, 5, 1);
CAG_TEST(*tests,
equal_range_complex_array(beg_complex_array(&l1),
end_complex_array(&l1),
beg_complex_array(&l2)) == CAG_TRUE,
"cag_array: equal arrays");
CAG_TEST(*tests, equal_all_complex_array(&l1, &l2) == CAG_TRUE,
"cag_array: equal all arrays");
at_complex_array(beg_complex_array(&l1), 3)->value.real = 10;
at_complex_array(beg_complex_array(&l1), 3)->value.imag = 20;
CAG_TEST(*tests,
equal_range_complex_array(beg_complex_array(&l1),
end_complex_array(&l1),
beg_complex_array(&l2))
== CAG_FALSE,
"cag_array: unequal arrays");
CAG_TEST(*tests, equal_all_complex_array(&l1, &l2) == CAG_FALSE,
"cag_array: unequal all arrays");
free_complex_array(&l1);
free_complex_array(&l2);
}
static void test_copy_over(struct cag_test_series *tests)
{
complex_array a, b;
it_complex_array it1, it2;
CAG_CHECKL(new_with_capacity_complex_array(&a, 2),
"new failure", error_a);
populate_array(&a, 0, 5, 1);
CAG_CHECKL(new_with_size_complex_array(&b, size_complex_array(&a)),
"new failure", error_b);
CAG_TEST(*tests, size_complex_array(&a) == size_complex_array(&b),
"cag_array: copied array same size");
CAG_CHECK(copy_over_complex_array(beg_complex_array(&a),
end_complex_array(&a),
beg_complex_array(&b)),
"copy failure");
for (it1 = beg_complex_array(&a), it2 = begin_complex_array(&b);
it1 != end_complex_array(&a); ++it1, ++it2)
CAG_TEST(*tests, it1->value.real == it2->value.real &&
it1->value.imag == it2->value.imag,
"cag_array: copied values are equal");
CAG_TEST(*tests, size_complex_array(&a) == size_complex_array(&b),
"cag_array: copied array same size");
free_complex_array(&a);
free_complex_array(&b);
CAG_CHECK(new_complex_array(&a), "new failure");
populate_array(&a, 0, 5, 1);
CAG_CHECK(new_with_capacity_complex_array(&b, 2),
"new with capacity");
CAG_CHECK(set_exact_size_complex_array(&b, 5), "set exact failure");
CAG_TEST(*tests, size_complex_array(&a) == size_complex_array(&b),
"cag_array: copied array same size after set exact");
copy_over_complex_array(beg_complex_array(&a),
end_complex_array(&a),
beg_complex_array(&b));
for (it1 = beg_complex_array(&a), it2 = begin_complex_array(&b);
it1 != end_complex_array(&a); ++it1, ++it2)
CAG_TEST(*tests, it1->value.real == it2->value.real &&
it1->value.imag == it2->value.imag,
"cag_array: copied values are equal after set exact");
CAG_TEST(*tests, size_complex_array(&a) == size_complex_array(&b),
"cag_array: copied array same size after set exact and copy");
error:
free_complex_array(&b);
error_b:
free_complex_array(&a);
error_a:
return;
}
int main(int argc, char* argv[]){
if(argc!=2){
printf("Incorrect number of command line arguments\n");
printf("Correct usage:.a.out <input file\n");
return -1;
}
Book library[MAX_LABRARY_SIZE];
int length=0;
int key=0;
int index=0;
length=populate_array(library,argv[1]);
if(length==-1){
printf("Can not open the file.");
return 0;
}
sort(library,length); //Sort the array by rating
printf("Enter a rating to search for: ");
scanf("%d",&key);
index=binary_search(library,0,length-1,key);
if(index==-1){
printf("Fail to find the rating");
return 0;
}
printf("\nSorted by rating:\n");
print(library,length,index);
printf("\nSorted by author:\n");
sort_by_author(library,length);
print(library,length,-1);
return 0;
}
static void test_erase(struct cag_test_series *tests)
{
complex_array a;
it_complex_array it;
new_with_capacity_complex_array(&a, 2);
populate_array(&a, 0, 5, 1);
it = next_complex_array(beg_complex_array(&a));
it = erase_complex_array(&a, it);
CAG_TEST(*tests, it->value.real == 2 && it->value.imag == -2,
"cag_array: iterator value after one erase");
CAG_TEST(*tests, size_complex_array(&a) == 4,
"cag_array: size after one erase");
it = erase_complex_array(&a, it);
CAG_TEST(*tests, it->value.real == 3 && it->value.imag == -3,
"cag_array: iterator value after two erases");
CAG_TEST(*tests, size_complex_array(&a) == 3,
"cag_array: size after two erases");
it = erase_range_complex_array(&a, beg_complex_array(&a),
end_complex_array(&a));
CAG_TEST(*tests, it == end_complex_array(&a),
"cag_array: iterator after range erase");
CAG_TEST(*tests, size_complex_array(&a) == 0,
"cag_array: size after range erase");
free_complex_array(&a);
}
static void test_find(struct cag_test_series *tests)
{
complex_array l;
it_complex_array it;
struct complex c;
c.imag = -9;
new_complex_array(&l);
populate_array(&l, 0, 10, 1);
it = find_all_complex_array(&l,c, find_element);
CAG_TEST(*tests, it && it->value.real == 9.0,
"cag_array: find element");
c.imag = -10;
it = find_all_complex_array(&l, c, find_element);
CAG_TEST(*tests, it == end_complex_array(&l),
"cag_array: find element");
c.imag = -9.0;
it = findp_all_complex_array(&l, &c, find_element);
CAG_TEST(*tests, it && it->value.real == 9.0,
"cag_array: find element");
c.imag = -10;
it = findp_all_complex_array(&l, &c, find_element);
CAG_TEST(*tests, it == end_complex_array(&l),
"cag_array: find element");
c.imag = -9.0;
free_complex_array(&l);
}
int main(int argc, char *argv[]) {
int total = 0;
int rows = strtol(argv[1], NULL, 10);
printf("ROWS: %d\n", rows);
unsigned int *t = NULL;
populate_array(&t, rows);
total = test(t, rows);
printf("Total: %d\n", total);
}
int main(void)//runs the program
{
int array[100];
populate_array(array);
print_array(array, a);
quicksort(array, 0, a-1);
printf("\n");
print_array(array, a);
}
static void test_cmp(struct cag_test_series *tests)
{
complex_array l1, l2;
struct complex c;
new_complex_array(&l1);
new_complex_array(&l2);
CAG_TEST(*tests, cmp_range_complex_array(beg_complex_array(&l1),
end_complex_array(&l1),
beg_complex_array(&l2),
end_complex_array(&l2)) == 0,
"cag_array: compare empty arrays");
populate_array(&l1, 0, 5, 1);
populate_array(&l2, 0, 5, 1);
CAG_TEST(*tests, cmp_all_complex_array(&l1, &l2) == 0,
"cag_array: compare all equal arrays");
CAG_TEST(*tests, cmp_range_complex_array(beg_complex_array(&l1),
end_complex_array(&l1),
beg_complex_array(&l2),
end_complex_array(&l2)) == 0,
"cag_array: compare equal arrays");
c.real = 10;
c.imag = -10;
append_complex_array(&l1, c);
CAG_TEST(*tests, cmp_all_complex_array(&l1, &l2) > 0,
"cag_array: compare all 1st array bigger");
CAG_TEST(*tests, cmp_range_complex_array(beg_complex_array(&l1),
end_complex_array(&l1),
beg_complex_array(&l2),
end_complex_array(&l2)) > 0,
"cag_array: compare 1st array bigger");
c.real = 20;
c.imag = -10;
append_complex_array(&l2, c);
CAG_TEST(*tests, cmp_all_complex_array(&l1, &l2) < 0,
"cag_array: compare all 2nd array bigger");
CAG_TEST(*tests, cmp_range_complex_array(beg_complex_array(&l1),
end_complex_array(&l1),
beg_complex_array(&l2),
end_complex_array(&l2)) < 0,
"cag_array: compare 2nd array bigger");
free_complex_array(&l1);
free_complex_array(&l2);
}
static void test_front_back(struct cag_test_series *tests)
{
complex_array a;
struct complex c;
new_complex_array(&a);
populate_array(&a, 1, 6, 1);
c = *front_complex_array(&a);
CAG_TEST(*tests, c.real == 1 && c.imag == -1,
"cag_array: retrieve front");
c = *back_complex_array(&a);
CAG_TEST(*tests, c.real == 5 && c.imag == -5,
"cag_array: retrieve back");
c = *rfront_complex_array(&a);
CAG_TEST(*tests, c.real == 5 && c.imag == -5,
"cag_array: retrieve front");
c = *rback_complex_array(&a);
CAG_TEST(*tests, c.real == 1 && c.imag == -1,
"cag_array: retrieve back");
free_complex_array(&a);
}
static void test_shuffle(struct cag_test_series *tests)
{
complex_array a;
it_complex_array it1, it2;
int inorder = 1;
new_complex_array(&a);
populate_array(&a, 0, 52, 1);
random_shuffle_complex_array(beg_complex_array(&a),
end_complex_array(&a));
it1 = beg_complex_array(&a);
CAG_TEST(*tests,
at_complex_array(it1, 0)->value.real != 0.0 &&
at_complex_array(it1, 51)->value.real != 51.0 &&
at_complex_array(it1, 25)->value.real != 25.0,
"cag_array: random shuffle puts values out of order");
sort_all_complex_array(&a);
CAG_FOLD_ALL(complex_array, &a, it1, it2,
{
if (it2->value.real <= it1->value.real)
inorder = 0;
},
static void test_copy(struct cag_test_series *tests)
{
complex_array a, b, c, d;
it_complex_array it1;
rit_complex_array rit;
new_complex_array(&a);
new_complex_array(&b);
new_complex_array(&c);
new_complex_array(&d);
populate_array(&a, 0, 5, 1);
CAG_CHECK(copy_all_complex_array(&a, &b), "Assignment failure");
CAG_TEST(*tests, cmp_all_complex_array(&a, &b) == 0,
"cag_test: assigned array equals");
CAG_TEST(*tests, size_complex_array(&a) == size_complex_array(&b),
"cag_array: assigned array same size");
CAG_CHECK(rcopy_all_complex_array(&a, &c), "Assignment failure");
for (it1 = beg_complex_array(&a), rit = rbegin_complex_array(&c);
it1 != end_complex_array(&a); ++it1, --rit)
CAG_TEST(*tests, it1->value.real == rit->value.real &&
it1->value.imag == rit->value.imag,
"cag_array: assigned values are equal");
CAG_TEST(*tests, size_complex_array(&a) == size_complex_array(&c),
"cag_array: assigned array same size");
CAG_CHECK(copy_if_all_complex_array(&a, &d, is_even_complex, NULL),
"Assignment failure");
it1 = beg_complex_array(&d);
CAG_TEST(*tests,
at_complex_array(it1, 0)->value.real == 0.0 &&
at_complex_array(it1, 1)->value.real == 2.0 &&
at_complex_array(it1, 2)->value.real == 4.0,
"cag_array: copy_if copies even numbers");
CAG_TEST(*tests, size_complex_array(&d) == 3,
"cag_array: copy_if copies expected number");
error:
free_complex_array(&a);
free_complex_array(&b);
free_complex_array(&c);
free_complex_array(&d);
}
int main() {
// Integer array to hold numbers we will sort, and an
// integer to represent the number of items stored
int array[MAX_ARRAY_SIZE];
int n;
// Get values from the user to fill the array
n = populate_array(array);
// Display the unsorted array
printf("\nThe initial array contains:\n");
print_array(array, n);
// Sort the array
quicksort(array, 0, n-1);
// Display the sorted array
printf("\nThe array is now sorted:\n");
print_array(array, n);
return 0; // Return with no errors
}
static void test_reverse(struct cag_test_series *tests)
{
complex_array a;
it_complex_array it;
int i = 4;
new_complex_array(&a);
populate_array(&a, 0, 5, 1);
reverse_complex_array(beg_complex_array(&a), end_complex_array(&a));
for (it = beg_complex_array(&a); it != end_complex_array(&a); ++it,--i)
CAG_TEST(*tests, it->value.real == i &&
it->value.imag == -i,
"cag_array: values are reversed");
CAG_TEST(*tests, size_complex_array(&a) == 5,
"cag_array: reversed array same size");
reverse_all_complex_array(&a);
i = 0;
for (it = beg_complex_array(&a); it != end_complex_array(&a); ++it, ++i)
CAG_TEST(*tests, it->value.real == i &&
it->value.imag == -i,
"cag_array: values are reversed all");
CAG_TEST(*tests, distance_all_complex_array(&a) == 5,
"cag_array: reversed array same size");
free_complex_array(&a);
}
static void test_bsearch(struct cag_test_series *tests)
{
complex_array l;
struct complex c;
it_complex_array it;
int b;
new_complex_array(&l);
populate_array(&l, 0, 10, 1);
c.real = 5.0;
it = lower_bound_all_complex_array(&l, c);
CAG_TEST(*tests, it->value.real == 5.0,
"cag_array: lower bound found");
c.real = 5.5;
it = lower_bound_all_complex_array(&l, c);
CAG_TEST(*tests, it->value.real == 6.0,
"cag_array: lower bound found");
c.real = -1.0;
it = lower_boundp_all_complex_array(&l, &c);
CAG_TEST(*tests, it->value.real == 0.0,
"cag_array: lower bound found");
c.real = 10.0;
it = lower_boundp_all_complex_array(&l, &c);
CAG_TEST(*tests, it == end_complex_array(&l),
"cag_array: lower bound found");
c.real = 9.0;
it = lower_boundp_all_complex_array(&l, &c);
CAG_TEST(*tests, it->value.real == 9.0,
"cag_array: lower bound found");
b = binary_search_all_complex_array(&l, c);
CAG_TEST(*tests, b == CAG_TRUE,
"cag_array: binary search found");
c.real = 2.0;
b = binary_search_all_complex_array(&l, c);
CAG_TEST(*tests, b == CAG_TRUE,
"cag_array: binary search found");
c.real = 0.0;
b = binary_search_all_complex_array(&l, c);
CAG_TEST(*tests, b == CAG_TRUE,
"cag_array: binary search found");
c.real = 11.0;
b = binary_search_all_complex_array(&l, c);
CAG_TEST(*tests, b == CAG_FALSE,
"cag_array: binary search not found");
b = binary_rsearch_complex_array(rbeg_complex_array(&l),
rend_complex_array(&l), c);
CAG_TEST(*tests, b == CAG_FALSE,
"cag_array: reverse binary search not found");
c.real = 5.0;
b = binary_searchp_all_complex_array(&l, &c);
CAG_TEST(*tests, b == CAG_TRUE,
"cag_array: binary search found");
c.real = 9.0;
b = binary_searchp_all_complex_array(&l, &c);
CAG_TEST(*tests, b == CAG_TRUE,
"cag_array: binary search found");
c.real = 2.0;
b = binary_searchp_all_complex_array(&l, &c);
CAG_TEST(*tests, b == CAG_TRUE,
"cag_array: binary search found");
c.real = 0.0;
b = binary_searchp_all_complex_array(&l, &c);
CAG_TEST(*tests, b == CAG_TRUE,
"cag_array: binary search found");
c.real = 11.0;
b = binary_searchp_all_complex_array(&l, &c);
CAG_TEST(*tests, b == CAG_FALSE,
"cag_array: binary search not found");
b = binary_rsearchp_complex_array(rbeg_complex_array(&l),
rend_complex_array(&l), &c);
CAG_TEST(*tests, b == CAG_FALSE,
"cag_array: reverse binary search not found");
free_complex_array(&l);
new_complex_array(&l);
c.real = 5.0;
b = binary_rsearch_complex_array(rbeg_complex_array(&l),
rend_complex_array(&l), c);
CAG_TEST(*tests, b == CAG_FALSE,
"cag_array: reverse binary search on empty array");
populate_array(&l, 10, 0, -1);
c.real = 2.0;
b = binary_rsearchp_complex_array(rbeg_complex_array(&l),
rend_complex_array(&l), &c);
CAG_TEST(*tests, b == CAG_TRUE,
"cag_array: binary search found");
c.real = 11.0;
b = binary_rsearchp_complex_array(rbeg_complex_array(&l),
rend_complex_array(&l), &c);
CAG_TEST(*tests, b == CAG_FALSE,
"cag_array: binary search found");
free_complex_array(&l);
}
static void test_insert_order(struct cag_test_series *tests)
{
struct complex c = {3, -3};
complex_array l;
it_complex_array it;
size_t d;
double t = -20.0;
int inorder = CAG_TRUE;
new_complex_array(&l);
c.real = 6;
insert_gt_complex_array(&l, beg_complex_array(&l), c);
c.real = 0;
insert_gt_complex_array(&l, beg_complex_array(&l), c);
c.real = 4;
insert_gt_complex_array(&l, beg_complex_array(&l), c);
c.real = 8;
insert_gt_complex_array(&l, beg_complex_array(&l), c);
c.real = 2;
insert_gt_complex_array(&l, beg_complex_array(&l), c);
for (it = beg_complex_array(&l); it != end_complex_array(&l);
++it)
if (it->value.real < t) {
inorder = CAG_FALSE;
break;
} else
t = it->value.real;
d = distance_complex_array(beg_complex_array(&l), end_complex_array(&l));
CAG_TEST(*tests, d == 5 && inorder == CAG_TRUE,
"cag_array: insert ordered values");
c.real = 3.0;
it = insert_gt_complex_array(&l, beg_complex_array(&l), c);
CAG_TEST(*tests, (it-1)->value.real == 2.0 &&
it->value.real == 3.0 &&
(it+1)->value.real == 4.0 &&
distance_complex_array(beg_complex_array(&l),
end_complex_array(&l)) == d+1,
"cag_array: insert gt middle");
c.real = 20.0;
it = insert_gt_complex_array(&l, beg_complex_array(&l), c);
CAG_TEST(*tests, (it-1)->value.real == 8.0 &&
it->value.real == 20.0 &&
distance_complex_array(beg_complex_array(&l),
end_complex_array(&l)) == d+2,
"cag_array: insert gt end");
c.real = -1.0;
it = insert_gt_complex_array(&l, beg_complex_array(&l), c);
CAG_TEST(*tests, it == beg_complex_array(&l) &&
(it+1)->value.real == 0.0 &&
it->value.real == -1.0 &&
distance_complex_array(beg_complex_array(&l),
end_complex_array(&l)) == d+3,
"cag_array: insert gt beginning");
c.real = -0.5;
c.imag = 10.0;
it = insert_gt_complex_array(&l, beg_complex_array(&l), c);
CAG_TEST(*tests, (it-1)->value.real == -1.0 &&
it->value.real == -0.5 &&
distance_complex_array(beg_complex_array(&l),
end_complex_array(&l)) == d+4,
"cag_array: insert gt one beyond beginning");
c.imag = 5.0;
it = insert_gt_complex_array(&l, beg_complex_array(&l), c);
CAG_TEST(*tests, (it-1)->value.real == -1.0 &&
it->value.real == -0.5 &&
distance_complex_array(beg_complex_array(&l),
end_complex_array(&l)) == d+5,
"cag_array: insert gt duplicate stable");
it = insert_gteq_complex_array(&l, beg_complex_array(&l), c);
CAG_TEST(*tests, (it-1)->value.real == -0.5 &&
it->value.real == -0.5 &&
distance_complex_array(beg_complex_array(&l),
end_complex_array(&l)) == d+6,
"cag_array: insert gt duplicate unstable");
free_complex_array(&l);
new_complex_array(&l);
populate_array(&l, 10, 0, -2);
d = distance_complex_array(beg_complex_array(&l), end_complex_array(&l));
c.real = 3.0;
c.imag = 1.0;
it = insert_lt_complex_array(&l, beg_complex_array(&l), c);
CAG_TEST(*tests, (it+1)->value.real == 2.0 &&
it->value.real == 3.0 &&
(it-1)->value.real == 4.0 &&
distance_complex_array(beg_complex_array(&l),
end_complex_array(&l)) == d+1,
"cag_array: insert lt middle");
c.imag = 2.0;
it = insert_lt_complex_array(&l, beg_complex_array(&l), c);
CAG_TEST(*tests, (it+1)->value.real == 3.0 &&
it->value.real == 3.0 &&
(it-1)->value.real == 4.0 &&
distance_complex_array(beg_complex_array(&l),
end_complex_array(&l)) == d+2,
"cag_array: insert lt duplicate stable");
c.imag = 3.0;
it = insert_lteq_complex_array(&l, beg_complex_array(&l), c);
CAG_TEST(*tests, (it-1)->value.real == 3.0 &&
it->value.real == 3.0 &&
(it+1)->value.real == 2.0 &&
distance_complex_array(beg_complex_array(&l),
end_complex_array(&l)) == d+3,
"cag_array: insert lt duplicate unstable");
free_complex_array(&l);
}
