support for catching assertion assert()

[nicola-lunghi]

I have this code

int my_module_init(my_module_t *mymodule) {
    assert(mymodule != NULL);
    return 0;
}

how can I create a test that verify that the assertion is triggered?

void test_not_null() {

    UNITY_THROW_ASSERTION(myfunc(0));
}

[Letme]

You can mock header where you have assert defined, then you will require to have an Cmock expect assert_Expect(True). Not exactly Unity solution.

[nicola-lunghi]

I've used something like this

unity_assert_helper.c

#ifndef UNITY_ASSERT_HELPER_H
#define UNITY_ASSERT_HELPER_H

#include <unity.h>
#include <unity_internals.h>
#include <setjmp.h>
#include <string.h>

/**
 * @brief Test that an expression triggers an assertion failure
 *
 * This macro wraps code that should trigger an assert() and verifies
 * that the assertion actually fired.
 *
 * How it works:
 * - TEST_PROTECT() does setjmp and returns true (1st call)
 * - Expression runs and should call assert()
 * - Our __assert_func() calls TEST_ABORT() which does longjmp
 * - TEST_PROTECT() returns false (longjmp return)
 * - If expression completes without asserting, we fail the test
 *
 * Example:
 *   TEST_ASSERTHELPER_ASSERT_FAILS(some_function_with_assert(NULL));
 *
 * @param expression Code that should trigger an assertion
 */
#define TEST_ASSERTHELPER_ASSERT_FAILS(expression)                                                 \
    do {                                                                                           \
        jmp_buf _saved_abort_frame;                                                                \
        int _assert_triggered = 0;                                                                 \
        /* Save Unity's AbortFrame and set up our own */                                          \
        memcpy(&_saved_abort_frame, &Unity.AbortFrame, sizeof(jmp_buf));                          \
        if (setjmp(Unity.AbortFrame) == 0) {                                                       \
            expression;                                                                            \
        } else {                                                                                   \
            _assert_triggered = 1;                                                                 \
        }                                                                                          \
        /* Restore Unity's original AbortFrame */                                                 \
        memcpy(&Unity.AbortFrame, &_saved_abort_frame, sizeof(jmp_buf));                          \
        if (!_assert_triggered) {                                                                  \
            UNITY_TEST_FAIL(__LINE__, "Expected assertion to fail, but it did not");               \
        }                                                                                          \
    } while (0)

/**
 * @brief Test that an expression does NOT trigger an assertion
 *
 * This macro wraps code that should NOT trigger an assert() and verifies
 * that the code completes successfully without asserting.
 *
 * How it works:
 * - TEST_PROTECT() does setjmp and returns true (1st call)
 * - Expression runs and should complete without calling assert()
 * - If expression completes, test passes
 * - If assertion is triggered, TEST_ABORT() does longjmp and test fails
 *
 * Example:
 *   TEST_ASSERTHELPER_ASSERT_PASSES(some_function_with_assert(valid_ptr));
 *
 * @param expression Code that should NOT trigger an assertion
 */
#define TEST_ASSERTHELPER_ASSERT_PASSES(expression)                                                \
    do {                                                                                           \
        jmp_buf _saved_abort_frame;                                                                \
        int _assert_triggered = 0;                                                                 \
        /* Save Unity's AbortFrame and set up our own */                                          \
        memcpy(&_saved_abort_frame, &Unity.AbortFrame, sizeof(jmp_buf));                          \
        if (setjmp(Unity.AbortFrame) == 0) {                                                       \
            expression;                                                                            \
        } else {                                                                                   \
            _assert_triggered = 1;                                                                 \
        }                                                                                          \
        /* Restore Unity's original AbortFrame */                                                 \
        memcpy(&Unity.AbortFrame, &_saved_abort_frame, sizeof(jmp_buf));                          \
        if (_assert_triggered) {                                                                   \
            UNITY_TEST_FAIL(__LINE__, "Unexpected assertion was triggered");                       \
        }                                                                                          \
    } while (0)

#endif /* UNITY_ASSERT_HELPER_H */

unity_assert_helper.h

#ifndef UNITY_ASSERT_HELPER_H
#define UNITY_ASSERT_HELPER_H

#include "unity.h"
#include "unity_internals.h"

/**
 * @brief Test that an expression triggers an assertion failure
 *
 * This macro wraps code that should trigger an assert() and verifies
 * that the assertion actually fired.
 *
 * How it works:
 * - TEST_PROTECT() does setjmp and returns true (1st call)
 * - Expression runs and should call assert()
 * - Our __assert_func() calls TEST_ABORT() which does longjmp
 * - TEST_PROTECT() returns false (longjmp return)
 * - If expression completes without asserting, we fail the test
 *
 * Example:
 *   TEST_ASSERTHELPER_ASSERT_FAILS(some_function_with_assert(NULL));
 *
 * @param expression Code that should trigger an assertion
 */
#define TEST_ASSERTHELPER_ASSERT_FAILS(expression) \
    do { \
        Unity.CurrentTestFailed = 0; \
        if (TEST_PROTECT()) { \
            expression; \
            TEST_FAIL_MESSAGE("Expected assertion to fail, but it did not"); \
        } \
        Unity.CurrentTestFailed = 0; \
    } while (0)

/**
 * @brief Test that an expression does NOT trigger an assertion
 *
 * This macro wraps code that should NOT trigger an assert() and verifies
 * that the code completes successfully without asserting.
 *
 * How it works:
 * - TEST_PROTECT() does setjmp and returns true (1st call)
 * - Expression runs and should complete without calling assert()
 * - If expression completes, test passes
 * - If assertion is triggered, TEST_ABORT() does longjmp and test fails
 *
 * Example:
 *   TEST_ASSERTHELPER_ASSERT_PASSES(some_function_with_assert(valid_ptr));
 *
 * @param expression Code that should NOT trigger an assertion
 */
#define TEST_ASSERTHELPER_ASSERT_PASSES(expression) \
    do { \
        Unity.CurrentTestFailed = 0; \
        if (TEST_PROTECT()) { \
            expression; \
        } else { \
            TEST_FAIL_MESSAGE("Unexpected assertion was triggered"); \
        } \
        Unity.CurrentTestFailed = 0; \
    } while (0)

#endif /* UNITY_ASSERT_HELPER_H */

test_unity_assert.h

#include "unity.h"
#include <assert.h>
#include "unity_assert_helper.h"

// Define to control whether the SimpleMaybeFailingTest should fail or pass
// This is to test that Unity continues running tests after a failure in this test
// leave disabled unless you want to check the case where a test fails and execution continues
// #define ASSERT_CONTINUE_AFTER_FAIL_TEST (0u)
#define ASSERT_CONTINUE_AFTER_FAIL_TEST (1u)

// Helper function that triggers an assertion - used to test assert catching
static void function_that_asserts(int should_fail) {
    assert(should_fail == ASSERT_CONTINUE_AFTER_FAIL_TEST);
}

TEST(AssertHelper, SimpleMaybeFailingTest) {
    // This test should fail - used to verify Unity continues to next test
    TEST_ASSERT_EQUAL(ASSERT_CONTINUE_AFTER_FAIL_TEST, 0);
}
TEST(AssertHelper, VerifyAssertFails) {
    // Test that assertions can be caught with TEST_ASSERTHELPER_ASSERT_FAILS
    // This should pass because function_that_asserts(1) triggers assert(0)
    TEST_ASSERTHELPER_ASSERT_FAILS(function_that_asserts(1));
}
TEST(AssertHelper, VerifyAssertPasses) {
    // Test that functions without assertions pass with TEST_ASSERTHELPER_ASSERT_PASSES
    // This should pass because function_that_asserts(0) does not assert
    TEST_ASSERTHELPER_ASSERT_PASSES(function_that_asserts(0));
}
TEST(AssertHelper, VerifyAssertPassesMultiple) {
    // Test that functions without assertions pass with TEST_ASSERTHELPER_ASSERT_PASSES
    // This should pass because function_that_asserts(0) does not assert
    TEST_ASSERTHELPER_ASSERT_FAILS(function_that_asserts(1));
    TEST_ASSERTHELPER_ASSERT_PASSES(function_that_asserts(0));
}

TEST_GROUP_RUNNER(AssertHelper) {
    RUN_TEST_CASE(AssertHelper, SimpleMaybeFailingTest);
    RUN_TEST_CASE(AssertHelper, VerifyAssertFails);
    RUN_TEST_CASE(AssertHelper, VerifyAssertPasses);
    RUN_TEST_CASE(AssertHelper, VerifyAssertPassesMultiple);
    RUN_TEST_CASE(AssertHelper, SimpleMaybeFailingTest);
}

@Letme maybe it can be integrated in unity?

[Letme]

Propose a pull request. For certain not in an issue.

I am not sure about mapping custom assert to TEST_ABORT, maybe rather UNITY_TEST_FAIL? You also have UNITY_TEST_ASSERT macro which sounds like it is what you want to map your custom __assert_func() to do the assertion.