295 lines
11 KiB
C
295 lines
11 KiB
C
/*----------------------------------------------------------
|
|
* HTBLA-Leonding
|
|
* ----------------------------------------------------------
|
|
* Description:
|
|
* Test functions for customer_list.
|
|
* ----------------------------------------------------------
|
|
*/
|
|
#include <stdio.h>
|
|
|
|
#include "shortcut.h"
|
|
#include "customer_list.h"
|
|
#include "test_customer_list.h"
|
|
|
|
#define TEST_ENTRIES_COUNT 13
|
|
|
|
struct CustomerTestData {
|
|
int id;
|
|
const char* name;
|
|
int revenue;
|
|
};
|
|
|
|
struct CustomerTestData customers[] = {
|
|
/* id, name, revenue */
|
|
{200501, "Fabasoft", 5432}, // 0
|
|
{201005, "CountIT", 3893}, // 1
|
|
{199922, "e-punkt", 4198}, // 2
|
|
{200349, "karriere.at", 745}, // 3
|
|
{201893, "Google", 2934}, // 4
|
|
{200745, "Apple", 1034}, // 5
|
|
{200814, "Amazon", 987}, // 6
|
|
{201624, "Samsung", 45}, // 7
|
|
{201402, "Dynatrace", 857}, // 8
|
|
{200911, "BBEdit", 194}, // 9
|
|
{201090, "IBM", 893}, // 10
|
|
{200296, "AV Stumpfl", 207}, // 11
|
|
{201818, "Bosch", 1099}, // 12
|
|
};
|
|
|
|
// #define MORE_ENTRIES_COUNT 12
|
|
// static struct CustomerListEntryData *more_entries[] = {
|
|
// &p2, &p3, &p4, &p5, &p6, &p7, &p8, &p9, &p10, &p11, &p12, &p13
|
|
// };
|
|
|
|
static CustomerList customer_list;
|
|
|
|
/* ---------------------------- Public functions ------------------------------------- */
|
|
TEST(test_init_customer_list) {
|
|
ASSERT_TRUE(get_length(0) < 0, "An invalid list shall provide a negative length");
|
|
customer_list = init_customer_list();
|
|
ASSERT_EQUALS(0, get_length(customer_list));
|
|
}
|
|
|
|
static CustomerListEntry create_test_customer(int idx) {
|
|
return create_customer(customers[idx].id, customers[idx].name, customers[idx].revenue);
|
|
}
|
|
|
|
TEST(test_add_entry) {
|
|
bool success = add_customer(0, customers[0].id, customers[0].name, customers[0].revenue);
|
|
ASSERT_FALSE(success, "Adding a customer to an invalid list must not be possible");
|
|
ASSERT_TRUE(get_customer_id(0) < 0, "The ID of an invalid customer must be less than 0");
|
|
|
|
customer_list = init_customer_list();
|
|
success = add_customer(customer_list, customers[0].id, customers[0].name, customers[0].revenue);
|
|
ASSERT_TRUE(success, "Adding first entry must be possible");
|
|
CustomerListEntry res = get_customer_with_index(customer_list, 0);
|
|
if (res != 0) {
|
|
ASSERT_EQUALS(200501, get_customer_id(res));
|
|
}
|
|
ASSERT_EQUALS(1, get_length(customer_list));
|
|
}
|
|
|
|
/* ---------------------------- Private function ------------------------------------ */
|
|
/** make_list_full adds test entries until the grade list is full
|
|
*** @return True if filling is possible, FALSE otherwise
|
|
*/
|
|
static bool make_list_full();
|
|
TEST(test_add_entries) {
|
|
customer_list = init_customer_list();
|
|
|
|
CustomerListEntry one_entry[] = { create_test_customer(0) };
|
|
|
|
bool adding_possible = add_customers(customer_list, one_entry, 1);
|
|
ASSERT_TRUE(adding_possible, "Adding of one entry in empty list must be possible");
|
|
ASSERT_EQUALS(1, get_length(customer_list));
|
|
|
|
customer_list = init_customer_list();
|
|
ASSERT_EQUALS(0, get_length(customer_list));
|
|
|
|
add_customer(customer_list, customers[0].id, customers[0].name, customers[0].revenue);
|
|
adding_possible = make_list_full();
|
|
ASSERT_TRUE(adding_possible, "Making an empty list full must be possible");
|
|
ASSERT_EQUALS(MAX_LIST_ENTRIES, get_length(customer_list));
|
|
|
|
CustomerListEntry customer = get_customer_with_index(customer_list, MAX_LIST_ENTRIES - 1);
|
|
ASSERT_TRUE(customer != 0, "A customer shall be provided");
|
|
ASSERT_EQUALS(customers[MAX_LIST_ENTRIES - 1].id, get_customer_id(customer));
|
|
|
|
adding_possible = add_customers(customer_list, one_entry, 1);
|
|
ASSERT_FALSE(adding_possible, "Adding entries in full list must NOT be possible");
|
|
ASSERT_EQUALS(MAX_LIST_ENTRIES, get_length(customer_list));
|
|
}
|
|
|
|
static bool make_list_full() {
|
|
const int size = MAX_LIST_ENTRIES - get_length(customer_list);
|
|
CustomerListEntry entries[size];
|
|
int start_idx = get_length(customer_list);
|
|
for(int i = start_idx; i < MAX_LIST_ENTRIES; i++) {
|
|
entries[i - start_idx] = create_test_customer(i);
|
|
}
|
|
return add_customers(customer_list, entries, size);
|
|
}
|
|
|
|
|
|
TEST(test_get_customer_with_id_when_customer_list_is_empty) {
|
|
customer_list = init_customer_list();
|
|
CustomerListEntry customer = get_customer_with_id(customer_list, 1);
|
|
ASSERT_TRUE(customer == 0, "No customer must be provided if the list is empty");
|
|
}
|
|
|
|
TEST(test_get_customer_with_id_with_one_element) {
|
|
customer_list = init_customer_list();
|
|
ASSERT_EQUALS(0, get_length(customer_list));
|
|
|
|
add_customer(customer_list, customers[0].id, customers[0].name, customers[0].revenue);
|
|
ASSERT_EQUALS(1, get_length(customer_list));
|
|
CustomerListEntry customer = get_customer_with_id(customer_list, customers[0].id);
|
|
ASSERT_TRUE(customer != 0, "A customer shall be provided");
|
|
ASSERT_EQUALS(customers[0].id, get_customer_id(customer));
|
|
}
|
|
|
|
TEST(test_get_customer_with_id_when_list_is_full) {
|
|
customer_list = init_customer_list();
|
|
ASSERT_EQUALS(0, get_length(customer_list));
|
|
make_list_full();
|
|
CustomerListEntry customer = get_customer_with_id(customer_list, customers[5].id);
|
|
ASSERT_TRUE(customer != 0, "A customer shall be provided");
|
|
ASSERT_EQUALS(customers[5].id, get_customer_id(customer));
|
|
}
|
|
|
|
TEST(test_get_customers_with_revenue) {
|
|
CustomerListEntry result_list[MAX_LIST_ENTRIES];
|
|
int length = -1;
|
|
|
|
length = get_customers_with_revenue(0, 0, 10000, result_list, MAX_LIST_ENTRIES);
|
|
ASSERT_EQUALS(0, length);
|
|
|
|
customer_list = init_customer_list();
|
|
ASSERT_EQUALS(0, get_length(customer_list));
|
|
|
|
length = get_customers_with_revenue(customer_list, 0, 10000, result_list, MAX_LIST_ENTRIES);
|
|
ASSERT_EQUALS(0, length);
|
|
|
|
add_customer(customer_list, customers[0].id, customers[0].name, customers[0].revenue);
|
|
length = get_customers_with_revenue(customer_list, 0, 5431, result_list, MAX_LIST_ENTRIES);
|
|
ASSERT_EQUALS(0, length);
|
|
|
|
length = get_customers_with_revenue(customer_list, 0, 5432, result_list, MAX_LIST_ENTRIES);
|
|
ASSERT_EQUALS(1, length);
|
|
|
|
make_list_full();
|
|
|
|
length = get_customers_with_revenue(customer_list, 893, 1099, result_list, MAX_LIST_ENTRIES);
|
|
ASSERT_EQUALS(4, length);
|
|
if (length == 4) {
|
|
ASSERT_EQUALS(200745, get_customer_id(result_list[0]));
|
|
ASSERT_EQUALS(200814, get_customer_id(result_list[1]));
|
|
ASSERT_EQUALS(201090, get_customer_id(result_list[2]));
|
|
ASSERT_EQUALS(201818, get_customer_id(result_list[3]));
|
|
}
|
|
}
|
|
|
|
TEST(test_get_customer_with_highest_revenue) {
|
|
CustomerListEntry customer = 0;
|
|
|
|
customer = get_customer_with_highest_revenue(0);
|
|
ASSERT_TRUE(customer == 0, "Invalid customer list can't return any customer, 0 expected");
|
|
|
|
customer_list = init_customer_list();
|
|
ASSERT_EQUALS(0, get_length(customer_list));
|
|
|
|
customer = get_customer_with_highest_revenue(customer_list);
|
|
ASSERT_TRUE(customer == 0, "Empty customer list can't return any customer, 0 expected");
|
|
|
|
add_customer(customer_list, customers[0].id, customers[0].name, customers[0].revenue);
|
|
|
|
customer = get_customer_with_highest_revenue(customer_list);
|
|
ASSERT_TRUE(customer != 0, "Customer list with one customer must return first element");
|
|
ASSERT_EQUALS(customers[0].id, get_customer_id(customer));
|
|
|
|
make_list_full();
|
|
|
|
customer = get_customer_with_highest_revenue(customer_list);
|
|
ASSERT_TRUE(customer != 0, "Full customer list must return a highest revenue customer");
|
|
ASSERT_EQUALS(200501, get_customer_id(customer));
|
|
}
|
|
|
|
TEST(test_get_customer_with_lowest_revenue) {
|
|
CustomerListEntry customer = 0;
|
|
|
|
customer = get_customer_with_lowest_revenue(0);
|
|
ASSERT_TRUE(customer == 0, "Invalid customer list can't return any customer, 0 expected");
|
|
|
|
customer_list = init_customer_list();
|
|
ASSERT_EQUALS(0, get_length(customer_list));
|
|
|
|
customer = get_customer_with_lowest_revenue(customer_list);
|
|
ASSERT_TRUE(customer == 0, "Empty customer list can't return any customer, 0 expected");
|
|
|
|
add_customer(customer_list, customers[0].id, customers[0].name, customers[0].revenue);
|
|
customer = get_customer_with_lowest_revenue(customer_list);
|
|
ASSERT_TRUE(customer != 0, "Customer list with one customer must return first element");
|
|
ASSERT_EQUALS(customers[0].id, get_customer_id(customer));
|
|
|
|
make_list_full();
|
|
|
|
customer = get_customer_with_lowest_revenue(customer_list);
|
|
ASSERT_TRUE(customer != 0, "Full customer list must return a lowest revenue customer");
|
|
ASSERT_EQUALS(201624, get_customer_id(customer));
|
|
}
|
|
|
|
TEST(test_get_top_n_customers_revenue) {
|
|
CustomerListEntry result_list[MAX_LIST_ENTRIES];
|
|
int length = -1;
|
|
|
|
customer_list = init_customer_list();
|
|
length = get_top_n_customers_revenue(customer_list, 5, result_list);
|
|
ASSERT_EQUALS(0, length);
|
|
|
|
add_customer(customer_list, customers[0].id, customers[0].name, customers[0].revenue);
|
|
length = get_top_n_customers_revenue(customer_list, 5, result_list);
|
|
ASSERT_EQUALS(1, length);
|
|
ASSERT_EQUALS(customers[0].id, get_customer_id(result_list[0]));
|
|
|
|
make_list_full();
|
|
|
|
length = get_top_n_customers_revenue(customer_list, 1, result_list);
|
|
ASSERT_EQUALS(1, length);
|
|
ASSERT_EQUALS(200501, get_customer_id(result_list[0]));
|
|
|
|
length = get_top_n_customers_revenue(customer_list, 5, result_list);
|
|
ASSERT_EQUALS(5, length);
|
|
ASSERT_EQUALS(200501, get_customer_id(result_list[0]));
|
|
ASSERT_EQUALS(199922, get_customer_id(result_list[1]));
|
|
ASSERT_EQUALS(201005, get_customer_id(result_list[2]));
|
|
ASSERT_EQUALS(201893, get_customer_id(result_list[3]));
|
|
ASSERT_EQUALS(201818, get_customer_id(result_list[4]));
|
|
|
|
length = get_top_n_customers_revenue(customer_list, 0, result_list);
|
|
ASSERT_EQUALS(0, length);
|
|
|
|
length = get_top_n_customers_revenue(customer_list, TEST_ENTRIES_COUNT + 1, result_list);
|
|
ASSERT_EQUALS(TEST_ENTRIES_COUNT, length);
|
|
|
|
length = get_top_n_customers_revenue(0, TEST_ENTRIES_COUNT + 1, result_list);
|
|
ASSERT_TRUE(length <= 0, "An invalid list must indicate 0 or less found customers");
|
|
}
|
|
|
|
TEST(test_get_bottom_n_customers_revenue) {
|
|
CustomerListEntry result_list[MAX_LIST_ENTRIES];
|
|
int length = -1;
|
|
|
|
customer_list = init_customer_list();
|
|
length = get_bottom_n_customers_revenue(customer_list, 5, result_list);
|
|
ASSERT_EQUALS(0, length);
|
|
|
|
add_customer(customer_list, customers[0].id, customers[0].name, customers[0].revenue);
|
|
length = get_bottom_n_customers_revenue(customer_list, 5, result_list);
|
|
ASSERT_EQUALS(1, length);
|
|
ASSERT_EQUALS(customers[0].id, get_customer_id(result_list[0]));
|
|
|
|
make_list_full();
|
|
|
|
length = get_bottom_n_customers_revenue(customer_list, 1, result_list);
|
|
ASSERT_EQUALS(1, length);
|
|
ASSERT_EQUALS(201624, get_customer_id(result_list[0]));
|
|
|
|
length = get_bottom_n_customers_revenue(customer_list, 7, result_list);
|
|
ASSERT_EQUALS(7, length);
|
|
ASSERT_EQUALS(201624, get_customer_id(result_list[0]));
|
|
ASSERT_EQUALS(200911, get_customer_id(result_list[1]));
|
|
ASSERT_EQUALS(200296, get_customer_id(result_list[2]));
|
|
ASSERT_EQUALS(200349, get_customer_id(result_list[3]));
|
|
ASSERT_EQUALS(201402, get_customer_id(result_list[4]));
|
|
ASSERT_EQUALS(201090, get_customer_id(result_list[5]));
|
|
ASSERT_EQUALS(200814, get_customer_id(result_list[6]));
|
|
|
|
length = get_bottom_n_customers_revenue(customer_list, 0, result_list);
|
|
ASSERT_EQUALS(0, length);
|
|
|
|
length = get_bottom_n_customers_revenue(customer_list, TEST_ENTRIES_COUNT + 1, result_list);
|
|
ASSERT_EQUALS(TEST_ENTRIES_COUNT, length);
|
|
|
|
length = get_bottom_n_customers_revenue(0, TEST_ENTRIES_COUNT + 1, result_list);
|
|
ASSERT_TRUE(length <= 0, "An invalid list must indicate 0 or less found customers");
|
|
}
|