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

@@ -0,0 +1,52 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+struct FrozenSet
+{
+    int size;
+    int *elements;
+};
+
+char *frozen_set_to_string(struct FrozenSet *frozen_set)
+{
+    char *str = (char *)malloc(100 * sizeof(char)); // Assume max length of string is 100
+    // Implementation of converting frozen set to string goes here
+    return str;
+}
+
+int main()
+{
+    // Test case 1: Empty frozen set
+    struct FrozenSet empty_set = {0, NULL};
+    char *empty_str = frozen_set_to_string(&empty_set);
+    assert(empty_str != NULL);
+    free(empty_str);
+
+    // Test case 2: Frozen set with elements
+    int elements1[] = {1, 2, 3};
+    struct FrozenSet set1 = {3, elements1};
+    char *str1 = frozen_set_to_string(&set1);
+    assert(str1 != NULL);
+    free(str1);
+
+    // Test case 3: Frozen set with large number of elements
+    int elements2[] = {100, 200, 300, 400, 500};
+    struct FrozenSet set2 = {5, elements2};
+    char *str2 = frozen_set_to_string(&set2);
+    assert(str2 != NULL);
+    free(str2);
+
+    // Test case 4: Frozen set with negative elements
+    int elements3[] = {-1, -2, -3};
+    struct FrozenSet set3 = {3, elements3};
+    char *str3 = frozen_set_to_string(&set3);
+    assert(str3 != NULL);
+    free(str3);
+
+    // Add more test cases for corner cases and edge cases here...
+
+    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_generate_range.c

@@ -0,0 +1,62 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int *generate_range(int start, int end, int step, size_t *range_size)
+{
+    if (step == 0)
+    {
+        *range_size = 0;
+        return NULL;
+    }
+
+    int size = (end - start) / step + 1;
+    int *result = (int *)malloc(size * sizeof(int));
+
+    int value = start;
+    for (int i = 0; i < size; i++)
+    {
+        result[i] = value;
+        value += step;
+    }
+
+    *range_size = size;
+    return result;
+}
+
+void test_generate_range()
+{
+    size_t range_size;
+
+    // Test case 1: Normal range
+    int *range1 = generate_range(0, 5, 1, &range_size);
+    assert(range1 != NULL);
+    assert(range_size == 6);
+    for (int i = 0; i < 6; i++)
+    {
+        assert(range1[i] == i);
+    }
+    free(range1);
+
+    // Test case 2: Negative step
+    int *range2 = generate_range(10, 5, -2, &range_size);
+    assert(range2 != NULL);
+    assert(range_size == 3);
+    assert(range2[0] == 10);
+    assert(range2[1] == 8);
+    assert(range2[2] == 6);
+    free(range2);
+
+    // Test case 3: Step is zero
+    int *range3 = generate_range(-2, 2, 0, &range_size);
+    assert(range3 == NULL);
+    assert(range_size == 0);
+}
+
+int main()
+{
+    test_generate_range();
+    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_index_of_char.c

@@ -0,0 +1,77 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+// Function to test
+ssize_t index_of_char(const char *str, char chr);
+
+// Test cases
+void test_index_of_char_normal_case()
+{
+    const char *str = "hello";
+    char chr = 'e';
+    ssize_t result = index_of_char(str, chr);
+    assert(result == 1);
+}
+
+void test_index_of_char_not_found()
+{
+    const char *str = "hello";
+    char chr = 'z';
+    ssize_t result = index_of_char(str, chr);
+    assert(result == -1);
+}
+
+void test_index_of_char_empty_string()
+{
+    const char *str = "";
+    char chr = 'a';
+    ssize_t result = index_of_char(str, chr);
+    assert(result == -1);
+}
+
+void test_index_of_char_null_string()
+{
+    const char *str = NULL;
+    char chr = 'a';
+    ssize_t result = index_of_char(str, chr);
+    assert(result == -1);
+}
+
+void test_index_of_char_null_character()
+{
+    const char *str = "hello";
+    char chr = '\0';
+    ssize_t result = index_of_char(str, chr);
+    assert(result == -1);
+}
+
+void test_index_of_char_single_character_string_found()
+{
+    const char *str = "h";
+    char chr = 'h';
+    ssize_t result = index_of_char(str, chr);
+    assert(result == 0);
+}
+
+void test_index_of_char_single_character_string_not_found()
+{
+    const char *str = "a";
+    char chr = 'b';
+    ssize_t result = index_of_char(str, chr);
+    assert(result == -1);
+}
+
+// Main function to run all the test cases
+int main()
+{
+    test_index_of_char_normal_case();
+    test_index_of_char_not_found();
+    test_index_of_char_empty_string();
+    test_index_of_char_null_string();
+    test_index_of_char_null_character();
+    test_index_of_char_single_character_string_found();
+    test_index_of_char_single_character_string_not_found();
+
+    printf("All test cases 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_int_to_string.c

@@ -0,0 +1,54 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+// Test function
+void test_int_to_string()
+{
+    // Test case 1
+    int num1 = 12345;
+    char *expected_str1 = "12345";
+    char *result_str1 = int_to_string(num1);
+    assert(strcmp(expected_str1, result_str1) == 0);
+
+    // Test case 2
+    int num2 = -54321;
+    char *expected_str2 = "-54321";
+    char *result_str2 = int_to_string(num2);
+    assert(strcmp(expected_str2, result_str2) == 0);
+
+    // Test case 3
+    int num3 = 0;
+    char *expected_str3 = "0";
+    char *result_str3 = int_to_string(num3);
+    assert(strcmp(expected_str3, result_str3) == 0);
+
+    // Test case 4 (corner case: largest positive number)
+    int num4 = 2147483647;
+    char *expected_str4 = "2147483647";
+    char *result_str4 = int_to_string(num4);
+    assert(strcmp(expected_str4, result_str4) == 0);
+
+    // Test case 5 (corner case: smallest negative number)
+    int num5 = -2147483648;
+    char *expected_str5 = "-2147483648";
+    char *result_str5 = int_to_string(num5);
+    assert(strcmp(expected_str5, result_str5) == 0);
+
+    // Free dynamically allocated memory
+    free(result_str1);
+    free(result_str2);
+    free(result_str3);
+    free(result_str4);
+    free(result_str5);
+
+    printf("All test cases passed!\n");
+}
+
+// Main function
+int main()
+{
+    test_int_to_string();
+    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_is_alphanumeric.c

@@ -0,0 +1,50 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int is_alphanumeric(const char *str)
+{
+    if (str == NULL)
+    {
+        return 0;
+    }
+    while (*str)
+    {
+        if ((*str < 'a' || *str > 'z') && (*str < 'A' || *str > 'Z') && (*str < '0' || *str > '9'))
+        {
+            return 0;
+        }
+        str++;
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test cases for empty string
+    assert(is_alphanumeric("") == 0);
+
+    // Test cases for only alphabets
+    assert(is_alphanumeric("abc") == 1);
+    assert(is_alphanumeric("ABC") == 1);
+    assert(is_alphanumeric("abC") == 1);
+    assert(is_alphanumeric("aBc") == 1);
+    assert(is_alphanumeric("123") == 0);
+
+    // Test cases for only digits
+    assert(is_alphanumeric("123") == 1);
+    assert(is_alphanumeric("456") == 1);
+    assert(is_alphanumeric("789") == 1);
+    assert(is_alphanumeric("312") == 1);
+    assert(is_alphanumeric("abc123") == 0);
+
+    // Test case for special characters
+    assert(is_alphanumeric("abc123@") == 0);
+
+    // Test case for NULL input
+    assert(is_alphanumeric(NULL) == 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_is_array_digit.c

@@ -0,0 +1,67 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <string.h>
+
+int is_array_digit(const char *arr[], size_t size)
+{
+    // Check for NULL array or empty array
+    if (arr == NULL || size == 0)
+    {
+        return 1;
+    }
+
+    // Iterate through the array to check each string
+    for (size_t i = 0; i < size; i++)
+    {
+        if (arr[i] == NULL || *arr[i] == '\0')
+        {
+            continue; // Treat NULL or empty string as containing only digits
+        }
+
+        // Check if the string contains non-digit characters
+        for (size_t j = 0; j < strlen(arr[i]); j++)
+        {
+            if (arr[i][j] < '0' || arr[i][j] > '9')
+            {
+                return 0; // Non-digit character found
+            }
+        }
+    }
+
+    return 1; // All strings contain only digits
+}
+
+int main()
+{
+    // Test cases for is_array_digit function
+
+    // Empty array
+    const char *emptyArray[] = {};
+    assert(is_array_digit(emptyArray, 0) == 1);
+
+    // NULL array
+    assert(is_array_digit(NULL, 5) == 1);
+
+    // Array with all digit strings
+    const char *allDigitArray[] = {"123", "456", "789"};
+    assert(is_array_digit(allDigitArray, 3) == 1);
+
+    // Array with non-digit strings
+    const char *nonDigitArray[] = {"123", "4A6", "789"};
+    assert(is_array_digit(nonDigitArray, 3) == 0);
+
+    // Array with empty strings
+    const char *emptyStringArray[] = {"123", "", "789"};
+    assert(is_array_digit(emptyStringArray, 3) == 1);
+
+    // Array with NULL strings
+    const char *nullStringArray[] = {"123", NULL, "789"};
+    assert(is_array_digit(nullStringArray, 3) == 1);
+
+    // Array with non-null-terminated string
+    const char *nonNullTerminatedArray[] = {"123", "4567", "789"};
+    assert(is_array_digit(nonNullTerminatedArray, 3) == 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_is_array_lower.c

@@ -0,0 +1,52 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int is_array_lower(const char *arr[], size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        const char *str = arr[i];
+        while (*str)
+        {
+            if (*str < 'a' || *str > 'z')
+            {
+                return 0;
+            }
+            str++;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: All lowercase
+    const char *arr1[] = {"hello", "world", "this", "is", "a", "test"};
+    size_t size1 = sizeof(arr1) / sizeof(arr1[0]);
+    assert(is_array_lower(arr1, size1) == 1);
+
+    // Test case 2: Mixed case
+    const char *arr2[] = {"hello", "World", "tHis", "IS", "a", "teSt"};
+    size_t size2 = sizeof(arr2) / sizeof(arr2[0]);
+    assert(is_array_lower(arr2, size2) == 0);
+
+    // Test case 3: Empty array
+    const char *arr3[] = {};
+    size_t size3 = 0;
+    assert(is_array_lower(arr3, size3) == 1);
+
+    // Test case 4: Single empty string
+    const char *arr4[] = {""};
+    size_t size4 = 1;
+    assert(is_array_lower(arr4, size4) == 1);
+
+    // Test case 5: Single uppercase character
+    const char *arr5[] = {"Hello"};
+    size_t size5 = 1;
+    assert(is_array_lower(arr5, size5) == 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_is_array_upper.c

@@ -0,0 +1,28 @@
+#include "../foundationallib.h"
+#include <assert.h>
+int main()
+{
+    // Test case 1: Array containing only uppercase characters
+    const char *arr1[] = {"HELLO", "WORLD", "THIS", "IS", "A", "TEST"};
+    assert(is_array_upper(arr1, 6) == 1);
+
+    // Test case 2: Array containing both uppercase and lowercase characters
+    const char *arr2[] = {"Hello", "World", "This", "Is", "A", "Test"};
+    assert(is_array_upper(arr2, 6) == 0);
+
+    // Test case 3: Array containing only one string
+    const char *arr3[] = {"HELLO"};
+    assert(is_array_upper(arr3, 1) == 1);
+
+    // Test case 4: Array containing an empty string
+    const char *arr4[] = {""};
+    assert(is_array_upper(arr4, 1) == 1);
+
+    // Test case 5: Array containing special characters
+    const char *arr5[] = {"HELLO!", "WORLD@", "THIS#", "IS$", "A%", "TEST^"};
+    assert(is_array_upper(arr5, 6) == 0);
+
+    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_is_numeric.c

@@ -0,0 +1,36 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+// Function to test
+FOUNDATIONAL_LIB_FUNC int is_numeric(const char *str)
+{
+    while (*str)
+    {
+        if (*str < '0' || *str > '9')
+        {
+            return 0;
+        }
+        str++;
+    }
+    return 1;
+}
+
+// Test suite
+int main()
+{
+    // Test cases for is_numeric function
+    assert(is_numeric("12345") == 1);   // All numbers
+    assert(is_numeric("abc123") == 0);  // Alphanumeric
+    assert(is_numeric("9999999") == 1); // All numbers
+    assert(is_numeric("") == 1);        // Empty string
+    assert(is_numeric("00123") == 1);   // Leading zeros
+    assert(is_numeric("12 34") == 0);   // Space
+    assert(is_numeric("12.34") == 0);   // Decimal point
+    assert(is_numeric("+123") == 0);    // Positive sign
+    assert(is_numeric("-123") == 0);    // Negative sign
+
+    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_is_string_alpha.c

@@ -0,0 +1,43 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+
+FOUNDATIONAL_LIB_FUNC int is_string_alpha(const char *str)
+{
+    if (!str)
+    {
+        return 0;
+    }
+    while (*str)
+    {
+        if (!isalnum(*str))
+        {
+            return 0;
+        }
+        str++;
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Empty string should return 1
+    assert(is_string_alpha("") == 1);
+
+    // Test case 2: String with only alphabets should return 1
+    assert(is_string_alpha("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") == 1);
+
+    // Test case 3: String with only digits should return 1
+    assert(is_string_alpha("0123456789") == 1);
+
+    // Test case 4: String with both alphabets and digits should return 1
+    assert(is_string_alpha("abc123") == 1);
+
+    // Test case 5: String with special characters should return 0
+    assert(is_string_alpha("abc!@#") == 0);
+
+    // Test case 6: Null string should return 0
+    assert(is_string_alpha(NULL) == 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_is_string_digit.c

@@ -0,0 +1,54 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+int is_string_digit(const char *str)
+{
+    if (*str == '\0')
+    {
+        return 1;
+    }
+
+    while (*str)
+    {
+        if (*str < '0' || *str > '9')
+        {
+            return 0;
+        }
+        str++;
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Empty string
+    assert(is_string_digit("") == 1);
+
+    // Test case 2: Single non-digit character
+    assert(is_string_digit("a") == 0);
+
+    // Test case 3: Single digit character
+    assert(is_string_digit("5") == 1);
+
+    // Test case 4: String with all digits
+    assert(is_string_digit("1234567890") == 1);
+
+    // Test case 5: String with mixed characters including digits
+    assert(is_string_digit("abc123") == 0);
+
+    // Test case 6: String with special characters
+    assert(is_string_digit("!@#%$") == 0);
+
+    // Test case 7: String with leading whitespace
+    assert(is_string_digit(" 123") == 0);
+
+    // Test case 8: String with trailing whitespace
+    assert(is_string_digit("123 ") == 0);
+
+    // Test case 9: String with a mix of whitespace and digits
+    assert(is_string_digit("12 34") == 0);
+
+    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_is_string_lower.c

@@ -0,0 +1,50 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+int is_string_lower(const char *str)
+{
+    if (str == NULL)
+    {
+        return 0;
+    }
+
+    while (*str != '\0')
+    {
+        if (*str < 'a' || *str > 'z')
+        {
+            return 0;
+        }
+        str++;
+    }
+
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: All lowercase characters
+    const char *test_string1 = "abcdefghijklmnopqrstuvwxyz";
+    assert(is_string_lower(test_string1) == 1);
+
+    // Test case 2: Uppercase characters
+    const char *test_string2 = "abcDefg";
+    assert(is_string_lower(test_string2) == 0);
+
+    // Test case 3: Empty string
+    const char *test_string3 = "";
+    assert(is_string_lower(test_string3) == 1);
+
+    // Test case 4: NULL input
+    const char *test_string4 = NULL;
+    assert(is_string_lower(test_string4) == 0);
+
+    // Test case 5: Numbers and special characters
+    const char *test_string5 = "abc123";
+    assert(is_string_lower(test_string5) == 0);
+
+    printf("All test cases 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_is_string_space.c

@@ -0,0 +1,48 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+int is_string_space(const char *str)
+{
+    if (str == NULL)
+    {
+        return 0;
+    }
+    while (*str != '\0')
+    {
+        if (*str != ' ' && *str != '\t')
+        {
+            return 0;
+        }
+        str++;
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Empty string
+    const char *empty = "";
+    assert(is_string_space(empty) == 1);
+
+    // Test case 2: String with only spaces
+    const char *spaces = "    ";
+    assert(is_string_space(spaces) == 1);
+
+    // Test case 3: String with only tabs
+    const char *tabs = "\t\t\t";
+    assert(is_string_space(tabs) == 1);
+
+    // Test case 4: String with spaces and tabs
+    const char *mixed = "  \t  \t  ";
+    assert(is_string_space(mixed) == 1);
+
+    // Test case 5: String with other characters
+    const char *non_space = "not all spaces";
+    assert(is_string_space(non_space) == 0);
+
+    printf("All test cases passed!\n");
+
+    return 0;
+}