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

@@ -0,0 +1,47 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stddef.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_longs(const long *array, const long *array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Arrays are equal
+    long array1[] = {1, 2, 3, 4};
+    long array2[] = {1, 2, 3, 4};
+    assert(equal_array_of_longs(array1, array2, 4) == 1);
+
+    // Test case 2: Arrays are not equal
+    long array3[] = {1, 2, 3, 4};
+    long array4[] = {1, 2, 3, 5};
+    assert(equal_array_of_longs(array3, array4, 4) == 0);
+
+    // Test case 3: Arrays are empty
+    long *array5 = NULL;
+    long *array6 = NULL;
+    assert(equal_array_of_longs(array5, array6, 0) == 1);
+
+    // Test case 4: Arrays have one element and are equal
+    long array7[] = {1000};
+    long array8[] = {1000};
+    assert(equal_array_of_longs(array7, array8, 1) == 1);
+
+    // Test case 5: Arrays have one element and are not equal
+    long array9[] = {1000};
+    long array10[] = {999};
+    assert(equal_array_of_longs(array9, array10, 1) == 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_equal_array_of_short_ptrs.c

@@ -0,0 +1,36 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_short_ptrs(const short **array, const short **array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (*array[i] != *array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+void test_equal_array_of_short_ptrs()
+{
+    const short s1[] = {1, 2, 3};
+    const short s2[] = {1, 2, 3};
+    const short s3[] = {1, 3, 3};
+    const short *p1[] = {s1, s2};
+    const short *p2[] = {s1, s2};
+    const short *p3[] = {s1, s3};
+
+    assert(equal_array_of_short_ptrs(p1, p2, 2) == 1);
+    assert(equal_array_of_short_ptrs(p1, p3, 2) == 0);
+}
+
+int main()
+{
+    test_equal_array_of_short_ptrs();
+    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_equal_array_of_shorts.c

@@ -0,0 +1,52 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+#define TEST_CASES 5
+
+// Function to test
+int equal_array_of_shorts(const short *array, const short *array2, size_t size);
+
+// Test cases
+void test_equal_arrays()
+{
+    short arr1[] = {1, 2, 3, 4, 5};
+    short arr2[] = {1, 2, 3, 4, 5};
+    assert(equal_array_of_shorts(arr1, arr2, 5) == 1);
+}
+
+void test_unequal_arrays()
+{
+    short arr1[] = {1, 2, 3, 4, 5};
+    short arr2[] = {1, 2, 3, 4, 6};
+    assert(equal_array_of_shorts(arr1, arr2, 5) == 0);
+}
+
+void test_empty_arrays()
+{
+    short arr1[] = {};
+    short arr2[] = {};
+    assert(equal_array_of_shorts(arr1, arr2, 0) == 1);
+}
+
+void test_single_element_arrays()
+{
+    short arr1[] = {1};
+    short arr2[] = {2};
+    assert(equal_array_of_shorts(arr1, arr2, 1) == 0);
+}
+
+void test_null_arrays() { assert(equal_array_of_shorts(NULL, NULL, 0) == 1); }
+
+// Run test cases
+int main()
+{
+    test_equal_arrays();
+    test_unequal_arrays();
+    test_empty_arrays();
+    test_single_element_arrays();
+    test_null_arrays();
+
+    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_equal_array_of_size_t_ptrs.c

@@ -0,0 +1,62 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+int equal_array_of_size_t_ptrs(const size_t **array, const size_t **array2, size_t size)
+{
+    if (array == NULL && array2 == NULL)
+    {
+        return 1;
+    }
+    if (array == NULL || array2 == NULL)
+    {
+        return 0;
+    }
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+void test_equal_array_of_size_t_ptrs()
+{
+    // Test case 1: Empty arrays
+    const size_t *empty_array1[] = {NULL};
+    const size_t *empty_array2[] = {NULL};
+    assert(equal_array_of_size_t_ptrs(empty_array1, empty_array2, 0) == 1);
+
+    // Test case 2: Arrays with same single element
+    const size_t value = 42;
+    const size_t *array1[] = {&value};
+    const size_t *array2[] = {&value};
+    assert(equal_array_of_size_t_ptrs(array1, array2, 1) == 1);
+
+    // Test case 3: Arrays with different single elements
+    const size_t different_value = 100;
+    const size_t *array3[] = {&value};
+    const size_t *array4[] = {&different_value};
+    assert(equal_array_of_size_t_ptrs(array3, array4, 1) == 0);
+
+    // Test case 4: Arrays with multiple elements
+    const size_t value1 = 10, value2 = 20, value3 = 30;
+    const size_t *array5[] = {&value1, &value2, &value3};
+    const size_t *array6[] = {&value1, &value2, &value3};
+    assert(equal_array_of_size_t_ptrs(array5, array6, 3) == 1);
+
+    // Test case 5: Arrays with different multiple elements
+    const size_t *array7[] = {&value1, &value2, &value3};
+    const size_t *array8[] = {&value1, &value3, &value2};
+    assert(equal_array_of_size_t_ptrs(array7, array8, 3) == 0);
+}
+
+int main()
+{
+    test_equal_array_of_size_t_ptrs();
+    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_equal_array_of_size_ts.c

@@ -0,0 +1,62 @@
+#include <assert.h>
+
+#include "../foundationallib.h"
+int main()
+{
+    // Test case 1: Arrays are equal
+    {
+        const size_t arr1[] = {1, 2, 3, 4, 5};
+        const size_t arr2[] = {1, 2, 3, 4, 5};
+        size_t size = 5;
+        int result = equal_array_of_size_ts(arr1, arr2, size);
+        assert(result == 1);
+    }
+
+    // Test case 2: Arrays are not equal
+    {
+        const size_t arr1[] = {1, 2, 3};
+        const size_t arr2[] = {1, 2, 4};
+        size_t size = 3;
+        int result = equal_array_of_size_ts(arr1, arr2, size);
+        assert(result == 0);
+    }
+
+    // Test case 3: Empty arrays
+    {
+        const size_t *arr1 = NULL;
+        const size_t *arr2 = NULL;
+        size_t size = 0;
+        int result = equal_array_of_size_ts(arr1, arr2, size);
+        assert(result == 1);
+    }
+
+    // Test case 4: Arrays of different sizes
+    {
+        const size_t arr1[] = {1, 2, 3};
+        const size_t arr2[] = {1, 2};
+        size_t size1 = 3;
+        size_t size2 = 2;
+        int result = equal_array_of_size_ts(arr1, arr2, size1);
+        assert(result == 0);
+    }
+
+    // Test case 5: Large arrays
+    {
+        const size_t size = 10000;
+        size_t *arr1 = (size_t *)malloc(size * sizeof(size_t));
+        size_t *arr2 = (size_t *)malloc(size * sizeof(size_t));
+        for (size_t i = 0; i < size; i++)
+        {
+            arr1[i] = i;
+            arr2[i] = i;
+        }
+        int result = equal_array_of_size_ts(arr1, arr2, size);
+        assert(result == 1);
+        free(arr1);
+        free(arr2);
+    }
+
+    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_equal_array_of_uchar_ptrs.c

@@ -0,0 +1,46 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+
+int equal_array_of_uchar_ptrs(const unsigned char **array, const unsigned char **array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    const unsigned char *arr1[] = {"foo", "bar", "baz"};
+    const unsigned char *arr2[] = {"foo", "bar", "baz"};
+    const unsigned char *arr3[] = {"foo", "bar", "qux"};
+
+    // Test case 1: Arrays are equal
+    assert(equal_array_of_uchar_ptrs(arr1, arr2, 3) == 1);
+
+    // Test case 2: Arrays are not equal
+    assert(equal_array_of_uchar_ptrs(arr1, arr3, 3) == 0);
+
+    // Test case 3: Arrays with different sizes are not equal
+    assert(equal_array_of_uchar_ptrs(arr1, arr2, 2) == 0);
+
+    // Test case 4: Empty arrays are equal
+    assert(equal_array_of_uchar_ptrs(NULL, NULL, 0) == 1);
+
+    // Test case 5: Single-element arrays are equal
+    const unsigned char *arr4[] = {"foo"};
+    const unsigned char *arr5[] = {"foo"};
+    assert(equal_array_of_uchar_ptrs(arr4, arr5, 1) == 1);
+
+    // Test case 6: Single-element arrays are not equal
+    const unsigned char *arr6[] = {"foo"};
+    const unsigned char *arr7[] = {"bar"};
+    assert(equal_array_of_uchar_ptrs(arr6, arr7, 1) == 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_equal_array_of_uchars.c

@@ -0,0 +1,60 @@
+#include "../foundationallib.h"
+
+#define CTEST_MAIN
+#define CTEST_SEGFAULT
+
+#include <assert.h>
+#include <stddef.h>
+
+int equal_array_of_uchars(const unsigned char *array, const unsigned char *array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Arrays are equal
+    unsigned char arr1[] = {1, 2, 3};
+    unsigned char arr2[] = {1, 2, 3};
+    size_t size1 = 3;
+    assert(equal_array_of_uchars(arr1, arr2, size1) == 1);
+
+    // Test case 2: Arrays are not equal
+    unsigned char arr3[] = {1, 2, 3};
+    unsigned char arr4[] = {1, 2, 4};
+    size_t size2 = 3;
+    assert(equal_array_of_uchars(arr3, arr4, size2) == 0);
+
+    // Test case 3: Arrays are of different sizes
+    unsigned char arr5[] = {1, 2, 3};
+    unsigned char arr6[] = {1, 2, 3, 4};
+    size_t size3 = 3;
+    assert(equal_array_of_uchars(arr5, arr6, size3) == 0);
+
+    // Test case 4: Empty arrays
+    unsigned char arr7[] = {};
+    unsigned char arr8[] = {};
+    size_t size4 = 0;
+    assert(equal_array_of_uchars(arr7, arr8, size4) == 1);
+
+    // Test case 5: Large arrays
+    unsigned char arr9[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    unsigned char arr10[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    size_t size5 = 10;
+    assert(equal_array_of_uchars(arr9, arr10, size5) == 1);
+
+    // Test case 6: Large arrays with different elements
+    unsigned char arr11[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    unsigned char arr12[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
+    size_t size6 = 10;
+    assert(equal_array_of_uchars(arr11, arr12, size6) == 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_equal_array_of_uint_ptrs.c

@@ -0,0 +1,37 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+int main()
+{
+    // Test case 1: Empty arrays
+    const unsigned int *empty_array1[] = {};
+    const unsigned int *empty_array2[] = {};
+    assert(equal_array_of_uint_ptrs(empty_array1, empty_array2, 0) == 1);
+
+    // Test case 2: Arrays with one element
+    const unsigned int value1 = 42;
+    const unsigned int value2 = 42;
+    const unsigned int *array1[] = {&value1};
+    const unsigned int *array2[] = {&value2};
+    assert(equal_array_of_uint_ptrs(array1, array2, 1) == 1);
+
+    // Test case 3: Arrays with multiple elements
+    const unsigned int val1 = 10, val2 = 20, val3 = 30;
+    const unsigned int *arr1[] = {&val1, &val2, &val3};
+    const unsigned int *arr2[] = {&val1, &val2, &val3};
+    assert(equal_array_of_uint_ptrs(arr1, arr2, 3) == 1);
+
+    // Test case 4: Arrays with different elements
+    const unsigned int v1 = 100, v2 = 200;
+    const unsigned int *a1[] = {&v1};
+    const unsigned int *a2[] = {&v2};
+    assert(equal_array_of_uint_ptrs(a1, a2, 1) == 0);
+
+    // Test case 5: Arrays with different number of elements
+    assert(equal_array_of_uint_ptrs(arr1, arr2, 2) == 0);
+
+    // All tests passed
+    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_equal_array_of_uints.c

@@ -0,0 +1,36 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_uints(const unsigned int *array, const unsigned int *array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test cases
+    unsigned int arr1[] = {1, 2, 3, 4, 5};
+    unsigned int arr2[] = {1, 2, 3, 4, 5};
+    unsigned int arr3[] = {1, 2, 3, 4, 6};
+
+    // Test case 1: Equal arrays
+    assert(equal_array_of_uints(arr1, arr2, 5) == 1);
+
+    // Test case 2: Non-equal arrays
+    assert(equal_array_of_uints(arr1, arr3, 5) == 0);
+
+    // Test case 3: Empty arrays
+    assert(equal_array_of_uints(NULL, NULL, 0) == 1);
+
+    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_equal_array_of_ulong_long_ptrs.c

@@ -0,0 +1,56 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_ulong_long_ptrs(const unsigned long long **array, const unsigned long long **array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (*array[i] != *array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Identical arrays
+    const unsigned long long arr1[] = {1, 2, 3};
+    const unsigned long long arr2[] = {1, 2, 3};
+
+    const unsigned long long *ptr1[] = {arr1, arr1, arr1};
+    const unsigned long long *ptr2[] = {arr2, arr2, arr2};
+
+    assert(equal_array_of_ulong_long_ptrs(ptr1, ptr2, 3) == 1);
+
+    // Test case 2: Different arrays
+    const unsigned long long arr3[] = {4, 5, 6};
+    const unsigned long long *ptr3[] = {arr1, arr1, arr3};
+
+    assert(equal_array_of_ulong_long_ptrs(ptr1, ptr3, 3) == 0);
+
+    // Test case 3: Empty arrays
+    const unsigned long long *ptr4[] = {NULL, NULL, NULL};
+    const unsigned long long *ptr5[] = {NULL, NULL, NULL};
+
+    assert(equal_array_of_ulong_long_ptrs(ptr4, ptr5, 3) == 1);
+
+    // Test case 4: Arrays with NULL values
+    const unsigned long long arr4[] = {1, 2, 3};
+    const unsigned long long *ptr6[] = {arr4, NULL, arr4};
+    const unsigned long long *ptr7[] = {arr4, NULL, arr4};
+
+    assert(equal_array_of_ulong_long_ptrs(ptr6, ptr7, 3) == 0);
+
+    // Test case 5: Arrays with different sizes
+    const unsigned long long *ptr8[] = {arr1, arr1};
+    const unsigned long long *ptr9[] = {arr2, arr2, arr2};
+
+    assert(equal_array_of_ulong_long_ptrs(ptr8, ptr9, 2) == 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_equal_array_of_ulong_longs.c

@@ -0,0 +1,46 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_ulong_longs(const unsigned long long *array, const unsigned long long *array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test case 1: Arrays are equal
+    unsigned long long arr1[] = {1, 2, 3, 4, 5};
+    unsigned long long arr2[] = {1, 2, 3, 4, 5};
+    size_t size = sizeof(arr1) / sizeof(arr1[0]);
+    assert(equal_array_of_ulong_longs(arr1, arr2, size) == 1);
+
+    // Test case 2: Arrays are not equal
+    unsigned long long arr3[] = {1, 2, 3, 4, 5};
+    unsigned long long arr4[] = {1, 2, 3, 5, 5};
+    size = sizeof(arr3) / sizeof(arr3[0]);
+    assert(equal_array_of_ulong_longs(arr3, arr4, size) == 0);
+
+    // Test case 3: Arrays are empty
+    unsigned long long arr5[] = {};
+    unsigned long long arr6[] = {};
+    size = sizeof(arr5) / sizeof(arr5[0]);
+    assert(equal_array_of_ulong_longs(arr5, arr6, size) == 1);
+
+    // Test case 4: Arrays are of different sizes
+    unsigned long long arr7[] = {1, 2, 3, 4, 5};
+    unsigned long long arr8[] = {1, 2, 3, 4};
+    size_t size1 = sizeof(arr7) / sizeof(arr7[0]);
+    size_t size2 = sizeof(arr8) / sizeof(arr8[0]);
+    assert(equal_array_of_ulong_longs(arr7, arr8, size1) == 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_equal_array_of_ulong_ptrs.c

@@ -0,0 +1,38 @@
+#include "../foundationallib.h"
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_ulong_ptrs(const unsigned long **array, const unsigned long **array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (*array[i] != *array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+void test_equal_array_of_ulong_ptrs()
+{
+    const unsigned long arr1[] = {1, 2, 3, 4, 5};
+    const unsigned long arr2[] = {1, 2, 3, 4, 5};
+    const unsigned long arr3[] = {1, 2, 3, 4, 10};
+    const unsigned long arr4[] = {1, 2, 3, 4};
+    const unsigned long *ptr1 = arr1;
+    const unsigned long *ptr2 = arr2;
+    const unsigned long *ptr3 = arr3;
+    const unsigned long *ptr4 = arr4;
+
+    assert(equal_array_of_ulong_ptrs(&ptr1, &ptr2, 5) == 1);
+    assert(equal_array_of_ulong_ptrs(&ptr1, &ptr3, 5) == 0);
+    assert(equal_array_of_ulong_ptrs(&ptr1, &ptr4, 4) == 1);
+}
+
+int main()
+{
+    test_equal_array_of_ulong_ptrs();
+    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_equal_array_of_ulongs.c

@@ -0,0 +1,37 @@
+#include "../foundationallib.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+FOUNDATIONAL_LIB_FUNC int equal_array_of_ulongs(const unsigned long *array, const unsigned long *array2, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (array[i] != array2[i])
+        {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int main()
+{
+    // Test cases
+    unsigned long arr1[] = {1, 2, 3, 4, 5};
+    unsigned long arr2[] = {1, 2, 3, 4, 5};
+    unsigned long arr3[] = {1, 2, 3, 4, 6};
+    unsigned long arr4[] = {1, 2, 3, 4};
+    unsigned long arr5[] = {1, 2, 3, 4, 5, 6};
+    unsigned long arr6[] = {0, 0, 0, 0, 0};
+
+    // Test cases using assert.h
+    assert(equal_array_of_ulongs(arr1, arr2, 5) == 1); // Identical arrays
+    assert(equal_array_of_ulongs(arr1, arr3, 5) == 0); // Arrays with one different element
+    assert(equal_array_of_ulongs(arr1, arr4, 4) == 1); // Arrays with different size
+    assert(equal_array_of_ulongs(arr1, arr5, 6) == 0); // Arrays with different size
+    assert(equal_array_of_ulongs(arr1, arr6, 5) == 0); // Arrays with all elements as 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_equal_array_of_ushort_ptrs.c

@@ -0,0 +1,30 @@
+#include "../foundationallib.h"
+#include <assert.h>
+
+int main()
+{
+    // Test case 1: Arrays are equal
+    const unsigned short arr1[] = {1, 2, 3, 4};
+    const unsigned short arr2[] = {1, 2, 3, 4};
+    const unsigned short *ptr1[] = {arr1, arr1 + 1, arr1 + 2, arr1 + 3};
+    const unsigned short *ptr2[] = {arr2, arr2 + 1, arr2 + 2, arr2 + 3};
+    assert(equal_array_of_ushort_ptrs(ptr1, ptr2, 4) == 1);
+
+    // Test case 2: Arrays are not equal
+    const unsigned short arr3[] = {1, 2, 3, 4};
+    const unsigned short arr4[] = {4, 3, 2, 1};
+    const unsigned short *ptr3[] = {arr3, arr3 + 1, arr3 + 2, arr3 + 3};
+    const unsigned short *ptr4[] = {arr4, arr4 + 1, arr4 + 2, arr4 + 3};
+    assert(equal_array_of_ushort_ptrs(ptr3, ptr4, 4) == 0);
+
+    // Test case 3: Arrays of different sizes
+    const unsigned short arr5[] = {1, 2, 3};
+    const unsigned short arr6[] = {1, 2, 3, 4};
+    const unsigned short *ptr5[] = {arr5, arr5 + 1, arr5 + 2};
+    const unsigned short *ptr6[] = {arr6, arr6 + 1, arr6 + 2, arr6 + 3};
+    assert(equal_array_of_ushort_ptrs(ptr5, ptr6, 3) == 0);
+
+    // Add more test cases for corner cases here...
+
+    return 0;
+}