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

@@ -0,0 +1,53 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *shellescape(const char *input);
+
+void test_shellescape_empty_string()
+{
+    char *result = shellescape("");
+    assert(strcmp(result, "") == 0);
+    free(result);
+}
+
+void test_shellescape_no_special_characters()
+{
+    char *result = shellescape("Hello World");
+    assert(strcmp(result, "Hello World") == 0);
+    free(result);
+}
+
+void test_shellescape_with_special_characters()
+{
+    char *result = shellescape("This is a $test with *special* characters");
+    assert(strcmp(result, "This is a \\$test with \\*special\\* characters") == 0);
+    free(result);
+}
+
+void test_shellescape_null_input()
+{
+    char *result = shellescape(NULL);
+    assert(result == NULL);
+}
+
+void test_shellescape_long_input()
+{
+    char *input = "A very long input string with special characters $!@*^&";
+    char *result = shellescape(input);
+    char *expected_result = "A very long input string with special characters \\$\\!\\@\\*^\\&";
+    assert(strcmp(result, expected_result) == 0);
+    free(result);
+}
+
+int main()
+{
+    test_shellescape_empty_string();
+    test_shellescape_no_special_characters();
+    test_shellescape_with_special_characters();
+    test_shellescape_null_input();
+    test_shellescape_long_input();
+
+    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_shuffle_strings_in_place.c

@@ -0,0 +1,39 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test_shuffle_strings_in_place()
+{
+    char *test_strings[] = {"apple", "banana", "cherry", "date", "elderberry"};
+    size_t num_strings = sizeof(test_strings) / sizeof(test_strings[0]);
+
+    // Test for shuffling a valid array of strings
+    char **original_strings = malloc(sizeof(char *) * num_strings);
+    memcpy(original_strings, test_strings, sizeof(test_strings));
+    int result = shuffle_strings_in_place(test_strings, num_strings);
+    assert(result == 1);
+
+    // Test for strings being shuffled in place
+    int any_strings_moved = 0;
+    for (size_t i = 0; i < num_strings; i++)
+    {
+        if (strcmp(original_strings[i], test_strings[i]) != 0)
+        {
+            any_strings_moved = 1;
+            break;
+        }
+    }
+    assert(any_strings_moved == 1);
+
+    free(original_strings);
+
+    printf("All tests pass!\n");
+}
+
+int main()
+{
+    test_shuffle_strings_in_place();
+    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_split.c

@@ -0,0 +1,64 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+// Test function for split
+void test_split()
+{
+    const char *input = "Hello,World,How,Are,You?";
+    const char *delimiter = ",";
+    size_t max_times = 0;
+    size_t output_size = 0;
+
+    // Test Case 1: Normal Split
+    char **result = split(input, &output_size, delimiter, max_times, 0);
+    assert(output_size == 5);
+    assert(strcmp(result[0], "Hello") == 0);
+    assert(strcmp(result[1], "World") == 0);
+    assert(strcmp(result[2], "How") == 0);
+    assert(strcmp(result[3], "Are") == 0);
+    assert(strcmp(result[4], "You?") == 0);
+
+    // Test Case 2: Split with limited times
+    max_times = 2;
+    result = split(input, &output_size, delimiter, max_times, 0);
+    assert(output_size == 3);
+    assert(strcmp(result[0], "Hello") == 0);
+    assert(strcmp(result[1], "World") == 0);
+    assert(strcmp(result[2], "How,Are,You?") == 0);
+
+    // Test Case 3: Keep delimiters in result
+    result = split(input, &output_size, delimiter, max_times, 1);
+    assert(output_size == 3);
+    assert(strcmp(result[0], "Hello,") == 0);
+    assert(strcmp(result[1], "World,") == 0);
+    assert(strcmp(result[2], "How,Are,You?") == 0);
+
+    // Test Case 4: Split with non-existent delimiter
+    const char *non_existent_delim = "/";
+    result = split(input, &output_size, non_existent_delim, max_times, 0);
+    assert(output_size == 1);
+    assert(strcmp(result[0], input) == 0);
+
+    // Test Case 5: Input string is empty
+    const char *empty_input = "";
+    result = split(empty_input, &output_size, delimiter, max_times, 0);
+    assert(output_size == 0);
+    assert(result == NULL);
+
+    // Free memory
+    for (size_t i = 0; i < output_size; i++)
+    {
+        free(result[i]);
+    }
+    free(result);
+
+    printf("All tests passed!\n");
+}
+
+int main()
+{
+    test_split();
+    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_starts_with.c

@@ -0,0 +1,39 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+FOUNDATIONAL_LIB_FUNC int starts_with(const char *str, const char *prefix)
+{
+    if (str == NULL || prefix == NULL)
+    {
+        return 0;
+    }
+    while (*prefix)
+    {
+        if (*prefix++ != *str++)
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test cases
+    assert(starts_with("hello world", "hello") == 1);
+    assert(starts_with("hello world", "world") == 0);
+    assert(starts_with("", "prefix") == 0);
+    assert(starts_with("prefix", "") == 1);
+    assert(starts_with("prefix", "pre") == 1);
+    assert(starts_with("prefix", "prefiX") == 0);
+    assert(starts_with("Hello", "hello") == 0);
+    assert(starts_with("hello", "Hello") == 0);
+    assert(starts_with("hello", "he") == 1);
+    assert(starts_with("hello", "hello") == 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_str_to_double.c

@@ -0,0 +1,32 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+#define EPSILON 0.0000001
+
+void test_str_to_double()
+{
+    assert(fabs(str_to_double("0") - 0.0) < EPSILON);
+    assert(fabs(str_to_double("1") - 1.0) < EPSILON);
+    assert(fabs(str_to_double("-1") + 1.0) < EPSILON);
+    assert(fabs(str_to_double("3.14") - 3.14) < EPSILON);
+    assert(fabs(str_to_double("-3.14") + 3.14) < EPSILON);
+    assert(fabs(str_to_double("2.71828") - 2.71828) < EPSILON);
+    assert(fabs(str_to_double("-2.71828") + 2.71828) < EPSILON);
+    assert(fabs(str_to_double("1234567890.1234567890") - 1234567890.1234567890) < EPSILON);
+    assert(fabs(str_to_double("-1234567890.1234567890") + 1234567890.1234567890) < EPSILON);
+
+    // Add more test cases for corner cases such as
+    // - Empty string
+    // - String with only whitespace
+    // - String with invalid characters
+    // - String with extremely large or small numbers
+    // - String with scientific notation
+
+    // assert statements for corner cases will go here
+}
+
+int main()
+{
+    test_str_to_double();
+    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_string_array_uniq.c

@@ -0,0 +1,60 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Function to test
+int string_array_uniq(const char **arr, size_t size, char ***output, size_t *output_size);
+
+// Test cases
+void test_empty_array()
+{
+    const char *input_array[] = {};
+    char **result_array;
+    size_t result_size;
+    int status = string_array_uniq(input_array, 0, &result_array, &result_size);
+    assert(status == 0);
+    assert(result_size == 0);
+    free(result_array);
+}
+
+void test_no_duplicates()
+{
+    const char *input_array[] = {"apple", "orange", "banana", "grape"};
+    char **result_array;
+    size_t result_size;
+    int status = string_array_uniq(input_array, 4, &result_array, &result_size);
+    assert(status == 0);
+    assert(result_size == 4);
+    assert(strcmp(result_array[0], "apple") == 0);
+    assert(strcmp(result_array[1], "orange") == 0);
+    assert(strcmp(result_array[2], "banana") == 0);
+    assert(strcmp(result_array[3], "grape") == 0);
+    free(result_array);
+}
+
+void test_with_duplicates()
+{
+    const char *input_array[] = {"apple", "orange", "banana", "apple", "grape"};
+    char **result_array;
+    size_t result_size;
+    int status = string_array_uniq(input_array, 5, &result_array, &result_size);
+    assert(status == 0);
+    assert(result_size == 4);
+    assert(strcmp(result_array[0], "apple") == 0);
+    assert(strcmp(result_array[1], "orange") == 0);
+    assert(strcmp(result_array[2], "banana") == 0);
+    assert(strcmp(result_array[3], "grape") == 0);
+    free(result_array);
+}
+
+// Test runner
+int main()
+{
+    test_empty_array();
+    test_no_duplicates();
+    test_with_duplicates();
+    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_string_array_uniq_adjacent.c

@@ -0,0 +1,54 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test_string_array_uniq_adjacent()
+{
+    const char *input_array[] = {"apple", "orange", "orange", "banana", "banana", "apple", "grape"};
+    char **result_array;
+    size_t result_size;
+    int status;
+
+    // Test case 1: Full duplicate array
+    const char *test1_input[] = {"hello", "hello", "hello"};
+    status = string_array_uniq_adjacent(test1_input, 3, &result_array, &result_size);
+    assert(status == 0);
+    assert(result_size == 1);
+    assert(strcmp(result_array[0], "hello") == 0);
+    free(result_array[0]);
+    free(result_array);
+
+    // Test case 2: No duplicates
+    const char *test2_input[] = {"apple", "banana", "orange"};
+    status = string_array_uniq_adjacent(test2_input, 3, &result_array, &result_size);
+    assert(status == 0);
+    assert(result_size == 3);
+    for (size_t i = 0; i < result_size; i++)
+    {
+        assert(strcmp(test2_input[i], result_array[i]) == 0);
+        free(result_array[i]);
+    }
+    free(result_array);
+
+    // Test case 3: Mixed array
+    const char *test3_input[] = {"apple", "apple", "banana", "orange", "orange", "grape", "grape"};
+    status = string_array_uniq_adjacent(test3_input, 7, &result_array, &result_size);
+    assert(status == 0);
+    assert(result_size == 4);
+    const char *expected_result[4] = {"apple", "banana", "orange", "grape"};
+    for (size_t i = 0; i < result_size; i++)
+    {
+        assert(strcmp(expected_result[i], result_array[i]) == 0);
+        free(result_array[i]);
+    }
+    free(result_array);
+}
+
+int main()
+{
+    test_string_array_uniq_adjacent();
+    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_string_to_int.c

@@ -0,0 +1,55 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+void test_valid_integer()
+{
+    const char *str = "12345";
+    int result = string_to_int(str);
+    assert(result == 12345);
+}
+
+void test_negative_integer()
+{
+    const char *str = "-54321";
+    int result = string_to_int(str);
+    assert(result == -54321);
+}
+
+void test_zero()
+{
+    const char *str = "0";
+    int result = string_to_int(str);
+    assert(result == 0);
+}
+
+void test_large_integer()
+{
+    const char *str = "2147483647"; // INT_MAX
+    int result = string_to_int(str);
+    assert(result == 2147483647);
+    // edge case for signed int
+    const char *negative_str = "-2147483648"; // INT_MIN
+    int negative_result = string_to_int(negative_str);
+    assert(negative_result == -2147483648);
+}
+
+void test_invalid_integer()
+{
+    const char *str = "123abc";
+    // behavior is undefined for invalid integer representation
+    // so we can't use assert for this case
+    string_to_int(str);
+    // no assert for this case
+}
+
+int main()
+{
+    test_valid_integer();
+    test_negative_integer();
+    test_zero();
+    test_large_integer();
+    test_invalid_integer();
+
+    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_string_to_json.c

@@ -0,0 +1,98 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *string_to_json(const char *input_string)
+{
+    if (input_string == NULL)
+    {
+        return NULL;
+    }
+
+    size_t input_length = strlen(input_string);
+    size_t output_length = 0;
+
+    // Calculate the length of the output JSON string
+    for (size_t i = 0; i < input_length; i++)
+    {
+        if (input_string[i] == '"' || input_string[i] == '\\')
+        {
+            output_length += 2; // Add extra space for escaped character
+        }
+        else
+        {
+            output_length++;
+        }
+    }
+
+    // Allocate memory for the output JSON string
+    char *json_string = (char *)malloc(output_length + 1); // Add 1 for null terminator
+    if (json_string == NULL)
+    {
+        return NULL;
+    }
+
+    // Convert the input string to JSON format
+    size_t index = 0;
+    for (size_t i = 0; i < input_length; i++)
+    {
+        if (input_string[i] == '"')
+        {
+            json_string[index++] = '\\'; // Escape double quote
+            json_string[index++] = '"';
+        }
+        else if (input_string[i] == '\\')
+        {
+            json_string[index++] = '\\'; // Escape backslash
+            json_string[index++] = '\\';
+        }
+        else
+        {
+            json_string[index++] = input_string[i];
+        }
+    }
+    json_string[index] = '\0'; // Null-terminate the JSON string
+
+    return json_string;
+}
+
+void test_string_to_json()
+{
+    // Test cases with various input strings and their corresponding expected JSON strings
+    const char *input1 = "Hello, World!";
+    const char *expected_output1 = "Hello, World!";
+    char *result1 = string_to_json(input1);
+    assert(strcmp(result1, expected_output1) == 0); // Input string with no special characters
+    free(result1);
+
+    const char *input2 = "It's a \"nice\" day.";
+    const char *expected_output2 = "It's a \\\"nice\\\" day.";
+    char *result2 = string_to_json(input2);
+    assert(strcmp(result2, expected_output2) == 0); // Input string with double quotes
+    free(result2);
+
+    const char *input3 = "\\escape\\";
+    const char *expected_output3 = "\\\\escape\\\\";
+    char *result3 = string_to_json(input3);
+    assert(strcmp(result3, expected_output3) == 0); // Input string with backslashes
+    free(result3);
+
+    const char *input4 = "";
+    const char *expected_output4 = "";
+    char *result4 = string_to_json(input4);
+    assert(strcmp(result4, expected_output4) == 0); // Empty input string
+    free(result4);
+
+    const char *input5 = NULL;
+    char *result5 = string_to_json(input5);
+    assert(result5 == NULL); // NULL input string
+}
+
+int main()
+{
+    test_string_to_json();
+    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_string_to_lowercase.c

@@ -0,0 +1,73 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *string_to_lowercase(char *str)
+{
+    if (str == NULL)
+    {
+        return NULL;
+    }
+
+    char *result = strdup(str);
+    if (result == NULL)
+    {
+        return NULL;
+    }
+
+    for (int i = 0; result[i]; i++)
+    {
+        result[i] = tolower(result[i]);
+    }
+
+    return result;
+}
+
+void test_string_to_lowercase()
+{
+    // Test with a normal string
+    char *input1 = "Hello, World!";
+    char *expected_output1 = "hello, world!";
+    char *output1 = string_to_lowercase(input1);
+    assert(strcmp(output1, expected_output1) == 0);
+
+    free(output1);
+
+    // Test with an empty string
+    char *input2 = "";
+    char *expected_output2 = "";
+    char *output2 = string_to_lowercase(input2);
+    assert(strcmp(output2, expected_output2) == 0);
+
+    free(output2);
+
+    // Test with a string containing only uppercase letters
+    char *input3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    char *expected_output3 = "abcdefghijklmnopqrstuvwxyz";
+    char *output3 = string_to_lowercase(input3);
+    assert(strcmp(output3, expected_output3) == 0);
+
+    free(output3);
+
+    // Test with a string containing non-alphabetic characters
+    char *input4 = "123!@#";
+    char *expected_output4 = "123!@#";
+    char *output4 = string_to_lowercase(input4);
+    assert(strcmp(output4, expected_output4) == 0);
+
+    free(output4);
+
+    // Test with a NULL input
+    char *input5 = NULL;
+    char *output5 = string_to_lowercase(input5);
+    assert(output5 == NULL);
+}
+
+int main()
+{
+    test_string_to_lowercase();
+    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_string_to_title_case.c

@@ -0,0 +1,80 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *string_to_title_case(const char *str)
+{
+    if (str == NULL)
+    {
+        return NULL;
+    }
+
+    size_t len = strlen(str);
+    char *result = (char *)malloc((len + 1) * sizeof(char));
+    if (result == NULL)
+    {
+        return NULL;
+    }
+
+    strncpy(result, str, len);
+
+    int capitalize_next = 1;
+    for (size_t i = 0; i < len; i++)
+    {
+        if (result[i] == ' ')
+        {
+            capitalize_next = 1;
+        }
+        else
+        {
+            if (capitalize_next)
+            {
+                result[i] = (char)toupper(result[i]);
+                capitalize_next = 0;
+            }
+            else
+            {
+                result[i] = (char)tolower(result[i]);
+            }
+        }
+    }
+
+    return result;
+}
+
+int main()
+{
+    // Test case 1: Empty string
+    char *empty_string = string_to_title_case("");
+    assert(empty_string != NULL);
+    assert(strcmp(empty_string, "") == 0);
+    free(empty_string);
+
+    // Test case 2: All uppercase string
+    char *all_uppercase = string_to_title_case("HELLO WORLD");
+    assert(all_uppercase != NULL);
+    assert(strcmp(all_uppercase, "Hello World") == 0);
+    free(all_uppercase);
+
+    // Test case 3: All lowercase string
+    char *all_lowercase = string_to_title_case("hello world");
+    assert(all_lowercase != NULL);
+    assert(strcmp(all_lowercase, "Hello World") == 0);
+    free(all_lowercase);
+
+    // Test case 4: Mixed case string
+    char *mixed_case = string_to_title_case("hElLo WoRlD");
+    assert(mixed_case != NULL);
+    assert(strcmp(mixed_case, "Hello World") == 0);
+    free(mixed_case);
+
+    // Test case 5: NULL input
+    char *null_input = string_to_title_case(NULL);
+    assert(null_input == NULL);
+
+    printf("All tests passed!\n");
+
+    return 0;
+}