From 26a71a823aef804a7f4229c57f5703117e8f1531 Mon Sep 17 00:00:00 2001 From: Dominic Masters Date: Tue, 6 Jan 2026 21:23:39 -0600 Subject: [PATCH] Test assert --- src/assert/assert.h | 9 --- test/CMakeLists.txt | 1 + test/assert/CMakeLists.txt | 9 +++ test/assert/test_assert.c | 154 +++++++++++++++++++++++++++++++++++++ 4 files changed, 164 insertions(+), 9 deletions(-) create mode 100644 test/assert/CMakeLists.txt create mode 100644 test/assert/test_assert.c diff --git a/src/assert/assert.h b/src/assert/assert.h index 268b5f5..d6acfa1 100644 --- a/src/assert/assert.h +++ b/src/assert/assert.h @@ -104,15 +104,6 @@ const char *message ); - void assertMemoryRangeMatchesImpl( - const char *file, - const int32_t line, - const void *start, - const void *end, - const size_t size, - const char *message - ); - /** * Asserts a given value to be true. * diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 67fbe2b..2499604 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -3,6 +3,7 @@ # This software is released under the MIT License. # https://opensource.org/licenses/MIT +add_subdirectory(assert) add_subdirectory(display) # add_subdirectory(rpg) add_subdirectory(item) diff --git a/test/assert/CMakeLists.txt b/test/assert/CMakeLists.txt new file mode 100644 index 0000000..1afa80e --- /dev/null +++ b/test/assert/CMakeLists.txt @@ -0,0 +1,9 @@ +# Copyright (c) 2026 Dominic Masters +# +# This software is released under the MIT License. +# https://opensource.org/licenses/MIT + +include(dusktest) + +# Tests +dusktest(test_assert.c) \ No newline at end of file diff --git a/test/assert/test_assert.c b/test/assert/test_assert.c new file mode 100644 index 0000000..0a56a17 --- /dev/null +++ b/test/assert/test_assert.c @@ -0,0 +1,154 @@ +/** + * Copyright (c) 2026 Dominic Masters + * + * This software is released under the MIT License. + * https://opensource.org/licenses/MIT + */ + +#include "dusktest.h" +#include "assert/assert.h" + +static void test_assertTrueImpl(void **state) { + (void)state; + + // Should not assert when true false statement + assertTrueImpl(__FILE__, __LINE__, true, "This should not assert"); + + // Should assert when passing false statement + expect_assert_failure(assertTrueImpl(__FILE__, __LINE__, false, "asserts")); +} + +static void test_assertFalseImpl(void **state) { + (void)state; + + // Should not assert when passing false statement + assertFalseImpl(__FILE__, __LINE__, false, "This should not assert"); + + // Should assert when passing true statement + expect_assert_failure(assertFalseImpl(__FILE__, __LINE__, true, "asserts")); +} + + +static void test_assertUnreachableImpl(void **state) { + (void)state; + + // Should always assert false + expect_assert_failure(assertUnreachableImpl(__FILE__, __LINE__, "asserts")); +} + +static void test_assertNotNullImpl(void **state) { + (void)state; + + int someValue = 42; + + // Should not assert with a valid pointer + assertNotNullImpl(__FILE__, __LINE__, &someValue, "not assert"); + + // Should assert with a NULL pointer + expect_assert_failure(assertNotNullImpl(__FILE__, __LINE__, NULL, "asserts")); +} + +static void test_assertDeprecatedImpl(void **state) { + (void)state; + + // Always asserts when called + expect_assert_failure(assertDeprecatedImpl(__FILE__, __LINE__, "deprecated")); +} + +static void test_assertTrue(void **state) { + (void)state; + + // Should not assert when passing true statement + assertTrue(true, "This should not assert"); + + // Should assert when passing false statement + expect_assert_failure(assertTrue(false, "asserts")); +} + +static void test_assertFalse(void **state) { + (void)state; + + // Should not assert when passing true statement + assertFalse(false, "This should not assert"); + + // Should assert when passing false statement + expect_assert_failure(assertFalse(true, "asserts")); +} + +static void test_assertUnreachable(void **state) { + (void)state; + + // Should always assert false + expect_assert_failure(assertUnreachable("asserts")); +} + +static void test_assertNotNull(void **state) { + (void)state; + + int someValue = 42; + + // Should not assert with a valid pointer + assertNotNull(&someValue, "not assert"); + + // Should assert with a NULL pointer + expect_assert_failure(assertNotNull(NULL, "asserts")); +} + +static void test_assertNull(void **state) { + (void)state; + + int someValue = 42; + + // Should assert with a valid pointer + expect_assert_failure(assertNull(&someValue, "asserts")); + + // Should not assert with a NULL pointer + assertNull(NULL, "not assert"); +} + +static void test_assertDeprecated(void **state) { + (void)state; + + // Always asserts when called + expect_assert_failure(assertDeprecated("deprecated")); +} + +static void test_assertStrLenMax(void **state) { + (void)state; + + // Should not assert when string length is within limit + assertStrLenMax("test", 10, "This should not assert"); + + // Should assert when string length exceeds limit + expect_assert_failure(assertStrLenMax("exceeding", 5, "asserts")); +} + +static void test_assertStrLenMin(void **state) { + (void)state; + + // Should not assert when string length meets minimum + assertStrLenMin("sufficient", 5, "This should not assert"); + + // Should assert when string length is below minimum + expect_assert_failure(assertStrLenMin("tiny", 10, "asserts")); +} + +int main(void) { + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_assertTrueImpl), + cmocka_unit_test(test_assertFalseImpl), + cmocka_unit_test(test_assertUnreachableImpl), + cmocka_unit_test(test_assertNotNullImpl), + cmocka_unit_test(test_assertDeprecatedImpl), + cmocka_unit_test(test_assertTrue), + cmocka_unit_test(test_assertFalse), + cmocka_unit_test(test_assertUnreachable), + cmocka_unit_test(test_assertNotNull), + cmocka_unit_test(test_assertNull), + cmocka_unit_test(test_assertDeprecated), + cmocka_unit_test(test_assertStrLenMax), + cmocka_unit_test(test_assertStrLenMin), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +} \ No newline at end of file