3rd-party/Unity
1
0
Fork 0
mirror of https://github.com/ThrowTheSwitch/Unity.git synced 2026-01-23 00:15:58 +01:00
Code Issues Releases Wiki Activity

Added NOT-EQUAL int variants.

Browse Source 
Organized Unit Tests
This commit is contained in:
mvandervoord
2020-03-16 18:45:40 -04:00
parent bad429428d
commit 71e77ce6fb
17 changed files with 9127 additions and 8261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
docs/UnityAssertionsReference.md
View File

@@ -336,59 +336,18 @@ Asserts the specified bit of the `actual` parameter is low.
These assertions verify that the `actual` parameter is less than or greater
than `threshold` (exclusive). For example, if the threshold value is 0 for the
greater than assertion will fail if it is 0 or less.
##### `TEST_ASSERT_GREATER_THAN (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_INT (threshold, actual)`
greater than assertion will fail if it is 0 or less. There are assertions for
all the various sizes of ints, as for the equality assertions. Some examples:
##### `TEST_ASSERT_GREATER_THAN_INT8 (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_INT16 (threshold, actual)`
##### `TEST_ASSERT_GREATER_OR_EQUAL_INT16 (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_INT32 (threshold, actual)`
##### `TEST_ASSERT_SMALLER_THAN_INT32 (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_UINT (threshold, actual)`
##### `TEST_ASSERT_SMALL_OR_EQUAL_UINT (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_UINT8 (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_UINT16 (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_UINT32 (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_HEX8 (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_HEX16 (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_HEX32 (threshold, actual)`
##### `TEST_ASSERT_GREATER_THAN_CHAR (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_INT (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_INT8 (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_INT16 (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_INT32 (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_UINT (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_UINT8 (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_UINT16 (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_UINT32 (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_HEX8 (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_HEX16 (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_HEX32 (threshold, actual)`
##### `TEST_ASSERT_LESS_THAN_CHAR (threshold, actual)`
##### `TEST_ASSERT_NOT_EQUAL_UINT8 (threshold, actual)`
### Integer Ranges (of all sizes)

8
src/unity.c
View File

@@ -43,6 +43,7 @@ static const char PROGMEM UnityStrWas[] = " Was ";
static const char PROGMEM UnityStrGt[] = " to be greater than ";
static const char PROGMEM UnityStrLt[] = " to be less than ";
static const char PROGMEM UnityStrOrEqual[] = "or equal to ";
static const char PROGMEM UnityStrNotEqual[] = " to be not equal to ";
static const char PROGMEM UnityStrElement[] = " Element ";
static const char PROGMEM UnityStrByte[] = " Byte ";
static const char PROGMEM UnityStrMemory[] = " Memory Mismatch.";
@@ -748,9 +749,10 @@ void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold,
UnityTestResultsFailBegin(lineNumber);
UnityPrint(UnityStrExpected);
UnityPrintNumberByStyle(actual, style);
if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); }
if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); }
if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); }
if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); }
if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); }
if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); }
if (compare == UNITY_NOT_EQUAL) { UnityPrint(UnityStrNotEqual); }
UnityPrintNumberByStyle(threshold, style);
UnityAddMsgIfSpecified(msg);
UNITY_FAIL_AND_BAIL;

37
src/unity.h
View File

@@ -155,6 +155,24 @@ void verifyTest(void);
#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, NULL)
#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, NULL)
/* Integer Not Equal To (of all sizes) */
#define TEST_ASSERT_NOT_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (actual), __LINE__, NULL)
/* Integer Greater Than/ Less Than (of all sizes) */
#define TEST_ASSERT_GREATER_THAN(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL)
#define TEST_ASSERT_GREATER_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL)
@@ -405,6 +423,25 @@ void verifyTest(void);
#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, (message))
#define TEST_ASSERT_EQUAL_CHAR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, (message))
/* Integer Not Equal To (of all sizes) */
#define TEST_ASSERT_NOT_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_NOT_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (actual), __LINE__, (message))
/* Integer Greater Than/ Less Than (of all sizes) */
#define TEST_ASSERT_GREATER_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message))
#define TEST_ASSERT_GREATER_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message))

17
src/unity_internals.h
View File

@@ -421,6 +421,7 @@ typedef enum
UNITY_GREATER_OR_EQUAL = 0x2 + UNITY_EQUAL_TO,
UNITY_SMALLER_THAN = 0x4,
UNITY_SMALLER_OR_EQUAL = 0x4 + UNITY_EQUAL_TO,
UNITY_NOT_EQUAL = 0x0,
UNITY_UNKNOWN
} UNITY_COMPARISON_T;
@@ -778,6 +779,19 @@ int UnityTestMatches(void);
#define UNITY_TEST_ASSERT_EQUAL_CHAR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR)
#define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message) UnityAssertBits((UNITY_INT)(mask), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line))
#define UNITY_TEST_ASSERT_NOT_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
#define UNITY_TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
#define UNITY_TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
#define UNITY_TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
#define UNITY_TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR)
#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
@@ -907,6 +921,9 @@ int UnityTestMatches(void);
#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
#define UNITY_TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)
#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64)
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64)
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64)

9
test/rakefile
View File

@@ -41,6 +41,15 @@ namespace :test do
run_tests unit_test_files
end
namespace :unit do
unit_test_files.each do |f|
desc "test this unit only"
task File.basename(f,'.c').sub('test_unity_','') => [:prepare_for_tests] do
run_tests [f]
end
end
end
desc "Test unity's helper scripts"
task :scripts => [:prepare_for_tests] do
Dir['tests/test_*.rb'].each do |scriptfile|

1
test/rakefile_helper.rb
View File

@@ -264,6 +264,7 @@ module RakefileHelpers
end
end
report "\nRunning Tests in #{test}"
obj_list = []
test_defines = []

132
test/tests/self_assessment_utils.h Normal file
View File

@@ -0,0 +1,132 @@
#ifdef TEST_INSTANCES
#include <string.h>
#include <stdint.h>
/* Dividing by these constants produces +/- infinity.
* The rationale is given in UnityAssertFloatIsInf's body.
*/
#ifndef UNITY_EXCLUDE_FLOAT
static const UNITY_FLOAT f_zero = 0.0f;
#endif
#ifndef UNITY_EXCLUDE_DOUBLE
static const UNITY_DOUBLE d_zero = 0.0;
#endif
/* Macros for Catching An Expected Failure or Ignore */
#define EXPECT_ABORT_BEGIN \
startPutcharSpy(); \
if (TEST_PROTECT()) \
{
#define VERIFY_FAILS_END \
} \
endPutcharSpy(); /* start/end Spy to suppress output of failure message */ \
Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1; \
if (Unity.CurrentTestFailed == 1) { \
SetToOneMeanWeAlreadyCheckedThisGuy = 1; \
UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \
UNITY_OUTPUT_CHAR(':'); \
UnityPrint(Unity.CurrentTestName); \
UnityPrint(":FAIL: [[[[ Test Should Have Failed But Did Not ]]]]"); \
UNITY_OUTPUT_CHAR('\n'); \
}
#define VERIFY_IGNORES_END \
} \
endPutcharSpy(); /* start/end Spy to suppress output of ignore message */ \
Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1; \
Unity.CurrentTestIgnored = 0; \
if (Unity.CurrentTestFailed == 1) { \
SetToOneMeanWeAlreadyCheckedThisGuy = 1; \
UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \
UNITY_OUTPUT_CHAR(':'); \
UnityPrint(Unity.CurrentTestName); \
UnityPrint(":FAIL: [[[[ Test Should Have Ignored But Did Not ]]]]"); \
UNITY_OUTPUT_CHAR('\n'); \
}
int SetToOneToFailInTearDown;
int SetToOneMeanWeAlreadyCheckedThisGuy;
/* Tricky series of macros to set USING_OUTPUT_SPY */
#define USING_SPY_AS(a) EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0)
#define ASSIGN_VALUE(a) VAL_##a
#define VAL_putcharSpy 0, 1
#define EXPAND_AND_USE_2ND(a, b) SECOND_PARAM(a, b, throwaway)
#define SECOND_PARAM(a, b, ...) b
#if USING_SPY_AS(UNITY_OUTPUT_CHAR)
#define USING_OUTPUT_SPY /* true only if UNITY_OUTPUT_CHAR = putcharSpy */
#endif
#ifdef USING_OUTPUT_SPY
#include <stdio.h>
#define SPY_BUFFER_MAX 40
static char putcharSpyBuffer[SPY_BUFFER_MAX];
#endif
static int indexSpyBuffer;
static int putcharSpyEnabled;
void startPutcharSpy(void)
{
indexSpyBuffer = 0;
putcharSpyEnabled = 1;
}
void endPutcharSpy(void)
{
putcharSpyEnabled = 0;
}
char* getBufferPutcharSpy(void)
{
#ifdef USING_OUTPUT_SPY
putcharSpyBuffer[indexSpyBuffer] = '\0';
return putcharSpyBuffer;
#else
return NULL;
#endif
}
void putcharSpy(int c)
{
#ifdef USING_OUTPUT_SPY
if (putcharSpyEnabled)
{
if (indexSpyBuffer < SPY_BUFFER_MAX - 1)
putcharSpyBuffer[indexSpyBuffer++] = (char)c;
} else
putchar((char)c);
#else
(void)c;
#endif
}
/* This is for counting the calls to the flushSpy */
static int flushSpyEnabled;
static int flushSpyCalls = 0;
void startFlushSpy(void)
{
flushSpyCalls = 0;
flushSpyEnabled = 1;
}
void endFlushSpy(void)
{
flushSpyCalls = 0;
flushSpyEnabled = 0;
}
int getFlushSpyCalls(void)
{
return flushSpyCalls;
}
void flushSpy(void)
{
if (flushSpyEnabled){ flushSpyCalls++; }
}
#endif

2871
test/tests/test_unity_arrays.c Normal file
View File

File diff suppressed because it is too large Load Diff

355
test/tests/test_unity_core.c Normal file
View File

@@ -0,0 +1,355 @@
/* ==========================================
Unity Project - A Test Framework for C
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
[Released under MIT License. Please refer to license.txt for details]
========================================== */
#include "unity.h"
#define TEST_INSTANCES
#include "self_assessment_utils.h"
void setUp(void)
{
SetToOneToFailInTearDown = 0;
SetToOneMeanWeAlreadyCheckedThisGuy = 0;
}
void tearDown(void)
{
endPutcharSpy(); /* Stop suppressing test output */
if (SetToOneToFailInTearDown == 1)
{
/* These will be skipped internally if already failed/ignored */
TEST_FAIL_MESSAGE("<= Failed in tearDown");
TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
}
if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
{
UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
UNITY_OUTPUT_CHAR('\n');
}
}
void testUnitySizeInitializationReminder(void)
{
/* This test ensures that sizeof(struct UNITY_STORAGE_T) doesn't change. If this
* test breaks, go look at the initialization of the Unity global variable
* in unity.c and make sure we're filling in the proper fields. */
const char* message = "Unexpected size for UNITY_STORAGE_T struct. Please check that "
"the initialization of the Unity symbol in unity.c is "
"still correct.";
/* Define a structure with all the same fields as `struct UNITY_STORAGE_T`. */
#ifdef UNITY_EXCLUDE_DETAILS
struct {
const char* TestFile;
const char* CurrentTestName;
UNITY_LINE_TYPE CurrentTestLineNumber;
UNITY_COUNTER_TYPE NumberOfTests;
UNITY_COUNTER_TYPE TestFailures;
UNITY_COUNTER_TYPE TestIgnores;
UNITY_COUNTER_TYPE CurrentTestFailed;
UNITY_COUNTER_TYPE CurrentTestIgnored;
#ifdef UNITY_INCLUDE_EXEC_TIME
UNITY_TIME_TYPE CurrentTestStartTime;
UNITY_TIME_TYPE CurrentTestStopTime;
#endif
#ifndef UNITY_EXCLUDE_SETJMP_H
jmp_buf AbortFrame;
#endif
} _Expected_Unity;
#else
struct {
const char* TestFile;
const char* CurrentTestName;
const char* CurrentDetails1;
const char* CurrentDetails2;
UNITY_LINE_TYPE CurrentTestLineNumber;
UNITY_COUNTER_TYPE NumberOfTests;
UNITY_COUNTER_TYPE TestFailures;
UNITY_COUNTER_TYPE TestIgnores;
UNITY_COUNTER_TYPE CurrentTestFailed;
UNITY_COUNTER_TYPE CurrentTestIgnored;
#ifdef UNITY_INCLUDE_EXEC_TIME
UNITY_COUNTER_TYPE CurrentTestStartTime;
UNITY_COUNTER_TYPE CurrentTestStopTime;
#endif
#ifndef UNITY_EXCLUDE_SETJMP_H
jmp_buf AbortFrame;
#endif
} _Expected_Unity;
#endif
/* Compare our fake structure's size to the actual structure's size. They
* should be the same.
*
* This accounts for alignment, padding, and packing issues that might come
* up between different architectures. */
TEST_ASSERT_EQUAL_MESSAGE(sizeof(_Expected_Unity), sizeof(Unity), message);
}
void testPassShouldEndImmediatelyWithPass(void)
{
TEST_PASS();
TEST_FAIL_MESSAGE("We should have passed already and finished this test");
}
void testPassShouldEndImmediatelyWithPassAndMessage(void)
{
TEST_PASS_MESSAGE("Woohoo! This Automatically Passes!");
TEST_FAIL_MESSAGE("We should have passed already and finished this test");
}
void testMessageShouldDisplayMessageWithoutEndingAndGoOnToPass(void)
{
TEST_MESSAGE("This is just a message");
TEST_MESSAGE("This is another message");
TEST_PASS();
}
void testMessageShouldDisplayMessageWithoutEndingAndGoOnToFail(void)
{
TEST_MESSAGE("This is yet another message");
EXPECT_ABORT_BEGIN
TEST_FAIL();
VERIFY_FAILS_END
}
void testTrue(void)
{
TEST_ASSERT(1);
TEST_ASSERT_TRUE(1);
}
void testFalse(void)
{
TEST_ASSERT_FALSE(0);
TEST_ASSERT_UNLESS(0);
}
void testPreviousPass(void)
{
TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures);
}
void testNotVanilla(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT(0);
VERIFY_FAILS_END
}
void testNotTrue(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_TRUE(0);
VERIFY_FAILS_END
}
void testNotFalse(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_FALSE(1);
VERIFY_FAILS_END
}
void testNotUnless(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_UNLESS(1);
VERIFY_FAILS_END
}
void testNotNotEqual(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_NOT_EQUAL(10, 10);
VERIFY_FAILS_END
}
void testFail(void)
{
EXPECT_ABORT_BEGIN
TEST_FAIL_MESSAGE("Expected for testing");
VERIFY_FAILS_END
}
void testIsNull(void)
{
char* ptr1 = NULL;
const char* ptr2 = "hello";
TEST_ASSERT_NULL(ptr1);
TEST_ASSERT_NOT_NULL(ptr2);
}
void testIsNullShouldFailIfNot(void)
{
const char* ptr1 = "hello";
EXPECT_ABORT_BEGIN
TEST_ASSERT_NULL(ptr1);
VERIFY_FAILS_END
}
void testNotNullShouldFailIfNULL(void)
{
char* ptr1 = NULL;
EXPECT_ABORT_BEGIN
TEST_ASSERT_NOT_NULL(ptr1);
VERIFY_FAILS_END
}
void testIsEmpty(void)
{
const char* ptr1 = "\0";
const char* ptr2 = "hello";
TEST_ASSERT_EMPTY(ptr1);
TEST_ASSERT_NOT_EMPTY(ptr2);
}
void testIsEmptyShouldFailIfNot(void)
{
const char* ptr1 = "hello";
EXPECT_ABORT_BEGIN
TEST_ASSERT_EMPTY(ptr1);
VERIFY_FAILS_END
}
void testNotEmptyShouldFailIfEmpty(void)
{
const char* ptr1 = "\0";
EXPECT_ABORT_BEGIN
TEST_ASSERT_NOT_EMPTY(ptr1);
VERIFY_FAILS_END
}
void testIgnore(void)
{
EXPECT_ABORT_BEGIN
TEST_IGNORE();
TEST_FAIL_MESSAGE("This should not be reached");
VERIFY_IGNORES_END
}
void testIgnoreMessage(void)
{
EXPECT_ABORT_BEGIN
TEST_IGNORE_MESSAGE("This is an expected TEST_IGNORE_MESSAGE string!");
TEST_FAIL_MESSAGE("This should not be reached");
VERIFY_IGNORES_END
}
void testProtection(void)
{
volatile int mask = 0;
if (TEST_PROTECT())
{
mask |= 1;
TEST_ABORT();
}
else
{
Unity.CurrentTestFailed = 0;
mask |= 2;
}
TEST_ASSERT_EQUAL(3, mask);
}
void testIgnoredAndThenFailInTearDown(void)
{
SetToOneToFailInTearDown = 1;
TEST_IGNORE();
}
void testFailureCountIncrementsAndIsReturnedAtEnd(void)
{
#ifndef USING_OUTPUT_SPY
TEST_IGNORE();
#else
UNITY_UINT savedFailures = Unity.TestFailures;
Unity.CurrentTestFailed = 1;
startPutcharSpy(); /* Suppress output */
startFlushSpy();
TEST_ASSERT_EQUAL(0, getFlushSpyCalls());
UnityConcludeTest();
endPutcharSpy();
TEST_ASSERT_EQUAL(savedFailures + 1, Unity.TestFailures);
#if defined(UNITY_OUTPUT_FLUSH) && defined(UNITY_OUTPUT_FLUSH_HEADER_DECLARATION)
TEST_ASSERT_EQUAL(1, getFlushSpyCalls());
#else
TEST_ASSERT_EQUAL(0, getFlushSpyCalls());
#endif
endFlushSpy();
startPutcharSpy(); /* Suppress output */
int failures = UnityEnd();
Unity.TestFailures--;
endPutcharSpy();
TEST_ASSERT_EQUAL(savedFailures + 1, failures);
#endif
}
/* ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DETAIL SUPPORT ================== */
void testThatDetailsCanBeHandleOneDetail(void)
{
#ifdef UNITY_EXCLUDE_DETAILS
TEST_IGNORE();
#else
UNITY_SET_DETAIL("Detail1");
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_INT_MESSAGE(5, 6, "Should Fail And Say Detail1");
VERIFY_FAILS_END
#endif
}
void testThatDetailsCanHandleTestFail(void)
{
#ifdef UNITY_EXCLUDE_DETAILS
TEST_IGNORE();
#else
UNITY_SET_DETAILS("Detail1","Detail2");
EXPECT_ABORT_BEGIN
TEST_FAIL_MESSAGE("Should Fail And Say Detail1 and Detail2");
VERIFY_FAILS_END
#endif
}
void testThatDetailsCanBeHandleTwoDetails(void)
{
#ifdef UNITY_EXCLUDE_DETAILS
TEST_IGNORE();
#else
UNITY_SET_DETAILS("Detail1","Detail2");
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_HEX8_MESSAGE(7, 8, "Should Fail And Say Detail1 and Detail2");
VERIFY_FAILS_END
#endif
}
void testThatDetailsCanBeHandleSingleDetailClearingTwoDetails(void)
{
#ifdef UNITY_EXCLUDE_DETAILS
TEST_IGNORE();
#else
UNITY_SET_DETAILS("Detail1","Detail2");
UNITY_SET_DETAIL("DetailNew");
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_MESSAGE("MEH", "GUH", "Should Fail And Say DetailNew");
VERIFY_FAILS_END
#endif
}

770
test/tests/test_unity_doubles.c Normal file
View File

@@ -0,0 +1,770 @@
/* ==========================================
Unity Project - A Test Framework for C
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
[Released under MIT License. Please refer to license.txt for details]
========================================== */
#include "unity.h"
#define TEST_INSTANCES
#include "self_assessment_utils.h"
void setUp(void)
{
SetToOneToFailInTearDown = 0;
SetToOneMeanWeAlreadyCheckedThisGuy = 0;
}
void tearDown(void)
{
endPutcharSpy(); /* Stop suppressing test output */
if (SetToOneToFailInTearDown == 1)
{
/* These will be skipped internally if already failed/ignored */
TEST_FAIL_MESSAGE("<= Failed in tearDown");
TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
}
if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
{
UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
UNITY_OUTPUT_CHAR('\n');
}
}
void testDoublesWithinDelta(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_DOUBLE_WITHIN(0.00003, 187245.03485, 187245.03488);
TEST_ASSERT_DOUBLE_WITHIN(1.0, 187245.0, 187246.0);
TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2549, 9273.2049);
TEST_ASSERT_DOUBLE_WITHIN(0.007, -726.93725, -726.94424);
#endif
}
void testDoublesNotWithinDelta(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2649, 9273.2049);
VERIFY_FAILS_END
#endif
}
void testDoublesEqual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_DOUBLE(187245123456.0, 187245123456.0);
TEST_ASSERT_EQUAL_DOUBLE(187241234567.5, 187241234567.6);
TEST_ASSERT_EQUAL_DOUBLE(9273.2512345649, 9273.25123455699);
TEST_ASSERT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374);
#endif
}
void testDoublesNotEqual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(9273.9649, 9273.0049);
VERIFY_FAILS_END
#endif
}
void testDoublesNotEqualNegative1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(-9273.9649, -9273.0049);
VERIFY_FAILS_END
#endif
}
void testDoublesNotEqualNegative2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(-9273.0049, -9273.9649);
VERIFY_FAILS_END
#endif
}
void testDoublesNotEqualActualNaN(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(85.963, 0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotEqualExpectedNaN(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 85.963);
VERIFY_FAILS_END
#endif
}
void testDoublesEqualBothNaN(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
#endif
}
void testDoublesNotEqualInfNaN(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotEqualNaNInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotEqualActualInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(321.642, 1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotEqualExpectedInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 321.642);
VERIFY_FAILS_END
#endif
}
void testDoublesEqualBothInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
#endif
}
void testDoublesNotEqualPlusMinusInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoubleIsPosInf1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_DOUBLE_IS_INF(2.0 / d_zero);
#endif
}
void testDoubleIsPosInf2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoubleIsNegInf1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_DOUBLE_IS_NEG_INF(-3.0 / d_zero);
#endif
}
void testDoubleIsNegInf2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(-3.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoubleIsNotPosInf1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_INF(2.0);
VERIFY_FAILS_END
#endif
}
void testDoubleIsNotPosInf2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0);
#endif
}
void testDoubleIsNotNegInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_NEG_INF(-999.876);
VERIFY_FAILS_END
#endif
}
void testDoubleIsNan1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero);
#endif
}
void testDoubleIsNan2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_NOT_NAN(0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoubleIsNotNan1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_NAN(234.9);
VERIFY_FAILS_END
#endif
}
void testDoubleIsNotNan2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_DOUBLE_IS_NOT_NAN(234.9);
#endif
}
void testDoubleInfIsNotNan(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_NAN(1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoubleNanIsNotInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_INF(0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoubleIsDeterminate1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_DOUBLE_IS_DETERMINATE(0.0);
TEST_ASSERT_DOUBLE_IS_DETERMINATE(123.3);
TEST_ASSERT_DOUBLE_IS_DETERMINATE(-88.3);
#endif
}
void testDoubleIsDeterminate2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-88.3);
VERIFY_FAILS_END
#endif
}
void testDoubleIsNotDeterminate1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(1.0 / d_zero);
TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-1.0 / d_zero);
TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(0.0 / d_zero);
#endif
}
void testDoubleIsNotDeterminate2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_IS_DETERMINATE(-1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoubleTraitFailsOnInvalidTrait(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
UnityAssertDoubleSpecial(1.0, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT);
VERIFY_FAILS_END
#endif
}
void testEqualDoubleArrays(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0, -8.0, 25.4, -0.123};
double p1[] = {1.0, -8.0, 25.4, -0.123};
double p2[] = {1.0, -8.0, 25.4, -0.2};
double p3[] = {1.0, -23.0, 25.0, -0.26};
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 1);
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 4);
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p2, 3);
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p3, 1);
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(NULL, NULL, 1);
#endif
}
void testNotEqualDoubleArraysExpectedNull(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double* p0 = NULL;
double p1[] = {1.0, 8.0, 25.4, 0.252};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleArraysActualNull(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0, 8.0, 25.4, 0.253};
double* p1 = NULL;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleArrays1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0, 8.0, 25.4, 0.25666666667};
double p1[] = {1.0, 8.0, 25.4, 0.25666666666};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleArrays2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0, 8.0, 25.4, 0.253};
double p1[] = {2.0, 8.0, 25.4, 0.253};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleArrays3(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0, 8.0, 25.4, 0.253};
double p1[] = {1.0, 8.0, 25.5, 0.253};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleArraysNegative1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {-1.0, -8.0, -25.4, -0.2566666667};
double p1[] = {-1.0, -8.0, -25.4, -0.2566666666};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleArraysNegative2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {-1.0, -8.0, -25.4, -0.253};
double p1[] = {-2.0, -8.0, -25.4, -0.253};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleArraysNegative3(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {-1.0, -8.0, -25.4, -0.253};
double p1[] = {-1.0, -8.0, -25.5, -0.253};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testEqualDoubleArraysNaN(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0, 0.0 / d_zero, 25.4, 0.253};
double p1[] = {1.0, 0.0 / d_zero, 25.4, 0.253};
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
#endif
}
void testEqualDoubleArraysInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0, 1.0 / d_zero, 25.4, 0.253};
double p1[] = {1.0, 1.0 / d_zero, 25.4, 0.253};
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
#endif
}
void testNotEqualDoubleArraysLengthZero(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[1] = {0.0};
double p1[1] = {0.0};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 0);
VERIFY_FAILS_END
#endif
}
void testEqualDoubleEachEqual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0, 1.0, 1.0, 1.0};
double p1[] = {-0.123, -0.123, -0.123, -0.123};
double p2[] = {25.4, 25.4, 25.4, -0.2};
double p3[] = {1.0, -23.0, 25.0, -0.26};
TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 1);
TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4);
TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.123, p1, 4);
TEST_ASSERT_EACH_EQUAL_DOUBLE(25.4, p2, 3);
TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p3, 1);
#endif
}
void testNotEqualDoubleEachEqualActualNull(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double* p0 = NULL;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_DOUBLE(5, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleEachEqual1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {0.253, 8.0, 0.253, 0.253};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_DOUBLE(0.253, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleEachEqual2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {8.0, 8.0, 8.0, 0.253};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_DOUBLE(8.0, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleEachEqual3(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0, 1.0, 1.0, 0.253};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleEachEqualNegative1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {-1.0, -0.253, -0.253, -0.253};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.253, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleEachEqualNegative2(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {-25.4, -8.0, -25.4, -25.4};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_DOUBLE(-25.4, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualDoubleEachEqualNegative3(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {-8.0, -8.0, -8.0, -0.253};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_DOUBLE(-8.0, p0, 4);
VERIFY_FAILS_END
#endif
}
void testEqualDoubleEachEqualNaN(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero};
TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0 / d_zero, p0, 4);
#endif
}
void testEqualDoubleEachEqualInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[] = {1.0 / d_zero, 1.0 / d_zero, 25.4, 0.253};
TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0 / d_zero, p0, 2);
#endif
}
void testNotEqualDoubleEachEqualLengthZero(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
double p0[1] = {0.0};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0, p0, 0);
VERIFY_FAILS_END
#endif
}
void testDoublePrinting(void)
{
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499);
TEST_ASSERT_EQUAL_PRINT_FLOATING("5.0000005e-07", 0.00000050000005);
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469499", 0.100469499);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 0.9999999995); /*Rounding to int place*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25);
TEST_ASSERT_EQUAL_PRINT_FLOATING("7.99999999", 7.99999999); /*Not rounding*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000002", 16.0000002);
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000004", 16.0000004);
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000006", 16.0000006);
TEST_ASSERT_EQUAL_PRINT_FLOATING("999999999", 999999999.0); /*Last full print integer*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("0", -0.0); /* -0 no supported on all targets */
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.0000005e-07", -0.00000050000005);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469499", -0.100469499);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -0.9999999995); /*Rounding to int place*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.99999999", -7.99999999); /*Not rounding*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000002", -16.0000002);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000004", -16.0000004);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000006", -16.0000006);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-999999999", -999999999.0); /*Last full print integer*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.10046949999999999);
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967295.9);
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 9999999995.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199254740990.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("7e+100", 7.0e+100);
TEST_ASSERT_EQUAL_PRINT_FLOATING("3e+200", 3.0e+200);
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23456789e+300", 9.23456789e+300);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.10046949999999999);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967295.9);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967296.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7e+100", -7.0e+100);
#endif
}
void testDoublePrintingRoundTiesToEven(void)
{
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE();
#else
#ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00000001e+10", 10000000050.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199245000000.0);
#else /* Default to Round ties to even */
TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000050.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15", 9007199245000000.0);
#endif
#endif
}
void testDoublePrintingInfinityAndNaN(void)
{
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0 / d_zero);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0 / d_zero);
TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0 / d_zero);
#endif
}

886
test/tests/test_unity_floats.c Normal file
View File

@@ -0,0 +1,886 @@
/* ==========================================
Unity Project - A Test Framework for C
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
[Released under MIT License. Please refer to license.txt for details]
========================================== */
#include "unity.h"
#define TEST_INSTANCES
#include "self_assessment_utils.h"
void setUp(void)
{
SetToOneToFailInTearDown = 0;
SetToOneMeanWeAlreadyCheckedThisGuy = 0;
}
void tearDown(void)
{
endPutcharSpy(); /* Stop suppressing test output */
if (SetToOneToFailInTearDown == 1)
{
/* These will be skipped internally if already failed/ignored */
TEST_FAIL_MESSAGE("<= Failed in tearDown");
TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
}
if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
{
UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
UNITY_OUTPUT_CHAR('\n');
}
}
void testFloatsWithinDelta(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f);
TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f);
TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f);
#endif
}
void testFloatsNotWithinDelta(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f);
VERIFY_FAILS_END
#endif
}
void testFloatsEqual(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f);
TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f);
TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f);
TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f);
#endif
}
void testFloatsNotEqual(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f);
VERIFY_FAILS_END
#endif
}
void testFloatsNotEqualNegative1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f);
VERIFY_FAILS_END
#endif
}
void testFloatsNotEqualNegative2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f);
VERIFY_FAILS_END
#endif
}
void testFloatsNotEqualActualNaN(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(85.963f, 0.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatsNotEqualExpectedNaN(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 85.963f);
VERIFY_FAILS_END
#endif
}
void testFloatsEqualBothNaN(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero);
#endif
}
void testFloatsNotEqualInfNaN(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatsNotEqualNaNInf(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatsNotEqualActualInf(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(321.642f, 1.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatsNotEqualExpectedInf(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 321.642f);
VERIFY_FAILS_END
#endif
}
void testFloatsEqualBothInf(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero);
#endif
}
void testFloatsNotEqualPlusMinusInf(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatIsPosInf1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_FLOAT_IS_INF(2.0f / f_zero);
#endif
}
void testFloatIsPosInf2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatIsNegInf1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_FLOAT_IS_NEG_INF(-3.0f / f_zero);
#endif
}
void testFloatIsNegInf2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(-3.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatIsNotPosInf1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_INF(2.0f);
VERIFY_FAILS_END
#endif
}
void testFloatIsNotPosInf2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f);
#endif
}
void testFloatIsNotNegInf(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_NEG_INF(-999.876f);
VERIFY_FAILS_END
#endif
}
void testFloatIsNan1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero);
#endif
}
void testFloatIsNan2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_NOT_NAN(0.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatIsNotNan1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_NAN(234.9f);
VERIFY_FAILS_END
#endif
}
void testFloatIsNotNan2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_FLOAT_IS_NOT_NAN(234.9f);
#endif
}
void testFloatInfIsNotNan(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_NAN(1.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatNanIsNotInf(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_INF(0.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatIsDeterminate1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_FLOAT_IS_DETERMINATE(0.0f);
TEST_ASSERT_FLOAT_IS_DETERMINATE(123.3f);
TEST_ASSERT_FLOAT_IS_DETERMINATE(-88.3f);
#endif
}
void testFloatIsDeterminate2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-88.3f);
VERIFY_FAILS_END
#endif
}
void testFloatIsNotDeterminate1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(1.0f / f_zero);
TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-1.0f / f_zero);
TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(0.0f / f_zero);
#endif
}
void testFloatIsNotDeterminate2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_IS_DETERMINATE(-1.0f / f_zero);
VERIFY_FAILS_END
#endif
}
void testFloatTraitFailsOnInvalidTrait(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
UnityAssertFloatSpecial(1.0f, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT);
VERIFY_FAILS_END
#endif
}
void testEqualFloatArrays(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f, -8.0f, 25.4f, -0.123f};
float p1[] = {1.0f, -8.0f, 25.4f, -0.123f};
float p2[] = {1.0f, -8.0f, 25.4f, -0.2f};
float p3[] = {1.0f, -23.0f, 25.0f, -0.26f};
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 1);
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 4);
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3);
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1);
TEST_ASSERT_EQUAL_FLOAT_ARRAY(NULL, NULL, 1);
#endif
}
void testNotEqualFloatArraysExpectedNull(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float* p0 = NULL;
float p1[] = {1.0f, 8.0f, 25.4f, 0.252f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatArraysActualNull(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
float* p1 = NULL;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatArrays1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
float p1[] = {1.0f, 8.0f, 25.4f, 0.252f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatArrays2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
float p1[] = {2.0f, 8.0f, 25.4f, 0.253f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatArrays3(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
float p1[] = {1.0f, 8.0f, 25.5f, 0.253f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatArraysNegative1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
float p1[] = {-1.0f, -8.0f, -25.4f, -0.252f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatArraysNegative2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
float p1[] = {-2.0f, -8.0f, -25.4f, -0.253f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatArraysNegative3(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
float p1[] = {-1.0f, -8.0f, -25.5f, -0.253f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
#endif
}
void testEqualFloatArraysNaN(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f};
float p1[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f};
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
#endif
}
void testEqualFloatArraysInf(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f};
float p1[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f};
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
#endif
}
void testNotEqualFloatArraysLengthZero(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[1] = {0.0f};
float p1[1] = {0.0f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0);
VERIFY_FAILS_END
#endif
}
void testEqualFloatEachEqual(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f, 1.0f, 1.0f, 1.0f};
float p1[] = {-0.123f, -0.123f, -0.123f, -0.123f};
float p2[] = {25.4f, 25.4f, 25.4f, -0.2f};
float p3[] = {1.0f, -23.0f, 25.0f, -0.26f};
TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 1);
TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4);
TEST_ASSERT_EACH_EQUAL_FLOAT(-0.123f, p1, 4);
TEST_ASSERT_EACH_EQUAL_FLOAT(25.4f, p2, 3);
TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p3, 1);
#endif
}
void testNotEqualFloatEachEqualActualNull(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float* p0 = NULL;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_FLOAT(5, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatEachEqual1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {0.253f, 8.0f, 0.253f, 0.253f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_FLOAT(0.253f, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatEachEqual2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {8.0f, 8.0f, 8.0f, 0.253f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_FLOAT(8.0f, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatEachEqual3(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f, 1.0f, 1.0f, 0.253f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatEachEqualNegative1(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {-1.0f, -0.253f, -0.253f, -0.253f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_FLOAT(-0.253f, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatEachEqualNegative2(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {-25.4f, -8.0f, -25.4f, -25.4f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_FLOAT(-25.4f, p0, 4);
VERIFY_FAILS_END
#endif
}
void testNotEqualFloatEachEqualNegative3(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {-8.0f, -8.0f, -8.0f, -0.253f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_FLOAT(-8.0f, p0, 4);
VERIFY_FAILS_END
#endif
}
void testEqualFloatEachEqualNaN(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero};
TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f / f_zero, p0, 4);
#endif
}
void testEqualFloatEachEqualInf(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[] = {1.0f / f_zero, 1.0f / f_zero, 25.4f, 0.253f};
TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f / f_zero, p0, 2);
#endif
}
void testNotEqualFloatEachEqualLengthZero(void)
{
#ifdef UNITY_EXCLUDE_FLOAT
TEST_IGNORE();
#else
float p0[1] = {0.0f};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f, p0, 0);
VERIFY_FAILS_END
#endif
}
#define TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, actual) { \
startPutcharSpy(); UnityPrintFloat((actual)); endPutcharSpy(); \
TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \
}
void testFloatPrinting(void)
{
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.100469499f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("2", 1.9999995f); /*Rounding to int place*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("7.999999", 7.999999f); /*Not rounding*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00002", 16.00002f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00004", 16.00004f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00006", 16.00006f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("9999999", 9999999.0f); /*Last full print integer*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0", -0.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.100469499f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-2", -1.9999995f); /*Rounding to int place*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.999999", -7.999999f); /*Not rounding*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00002", -16.00002f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00004", -16.00004f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00006", -16.00006f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-9999999", -9999999.0f); /*Last full print integer*/
/* Fails, prints "4.294968e+09" due to FP math imprecision
* TEST_ASSERT_EQUAL_PRINT_FLOATING("4.294967e+09", 4294967296.0f); */
TEST_ASSERT_EQUAL_PRINT_FLOATING("5e+09", 5000000000.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("8e+09", 8.0e+09f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("8.309999e+09", 8309999104.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 1.0e+10f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000000.0f);
/* Some compilers have trouble with inexact float constants, a float cast works generally */
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.000055e+10", (float)1.000055e+10f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.1e+38", (float)1.10000005e+38f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.635299e+10", 1.63529943e+10f);
/* Fails, prints "3.402824e+38" due to FP math imprecision
* TEST_ASSERT_EQUAL_PRINT_FLOATING("3.402823e+38", 3.40282346638e38f); */
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1e+10", -1.0e+10f);
/* Fails, prints "-3.402824e+38" due to FP math imprecision
* TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.402823e+38", -3.40282346638e38f); */
#endif
}
void testFloatPrintingRoundTiesToEven(void)
{
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE();
#else
#ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882813", 0.00048828125f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.3", 488281.25f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("5.000001e-07", 0.00000050000005f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.000001e-07", -0.00000050000005f);
#else /* Default to Round ties to even */
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882812", 0.00048828125f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.2", 488281.25f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("5e-07", 0.00000050000005f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-5e-07", -0.00000050000005f);
#endif
#endif
}
void testFloatPrintingInfinityAndNaN(void)
{
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0f / f_zero);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0f / f_zero);
TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0f / f_zero);
#endif
}
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
#ifdef UNITY_INCLUDE_DOUBLE
static void printFloatValue(float f)
{
char expected[18];
startPutcharSpy();
UnityPrintFloat(f);
sprintf(expected, "%.9g", f);
/* We print all NaN's as "nan", not "-nan" */
if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan");
if (strcmp(expected, getBufferPutcharSpy()))
{
/* Fail with diagnostic printing */
TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f);
}
}
#else
static void printFloatValue(float f)
{
char expected[18];
char expected_lower[18];
char expected_lower2[18];
char expected_lower3[18];
char expected_higher[18];
char expected_higher2[18];
char expected_higher3[18];
startPutcharSpy();
UnityPrintFloat(f);
sprintf(expected, "%.7g", f);
/* We print all NaN's as "nan", not "-nan" */
if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan");
strcpy(expected_lower, expected);
strcpy(expected_lower2, expected);
strcpy(expected_lower3, expected);
strcpy(expected_higher, expected);
strcpy(expected_higher2, expected);
strcpy(expected_higher3, expected);
/* Allow for rounding differences in the last digit */
double lower = (double)f * 0.99999995;
double higher = (double)f * 1.00000005;
if(isfinite(lower)) sprintf(expected_lower, "%.7g", lower);
if(isfinite(higher)) sprintf(expected_higher, "%.7g", higher);
/* Outside [1,10000000] allow for relative error of +/-2.5e-7 */
if (f < 1.0 || f > 10000000)
{
double lower2 = (double)f * 0.99999985;
double lower3 = (double)f * 0.99999975;
double higher2 = (double)f * 1.00000015;
double higher3 = (double)f * 1.00000025;
if (isfinite(lower2)) sprintf(expected_lower2, "%.7g", lower2);
if (isfinite(lower3)) sprintf(expected_lower3, "%.7g", lower3);
if (isfinite(higher2)) sprintf(expected_higher2, "%.7g", higher2);
if (isfinite(higher3)) sprintf(expected_higher3, "%.7g", higher3);
}
if (strcmp(expected, getBufferPutcharSpy()) != 0 &&
strcmp(expected_lower, getBufferPutcharSpy()) != 0 &&
strcmp(expected_lower2, getBufferPutcharSpy()) != 0 &&
strcmp(expected_lower3, getBufferPutcharSpy()) != 0 &&
strcmp(expected_higher, getBufferPutcharSpy()) != 0 &&
strcmp(expected_higher2, getBufferPutcharSpy()) != 0 &&
strcmp(expected_higher3, getBufferPutcharSpy()) != 0)
{
/* Fail with diagnostic printing */
TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f);
}
}
#endif
#endif
void testFloatPrintingRandomSamples(void)
{
#if !defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE();
#else
union { float f_value; uint32_t int_value; } u;
/* These values are not covered by the MINSTD generator */
u.int_value = 0x00000000; printFloatValue(u.f_value);
u.int_value = 0x80000000; printFloatValue(u.f_value);
u.int_value = 0x7fffffff; printFloatValue(u.f_value);
u.int_value = 0xffffffff; printFloatValue(u.f_value);
uint32_t a = 1;
for(int num_tested = 0; num_tested < 1000000; num_tested++)
{
/* MINSTD pseudo-random number generator */
a = (uint32_t)(((uint64_t)a * 48271u) % 2147483647u);
/* MINSTD does not set the highest bit; test both possibilities */
u.int_value = a; printFloatValue(u.f_value);
u.int_value = a | 0x80000000; printFloatValue(u.f_value);
}
#endif
}

2854
test/tests/test_unity_integers.c Normal file
View File

File diff suppressed because it is too large Load Diff

770
test/tests/test_unity_integers_64.c Normal file
View File

@@ -0,0 +1,770 @@
/* ==========================================
Unity Project - A Test Framework for C
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
[Released under MIT License. Please refer to license.txt for details]
========================================== */
#include "unity.h"
#define TEST_INSTANCES
#include "self_assessment_utils.h"
void setUp(void)
{
SetToOneToFailInTearDown = 0;
SetToOneMeanWeAlreadyCheckedThisGuy = 0;
}
void tearDown(void)
{
endPutcharSpy(); /* Stop suppressing test output */
if (SetToOneToFailInTearDown == 1)
{
/* These will be skipped internally if already failed/ignored */
TEST_FAIL_MESSAGE("<= Failed in tearDown");
TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
}
if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
{
UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
UNITY_OUTPUT_CHAR('\n');
}
}
void testInt64ArrayWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005};
UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
TEST_ASSERT_INT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3);
TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3);
#endif
}
void testInt64ArrayWithinDeltaAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005};
UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message.");
TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message.");
#endif
}
void tesUInt64ArrayNotWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3);
VERIFY_FAILS_END
#endif
}
void testInt64ArrayNotWithinDeltaAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testInt64ArrayWithinDeltaPointless(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0);
VERIFY_FAILS_END
#endif
}
void testInt64ArrayWithinDeltaPointlessAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testInt64ArrayWithinDeltaExpectedNull(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_INT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3);
VERIFY_FAILS_END
#endif
}
void testInt64ArrayWithinDeltaExpectedNullAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testInt64ArrayWithinDeltaActualNull(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
EXPECT_ABORT_BEGIN
TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, NULL, 3);
VERIFY_FAILS_END
#endif
}
void testInt64ArrayWithinDeltaActualNullAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
EXPECT_ABORT_BEGIN
TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testInt64ArrayWithinDeltaSamePointer(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3);
#endif
}
void testInt64ArrayWithinDeltaSamePointerAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 expected[] = {12345000, -12344995, 12345005};
TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message.");
#endif
}
void testUInt64ArrayWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005};
UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3);
TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3);
#endif
}
void testUInt64ArrayWithinDeltaAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005};
UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message.");
TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message.");
#endif
}
void testUInt64ArrayNotWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3);
VERIFY_FAILS_END
#endif
}
void testUInt64ArrayNotWithinDeltaAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testUInt64ArrayWithinDeltaPointless(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0);
VERIFY_FAILS_END
#endif
}
void testUInt64ArrayWithinDeltaPointlessAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testUInt64ArrayWithinDeltaExpectedNull(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3);
VERIFY_FAILS_END
#endif
}
void testUInt64ArrayWithinDeltaExpectedNullAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055};
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testUInt64ArrayWithinDeltaActualNull(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, NULL, 3);
VERIFY_FAILS_END
#endif
}
void testUInt64ArrayWithinDeltaActualNullAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testUInt64ArrayWithinDeltaSamePointer(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3);
#endif
}
void testUInt64ArrayWithinDeltaSamePointerAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {12345000, 12344995, 12345005};
TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message.");
#endif
}
void testHEX64ArrayWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000};
UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualSmallDelta, 3);
TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 3);
#endif
}
void testHEX64ArrayWithinDeltaAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000};
UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualSmallDelta, 3, "Custom Message.");
TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 3, "Custom Message.");
#endif
}
void testHEX64ArrayNotWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualBigDelta, 3);
VERIFY_FAILS_END
#endif
}
void testHEX64ArrayNotWithinDeltaAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualBigDelta, 3, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testHEX64ArrayWithinDeltaPointless(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 0);
VERIFY_FAILS_END
#endif
}
void testHEX64ArrayWithinDeltaPointlessAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 0, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testHEX64ArrayWithinDeltaExpectedNull(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, NULL, actualBigDelta, 3);
VERIFY_FAILS_END
#endif
}
void testHEX64ArrayWithinDeltaExpectedNullAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000};
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, NULL, actualBigDelta, 3, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testHEX64ArrayWithinDeltaActualNull(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, NULL, 3);
VERIFY_FAILS_END
#endif
}
void testHEX64ArrayWithinDeltaActualNullAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, NULL, 3, "Custom Message.");
VERIFY_FAILS_END
#endif
}
void testHEX64ArrayWithinDeltaSamePointer(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, expected, 3);
#endif
}
void testHEX64ArrayWithinDeltaSamePointerAndMessage(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000};
TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, expected, 3, "Custom Message.");
#endif
}
void testEqualHex64s(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 v0, v1;
UNITY_UINT64 *p0, *p1;
v0 = 0x9876543201234567;
v1 = 0x9876543201234567;
p0 = &v0;
p1 = &v1;
TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, 0x9876543201234567);
TEST_ASSERT_EQUAL_HEX64(v0, v1);
TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, v1);
TEST_ASSERT_EQUAL_HEX64(v0, 0x9876543201234567);
TEST_ASSERT_EQUAL_HEX64(*p0, v1);
TEST_ASSERT_EQUAL_HEX64(*p0, *p1);
TEST_ASSERT_EQUAL_HEX64(*p0, 0x9876543201234567);
#endif
}
void testEqualUint64s(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 v0, v1;
UNITY_UINT64 *p0, *p1;
v0 = 0x9876543201234567;
v1 = 0x9876543201234567;
p0 = &v0;
p1 = &v1;
TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, 0x9876543201234567);
TEST_ASSERT_EQUAL_UINT64(v0, v1);
TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, v1);
TEST_ASSERT_EQUAL_UINT64(v0, 0x9876543201234567);
TEST_ASSERT_EQUAL_UINT64(*p0, v1);
TEST_ASSERT_EQUAL_UINT64(*p0, *p1);
TEST_ASSERT_EQUAL_UINT64(*p0, 0x9876543201234567);
#endif
}
void testEqualInt64s(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 v0, v1;
UNITY_INT64 *p0, *p1;
v0 = (UNITY_INT64)0x9876543201234567;
v1 = (UNITY_INT64)0x9876543201234567;
p0 = &v0;
p1 = &v1;
TEST_ASSERT_EQUAL_INT64(0x9876543201234567, 0x9876543201234567);
TEST_ASSERT_EQUAL_INT64(v0, v1);
TEST_ASSERT_EQUAL_INT64(0x9876543201234567, v1);
TEST_ASSERT_EQUAL_INT64(v0, 0x9876543201234567);
TEST_ASSERT_EQUAL_INT64(*p0, v1);
TEST_ASSERT_EQUAL_INT64(*p0, *p1);
TEST_ASSERT_EQUAL_INT64(*p0, 0x9876543201234567);
#endif
}
void testNotEqualHex64s(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 v0, v1;
v0 = 9000000000;
v1 = 9100000000;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_HEX64(v0, v1);
VERIFY_FAILS_END
#endif
}
void testNotEqualUint64s(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_UINT64 v0, v1;
v0 = 9000000000;
v1 = 9100000000;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_UINT64(v0, v1);
VERIFY_FAILS_END
#endif
}
void testNotEqualInt64s(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 v0, v1;
v0 = -9000000000;
v1 = 9100000000;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_INT64(v0, v1);
VERIFY_FAILS_END
#endif
}
void testNotEqualHex64sIfSigned(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
UNITY_INT64 v0, v1;
v0 = -9000000000;
v1 = 9000000000;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_HEX64(v0, v1);
VERIFY_FAILS_END
#endif
}
void testHEX64sWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
TEST_ASSERT_HEX64_WITHIN(5, 5000, 4996);
TEST_ASSERT_HEX64_WITHIN(5, 5000, 5005);
#endif
}
void testHEX64sNotWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
VERIFY_FAILS_END
#endif
}
void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_WITHIN(5, 1, -1);
VERIFY_FAILS_END
#endif
}
void testUINT64sWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
TEST_ASSERT_UINT64_WITHIN(5, 5000, 4996);
TEST_ASSERT_UINT64_WITHIN(5, 5000, 5005);
#endif
}
void testUINT64sNotWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
VERIFY_FAILS_END
#endif
}
void testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_UINT64_WITHIN(5, 1, -1);
VERIFY_FAILS_END
#endif
}
void testINT64sWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
TEST_ASSERT_INT64_WITHIN(5, 5000, 4996);
TEST_ASSERT_INT64_WITHIN(5, 5000, 5005);
#endif
}
void testINT64sNotWithinDelta(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
VERIFY_FAILS_END
#endif
}
void testINT64sNotWithinDeltaAndDifferenceOverflows(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_INT64_WITHIN(1, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF);
VERIFY_FAILS_END
#endif
}
void testPrintNumbersInt64(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
#ifndef USING_OUTPUT_SPY
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0);
TEST_ASSERT_EQUAL_PRINT_NUMBERS("10000000000", 10000000000);
TEST_ASSERT_EQUAL_PRINT_NUMBERS("-9223372036854775808", (UNITY_INT)0x8000000000000000);
TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (UNITY_INT)0xFFFFFFFFFFFFFFFF);
#endif
#endif
}
void testPrintNumbersUInt64(void)
{
#ifndef UNITY_SUPPORT_64
TEST_IGNORE();
#else
#ifndef USING_OUTPUT_SPY
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0);
TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("70000000000", 70000000000);
TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("9223372036854775808", (UNITY_UINT)0x8000000000000000);
TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("18446744073709551615", (UNITY_UINT)0xFFFFFFFFFFFFFFFF);
#endif
#endif
}

78
test/tests/test_unity_memory.c Normal file
View File

@@ -0,0 +1,78 @@
/* ==========================================
Unity Project - A Test Framework for C
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
[Released under MIT License. Please refer to license.txt for details]
========================================== */
#include "unity.h"
#define TEST_INSTANCES
#include "self_assessment_utils.h"
void setUp(void)
{
SetToOneToFailInTearDown = 0;
SetToOneMeanWeAlreadyCheckedThisGuy = 0;
}
void tearDown(void)
{
endPutcharSpy(); /* Stop suppressing test output */
if (SetToOneToFailInTearDown == 1)
{
/* These will be skipped internally if already failed/ignored */
TEST_FAIL_MESSAGE("<= Failed in tearDown");
TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
}
if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
{
UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
UNITY_OUTPUT_CHAR('\n');
}
}
void testEqualMemory(void)
{
const char *testString = "whatever";
TEST_ASSERT_EQUAL_MEMORY(testString, testString, 8);
TEST_ASSERT_EQUAL_MEMORY("whatever", "whatever", 8);
TEST_ASSERT_EQUAL_MEMORY("whatever", testString, 8);
TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 8);
TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 2);
TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 1);
}
void testNotEqualMemory1(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY("foo", "bar", 3);
VERIFY_FAILS_END
}
void testNotEqualMemory2(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY("fool", "food", 4);
VERIFY_FAILS_END
}
void testNotEqualMemory3(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY(NULL, "food", 4);
VERIFY_FAILS_END
}
void testNotEqualMemory4(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY("fool", NULL, 4);
VERIFY_FAILS_END
}
void testNotEqualMemoryLengthZero(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 0);
VERIFY_FAILS_END
}

0
test/tests/testparameterized.c → test/tests/test_unity_parameterized.c
View File

326
test/tests/test_unity_strings.c Normal file
View File

@@ -0,0 +1,326 @@
/* ==========================================
Unity Project - A Test Framework for C
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
[Released under MIT License. Please refer to license.txt for details]
========================================== */
#include "unity.h"
#define TEST_INSTANCES
#include "self_assessment_utils.h"
void setUp(void)
{
SetToOneToFailInTearDown = 0;
SetToOneMeanWeAlreadyCheckedThisGuy = 0;
}
void tearDown(void)
{
endPutcharSpy(); /* Stop suppressing test output */
if (SetToOneToFailInTearDown == 1)
{
/* These will be skipped internally if already failed/ignored */
TEST_FAIL_MESSAGE("<= Failed in tearDown");
TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
}
if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
{
UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
UNITY_OUTPUT_CHAR('\n');
}
}
void testEqualStrings(void)
{
const char *testString = "foo";
TEST_ASSERT_EQUAL_STRING(testString, testString);
TEST_ASSERT_EQUAL_STRING_MESSAGE("foo", "foo", "foo isn't foo");
TEST_ASSERT_EQUAL_STRING("foo", testString);
TEST_ASSERT_EQUAL_STRING(testString, "foo");
TEST_ASSERT_EQUAL_STRING("", "");
}
void testEqualStringsLen(void)
{
const char *testString = "foobar";
TEST_ASSERT_EQUAL_STRING_LEN(testString, testString, strlen(testString));
TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE("foobar", "foobaz", 5, "fooba isn't fooba");
TEST_ASSERT_EQUAL_STRING_LEN("foo", testString, 3);
TEST_ASSERT_EQUAL_STRING_LEN(testString, "foo", 3);
TEST_ASSERT_EQUAL_STRING_LEN("", "", 3);
}
void testEqualStringsWithCarriageReturnsAndLineFeeds(void)
{
const char *testString = "foo\r\nbar";
TEST_ASSERT_EQUAL_STRING(testString, testString);
TEST_ASSERT_EQUAL_STRING("foo\r\nbar", "foo\r\nbar");
TEST_ASSERT_EQUAL_STRING("foo\r\nbar", testString);
TEST_ASSERT_EQUAL_STRING(testString, "foo\r\nbar");
TEST_ASSERT_EQUAL_STRING("", "");
}
void testNotEqualString1(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING("foo", "bar");
VERIFY_FAILS_END
}
void testNotEqualStringLen1(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_LEN("foobar", "foobaz", 6);
VERIFY_FAILS_END
}
void testNotEqualString2(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING("foo", "");
VERIFY_FAILS_END
}
void testNotEqualStringLen2(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_LEN("foo", "", 3);
VERIFY_FAILS_END
}
void testNotEqualString3(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING("", "bar");
VERIFY_FAILS_END
}
void testNotEqualStringLen3(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_LEN("", "bar", 3);
VERIFY_FAILS_END
}
void testNotEqualString4(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING("bar\r", "bar\n");
VERIFY_FAILS_END
}
void testNotEqualStringLen4(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_LEN("ba\r\x16", "ba\r\n", 4);
VERIFY_FAILS_END
}
void testNotEqualString5(void)
{
const char str1[] = { 0x41, 0x42, 0x03, 0x00 };
const char str2[] = { 0x41, 0x42, 0x04, 0x00 };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING(str1, str2);
VERIFY_FAILS_END
}
void testNotEqualString_ExpectedStringIsNull(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING(NULL, "bar");
VERIFY_FAILS_END
}
void testNotEqualStringLen_ExpectedStringIsNull(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_LEN(NULL, "bar", 1);
VERIFY_FAILS_END
}
void testNotEqualString_ActualStringIsNull(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING("foo", NULL);
VERIFY_FAILS_END
}
void testNotEqualStringLen_ActualStringIsNull(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_LEN("foo", NULL, 1);
VERIFY_FAILS_END
}
void testNotEqualString_ExpectedStringIsLonger(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING("foo2", "foo");
VERIFY_FAILS_END
}
void testNotEqualString_ActualStringIsLonger(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING("foo", "foo2");
VERIFY_FAILS_END
}
void testEqualStringArrays(void)
{
const char *testStrings[] = { "foo", "boo", "woo", "moo" };
const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, expStrings, 3);
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 3);
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 2);
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 1);
}
void testNotEqualStringArray1(void)
{
const char *testStrings[] = { "foo", "boo", "woo", "moo" };
const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
VERIFY_FAILS_END
}
void testNotEqualStringArray2(void)
{
const char *testStrings[] = { "zoo", "boo", "woo", "moo" };
const char *expStrings[] = { "foo", "boo", "woo", "moo" };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
VERIFY_FAILS_END
}
void testNotEqualStringArray3(void)
{
const char *testStrings[] = { "foo", "boo", "woo", NULL };
const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
VERIFY_FAILS_END
}
void testNotEqualStringArray4(void)
{
const char *testStrings[] = { "foo", "boo", "woo", "moo" };
const char *expStrings[] = { "foo", NULL, "woo", "moo" };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
VERIFY_FAILS_END
}
void testNotEqualStringArray5(void)
{
const char **testStrings = NULL;
const char *expStrings[] = { "foo", "boo", "woo", "zoo" };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
VERIFY_FAILS_END
}
void testNotEqualStringArray6(void)
{
const char *testStrings[] = { "foo", "boo", "woo", "zoo" };
const char **expStrings = NULL;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
VERIFY_FAILS_END
}
void testEqualStringArrayIfBothNulls(void)
{
const char **testStrings = NULL;
const char **expStrings = NULL;
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
}
void testNotEqualStringArrayLengthZero(void)
{
const char *testStrings[] = {NULL};
const char **expStrings = NULL;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 0);
VERIFY_FAILS_END
}
void testEqualStringEachEqual(void)
{
const char *testStrings1[] = { "foo", "foo", "foo", "foo" };
const char *testStrings2[] = { "boo", "boo", "boo", "zoo" };
const char *testStrings3[] = { "", "", "", "" };
TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 4);
TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 1);
TEST_ASSERT_EACH_EQUAL_STRING("boo", testStrings2, 3);
TEST_ASSERT_EACH_EQUAL_STRING("", testStrings3, 4);
}
void testNotEqualStringEachEqual1(void)
{
const char *testStrings[] = { "foo", "foo", "foo", "moo" };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
VERIFY_FAILS_END
}
void testNotEqualStringEachEqual2(void)
{
const char *testStrings[] = { "boo", "foo", "foo", "foo" };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
VERIFY_FAILS_END
}
void testNotEqualStringEachEqual3(void)
{
const char *testStrings[] = { "foo", "foo", "foo", NULL };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
VERIFY_FAILS_END
}
void testNotEqualStringEachEqual4(void)
{
const char *testStrings[] = { "foo", "foo", "woo", "foo" };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4);
VERIFY_FAILS_END
}
void testNotEqualStringEachEqual5(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EACH_EQUAL_STRING("foo", NULL, 1);
VERIFY_FAILS_END
}
void testCstringsEscapeSequence(void)
{
#ifndef USING_OUTPUT_SPY
TEST_IGNORE();
#else
startPutcharSpy();
UnityPrint("\x16\x10");
endPutcharSpy();
TEST_ASSERT_EQUAL_STRING("\\x16\\x10", getBufferPutcharSpy());
#endif
}

8201
test/tests/testunity.c
View File

File diff suppressed because it is too large Load Diff