Assume Numeric

Table Of Contents

A numeric assumption/assertion focuses on verifying the correctness of integer and numerical values. This type of assumption checks that numeric values match expected results, whether exact or within a certain range. Numeric assertions are vital for ensuring that calculations, input validations, and data manipulations produce correct and reliable outcomes, particularly in systems where numerical integrity is key.

C, C++ REFERENCE #

/**
 * @brief Assumes that the given 8-bit octal values are equal.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_ITS_EQUAL_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) == (uint8_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 8-bit octal value is less than the expected value.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_ITS_LESS_THAN_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) < (uint8_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 8-bit octal value is more than the expected value.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_ITS_MORE_THAN_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) > (uint8_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 8-bit octal value is less than or equal to the expected value.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) <= (uint8_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit octal value is more than or equal to the expected value.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) >= (uint8_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit octal values are not equal.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_NOT_EQUAL_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) != (uint8_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 8-bit octal value is not less than the expected value.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_NOT_LESS_THAN_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) >= (uint8_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 8-bit octal value is not more than the expected value.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_NOT_MORE_THAN_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) <= (uint8_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 8-bit octal value is not less than or equal to the expected value.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) > (uint8_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit octal value is not more than or equal to the expected value.
 *
 * @param actual The actual 8-bit octal value.
 * @param expected The expected 8-bit octal value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_O8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) < (uint8_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit octal values are equal.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_ITS_EQUAL_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) == (uint16_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 16-bit octal value is less than the expected value.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_ITS_LESS_THAN_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) < (uint16_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 16-bit octal value is more than the expected value.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_ITS_MORE_THAN_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) > (uint16_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 16-bit octal value is less than or equal to the expected value.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) <= (uint16_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit octal value is more than or equal to the expected value.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) >= (uint16_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit octal values are not equal.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_NOT_EQUAL_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) != (uint16_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 16-bit octal value is not less than the expected value.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_NOT_LESS_THAN_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) >= (uint16_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 16-bit octal value is not more than the expected value.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_NOT_MORE_THAN_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) <= (uint16_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 16-bit octal value is not less than or equal to the expected value.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) > (uint16_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit octal value is not more than or equal to the expected value.
 *
 * @param actual The actual 16-bit octal value.
 * @param expected The expected 16-bit octal value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_O16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) < (uint16_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit octal values are equal.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_ITS_EQUAL_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) == (uint32_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 32-bit octal value is less than the expected value.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_ITS_LESS_THAN_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) < (uint32_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 32-bit octal value is more than the expected value.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_ITS_MORE_THAN_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) > (uint32_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 32-bit octal value is less than or equal to the expected value.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) <= (uint32_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit octal value is more than or equal to the expected value.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) >= (uint32_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit octal values are not equal.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_NOT_EQUAL_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) != (uint32_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 32-bit octal value is not less than the expected value.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_NOT_LESS_THAN_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) >= (uint32_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 32-bit octal value is not more than the expected value.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_NOT_MORE_THAN_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) <= (uint32_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 32-bit octal value is not less than or equal to the expected value.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) > (uint32_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit octal value is not more than or equal to the expected value.
 *
 * @param actual The actual 32-bit octal value.
 * @param expected The expected 32-bit octal value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_O32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) < (uint32_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit octal values are equal.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_ITS_EQUAL_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) == (uint64_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 64-bit octal value is less than the expected value.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_ITS_LESS_THAN_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) < (uint64_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 64-bit octal value is more than the expected value.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_ITS_MORE_THAN_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) > (uint64_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 64-bit octal value is less than or equal to the expected value.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) <= (uint64_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit octal value is more than or equal to the expected value.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) >= (uint64_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit octal values are not equal.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_NOT_EQUAL_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) != (uint64_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 64-bit octal value is not less than the expected value.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_NOT_LESS_THAN_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) >= (uint64_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 64-bit octal value is not more than the expected value.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_NOT_MORE_THAN_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) <= (uint64_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 64-bit octal value is not less than or equal to the expected value.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) > (uint64_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit octal value is not more than or equal to the expected value.
 *
 * @param actual The actual 64-bit octal value.
 * @param expected The expected 64-bit octal value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_O64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) < (uint64_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

// Hexadecimal assumtions

/**
 * @brief Assumes that the given 8-bit hexadecimal values are equal.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_ITS_EQUAL_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) == (uint8_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 8-bit hexadecimal value is less than the expected value.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_ITS_LESS_THAN_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) < (uint8_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 8-bit hexadecimal value is more than the expected value.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_ITS_MORE_THAN_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) > (uint8_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 8-bit hexadecimal value is less than or equal to the expected value.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) <= (uint8_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit hexadecimal value is more than or equal to the expected value.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) >= (uint8_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit hexadecimal values are not equal.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_NOT_EQUAL_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) != (uint8_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 8-bit hexadecimal value is not less than the expected value.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_NOT_LESS_THAN_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) >= (uint8_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 8-bit hexadecimal value is not more than the expected value.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_NOT_MORE_THAN_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) <= (uint8_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 8-bit hexadecimal value is not less than or equal to the expected value.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) > (uint8_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit hexadecimal value is not more than or equal to the expected value.
 *
 * @param actual The actual 8-bit hexadecimal value.
 * @param expected The expected 8-bit hexadecimal value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_H8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) < (uint8_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal values are equal.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_ITS_EQUAL_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) == (uint16_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal value is less than the expected value.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_ITS_LESS_THAN_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) < (uint16_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal value is more than the expected value.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_ITS_MORE_THAN_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) > (uint16_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal value is less than or equal to the expected value.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) <= (uint16_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal value is more than or equal to the expected value.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) >= (uint16_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal values are not equal.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_NOT_EQUAL_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) != (uint16_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal value is not less than the expected value.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_NOT_LESS_THAN_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) >= (uint16_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal value is not more than the expected value.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_NOT_MORE_THAN_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) <= (uint16_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal value is not less than or equal to the expected value.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) > (uint16_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit hexadecimal value is not more than or equal to the expected value.
 *
 * @param actual The actual 16-bit hexadecimal value.
 * @param expected The expected 16-bit hexadecimal value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_H16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) < (uint16_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal values are equal.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_ITS_EQUAL_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) == (uint32_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal value is less than the expected value.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_ITS_LESS_THAN_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) < (uint32_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal value is more than the expected value.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_ITS_MORE_THAN_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) > (uint32_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal value is less than or equal to the expected value.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) <= (uint32_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal value is more than or equal to the expected value.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) >= (uint32_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal values are not equal.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_NOT_EQUAL_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) != (uint32_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal value is not less than the expected value.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_NOT_LESS_THAN_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) >= (uint32_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal value is not more than the expected value.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_NOT_MORE_THAN_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) <= (uint32_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal value is not less than or equal to the expected value.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) > (uint32_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit hexadecimal value is not more than or equal to the expected value.
 *
 * @param actual The actual 32-bit hexadecimal value.
 * @param expected The expected 32-bit hexadecimal value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_H32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) < (uint32_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal values are equal.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_ITS_EQUAL_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) == (uint64_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal value is less than the expected value.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_ITS_LESS_THAN_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) < (uint64_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal value is more than the expected value.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_ITS_MORE_THAN_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) > (uint64_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal value is less than or equal to the expected value.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) <= (uint64_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal value is more than or equal to the expected value.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) >= (uint64_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal values are not equal.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_NOT_EQUAL_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) != (uint64_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal value is not less than the expected value.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_NOT_LESS_THAN_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) >= (uint64_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal value is not more than the expected value.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_NOT_MORE_THAN_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) <= (uint64_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal value is not less than or equal to the expected value.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) > (uint64_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit hexadecimal value is not more than or equal to the expected value.
 *
 * @param actual The actual 64-bit hexadecimal value.
 * @param expected The expected 64-bit hexadecimal value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_H64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) < (uint64_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit integer values are equal.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_ITS_EQUAL_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) == (int8_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 8-bit integer value is less than the expected value.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_ITS_LESS_THAN_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) < (int8_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 8-bit integer value is more than the expected value.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_ITS_MORE_THAN_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) > (int8_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 8-bit integer value is less than or equal to the expected value.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) <= (int8_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit integer value is more than or equal to the expected value.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) >= (int8_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit integer values are not equal.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_NOT_EQUAL_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) != (int8_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 8-bit integer value is not less than the expected value.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_NOT_LESS_THAN_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) >= (int8_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 8-bit integer value is not more than the expected value.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_NOT_MORE_THAN_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) <= (int8_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 8-bit integer value is not less than or equal to the expected value.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) > (int8_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit integer value is not more than or equal to the expected value.
 *
 * @param actual The actual 8-bit integer value.
 * @param expected The expected 8-bit integer value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_I8(actual, expected) \
    FOSSIL_TEST_ASSUME((int8_t)(actual) < (int8_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit integer values are equal.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_ITS_EQUAL_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) == (int16_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 16-bit integer value is less than the expected value.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_ITS_LESS_THAN_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) < (int16_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 16-bit integer value is more than the expected value.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_ITS_MORE_THAN_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) > (int16_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 16-bit integer value is less than or equal to the expected value.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) <= (int16_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit integer value is more than or equal to the expected value.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) >= (int16_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit integer values are not equal.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_NOT_EQUAL_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) != (int16_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 16-bit integer value is not less than the expected value.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_NOT_LESS_THAN_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) >= (int16_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 16-bit integer value is not more than the expected value.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_NOT_MORE_THAN_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) <= (int16_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 16-bit integer value is not less than or equal to the expected value.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) > (int16_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit integer value is not more than or equal to the expected value.
 *
 * @param actual The actual 16-bit integer value.
 * @param expected The expected 16-bit integer value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_I16(actual, expected) \
    FOSSIL_TEST_ASSUME((int16_t)(actual) < (int16_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit integer values are equal.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_ITS_EQUAL_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) == (int32_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 32-bit integer value is less than the expected value.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_ITS_LESS_THAN_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) < (int32_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 32-bit integer value is more than the expected value.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_ITS_MORE_THAN_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) > (int32_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 32-bit integer value is less than or equal to the expected value.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) <= (int32_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit integer value is more than or equal to the expected value.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) >= (int32_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit integer values are not equal.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_NOT_EQUAL_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) != (int32_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 32-bit integer value is not less than the expected value.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_NOT_LESS_THAN_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) >= (int32_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 32-bit integer value is not more than the expected value.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_NOT_MORE_THAN_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) <= (int32_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 32-bit integer value is not less than or equal to the expected value.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) > (int32_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit integer value is not more than or equal to the expected value.
 *
 * @param actual The actual 32-bit integer value.
 * @param expected The expected 32-bit integer value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_I32(actual, expected) \
    FOSSIL_TEST_ASSUME((int32_t)(actual) < (int32_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit integer values are equal.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_ITS_EQUAL_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) == (int64_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 64-bit integer value is less than the expected value.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_ITS_LESS_THAN_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) < (int64_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 64-bit integer value is more than the expected value.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_ITS_MORE_THAN_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) > (int64_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 64-bit integer value is less than or equal to the expected value.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) <= (int64_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit integer value is more than or equal to the expected value.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) >= (int64_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit integer values are not equal.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_NOT_EQUAL_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) != (int64_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 64-bit integer value is not less than the expected value.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_NOT_LESS_THAN_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) >= (int64_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 64-bit integer value is not more than the expected value.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_NOT_MORE_THAN_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) <= (int64_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 64-bit integer value is not less than or equal to the expected value.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) > (int64_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit integer value is not more than or equal to the expected value.
 *
 * @param actual The actual 64-bit integer value.
 * @param expected The expected 64-bit integer value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_I64(actual, expected) \
    FOSSIL_TEST_ASSUME((int64_t)(actual) < (int64_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer values are equal.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_ITS_EQUAL_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) == (uint8_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer value is less than the expected value.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_ITS_LESS_THAN_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) < (uint8_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer value is more than the expected value.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_ITS_MORE_THAN_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) > (uint8_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer value is less than or equal to the expected value.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) <= (uint8_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer value is more than or equal to the expected value.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) >= (uint8_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer values are not equal.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_NOT_EQUAL_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) != (uint8_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer value is not less than the expected value.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_NOT_LESS_THAN_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) >= (uint8_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer value is not more than the expected value.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_NOT_MORE_THAN_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) <= (uint8_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer value is not less than or equal to the expected value.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) > (uint8_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 8-bit unsigned integer value is not more than or equal to the expected value.
 *
 * @param actual The actual 8-bit unsigned integer value.
 * @param expected The expected 8-bit unsigned integer value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_U8(actual, expected) \
    FOSSIL_TEST_ASSUME((uint8_t)(actual) < (uint8_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer values are equal.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_ITS_EQUAL_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) == (uint16_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer value is less than the expected value.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_ITS_LESS_THAN_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) < (uint16_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer value is more than the expected value.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_ITS_MORE_THAN_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) > (uint16_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer value is less than or equal to the expected value.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) <= (uint16_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer value is more than or equal to the expected value.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) >= (uint16_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer values are not equal.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_NOT_EQUAL_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) != (uint16_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer value is not less than the expected value.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_NOT_LESS_THAN_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) >= (uint16_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer value is not more than the expected value.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_NOT_MORE_THAN_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) <= (uint16_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer value is not less than or equal to the expected value.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) > (uint16_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 16-bit unsigned integer value is not more than or equal to the expected value.
 *
 * @param actual The actual 16-bit unsigned integer value.
 * @param expected The expected 16-bit unsigned integer value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_U16(actual, expected) \
    FOSSIL_TEST_ASSUME((uint16_t)(actual) < (uint16_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer values are equal.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_ITS_EQUAL_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) == (uint32_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer value is less than the expected value.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_ITS_LESS_THAN_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) < (uint32_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer value is more than the expected value.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_ITS_MORE_THAN_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) > (uint32_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer value is less than or equal to the expected value.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) <= (uint32_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer value is more than or equal to the expected value.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) >= (uint32_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer values are not equal.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_NOT_EQUAL_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) != (uint32_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer value is not less than the expected value.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_NOT_LESS_THAN_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) >= (uint32_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer value is not more than the expected value.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_NOT_MORE_THAN_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) <= (uint32_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer value is not less than or equal to the expected value.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) > (uint32_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 32-bit unsigned integer value is not more than or equal to the expected value.
 *
 * @param actual The actual 32-bit unsigned integer value.
 * @param expected The expected 32-bit unsigned integer value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_U32(actual, expected) \
    FOSSIL_TEST_ASSUME((uint32_t)(actual) < (uint32_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer values are equal.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_ITS_EQUAL_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) == (uint64_t)(expected), "Expected " #actual " to be equal to " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer value is less than the expected value.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_ITS_LESS_THAN_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) < (uint64_t)(expected), "Expected " #actual " to be less than " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer value is more than the expected value.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_ITS_MORE_THAN_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) > (uint64_t)(expected), "Expected " #actual " to be more than " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer value is less than or equal to the expected value.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_ITS_LESS_OR_EQUAL_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) <= (uint64_t)(expected), "Expected " #actual " to be less than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer value is more than or equal to the expected value.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_ITS_MORE_OR_EQUAL_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) >= (uint64_t)(expected), "Expected " #actual " to be more than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer values are not equal.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_NOT_EQUAL_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) != (uint64_t)(expected), "Expected " #actual " to not be equal to " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer value is not less than the expected value.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_NOT_LESS_THAN_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) >= (uint64_t)(expected), "Expected " #actual " to not be less than " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer value is not more than the expected value.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_NOT_MORE_THAN_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) <= (uint64_t)(expected), "Expected " #actual " to not be more than " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer value is not less than or equal to the expected value.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_NOT_LESS_OR_EQUAL_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) > (uint64_t)(expected), "Expected " #actual " to not be less than or equal to " #expected)

/**
 * @brief Assumes that the given 64-bit unsigned integer value is not more than or equal to the expected value.
 *
 * @param actual The actual 64-bit unsigned integer value.
 * @param expected The expected 64-bit unsigned integer value.
 */
#define ASSUME_NOT_MORE_OR_EQUAL_U64(actual, expected) \
    FOSSIL_TEST_ASSUME((uint64_t)(actual) < (uint64_t)(expected), "Expected " #actual " to not be more than or equal to " #expected)

PYTHON REFERENCE #

# TODO: add code here

What are your feelings

Updated on May 12, 2025