foundational_lib 1.0

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_append_string_to_array.c

@@ -0,0 +1,33 @@
+#include "../foundationallib.h"
+#include <assert.h>
+int test_append_string_to_array()
+{
+    const char **array = NULL;
+    size_t array_size = 0;
+    size_t array_current_alloc_size = 0;
+
+    // Test case 1: Append to empty array
+    const char *test_string_1 = "Hello";
+    int result = append_string_to_array(&array, &array_size, &array_current_alloc_size, test_string_1);
+    assert(result == 0);
+    assert(array_size == 1);
+    printf("Alloc size is %zu\n", array_current_alloc_size);
+    assert(array_current_alloc_size >= 1);
+    assert(strcmp(array[0], test_string_1) == 0);
+
+    // Test case 2: Append to non-empty array
+    const char *test_string_2 = "World";
+    result = append_string_to_array(&array, &array_size, &array_current_alloc_size, test_string_2);
+    assert(result == 0);
+    assert(array_size == 2);
+    assert(array_current_alloc_size >= 2);
+    assert(strcmp(array[1], test_string_2) == 0);
+
+    return 0;
+}
+
+int main()
+{
+    test_append_string_to_array();
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_append_string_to_array_no_initial_alloc.c

@@ -0,0 +1,51 @@
+#include "../foundationallib.h"
+#include <assert.h>
+void test_append_string_to_array_no_initial_alloc()
+{
+    const char **array = NULL;
+    size_t array_size = 0;
+    size_t array_current_alloc_size = 0;
+
+    // Test empty array with initial allocation size other than 0
+    {
+        const char *new_string = "Test String 1";
+        int result = append_string_to_array_no_initial_alloc(&array, &array_size, &array_current_alloc_size, new_string);
+        assert(result == 0);
+        assert(array_size == 1);
+        assert(array_current_alloc_size > 0);
+        assert(strcmp(array[0], new_string) == 0);
+    }
+
+    // Test adding multiple strings
+    {
+        const char *new_string = "Test String 2";
+        int result = append_string_to_array_no_initial_alloc(&array, &array_size, &array_current_alloc_size, new_string);
+        assert(result == 0);
+        assert(array_size == 2);
+        assert(array_current_alloc_size > 0);
+        assert(strcmp(array[1], new_string) == 0);
+    }
+
+    // Test error when allocating size is 0
+    {
+        array_current_alloc_size = 0;
+        const char *new_string = "Test String 3";
+        int result = append_string_to_array_no_initial_alloc(&array, &array_size, &array_current_alloc_size, new_string);
+        assert(result == -1);
+    }
+
+    // Free memory
+    for (size_t i = 0; i < array_size; i++)
+    {
+        free((void *)array[i]);
+    }
+    free(array);
+    array = NULL;
+}
+
+int main()
+{
+    test_append_string_to_array_no_initial_alloc();
+    printf("All tests passed successfully!\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_array_total_string_length.c

@@ -0,0 +1,25 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+void test_array_total_string_length()
+{
+    const char *array1[] = {"abc", "def", "ghi"};
+    const char *array2[] = {"hello", "world"};
+    const char *array3[] = {"", "", ""};
+    const char *array4[] = {NULL, "test", "string"};
+    const char *array5[] = {"this is a test", "of the array", "of strings"};
+
+    assert(array_total_string_length(array1, 3) == 9);
+    assert(array_total_string_length(array2, 2) == 10);
+    assert(array_total_string_length(array3, 3) == 0);
+    assert(array_total_string_length(array4, 3) == 11);
+    assert(array_total_string_length(array5, 3) == 31);
+}
+
+int main()
+{
+    test_array_total_string_length();
+    printf("All tests passed!\n");
+
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_arraydup.c

@@ -0,0 +1,33 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+// Test cases
+void test_arraydup()
+{
+    int source[] = {1, 2, 3, 4, 5};
+    int num_elements = 5;
+
+    // Test case 1: Test duplication of integers
+    int *result = (int *)arraydup(source, num_elements, sizeof(int));
+    for (int i = 0; i < num_elements; i++)
+    {
+        assert(result[i] == source[i]);
+    }
+    free(result);
+
+    // Test case 2: Test duplication of characters
+    char source_chars[] = {'a', 'b', 'c', 'd', 'e'};
+    char *result_chars = (char *)arraydup(source_chars, num_elements, sizeof(char));
+    for (int i = 0; i < num_elements; i++)
+    {
+        assert(result_chars[i] == source_chars[i]);
+    }
+    free(result_chars);
+}
+
+int main()
+{
+    test_arraydup();
+    printf("All test cases passed!\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_calculate_average_in_int_array.c

@@ -0,0 +1,70 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+// Function to be tested
+double calculate_average_in_int_array(const int *array, size_t size);
+
+// Test cases
+void test_empty_array()
+{
+    int array[] = {};
+    size_t size = 0;
+    double result = calculate_average_in_int_array(array, size);
+    assert(result == 0.0);
+}
+
+void test_single_element_array()
+{
+    int array[] = {5};
+    size_t size = 1;
+    double result = calculate_average_in_int_array(array, size);
+    assert(result == 5.0);
+}
+
+void test_positive_numbers_array()
+{
+    int array[] = {1, 2, 3, 4, 5};
+    size_t size = 5;
+    double result = calculate_average_in_int_array(array, size);
+    assert(result == 3.0);
+}
+
+void test_negative_numbers_array()
+{
+    int array[] = {-3, -1, 2, 4, 6};
+    size_t size = 5;
+    double result = calculate_average_in_int_array(array, size);
+    assert(result == 1.6);
+}
+
+void test_mixed_numbers_array()
+{
+    int array[] = {-2, 5, -8, 10, 4};
+    size_t size = 5;
+    double result = calculate_average_in_int_array(array, size);
+    assert(result == 1.8);
+}
+
+void test_large_numbers_array()
+{
+    int array[10000];
+    for (int i = 0; i < 10000; i++)
+    {
+        array[i] = i * 2;
+    }
+    size_t size = 10000;
+    double result = calculate_average_in_int_array(array, size);
+    assert(result == 9999.0);
+}
+
+int main()
+{
+    test_empty_array();
+    test_single_element_array();
+    test_positive_numbers_array();
+    test_negative_numbers_array();
+    test_mixed_numbers_array();
+    test_large_numbers_array();
+
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_calculate_sum_in_int_array.c

@@ -0,0 +1,47 @@
+#include "../foundationallib.h"
+#include <assert.h>
+FOUNDATIONAL_LIB_FUNC int calculate_sum_in_int_array(const int *array, size_t size)
+{
+    int sum = 0;
+    for (size_t i = 0; i < size; i++)
+    {
+        sum += array[i];
+    }
+    return sum;
+}
+
+int main()
+{
+    // Test Case 1: Empty array
+    const int arr1[] = {};
+    assert(calculate_sum_in_int_array(arr1, 0) == 0);
+
+    // Test Case 2: Array with one element
+    const int arr2[] = {5};
+    assert(calculate_sum_in_int_array(arr2, 1) == 5);
+
+    // Test Case 3: Array with positive integers
+    const int arr3[] = {1, 2, 3, 4, 5};
+    assert(calculate_sum_in_int_array(arr3, 5) == 15);
+
+    // Test Case 4: Array with negative integers
+    const int arr4[] = {-1, -2, -3, -4, -5};
+    assert(calculate_sum_in_int_array(arr4, 5) == -15);
+
+    // Test Case 5: Array with mixed positive and negative integers
+    const int arr5[] = {1, -2, 3, -4, 5};
+    assert(calculate_sum_in_int_array(arr5, 5) == 3);
+
+    // Test Case 6: Array with maximum size
+    const int max_size = 1000000; // Maximum size for array
+    int arr6[max_size];
+    for (int i = 0; i < max_size; i++)
+    {
+        arr6[i] = 1;
+    }
+    assert(calculate_sum_in_int_array(arr6, max_size) == max_size);
+
+    printf("All test cases passed successfully!\n");
+
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_common_prefix_length.c

@@ -0,0 +1,23 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+int main()
+{
+    // Test cases
+    assert(common_prefix_length("abcdef", "abcde") == 5);
+    assert(common_prefix_length("abc", "abcde") == 3);
+    assert(common_prefix_length("abcdef", "xyz") == 0);
+    assert(common_prefix_length("abc", "abcdef") == 3);
+    assert(common_prefix_length("", "") == 0);
+    assert(common_prefix_length("abc", "abc") == 3);
+    assert(common_prefix_length("a", "b") == 0);
+    assert(common_prefix_length("abc", "") == 0);
+
+    // Additional corner cases
+    assert(common_prefix_length(NULL, "abc") == 0);
+    assert(common_prefix_length("abc", NULL) == 0);
+    assert(common_prefix_length(NULL, NULL) == 0);
+
+    printf("All tests passed!\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_common_suffix_length.c

@@ -0,0 +1,23 @@
+#include "../foundationallib.h"
+#include <assert.h>
+void test_common_suffix_length()
+{
+    // Test cases
+    assert(common_suffix_length("hello", "world") == 0);
+    assert(common_suffix_length("hello", "hello") == 5);
+    assert(common_suffix_length("hello", "o") == 1);
+    assert(common_suffix_length("", "") == 0);
+    assert(common_suffix_length("abc", "def") == 0);
+    assert(common_suffix_length("abcdef", "def") == 3);
+    assert(common_suffix_length("abcdef", "de") == 2);
+    assert(common_suffix_length("abcdef", "") == 0);
+    assert(common_suffix_length("", "abcdef") == 0);
+    assert(common_suffix_length("foo/bar", "bar") == 3);
+}
+
+int main()
+{
+    test_common_suffix_length();
+    printf("All tests passed!\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_concatenate_five_strings.c

@@ -0,0 +1,32 @@
+#include "../foundationallib.h"
+#include <assert.h>
+int main()
+{
+    // Test case 1: Test with all empty strings
+    char *result1 = concatenate_five_strings("", "", "", "", "");
+    assert(strcmp(result1, "") == 0);
+    free(result1);
+
+    // Test case 2: Test with non-empty strings
+    char *result2 = concatenate_five_strings("Hello, ", "world", "!", " This is ", "a test!");
+    assert(strcmp(result2, "Hello, world! This is a test!") == 0);
+    free(result2);
+
+    // Test case 3: Test with one empty string
+    char *result3 = concatenate_five_strings("Hello, ", "world", "!", " This is ", "");
+    assert(strcmp(result3, "Hello, world! This is ") == 0);
+    free(result3);
+
+    // Test case 4: Test with long strings
+    char *result4 = concatenate_five_strings("Lorem ipsum dolor sit amet, ", "consectetur adipiscing elit. ", "Integer ", "nec ", "odio.");
+    assert(strcmp(result4, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer nec odio.") == 0);
+    free(result4);
+
+    // Test case 5: Test with NULL strings
+    char *result5 = concatenate_five_strings(NULL, "world", "!", " This is ", "a test!");
+    assert(result5 == NULL);
+
+    printf("All tests passed successfully!\n");
+
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_concatenate_four_strings.c

@@ -0,0 +1,39 @@
+#include "../foundationallib.h"
+// Test cases
+void test_concatenate_four_strings()
+{
+    // Test case 1: All empty strings
+    char *result1 = concatenate_four_strings("", "", "", "");
+    assert(result1 != NULL);
+    assert(strcmp(result1, "") == 0);
+    free(result1);
+
+    // Test case 2: One empty string
+    char *result2 = concatenate_four_strings("abc", "", "def", "ghi");
+    assert(result2 != NULL);
+    assert(strcmp(result2, "abcdefghi") == 0);
+    free(result2);
+
+    // Test case 3: All non-empty strings
+    char *result3 = concatenate_four_strings("This ", "is a ", "test ", "string");
+    assert(result3 != NULL);
+    assert(strcmp(result3, "This is a test string") == 0);
+    free(result3);
+
+    // Test case 4: Testing long strings
+    char *result4 = concatenate_four_strings("Lorem ipsum ", "dolor sit amet, ", "consectetur adipiscing ", "elit");
+    assert(result4 != NULL);
+    assert(strcmp(result4, "Lorem ipsum dolor sit amet, consectetur adipiscing elit") == 0);
+    free(result4);
+
+    // Test case 5: Testing NULL input
+    char *result5 = concatenate_four_strings(NULL, "abc", "def", "ghi");
+    assert(result5 == NULL);
+}
+
+int main()
+{
+    test_concatenate_four_strings();
+    printf("All tests passed!\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_concatenate_string_array.c

@@ -0,0 +1,28 @@
+#include "../foundationallib.h"
+#include <assert.h>
+// Test Suite
+int main()
+{
+    const char *test_strings1[] = {"Hello, ", "world!"};
+    char *result1 = concatenate_string_array(test_strings1, 2);
+    assert(strcmp(result1, "Hello, world!") == 0);
+    free(result1);
+
+    const char *test_strings2[] = {"This ", "is ", "a ", "test."};
+    char *result2 = concatenate_string_array(test_strings2, 4);
+    assert(strcmp(result2, "This is a test.") == 0);
+    free(result2);
+
+    const char *test_strings3[] = {"One string only."};
+    char *result3 = concatenate_string_array(test_strings3, 1);
+    assert(strcmp(result3, "One string only.") == 0);
+    free(result3);
+
+    const char *test_strings4[] = {NULL};
+    char *result4 = concatenate_string_array(test_strings4, 0);
+    assert(result4 == NULL);
+    free(result4);
+
+    printf("All tests passed!\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_concatenate_strings.c

@@ -0,0 +1,47 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+void test_concatenate_strings()
+{
+    // Test case 1: both strings are empty
+    const char *str1 = "";
+    const char *str2 = "";
+    char *result = concatenate_strings(str1, str2);
+    assert(strcmp(result, "") == 0);
+    free(result);
+
+    // Test case 2: one string is empty
+    str1 = "Hello";
+    str2 = "";
+    result = concatenate_strings(str1, str2);
+    assert(strcmp(result, "Hello") == 0);
+    free(result);
+
+    // Test case 3: both strings are non-empty
+    str1 = "Hello, ";
+    str2 = "World!";
+    result = concatenate_strings(str1, str2);
+    assert(strcmp(result, "Hello, World!") == 0);
+    free(result);
+
+    // Test case 4: one string is NULL
+    str1 = "Hello";
+    str2 = NULL;
+    result = concatenate_strings(str1, str2);
+    assert(result == NULL);
+    free(result);
+
+    // Test case 5: both strings are NULL
+    str1 = NULL;
+    str2 = NULL;
+    result = concatenate_strings(str1, str2);
+    assert(result == NULL);
+    free(result);
+}
+
+int main()
+{
+    test_concatenate_strings();
+    printf("All tests passed!\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_concatenate_three_strings.c

@@ -0,0 +1,43 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+void test_concatenate_three_strings()
+{
+    // Test case 1: all empty strings
+    const char *str1 = "";
+    const char *str2 = "";
+    const char *str3 = "";
+    char *result = concatenate_three_strings(str1, str2, str3);
+    assert(strcmp(result, "") == 0);
+    free(result);
+
+    // Test case 2: one empty string
+    str1 = "hello";
+    str2 = "";
+    str3 = "world";
+    result = concatenate_three_strings(str1, str2, str3);
+    assert(strcmp(result, "helloworld") == 0);
+    free(result);
+
+    // Test case 3: all non-empty strings
+    str1 = "This ";
+    str2 = "is a ";
+    str3 = "test";
+    result = concatenate_three_strings(str1, str2, str3);
+    assert(strcmp(result, "This is a test") == 0);
+    free(result);
+
+    // Test case 4: memory allocation failure
+    char *ptr = (char *)malloc(1);
+    assert(ptr != NULL); // Ensure that memory allocation works fine
+    free(ptr);
+    ptr = (char *)malloc(1);
+    assert(ptr == NULL); // Ensure that memory allocation fails
+}
+
+int main()
+{
+    test_concatenate_three_strings();
+    printf("All tests passed successfully.\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_count_occurrences_of_substr.c

@@ -0,0 +1,21 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+int main()
+{
+    // Test cases and assertions for count_occurrences_of_subst
+    assert(count_occurrences_of_substr("hellohellohello", "hello") == 3);
+    assert(count_occurrences_of_substr("abcabcabc", "abc") == 3);
+    assert(count_occurrences_of_substr("aaaaaaa", "aaa") == 4);
+    assert(count_occurrences_of_substr("not found", "abc") == 0);
+    assert(count_occurrences_of_substr("Case sensitive", "case") == 0);
+    assert(count_occurrences_of_substr("Case sensitive", "Case") == 1);
+
+    // Additional edge cases
+    assert(count_occurrences_of_substr("aaaaa", "aa") == 4);
+    assert(count_occurrences_of_substr("ababababa", "aba") == 3);
+    assert(count_occurrences_of_substr("", "abc") == 0);
+    assert(count_occurrences_of_substr("abc", "") == 0);
+
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_count_occurrences_of_substr_len.c

@@ -0,0 +1,66 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+// The function to be tested
+size_t count_occurrences_of_substr_len(const char *string, size_t string_length, const char *substring, size_t substring_length);
+
+void test_0_occurrences()
+{
+    const char *str = "This is a test string.";
+    const char *sub = "apple";
+    size_t count = count_occurrences_of_substr_len(str, strlen(str), sub, strlen(sub));
+    assert(count == 0);
+}
+
+void test_1_occurrence()
+{
+    const char *str = "This is a test string.";
+    const char *sub = "test";
+    size_t count = count_occurrences_of_substr_len(str, strlen(str), sub, strlen(sub));
+    assert(count == 1);
+}
+
+void test_case_sensitive()
+{
+    const char *str = "This is a test string for testing.";
+    const char *sub = "Test";
+    size_t count = count_occurrences_of_substr_len(str, strlen(str), sub, strlen(sub));
+    assert(count == 0);
+}
+
+void test_overlapping_occurrences()
+{
+    const char *str = "aaaaaa";
+    const char *sub = "aaa";
+    size_t count = count_occurrences_of_substr_len(str, strlen(str), sub, strlen(sub));
+    assert(count == 4);
+}
+
+void test_empty_string()
+{
+    const char *str = "";
+    const char *sub = "test";
+    size_t count = count_occurrences_of_substr_len(str, strlen(str), sub, strlen(sub));
+    assert(count == 0);
+}
+
+void test_empty_substring()
+{
+    const char *str = "This is a test string.";
+    const char *sub = "";
+    size_t count = count_occurrences_of_substr_len(str, strlen(str), sub, strlen(sub));
+    assert(count == strlen(str) + 1);
+}
+
+int main()
+{
+    test_0_occurrences();
+    test_1_occurrence();
+    test_case_sensitive();
+    test_overlapping_occurrences();
+    test_empty_string();
+    test_empty_substring();
+
+    printf("All tests passed successfully!\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_dict_add.c

@@ -0,0 +1,49 @@
+#include "../foundationallib.h"
+#include <assert.h>
+// Define the dictionary structure
+struct Dict
+{
+    char *key;
+    void *value;
+};
+
+// Test function for dict_add
+void test_dict_add()
+{
+    // Create a new dictionary
+    struct Dict *dict = (struct Dict *)malloc(sizeof(struct Dict));
+    assert(dict != NULL);
+
+    // Test adding a key-value pair
+    const char *key1 = "key1";
+    int value1 = 10;
+    assert(dict_add(dict, key1, &value1) == 0);
+    assert(strcmp(dict->key, key1) == 0);
+    assert(*(int *)dict->value == value1);
+
+    // Test adding a duplicate key
+    const char *key2 = "key2";
+    int value2 = 20;
+    assert(dict_add(dict, key2, &value2) == 0);
+    assert(strcmp(dict->key, key2) == 0);
+    assert(*(int *)dict->value == value2);
+
+    // Test adding NULL key
+    assert(dict_add(dict, NULL, &value1) == -1);
+
+    // Test adding NULL value
+    const char *key3 = "key3";
+    assert(dict_add(dict, key3, NULL) == -1);
+
+    // Test adding to a NULL dictionary
+    assert(dict_add(NULL, key1, &value1) == -1);
+
+    free(dict);
+}
+
+int main()
+{
+    test_dict_add();
+    printf("All tests passed successfully\n");
+    return 0;
+}

data/tests/more/experimental/third_test_suite/non_production_ready_test_suite/test_every_relevant_function_in_a_separate_thorough_program/work_in_progress_code/src/test_dict_del_key.c

@@ -0,0 +1,26 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+int main()
+{
+    // Test dictionary
+    struct Dict *test_dict = dict_new_instance();
+    struct Dict *test_dict2 = dict_new_instance();
+
+    // Test case 1: Deleting an existing key
+    dict_del_key(test_dict, "test_key");
+
+    assert(!dict_get(test_dict, "test_key"));
+
+    // Test case 2: Deleting a non-existing key
+    dict_del_key(test_dict2, "non_existing_key");
+    assert(!dict_get(test_dict2, "non_existing_key"));
+
+    // Add more test cases for edge and corner cases
+
+    printf("All test cases passed successfully!\n");
+
+    free(test_dict);
+    free(test_dict2);
+    return 0;
+}