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_is_string_upper.c

@@ -0,0 +1,72 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int is_string_upper(const char *str)
+{
+    if (str == NULL)
+    {
+        return 0;
+    }
+
+    while (*str)
+    {
+        if (!(*str >= 'A' && *str <= 'Z'))
+        {
+            return 0;
+        }
+        str++;
+    }
+    return 1;
+}
+
+void test_is_string_upper()
+{
+    // Test with empty string
+    assert(is_string_upper("") == 1);
+
+    // Test with all uppercase string
+    assert(is_string_upper("HELLO") == 1);
+
+    // Test with mixed case string
+    assert(is_string_upper("Hello") == 0);
+
+    // Test with lowercase string
+    assert(is_string_upper("hello") == 0);
+
+    // Test with special characters
+    assert(is_string_upper("!@#$%") == 0);
+
+    // Test with NULL input
+    assert(is_string_upper(NULL) == 0);
+
+    // Test with long uppercase string
+    char long_upper[1000];
+    for (int i = 0; i < 1000; i++)
+    {
+        long_upper[i] = 'A';
+    }
+    long_upper[1000] = '\0';
+    assert(is_string_upper(long_upper) == 1);
+
+    // Test with long mixed case string
+    char long_mixed[1000];
+    for (int i = 0; i < 500; i++)
+    {
+        long_mixed[i] = 'A';
+    }
+    for (int i = 500; i < 1000; i++)
+    {
+        long_mixed[i] = 'a';
+    }
+    long_mixed[1000] = '\0';
+    assert(is_string_upper(long_mixed) == 0);
+}
+
+int main()
+{
+    test_is_string_upper();
+    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_is_valid_integer.c

@@ -0,0 +1,16 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+int main()
+{
+    assert(is_valid_integer("123456") == 1);
+    assert(is_valid_integer("-123456") == 0);
+    assert(is_valid_integer("12a3456") == 0);
+    assert(is_valid_integer("0") == 1);
+    assert(is_valid_integer("12345678901234567890") == 1);
+    assert(is_valid_integer("") == 0);
+
+    printf("All tests pass!\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_is_valid_utf8.c

@@ -0,0 +1,46 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stddef.h>
+// Tests for valid UTF-8 sequences
+void test_valid_utf8_sequences()
+{
+    const char *valid_sequences[] = {
+        "Hello, world!",    "UTF-8 is awesome 😊", "こんにちは",
+        "\xF0\x9F\x98\x8A", // Unicode "grinning face with smiling eyes" emoji
+        "\xE2\x82\xAC",     // Euro sign
+        "\xE2\x82\xA1"      // Unassigned code point
+    };
+
+    for (size_t i = 0; i < sizeof(valid_sequences) / sizeof(valid_sequences[0]); i++)
+    {
+        assert(is_valid_utf8(valid_sequences[i], len) == 1);
+    }
+}
+
+// Tests for invalid UTF-8 sequences
+void test_invalid_utf8_sequences()
+{
+    const char *invalid_sequences[] = {
+        "Hello, \xF0\x9F\x98 world!",               // Invalid continuation byte
+        "UTF-8 is awesome \xF0",                    // Incomplete encoding
+        "こんにちは\x80",                           // Overlong encoding
+        "Broken \xED\xA0\x80\xED\xB0\x80 sequence", // Surrogate pair
+        "This is not \xC0\xAFbinary",
+        "This is \xC0z",            // Overlong encoding
+        "This is \xE0\x80\x80",     // Overlong encoding
+        "This is \xF4\x90\x80\x80", // Code point > U+10FFFF
+        "This is \xF8A00000"        // Code point > U+10FFFF
+    };
+
+    for (size_t i = 0; i < sizeof(invalid_sequences) / sizeof(invalid_sequences[0]); i++)
+    {
+        assert(is_valid_utf8(invalid_sequences[i], len) == 0);
+    }
+}
+
+int main()
+{
+    test_valid_utf8_sequences();
+    test_invalid_utf8_sequences();
+    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_join.c

@@ -0,0 +1,53 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+void test_join()
+{
+    const char *array1[] = {"hello", "world", "good", "morning"};
+    const char *delimiter1 = ",";
+    char *expected_result1 = "hello,world,good,morning";
+    char *result1 = join(array1, 4, delimiter1);
+    assert(strcmp(result1, expected_result1) == 0);
+    free(result1);
+
+    const char *array2[] = {"apple", "orange"};
+    const char *delimiter2 = "|";
+    char *expected_result2 = "apple|orange";
+    char *result2 = join(array2, 2, delimiter2);
+    assert(strcmp(result2, expected_result2) == 0);
+    free(result2);
+
+    const char *array3[] = {"This", "is", "a", "test"};
+    const char *delimiter3 = " ";
+    char *expected_result3 = "This is a test";
+    char *result3 = join(array3, 4, delimiter3);
+    assert(strcmp(result3, expected_result3) == 0);
+    free(result3);
+
+    const char *array4[] = {"Hello"};
+    const char *delimiter4 = "-";
+    char *expected_result4 = "Hello";
+    char *result4 = join(array4, 1, delimiter4);
+    assert(strcmp(result4, expected_result4) == 0);
+    free(result4);
+
+    const char *array5[] = {""};
+    const char *delimiter5 = ":";
+    char *expected_result5 = "";
+    char *result5 = join(array5, 1, delimiter5);
+    assert(strcmp(result5, expected_result5) == 0);
+    free(result5);
+
+    const char *array6[] = {NULL, "world", "hello"};
+    const char *delimiter6 = " ";
+    char *result6 = join(array6, 3, delimiter6);
+    assert(result6 == NULL);
+}
+
+int main()
+{
+    test_join();
+    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_last_index_of_char.c

@@ -0,0 +1,15 @@
+#include "../foundationallib.h"
+#include <assert.h>
+int main()
+{
+    // Test cases
+    assert(last_index_of_char("hello", 'l') == 3);
+    assert(last_index_of_char("hello", 'o') == 4);
+    assert(last_index_of_char("hello", 'h') == 0);
+    assert(last_index_of_char("hello", 'z') == -1);
+    assert(last_index_of_char("", 'a') == -1);
+    assert(last_index_of_char("hello", '\0') == -1);
+
+    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_list_comprehension.c

@@ -0,0 +1,95 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Define the function signature for list_comprehension
+typedef void *(*LIST_COMP_FUNC)(const void *, size_t, size_t, void (*)(void *), int (*)(void *), size_t *);
+
+// Function to test list_comprehension with integers
+void test_list_comprehension_integers(LIST_COMP_FUNC func)
+{
+    size_t input[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+    size_t input_size = sizeof(input) / sizeof(input[0]);
+
+    void square_transform(void *value)
+    {
+        size_t *num = (size_t *)value;
+        *num = (*num) * (*num);
+    }
+
+    int odd_filter(void *value)
+    {
+        size_t *num = (size_t *)value;
+        return (*num) % 2 != 0;
+    }
+
+    size_t result_size;
+    size_t *result = (size_t *)func(input, input_size, sizeof(size_t), square_transform, odd_filter, &result_size);
+
+    size_t expected_result[] = {1, 9, 25, 49, 81};
+    size_t expected_result_size = sizeof(expected_result) / sizeof(expected_result[0]);
+
+    assert(result_size == expected_result_size);
+    for (int i = 0; i < result_size; i++)
+    {
+        assert(result[i] == expected_result[i]);
+    }
+
+    free(result);
+}
+
+// Function to test list_comprehension with strings
+void test_list_comprehension_strings(LIST_COMP_FUNC func)
+{
+    const char *words[] = {"apple", "banana", "orange", "grape", "kiwi"};
+    size_t words_size = sizeof(words) / sizeof(words[0]);
+
+    void uppercase_transform(void *value)
+    {
+        char **str = (char **)value;
+        for (int i = 0; (*str)[i]; ++i)
+        {
+            (*str)[i] = toupper((*str)[i]);
+        }
+    }
+
+    int exclude_a_filter(void *value)
+    {
+        char **str = (char **)value;
+        return (*str)[0] != 'a' && (*str)[0] != 'A';
+    }
+
+    size_t result_size;
+    char **result = (char **)func(words, words_size, sizeof(char *), uppercase_transform, exclude_a_filter, &result_size);
+
+    const char *expected_result[] = {"ORANGE", "GRAPE", "KIWI"};
+    size_t expected_result_size = sizeof(expected_result) / sizeof(expected_result[0]);
+
+    assert(result_size == expected_result_size);
+    for (int i = 0; i < result_size; i++)
+    {
+        assert(strcmp(result[i], expected_result[i]) == 0);
+    }
+
+    for (int i = 0; i < result_size; i++)
+    {
+        free(result[i]);
+    }
+    free(result);
+}
+
+int main()
+{
+    // Test list_comprehension with integers
+    printf("Testing list_comprehension with integers...\n");
+    test_list_comprehension_integers(list_comprehension);
+
+    // Test list_comprehension with strings
+    printf("Testing list_comprehension with strings...\n");
+    test_list_comprehension_strings(list_comprehension);
+
+    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_list_comprehension_multithreaded.c

@@ -0,0 +1,41 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+void transform_function(void *value)
+{
+    int *val = (int *)value;
+    *val = *val * 2;
+}
+
+int filter_function(void *value)
+{
+    int *val = (int *)value;
+    return *val % 2 == 0;
+}
+
+void test_list_comprehension_multithreaded()
+{
+    size_t input_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    size_t array_size = sizeof(input_array) / sizeof(input_array[0]);
+    size_t elem_size = sizeof(input_array[0]);
+    size_t result_size;
+
+    int expected_output[] = {4, 8, 12, 16, 20};
+    void *result = list_comprehension_multithreaded(input_array, array_size, elem_size, transform_function, filter_function, &result_size, 2);
+
+    assert(result_size == sizeof(expected_output) / sizeof(expected_output[0]));
+    for (size_t i = 0; i < result_size; i++)
+    {
+        assert(*(int *)(result + (i * elem_size)) == expected_output[i]);
+    }
+
+    free(result);
+}
+
+int main()
+{
+    test_list_comprehension_multithreaded();
+    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_longest_common_prefix.c

@@ -0,0 +1,35 @@
+#include "../foundationallib.h"
+#include <assert.h>
+void test_longest_common_prefix()
+{
+    const char *input1[] = {"flower", "flow", "flight"};
+    char *result1 = longest_common_prefix(input1, 3);
+    assert(strcmp(result1, "fl") == 0);
+    free(result1);
+
+    const char *input2[] = {"dog", "racecar", "car"};
+    char *result2 = longest_common_prefix(input2, 3);
+    assert(result2 == NULL);
+
+    const char *input3[] = {"", "abc", "def"};
+    char *result3 = longest_common_prefix(input3, 3);
+    assert(strcmp(result3, "") == 0);
+    free(result3);
+
+    const char *input4[] = {"", "", ""};
+    char *result4 = longest_common_prefix(input4, 3);
+    assert(strcmp(result4, "") == 0);
+    free(result4);
+
+    const char *input5[] = {"abcd", "abcd", "abcd"};
+    char *result5 = longest_common_prefix(input5, 3);
+    assert(strcmp(result5, "abcd") == 0);
+    free(result5);
+}
+
+int main()
+{
+    test_longest_common_prefix();
+    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_longest_common_suffix.c

@@ -0,0 +1,61 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <string.h>
+
+// Define this if the function is part of a library
+
+// Function to test
+FOUNDATIONAL_LIB_FUNC char *longest_common_suffix(const char **strings, size_t count);
+
+// Test cases
+void testSingleString()
+{
+    const char *input[] = {"hello"};
+    char *result = longest_common_suffix(input, 1);
+    assert(strcmp(result, "hello") == 0);
+    free(result);
+}
+
+void testEmptyStrings()
+{
+    const char *input[] = {"", "", ""};
+    char *result = longest_common_suffix(input, 3);
+    assert(strcmp(result, "") == 0);
+    free(result);
+}
+
+void testNoCommonSuffix()
+{
+    const char *input[] = {"hello", "world", "foo"};
+    char *result = longest_common_suffix(input, 3);
+    assert(strcmp(result, "") == 0);
+    free(result);
+}
+
+void testCommonSuffix()
+{
+    const char *input[] = {"testing", "ing", "string"};
+    char *result = longest_common_suffix(input, 3);
+    assert(strcmp(result, "ing") == 0);
+    free(result);
+}
+
+void testLongestCommonSuffix()
+{
+    const char *input[] = {"apple", "people", "staple"};
+    char *result = longest_common_suffix(input, 3);
+    assert(strcmp(result, "ple") == 0);
+    free(result);
+}
+
+int main()
+{
+    testSingleString();
+    testEmptyStrings();
+    testNoCommonSuffix();
+    testCommonSuffix();
+    testLongestCommonSuffix();
+
+    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_map.c

@@ -0,0 +1,46 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void map(void *array, size_t size, size_t elem_size, void (*transform)(void *));
+
+void increment_transform(void *element) { (*(int *)element)++; }
+
+void double_transform(void *element) { (*(double *)element) *= 2; }
+
+void test_map()
+{
+    int int_array[] = {1, 2, 3, 4, 5};
+    double double_array[] = {1.5, 2.5, 3.5, 4.5, 5.5};
+    const size_t int_size = sizeof(int);
+    const size_t double_size = sizeof(double);
+
+    // Test with increment_transform on int_array
+    map(int_array, 5, int_size, increment_transform);
+    assert(int_array[0] == 2);
+    assert(int_array[1] == 3);
+    assert(int_array[2] == 4);
+    assert(int_array[3] == 5);
+    assert(int_array[4] == 6);
+
+    // Test with double_transform on double_array
+    map(double_array, 5, double_size, double_transform);
+    assert(double_array[0] == 3.0);
+    assert(double_array[1] == 5.0);
+    assert(double_array[2] == 7.0);
+    assert(double_array[3] == 9.0);
+    assert(double_array[4] == 11.0);
+
+    // Test with increment_transform on empty array
+    int *empty_array = NULL;
+    map(empty_array, 0, int_size, increment_transform);
+    assert(empty_array == NULL);
+}
+
+int main()
+{
+    test_map();
+    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_map_int.c

@@ -0,0 +1,59 @@
+#include "../foundationallib.h"
+
+#define _CRT_SECURE_NO_WARNINGS
+#include <assert.h>
+#include <stdio.h>
+
+// Function to be tested
+void map_int(int *array, size_t size, int (*transform)(int))
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        array[i] = transform(array[i]);
+    }
+}
+
+// Test suite
+void test_map_int()
+{
+    // Test case 1: Test with an empty array
+    int empty_array[] = {};
+    map_int(empty_array, 0, NULL); // No transformation function, should not crash
+
+    // Test case 2: Test with positive numbers
+    int positive_array[] = {1, 2, 3, 4, 5};
+    map_int(positive_array, 5, NULL); // No transformation function, should not crash
+    assert(positive_array[0] == 1);
+    assert(positive_array[1] == 2);
+    assert(positive_array[2] == 3);
+    assert(positive_array[3] == 4);
+    assert(positive_array[4] == 5);
+
+    // Test case 3: Test with a transformation function
+    int square_array[] = {1, 2, 3, 4, 5};
+    map_int(square_array, 5, square_transform); // User-defined transformation function
+    assert(square_array[0] == 1);
+    assert(square_array[1] == 4);
+    assert(square_array[2] == 9);
+    assert(square_array[3] == 16);
+    assert(square_array[4] == 25);
+
+    // Test case 4: Test with negative numbers
+    int negative_array[] = {-1, -2, -3, -4, -5};
+    map_int(negative_array, 5, NULL); // No transformation function, should not crash
+    assert(negative_array[0] == -1);
+    assert(negative_array[1] == -2);
+    assert(negative_array[2] == -3);
+    assert(negative_array[3] == -4);
+    assert(negative_array[4] == -5);
+}
+
+// User-defined transformation function
+int square_transform(int x) { return x * x; }
+
+int main()
+{
+    test_map_int();
+    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_prepend_string_to_array.c

@@ -0,0 +1,68 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int prepend_string_to_array(const char ***array, size_t *array_size, size_t *array_current_alloc_size, const char *string)
+{
+    if (*array_size >= *array_current_alloc_size)
+    {
+        size_t new_size = *array_current_alloc_size == 0 ? 1 : *array_current_alloc_size * 2;
+        const char **new_array = realloc(*array, new_size * sizeof(const char *));
+        if (!new_array)
+        {
+            return -1; // Realloc failed
+        }
+        *array = new_array;
+        *array_current_alloc_size = new_size;
+    }
+
+    memmove(*array + 1, *array, *array_size * sizeof(const char *)); // Shift existing elements
+    (*array)[0] = strdup(string);
+    (*array_size)++;
+
+    return 0;
+}
+
+void test_prepend_string()
+{
+    const char **array = NULL;
+    size_t array_size = 0;
+    size_t array_current_alloc_size = 0;
+
+    // Test prepending to an empty array
+    prepend_string_to_array(&array, &array_size, &array_current_alloc_size, "first");
+    assert(array_size == 1);
+    assert(array_current_alloc_size >= 1);
+    assert(strcmp(array[0], "first") == 0);
+
+    // Test prepending to a non-empty array
+    prepend_string_to_array(&array, &array_size, &array_current_alloc_size, "second");
+    assert(array_size == 2);
+    assert(array_current_alloc_size >= 2);
+    assert(strcmp(array[0], "second") == 0);
+    assert(strcmp(array[1], "first") == 0);
+
+    // Test prepending to a full array
+    prepend_string_to_array(&array, &array_size, &array_current_alloc_size, "third");
+    assert(array_size == 3);
+    assert(array_current_alloc_size >= 3);
+    assert(strcmp(array[0], "third") == 0);
+    assert(strcmp(array[1], "second") == 0);
+    assert(strcmp(array[2], "first") == 0);
+
+    // Clean up
+    for (size_t i = 0; i < array_size; i++)
+    {
+        free((void *)array[i]);
+    }
+    free(array);
+}
+
+int main()
+{
+    test_prepend_string();
+    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_prepend_string_to_array_no_initial_alloc.c

@@ -0,0 +1,57 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* The function to be tested */
+FOUNDATIONAL_LIB_FUNC int prepend_string_to_array_no_initial_alloc(const char ***array, size_t *array_size, size_t *array_current_alloc_size, const char *string)
+{
+    // Implementation of the function
+}
+
+/* Test for adding a string to an empty array */
+void test_prepend_to_empty_array()
+{
+    const char **array = NULL;
+    size_t array_size = 0;
+    size_t array_current_alloc_size = 0;
+    const char *new_string = "test";
+
+    prepend_string_to_array_no_initial_alloc(&array, &array_size, &array_current_alloc_size, new_string);
+
+    assert(array_size == 1);
+    assert(array_current_alloc_size >= 1);
+    assert(strcmp(array[0], new_string) == 0);
+
+    free(array);
+}
+
+/* Test for adding a string to a non-empty array */
+void test_prepend_to_non_empty_array()
+{
+    const char *initial_array[] = {"existing1", "existing2"};
+    const char **array = initial_array;
+    size_t array_size = 2;
+    size_t array_current_alloc_size = 2;
+    const char *new_string = "test";
+
+    prepend_string_to_array_no_initial_alloc(&array, &array_size, &array_current_alloc_size, new_string);
+
+    assert(array_size == 3);
+    assert(array_current_alloc_size >= 3);
+    assert(strcmp(array[0], new_string) == 0);
+    assert(strcmp(array[1], "existing1") == 0);
+    assert(strcmp(array[2], "existing2") == 0);
+
+    free(array);
+}
+
+int main()
+{
+    test_prepend_to_empty_array();
+    test_prepend_to_non_empty_array();
+
+    printf("All tests passed!\n");
+    return 0;
+}