mirror of https://github.com/DaveGamble/cJSON
Update Unity to version v2.4.2
Merge commit 'b7bfe1e91a0b55d72f849944d5a33b7962d7bf51' into develop
This commit is contained in:
Max Bruckner
commit
acf80470f8
|
|
@ -118,6 +118,17 @@ Another way of calling TEST_ASSERT_EQUAL_INT
|
|||
Asserts that the actual value is within plus or minus delta of the expected value. This also comes in
|
||||
size specific variants.
|
||||
|
||||
|
||||
TEST_ASSERT_GREATER_THAN(threshold, actual)
|
||||
|
||||
Asserts that the actual value is greater than the threshold. This also comes in size specific variants.
|
||||
|
||||
|
||||
TEST_ASSERT_LESS_THAN(threshold, actual)
|
||||
|
||||
Asserts that the actual value is less than the threshold. This also comes in size specific variants.
|
||||
|
||||
|
||||
Arrays
|
||||
------
|
||||
|
||||
|
|
|
|||
|
|
@ -172,7 +172,7 @@ class UnityModuleGenerator
|
|||
when 'camel' then part1
|
||||
when 'snake' then part1.downcase
|
||||
when 'caps' then part1.upcase
|
||||
else part1.downcase
|
||||
else part1
|
||||
end
|
||||
else
|
||||
case (@options[:naming])
|
||||
|
|
@ -180,7 +180,7 @@ class UnityModuleGenerator
|
|||
when 'camel' then part1 + part2
|
||||
when 'snake' then part1.downcase + '_' + part2.downcase
|
||||
when 'caps' then part1.upcase + '_' + part2.upcase
|
||||
else part1.downcase + '_' + part2.downcase
|
||||
else part1 + '_' + part2
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -290,7 +290,7 @@ if $0 == __FILE__
|
|||
' -n"camel" sets the file naming convention.',
|
||||
' bumpy - BumpyCaseFilenames.',
|
||||
' camel - camelCaseFilenames.',
|
||||
' snake - snake_case_filenames. (DEFAULT)',
|
||||
' snake - snake_case_filenames.',
|
||||
' caps - CAPS_CASE_FILENAMES.',
|
||||
' -u update subversion too (requires subversion command line)',
|
||||
' -y"my.yml" selects a different yaml config file for module generation',
|
||||
|
|
|
|||
|
|
@ -119,7 +119,7 @@ class UnityTestRunnerGenerator
|
|||
source_index = 0
|
||||
tests_and_line_numbers.size.times do |i|
|
||||
source_lines[source_index..-1].each_with_index do |line, index|
|
||||
next unless line =~ /#{tests_and_line_numbers[i][:test]}/
|
||||
next unless line =~ /\s+#{tests_and_line_numbers[i][:test]}(?:\s|\()/
|
||||
source_index += index
|
||||
tests_and_line_numbers[i][:line_number] = source_index + 1
|
||||
break
|
||||
|
|
|
|||
|
|
@ -290,6 +290,60 @@ Asserts the specified bit of the `actual` parameter is high.
|
|||
|
||||
Asserts the specified bit of the `actual` parameter is low.
|
||||
|
||||
### Integer Less Than / Greater Than
|
||||
|
||||
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)`
|
||||
|
||||
##### `TEST_ASSERT_GREATER_THAN_INT8 (threshold, actual)`
|
||||
|
||||
##### `TEST_ASSERT_GREATER_THAN_INT16 (threshold, actual)`
|
||||
|
||||
##### `TEST_ASSERT_GREATER_THAN_INT32 (threshold, actual)`
|
||||
|
||||
##### `TEST_ASSERT_GREATER_THAN_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_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)`
|
||||
|
||||
|
||||
### Integer Ranges (of all sizes)
|
||||
|
||||
|
|
|
|||
|
|
@ -201,10 +201,12 @@
|
|||
* `stdout` option. You decide to route your test result output to a custom
|
||||
* serial `RS232_putc()` function you wrote like thus:
|
||||
*/
|
||||
/* #define UNITY_OUTPUT_CHAR(a) RS232_putc(a) */
|
||||
/* #define UNITY_OUTPUT_FLUSH() RS232_flush() */
|
||||
/* #define UNITY_OUTPUT_START() RS232_config(115200,1,8,0) */
|
||||
/* #define UNITY_OUTPUT_COMPLETE() RS232_close() */
|
||||
/* #define UNITY_OUTPUT_CHAR(a) RS232_putc(a) */
|
||||
/* #define UNITY_OUTPUT_CHAR_HEADER_DECLARATION RS232_putc(int) */
|
||||
/* #define UNITY_OUTPUT_FLUSH() RS232_flush() */
|
||||
/* #define UNITY_OUTPUT_FLUSH_HEADER_DECLARATION RS232_flush(void) */
|
||||
/* #define UNITY_OUTPUT_START() RS232_config(115200,1,8,0) */
|
||||
/* #define UNITY_OUTPUT_COMPLETE() RS232_close() */
|
||||
|
||||
/* For some targets, Unity can make the otherwise required `setUp()` and
|
||||
* `tearDown()` functions optional. This is a nice convenience for test writers
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ module RakefileHelpers
|
|||
defines = if $cfg['compiler']['defines']['items'].nil?
|
||||
''
|
||||
else
|
||||
squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar'])
|
||||
squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar'] + ['UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)'])
|
||||
end
|
||||
options = squash('', $cfg['compiler']['options'])
|
||||
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ endif
|
|||
CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror
|
||||
CFLAGS += $(DEBUG)
|
||||
DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar
|
||||
DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)
|
||||
SRC = ../src/unity_fixture.c \
|
||||
../../../src/unity.c \
|
||||
unity_fixture_Test.c \
|
||||
|
|
|
|||
|
|
@ -1,2 +1,2 @@
|
|||
120
|
||||
121
|
||||
|
||||
|
|
|
|||
|
|
@ -1,2 +1,2 @@
|
|||
2.4.1
|
||||
2.4.2
|
||||
|
||||
|
|
|
|||
|
|
@ -27,6 +27,8 @@ static const char UnityStrNull[] = "NULL";
|
|||
static const char UnityStrSpacer[] = ". ";
|
||||
static const char UnityStrExpected[] = " Expected ";
|
||||
static const char UnityStrWas[] = " Was ";
|
||||
static const char UnityStrGt[] = " to be greater than ";
|
||||
static const char UnityStrLt[] = " to be less than ";
|
||||
static const char UnityStrElement[] = " Element ";
|
||||
static const char UnityStrByte[] = " Byte ";
|
||||
static const char UnityStrMemory[] = " Memory Mismatch.";
|
||||
|
|
@ -235,95 +237,97 @@ void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number)
|
|||
|
||||
/*-----------------------------------------------*/
|
||||
#ifndef UNITY_EXCLUDE_FLOAT_PRINT
|
||||
static void UnityPrintDecimalAndNumberWithLeadingZeros(UNITY_INT32 fraction_part, UNITY_INT32 divisor)
|
||||
{
|
||||
UNITY_OUTPUT_CHAR('.');
|
||||
while (divisor > 0)
|
||||
{
|
||||
UNITY_OUTPUT_CHAR('0' + fraction_part / divisor);
|
||||
fraction_part %= divisor;
|
||||
divisor /= 10;
|
||||
if (fraction_part == 0) break; /* Truncate trailing 0's */
|
||||
}
|
||||
}
|
||||
#ifndef UNITY_ROUND_TIES_AWAY_FROM_ZERO
|
||||
/* If rounds up && remainder 0.5 && result odd && below cutoff for double precision issues */
|
||||
#define ROUND_TIES_TO_EVEN(orig, num_int, num) \
|
||||
if (num_int > (num) && (num) - (num_int-1) <= 0.5 && (num_int & 1) == 1 && orig < 1e22) \
|
||||
num_int -= 1 /* => a tie to round down to even */
|
||||
#else
|
||||
#define ROUND_TIES_TO_EVEN(orig, num_int, num) /* Remove macro */
|
||||
#endif
|
||||
|
||||
/* Printing floating point numbers is hard. Some goals of this implementation: works for embedded
|
||||
* systems, floats or doubles, and has a reasonable format. The key paper in this area,
|
||||
* 'How to Print Floating-Point Numbers Accurately' by Steele & White, shows an approximation by
|
||||
* scaling called Dragon 2. This code uses a similar idea. The other core algorithm uses casts and
|
||||
* floating subtraction to give exact remainders after the decimal, to be scaled into an integer.
|
||||
* Extra trailing 0's are excluded. The output defaults to rounding to nearest, ties to even. You
|
||||
* can enable rounding ties away from zero. Note: UNITY_DOUBLE param can typedef to float or double
|
||||
|
||||
* The old version required compiling in snprintf. For reference, with a similar format as now:
|
||||
* char buf[19];
|
||||
* if (number > 4294967296.0 || -number > 4294967296.0) snprintf(buf, sizeof buf, "%.8e", number);
|
||||
* else snprintf(buf, sizeof buf, "%.6f", number);
|
||||
* UnityPrint(buf);
|
||||
*/
|
||||
/* This function prints a floating-point value in a format similar to
|
||||
* printf("%.6g"). It can work with either single- or double-precision,
|
||||
* but for simplicity, it prints only 6 significant digits in either case.
|
||||
* Printing more than 6 digits accurately is hard (at least in the single-
|
||||
* precision case) and isn't attempted here. */
|
||||
void UnityPrintFloat(const UNITY_DOUBLE input_number)
|
||||
{
|
||||
UNITY_DOUBLE number;
|
||||
UNITY_DOUBLE number = input_number;
|
||||
|
||||
if (input_number < 0)
|
||||
/* print minus sign (including for negative zero) */
|
||||
if (number < 0.0f || (number == 0.0f && 1.0f / number < 0.0f))
|
||||
{
|
||||
UNITY_OUTPUT_CHAR('-');
|
||||
number = -input_number;
|
||||
} else
|
||||
{
|
||||
number = input_number;
|
||||
number = -number;
|
||||
}
|
||||
|
||||
if (isnan(number)) UnityPrint(UnityStrNaN);
|
||||
else if (isinf(number)) UnityPrintLen(UnityStrInf, 3);
|
||||
else if (number <= 0.0000005 && number > 0) UnityPrint("0.000000..."); /* Small number */
|
||||
else if (number < 4294967295.9999995) /* Rounded result fits in 32 bits, "%.6f" format */
|
||||
/* handle zero, NaN, and +/- infinity */
|
||||
if (number == 0.0f) UnityPrint("0");
|
||||
else if (isnan(number)) UnityPrint("nan");
|
||||
else if (isinf(number)) UnityPrint("inf");
|
||||
else
|
||||
{
|
||||
const UNITY_INT32 divisor = 1000000/10;
|
||||
UNITY_UINT32 integer_part = (UNITY_UINT32)number;
|
||||
UNITY_INT32 fraction_part = (UNITY_INT32)((number - (UNITY_DOUBLE)integer_part)*1000000.0 + 0.5);
|
||||
/* Double precision calculation gives best performance for six rounded decimal places */
|
||||
ROUND_TIES_TO_EVEN(number, fraction_part, (number - (UNITY_DOUBLE)integer_part)*1000000.0);
|
||||
int exponent = 0;
|
||||
int decimals, digits;
|
||||
UNITY_INT32 n;
|
||||
char buf[16];
|
||||
|
||||
if (fraction_part == 1000000) /* Carry across the decimal point */
|
||||
/* scale up or down by powers of 10 */
|
||||
while (number < 100000.0f / 1e6f) { number *= 1e6f; exponent -= 6; }
|
||||
while (number < 100000.0f) { number *= 10.0f; exponent--; }
|
||||
while (number > 1000000.0f * 1e6f) { number /= 1e6f; exponent += 6; }
|
||||
while (number > 1000000.0f) { number /= 10.0f; exponent++; }
|
||||
|
||||
/* round to nearest integer */
|
||||
n = ((UNITY_INT32)(number + number) + 1) / 2;
|
||||
if (n > 999999)
|
||||
{
|
||||
fraction_part = 0;
|
||||
integer_part += 1;
|
||||
}
|
||||
|
||||
UnityPrintNumberUnsigned(integer_part);
|
||||
UnityPrintDecimalAndNumberWithLeadingZeros(fraction_part, divisor);
|
||||
}
|
||||
else /* Number is larger, use exponential format of 9 digits, "%.8e" */
|
||||
{
|
||||
const UNITY_INT32 divisor = 1000000000/10;
|
||||
UNITY_INT32 integer_part;
|
||||
UNITY_DOUBLE_TYPE divide = 10.0;
|
||||
int exponent = 9;
|
||||
|
||||
while (number / divide >= 1000000000.0 - 0.5)
|
||||
{
|
||||
divide *= 10;
|
||||
n = 100000;
|
||||
exponent++;
|
||||
}
|
||||
integer_part = (UNITY_INT32)(number / divide + 0.5);
|
||||
/* Double precision calculation required for float, to produce 9 rounded digits */
|
||||
ROUND_TIES_TO_EVEN(number, integer_part, number / divide);
|
||||
|
||||
UNITY_OUTPUT_CHAR('0' + integer_part / divisor);
|
||||
UnityPrintDecimalAndNumberWithLeadingZeros(integer_part % divisor, divisor / 10);
|
||||
UNITY_OUTPUT_CHAR('e');
|
||||
UNITY_OUTPUT_CHAR('+');
|
||||
if (exponent < 10) UNITY_OUTPUT_CHAR('0');
|
||||
UnityPrintNumber(exponent);
|
||||
/* determine where to place decimal point */
|
||||
decimals = (exponent <= 0 && exponent >= -9) ? -exponent : 5;
|
||||
exponent += decimals;
|
||||
|
||||
/* truncate trailing zeroes after decimal point */
|
||||
while (decimals > 0 && n % 10 == 0)
|
||||
{
|
||||
n /= 10;
|
||||
decimals--;
|
||||
}
|
||||
|
||||
/* build up buffer in reverse order */
|
||||
digits = 0;
|
||||
while (n != 0 || digits < decimals + 1)
|
||||
{
|
||||
buf[digits++] = (char)('0' + n % 10);
|
||||
n /= 10;
|
||||
}
|
||||
while (digits > 0)
|
||||
{
|
||||
if(digits == decimals) UNITY_OUTPUT_CHAR('.');
|
||||
UNITY_OUTPUT_CHAR(buf[--digits]);
|
||||
}
|
||||
|
||||
/* print exponent if needed */
|
||||
if (exponent != 0)
|
||||
{
|
||||
UNITY_OUTPUT_CHAR('e');
|
||||
|
||||
if(exponent < 0)
|
||||
{
|
||||
UNITY_OUTPUT_CHAR('-');
|
||||
exponent = -exponent;
|
||||
}
|
||||
else
|
||||
{
|
||||
UNITY_OUTPUT_CHAR('+');
|
||||
}
|
||||
|
||||
digits = 0;
|
||||
while (exponent != 0 || digits < 2)
|
||||
{
|
||||
buf[digits++] = (char)('0' + exponent % 10);
|
||||
exponent /= 10;
|
||||
}
|
||||
while (digits > 0)
|
||||
{
|
||||
UNITY_OUTPUT_CHAR(buf[--digits]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */
|
||||
|
|
@ -526,6 +530,50 @@ void UnityAssertEqualNumber(const UNITY_INT expected,
|
|||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------*/
|
||||
void UnityAssertGreaterNumber(const UNITY_INT threshold,
|
||||
const UNITY_INT actual,
|
||||
const char *msg,
|
||||
const UNITY_LINE_TYPE lineNumber,
|
||||
const UNITY_DISPLAY_STYLE_T style)
|
||||
{
|
||||
RETURN_IF_FAIL_OR_IGNORE;
|
||||
|
||||
if (!(actual > threshold))
|
||||
{
|
||||
UnityTestResultsFailBegin(lineNumber);
|
||||
UnityPrint(UnityStrExpected);
|
||||
UnityPrintNumberByStyle(actual, style);
|
||||
UnityPrint(UnityStrGt);
|
||||
UnityPrintNumberByStyle(threshold, style);
|
||||
UnityAddMsgIfSpecified(msg);
|
||||
UNITY_FAIL_AND_BAIL;
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------*/
|
||||
void UnityAssertSmallerNumber(const UNITY_INT threshold,
|
||||
const UNITY_INT actual,
|
||||
const char *msg,
|
||||
const UNITY_LINE_TYPE lineNumber,
|
||||
const UNITY_DISPLAY_STYLE_T style)
|
||||
{
|
||||
RETURN_IF_FAIL_OR_IGNORE;
|
||||
|
||||
if (!(actual < threshold))
|
||||
{
|
||||
UnityTestResultsFailBegin(lineNumber);
|
||||
UnityPrint(UnityStrExpected);
|
||||
UnityPrintNumberByStyle(actual, style);
|
||||
UnityPrint(UnityStrLt);
|
||||
UnityPrintNumberByStyle(threshold, style);
|
||||
UnityAddMsgIfSpecified(msg);
|
||||
UNITY_FAIL_AND_BAIL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#define UnityPrintPointlessAndBail() \
|
||||
{ \
|
||||
UnityTestResultsFailBegin(lineNumber); \
|
||||
|
|
@ -1025,7 +1073,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
|||
{
|
||||
UNITY_UINT32 i = 0;
|
||||
UNITY_UINT32 j = 0;
|
||||
const char* exp = NULL;
|
||||
const char* expd = NULL;
|
||||
const char* act = NULL;
|
||||
|
||||
RETURN_IF_FAIL_OR_IGNORE;
|
||||
|
|
@ -1048,7 +1096,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
|||
|
||||
if (flags != UNITY_ARRAY_TO_ARRAY)
|
||||
{
|
||||
exp = (const char*)expected;
|
||||
expd = (const char*)expected;
|
||||
}
|
||||
|
||||
do
|
||||
|
|
@ -1056,15 +1104,15 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
|||
act = actual[j];
|
||||
if (flags == UNITY_ARRAY_TO_ARRAY)
|
||||
{
|
||||
exp = ((const char* const*)expected)[j];
|
||||
expd = ((const char* const*)expected)[j];
|
||||
}
|
||||
|
||||
/* if both pointers not null compare the strings */
|
||||
if (exp && act)
|
||||
if (expd && act)
|
||||
{
|
||||
for (i = 0; exp[i] || act[i]; i++)
|
||||
for (i = 0; expd[i] || act[i]; i++)
|
||||
{
|
||||
if (exp[i] != act[i])
|
||||
if (expd[i] != act[i])
|
||||
{
|
||||
Unity.CurrentTestFailed = 1;
|
||||
break;
|
||||
|
|
@ -1073,7 +1121,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
|||
}
|
||||
else
|
||||
{ /* handle case of one pointers being null (if both null, test should pass) */
|
||||
if (exp != act)
|
||||
if (expd != act)
|
||||
{
|
||||
Unity.CurrentTestFailed = 1;
|
||||
}
|
||||
|
|
@ -1087,7 +1135,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
|
|||
UnityPrint(UnityStrElement);
|
||||
UnityPrintNumberUnsigned(j);
|
||||
}
|
||||
UnityPrintExpectedAndActualStrings(exp, act);
|
||||
UnityPrintExpectedAndActualStrings(expd, act);
|
||||
UnityAddMsgIfSpecified(msg);
|
||||
UNITY_FAIL_AND_BAIL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -114,6 +114,35 @@ void tearDown(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 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)
|
||||
#define TEST_ASSERT_GREATER_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, NULL)
|
||||
|
||||
|
||||
#define TEST_ASSERT_LESS_THAN(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_LESS_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, NULL)
|
||||
|
||||
|
||||
/* Integer Ranges (of all sizes) */
|
||||
#define TEST_ASSERT_INT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_INT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL)
|
||||
|
|
@ -157,6 +186,8 @@ void tearDown(void);
|
|||
#define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, NULL)
|
||||
#define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, NULL)
|
||||
|
||||
|
||||
|
||||
/* Arrays Compared To Single Value */
|
||||
#define TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, NULL)
|
||||
#define TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, NULL)
|
||||
|
|
@ -241,6 +272,35 @@ void tearDown(void);
|
|||
#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (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))
|
||||
#define TEST_ASSERT_GREATER_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, (message))
|
||||
|
||||
|
||||
#define TEST_ASSERT_LESS_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_LESS_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, (message))
|
||||
|
||||
|
||||
/* Integer Ranges (of all sizes) */
|
||||
#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_INT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message))
|
||||
|
|
|
|||
|
|
@ -244,8 +244,8 @@ typedef UNITY_FLOAT_TYPE UNITY_FLOAT;
|
|||
#define UNITY_OUTPUT_CHAR(a) (void)putchar(a)
|
||||
#else
|
||||
/* If defined as something else, make sure we declare it here so it's ready for use */
|
||||
#ifndef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
|
||||
extern void UNITY_OUTPUT_CHAR(int);
|
||||
#ifdef UNITY_OUTPUT_CHAR_HEADER_DECLARATION
|
||||
extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
|
@ -253,22 +253,22 @@ extern void UNITY_OUTPUT_CHAR(int);
|
|||
#ifdef UNITY_USE_FLUSH_STDOUT
|
||||
/* We want to use the stdout flush utility */
|
||||
#include <stdio.h>
|
||||
#define UNITY_OUTPUT_FLUSH (void)fflush(stdout)
|
||||
#define UNITY_OUTPUT_FLUSH() (void)fflush(stdout)
|
||||
#else
|
||||
/* We've specified nothing, therefore flush should just be ignored */
|
||||
#define UNITY_OUTPUT_FLUSH
|
||||
#define UNITY_OUTPUT_FLUSH()
|
||||
#endif
|
||||
#else
|
||||
/* We've defined flush as something else, so make sure we declare it here so it's ready for use */
|
||||
#ifndef UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION
|
||||
extern void UNITY_OUTPUT_FLUSH(void);
|
||||
#ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION
|
||||
extern void UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef UNITY_OUTPUT_FLUSH
|
||||
#define UNITY_FLUSH_CALL()
|
||||
#else
|
||||
#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH
|
||||
#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH()
|
||||
#endif
|
||||
|
||||
#ifndef UNITY_PRINT_EOL
|
||||
|
|
@ -453,6 +453,18 @@ void UnityAssertEqualNumber(const UNITY_INT expected,
|
|||
const UNITY_LINE_TYPE lineNumber,
|
||||
const UNITY_DISPLAY_STYLE_T style);
|
||||
|
||||
void UnityAssertGreaterNumber(const UNITY_INT threshold,
|
||||
const UNITY_INT actual,
|
||||
const char* msg,
|
||||
const UNITY_LINE_TYPE lineNumber,
|
||||
const UNITY_DISPLAY_STYLE_T style);
|
||||
|
||||
void UnityAssertSmallerNumber(const UNITY_INT threshold,
|
||||
const UNITY_INT actual,
|
||||
const char* msg,
|
||||
const UNITY_LINE_TYPE lineNumber,
|
||||
const UNITY_DISPLAY_STYLE_T style);
|
||||
|
||||
void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
|
||||
UNITY_INTERNAL_PTR actual,
|
||||
const UNITY_UINT32 num_elements,
|
||||
|
|
@ -650,6 +662,34 @@ int UnityTestMatches(void);
|
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
|
||||
#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_GREATER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
|
||||
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
|
||||
|
||||
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT8(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT16(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT32(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT16(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT32(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX8(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX16(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16)
|
||||
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX32(threshold, actual, line, message) UnityAssertSmallerNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32)
|
||||
|
||||
|
||||
|
||||
#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT)
|
||||
#define UNITY_TEST_ASSERT_INT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8)
|
||||
#define UNITY_TEST_ASSERT_INT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16)
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ CFLAGS += -Wbad-function-cast -Wcast-qual -Wold-style-definition -Wshadow -Wstri
|
|||
#DEBUG = -O0 -g
|
||||
CFLAGS += $(DEBUG)
|
||||
DEFINES = -D UNITY_OUTPUT_CHAR=putcharSpy
|
||||
DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\)
|
||||
DEFINES += -D UNITY_SUPPORT_64 -D UNITY_INCLUDE_DOUBLE
|
||||
SRC = ../src/unity.c tests/testunity.c build/testunityRunner.c
|
||||
INC_DIR = -I ../src
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ module RakefileHelpers
|
|||
defines = if $cfg['compiler']['defines']['items'].nil?
|
||||
''
|
||||
else
|
||||
squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=putcharSpy'] + inject_defines)
|
||||
squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=putcharSpy'] + ['UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\)'] + inject_defines)
|
||||
end
|
||||
options = squash('', $cfg['compiler']['options'])
|
||||
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
|
||||
|
|
|
|||
|
|
@ -764,8 +764,9 @@ void testNotEqualBitsLow(void)
|
|||
EXPECT_ABORT_BEGIN
|
||||
TEST_ASSERT_BITS_LOW(v0, v1);
|
||||
VERIFY_FAILS_END
|
||||
|
||||
}
|
||||
|
||||
|
||||
void testEqualShorts(void)
|
||||
{
|
||||
short v0, v1;
|
||||
|
|
@ -1305,6 +1306,415 @@ void testINT8sNotWithinDeltaAndCustomMessage(void)
|
|||
VERIFY_FAILS_END
|
||||
}
|
||||
|
||||
|
||||
//-----------------
|
||||
void testGreaterThan(void)
|
||||
{
|
||||
UNITY_INT v0, v1;
|
||||
UNITY_INT *p0, *p1;
|
||||
|
||||
v0 = 0;
|
||||
v1 = 1;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN(*p0, *p1);
|
||||
}
|
||||
|
||||
void testGreaterThanINT(void)
|
||||
{
|
||||
UNITY_INT v0, v1;
|
||||
UNITY_INT *p0, *p1;
|
||||
|
||||
v0 = 302;
|
||||
v1 = 3334;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_INT(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_INT(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_INT(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_INT(*p0, *p1);
|
||||
}
|
||||
|
||||
|
||||
void testGreaterThanINT8(void)
|
||||
{
|
||||
UNITY_INT8 v0, v1;
|
||||
UNITY_INT8 *p0, *p1;
|
||||
|
||||
v0 = -128;
|
||||
v1 = 127;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_INT8(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_INT8(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_INT8(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_INT8(*p0, *p1);
|
||||
}
|
||||
|
||||
void testGreaterThanINT16(void)
|
||||
{
|
||||
UNITY_INT16 v0, v1;
|
||||
UNITY_INT16 *p0, *p1;
|
||||
|
||||
v0 = -32768;
|
||||
v1 = 32767;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_INT16(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_INT16(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_INT16(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_INT16(*p0, *p1);
|
||||
}
|
||||
|
||||
void testGreaterThanINT32(void)
|
||||
{
|
||||
UNITY_INT32 v0, v1;
|
||||
UNITY_INT32 *p0, *p1;
|
||||
|
||||
v0 = -214783648;
|
||||
v1 = 214783647;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_INT32(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_INT32(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_INT32(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_INT32(*p0, *p1);
|
||||
}
|
||||
|
||||
void testGreaterThanUINT(void)
|
||||
{
|
||||
UNITY_UINT v0, v1;
|
||||
UNITY_UINT *p0, *p1;
|
||||
|
||||
v0 = 0;
|
||||
v1 = 1;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_UINT(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT(*p0, *p1);
|
||||
}
|
||||
|
||||
|
||||
void testGreaterThanUINT8(void)
|
||||
{
|
||||
UNITY_UINT8 v0, v1;
|
||||
UNITY_UINT8 *p0, *p1;
|
||||
|
||||
v0 = 0;
|
||||
v1 = 255;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_UINT8(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT8(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT8(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT8(*p0, *p1);
|
||||
}
|
||||
|
||||
void testGreaterThanUINT16(void)
|
||||
{
|
||||
UNITY_UINT16 v0, v1;
|
||||
UNITY_UINT16 *p0, *p1;
|
||||
|
||||
v0 = 0;
|
||||
v1 = 65535;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_UINT16(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT16(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT16(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT16(*p0, *p1);
|
||||
}
|
||||
|
||||
void testGreaterThanUINT32(void)
|
||||
{
|
||||
UNITY_UINT32 v0, v1;
|
||||
UNITY_UINT32 *p0, *p1;
|
||||
|
||||
v0 = 0;
|
||||
v1 = 4294967295;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_UINT32(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT32(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT32(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_UINT32(*p0, *p1);
|
||||
}
|
||||
|
||||
void testGreaterThanHEX8(void)
|
||||
{
|
||||
UNITY_UINT8 v0, v1;
|
||||
UNITY_UINT8 *p0, *p1;
|
||||
|
||||
v0 = 0x00;
|
||||
v1 = 0xFF;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_HEX8(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_HEX8(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_HEX8(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_HEX8(*p0, *p1);
|
||||
}
|
||||
|
||||
void testGreaterThanHEX16(void)
|
||||
{
|
||||
UNITY_UINT16 v0, v1;
|
||||
UNITY_UINT16 *p0, *p1;
|
||||
|
||||
v0 = 0x0000;
|
||||
v1 = 0xFFFF;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_HEX16(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_HEX16(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_HEX16(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_HEX16(*p0, *p1);
|
||||
}
|
||||
|
||||
void testGreaterThanHEX32(void)
|
||||
{
|
||||
UNITY_UINT32 v0, v1;
|
||||
UNITY_UINT32 *p0, *p1;
|
||||
|
||||
v0 = 0x00000000;
|
||||
v1 = 0xFFFFFFFF;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_GREATER_THAN_HEX32(v0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_HEX32(*p0, v1);
|
||||
TEST_ASSERT_GREATER_THAN_HEX32(v0, *p1);
|
||||
TEST_ASSERT_GREATER_THAN_HEX32(*p0, *p1);
|
||||
}
|
||||
|
||||
|
||||
void testNotGreaterThan(void)
|
||||
{
|
||||
EXPECT_ABORT_BEGIN
|
||||
TEST_ASSERT_GREATER_THAN(0, -1);
|
||||
VERIFY_FAILS_END
|
||||
}
|
||||
|
||||
void testLessThan(void)
|
||||
{
|
||||
UNITY_INT v0, v1;
|
||||
UNITY_INT *p0, *p1;
|
||||
|
||||
v0 = 0;
|
||||
v1 = -1;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN(*p0, *p1);
|
||||
}
|
||||
|
||||
void testLessThanINT(void)
|
||||
{
|
||||
UNITY_INT v0, v1;
|
||||
UNITY_INT *p0, *p1;
|
||||
|
||||
v0 = 3334;
|
||||
v1 = 302;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_INT(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_INT(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_INT(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_INT(*p0, *p1);
|
||||
}
|
||||
|
||||
|
||||
void testLessThanINT8(void)
|
||||
{
|
||||
UNITY_INT8 v0, v1;
|
||||
UNITY_INT8 *p0, *p1;
|
||||
|
||||
v0 = 127;
|
||||
v1 = -128;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_INT8(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_INT8(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_INT8(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_INT8(*p0, *p1);
|
||||
}
|
||||
|
||||
void testLessThanINT16(void)
|
||||
{
|
||||
UNITY_INT16 v0, v1;
|
||||
UNITY_INT16 *p0, *p1;
|
||||
|
||||
v0 = 32767;
|
||||
v1 = -32768;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_INT16(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_INT16(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_INT16(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_INT16(*p0, *p1);
|
||||
}
|
||||
|
||||
void testLessThanINT32(void)
|
||||
{
|
||||
UNITY_INT32 v0, v1;
|
||||
UNITY_INT32 *p0, *p1;
|
||||
|
||||
v0 = 214783647;
|
||||
v1 = -214783648;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_INT32(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_INT32(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_INT32(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_INT32(*p0, *p1);
|
||||
}
|
||||
|
||||
void testLessThanUINT(void)
|
||||
{
|
||||
UNITY_UINT v0, v1;
|
||||
UNITY_UINT *p0, *p1;
|
||||
|
||||
v0 = 1;
|
||||
v1 = 0;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_UINT(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_UINT(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_UINT(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_UINT(*p0, *p1);
|
||||
}
|
||||
|
||||
|
||||
void testLessThanUINT8(void)
|
||||
{
|
||||
UNITY_UINT8 v0, v1;
|
||||
UNITY_UINT8 *p0, *p1;
|
||||
|
||||
v0 = 255;
|
||||
v1 = 0;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_UINT8(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_UINT8(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_UINT8(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_UINT8(*p0, *p1);
|
||||
}
|
||||
|
||||
void testLessThanUINT16(void)
|
||||
{
|
||||
UNITY_UINT16 v0, v1;
|
||||
UNITY_UINT16 *p0, *p1;
|
||||
|
||||
v0 = 65535;
|
||||
v1 = 0;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_UINT16(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_UINT16(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_UINT16(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_UINT16(*p0, *p1);
|
||||
}
|
||||
|
||||
void testLessThanUINT32(void)
|
||||
{
|
||||
UNITY_UINT32 v0, v1;
|
||||
UNITY_UINT32 *p0, *p1;
|
||||
|
||||
v0 = 4294967295;
|
||||
v1 = 0;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_UINT32(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_UINT32(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_UINT32(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_UINT32(*p0, *p1);
|
||||
}
|
||||
|
||||
void testLessThanHEX8(void)
|
||||
{
|
||||
UNITY_UINT8 v0, v1;
|
||||
UNITY_UINT8 *p0, *p1;
|
||||
|
||||
v0 = 0xFF;
|
||||
v1 = 0x00;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_HEX8(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_HEX8(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_HEX8(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_HEX8(*p0, *p1);
|
||||
}
|
||||
|
||||
void testLessThanHEX16(void)
|
||||
{
|
||||
UNITY_UINT16 v0, v1;
|
||||
UNITY_UINT16 *p0, *p1;
|
||||
|
||||
v0 = 0xFFFF;
|
||||
v1 = 0x0000;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_HEX16(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_HEX16(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_HEX16(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_HEX16(*p0, *p1);
|
||||
}
|
||||
|
||||
void testLessThanHEX32(void)
|
||||
{
|
||||
UNITY_UINT32 v0, v1;
|
||||
UNITY_UINT32 *p0, *p1;
|
||||
|
||||
v0 = 0xFFFFFFFF;
|
||||
v1 = 0x00000000;
|
||||
p0 = &v0;
|
||||
p1 = &v1;
|
||||
|
||||
TEST_ASSERT_LESS_THAN_HEX32(v0, v1);
|
||||
TEST_ASSERT_LESS_THAN_HEX32(*p0, v1);
|
||||
TEST_ASSERT_LESS_THAN_HEX32(v0, *p1);
|
||||
TEST_ASSERT_LESS_THAN_HEX32(*p0, *p1);
|
||||
}
|
||||
|
||||
|
||||
void testNotLessThan(void)
|
||||
{
|
||||
EXPECT_ABORT_BEGIN
|
||||
TEST_ASSERT_LESS_THAN(0, 1);
|
||||
VERIFY_FAILS_END
|
||||
}
|
||||
|
||||
|
||||
|
||||
//-----------------
|
||||
void testEqualStrings(void)
|
||||
{
|
||||
const char *testString = "foo";
|
||||
|
|
@ -4056,61 +4466,46 @@ void testFloatPrinting(void)
|
|||
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
|
||||
TEST_IGNORE();
|
||||
#else
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0", 0.0f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.000000...", 0.000000499f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.000001", 0.00000050000005f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.100469499f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0", 0.9999995f); /*Rounding to int place*/
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0", 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.000002", 16.000002f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.000004", 16.000004f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.000006", 16.000006f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4294967040.0", 4294967040.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("5e-07", 0.00000050000005f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.100469499f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 0.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.99999", 7.99999f); /*Not rounding*/
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0002", 16.0002f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0004", 16.0004f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0006", 16.0006f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("999999", 999999.0f); /*Last full print integer*/
|
||||
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0", -0.0f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.000000...",-0.000000499f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.000001", -0.00000050000005f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.100469499f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0", -0.9999995f); /*Rounding to int place*/
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0", -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.000002", -16.000002f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000004", -16.000004f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000006", -16.000006f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4294967040.0",-4294967040.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("-5e-07", -0.00000050000005f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.100469499f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -0.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.99999", -7.99999f); /*Not rounding*/
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0002", -16.0002f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0004", -16.0004f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0006", -16.0006f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-999999", -999999.0f); /*Last full print integer*/
|
||||
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("5.0e+09", 5000000000.0f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("8.0e+09", 8.0e+09f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("8.3099991e+09", 8309999104.0f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 1.0e+10f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 10000000000.0f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+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.31e+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.00005499e+10", (float)1.000055e+10f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.10000006e+38", (float)1.10000005e+38f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.63529943e+10", 1.63529943e+10f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("3.40282347e+38", 3.40282346638e38f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00005e+10", (float)1.000054e+10f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.1e+38", (float)1.10000005e+38f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.6353e+10", 1.63529943e+10f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("3.40282e+38", 3.40282346638e38f);
|
||||
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0e+10", -1.0e+10f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.40282347e+38",-3.40282346638e38f);
|
||||
#endif
|
||||
}
|
||||
|
||||
void testFloatPrintingRoundTiesToEven(void)
|
||||
{
|
||||
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
|
||||
TEST_IGNORE();
|
||||
#else
|
||||
#ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.007813", 0.0078125f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.976563", 0.9765625f);
|
||||
#else /* Default to Round ties to even */
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.007182", 0.0071825f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.976562", 0.9765625f);
|
||||
#endif
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1e+10", -1.0e+10f);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.40282e+38", -3.40282346638e38f);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -4119,105 +4514,69 @@ 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("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);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0f / f_zero);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
|
||||
static void AllFloatPrinting_LessThan32Bits(void)
|
||||
static void printFloatValue(float f)
|
||||
{
|
||||
char expected[18];
|
||||
union { float f_value; int32_t int_value; } u;
|
||||
/* Float representations are laid out in integer order, walk up the list */
|
||||
for (u.f_value = 0.00000050000005f; u.f_value <= 4294967040.0f; u.int_value += 1)
|
||||
char expected_lower[18];
|
||||
char expected_higher[18];
|
||||
|
||||
startPutcharSpy();
|
||||
|
||||
UnityPrintFloat(f);
|
||||
|
||||
sprintf(expected, "%.6g", f);
|
||||
|
||||
/* We print all NaN's as "nan", not "-nan" */
|
||||
if(strcmp(expected, "-nan") == 0) strcpy(expected, "nan");
|
||||
|
||||
/* Allow for rounding differences in last digit */
|
||||
double lower = (double)f * 0.9999995;
|
||||
double higher = (double)f * 1.0000005;
|
||||
|
||||
if (isfinite(lower)) sprintf(expected_lower, "%.6g", lower); else strcpy(expected_lower, expected);
|
||||
if (isfinite(higher)) sprintf(expected_higher, "%.6g", higher); else strcpy(expected_higher, expected);
|
||||
|
||||
if (strcmp(expected, getBufferPutcharSpy()) != 0 &&
|
||||
strcmp(expected_lower, getBufferPutcharSpy()) != 0 &&
|
||||
strcmp(expected_higher, getBufferPutcharSpy()) != 0)
|
||||
{
|
||||
startPutcharSpy();
|
||||
|
||||
UnityPrintFloat(u.f_value); /*1.5x as fast as sprintf 5e-7f - 0.01f, 20s vs 30s*/
|
||||
int len = sprintf(expected, "%.6f", u.f_value);
|
||||
|
||||
while (expected[len - 1] == '0' && expected[len - 2] != '.') { len--; }
|
||||
expected[len] = '\0'; /* delete trailing 0's */
|
||||
|
||||
if (strcmp(expected, getBufferPutcharSpy()) != 0)
|
||||
{
|
||||
double six_digits = ((double)u.f_value - (uint32_t)u.f_value)*1000000.0;
|
||||
/* Not a tie (remainder != 0.5) => Can't explain the different strings */
|
||||
if (six_digits - (uint32_t)six_digits != 0.5)
|
||||
{
|
||||
/* Fail with diagnostic printing */
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, u.f_value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Compared to perfect, floats are occasionally rounded wrong. It doesn't affect
|
||||
* correctness, though. Two examples (of 13 total found during testing):
|
||||
* Printed: 6.19256349e+20, Exact: 619256348499999981568.0f <= Eliminated by ROUND_TIES_TO_EVEN
|
||||
* Printed: 2.19012272e+35, Exact: 219012271499999993621766990196637696.0f */
|
||||
static void AllFloatPrinting_Larger(const float start, const float end)
|
||||
{
|
||||
unsigned int wrong = 0;
|
||||
char expected[18];
|
||||
union { float f_value; int32_t int_value; } u;
|
||||
for (u.f_value = start; u.f_value <= end; u.int_value += 1)
|
||||
{
|
||||
startPutcharSpy();
|
||||
|
||||
UnityPrintFloat(u.f_value); /*Twice as fast as sprintf 2**32-1e12, 10s vs 21s*/
|
||||
sprintf(expected, "%.8e", u.f_value);
|
||||
|
||||
int len = 11 - 1; /* 11th char is 'e' in exponential format */
|
||||
while (expected[len - 1] == '0' && expected[len - 2] != '.') { len --; }
|
||||
if (expected[14] != '\0') memmove(&expected[12], &expected[13], 3); /* Two char exponent */
|
||||
memmove(&expected[len], &expected[11 - 1], sizeof "e+09"); /* 5 char length */
|
||||
|
||||
if (strcmp(expected, getBufferPutcharSpy()) != 0)
|
||||
{
|
||||
wrong++;
|
||||
/* endPutcharSpy(); UnityPrint("Expected "); UnityPrint(expected);
|
||||
UnityPrint(" Was "); UnityPrint(getBufferPutcharSpy()); UNITY_OUTPUT_CHAR('\n'); */
|
||||
|
||||
if (wrong > 10 || (wrong > 3 && end <= 1e25f))
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, u.f_value);
|
||||
/* Empirical values from the current routine, don't be worse when making changes */
|
||||
}
|
||||
/* Fail with diagnostic printing */
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Exhaustive testing of all float values we differentiate when printing. Doubles
|
||||
* are not explored here -- too many. These tests confirm that the routine works
|
||||
* for all floats > 5e-7, positives only. Off by default due to test time.
|
||||
* Compares Unity's routine to your sprintf() C lib, tested to pass on 3 platforms.
|
||||
* Part1 takes a long time, around 3 minutes compiled with -O2
|
||||
* Runs through all floats from 0.000001 - 2**32, ~300 million values */
|
||||
void testAllFloatPrintingPart1_LessThan32Bits(void)
|
||||
void testFloatPrintingRandomSamples(void)
|
||||
{
|
||||
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
|
||||
AllFloatPrinting_LessThan32Bits();
|
||||
#if !defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) || !defined(USING_OUTPUT_SPY)
|
||||
TEST_IGNORE();
|
||||
#else
|
||||
TEST_IGNORE(); /* Ignore one of three */
|
||||
#endif
|
||||
}
|
||||
union { float f_value; uint32_t int_value; } u;
|
||||
|
||||
/* Test takes a long time, around 3.5 minutes compiled with -O2, try ~500 million values */
|
||||
void testAllFloatPrintingPart2_Larger(void)
|
||||
{
|
||||
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
|
||||
AllFloatPrinting_Larger(4294967296.0f, 1e25f);
|
||||
#endif
|
||||
}
|
||||
/* 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);
|
||||
|
||||
/* Test takes a long time, around 3.5 minutes compiled with -O2, try ~500 million values */
|
||||
void testAllFloatPrintingPart3_LargerStill(void)
|
||||
{
|
||||
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
|
||||
AllFloatPrinting_Larger(1e25f, 3.40282347e+38f);
|
||||
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
|
||||
}
|
||||
|
||||
|
|
@ -4893,35 +5252,20 @@ 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.100469", 0.10046949999999999);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4294967295.999999", 4294967295.999999);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967295.9999995);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 9999999995.0);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199254740990.0);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("7.0e+100", 7.0e+100);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("3.0e+200", 3.0e+200);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23456789e+300", 9.23456789e+300);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.10046949999999999);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967295.999999);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967295.9999995);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967296.0);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 9999999995.0);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.0072e+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.23457e+300", 9.23456789e+300);
|
||||
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.10046949999999999);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4294967295.999999", -4294967295.999999);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967295.9999995);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.0e+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("1.0e+10", 10000000050.0);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15", 9007199245000000.0);
|
||||
#endif
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.10046949999999999);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.29497e+09", -4294967295.999999);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.29497e+09", -4294967295.9999995);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7e+100", -7.0e+100);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -4930,10 +5274,10 @@ 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("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);
|
||||
TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0 / d_zero);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue