From 91390da961546afcaa7a89b4fbc01b8039520e22 Mon Sep 17 00:00:00 2001 From: Tom Cornebize Date: Sat, 17 Sep 2016 14:49:54 +0200 Subject: [PATCH] Add unit tests for container_equals and container_is_subset. --- src/containers/mixed_subset.c | 1 - tests/CMakeLists.txt | 1 + tests/container_comparison_unit.c | 182 ++++++++++++++++++++++++++++++ 3 files changed, 183 insertions(+), 1 deletion(-) create mode 100644 tests/container_comparison_unit.c diff --git a/src/containers/mixed_subset.c b/src/containers/mixed_subset.c index 5af269c96..3aa601c01 100644 --- a/src/containers/mixed_subset.c +++ b/src/containers/mixed_subset.c @@ -42,7 +42,6 @@ bool array_container_is_subset_run(array_container_t* container1, if (container1->cardinality > run_container_cardinality(container2)) return false; int i_array = 0, i_run = 0; - run_container_printf(container2); printf("\n"); while(i_array < container1->cardinality && i_run < container2->n_runs) { uint32_t start = container2->runs[i_run].value; uint32_t stop = start+container2->runs[i_run].length; diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index a56caa5a5..f0480bc5b 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -13,5 +13,6 @@ add_c_test(toplevel_unit) add_c_test(realdata_unit) add_c_test(util_unit) add_c_test(format_portability_unit) +add_c_test(container_comparison_unit) add_subdirectory(vendor/cmocka) diff --git a/tests/container_comparison_unit.c b/tests/container_comparison_unit.c new file mode 100644 index 000000000..7bb098ae9 --- /dev/null +++ b/tests/container_comparison_unit.c @@ -0,0 +1,182 @@ +/* + * container_comparison_unit.c + * + */ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "test.h" + +static inline void container_checked_add(void *container, uint16_t val, + uint8_t typecode) { + uint8_t new_type; + void *new_container = container_add(container, val, typecode, &new_type); + assert_int_equal(typecode, new_type); + assert_true(container == new_container); +} + +static inline void *container_create(uint8_t typecode) { + void *result = NULL; + switch (typecode) { + case BITSET_CONTAINER_TYPE_CODE: + result = bitset_container_create(); + break; + case ARRAY_CONTAINER_TYPE_CODE: + result = array_container_create(); + break; + case RUN_CONTAINER_TYPE_CODE: + result = run_container_create(); + break; + default: + assert(false); + __builtin_unreachable(); + } + assert_non_null(result); + return result; +} + +void generic_equal_test(uint8_t type1, uint8_t type2) { + void *container1 = container_create(type1); + void *container2 = container_create(type2); + assert_true(container_equals(container1, type1, container2, type2)); + for(int i = 0 ; i < 100 ; i++) { + container_checked_add(container1, i*10, type1); + container_checked_add(container2, i*10, type2); + assert_true(container_equals(container1, type1, container2, type2)); + } + container_checked_add(container1, 273, type1); + assert_false(container_equals(container1, type1, container2, type2)); + container_checked_add(container2, 854, type2); + assert_false(container_equals(container1, type1, container2, type2)); + container_checked_add(container1, 854, type1); + assert_false(container_equals(container1, type1, container2, type2)); + container_checked_add(container2, 273, type2); + assert_true(container_equals(container1, type1, container2, type2)); + container_free(container1, type1); + container_free(container2, type2); +} + +void equal_array_array_test() { + generic_equal_test(ARRAY_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE); +} + +void equal_bitset_bitset_test() { + generic_equal_test(BITSET_CONTAINER_TYPE_CODE, BITSET_CONTAINER_TYPE_CODE); +} + +void equal_run_run_test() { + generic_equal_test(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE); +} + +void equal_array_bitset_test() { + generic_equal_test(ARRAY_CONTAINER_TYPE_CODE, BITSET_CONTAINER_TYPE_CODE); +} + +void equal_bitset_array_test() { + generic_equal_test(BITSET_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE); +} + +void equal_array_run_test() { + generic_equal_test(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE); +} + +void equal_run_array_test() { + generic_equal_test(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE); +} + +void equal_bitset_run_test() { + generic_equal_test(BITSET_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE); +} + +void equal_run_bitset_test() { + generic_equal_test(RUN_CONTAINER_TYPE_CODE, BITSET_CONTAINER_TYPE_CODE); +} + +void generic_subset_test(uint8_t type1, uint8_t type2) { + void *container1 = container_create(type1); + void *container2 = container_create(type2); + assert_true(container_is_subset(container1, type1, container2, type2)); + for(int i = 0 ; i < 100 ; i++) { + container_checked_add(container1, i*11, type1); + container_checked_add(container2, i*11, type2); + assert_true(container_is_subset(container1, type1, container2, type2)); + } + for(int i = 0 ; i < 100 ; i++) { + container_checked_add(container2, i*7, type2); + assert_true(container_is_subset(container1, type1, container2, type2)); + } + for(int i = 0 ; i < 100 ; i++) { + if(i%7==0 || i%11==0) continue; + container_checked_add(container1, i*5, type1); + assert_false(container_is_subset(container1, type1, container2, type2)); + container_checked_add(container2, i*5, type2); + assert_true(container_is_subset(container1, type1, container2, type2)); + } + container_free(container1, type1); + container_free(container2, type2); +} + +void subset_array_array_test() { + generic_subset_test(ARRAY_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE); +} + +void subset_bitset_bitset_test() { + generic_subset_test(BITSET_CONTAINER_TYPE_CODE, BITSET_CONTAINER_TYPE_CODE); +} + +void subset_run_run_test() { + generic_subset_test(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE); +} + +void subset_array_bitset_test() { + generic_subset_test(ARRAY_CONTAINER_TYPE_CODE, BITSET_CONTAINER_TYPE_CODE); +} + +void subset_array_run_test() { + generic_subset_test(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE); +} + +void subset_run_array_test() { + generic_subset_test(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE); +} + +void subset_bitset_run_test() { + generic_subset_test(BITSET_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE); +} + +void subset_run_bitset_test() { + generic_subset_test(RUN_CONTAINER_TYPE_CODE, BITSET_CONTAINER_TYPE_CODE); +} + +int main() { + const struct CMUnitTest tests[] = { + cmocka_unit_test(equal_array_array_test), + cmocka_unit_test(equal_bitset_bitset_test), + cmocka_unit_test(equal_run_run_test), + cmocka_unit_test(equal_array_bitset_test), + cmocka_unit_test(equal_bitset_array_test), + cmocka_unit_test(equal_array_run_test), + cmocka_unit_test(equal_run_array_test), + cmocka_unit_test(equal_bitset_run_test), + cmocka_unit_test(equal_run_bitset_test), + cmocka_unit_test(subset_array_array_test), + cmocka_unit_test(subset_bitset_bitset_test), + cmocka_unit_test(subset_run_run_test), + cmocka_unit_test(subset_array_bitset_test), + cmocka_unit_test(subset_array_run_test), + cmocka_unit_test(subset_run_array_test), + cmocka_unit_test(subset_bitset_run_test), + cmocka_unit_test(subset_run_bitset_test), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +}