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

@@ -0,0 +1,48 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main()
+{
+    const char *test_strings[] = {"Hello", "World", "This", "Is", "A", "Test"};
+    const size_t num_strings = sizeof(test_strings) / sizeof(test_strings[0]);
+
+    // Test 1: Check if the selected string is within the given array
+    const char *selected_string = sample_strings(test_strings, num_strings);
+    int found = 0;
+    for (size_t i = 0; i < num_strings; i++)
+    {
+        if (selected_string == test_strings[i])
+        {
+            found = 1;
+            break;
+        }
+    }
+    assert(found && "Selected string is not in the given array");
+
+    // Test 2: Check if the returned pointer is not NULL
+    assert(selected_string != NULL && "Selected string pointer is NULL");
+
+    // Test 3: Check for correctness of the selected string
+    size_t selected_length = 0;
+    while (selected_string[selected_length] != '\0')
+    {
+        selected_length++;
+    }
+    int matching = 1;
+    for (size_t i = 0; i < selected_length; i++)
+    {
+        if (selected_string[i] != test_strings[0][i])
+        {
+            matching = 0;
+            break;
+        }
+    }
+    assert(matching && "Selected string does not match with the original string in the array");
+
+    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_select_array.c

@@ -0,0 +1,29 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+void test_select_array()
+{
+    int source1[] = {1, 2, 3, 4, 5};
+    size_t result_size;
+    int *result1 = select_array(source1, 5, sizeof(int), even_condition, &result_size);
+    assert(result1[0] == 2);
+    assert(result1[1] == 4);
+    assert(result_size == 2);
+    free(result1);
+
+    int source2[] = {1, -2, 3, -4, 5};
+    int *result2 = select_array(source2, 5, sizeof(int), positive_condition, &result_size);
+    assert(result2[0] == 1);
+    assert(result2[1] == 3);
+    assert(result2[2] == 5);
+    assert(result_size == 3);
+    free(result2);
+}
+
+int main()
+{
+    test_select_array();
+    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_set_add.c

@@ -0,0 +1,69 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Set
+{
+    char *key;
+    struct Set *next;
+};
+
+FOUNDATIONAL_LIB_FUNC int set_add(struct Set *set, const char *key)
+{
+    if (set == NULL || key == NULL)
+    {
+        return -1; // Error: NULL pointer
+    }
+
+    struct Set *new_set = (struct Set *)malloc(sizeof(struct Set));
+    if (new_set == NULL)
+    {
+        return -1; // Error: Memory allocation failed
+    }
+
+    new_set->key = strdup(key);
+    new_set->next = set->next;
+    set->next = new_set;
+
+    return 0; // Success
+}
+
+void test_set_add()
+{
+    struct Set *set = (struct Set *)malloc(sizeof(struct Set));
+    assert(set_add(set, "key1") == -1); // Error: NULL pointer
+    free(set);
+
+    set = (struct Set *)malloc(sizeof(struct Set));
+    set->key = strdup("key1");
+    set->next = NULL;
+    assert(set_add(NULL, "key2") == -1); // Error: NULL pointer
+    free(set->key);
+    free(set);
+
+    set = (struct Set *)malloc(sizeof(struct Set));
+    set->key = strdup("key1");
+    set->next = NULL;
+    assert(set_add(set, NULL) == -1); // Error: NULL pointer
+    free(set->key);
+    free(set);
+
+    set = (struct Set *)malloc(sizeof(struct Set));
+    set->key = strdup("key1");
+    set->next = NULL;
+    assert(set_add(set, "key2") == 0); // Success
+    assert(strcmp(set->next->key, "key2") == 0);
+    free(set->next->key);
+    free(set->next);
+    free(set);
+
+    printf("All tests passed!\n");
+}
+
+int main()
+{
+    test_set_add();
+    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_set_del_key.c

@@ -0,0 +1,29 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+// Test cases
+void test_set_del_key()
+{
+    struct Set set;
+    // initialize the set with some keys
+
+    // Test deleting a key that exists in the set
+    const char *existing_key = "existing_key";
+    set_del_key(&set, existing_key);
+    // assert that the key has been deleted from the set
+    assert(!has_key(&set, existing_key));
+
+    // Test deleting a key that does not exist in the set
+    const char *non_existing_key = "non_existing_key";
+    set_del_key(&set, non_existing_key);
+    // assert that the set remains unchanged
+    assert(get_size(&set) == initial_size);
+}
+
+int main()
+{
+    test_set_del_key();
+    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_set_del_keys.c

@@ -0,0 +1,35 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+// Test suite for set_del_keys function
+void test_set_del_keys()
+{
+    // Test case 1: Deleting single key from an empty set
+    Set set1 = {NULL, 0};
+    set_del_keys(NULL);
+    assert(set1.size == 0);
+
+    // Test case 2: Deleting single key from a non-empty set
+    char *key1 = "key1";
+    Set set2 = {&key1, 1};
+    set_del_keys(&key1);
+    assert(set2.size == 0);
+
+    // Test case 3: Deleting multiple keys from a non-empty set
+    char *key2 = "key2";
+    char *key3 = "key3";
+    Set set3 = {&key1, 3};
+    set_del_keys(&key2);
+    set_del_keys(&key3);
+    assert(set3.size == 1);
+
+    printf("All test cases passed!\n");
+}
+
+int main()
+{
+    test_set_del_keys();
+    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_set_destructor.c

@@ -0,0 +1,31 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdlib.h>
+// Test case 1: Test setting destructor for an empty set
+void test_set_destructor_empty_set()
+{
+    struct Set *set = (struct Set *)malloc(sizeof(struct Set));
+    set_destructor(set);
+    // No assertions, just making sure it doesn't crash
+    free(set);
+}
+
+// Test case 2: Test setting destructor for a set with elements
+void test_set_destructor_set_with_elements()
+{
+    struct Set *set = (struct Set *)malloc(sizeof(struct Set));
+    // Initialize set with elements
+    set_destructor(set);
+    // No assertions, just making sure it doesn't crash
+    free(set);
+}
+
+int main()
+{
+    test_set_destructor_empty_set();
+    test_set_destructor_set_with_elements();
+    // Add more test cases for corner cases here
+
+    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_set_hash.c

@@ -0,0 +1,44 @@
+#include "../foundationallib.h"
+#include <assert.h>
+int main()
+{
+    // Test cases
+    const char *testCases[] = {
+        "hello",                      // basic test case
+        "",                           // empty string
+        "1234567890",                 // numeric string
+        "abcdefghijklmnopqrstuvwxyz", // lowercase alphabets
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ", // uppercase alphabets
+        "!@#$%^&*()",                 // special characters
+        "12345abcde!",                // combination of numbers and characters
+        "hello",                      // identical to first test case for collision
+        "world",                      // different from first test case for non-collision
+    };
+
+    size_t capacities[] = {
+        10,   // small capacity
+        100,  // medium capacity
+        1000, // large capacity
+        10000 // very large capacity
+    };
+
+    int numTestCases = sizeof(testCases) / sizeof(testCases[0]);
+    int numCapacities = sizeof(capacities) / sizeof(capacities[0]);
+
+    for (int i = 0; i < numTestCases; i++)
+    {
+        for (int j = 0; j < numCapacities; j++)
+        {
+            size_t hashValue = set_hash(testCases[i], capacities[j]);
+
+            printf("Hash value for '%s' with capacity %zu: %zu\n", testCases[i], capacities[j], hashValue);
+
+            // Test capacity range
+            assert(hashValue < capacities[j]);
+        }
+    }
+
+    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_set_in.c

@@ -0,0 +1,52 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+// Function to check if a key is present in the Set
+int set_in(struct Set *set, const char *key)
+{
+    for (int i = 0; i < set->size; i++)
+    {
+        if (strcmp(set->keys[i], key) == 0)
+        {
+            return 1; // Key is present
+        }
+    }
+    return 0; // Key is not present
+}
+
+int main()
+{
+    // Create a new Set
+    struct Set *test_set = create_set();
+
+    // Test case 1: Set is empty
+    assert(set_in(test_set, "test1") == 0);
+
+    // Add keys to the set for further tests
+    add_to_set(test_set, "test1");
+    add_to_set(test_set, "test2");
+    add_to_set(test_set, "test3");
+
+    // Test case 2: Key present in the set
+    assert(set_in(test_set, "test2") == 1);
+
+    // Test case 3: Key not present in the set
+    assert(set_in(test_set, "test4") == 0);
+
+    // Test case 4: Set is full
+    struct Set *full_set = create_set();
+    for (int i = 0; i < 100; i++)
+    {
+        char key[10];
+        snprintf(key, 10, "key%d", i);
+        add_to_set(full_set, key);
+    }
+    assert(set_in(full_set, "key99") == 1);
+    assert(set_in(full_set, "key100") == 0);
+
+    // All tests passed
+    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_set_iter.c

@@ -0,0 +1,69 @@
+#include "../foundationallib.h"
+
+// Define the callback function for testing
+void test_callback(char *key)
+{
+    // For testing purposes, we will simply print the key and value
+    printf("Key: %s, Value: %p\n", key, value);
+}
+
+// Define the test suite
+void run_tests()
+{
+    // Create a sample setionary for testing
+    struct Set *set = set_new_instance();
+    set_iter(set, &test_callback);
+    set_destructor(set);
+
+    struct Set *set = set_new_instance();
+    set_add(set, "foo");
+    set_iter(set, &test_callback);
+    set_destructor(set);
+
+    struct Set *set = set_new_instance();
+    set_add(set, "fooz");
+    set_add(set, "dsdsfooz");
+    set_iter(set, &test_callback);
+    set_destructor(set);
+
+    struct set *set = set_new_instance();
+    set_add(set, "fooz", "barz");
+    set_add(set, "dsdsfooz");
+    set_add(set, "dsdsfoozssssssssss");
+    set_iter(set, &test_callback);
+    set_destructor(set);
+
+    struct set *set = set_new_instance();
+    set_add(set, "fooz", "barz");
+    set_add(set, "dsdsfoozssssssssssssssssssssssssssssssss");
+    set_add(set, "dsdsfoozssssssssss");
+    set_add(set, "foozssssssssssssssssssssssssssssssssssssssssssss", "barz");
+    set_add(set, "dsdsfoozssssssssssssssssssssssssss");
+    set_add(set, "dsdsfoozssssssssss");
+    set_add(set, "foozssssssssssssssssssssssssssssss", "barz");
+    set_add(set, "dsdsfoozdasdsadasdsadsa");
+    set_add(set, "dsdsfoozssssssssss");
+    set_add(set, "foozdasdasdasdas", "barz");
+    set_add(set, "dsdsfoozca");
+    set_add(set, "dsdsfoozssssssssss");
+    set_add(set, "foozsssssssssssssssssssssssssssss", "barz");
+    set_add(set, "dsdsfoozqqqqqqqqqqqqqqqqqqqqqqqq");
+    set_add(set, "dsdsfoozssssssssssqqqqqqqqqqqqqqqq");
+    set_add(set, "foozqqqqqqqqqqqq", "barz");
+    set_add(set, "dsdsfoozaaaaaaaaaaa");
+    set_add(set, "dsdsfoozssssssssss");
+    set_add(set, "foozssssssssssssssssssssssssssss", "barz");
+    set_add(set, "dsdsfooz");
+    set_add(set, "dddddddddddsdsfoozssssssssss");
+    set_add(set, "foozsssssssssss", "barz");
+    set_add(set, "dsdsdsfooz");
+    set_add(set, "dsdsfoozssssssssssds");
+    set_iter(set, &test_callback);
+    set_destructor(set);
+}
+
+int main()
+{
+    run_tests();
+    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_set_new_instance.c

@@ -0,0 +1,30 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Test cases for set_new_instance function
+void test_set_new_instance()
+{
+    struct Set *set = set_new_instance();
+
+    // Assert that the set instance is not NULL
+    assert(set != NULL);
+
+    // Add more test cases here if necessary
+
+    // Free the memory allocated for the set instance
+    free(set);
+}
+
+// Main function to run the test cases
+int main()
+{
+    // Run the test case for set_new_instance
+    test_set_new_instance();
+
+    // Print a message indicating that all test cases passed
+    printf("All test cases passed for set_new_instance function\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_set_reserve_more.c

@@ -0,0 +1,36 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+int main()
+{
+    // Create a new Set instance
+    struct Set *set = create_set();
+
+    // Test case 1: Reserving additional space for 0 new elements
+    assert(set_reserve_more(set, 0) == 0);
+
+    // Test case 2: Reserving additional space for 10 new elements
+    assert(set_reserve_more(set, 10) == 0);
+
+    // Test case 3: Reserving additional space for a large number of new elements
+    assert(set_reserve_more(set, 100000) == 0);
+
+    // Test case 4: Reserving additional space for a negative number of new elements
+    assert(set_reserve_more(set, -5) == -1);
+
+    // Test case 5: Reserving additional space for a very large number of new elements
+    assert(set_reserve_more(set, 1000000000) == 0);
+
+    // Test case 6: Reserving additional space for the maximum possible number of new elements
+    assert(set_reserve_more(set, SIZE_MAX) == 0);
+
+    // Test case 7: Reserving additional space for an excessively large number of new elements
+    // (Assuming SIZE_MAX is the maximum value for size_t)
+    assert(set_reserve_more(set, SIZE_MAX + 1) == -1);
+
+    // Clean up and free the Set instance
+    destroy_set(set);
+
+    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_set_resize.c

@@ -0,0 +1,37 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+int main()
+{
+    // Test case 1: Resize a Set with initial size 3
+    Set *set1 = set_init(3);
+    assert(set1 != NULL);
+    assert(set1->size == 0);
+    assert(set1->capacity == 3);
+    assert(set_resize(set1) == 1);
+    assert(set1->capacity == 6);
+
+    // Test case 2: Resize a Set with initial size 0
+    Set *set2 = set_init(0);
+    assert(set2 != NULL);
+    assert(set2->size == 0);
+    assert(set2->capacity == 0);
+    assert(set_resize(set2) == 1);
+    assert(set2->capacity == 0); // Should remain 0
+
+    // Test case 3: Resize a NULL Set
+    Set *set3 = NULL;
+    assert(set_resize(set3) == 0);
+
+    printf("All tests passed successfully.\n");
+
+    // Free memory and return
+    if (set1)
+        free(set1->data);
+    free(set1);
+    if (set2)
+        free(set2->data);
+    free(set2);
+    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_set_size.c

@@ -0,0 +1,42 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+struct Set
+{
+    int elements[100];
+    size_t size;
+};
+
+typedef struct Set Set;
+
+size_t set_size(Set *set) { return set->size; }
+
+int main()
+{
+    Set set1 = {{1, 2, 3, 4, 5}, 5};
+    Set set2 = {{}, 0};
+
+    // Test case 1: Test with non-empty set
+    assert(set_size(&set1) == 5);
+
+    // Test case 2: Test with empty set
+    assert(set_size(&set2) == 0);
+
+    // Test case 3: Test with set of size 1
+    Set set3 = {{10}, 1};
+    assert(set_size(&set3) == 1);
+
+    // Test case 4: Test with set of size 100
+    Set set4;
+    for (int i = 0; i < 100; i++)
+    {
+        set4.elements[i] = i + 1;
+    }
+    set4.size = 100;
+    assert(set_size(&set4) == 100);
+
+    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_set_to_array.c

@@ -0,0 +1,41 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+// Test function
+int test_set_to_array()
+{
+    // Test case 1: empty set
+    struct Set *empty_set = NULL;
+    char **empty_keys;
+    size_t empty_size_of_keys;
+    int result1 = set_to_array(empty_set, &empty_keys, &empty_size_of_keys);
+    assert(result1 == 1);
+    assert(empty_keys == NULL);
+    assert(empty_size_of_keys == 0);
+
+    // Test case 2: non-empty set
+    struct Set *non_empty_set = NULL; // Initialize non-empty set with some values
+    char **non_empty_keys;
+    size_t non_empty_size_of_keys;
+    int result2 = set_to_array(non_empty_set, &non_empty_keys, &non_empty_size_of_keys);
+    // Add assertions for expected values in non_empty_keys and non_empty_size_of_keys
+
+    return 0;
+}
+
+int main()
+{
+    int res = test_set_to_array();
+    if (res == 0)
+    {
+        printf("All tests passed\n");
+    }
+    else
+    {
+        printf("Some tests failed\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_set_to_string.c

@@ -0,0 +1,81 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+struct Set
+{
+    int *elements;
+    int size;
+};
+
+char *set_to_string(struct Set *set)
+{
+    // Assuming the set is not empty
+    char *str = malloc(set->size * 2 + 3);
+    if (str == NULL)
+    {
+        return NULL; // Memory allocation failed
+    }
+    str[0] = '{';
+    int index = 1;
+    for (int i = 0; i < set->size; i++)
+    {
+        index += sprintf(&str[index], "%d", set->elements[i]);
+        if (i != set->size - 1)
+        {
+            str[index++] = ',';
+            str[index++] = ' ';
+        }
+    }
+    str[index++] = '}';
+    str[index] = '\0';
+
+    return str;
+}
+
+// Test cases
+void test_set_to_string_empty()
+{
+    struct Set set = {NULL, 0};
+    char *str = set_to_string(&set);
+    assert(str != NULL);
+    assert(strcmp(str, "{}") == 0);
+    free(str);
+}
+
+void test_set_to_string_single_element()
+{
+    int elements[] = {5};
+    struct Set set = {elements, 1};
+    char *str = set_to_string(&set);
+    assert(str != NULL);
+    assert(strcmp(str, "{5}") == 0);
+    free(str);
+}
+
+void test_set_to_string_multiple_elements()
+{
+    int elements[] = {3, 7, 12};
+    struct Set set = {elements, 3};
+    char *str = set_to_string(&set);
+    assert(str != NULL);
+    assert(strcmp(str, "{3, 7, 12}") == 0);
+    free(str);
+}
+
+void test_set_to_string_null_set()
+{
+    char *str = set_to_string(NULL);
+    assert(str == NULL);
+}
+
+int main()
+{
+    test_set_to_string_empty();
+    test_set_to_string_single_element();
+    test_set_to_string_multiple_elements();
+    test_set_to_string_null_set();
+    printf("All tests passed\n");
+    return 0;
+}