foundational_lib2 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_equal_array_of_ushorts.c

@@ -0,0 +1,55 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_ushorts(const unsigned short *array, const unsigned short *array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test 1: Arrays are equal
+    {
+        unsigned short array1[] = {1, 2, 3, 4};
+        unsigned short array2[] = {1, 2, 3, 4};
+        size_t size = 4;
+        assert(equal_array_of_ushorts(array1, array2, size) == 1);
+    }
+
+    // Test 2: Arrays are not equal
+    {
+        unsigned short array1[] = {1, 2, 3, 4};
+        unsigned short array2[] = {1, 2, 3, 5};
+        size_t size = 4;
+        assert(equal_array_of_ushorts(array1, array2, size) == 0);
+    }
+
+    // Test 3: Arrays of different sizes
+    {
+        unsigned short array1[] = {1, 2, 3};
+        unsigned short array2[] = {1, 2, 3, 4, 5};
+        size_t size1 = 3;
+        size_t size2 = 5;
+        assert(equal_array_of_ushorts(array1, array2, size1) == 0);
+        assert(equal_array_of_ushorts(array1, array2, size2) == 0);
+    }
+
+    // Test 4: Empty arrays
+    {
+        unsigned short array1[] = {};
+        unsigned short array2[] = {};
+        size_t size = 0;
+        assert(equal_array_of_ushorts(array1, array2, size) == 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_equal_strings.c

@@ -0,0 +1,45 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+#define TEST_CASES 6
+
+void test_equal_strings()
+{
+    // Test case 1: Both strings are empty
+    const char *str1 = "";
+    const char *str2 = "";
+    assert(equal_strings(str1, str2) == 1);
+
+    // Test case 2: Both strings are "hello"
+    str1 = "hello";
+    str2 = "hello";
+    assert(equal_strings(str1, str2) == 1);
+
+    // Test case 3: First string is "apple" and second string is "applesauce"
+    str1 = "apple";
+    str2 = "applesauce";
+    assert(equal_strings(str1, str2) == 0);
+
+    // Test case 4: First string is "testing" and second string is "testing"
+    str1 = "testing";
+    str2 = "testing";
+    assert(equal_strings(str1, str2) == 1);
+
+    // Test case 5: First string is "Hello" and second string is "hello"
+    str1 = "Hello";
+    str2 = "hello";
+    assert(equal_strings(str1, str2) == 0);
+
+    // Test case 6: First string is "12345" and second string is "54321"
+    str1 = "12345";
+    str2 = "54321";
+    assert(equal_strings(str1, str2) == 0);
+}
+
+int main()
+{
+    test_equal_strings();
+    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_filter.c

@@ -0,0 +1,59 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+size_t filter(void *source, size_t source_size, size_t elem_size, void *destination, size_t dest_size, int (*condition)(void *))
+{
+    size_t num_filtered = 0;
+    for (size_t i = 0; i < source_size; i++)
+    {
+        if (condition((char *)source + (i * elem_size)))
+        {
+            if (num_filtered < dest_size)
+            {
+                memcpy((char *)destination + (num_filtered * elem_size), (char *)source + (i * elem_size), elem_size);
+                num_filtered++;
+            }
+            else
+            {
+                break; // Destination array full
+            }
+        }
+    }
+    return num_filtered;
+}
+
+int main()
+{
+    // Test case 1: source array is empty
+    int source_empty[] = {};
+    int destination_empty[5];
+    size_t num_filtered_empty = filter(source_empty, 0, sizeof(int), destination_empty, 5, is_even_condition);
+    assert(num_filtered_empty == 0);
+
+    // Test case 2: destination array is empty
+    int source_not_empty[] = {1, 2, 3, 4, 5};
+    int destination_full[1];
+    size_t num_filtered_full = filter(source_not_empty, 5, sizeof(int), destination_full, 0, is_even_condition);
+    assert(num_filtered_full == 0);
+
+    // Test case 3: all elements satisfy the condition
+    int source_all_even[] = {2, 4, 6, 8, 10};
+    int destination_all_even[5];
+    size_t num_filtered_all_even = filter(source_all_even, 5, sizeof(int), destination_all_even, 5, is_even_condition);
+    assert(num_filtered_all_even == 5);
+    for (size_t i = 0; i < num_filtered_all_even; i++)
+    {
+        assert(*(int *)((char *)destination_all_even + (i * sizeof(int))) == source_all_even[i]);
+    }
+
+    // Test case 4: no elements satisfy the condition
+    int source_none_even[] = {1, 3, 5, 7, 9};
+    int destination_none_even[5];
+    size_t num_filtered_none_even = filter(source_none_even, 5, sizeof(int), destination_none_even, 5, is_even_condition);
+    assert(num_filtered_none_even == 0);
+
+    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_filter_int.c

@@ -0,0 +1,39 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+// Define the filter_int function
+typedef size_t (*filter_int_fn)(int *, size_t, int *, int (*)(int));
+
+// Define the condition function
+int is_even_condition(int x) { return (x % 2 == 0); }
+
+// Test cases
+void test_filter_int(filter_int_fn filter_int)
+{
+    int source[] = {1, 2, 3, 4, 5};
+    int destination[5];
+
+    // Test case 1: Test with even condition
+    size_t num_filtered = filter_int(source, 5, destination, is_even_condition);
+    assert(num_filtered == 2);
+    assert(destination[0] == 2);
+    assert(destination[1] == 4);
+
+    // Test case 2: Test with odd condition
+    size_t num_filtered_odd = filter_int(source, 5, destination, [](int x) { return (x % 2 != 0); });
+    assert(num_filtered_odd == 3);
+    assert(destination[0] == 1);
+    assert(destination[1] == 3);
+    assert(destination[2] == 5);
+}
+
+int main()
+{
+    // Run the test cases
+    test_filter_int(filter_int);
+
+    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_find_first_of.c

@@ -0,0 +1,48 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+FOUNDATIONAL_LIB_FUNC ssize_t find_first_of(const char *str, const char *char_set)
+{
+    for (size_t i = 0; str[i] != '\0'; i++)
+    {
+        for (size_t j = 0; char_set[j] != '\0'; j++)
+        {
+            if (str[i] == char_set[j])
+            {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+
+void test_find_first_of()
+{
+    const char *str = "Hello, World!";
+
+    // Test cases for finding individual characters
+    assert(find_first_of(str, "aeiou") == 1); // 'e' at index 1
+    assert(find_first_of(str, "l") == 2);     // 'l' at index 2
+    assert(find_first_of(str, "xy") == -1);   // None of 'x' or 'y' found
+
+    // Test cases for empty string and char_set
+    assert(find_first_of("", "abc") == -1); // Empty string
+    assert(find_first_of(str, "") == -1);   // Empty char_set
+
+    // Test cases for all characters in the string
+    assert(find_first_of(str, "Hed!") == 0); // 'H' at index 0
+    assert(find_first_of(str, "d!!") == 7);  // 'd' at index 7
+
+    // Test cases for not finding any characters
+    assert(find_first_of(str, "123") == -1); // None of '1', '2', '3' found
+
+    printf("All test cases passed!\n");
+}
+
+int main()
+{
+    test_find_first_of();
+    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_find_last_of.c

@@ -0,0 +1,48 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC ssize_t find_last_of(const char *str, const char *char_set)
+{
+    if (str == NULL || char_set == NULL)
+    {
+        return -1;
+    }
+
+    ssize_t last_index = -1;
+
+    for (const char *ptr = str; *ptr != '\0'; ptr++)
+    {
+        const char *found = strchr(char_set, *ptr);
+        if (found != NULL)
+        {
+            last_index = ptr - str;
+        }
+    }
+
+    return last_index;
+}
+
+void test_find_last_of()
+{
+    // Test cases
+    assert(find_last_of("hello", "abc") == -1); // No matching characters
+    assert(find_last_of("hello", "el") == 4);   // 'o' is the last matching character
+    assert(find_last_of("hello", "ohl") == 4);  // 'o' is the last matching character
+    assert(find_last_of("hello", "ox") == -1);  // No matching characters
+    assert(find_last_of("hello", "") == -1);    // Empty char_set
+
+    // Edge cases
+    assert(find_last_of("", "abc") == -1);     // Empty string
+    assert(find_last_of(NULL, "abc") == -1);   // Null string
+    assert(find_last_of("hello", NULL) == -1); // Null char_set
+    assert(find_last_of(NULL, NULL) == -1);    // Null string and char_set
+}
+
+int main()
+{
+    test_find_last_of();
+    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_find_max_int_in_array.c

@@ -0,0 +1,55 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stddef.h>
+
+FOUNDATIONAL_LIB_FUNC int find_max_int_in_array(const int *array, size_t size)
+{
+    if (array == NULL || size == 0)
+    {
+        return 0; // Return 0 if the array is empty or NULL
+    }
+
+    int max = array[0];
+    for (size_t i = 1; i < size; i++)
+    {
+        if (array[i] > max)
+        {
+            max = array[i]; // Update max if a larger element is found
+        }
+    }
+
+    return max;
+}
+
+int main()
+{
+    // Test case 1: array with positive integers
+    int test1[] = {5, 10, 3, 8, 15};
+    assert(find_max_int_in_array(test1, 5) == 15);
+
+    // Test case 2: array with negative integers
+    int test2[] = {-5, -10, -3, -8, -15};
+    assert(find_max_int_in_array(test2, 5) == -3);
+
+    // Test case 3: array with a single element
+    int test3[] = {100};
+    assert(find_max_int_in_array(test3, 1) == 100);
+
+    // Test case 4: array with all elements equal
+    int test4[] = {7, 7, 7, 7};
+    assert(find_max_int_in_array(test4, 4) == 7);
+
+    // Test case 5: empty array
+    int *test5 = NULL;
+    assert(find_max_int_in_array(test5, 0) == 0);
+
+    // Test case 6: array with one big number
+    int test6[] = {9999999};
+    assert(find_max_int_in_array(test6, 1) == 9999999);
+
+    // Test case 7: array with one small number
+    int test7[] = {-9999999};
+    assert(find_max_int_in_array(test7, 1) == -9999999);
+
+    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_find_min_int_in_array.c

@@ -0,0 +1,58 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdio.h>
+int main()
+{
+    // Test case 1: Minimum at the beginning of the array
+    {
+        int arr[] = {1, 2, 3, 4, 5};
+        size_t size = sizeof(arr) / sizeof(arr[0]);
+        int min = find_min_int_in_array(arr, size);
+        assert(min == 1);
+    }
+
+    // Test case 2: Minimum at the end of the array
+    {
+        int arr[] = {5, 4, 3, 2, 1};
+        size_t size = sizeof(arr) / sizeof(arr[0]);
+        int min = find_min_int_in_array(arr, size);
+        assert(min == 1);
+    }
+
+    // Test case 3: Minimum in the middle of the array
+    {
+        int arr[] = {5, 4, 1, 2, 3};
+        size_t size = sizeof(arr) / sizeof(arr[0]);
+        int min = find_min_int_in_array(arr, size);
+        assert(min == 1);
+    }
+
+    // Test case 4: Array with only one element
+    {
+        int arr[] = {5};
+        size_t size = sizeof(arr) / sizeof(arr[0]);
+        int min = find_min_int_in_array(arr, size);
+        assert(min == 5);
+    }
+
+    // Test case 5: Array with negative numbers
+    {
+        int arr[] = {-5, -3, -1, -2, -4};
+        size_t size = sizeof(arr) / sizeof(arr[0]);
+        int min = find_min_int_in_array(arr, size);
+        assert(min == -5);
+    }
+
+    // Test case 6: Array with duplicate minimum elements
+    {
+        int arr[] = {3, 1, 2, 1, 4};
+        size_t size = sizeof(arr) / sizeof(arr[0]);
+        int min = find_min_int_in_array(arr, size);
+        assert(min == 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_first_non_repeating_char.c

@@ -0,0 +1,42 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+FOUNDATIONAL_LIB_FUNC char first_non_repeating_char(const char *str)
+{
+    int charCount[256] = {0};
+
+    for (int i = 0; str[i] != '\0'; i++)
+    {
+        charCount[(int)str[i]]++;
+    }
+
+    for (int i = 0; str[i] != '\0'; i++)
+    {
+        if (charCount[(int)str[i]] == 1)
+        {
+            return str[i];
+        }
+    }
+
+    return '\0';
+}
+
+int main()
+{
+    // Test cases for the first_non_repeating_char function
+    assert(first_non_repeating_char("") == '\0');
+    assert(first_non_repeating_char("a") == 'a');
+    assert(first_non_repeating_char("aa") == '\0');
+    assert(first_non_repeating_char("leetcode") == 'l');
+    assert(first_non_repeating_char("loveleetcode") == 'v');
+
+    // Additional test cases
+    assert(first_non_repeating_char("hello") == 'h');
+    assert(first_non_repeating_char("helloworld") == 'e');
+    assert(first_non_repeating_char("abcdefghijklmnopqrstuvwxyz") == 'a');
+    assert(first_non_repeating_char("aabbccddeeffgghhii") == '\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_format_string.c

@@ -0,0 +1,68 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// The function to be tested
+char *format_string(const char *format, ...);
+
+// Test for basic functionality
+void test_basic_formatting()
+{
+    char *result = format_string("{}", "test");
+    assert(strcmp(result, "test") == 0);
+    free(result);
+}
+
+// Test for multiple curly braces
+void test_multiple_curly_braces()
+{
+    char *result = format_string("{0} {} {1}", "test1", "test2");
+    assert(strcmp(result, "test1 test2") == 0);
+    free(result);
+}
+
+// Test for empty format string
+void test_empty_format_string()
+{
+    char *result = format_string("", "test");
+    assert(strcmp(result, "") == 0);
+    free(result);
+}
+
+// Test for invalid format string
+void test_invalid_format_string()
+{
+    char *result = format_string("{1} {", "test");
+    assert(result == NULL);
+}
+
+// Test for large number of arguments
+void test_large_number_of_arguments()
+{
+    char *result = format_string("{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14} {15} {16} {17} {18} {19} {20} {21} {22} {23} {24} {25} {26} {27} {28} {29} {30} {31} {32} {33} {34} {35} {36} {37} {38} {39} {40} {41} {42} {43} {44} {45} {46} {47} {48} {49} {50} {51} {52} {53} {54} {55} {56} {57} {58} {59} {60} {61} {62} {63} {64} {65} {66} {67} {68} {69} {70} {71} {72} {73} {74} {75} {76} {77} {78} {79} {80} {81} {82} {83} {84} {85} {86} {87} {88} {89} {90} {91} {92} {93} {94} "
+                                 "{95} {96} {97} {98} {99} {100} {101} {102} {103} {104} {105} {106} {107} {108} {109} {110} {111} {112} {113} {114} {115} {116} {117} {118} {119} {120} {121} {122} {123} {124} {125} {126} {127} {128} {129} {130} {131} {132} {133} {134} {135} {136} {137} {138} {139} {140} {141} {142} {143} {144} {145} {146} {147} {148} {149} {150} {151} {152} {153} {154} {155} {156} {157} {158} {159} {160} {161} {162} {163} {164} {165} {166} {167} {168} {169} {170} {171} {172} "
+                                 "{173} {174} {175} {176} {177} {178} {179} {180} {181} {182} {183} {184} {185} {186} {187} {188} {189} {190} {191} {192} {193} {194} {195} {196} {197} {198} {199} {200}",
+                                 "test0", "test1", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10", "test11", "test12", "test13", "test14", "test15", "test16", "test17", "test18", "test19", "test20", "test21", "test22", "test23", "test24", "test25", "test26", "test27", "test28", "test29", "test30", "test31", "test32", "test33", "test34", "test35", "test36", "test37", "test38", "test39", "test40", "test41", "test42", "test43", "test44", "test45", "test46",
+                                 "test47", "test48", "test49", "test50", "test51", "test52", "test53", "test54", "test55", "test56", "test57", "test58", "test59", "test60", "test61", "test62", "test63", "test64", "test65", "test66", "test67", "test68", "test69", "test70", "test71", "test72", "test73", "test74", "test75", "test76", "test77", "test78", "test79", "test80", "test81", "test82", "test83", "test84", "test85", "test86", "test87", "test88", "test89", "test90", "test91", "test92",
+                                 "test93", "test94", "test95", "test96", "test97", "test98", "test99", "test100", "test101", "test102", "test103", "test104", "test105", "test106", "test107", "test108", "test109", "test110", "test111", "test112", "test113", "test114", "test115", "test116", "test117", "test118", "test119", "test120", "test121", "test122", "test123", "test124", "test125", "test126", "test127", "test128", "test129", "test130", "test131", "test132", "test133", "test134", "test135",
+                                 "test136", "test137", "test138", "test139", "test140", "test141", "test142", "test143", "test144", "test145", "test146", "test147", "test148", "test149", "test150", "test151", "test152", "test153", "test154", "test155", "test156", "test157", "test158", "test159", "test160", "test161", "test162", "test163", "test164", "test165", "test166", "test167", "test168", "test169", "test170", "test171", "test172", "test173", "test174", "test175", "test176", "test177",
+                                 "test178", "test179", "test180", "test181", "test182", "test183", "test184", "test185", "test186", "test187", "test188", "test189", "test190", "test191", "test192", "test193", "test194", "test195", "test196", "test197", "test198", "test199", "test200");
+    assert(strcmp(result, "test0 test1 test2 test3 test4 test5 test6 test7 test8 test9 test10 test11 test12 test13 test14 test15 test16 test17 test18 test19 test20 test21 test22 test23 test24 test25 test26 test27 test28 test29 test30 test31 test32 test33 test34 test35 test36 test37 test38 test39 test40 test41 test42 test43 test44 test45 test46 test47 test48 test49 test50 test51 test52 test53 test54 test55 test56 test57 test58 test59 test60 test61 test62 test63 test64 test65 test66 test67 "
+                          "test68 test69 test70 test71 test72 test73 test74 test75 test76 test77 test78 test79 test80 test81 test82 test83 test84 test85 test86 test87 test88 test89 test90 test91 test92 test93 test94 test95 test96 test97 test98 test99 test100 test101 test102 test103 test104 test105 test106 test107 test108 test109 test110 test111 test112 test113 test114 test115 test116 test117 test118 test119 test120 test121 test122 test123 test124 test125 test126 test127 test128 test129 test130 "
+                          "test131 test132 test133 test134 test135 test136 test137 test138 test139 test140 test141 test142 test143 test144 test145 test146 test147 test148 test149 test150 test151 test152 test153 test154 test155 test156 test157 test158 test159 test160 test161 test162 test163 test164 test165 test166 test167 test168 test169 test170 test171 test172 test173 test174 test175 test176 test177 test178 test179 test180 test181 test182 test183 test184 test185 test186 test187 test188 test189 "
+                          "test190 test191 test192 test193 test194 test195 test196 test197 test198 test199 test200") == 0);
+    free(result);
+}
+
+int main()
+{
+    test_basic_formatting();
+    test_multiple_curly_braces();
+    test_empty_format_string();
+    test_invalid_format_string();
+    test_large_number_of_arguments();
+    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_free_array.c

@@ -0,0 +1,63 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdlib.h>
+
+// Function to be tested
+void free_array(void **array, size_t len)
+{
+    for (size_t i = 0; i < len; i++)
+    {
+        free(array[i]);
+    }
+    free(array);
+}
+
+// Test cases
+void test_free_array_null_array()
+{
+    void **array = NULL;
+    free_array(array, 0);
+    // No assertion, just making sure it doesn't crash
+}
+
+void test_free_array_empty_array()
+{
+    void **array = malloc(0);
+    free_array(array, 0);
+    // No assertion, just making sure it doesn't crash
+}
+
+void test_free_array_single_element()
+{
+    void *element = malloc(sizeof(int));
+    void **array = malloc(sizeof(void *));
+    array[0] = element;
+
+    free_array(array, 1);
+    assert(array[0] == NULL);
+    free(array);
+}
+
+void test_free_array_multiple_elements()
+{
+    void *element1 = malloc(sizeof(int));
+    void *element2 = malloc(sizeof(int));
+    void **array = malloc(2 * sizeof(void *));
+    array[0] = element1;
+    array[1] = element2;
+
+    free_array(array, 2);
+    assert(array[0] == NULL);
+    assert(array[1] == NULL);
+    free(array);
+}
+
+int main()
+{
+    test_free_array_null_array();
+    test_free_array_empty_array();
+    test_free_array_single_element();
+    test_free_array_multiple_elements();
+
+    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_free_string_array.c

@@ -0,0 +1,50 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdlib.h>
+
+void free_string_array(char **array, size_t len)
+{
+    if (array == NULL)
+        return;
+
+    for (size_t i = 0; i < len; i++)
+    {
+        free(array[i]);
+    }
+
+    free(array);
+}
+
+int main()
+{
+    // Test case 1: array is NULL
+    char **test1 = NULL;
+    free_string_array(test1, 0);
+
+    // Test case 2: len is 0
+    char **test2 = (char **)malloc(0 * sizeof(char *));
+    free_string_array(test2, 0);
+
+    // Test case 3: len is 1
+    char **test3 = (char **)malloc(1 * sizeof(char *));
+    test3[0] = (char *)malloc(6);
+    test3[0] = "Hello";
+    free_string_array(test3, 1);
+    assert(test3 == NULL); // Check if test3 is NULL after freeing
+
+    // Test case 4: len is greater than 1
+    char **test4 = (char **)malloc(3 * sizeof(char *));
+    test4[0] = (char *)malloc(6);
+    test4[1] = (char *)malloc(6);
+    test4[2] = (char *)malloc(6);
+    test4[0] = "Hello";
+    test4[1] = "World";
+    test4[2] = "!";
+    free_string_array(test4, 3);
+    assert(test4 == NULL); // Check if test4 is NULL after freeing
+
+    // Add more test cases for different corner cases
+
+    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_frozen_dict_del_keys.c

@@ -0,0 +1,28 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+int main()
+{
+    char *keys1[] = {"key1", "key2", "key3"};
+    char *keys2[] = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"};
+
+    // Test case 1: Delete keys from a frozen dictionary with 3 keys
+    frozen_dict_del_keys(keys1);
+
+    // Add assertion to check the result
+    assert(keys1[0] == NULL);
+    assert(keys1[1] == NULL);
+    assert(keys1[2] == NULL);
+
+    // Test case 2: Delete keys from a frozen dictionary with 10 keys
+    frozen_dict_del_keys(keys2);
+
+    // Add assertion to check the result
+    for (int i = 0; i < 10; i++)
+    {
+        assert(keys2[i] == NULL);
+    }
+
+    printf("All test cases passed\n");
+    return 0;
+}