blizzardfinnegan/exercism-c
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Init commit

Browse source 
Leap, Difference of Squares, Grains, Collatz Conjecture, Queen Attack,
Darts, Hamming, and Space Age completed yesterday.

Binary and Linked List completed today.
This commit is contained in:
Blizzard Finnegan 2025-01-11 18:45:47 -05:00
parent 974892d7f1
commit b92478b09c
Signed by: blizzardfinnegan
GPG key ID: 61C1E13067E0018E
903 changed files with 345120 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

242
sublist/test_sublist.c Normal file
View file

@ -0,0 +1,242 @@
#include "test-framework/unity.h"
#include "sublist.h"
#define ELEMENT_COUNT(array) (sizeof(array) / sizeof(array[0]))
void setUp(void)
{
}
void tearDown(void)
{
}
static void test_empty_lists(void)
{
TEST_ASSERT_EQUAL(EQUAL, check_lists(NULL, NULL, 0, 0));
}
static void test_empty_list_within_non_empty_list(void)
{
TEST_IGNORE(); // delete this line to run test
int base_list[] = { 1, 2, 3 };
TEST_ASSERT_EQUAL(SUBLIST,
check_lists(NULL, base_list, 0, ELEMENT_COUNT(base_list)));
}
static void test_non_empty_list_contains_empty_list(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 2, 3 };
TEST_ASSERT_EQUAL(SUPERLIST,
check_lists(list_to_compare, NULL,
ELEMENT_COUNT(list_to_compare), 0));
}
static void test_list_equals_itself(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 2, 3 };
int base_list[] = { 1, 2, 3 };
TEST_ASSERT_EQUAL(EQUAL,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_different_lists(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 2, 3 };
int base_list[] = { 2, 3, 4 };
TEST_ASSERT_EQUAL(UNEQUAL,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_false_start(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 2, 5 };
int base_list[] = { 0, 1, 2, 3, 1, 2, 5, 6 };
TEST_ASSERT_EQUAL(SUBLIST,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_consecutive(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 1, 2 };
int base_list[] = { 0, 1, 1, 1, 2, 1, 2 };
TEST_ASSERT_EQUAL(SUBLIST,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_sublist_at_start(void)
{
TEST_IGNORE();
int list_to_compare[] = { 0, 1, 2 };
int base_list[] = { 0, 1, 2, 3, 4, 5 };
TEST_ASSERT_EQUAL(SUBLIST,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_sublist_at_middle(void)
{
TEST_IGNORE();
int list_to_compare[] = { 2, 3, 4 };
int base_list[] = { 0, 1, 2, 3, 4, 5 };
TEST_ASSERT_EQUAL(SUBLIST,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_sublist_at_end(void)
{
TEST_IGNORE();
int list_to_compare[] = { 3, 4, 5 };
int base_list[] = { 0, 1, 2, 3, 4, 5 };
TEST_ASSERT_EQUAL(SUBLIST,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_at_start_of_superlist(void)
{
TEST_IGNORE();
int list_to_compare[] = { 0, 1, 2, 3, 4, 5 };
int base_list[] = { 0, 1, 2 };
TEST_ASSERT_EQUAL(SUPERLIST,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_in_middle_of_superlist(void)
{
TEST_IGNORE();
int list_to_compare[] = { 0, 1, 2, 3, 4, 5 };
int base_list[] = { 2, 3 };
TEST_ASSERT_EQUAL(SUPERLIST,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_at_end_of_superlist(void)
{
TEST_IGNORE();
int list_to_compare[] = { 0, 1, 2, 3, 4, 5 };
int base_list[] = { 3, 4, 5 };
TEST_ASSERT_EQUAL(SUPERLIST,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_first_list_missing_element_from_second_list(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 3 };
int base_list[] = { 1, 2, 3 };
TEST_ASSERT_EQUAL(UNEQUAL,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_second_list_missing_element_from_first_list(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 2, 3 };
int base_list[] = { 1, 3 };
TEST_ASSERT_EQUAL(UNEQUAL,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_order_matters_to_a_list(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 2, 3 };
int base_list[] = { 3, 2, 1 };
TEST_ASSERT_EQUAL(UNEQUAL,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_same_digits_but_different_numbers(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 0, 1 };
int base_list[] = { 10, 1 };
TEST_ASSERT_EQUAL(UNEQUAL,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
static void test_different_signs(void)
{
TEST_IGNORE();
int list_to_compare[] = { 1, 2, 3 };
int base_list[] = { 1, -2, 3 };
TEST_ASSERT_EQUAL(UNEQUAL,
check_lists(list_to_compare, base_list,
ELEMENT_COUNT(list_to_compare),
ELEMENT_COUNT(base_list)));
}
int main(void)
{
UnityBegin("test_sublist.c");
RUN_TEST(test_empty_lists);
RUN_TEST(test_empty_list_within_non_empty_list);
RUN_TEST(test_non_empty_list_contains_empty_list);
RUN_TEST(test_list_equals_itself);
RUN_TEST(test_different_lists);
RUN_TEST(test_false_start);
RUN_TEST(test_consecutive);
RUN_TEST(test_sublist_at_start);
RUN_TEST(test_sublist_at_middle);
RUN_TEST(test_sublist_at_end);
RUN_TEST(test_at_start_of_superlist);
RUN_TEST(test_in_middle_of_superlist);
RUN_TEST(test_at_end_of_superlist);
RUN_TEST(test_first_list_missing_element_from_second_list);
RUN_TEST(test_second_list_missing_element_from_first_list);
RUN_TEST(test_order_matters_to_a_list);
RUN_TEST(test_same_digits_but_different_numbers);
RUN_TEST(test_different_signs);
return UnityEnd();
}