mirror/cJSON
1
0
Fork 0
mirror of https://github.com/DaveGamble/cJSON.git synced 2023-08-10 21:13:26 +03:00
Code Issues Projects Releases Wiki Activity

Update Unity to version v2.4.2

Browse Source 
Merge commit 'b7bfe1e91a0b55d72f849944d5a33b7962d7bf51' into develop
This commit is contained in:
Max Bruckner 2017-09-12 18:30:07 +02:00
commit acf80470f8
16 changed files with 830 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
tests/unity/README.md
View File

@ -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 Asserts that the actual value is within plus or minus delta of the expected value. This also comes in
size specific variants. 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 Arrays
------ ------

6
tests/unity/auto/generate_module.rb
View File

@ -172,7 +172,7 @@ class UnityModuleGenerator
when 'camel' then part1 when 'camel' then part1
when 'snake' then part1.downcase when 'snake' then part1.downcase
when 'caps' then part1.upcase when 'caps' then part1.upcase
else part1.downcase else part1
end end
else else
case (@options[:naming]) case (@options[:naming])
@ -180,7 +180,7 @@ class UnityModuleGenerator
when 'camel' then part1 + part2 when 'camel' then part1 + part2
when 'snake' then part1.downcase + '_' + part2.downcase when 'snake' then part1.downcase + '_' + part2.downcase
when 'caps' then part1.upcase + '_' + part2.upcase when 'caps' then part1.upcase + '_' + part2.upcase
else part1.downcase + '_' + part2.downcase else part1 + '_' + part2
end end
end end
end end
@ -290,7 +290,7 @@ if $0 == __FILE__
' -n"camel" sets the file naming convention.', ' -n"camel" sets the file naming convention.',
' bumpy - BumpyCaseFilenames.', ' bumpy - BumpyCaseFilenames.',
' camel - camelCaseFilenames.', ' camel - camelCaseFilenames.',
' snake - snake_case_filenames. (DEFAULT)', ' snake - snake_case_filenames.',
' caps - CAPS_CASE_FILENAMES.', ' caps - CAPS_CASE_FILENAMES.',
' -u update subversion too (requires subversion command line)', ' -u update subversion too (requires subversion command line)',
' -y"my.yml" selects a different yaml config file for module generation', ' -y"my.yml" selects a different yaml config file for module generation',

2
tests/unity/auto/generate_test_runner.rb
View File

@ -119,7 +119,7 @@ class UnityTestRunnerGenerator
source_index = 0 source_index = 0
tests_and_line_numbers.size.times do |i| tests_and_line_numbers.size.times do |i|
source_lines[source_index..-1].each_with_index do |line, index| 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 source_index += index
tests_and_line_numbers[i][:line_number] = source_index + 1 tests_and_line_numbers[i][:line_number] = source_index + 1
break break

0
tests/unity/auto/stylize_as_junit.rb Normal file → Executable file
View File

54
tests/unity/docs/UnityAssertionsReference.md
View File

@ -290,6 +290,60 @@ Asserts the specified bit of the `actual` parameter is high.
Asserts the specified bit of the `actual` parameter is low. 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) ### Integer Ranges (of all sizes)

10
tests/unity/examples/unity_config.h
View File

@ -201,10 +201,12 @@
* `stdout` option. You decide to route your test result output to a custom * `stdout` option. You decide to route your test result output to a custom
* serial `RS232_putc()` function you wrote like thus: * serial `RS232_putc()` function you wrote like thus:
*/ */
/* #define UNITY_OUTPUT_CHAR(a) RS232_putc(a) */ /* #define UNITY_OUTPUT_CHAR(a) RS232_putc(a) */
/* #define UNITY_OUTPUT_FLUSH() RS232_flush() */ /* #define UNITY_OUTPUT_CHAR_HEADER_DECLARATION RS232_putc(int) */
/* #define UNITY_OUTPUT_START() RS232_config(115200,1,8,0) */ /* #define UNITY_OUTPUT_FLUSH() RS232_flush() */
/* #define UNITY_OUTPUT_COMPLETE() RS232_close() */ /* #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 /* For some targets, Unity can make the otherwise required `setUp()` and
* `tearDown()` functions optional. This is a nice convenience for test writers * `tearDown()` functions optional. This is a nice convenience for test writers

2
tests/unity/extras/fixture/rakefile_helper.rb
View File

@ -53,7 +53,7 @@ module RakefileHelpers
defines = if $cfg['compiler']['defines']['items'].nil? defines = if $cfg['compiler']['defines']['items'].nil?
'' ''
else 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 end
options = squash('', $cfg['compiler']['options']) options = squash('', $cfg['compiler']['options'])
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items']) includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])

1
tests/unity/extras/fixture/test/Makefile
View File

@ -6,6 +6,7 @@ endif
CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror
CFLAGS += $(DEBUG) CFLAGS += $(DEBUG)
DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar DEFINES = -D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar
DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=UnityOutputCharSpy_OutputChar\(int\)
SRC = ../src/unity_fixture.c \ SRC = ../src/unity_fixture.c \
../../../src/unity.c \ ../../../src/unity.c \
unity_fixture_Test.c \ unity_fixture_Test.c \

2
tests/unity/release/build.info
View File

@ -1,2 +1,2 @@
120 121

2
tests/unity/release/version.info
View File

@ -1,2 +1,2 @@
2.4.1 2.4.2

216
tests/unity/src/unity.c
View File

@ -27,6 +27,8 @@ static const char UnityStrNull[] = "NULL";
static const char UnityStrSpacer[] = ". "; static const char UnityStrSpacer[] = ". ";
static const char UnityStrExpected[] = " Expected "; static const char UnityStrExpected[] = " Expected ";
static const char UnityStrWas[] = " Was "; 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 UnityStrElement[] = " Element ";
static const char UnityStrByte[] = " Byte "; static const char UnityStrByte[] = " Byte ";
static const char UnityStrMemory[] = " Memory Mismatch."; 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 #ifndef UNITY_EXCLUDE_FLOAT_PRINT
static void UnityPrintDecimalAndNumberWithLeadingZeros(UNITY_INT32 fraction_part, UNITY_INT32 divisor) /* This function prints a floating-point value in a format similar to
{ * printf("%.6g"). It can work with either single- or double-precision,
UNITY_OUTPUT_CHAR('.'); * but for simplicity, it prints only 6 significant digits in either case.
while (divisor > 0) * Printing more than 6 digits accurately is hard (at least in the single-
{ * precision case) and isn't attempted here. */
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);
*/
void UnityPrintFloat(const UNITY_DOUBLE input_number) 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('-'); UNITY_OUTPUT_CHAR('-');
number = -input_number; number = -number;
} else
{
number = input_number;
} }
if (isnan(number)) UnityPrint(UnityStrNaN); /* handle zero, NaN, and +/- infinity */
else if (isinf(number)) UnityPrintLen(UnityStrInf, 3); if (number == 0.0f) UnityPrint("0");
else if (number <= 0.0000005 && number > 0) UnityPrint("0.000000..."); /* Small number */ else if (isnan(number)) UnityPrint("nan");
else if (number < 4294967295.9999995) /* Rounded result fits in 32 bits, "%.6f" format */ else if (isinf(number)) UnityPrint("inf");
else
{ {
const UNITY_INT32 divisor = 1000000/10; int exponent = 0;
UNITY_UINT32 integer_part = (UNITY_UINT32)number; int decimals, digits;
UNITY_INT32 fraction_part = (UNITY_INT32)((number - (UNITY_DOUBLE)integer_part)*1000000.0 + 0.5); UNITY_INT32 n;
/* Double precision calculation gives best performance for six rounded decimal places */ char buf[16];
ROUND_TIES_TO_EVEN(number, fraction_part, (number - (UNITY_DOUBLE)integer_part)*1000000.0);
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; n = 100000;
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;
exponent++; 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); /* determine where to place decimal point */
UnityPrintDecimalAndNumberWithLeadingZeros(integer_part % divisor, divisor / 10); decimals = (exponent <= 0 && exponent >= -9) ? -exponent : 5;
UNITY_OUTPUT_CHAR('e'); exponent += decimals;
UNITY_OUTPUT_CHAR('+');
if (exponent < 10) UNITY_OUTPUT_CHAR('0'); /* truncate trailing zeroes after decimal point */
UnityPrintNumber(exponent); 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 */ #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() \ #define UnityPrintPointlessAndBail() \
{ \ { \
UnityTestResultsFailBegin(lineNumber); \ UnityTestResultsFailBegin(lineNumber); \
@ -1025,7 +1073,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
{ {
UNITY_UINT32 i = 0; UNITY_UINT32 i = 0;
UNITY_UINT32 j = 0; UNITY_UINT32 j = 0;
const char* exp = NULL; const char* expd = NULL;
const char* act = NULL; const char* act = NULL;
RETURN_IF_FAIL_OR_IGNORE; RETURN_IF_FAIL_OR_IGNORE;
@ -1048,7 +1096,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
if (flags != UNITY_ARRAY_TO_ARRAY) if (flags != UNITY_ARRAY_TO_ARRAY)
{ {
exp = (const char*)expected; expd = (const char*)expected;
} }
do do
@ -1056,15 +1104,15 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
act = actual[j]; act = actual[j];
if (flags == UNITY_ARRAY_TO_ARRAY) 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 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; Unity.CurrentTestFailed = 1;
break; break;
@ -1073,7 +1121,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
} }
else else
{ /* handle case of one pointers being null (if both null, test should pass) */ { /* handle case of one pointers being null (if both null, test should pass) */
if (exp != act) if (expd != act)
{ {
Unity.CurrentTestFailed = 1; Unity.CurrentTestFailed = 1;
} }
@ -1087,7 +1135,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
UnityPrint(UnityStrElement); UnityPrint(UnityStrElement);
UnityPrintNumberUnsigned(j); UnityPrintNumberUnsigned(j);
} }
UnityPrintExpectedAndActualStrings(exp, act); UnityPrintExpectedAndActualStrings(expd, act);
UnityAddMsgIfSpecified(msg); UnityAddMsgIfSpecified(msg);
UNITY_FAIL_AND_BAIL; UNITY_FAIL_AND_BAIL;
} }

60
tests/unity/src/unity.h
View File

@ -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_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) #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) */ /* 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_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) #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_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) #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 */ /* 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_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) #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_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)) #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) */ /* 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_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)) #define TEST_ASSERT_INT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message))

54
tests/unity/src/unity_internals.h
View File

@ -244,8 +244,8 @@ typedef UNITY_FLOAT_TYPE UNITY_FLOAT;
#define UNITY_OUTPUT_CHAR(a) (void)putchar(a) #define UNITY_OUTPUT_CHAR(a) (void)putchar(a)
#else #else
/* If defined as something else, make sure we declare it here so it's ready for use */ /* If defined as something else, make sure we declare it here so it's ready for use */
#ifndef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION #ifdef UNITY_OUTPUT_CHAR_HEADER_DECLARATION
extern void UNITY_OUTPUT_CHAR(int); extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION;
#endif #endif
#endif #endif
@ -253,22 +253,22 @@ extern void UNITY_OUTPUT_CHAR(int);
#ifdef UNITY_USE_FLUSH_STDOUT #ifdef UNITY_USE_FLUSH_STDOUT
/* We want to use the stdout flush utility */ /* We want to use the stdout flush utility */
#include <stdio.h> #include <stdio.h>
#define UNITY_OUTPUT_FLUSH (void)fflush(stdout) #define UNITY_OUTPUT_FLUSH() (void)fflush(stdout)
#else #else
/* We've specified nothing, therefore flush should just be ignored */ /* We've specified nothing, therefore flush should just be ignored */
#define UNITY_OUTPUT_FLUSH #define UNITY_OUTPUT_FLUSH()
#endif #endif
#else #else
/* We've defined flush as something else, so make sure we declare it here so it's ready for use */ /* 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 #ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION
extern void UNITY_OUTPUT_FLUSH(void); extern void UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION;
#endif #endif
#endif #endif
#ifndef UNITY_OUTPUT_FLUSH #ifndef UNITY_OUTPUT_FLUSH
#define UNITY_FLUSH_CALL() #define UNITY_FLUSH_CALL()
#else #else
#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH #define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH()
#endif #endif
#ifndef UNITY_PRINT_EOL #ifndef UNITY_PRINT_EOL
@ -453,6 +453,18 @@ void UnityAssertEqualNumber(const UNITY_INT expected,
const UNITY_LINE_TYPE lineNumber, const UNITY_LINE_TYPE lineNumber,
const UNITY_DISPLAY_STYLE_T style); 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, void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
UNITY_INTERNAL_PTR actual, UNITY_INTERNAL_PTR actual,
const UNITY_UINT32 num_elements, 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_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_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_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_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) #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)

1
tests/unity/test/Makefile
View File

@ -14,6 +14,7 @@ CFLAGS += -Wbad-function-cast -Wcast-qual -Wold-style-definition -Wshadow -Wstri
#DEBUG = -O0 -g #DEBUG = -O0 -g
CFLAGS += $(DEBUG) CFLAGS += $(DEBUG)
DEFINES = -D UNITY_OUTPUT_CHAR=putcharSpy DEFINES = -D UNITY_OUTPUT_CHAR=putcharSpy
DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\)
DEFINES += -D UNITY_SUPPORT_64 -D UNITY_INCLUDE_DOUBLE DEFINES += -D UNITY_SUPPORT_64 -D UNITY_INCLUDE_DOUBLE
SRC = ../src/unity.c tests/testunity.c build/testunityRunner.c SRC = ../src/unity.c tests/testunity.c build/testunityRunner.c
INC_DIR = -I ../src INC_DIR = -I ../src

2
tests/unity/test/rakefile_helper.rb
View File

@ -91,7 +91,7 @@ module RakefileHelpers
defines = if $cfg['compiler']['defines']['items'].nil? defines = if $cfg['compiler']['defines']['items'].nil?
'' ''
else 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 end
options = squash('', $cfg['compiler']['options']) options = squash('', $cfg['compiler']['options'])
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items']) includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])

676
tests/unity/test/tests/testunity.c
View File

@ -764,8 +764,9 @@ void testNotEqualBitsLow(void)
EXPECT_ABORT_BEGIN EXPECT_ABORT_BEGIN
TEST_ASSERT_BITS_LOW(v0, v1); TEST_ASSERT_BITS_LOW(v0, v1);
VERIFY_FAILS_END VERIFY_FAILS_END
} }
void testEqualShorts(void) void testEqualShorts(void)
{ {
short v0, v1; short v0, v1;
@ -1305,6 +1306,415 @@ void testINT8sNotWithinDeltaAndCustomMessage(void)
VERIFY_FAILS_END 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) void testEqualStrings(void)
{ {
const char *testString = "foo"; const char *testString = "foo";
@ -4056,61 +4466,46 @@ void testFloatPrinting(void)
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY) #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE(); TEST_IGNORE();
#else #else
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0", 0.0f); TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.000000...", 0.000000499f); TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.000001", 0.00000050000005f); TEST_ASSERT_EQUAL_PRINT_FLOATING("5e-07", 0.00000050000005f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.100469499f); 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.9999995f); /*Rounding to int place*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0", 1.0f); TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25f); 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("7.99999", 7.99999f); /*Not rounding*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.000002", 16.000002f); TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0002", 16.0002f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.000004", 16.000004f); TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0004", 16.0004f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("16.000006", 16.000006f); TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0006", 16.0006f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("4294967040.0", 4294967040.0f); /*Last full print integer*/ 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", -0.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.000000...",-0.000000499f); TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.000001", -0.00000050000005f); TEST_ASSERT_EQUAL_PRINT_FLOATING("-5e-07", -0.00000050000005f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.100469499f); 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.9999995f); /*Rounding to int place*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0", -1.0f); TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25f); 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("-7.99999", -7.99999f); /*Not rounding*/
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000002", -16.000002f); TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0002", -16.0002f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000004", -16.000004f); TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0004", -16.0004f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000006", -16.000006f); TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0006", -16.0006f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4294967040.0",-4294967040.0f); /*Last full print integer*/ 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("4.29497e+09", 4294967296.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("5.0e+09", 5000000000.0f); TEST_ASSERT_EQUAL_PRINT_FLOATING("5e+09", 5000000000.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("8.0e+09", 8.0e+09f); TEST_ASSERT_EQUAL_PRINT_FLOATING("8e+09", 8.0e+09f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("8.3099991e+09", 8309999104.0f); TEST_ASSERT_EQUAL_PRINT_FLOATING("8.31e+09", 8309999104.0f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 1.0e+10f); TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 1.0e+10f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 10000000000.0f); TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000000.0f);
/* Some compilers have trouble with inexact float constants, a float cast works generally */ /* 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.00005e+10", (float)1.000054e+10f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.10000006e+38", (float)1.10000005e+38f); TEST_ASSERT_EQUAL_PRINT_FLOATING("1.1e+38", (float)1.10000005e+38f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.63529943e+10", 1.63529943e+10f); TEST_ASSERT_EQUAL_PRINT_FLOATING("1.6353e+10", 1.63529943e+10f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("3.40282347e+38", 3.40282346638e38f); 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("-1e+10", -1.0e+10f);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.40282347e+38",-3.40282346638e38f); TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.40282e+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
#endif #endif
} }
@ -4119,105 +4514,69 @@ void testFloatPrintingInfinityAndNaN(void)
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY) #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE(); TEST_IGNORE();
#else #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 #endif
} }
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY) #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]; char expected[18];
union { float f_value; int32_t int_value; } u; char expected_lower[18];
/* Float representations are laid out in integer order, walk up the list */ char expected_higher[18];
for (u.f_value = 0.00000050000005f; u.f_value <= 4294967040.0f; u.int_value += 1)
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(); /* Fail with diagnostic printing */
TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f);
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 */
}
} }
} }
#endif #endif
/* Exhaustive testing of all float values we differentiate when printing. Doubles void testFloatPrintingRandomSamples(void)
* 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)
{ {
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY) #if !defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) || !defined(USING_OUTPUT_SPY)
AllFloatPrinting_LessThan32Bits(); TEST_IGNORE();
#else #else
TEST_IGNORE(); /* Ignore one of three */ union { float f_value; uint32_t int_value; } u;
#endif
}
/* Test takes a long time, around 3.5 minutes compiled with -O2, try ~500 million values */ /* These values are not covered by the MINSTD generator */
void testAllFloatPrintingPart2_Larger(void) u.int_value = 0x00000000; printFloatValue(u.f_value);
{ u.int_value = 0x80000000; printFloatValue(u.f_value);
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY) u.int_value = 0x7fffffff; printFloatValue(u.f_value);
AllFloatPrinting_Larger(4294967296.0f, 1e25f); u.int_value = 0xffffffff; printFloatValue(u.f_value);
#endif
}
/* Test takes a long time, around 3.5 minutes compiled with -O2, try ~500 million values */ uint32_t a = 1;
void testAllFloatPrintingPart3_LargerStill(void) for(int num_tested = 0; num_tested < 1000000; num_tested++)
{ {
#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY) /* MINSTD pseudo-random number generator */
AllFloatPrinting_Larger(1e25f, 3.40282347e+38f); 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 #endif
} }
@ -4893,35 +5252,20 @@ void testDoublePrinting(void)
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE(); TEST_IGNORE();
#else #else
TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.10046949999999999); TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469", 0.10046949999999999);
TEST_ASSERT_EQUAL_PRINT_FLOATING("4294967295.999999", 4294967295.999999); TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967295.999999);
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967295.9999995); TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967295.9999995);
TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0); TEST_ASSERT_EQUAL_PRINT_FLOATING("4.29497e+09", 4294967296.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10", 9999999995.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("9.0072e+15", 9007199254740990.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("7.0e+100", 7.0e+100); TEST_ASSERT_EQUAL_PRINT_FLOATING("7e+100", 7.0e+100);
TEST_ASSERT_EQUAL_PRINT_FLOATING("3.0e+200", 3.0e+200); 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("9.23457e+300", 9.23456789e+300);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.10046949999999999); TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469", -0.10046949999999999);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4294967295.999999", -4294967295.999999); TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.29497e+09", -4294967295.999999);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967295.9999995); TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.29497e+09", -4294967295.9999995);
TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.0e+100", -7.0e+100); 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("1.0e+10", 10000000050.0);
TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15", 9007199245000000.0);
#endif
#endif #endif
} }
@ -4930,10 +5274,10 @@ void testDoublePrintingInfinityAndNaN(void)
#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
TEST_IGNORE(); TEST_IGNORE();
#else #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 #endif
} }