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

@@ -0,0 +1,58 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// define this macro for library functions
+
+// Function to duplicate a formatted string
+char *dup_format(const char *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    int length = vsnprintf(NULL, 0, format, args);
+    va_end(args);
+
+    char *result = (char *)malloc(length + 1);
+    if (result)
+    {
+        va_start(args, format);
+        vsnprintf(result, length + 1, format, args);
+        va_end(args);
+    }
+
+    return result;
+}
+
+int main()
+{
+    // Test suite for dup_format function
+    char *result;
+
+    // Test case 1: Basic format string
+    result = dup_format("%s %d", "Test", 123);
+    assert(strcmp(result, "Test 123") == 0);
+    free(result);
+
+    // Test case 2: Empty format string
+    result = dup_format("");
+    assert(strcmp(result, "") == 0);
+    free(result);
+
+    // Test case 3: Format string with large number of variables
+    result = dup_format("%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
+    assert(strcmp(result, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20") == 0);
+    free(result);
+
+    // Test case 4: NULL format string
+    result = dup_format(NULL);
+    assert(result == NULL);
+
+    // Add more test cases for corner cases
+
+    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_ends_with.c

@@ -0,0 +1,48 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int ends_with(const char *str, const char *suffix)
+{
+    if (str == NULL || suffix == NULL)
+    {
+        return 0;
+    }
+
+    size_t str_len = strlen(str);
+    size_t suffix_len = strlen(suffix);
+
+    if (suffix_len > str_len)
+    {
+        return 0;
+    }
+
+    return (strncmp(str + (str_len - suffix_len), suffix, suffix_len) == 0) ? 1 : 0;
+}
+
+int main()
+{
+    // Test cases
+    assert(ends_with("hello", "lo") == 1);
+    assert(ends_with("hello", "hello") == 1);
+    assert(ends_with("hello", "llo") == 1);
+    assert(ends_with("hello", "hello!") == 0);
+    assert(ends_with("hello", "o") == 1);
+    assert(ends_with("hello", "h") == 0);
+    assert(ends_with("hello", "") == 1);
+    assert(ends_with("", "suffix") == 0);
+    assert(ends_with("", "") == 1);
+
+    // Additional corner cases
+    assert(ends_with("hello", "HELLO") == 0);  // Case-sensitive check
+    assert(ends_with("hello", "lo!") == 0);    // Partial match
+    assert(ends_with("hello", "hello") == 1);  // Full match
+    assert(ends_with("hello", "o") == 1);      // Single character suffix
+    assert(ends_with("hello", "hello!") == 0); // Suffix longer than string
+    assert(ends_with("hello", "H") == 0);      // Case-sensitive check
+
+    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_equal_array_of_char_ptrs.c

@@ -0,0 +1,55 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+// Function prototype
+FOUNDATIONAL_LIB_FUNC int equal_array_of_char_ptrs(const char **array, const char **array2, size_t size);
+
+// Test cases
+void test_equal_arrays()
+{
+    const char *arr1[] = {"abc", "def", "ghi"};
+    const char *arr2[] = {"abc", "def", "ghi"};
+    assert(equal_array_of_char_ptrs(arr1, arr2, 3) == 1);
+}
+
+void test_unequal_arrays()
+{
+    const char *arr1[] = {"abc", "def", "ghi"};
+    const char *arr2[] = {"abc", "xyz", "ghi"};
+    assert(equal_array_of_char_ptrs(arr1, arr2, 3) == 0);
+}
+
+void test_empty_arrays()
+{
+    const char *arr1[] = {};
+    const char *arr2[] = {};
+    assert(equal_array_of_char_ptrs(arr1, arr2, 0) == 1);
+}
+
+void test_different_sizes()
+{
+    const char *arr1[] = {"abc", "def", "ghi"};
+    const char *arr2[] = {"abc", "def", "ghi", "jkl"};
+    assert(equal_array_of_char_ptrs(arr1, arr2, 3) == 0);
+}
+
+void test_null_arrays()
+{
+    const char *arr1[] = {"abc", "def", "ghi"};
+    const char *arr2[] = {NULL, NULL, "ghi"};
+    assert(equal_array_of_char_ptrs(arr1, arr2, 3) == 0);
+}
+
+int main()
+{
+    test_equal_arrays();
+    test_unequal_arrays();
+    test_empty_arrays();
+    test_different_sizes();
+    test_null_arrays();
+
+    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_equal_array_of_chars.c

@@ -0,0 +1,53 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_chars(const char *array, const char *array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+void test_equal_array_of_chars()
+{
+    const char test1[] = {'a', 'b', 'c'};
+    const char test2[] = {'a', 'b', 'c'};
+    const char test3[] = {'a', 'b', 'd'};
+
+    // Test equal arrays
+    assert(equal_array_of_chars(test1, test2, 3) == 1);
+
+    // Test unequal arrays
+    assert(equal_array_of_chars(test1, test3, 3) == 0);
+
+    // Test arrays of different sizes
+    assert(equal_array_of_chars(test1, test2, 2) == 0);
+
+    // Test empty arrays
+    assert(equal_array_of_chars("", "", 0) == 1);
+
+    // Test large arrays
+    char largeArray1[100];
+    char largeArray2[100];
+    for (size_t i = 0; i < 100; i++)
+    {
+        largeArray1[i] = 'a';
+        largeArray2[i] = 'a';
+    }
+    assert(equal_array_of_chars(largeArray1, largeArray2, 100) == 1);
+}
+
+int main()
+{
+    test_equal_array_of_chars();
+    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_equal_array_of_double_ptrs.c

@@ -0,0 +1,50 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stddef.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_double_ptrs(const double **array, const double **array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (*array[i] != *array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Equal arrays
+    const double a[] = {1.1, 2.2, 3.3};
+    const double b[] = {1.1, 2.2, 3.3};
+    const double *array1[] = {a, b};
+    const double *array2[] = {a, b};
+    assert(equal_array_of_double_ptrs(array1, array2, 2) == 1);
+
+    // Test case 2: Unequal arrays
+    const double c[] = {1.1, 2.2, 3.3};
+    const double d[] = {4.4, 5.5, 6.6};
+    const double *array3[] = {c, d};
+    const double *array4[] = {c, c};
+    assert(equal_array_of_double_ptrs(array3, array4, 2) == 0);
+
+    // Test case 3: Empty arrays
+    const double *emptyArray1[] = {};
+    const double *emptyArray2[] = {};
+    assert(equal_array_of_double_ptrs(emptyArray1, emptyArray2, 0) == 1);
+
+    // Test case 4: Arrays with null pointers
+    const double *nullArray1[] = {NULL, NULL, NULL};
+    const double *nullArray2[] = {NULL, NULL, NULL};
+    assert(equal_array_of_double_ptrs(nullArray1, nullArray2, 3) == 1);
+
+    // Test case 5: Arrays with mixed content
+    const double e = 2.2;
+    const double *mixedArray1[] = {&e};
+    const double *mixedArray2[] = {&e};
+    assert(equal_array_of_double_ptrs(mixedArray1, mixedArray2, 1) == 1);
+
+    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_equal_array_of_doubles.c

@@ -0,0 +1,35 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stddef.h>
+
+#define TEST_CASES 5
+
+void test_equal_array_of_doubles()
+{
+    double array1[] = {1.0, 2.0, 3.0};
+    double array2[] = {1.0, 2.0, 3.0};
+    double array3[] = {3.0, 2.0, 1.0};
+    double array4[] = {1.0, 2.0, 3.0, 4.0};
+    double array5[] = {1.0, 2.0, 3.00000000001};
+
+    // Test case 1: Arrays are equal
+    assert(equal_array_of_doubles(array1, array2, 3) == 1);
+
+    // Test case 2: Arrays are not equal
+    assert(equal_array_of_doubles(array1, array3, 3) == 0);
+
+    // Test case 3: Arrays have different sizes
+    assert(equal_array_of_doubles(array1, array4, 3) == 0);
+
+    // Test case 4: Arrays are almost equal
+    assert(equal_array_of_doubles(array1, array5, 3) == 1);
+
+    // Test case 5: Empty arrays are equal
+    assert(equal_array_of_doubles(NULL, NULL, 0) == 1);
+}
+
+int main()
+{
+    test_equal_array_of_doubles();
+    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_equal_array_of_float_ptrs.c

@@ -0,0 +1,36 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+int equal_array_of_float_ptrs(const float **array, const float **array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (*array[i] != *array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+void test_equal_array_of_float_ptrs()
+{
+    const float a[3] = {1.0, 2.0, 3.0};
+    const float b[3] = {1.0, 2.0, 3.0};
+    const float c[3] = {1.0, 2.1, 3.0};
+
+    const float *array1[3] = {&a[0], &a[1], &a[2]};
+    const float *array2[3] = {&b[0], &b[1], &b[2]};
+    const float *array3[3] = {&c[0], &c[1], &c[2]};
+
+    assert(equal_array_of_float_ptrs(array1, array2, 3) == 1); // Same arrays should return 1
+    assert(equal_array_of_float_ptrs(array1, array3, 3) == 0); // Different arrays should return 0
+}
+
+int main()
+{
+    test_equal_array_of_float_ptrs();
+    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_equal_array_of_floats.c

@@ -0,0 +1,45 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+void test_equal_arrays()
+{
+    float arr1[] = {1.0, 2.0, 3.0};
+    float arr2[] = {1.0, 2.0, 3.0};
+    assert(equal_array_of_floats(arr1, arr2, 3) == 1);
+}
+
+void test_unequal_arrays()
+{
+    float arr1[] = {1.0, 2.0, 3.0};
+    float arr2[] = {3.0, 2.0, 1.0};
+    assert(equal_array_of_floats(arr1, arr2, 3) == 0);
+}
+
+void test_empty_arrays()
+{
+    float arr1[] = {};
+    float arr2[] = {};
+    assert(equal_array_of_floats(arr1, arr2, 0) == 1);
+}
+
+void test_large_arrays()
+{
+    float arr1[1000];
+    float arr2[1000];
+    for (int i = 0; i < 1000; i++)
+    {
+        arr1[i] = i;
+        arr2[i] = i;
+    }
+    assert(equal_array_of_floats(arr1, arr2, 1000) == 1);
+}
+
+int main()
+{
+    test_equal_arrays();
+    test_unequal_arrays();
+    test_empty_arrays();
+    test_large_arrays();
+    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_equal_array_of_int_ptrs.c

@@ -0,0 +1,51 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+// Define if necessary
+
+// Function to be tested
+FOUNDATIONAL_LIB_FUNC int equal_array_of_int_ptrs(const int **array, const int **array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (*array[i] != *array2[i])
+        {
+            return 0; // Arrays are not equal
+        }
+    }
+    return 1; // Arrays are equal
+}
+
+// Test cases
+int main()
+{
+    const int a1[] = {1, 2, 3};
+    const int a2[] = {1, 2, 3};
+    const int a3[] = {1, 2, 4};
+    const int a4[] = {1, 2, 3};
+
+    const int *p1[] = {a1, a2, a3};
+    const int *p2[] = {a1, a2, a4};
+
+    // Test case 1: Equal arrays
+    assert(equal_array_of_int_ptrs(p1, p2, 3) == 1);
+
+    // Test case 2: Unequal arrays
+    assert(equal_array_of_int_ptrs(p1, p1, 3) == 1);
+
+    // Test case 3: Null arrays
+    assert(equal_array_of_int_ptrs(NULL, NULL, 0) == 1);
+
+    // Test case 4: Single element arrays
+    const int a5[] = {5};
+    const int a6[] = {5};
+    const int *p3[] = {a5};
+    const int *p4[] = {a6};
+    assert(equal_array_of_int_ptrs(p3, p4, 1) == 1);
+
+    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_equal_array_of_ints.c

@@ -0,0 +1,55 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stddef.h>
+
+// Function to test
+int equal_array_of_ints(const int *array, const int *array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Arrays with same elements
+    int arr1[] = {1, 2, 3, 4, 5};
+    int arr2[] = {1, 2, 3, 4, 5};
+    assert(equal_array_of_ints(arr1, arr2, 5) == 1);
+
+    // Test case 2: Arrays with different elements
+    int arr3[] = {1, 2, 3, 4, 5};
+    int arr4[] = {1, 3, 2, 4, 5};
+    assert(equal_array_of_ints(arr3, arr4, 5) == 0);
+
+    // Test case 3: Arrays with one element
+    int arr5[] = {10};
+    int arr6[] = {10};
+    assert(equal_array_of_ints(arr5, arr6, 1) == 1);
+
+    // Test case 4: Arrays with different sizes
+    int arr7[] = {1, 1, 1};
+    int arr8[] = {1, 1, 1, 1};
+    assert(equal_array_of_ints(arr7, arr8, 3) == 0);
+
+    // Additional corner cases
+    // Test case 5: Empty arrays
+    assert(equal_array_of_ints(NULL, NULL, 0) == 1);
+
+    // Test case 6: Large arrays
+    int largeArr1[1000], largeArr2[1000];
+    for (size_t i = 0; i < 1000; i++)
+    {
+        largeArr1[i] = i;
+        largeArr2[i] = i;
+    }
+    assert(equal_array_of_ints(largeArr1, largeArr2, 1000) == 1);
+
+    // All tests passed
+    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_equal_array_of_long_long_ptrs.c

@@ -0,0 +1,27 @@
+#include "../foundationallib.h"
+
+#define ASSERT_EQUAL_ARRAY(arr1, arr2, size, expected)                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+    do                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
+    {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+        int result = equal_array_of_long_long_ptrs(arr1, arr2, size);                                                                                                                                                                                                                                                                                                                                                                                                                                              \
+        if (result != expected)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+        {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+            fprintf(stderr, "Assertion failed: %s, line %d\n", __FILE__, __LINE__);                                                                                                                                                                                                                                                                                                                                                                                                                                \
+            fprintf(stderr, "   Expected: %d\n", expected);                                                                                                                                                                                                                                                                                                                                                                                                                                                        \
+            fprintf(stderr, "   Actual: %d\n", result);                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+        }                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+    } while (0)
+
+int main()
+{
+    const long long *arr1[] = {(long long[]){1, 2, 3}, (long long[]){4, 5, 6}, (long long[]){7, 8, 9}};
+    const long long *arr2[] = {(long long[]){1, 2, 3}, (long long[]){4, 5, 6}, (long long[]){7, 8, 9}};
+    const long long *arr3[] = {(long long[]){9, 8, 7}, (long long[]){6, 5, 4}, (long long[]){3, 2, 1}};
+
+    size_t size = sizeof(arr1) / sizeof(arr1[0]);
+
+    ASSERT_EQUAL_ARRAY(arr1, arr2, size, 1); // Equal arrays should return 1
+    ASSERT_EQUAL_ARRAY(arr1, arr3, size, 0); // Non-equal arrays should return 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_equal_array_of_long_longs.c

@@ -0,0 +1,53 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_long_longs(const long long *array, const long long *array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Arrays are equal
+    long long arr1[] = {1, 2, 3, 4, 5};
+    long long arr2[] = {1, 2, 3, 4, 5};
+    assert(equal_array_of_long_longs(arr1, arr2, 5) == 1);
+
+    // Test case 2: Arrays are not equal
+    long long arr3[] = {1, 2, 3, 4, 5};
+    long long arr4[] = {1, 2, 3, 5, 5};
+    assert(equal_array_of_long_longs(arr3, arr4, 5) == 0);
+
+    // Test case 3: Empty arrays
+    long long arr5[] = {};
+    long long arr6[] = {};
+    assert(equal_array_of_long_longs(arr5, arr6, 0) == 1);
+
+    // Test case 4: Arrays of different sizes
+    long long arr7[] = {1, 2, 3};
+    long long arr8[] = {1, 2, 3, 4};
+    assert(equal_array_of_long_longs(arr7, arr8, 3) == 0);
+
+    // Test case 5: Large arrays
+    const size_t large_size = 1000000;
+    long long large_arr1[large_size];
+    long long large_arr2[large_size];
+    for (size_t i = 0; i < large_size; i++)
+    {
+        large_arr1[i] = i;
+        large_arr2[i] = i;
+    }
+    assert(equal_array_of_long_longs(large_arr1, large_arr2, large_size) == 1);
+
+    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_equal_array_of_long_ptrs.c

@@ -0,0 +1,66 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stddef.h>
+
+// Foundational library function to be tested
+int equal_array_of_long_ptrs(const long **array, const long **array2, size_t size);
+
+// Test cases
+void test_equal_arrays()
+{
+    const long arr1[] = {1, 2, 3};
+    const long arr2[] = {1, 2, 3};
+    const long *ptr1[] = {arr1, arr1, arr1};
+    const long *ptr2[] = {arr2, arr2, arr2};
+
+    assert(equal_array_of_long_ptrs(ptr1, ptr2, 3) == 1);
+}
+
+void test_unequal_arrays()
+{
+    const long arr1[] = {1, 2, 3};
+    const long arr2[] = {3, 2, 1};
+    const long *ptr1[] = {arr1, arr1, arr1};
+    const long *ptr2[] = {arr2, arr2, arr2};
+
+    assert(equal_array_of_long_ptrs(ptr1, ptr2, 3) == 0);
+}
+
+void test_empty_arrays()
+{
+    const long *ptr1[] = {};
+    const long *ptr2[] = {};
+
+    assert(equal_array_of_long_ptrs(ptr1, ptr2, 0) == 1);
+}
+
+void test_null_arrays()
+{
+    const long *ptr1[] = {NULL, NULL};
+    const long *ptr2[] = {NULL, NULL};
+
+    assert(equal_array_of_long_ptrs(ptr1, ptr2, 2) == 1);
+}
+
+void test_null_element()
+{
+    const long arr1[] = {1, 2, 3};
+    const long *ptr1[] = {arr1, arr1, NULL};
+    const long *ptr2[] = {arr1, arr1, NULL};
+
+    assert(equal_array_of_long_ptrs(ptr1, ptr2, 3) == 1);
+}
+
+// Main function to run all test cases
+int main()
+{
+    test_equal_arrays();
+    test_unequal_arrays();
+    test_empty_arrays();
+    test_null_arrays();
+    test_null_element();
+
+    printf("All tests passed!\n");
+    return 0;
+}