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

@@ -0,0 +1,41 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+FOUNDATIONAL_LIB_FUNC long rand_number_from_range_inclusive_signed(signed long min, signed long max) { return min + rand() % (max - min + 1); }
+
+int main()
+{
+    // Test for range [-10, 10]
+    for (int i = 0; i < 1000; i++)
+    {
+        long num = rand_number_from_range_inclusive_signed(-10, 10);
+        assert(num >= -10 && num <= 10);
+    }
+
+    // Test for range [0, 100]
+    for (int i = 0; i < 1000; i++)
+    {
+        long num = rand_number_from_range_inclusive_signed(0, 100);
+        assert(num >= 0 && num <= 100);
+    }
+
+    // Test for range [-100, 0]
+    for (int i = 0; i < 1000; i++)
+    {
+        long num = rand_number_from_range_inclusive_signed(-100, 0);
+        assert(num >= -100 && num <= 0);
+    }
+
+    // Test for range [-10000, 10000]
+    for (int i = 0; i < 1000; i++)
+    {
+        long num = rand_number_from_range_inclusive_signed(-10000, 10000);
+        assert(num >= -10000 && num <= 10000);
+    }
+
+    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_rand_number_from_range_inclusive_unsigned.c

@@ -0,0 +1,23 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+void test_rand_number_from_range_inclusive_unsigned()
+{
+    // Test with min equal to max
+    assert(rand_number_from_range_inclusive_unsigned(5, 5) == 5);
+
+    // Test with min less than max
+    unsigned long result = rand_number_from_range_inclusive_unsigned(5, 10);
+    assert(result >= 5 && result <= 10);
+
+    // Test with min greater than max
+    result = rand_number_from_range_inclusive_unsigned(10, 5);
+    assert(result >= 5 && result <= 10);
+}
+
+int main()
+{
+    test_rand_number_from_range_inclusive_unsigned();
+    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_reduce.c

@@ -0,0 +1,49 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdio.h>
+
+void reduce(void *array, size_t size, size_t elem_size, void *result, void (*operation)(void *, void *));
+
+// Define binary operation function for testing
+void test_sum_operation(void *element1, void *element2) { (*(int *)element1) += (*(int *)element2); }
+
+int main()
+{
+    int test_array[] = {1, 2, 3, 4, 5};
+    int test_result = 0;
+
+    // Test case 1: Reduce operation with sum binary function
+    reduce(test_array, 5, sizeof(int), &test_result, test_sum_operation);
+    assert(test_result == 15);
+
+    // Test case 2: Reduce operation with product binary function
+    void test_product_operation(void *element1, void *element2) { (*(int *)element1) *= (*(int *)element2); }
+    test_result = 1;
+    reduce(test_array, 5, sizeof(int), &test_result, test_product_operation);
+    assert(test_result == 120);
+
+    // Test case 3: Reduce operation with max binary function
+    void test_max_operation(void *element1, void *element2)
+    {
+        if ((*(int *)element2) > (*(int *)element1))
+        {
+            (*(int *)element1) = (*(int *)element2);
+        }
+    }
+    test_result = 0;
+    reduce(test_array, 5, sizeof(int), &test_result, test_max_operation);
+    assert(test_result == 5);
+
+    // Add more test cases for corner cases, edge cases, and boundary cases
+
+    printf("All tests passed successfully!\n");
+
+    return 0;
+}
+
+void reduce(void *array, size_t size, size_t elem_size, void *result, void (*operation)(void *, void *))
+{
+    // Implementation of reduce function
+}

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

@@ -0,0 +1,44 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+FOUNDATIONAL_LIB_FUNC int reduce_int(int *array, size_t size, int (*operation)(int, int))
+{
+    int result = array[0];
+    for (size_t i = 1; i < size; i++)
+    {
+        result = operation(result, array[i]);
+    }
+    return result;
+}
+
+// Test cases
+void test_add_operation()
+{
+    int test_array[] = {1, 2, 3, 4, 5};
+    int result = reduce_int(test_array, 5, add_operation);
+    assert(result == 15);
+}
+
+void test_multiply_operation()
+{
+    int test_array[] = {1, 2, 3, 4, 5};
+    int result = reduce_int(test_array, 5, multiply_operation);
+    assert(result == 120);
+}
+
+int main()
+{
+    // Run test cases
+    test_add_operation();
+    test_multiply_operation();
+
+    printf("All test cases passed!\n");
+
+    return 0;
+}
+
+// Example binary operation function: addition
+int add_operation(int x, int y) { return x + y; }
+
+// Example binary operation function: multiplication
+int multiply_operation(int x, int y) { return x * y; }

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

@@ -0,0 +1,47 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+// Define a condition function for testing
+int is_even(const void *element)
+{
+    const int *value = (const int *)element;
+    return *value % 2 != 0;
+}
+
+// Define the test suite
+void test_reject_array()
+{
+    // Test case 1: Reject all elements
+    {
+        int source[] = {1, 3, 5};
+        size_t source_size = sizeof(source) / sizeof(source[0]);
+        size_t result_size;
+        int *result = reject_array(source, source_size, sizeof(int), is_even, &result_size);
+        assert(result_size == 0);
+        free(result);
+    }
+
+    // Test case 2: Reject no elements
+    {
+        int source[] = {2, 4, 6};
+        size_t source_size = sizeof(source) / sizeof(source[0]);
+        size_t result_size;
+        int *result = reject_array(source, source_size, sizeof(int), is_even, &result_size);
+        assert(result_size == source_size);
+        for (size_t i = 0; i < result_size; i++)
+        {
+            assert(result[i] == source[i]);
+        }
+        free(result);
+    }
+
+    // Additional test cases can be added here
+}
+
+int main()
+{
+    test_reject_array();
+    printf("All tests pass!\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_replace_all.c

@@ -0,0 +1,73 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+void test_replace_all()
+{
+    char *input1 = "Hello, world!";
+    char *input2 = "aaa";
+    char *input3 = "abcdabcd";
+    char *input4 = "abcdabcdabcd";
+    char *input5 = "abcdabcdabcdabcd";
+    char *input6 = "";
+    char *input7 = "xyz";
+    char *input8 = "mississippi";
+
+    char *old_substring = "world";
+    char *new_substring = "universe";
+    char *result1 = replace_all(input1, old_substring, new_substring);
+    assert(strcmp(result1, "Hello, universe!") == 0);
+    free(result1);
+
+    old_substring = "aa";
+    new_substring = "bb";
+    char *result2 = replace_all(input2, old_substring, new_substring);
+    assert(strcmp(result2, "bb") == 0);
+    free(result2);
+
+    old_substring = "abcd";
+    new_substring = "xy";
+    char *result3 = replace_all(input3, old_substring, new_substring);
+    assert(strcmp(result3, "xyxy") == 0);
+    free(result3);
+
+    old_substring = "abcd";
+    new_substring = "xy";
+    char *result4 = replace_all(input4, old_substring, new_substring);
+    assert(strcmp(result4, "xyxyxy") == 0);
+    free(result4);
+
+    old_substring = "abcd";
+    new_substring = "xy";
+    char *result5 = replace_all(input5, old_substring, new_substring);
+    assert(strcmp(result5, "xyxyxyxy") == 0);
+    free(result5);
+
+    old_substring = "xyz";
+    new_substring = "abc";
+    char *result6 = replace_all(input6, old_substring, new_substring);
+    assert(strcmp(result6, "") == 0);
+    free(result6);
+
+    old_substring = "iss";
+    new_substring = "ix";
+    char *result7 = replace_all(input7, old_substring, new_substring);
+    assert(strcmp(result7, "xy") == 0);
+    free(result7);
+
+    old_substring = "is";
+    new_substring = "was";
+    char *result8 = replace_all(input8, old_substring, new_substring);
+    assert(strcmp(result8, "wasswasppi") == 0);
+    free(result8);
+
+    printf("All tests passed successfully!\n");
+}
+
+int main()
+{
+    test_replace_all();
+    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_replace_all_with_callback.c

@@ -0,0 +1,46 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+/* Callback function for testing */
+const char *test_callback(const char *old_substring)
+{
+    if (strcmp(old_substring, "old") == 0)
+    {
+        return "new";
+    }
+    else
+    {
+        return old_substring;
+    }
+}
+
+int main()
+{
+    char *result;
+
+    // Test case 1: Empty string
+    result = replace_all_with_callback("", "old", test_callback);
+    assert(strcmp(result, "") == 0);
+    free(result);
+
+    // Test case 2: No occurrences of old substring
+    result = replace_all_with_callback("test", "old", test_callback);
+    assert(strcmp(result, "test") == 0);
+    free(result);
+
+    // Test case 3: Single occurrence of old substring
+    result = replace_all_with_callback("old test", "old", test_callback);
+    assert(strcmp(result, "new test") == 0);
+    free(result);
+
+    // Test case 4: Multiple occurrences of old substring
+    result = replace_all_with_callback("old old test old", "old", test_callback);
+    assert(strcmp(result, "new new test new") == 0);
+    free(result);
+
+    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_replace_all_with_lens.c

@@ -0,0 +1,61 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int test_replace_all_with_lens()
+{
+    const char *source = "Hello world! This is a test";
+    const char *find = "is";
+    const char *replace = "was";
+    size_t source_len = strlen(source);
+    size_t find_len = strlen(find);
+    size_t replace_len = strlen(replace);
+
+    int caller_should_use_orig_string_without_modification;
+    size_t num_matches;
+    char *new_text;
+
+    // Test case 1: Replace 'is' with 'was'
+    int result = replace_all_with_lens(source, find, replace, source_len, find_len, replace_len, &caller_should_use_orig_string_without_modification, &num_matches, &new_text);
+    assert(result == 0);
+    assert(caller_should_use_orig_string_without_modification == 0);
+    assert(num_matches == 2);
+    assert(strcmp(new_text, "Hello world! Thwas was a test") == 0);
+    free(new_text);
+
+    // Test case 2: No replacement, should use original string without modification
+    find = "xyz";
+    replace = "abc";
+    find_len = strlen(find);
+    replace_len = strlen(replace);
+
+    result = replace_all_with_lens(source, find, replace, source_len, find_len, replace_len, &caller_should_use_orig_string_without_modification, &num_matches, &new_text);
+    assert(result == SUCCESS);
+    assert(caller_should_use_orig_string_without_modification == 1);
+    assert(num_matches == 0);
+    assert(new_text == NULL);
+
+    // Test case 3: Empty source string
+    source = "";
+    source_len = strlen(source);
+    find = "abc";
+    replace = "def";
+    find_len = strlen(find);
+    replace_len = strlen(replace);
+
+    result = replace_all_with_lens(source, find, replace, source_len, find_len, replace_len, &caller_should_use_orig_string_without_modification, &num_matches, &new_text);
+    assert(result == SUCCESS);
+    assert(caller_should_use_orig_string_without_modification == 1);
+    assert(num_matches == 0);
+    assert(new_text == NULL);
+
+    return 0;
+}
+
+int main()
+{
+    test_replace_all_with_lens();
+    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_replicate.c

@@ -0,0 +1,56 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+// Function to be tested
+void print_ushort_to_stream(const unsigned short value, FILE *stream) { fprintf(stream, "%hu", value); }
+
+// Test cases
+
+void test_print_ushort_to_stream_positive_value()
+{
+    FILE *stream = fopen("test_output.txt", "w");
+    unsigned short test_value = 123;
+    print_ushort_to_stream(test_value, stream);
+    fclose(stream);
+    FILE *file = fopen("test_output.txt", "r");
+    unsigned short result_value;
+    fscanf(file, "%hu", &result_value);
+    fclose(file);
+    assert(result_value == test_value);
+}
+
+void test_print_ushort_to_stream_zero_value()
+{
+    FILE *stream = fopen("test_output.txt", "w");
+    unsigned short test_value = 0;
+    print_ushort_to_stream(test_value, stream);
+    fclose(stream);
+    FILE *file = fopen("test_output.txt", "r");
+    unsigned short result_value;
+    fscanf(file, "%hu", &result_value);
+    fclose(file);
+    assert(result_value == test_value);
+}
+
+void test_print_ushort_to_stream_max_value()
+{
+    FILE *stream = fopen("test_output.txt", "w");
+    unsigned short test_value = USHRT_MAX;
+    print_ushort_to_stream(test_value, stream);
+    fclose(stream);
+    FILE *file = fopen("test_output.txt", "r");
+    unsigned short result_value;
+    fscanf(file, "%hu", &result_value);
+    fclose(file);
+    assert(result_value == test_value);
+}
+
+int main()
+{
+    test_print_ushort_to_stream_positive_value();
+    test_print_ushort_to_stream_zero_value();
+    test_print_ushort_to_stream_max_value();
+    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_reverse_int_array.c

@@ -0,0 +1,58 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+// Define the function prototype
+void reverse_int_array(int *array, size_t size);
+
+// Test cases
+void test_reverse_int_array_empty()
+{
+    int array[] = {};
+    reverse_int_array(array, 0);
+    assert(1); // No assertion to check for empty array
+}
+
+void test_reverse_int_array_single()
+{
+    int array[] = {5};
+    reverse_int_array(array, 1);
+    assert(array[0] == 5);
+}
+
+void test_reverse_int_array_even()
+{
+    int array[] = {1, 2, 3, 4};
+    reverse_int_array(array, 4);
+    assert(array[0] == 4);
+    assert(array[1] == 3);
+    assert(array[2] == 2);
+    assert(array[3] == 1);
+}
+
+void test_reverse_int_array_odd()
+{
+    int array[] = {1, 2, 3, 4, 5};
+    reverse_int_array(array, 5);
+    assert(array[0] == 5);
+    assert(array[1] == 4);
+    assert(array[2] == 3);
+    assert(array[3] == 2);
+    assert(array[4] == 1);
+}
+
+void run_tests()
+{
+    test_reverse_int_array_empty();
+    test_reverse_int_array_single();
+    test_reverse_int_array_even();
+    test_reverse_int_array_odd();
+
+    printf("All tests passed!\n");
+}
+
+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_reverse_string.c

@@ -0,0 +1,58 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <string.h>
+
+char *reverse_string(const char *str)
+{
+    if (str == NULL)
+    {
+        return NULL;
+    }
+
+    size_t len = strlen(str);
+    char *reversed = (char *)malloc((len + 1) * sizeof(char));
+
+    if (reversed == NULL)
+    {
+        return NULL;
+    }
+
+    for (size_t i = 0; i < len; i++)
+    {
+        reversed[i] = str[len - 1 - i];
+    }
+    reversed[len] = '\0';
+
+    return reversed;
+}
+
+int main()
+{
+    char *result;
+
+    // Test case 1: Empty string
+    result = reverse_string("");
+    assert(strcmp(result, "") == 0);
+    free(result);
+
+    // Test case 2: Single character string
+    result = reverse_string("a");
+    assert(strcmp(result, "a") == 0);
+    free(result);
+
+    // Test case 3: String with even length
+    result = reverse_string("hello");
+    assert(strcmp(result, "olleh") == 0);
+    free(result);
+
+    // Test case 4: String with odd length
+    result = reverse_string("world");
+    assert(strcmp(result, "dlrow") == 0);
+    free(result);
+
+    // Test case 5: Null input
+    result = reverse_string(NULL);
+    assert(result == NULL);
+
+    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_reverse_string_in_place.c

@@ -0,0 +1,60 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+void reverse_string_in_place(char *str)
+{
+    if (str == NULL)
+    {
+        return;
+    }
+
+    int len = strlen(str);
+    if (len <= 1)
+    {
+        return;
+    }
+
+    int i = 0;
+    int j = len - 1;
+    while (i < j)
+    {
+        char temp = str[i];
+        str[i] = str[j];
+        str[j] = temp;
+        i++;
+        j--;
+    }
+}
+
+void test_reverse_string()
+{
+    char str1[] = "hello";
+    reverse_string_in_place(str1);
+    assert(strcmp(str1, "olleh") == 0);
+
+    char str2[] = "racecar";
+    reverse_string_in_place(str2);
+    assert(strcmp(str2, "racecar") == 0);
+
+    char str3[] = "a";
+    reverse_string_in_place(str3);
+    assert(strcmp(str3, "a") == 0);
+
+    char str4[] = "1234567890";
+    reverse_string_in_place(str4);
+    assert(strcmp(str4, "0987654321") == 0);
+
+    char str5[] = "";
+    reverse_string_in_place(str5);
+    assert(strcmp(str5, "") == 0);
+}
+
+int main()
+{
+    test_reverse_string();
+    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_reverse_words.c

@@ -0,0 +1,58 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *reverse_words(const char *str);
+
+void test_reverse_words()
+{
+    char *result = reverse_words("hello world");
+    assert(strcmp(result, "world hello") == 0);
+    free(result);
+
+    result = reverse_words("a b c");
+    assert(strcmp(result, "c b a") == 0);
+    free(result);
+
+    result = reverse_words("   a   b    c   ");
+    assert(strcmp(result, "c b a") == 0);
+    free(result);
+
+    result = reverse_words("test");
+    assert(strcmp(result, "test") == 0);
+    free(result);
+
+    result = reverse_words("");
+    assert(strcmp(result, "") == 0);
+    free(result);
+
+    result = reverse_words("one");
+    assert(strcmp(result, "one") == 0);
+    free(result);
+
+    result = reverse_words("one two three");
+    assert(strcmp(result, "three two one") == 0);
+    free(result);
+
+    // Test a very long string
+    char long_str[1000000];
+    for (int i = 0; i < 1000000; i++)
+    {
+        long_str[i] = 'a';
+    }
+    result = reverse_words(long_str);
+    for (int i = 0; i < 1000000; i++)
+    {
+        assert(long_str[999999 - i] == result[i]);
+    }
+    free(result);
+}
+
+int main()
+{
+    test_reverse_words();
+    printf("All tests passed!\n");
+    return 0;
+}