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

@@ -0,0 +1,69 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+// Test cases
+void test_null_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+
+    dict_destructor(dict);
+}
+
+void test_single_key()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+void test_multiple_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+    dict_add(dict, "dasdasdasdas", "dasdasdasdas");
+    dict_add(dict, "q1qqqqqqqqqqqqq", "bar");
+    dict_add(dict, "qqqqqqqqqqqqqqqqqqqfoo", "bardas");
+    dict_add(dict, "fossssssso", "badsar");
+    dict_add(dict, "cat", "dsabar");
+    dict_add(dict, "leopard", "dasdasdasbar");
+    dict_add(dict, "!!!!!!!!!!!!!!!!!!", "badddr");
+    dict_add(dict, "fdsadasoo", "bar");
+    dict_add(dict, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^", "bar");
+    dict_add(dict, "$$$$$$$$$$$$$$$$$$", "bar");
+    dict_add(dict, "_", "bar");
+    dict_add(dict, "fodso", "bar");
+    dict_add(dict, "foodsa", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+int main()
+{
+
+    test_null_keys();
+    test_single_key();
+    test_multiple_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_dict_del_values.c

@@ -0,0 +1,69 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+// Test cases
+void test_null_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+
+    dict_destructor(dict);
+}
+
+void test_single_key()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+void test_multiple_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+    dict_add(dict, "dasdasdasdas", "dasdasdasdas");
+    dict_add(dict, "q1qqqqqqqqqqqqq", "bar");
+    dict_add(dict, "qqqqqqqqqqqqqqqqqqqfoo", "bardas");
+    dict_add(dict, "fossssssso", "badsar");
+    dict_add(dict, "cat", "dsabar");
+    dict_add(dict, "leopard", "dasdasdasbar");
+    dict_add(dict, "!!!!!!!!!!!!!!!!!!", "badddr");
+    dict_add(dict, "fdsadasoo", "bar");
+    dict_add(dict, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^", "bar");
+    dict_add(dict, "$$$$$$$$$$$$$$$$$$", "bar");
+    dict_add(dict, "_", "bar");
+    dict_add(dict, "fodso", "bar");
+    dict_add(dict, "foodsa", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+int main()
+{
+
+    test_null_keys();
+    test_single_key();
+    test_multiple_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_dict_destructor.c

@@ -0,0 +1,69 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+// Test cases
+void test_null_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+
+    dict_destructor(dict);
+}
+
+void test_single_key()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+void test_multiple_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+    dict_add(dict, "dasdasdasdas", "dasdasdasdas");
+    dict_add(dict, "q1qqqqqqqqqqqqq", "bar");
+    dict_add(dict, "qqqqqqqqqqqqqqqqqqqfoo", "bardas");
+    dict_add(dict, "fossssssso", "badsar");
+    dict_add(dict, "cat", "dsabar");
+    dict_add(dict, "leopard", "dasdasdasbar");
+    dict_add(dict, "!!!!!!!!!!!!!!!!!!", "badddr");
+    dict_add(dict, "fdsadasoo", "bar");
+    dict_add(dict, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^", "bar");
+    dict_add(dict, "$$$$$$$$$$$$$$$$$$", "bar");
+    dict_add(dict, "_", "bar");
+    dict_add(dict, "fodso", "bar");
+    dict_add(dict, "foodsa", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+int main()
+{
+
+    test_null_keys();
+    test_single_key();
+    test_multiple_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_dict_get.c

@@ -0,0 +1,69 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+// Test cases
+void test_null_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+
+    dict_destructor(dict);
+}
+
+void test_single_key()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+void test_multiple_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+    dict_add(dict, "dasdasdasdas", "dasdasdasdas");
+    dict_add(dict, "q1qqqqqqqqqqqqq", "bar");
+    dict_add(dict, "qqqqqqqqqqqqqqqqqqqfoo", "bardas");
+    dict_add(dict, "fossssssso", "badsar");
+    dict_add(dict, "cat", "dsabar");
+    dict_add(dict, "leopard", "dasdasdasbar");
+    dict_add(dict, "!!!!!!!!!!!!!!!!!!", "badddr");
+    dict_add(dict, "fdsadasoo", "bar");
+    dict_add(dict, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^", "bar");
+    dict_add(dict, "$$$$$$$$$$$$$$$$$$", "bar");
+    dict_add(dict, "_", "bar");
+    dict_add(dict, "fodso", "bar");
+    dict_add(dict, "foodsa", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+int main()
+{
+
+    test_null_keys();
+    test_single_key();
+    test_multiple_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_dict_get_check.c

@@ -0,0 +1,75 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+// Test cases
+void test_null_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+
+    dict_destructor(dict);
+}
+
+void test_single_key()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+void test_multiple_keys()
+{
+    struct Dict *dict = dict_new_instance();
+    size_t size;
+    dict_add(dict, "foo", "bar");
+    dict_add(dict, "dasdasdasdas", NULL);
+
+    assert(dict_get(dict, "dasdasdasdas") == NULL);
+    int is_it_in = 12345;
+    assert(dict_get_check(dict, "dasdasdasdas", &is_it_in) == NULL);
+    assert(is_it_in == 1);
+
+    dict_add(dict, "q1qqqqqqqqqqqqq", "bar");
+    dict_add(dict, "qqqqqqqqqqqqqqqqqqqfoo", NULL);
+    dict_add(dict, "fossssssso", "badsar");
+    dict_add(dict, "cat", "dsabar");
+    dict_add(dict, "leopard", "dasdasdasbar");
+    dict_add(dict, "!!!!!!!!!!!!!!!!!!", "badddr");
+    dict_add(dict, "fdsadasoo", "bar");
+    dict_add(dict, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^", "bar");
+    dict_add(dict, "$$$$$$$$$$$$$$$$$$", "bar");
+    dict_add(dict, "_", "bar");
+    dict_add(dict, "fodso", "bar");
+    dict_add(dict, "foodsa", "bar");
+
+    char **keys;
+
+    void **values;
+    dict_to_array(dict, &keys, &values, &size);
+    dict_del_keys(keys);
+    dict_del_values(values);
+    dict_destructor(dict);
+}
+
+int main()
+{
+
+    test_null_keys();
+    test_single_key();
+    test_multiple_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_dict_hash.c

@@ -0,0 +1,18 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+void test_dict_hash()
+{
+    /* Check it doesn't crash. */
+    for (size_t i = 0; i < 100000; ++i)
+        dict_hash("abcdefabcdefabcdefabcdefabcdefabcdefabcdef", 12345);
+}
+
+int main()
+{
+    test_dict_hash();
+    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_dict_iter.c

@@ -0,0 +1,69 @@
+#include "../foundationallib.h"
+
+// Define the callback function for testing
+void test_callback(char *key, void *value)
+{
+    // 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 dictionary for testing
+    struct Dict *dict = dict_new_instance();
+    dict_iter(dict, &test_callback);
+    dict_destructor(dict);
+
+    struct Dict *dict = dict_new_instance();
+    dict_add(dict, "foo", "bar");
+    dict_iter(dict, &test_callback);
+    dict_destructor(dict);
+
+    struct Dict *dict = dict_new_instance();
+    dict_add(dict, "fooz", "barz");
+    dict_add(dict, "dsdsfooz", NULL);
+    dict_iter(dict, &test_callback);
+    dict_destructor(dict);
+
+    struct Dict *dict = dict_new_instance();
+    dict_add(dict, "fooz", "barz");
+    dict_add(dict, "dsdsfooz", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_iter(dict, &test_callback);
+    dict_destructor(dict);
+
+    struct Dict *dict = dict_new_instance();
+    dict_add(dict, "fooz", "barz");
+    dict_add(dict, "dsdsfoozssssssssssssssssssssssssssssssss", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozssssssssssssssssssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfoozssssssssssssssssssssssssss", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozssssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfoozdasdsadasdsadsa", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozdasdasdasdas", "barz");
+    dict_add(dict, "dsdsfoozca", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozsssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfoozqqqqqqqqqqqqqqqqqqqqqqqq", NULL);
+    dict_add(dict, "dsdsfoozssssssssssqqqqqqqqqqqqqqqq", NULL);
+    dict_add(dict, "foozqqqqqqqqqqqq", "barz");
+    dict_add(dict, "dsdsfoozaaaaaaaaaaa", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfooz", NULL);
+    dict_add(dict, "dddddddddddsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozsssssssssss", "barz");
+    dict_add(dict, "dsdsdsfooz", NULL);
+    dict_add(dict, "dsdsfoozssssssssssds", NULL);
+    dict_iter(dict, &test_callback);
+    dict_destructor(dict);
+}
+
+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_dict_new_instance.c

@@ -0,0 +1,69 @@
+#include "../foundationallib.h"
+
+// Define the callback function for testing
+void test_callback(char *key, void *value)
+{
+    // 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 dictionary for testing
+    struct Dict *empty_dict = dict_new_instance();
+    dict_iter(empty_dict, &test_callback);
+    dict_destructor(empty_dict);
+
+    struct Dict *empty_dict = dict_new_instance();
+    dict_add(dict, "foo", "bar");
+    dict_iter(empty_dict, &test_callback);
+    dict_destructor(empty_dict);
+
+    struct Dict *empty_dict = dict_new_instance();
+    dict_add(dict, "fooz", "barz");
+    dict_add(dict, "dsdsfooz", NULL);
+    dict_iter(empty_dict, &test_callback);
+    dict_destructor(empty_dict);
+
+    struct Dict *empty_dict = dict_new_instance();
+    dict_add(dict, "fooz", "barz");
+    dict_add(dict, "dsdsfooz", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_iter(empty_dict, &test_callback);
+    dict_destructor(empty_dict);
+
+    struct Dict *empty_dict = dict_new_instance();
+    dict_add(dict, "fooz", "barz");
+    dict_add(dict, "dsdsfoozssssssssssssssssssssssssssssssss", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozssssssssssssssssssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfoozssssssssssssssssssssssssss", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozssssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfoozdasdsadasdsadsa", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozdasdasdasdas", "barz");
+    dict_add(dict, "dsdsfoozca", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozsssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfoozqqqqqqqqqqqqqqqqqqqqqqqq", NULL);
+    dict_add(dict, "dsdsfoozssssssssssqqqqqqqqqqqqqqqq", NULL);
+    dict_add(dict, "foozqqqqqqqqqqqq", "barz");
+    dict_add(dict, "dsdsfoozaaaaaaaaaaa", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfooz", NULL);
+    dict_add(dict, "dddddddddddsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozsssssssssss", "barz");
+    dict_add(dict, "dsdsdsfooz", NULL);
+    dict_add(dict, "dsdsfoozssssssssssds", NULL);
+    dict_iter(empty_dict, &test_callback);
+    dict_destructor(empty_dict);
+}
+
+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_dict_reserve_more.c

@@ -0,0 +1,21 @@
+#include <assert.h>
+
+#include "../foundationallib.h"
+
+void test_dict_reserve_more()
+{
+    // Test case 1: testing with a valid dictionary and a positive number of new elements
+    struct Dict *dict1 = dict_new_instance();
+    assert(dict_reserve_more(dict1, 10) == 0);
+
+    // Test case 2: testing with a valid dictionary and zero number of new elements
+    struct Dict *dict2 = dict_new_instance();
+    assert(dict_reserve_more(dict2, 0) == 0);
+}
+
+int main()
+{
+    test_dict_reserve_more();
+    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_resize.c

@@ -0,0 +1,8 @@
+#include "../foundationallib.h"
+
+int main()
+{
+    /* This is an internal function. We do not need to test it. */
+
+    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_size.c

@@ -0,0 +1,79 @@
+#include <assert.h>
+
+#include "../foundationallib.h"
+
+// Define the callback function for testing
+void test_callback(char *key, void *value)
+{
+    // 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 dictionary for testing
+    struct Dict *dict = dict_new_instance();
+    dict_iter(dict, &test_callback);
+    dict_destructor(dict);
+
+    struct Dict *dict = dict_new_instance();
+    dict_add(dict, "foo", "bar");
+    dict_iter(dict, &test_callback);
+    dict_destructor(dict);
+
+    struct Dict *dict = dict_new_instance();
+    dict_add(dict, "fooz", "barz");
+    assert(dict_size(dict) == 1);
+
+    dict_add(dict, "dsdsfooz", NULL);
+    assert(dict_size(dict) == 2);
+    dict_iter(dict, &test_callback);
+    dict_destructor(dict);
+
+    struct Dict *dict = dict_new_instance();
+    dict_add(dict, "fooz", "barz");
+    assert(dict_size(dict) == 1);
+    dict_add(dict, "dsdsfooz", NULL);
+    assert(dict_size(dict) == 2);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    assert(dict_size(dict) == 3);
+    dict_iter(dict, &test_callback);
+    dict_destructor(dict);
+
+    struct Dict *dict = dict_new_instance();
+    dict_add(dict, "fooz", "barz");
+    dict_add(dict, "dsdsfoozssssssssssssssssssssssssssssssss", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozssssssssssssssssssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfoozssssssssssssssssssssssssss", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozssssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfoozdasdsadasdsadsa", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozdasdasdasdas", "barz");
+    dict_add(dict, "dsdsfoozca", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozsssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfoozqqqqqqqqqqqqqqqqqqqqqqqq", NULL);
+    dict_add(dict, "dsdsfoozssssssssssqqqqqqqqqqqqqqqq", NULL);
+    dict_add(dict, "foozqqqqqqqqqqqq", "barz");
+    dict_add(dict, "dsdsfoozaaaaaaaaaaa", NULL);
+    dict_add(dict, "dsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozssssssssssssssssssssssssssss", "barz");
+    dict_add(dict, "dsdsfooz", NULL);
+    dict_add(dict, "dddddddddddsdsfoozssssssssss", NULL);
+    dict_add(dict, "foozsssssssssss", "barz");
+    dict_add(dict, "dsdsdsfooz", NULL);
+    dict_add(dict, "dsdsfoozssssssssssds", NULL);
+    dict_iter(dict, &test_callback);
+
+    assert(dict_size(dict) == 24);
+    dict_destructor(dict);
+}
+
+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_dict_to_array.c

@@ -0,0 +1,26 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+void test_dict_to_array_empty_dict()
+{
+    struct Dict *dict = NULL;
+    char **keys;
+    void **values;
+    size_t size = 0;
+    int result = dict_to_array(dict, &keys, &values, &size);
+    assert(result == -1);
+    assert(keys == NULL);
+    assert(values == NULL);
+    assert(size == 0);
+}
+
+void test_dict_to_array_non_empty_dict() {}
+
+int main()
+{
+    test_dict_to_array_empty_dict();
+    test_dict_to_array_non_empty_dict();
+    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_to_string.c

@@ -0,0 +1,29 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+void test_dict_to_string()
+{
+    struct Dict *d = dict_new_instance();
+
+    // Test pointer format
+    char *ptr_str = dict_to_string(&d, 0);
+    // Check that ptr_str is not NULL
+    assert(ptr_str != NULL);
+    // Free the memory allocated for ptr_str
+    free(ptr_str);
+
+    // Test string format
+    char *str_str = dict_to_string(&d, 1);
+    // Check that str_str is not NULL
+    assert(str_str != NULL);
+    // Free the memory allocated for str_str
+    free(str_str);
+}
+
+int main()
+{
+    test_dict_to_string();
+    return 0;
+}