Apostolos Fanakis
6 years ago
132 changed files with 24252 additions and 67 deletions
@ -1,49 +1,121 @@ |
|||
SHELL := /bin/bash |
|||
ifeq ($(OS),Windows_NT) |
|||
ifeq ($(shell uname -s),) # not in a bash-like shell |
|||
CLEANUP = del /F /Q |
|||
MKDIR = mkdir |
|||
else # in a bash-like shell, like msys |
|||
CLEANUP = rm -f |
|||
MKDIR = mkdir -p |
|||
endif |
|||
TARGET_EXTENSION=.exe |
|||
else |
|||
CLEANUP = rm -f |
|||
MKDIR = mkdir -p |
|||
TARGET_EXTENSION=out |
|||
endif |
|||
|
|||
CC = gcc -std=gnu99 |
|||
RM = rm -f |
|||
CFLAGS_DEBUG=-O0 -ggdb3 -Wall -Werror -pedantic -D_FORTIFY_SOURCE=2 -fasynchronous-unwind-tables -grecord-gcc-switches -Werror=implicit-function-declaration -I. |
|||
CFLAGS=-O2 -Wall -Werror -pedantic -I. |
|||
.PHONY: runners |
|||
.PHONY: clean |
|||
.PHONY: test |
|||
|
|||
TESTS_SRC = $(wildcard test/*.c) |
|||
EXECS_SRC = $(wildcard zaqar/*.c) |
|||
DEPS_SRC = $(wildcard lib/*.c) |
|||
PATHU = unity/src/ |
|||
PATHS = src/ |
|||
PATHT = test/ |
|||
PATHTR = test/runners/ |
|||
PATHL = lib/ |
|||
PATHB = build/ |
|||
PATHD = build/depends/ |
|||
PATHO = build/objs/ |
|||
PATHR = build/results/ |
|||
|
|||
DEPS_OBJ = $(DEPS_SRC:.c=.o) |
|||
TESTS_OBJ = $(DEPS_OBJ) \
|
|||
$(TESTS_SRC:.c=.o) |
|||
EXECS_OBJ = $(DEPS_OBJ) \
|
|||
$(EXECS_SRC:.c=.o) |
|||
ALL_OBJ = $(DEPS_OBJ) \
|
|||
$(TESTS_SRC:.c=.o) \
|
|||
$(EXECS_SRC:.c=.o) |
|||
BUILD_PATHS = $(PATHB) $(PATHD) $(PATHO) $(PATHR) $(PATHL) |
|||
|
|||
DEPS_TRACK = $(OBJ:.o=.d) |
|||
RUNNERS = $(patsubst $(PATHT)%.c,$(PATHTR)%_Runner.c, $(wildcard $(PATHT)*.c)) |
|||
|
|||
TESTS = test/test_circ_buff |
|||
EXECUTABLES = zaqar |
|||
runners: $(RUNNERS) test |
|||
|
|||
.PHONY: all |
|||
SRCTR = $(wildcard $(PATHTR)*.c) |
|||
|
|||
all: $(TESTS) $(EXECUTABLES) |
|||
execs: $(EXECUTABLES) |
|||
tests: $(TESTS) |
|||
COMPILE = gcc -c |
|||
LINK = gcc |
|||
DEPEND = gcc -MM -MG -MF |
|||
CFLAGS = -I. -I$(PATHU) -I$(PATHS) -I$(PATHL) -DTEST |
|||
|
|||
$(TESTS): $(TESTS_OBJ) |
|||
$(CC) -o $@ $^ $(CFLAGS) |
|||
CFLAGS += -std=c99 |
|||
CFLAGS += -Wall |
|||
CFLAGS += -Wextra |
|||
CFLAGS += -Wpointer-arith |
|||
CFLAGS += -Wcast-align |
|||
# CFLAGS += -Wwrite-strings
|
|||
CFLAGS += -Wswitch-default |
|||
CFLAGS += -Wunreachable-code |
|||
CFLAGS += -Winit-self |
|||
CFLAGS += -Wmissing-field-initializers |
|||
CFLAGS += -Wno-unknown-pragmas |
|||
CFLAGS += -Wstrict-prototypes |
|||
CFLAGS += -Wundef |
|||
CFLAGS += -Wold-style-definition |
|||
|
|||
$(EXECUTABLES): $(EXECS_OBJ) |
|||
$(CC) -o $@ $^ $(CFLAGS) |
|||
RESULTS = $(patsubst $(PATHTR)test_%_Runner.c,$(PATHR)test_%.txt,$(SRCTR)) |
|||
|
|||
-include $(DEPS_TRACK) |
|||
PASSED = `grep -s PASS $(PATHR)*.txt` |
|||
FAIL = `grep -s FAIL $(PATHR)*.txt` |
|||
IGNORE = `grep -s IGNORE $(PATHR)*.txt` |
|||
|
|||
%.d: %.c |
|||
@$(CPP) $(CFLAGS) $< -MM -MT $(@:.d=.o) >$@ |
|||
test: $(BUILD_PATHS) $(RESULTS) |
|||
@echo "===============UNIT TEST RESULTS===============\n" |
|||
@echo "---------------IGNORES---------------" |
|||
@echo "$(IGNORE)" |
|||
@echo "---------------FAILURES---------------" |
|||
@echo "$(FAIL)" |
|||
@echo "---------------PASSED---------------" |
|||
@echo "$(PASSED)" |
|||
@echo "\nDONE" |
|||
|
|||
$(PATHR)%.txt: $(PATHB)%.$(TARGET_EXTENSION) |
|||
-./$< > $@ 2>&1 |
|||
|
|||
$(PATHB)test_%.$(TARGET_EXTENSION): $(PATHO)test_%.o $(PATHO)test_%_Runner.o $(PATHO)%.o $(PATHU)unity.o #$(PATHD)test_%.d
|
|||
$(LINK) -o $@ $^ |
|||
|
|||
$(PATHO)%.o: $(PATHTR)%.c |
|||
$(COMPILE) $(CFLAGS) $< -o $@ |
|||
|
|||
$(PATHO)%.o:: $(PATHT)%.c |
|||
$(COMPILE) $(CFLAGS) $< -o $@ |
|||
|
|||
$(PATHO)%.o:: $(PATHS)%.c |
|||
$(COMPILE) $(CFLAGS) $< -o $@ |
|||
|
|||
$(PATHO)%.o:: $(PATHL)%.c |
|||
$(COMPILE) $(CFLAGS) $< -o $@ |
|||
|
|||
$(PATHO)%.o:: $(PATHU)%.c $(PATHU)%.h |
|||
$(COMPILE) $(CFLAGS) $< -o $@ |
|||
|
|||
$(PATHD)%.d:: $(PATHT)%.c |
|||
$(DEPEND) $@ $< |
|||
|
|||
$(PATHTR)%.c: |
|||
ruby unity/auto/generate_test_runner.rb $(patsubst $(PATHTR)%_Runner.c,$(PATHT)%.c, $@) $@ |
|||
|
|||
$(PATHB): |
|||
$(MKDIR) $(PATHB) |
|||
|
|||
$(PATHD): |
|||
$(MKDIR) $(PATHD) |
|||
|
|||
$(PATHO): |
|||
$(MKDIR) $(PATHO) |
|||
|
|||
$(PATHR): |
|||
$(MKDIR) $(PATHR) |
|||
|
|||
.PHONY: clean |
|||
clean: |
|||
rm -f $(ALL_OBJ) $(TESTS) $(EXECUTABLES) |
|||
$(CLEANUP) $(PATHO)*.o |
|||
$(CLEANUP) $(PATHB)*.$(TARGET_EXTENSION) |
|||
$(CLEANUP) $(PATHR)*.txt |
|||
|
|||
.PHONY: cleandep |
|||
cleandep: |
|||
rm -f $(DEPS_TRACK) |
|||
.PRECIOUS: $(PATHB)test_%.$(TARGET_EXTENSION) |
|||
.PRECIOUS: $(PATHD)%.d |
|||
.PRECIOUS: $(PATHO)%.o |
|||
.PRECIOUS: $(PATHR)%.txt |
|||
|
@ -0,0 +1,92 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
UNITY_EXEC_TIME_START(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
} \ |
|||
UNITY_EXEC_TIME_STOP(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#ifdef __WIN32__ |
|||
#define UNITY_INCLUDE_SETUP_STUBS |
|||
#endif |
|||
#include "unity.h" |
|||
#ifndef UNITY_EXCLUDE_SETJMP_H |
|||
#include <setjmp.h> |
|||
#endif |
|||
#include <stdio.h> |
|||
#include "circ_buff.h" |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <stdint.h> |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_circ_buf_init(void); |
|||
extern void test_circ_buf_put(void); |
|||
extern void test_circ_buf_get(void); |
|||
extern void test_circ_buf_empty(void); |
|||
extern void test_circ_buf_full(void); |
|||
extern void test_circ_buf_capacity(void); |
|||
extern void test_circ_buf_size(void); |
|||
extern void test_circ_buf_reset(void); |
|||
|
|||
|
|||
/*=======Suite Setup=====*/ |
|||
static void suite_setup(void) |
|||
{ |
|||
#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA) |
|||
suiteSetUp(); |
|||
#endif |
|||
} |
|||
|
|||
/*=======Suite Teardown=====*/ |
|||
static int suite_teardown(int num_failures) |
|||
{ |
|||
#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA) |
|||
return suiteTearDown(num_failures); |
|||
#else |
|||
return num_failures; |
|||
#endif |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
tearDown(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
suite_setup(); |
|||
UnityBegin("test/test_circ_buff.c"); |
|||
RUN_TEST(test_circ_buf_init, 17); |
|||
RUN_TEST(test_circ_buf_put, 29); |
|||
RUN_TEST(test_circ_buf_get, 73); |
|||
RUN_TEST(test_circ_buf_empty, 110); |
|||
RUN_TEST(test_circ_buf_full, 142); |
|||
RUN_TEST(test_circ_buf_capacity, 164); |
|||
RUN_TEST(test_circ_buf_size, 191); |
|||
RUN_TEST(test_circ_buf_reset, 220); |
|||
|
|||
return suite_teardown(UnityEnd()); |
|||
} |
@ -0,0 +1,27 @@ |
|||
############################################################################### |
|||
# Unity Project - A Test Framework for C |
|||
# .editorconfig - F. Zahn 2019 |
|||
############################################################################### |
|||
|
|||
# This is the topmost .editorconfig file |
|||
root = true |
|||
|
|||
# Settings that apply to all languages / files |
|||
[*] |
|||
charset = utf-8 |
|||
indent_size = 4 |
|||
indent_style = space |
|||
insert_final_newline = true |
|||
trim_trailing_whitespace = true |
|||
|
|||
[*.md] |
|||
trim_trailing_whitespace = false |
|||
|
|||
[*.txt] |
|||
trim_trailing_whitespace = false |
|||
|
|||
[*.rb] |
|||
indent_size = 2 |
|||
|
|||
[*.yml] |
|||
indent_size = 2 |
@ -0,0 +1,30 @@ |
|||
* text=auto |
|||
|
|||
# These files are text and should be normalized (convert crlf to lf) |
|||
*.rb text |
|||
*.test text |
|||
*.c text |
|||
*.cpp text |
|||
*.h text |
|||
*.txt text |
|||
*.yml text |
|||
*.s79 text |
|||
*.bat text |
|||
*.xcl text |
|||
*.inc text |
|||
*.info text |
|||
*.md text |
|||
makefile text |
|||
rakefile text |
|||
|
|||
|
|||
#These files are binary and should not be normalized |
|||
*.doc binary |
|||
*.odt binary |
|||
*.pdf binary |
|||
*.ewd binary |
|||
*.eww binary |
|||
*.dni binary |
|||
*.wsdt binary |
|||
*.dbgdt binary |
|||
*.mac binary |
@ -0,0 +1,9 @@ |
|||
build/ |
|||
test/sandbox |
|||
.DS_Store |
|||
examples/example_1/test1.exe |
|||
examples/example_1/test2.exe |
|||
examples/example_2/all_tests.exe |
|||
examples/example_1/test1.out |
|||
examples/example_1/test2.out |
|||
examples/example_2/all_tests.out |
@ -0,0 +1,29 @@ |
|||
language: c |
|||
|
|||
matrix: |
|||
include: |
|||
- os: osx |
|||
compiler: clang |
|||
osx_image: xcode7.3 |
|||
- os: linux |
|||
dist: trusty |
|||
compiler: gcc |
|||
|
|||
before_install: |
|||
- if [ "$TRAVIS_OS_NAME" == "osx" ]; then rvm install 2.3 && rvm use 2.3 && ruby -v; fi |
|||
- if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install --assume-yes --quiet gcc-multilib; fi |
|||
install: |
|||
- gem install rspec |
|||
- gem install rubocop -v 0.57.2 |
|||
script: |
|||
- cd test && rake ci |
|||
- make -s |
|||
- make -s DEBUG=-m32 #32-bit architecture with 64-bit support |
|||
- make -s DEBUG=-m32 UNITY_SUPPORT_64= #32-bit build without 64-bit types |
|||
- make -s UNITY_INCLUDE_DOUBLE= # without double |
|||
- cd ../extras/fixture/test && rake ci |
|||
- make -s default noStdlibMalloc |
|||
- make -s C89 |
|||
- cd ../../../examples/example_1 && make -s ci |
|||
- cd ../example_2 && make -s ci |
|||
- cd ../example_3 && rake |
@ -0,0 +1,70 @@ |
|||
##################################################### |
|||
# FILE NAME CMakeLists.txt # |
|||
# # |
|||
# WRITTEN BY Michael Brockus. # |
|||
# # |
|||
# PURPOSE contains CMake statements. # |
|||
# # |
|||
##################################################### |
|||
cmake_minimum_required(VERSION 3.13.2.0 FATAL_ERROR) |
|||
|
|||
|
|||
|
|||
# |
|||
# CMake: Declare project |
|||
# |
|||
project(unity LANGUAGES C DESCRIPTION "C Unit testing framework.") |
|||
|
|||
|
|||
|
|||
# |
|||
# CMake: Creation of library |
|||
# |
|||
add_library("unity" STATIC) |
|||
|
|||
|
|||
|
|||
# |
|||
# CMake: Adding source to target |
|||
# |
|||
target_sources("unity" PRIVATE "src/unity.c") |
|||
|
|||
|
|||
|
|||
# |
|||
# CMake: Including directories to target |
|||
# |
|||
target_include_directories("unity" |
|||
PUBLIC |
|||
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>" |
|||
"$<INSTALL_INTERFACE:src>" |
|||
|
|||
PRIVATE "src" |
|||
) |
|||
|
|||
|
|||
|
|||
# |
|||
# CMake: Give target an alias |
|||
# |
|||
add_library("unity::framework" ALIAS "unity") |
|||
|
|||
|
|||
|
|||
# |
|||
# CMake: export project |
|||
# |
|||
install(TARGETS "unity" EXPORT "unityConfig" |
|||
ARCHIVE DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/${CMAKE_INSTALL_LIBDIR}" |
|||
LIBRARY DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/${CMAKE_INSTALL_LIBDIR}" |
|||
RUNTIME DESTINATION "${CMAKE_CURRENT_SOURCE_DIR}/${CMAKE_INSTALL_BINDIR}" |
|||
|
|||
INCLUDES DESTINATION "${CMAKE_INSTALL_LIBDIR}" |
|||
) |
|||
|
|||
install(DIRECTORY src/ DESTINATION src) |
|||
|
|||
install(EXPORT unityConfig DESTINATION share/unityConfig/cmake) |
|||
|
|||
# This makes the project importable from the build directory |
|||
export(TARGETS unity FILE unityConfig.cmake) |
@ -0,0 +1,21 @@ |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) <year> 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|||
of this software and associated documentation files (the "Software"), to deal |
|||
in the Software without restriction, including without limitation the rights |
|||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|||
copies of the Software, and to permit persons to whom the Software is |
|||
furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|||
THE SOFTWARE. |
@ -0,0 +1,191 @@ |
|||
Unity Test API |
|||
============== |
|||
|
|||
[![Unity Build Status](https://api.travis-ci.org/ThrowTheSwitch/Unity.png?branch=master)](https://travis-ci.org/ThrowTheSwitch/Unity) |
|||
__Copyright (c) 2007 - 2019 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams__ |
|||
|
|||
Getting Started |
|||
=============== |
|||
The [docs](docs/) folder contains a [getting started guide](docs/UnityGettingStartedGuide.md) |
|||
and much more tips about using Unity. |
|||
|
|||
Unity Assertion Summary |
|||
======================= |
|||
For the full list, see [UnityAssertionsReference.md](docs/UnityAssertionsReference.md). |
|||
|
|||
Basic Validity Tests |
|||
-------------------- |
|||
|
|||
TEST_ASSERT_TRUE(condition) |
|||
|
|||
Evaluates whatever code is in condition and fails if it evaluates to false |
|||
|
|||
TEST_ASSERT_FALSE(condition) |
|||
|
|||
Evaluates whatever code is in condition and fails if it evaluates to true |
|||
|
|||
TEST_ASSERT(condition) |
|||
|
|||
Another way of calling `TEST_ASSERT_TRUE` |
|||
|
|||
TEST_ASSERT_UNLESS(condition) |
|||
|
|||
Another way of calling `TEST_ASSERT_FALSE` |
|||
|
|||
TEST_FAIL() |
|||
TEST_FAIL_MESSAGE(message) |
|||
|
|||
This test is automatically marked as a failure. The message is output stating why. |
|||
|
|||
Numerical Assertions: Integers |
|||
------------------------------ |
|||
|
|||
TEST_ASSERT_EQUAL_INT(expected, actual) |
|||
TEST_ASSERT_EQUAL_INT8(expected, actual) |
|||
TEST_ASSERT_EQUAL_INT16(expected, actual) |
|||
TEST_ASSERT_EQUAL_INT32(expected, actual) |
|||
TEST_ASSERT_EQUAL_INT64(expected, actual) |
|||
|
|||
Compare two integers for equality and display errors as signed integers. A cast will be performed |
|||
to your natural integer size so often this can just be used. When you need to specify the exact size, |
|||
like when comparing arrays, you can use a specific version: |
|||
|
|||
TEST_ASSERT_EQUAL_UINT(expected, actual) |
|||
TEST_ASSERT_EQUAL_UINT8(expected, actual) |
|||
TEST_ASSERT_EQUAL_UINT16(expected, actual) |
|||
TEST_ASSERT_EQUAL_UINT32(expected, actual) |
|||
TEST_ASSERT_EQUAL_UINT64(expected, actual) |
|||
|
|||
Compare two integers for equality and display errors as unsigned integers. Like INT, there are |
|||
variants for different sizes also. |
|||
|
|||
TEST_ASSERT_EQUAL_HEX(expected, actual) |
|||
TEST_ASSERT_EQUAL_HEX8(expected, actual) |
|||
TEST_ASSERT_EQUAL_HEX16(expected, actual) |
|||
TEST_ASSERT_EQUAL_HEX32(expected, actual) |
|||
TEST_ASSERT_EQUAL_HEX64(expected, actual) |
|||
|
|||
Compares two integers for equality and display errors as hexadecimal. Like the other integer comparisons, |
|||
you can specify the size... here the size will also effect how many nibbles are shown (for example, `HEX16` |
|||
will show 4 nibbles). |
|||
|
|||
TEST_ASSERT_EQUAL(expected, actual) |
|||
|
|||
Another way of calling TEST_ASSERT_EQUAL_INT |
|||
|
|||
TEST_ASSERT_INT_WITHIN(delta, expected, actual) |
|||
|
|||
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 |
|||
------ |
|||
|
|||
_ARRAY |
|||
|
|||
You can append `_ARRAY` to any of these macros to make an array comparison of that type. Here you will |
|||
need to care a bit more about the actual size of the value being checked. You will also specify an |
|||
additional argument which is the number of elements to compare. For example: |
|||
|
|||
TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, elements) |
|||
|
|||
_EACH_EQUAL |
|||
|
|||
Another array comparison option is to check that EVERY element of an array is equal to a single expected |
|||
value. You do this by specifying the EACH_EQUAL macro. For example: |
|||
|
|||
TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, elements) |
|||
|
|||
Numerical Assertions: Bitwise |
|||
----------------------------- |
|||
|
|||
TEST_ASSERT_BITS(mask, expected, actual) |
|||
|
|||
Use an integer mask to specify which bits should be compared between two other integers. High bits in the mask are compared, low bits ignored. |
|||
|
|||
TEST_ASSERT_BITS_HIGH(mask, actual) |
|||
|
|||
Use an integer mask to specify which bits should be inspected to determine if they are all set high. High bits in the mask are compared, low bits ignored. |
|||
|
|||
TEST_ASSERT_BITS_LOW(mask, actual) |
|||
|
|||
Use an integer mask to specify which bits should be inspected to determine if they are all set low. High bits in the mask are compared, low bits ignored. |
|||
|
|||
TEST_ASSERT_BIT_HIGH(bit, actual) |
|||
|
|||
Test a single bit and verify that it is high. The bit is specified 0-31 for a 32-bit integer. |
|||
|
|||
TEST_ASSERT_BIT_LOW(bit, actual) |
|||
|
|||
Test a single bit and verify that it is low. The bit is specified 0-31 for a 32-bit integer. |
|||
|
|||
Numerical Assertions: Floats |
|||
---------------------------- |
|||
|
|||
TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) |
|||
|
|||
Asserts that the actual value is within plus or minus delta of the expected value. |
|||
|
|||
TEST_ASSERT_EQUAL_FLOAT(expected, actual) |
|||
TEST_ASSERT_EQUAL_DOUBLE(expected, actual) |
|||
|
|||
Asserts that two floating point values are "equal" within a small % delta of the expected value. |
|||
|
|||
String Assertions |
|||
----------------- |
|||
|
|||
TEST_ASSERT_EQUAL_STRING(expected, actual) |
|||
|
|||
Compare two null-terminate strings. Fail if any character is different or if the lengths are different. |
|||
|
|||
TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) |
|||
|
|||
Compare two strings. Fail if any character is different, stop comparing after len characters. |
|||
|
|||
TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) |
|||
|
|||
Compare two null-terminate strings. Fail if any character is different or if the lengths are different. Output a custom message on failure. |
|||
|
|||
TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) |
|||
|
|||
Compare two strings. Fail if any character is different, stop comparing after len characters. Output a custom message on failure. |
|||
|
|||
Pointer Assertions |
|||
------------------ |
|||
|
|||
Most pointer operations can be performed by simply using the integer comparisons above. However, a couple of special cases are added for clarity. |
|||
|
|||
TEST_ASSERT_NULL(pointer) |
|||
|
|||
Fails if the pointer is not equal to NULL |
|||
|
|||
TEST_ASSERT_NOT_NULL(pointer) |
|||
|
|||
Fails if the pointer is equal to NULL |
|||
|
|||
Memory Assertions |
|||
----------------- |
|||
|
|||
TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) |
|||
|
|||
Compare two blocks of memory. This is a good generic assertion for types that can't be coerced into acting like |
|||
standard types... but since it's a memory compare, you have to be careful that your data types are packed. |
|||
|
|||
_MESSAGE |
|||
-------- |
|||
|
|||
you can append _MESSAGE to any of the macros to make them take an additional argument. This argument |
|||
is a string that will be printed at the end of the failure strings. This is useful for specifying more |
|||
information about the problem. |
|||
|
@ -0,0 +1,118 @@ |
|||
# ========================================== |
|||
# Unity Project - A Test Framework for C |
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
# [Released under MIT License. Please refer to license.txt for details] |
|||
# ========================================== |
|||
|
|||
if RUBY_PLATFORM =~ /(win|w)32$/ |
|||
begin |
|||
require 'Win32API' |
|||
rescue LoadError |
|||
puts 'ERROR! "Win32API" library not found' |
|||
puts '"Win32API" is required for colour on a windows machine' |
|||
puts ' try => "gem install Win32API" on the command line' |
|||
puts |
|||
end |
|||
# puts |
|||
# puts 'Windows Environment Detected...' |
|||
# puts 'Win32API Library Found.' |
|||
# puts |
|||
end |
|||
|
|||
class ColourCommandLine |
|||
def initialize |
|||
return unless RUBY_PLATFORM =~ /(win|w)32$/ |
|||
get_std_handle = Win32API.new('kernel32', 'GetStdHandle', ['L'], 'L') |
|||
@set_console_txt_attrb = |
|||
Win32API.new('kernel32', 'SetConsoleTextAttribute', %w[L N], 'I') |
|||
@hout = get_std_handle.call(-11) |
|||
end |
|||
|
|||
def change_to(new_colour) |
|||
if RUBY_PLATFORM =~ /(win|w)32$/ |
|||
@set_console_txt_attrb.call(@hout, win32_colour(new_colour)) |
|||
else |
|||
"\033[30;#{posix_colour(new_colour)};22m" |
|||
end |
|||
end |
|||
|
|||
def win32_colour(colour) |
|||
case colour |
|||
when :black then 0 |
|||
when :dark_blue then 1 |
|||
when :dark_green then 2 |
|||
when :dark_cyan then 3 |
|||
when :dark_red then 4 |
|||
when :dark_purple then 5 |
|||
when :dark_yellow, :narrative then 6 |
|||
when :default_white, :default, :dark_white then 7 |
|||
when :silver then 8 |
|||
when :blue then 9 |
|||
when :green, :success then 10 |
|||
when :cyan, :output then 11 |
|||
when :red, :failure then 12 |
|||
when :purple then 13 |
|||
when :yellow then 14 |
|||
when :white then 15 |
|||
else |
|||
0 |
|||
end |
|||
end |
|||
|
|||
def posix_colour(colour) |
|||
# ANSI Escape Codes - Foreground colors |
|||
# | Code | Color | |
|||
# | 39 | Default foreground color | |
|||
# | 30 | Black | |
|||
# | 31 | Red | |
|||
# | 32 | Green | |
|||
# | 33 | Yellow | |
|||
# | 34 | Blue | |
|||
# | 35 | Magenta | |
|||
# | 36 | Cyan | |
|||
# | 37 | Light gray | |
|||
# | 90 | Dark gray | |
|||
# | 91 | Light red | |
|||
# | 92 | Light green | |
|||
# | 93 | Light yellow | |
|||
# | 94 | Light blue | |
|||
# | 95 | Light magenta | |
|||
# | 96 | Light cyan | |
|||
# | 97 | White | |
|||
|
|||
case colour |
|||
when :black then 30 |
|||
when :red, :failure then 31 |
|||
when :green, :success then 32 |
|||
when :yellow then 33 |
|||
when :blue, :narrative then 34 |
|||
when :purple, :magenta then 35 |
|||
when :cyan, :output then 36 |
|||
when :white, :default_white then 37 |
|||
when :default then 39 |
|||
else |
|||
39 |
|||
end |
|||
end |
|||
|
|||
def out_c(mode, colour, str) |
|||
case RUBY_PLATFORM |
|||
when /(win|w)32$/ |
|||
change_to(colour) |
|||
$stdout.puts str if mode == :puts |
|||
$stdout.print str if mode == :print |
|||
change_to(:default_white) |
|||
else |
|||
$stdout.puts("#{change_to(colour)}#{str}\033[0m") if mode == :puts |
|||
$stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print |
|||
end |
|||
end |
|||
end |
|||
|
|||
def colour_puts(role, str) |
|||
ColourCommandLine.new.out_c(:puts, role, str) |
|||
end |
|||
|
|||
def colour_print(role, str) |
|||
ColourCommandLine.new.out_c(:print, role, str) |
|||
end |
@ -0,0 +1,39 @@ |
|||
# ========================================== |
|||
# Unity Project - A Test Framework for C |
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
# [Released under MIT License. Please refer to license.txt for details] |
|||
# ========================================== |
|||
|
|||
require_relative 'colour_prompt' |
|||
|
|||
$colour_output = true |
|||
|
|||
def report(message) |
|||
if !$colour_output |
|||
$stdout.puts(message) |
|||
else |
|||
message = message.join('\n') if message.class == Array |
|||
message.each_line do |line| |
|||
line.chomp! |
|||
colour = case line |
|||
when /(?:total\s+)?tests:?\s+(\d+)\s+(?:total\s+)?failures:?\s+\d+\s+Ignored:?/i |
|||
Regexp.last_match(1).to_i.zero? ? :green : :red |
|||
when /PASS/ |
|||
:green |
|||
when /^OK$/ |
|||
:green |
|||
when /(?:FAIL|ERROR)/ |
|||
:red |
|||
when /IGNORE/ |
|||
:yellow |
|||
when /^(?:Creating|Compiling|Linking)/ |
|||
:white |
|||
else |
|||
:silver |
|||
end |
|||
colour_puts(colour, line) |
|||
end |
|||
end |
|||
$stdout.flush |
|||
$stderr.flush |
|||
end |
@ -0,0 +1,36 @@ |
|||
#this is a sample configuration file for generate_module |
|||
#you would use it by calling generate_module with the -ygenerate_config.yml option |
|||
#files like this are useful for customizing generate_module to your environment |
|||
:generate_module: |
|||
:defaults: |
|||
#these defaults are used in place of any missing options at the command line |
|||
:path_src: ../src/ |
|||
:path_inc: ../src/ |
|||
:path_tst: ../test/ |
|||
:update_svn: true |
|||
:includes: |
|||
#use [] for no additional includes, otherwise list the includes on separate lines |
|||
:src: |
|||
- Defs.h |
|||
- Board.h |
|||
:inc: [] |
|||
:tst: |
|||
- Defs.h |
|||
- Board.h |
|||
- Exception.h |
|||
:boilerplates: |
|||
#these are inserted at the top of generated files. |
|||
#just comment out or remove if not desired. |
|||
#use %1$s where you would like the file name to appear (path/extension not included) |
|||
:src: | |
|||
//------------------------------------------- |
|||
// %1$s.c |
|||
//------------------------------------------- |
|||
:inc: | |
|||
//------------------------------------------- |
|||
// %1$s.h |
|||
//------------------------------------------- |
|||
:tst: | |
|||
//------------------------------------------- |
|||
// Test%1$s.c : Units tests for %1$s.c |
|||
//------------------------------------------- |
@ -0,0 +1,306 @@ |
|||
# ========================================== |
|||
# Unity Project - A Test Framework for C |
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
# [Released under MIT License. Please refer to license.txt for details] |
|||
# ========================================== |
|||
|
|||
# This script creates all the files with start code necessary for a new module. |
|||
# A simple module only requires a source file, header file, and test file. |
|||
# Triad modules require a source, header, and test file for each triad type (like model, conductor, and hardware). |
|||
|
|||
require 'rubygems' |
|||
require 'fileutils' |
|||
require 'pathname' |
|||
|
|||
# TEMPLATE_TST |
|||
TEMPLATE_TST ||= '#include "unity.h" |
|||
%2$s#include "%1$s.h" |
|||
|
|||
void setUp(void) |
|||
{ |
|||
} |
|||
|
|||
void tearDown(void) |
|||
{ |
|||
} |
|||
|
|||
void test_%1$s_NeedToImplement(void) |
|||
{ |
|||
TEST_IGNORE_MESSAGE("Need to Implement %1$s"); |
|||
} |
|||
'.freeze |
|||
|
|||
# TEMPLATE_SRC |
|||
TEMPLATE_SRC ||= '%2$s#include "%1$s.h" |
|||
'.freeze |
|||
|
|||
# TEMPLATE_INC |
|||
TEMPLATE_INC ||= '#ifndef %3$s_H |
|||
#define %3$s_H |
|||
%2$s |
|||
|
|||
#endif // %3$s_H |
|||
'.freeze |
|||
|
|||
class UnityModuleGenerator |
|||
############################ |
|||
def initialize(options = nil) |
|||
@options = UnityModuleGenerator.default_options |
|||
case options |
|||
when NilClass then @options |
|||
when String then @options.merge!(UnityModuleGenerator.grab_config(options)) |
|||
when Hash then @options.merge!(options) |
|||
else raise 'If you specify arguments, it should be a filename or a hash of options' |
|||
end |
|||
|
|||
# Create default file paths if none were provided |
|||
@options[:path_src] = "#{__dir__}/../src/" if @options[:path_src].nil? |
|||
@options[:path_inc] = @options[:path_src] if @options[:path_inc].nil? |
|||
@options[:path_tst] = "#{__dir__}/../test/" if @options[:path_tst].nil? |
|||
@options[:path_src] += '/' unless @options[:path_src][-1] == 47 |
|||
@options[:path_inc] += '/' unless @options[:path_inc][-1] == 47 |
|||
@options[:path_tst] += '/' unless @options[:path_tst][-1] == 47 |
|||
|
|||
# Built in patterns |
|||
@patterns = { |
|||
'src' => { |
|||
'' => { inc: [] } |
|||
}, |
|||
'test' => { |
|||
'' => { inc: [] } |
|||
}, |
|||
'dh' => { |
|||
'Driver' => { inc: [create_filename('%1$s', 'Hardware.h')] }, |
|||
'Hardware' => { inc: [] } |
|||
}, |
|||
'dih' => { |
|||
'Driver' => { inc: [create_filename('%1$s', 'Hardware.h'), create_filename('%1$s', 'Interrupt.h')] }, |
|||
'Interrupt' => { inc: [create_filename('%1$s', 'Hardware.h')] }, |
|||
'Hardware' => { inc: [] } |
|||
}, |
|||
'mch' => { |
|||
'Model' => { inc: [] }, |
|||
'Conductor' => { inc: [create_filename('%1$s', 'Model.h'), create_filename('%1$s', 'Hardware.h')] }, |
|||
'Hardware' => { inc: [] } |
|||
}, |
|||
'mvp' => { |
|||
'Model' => { inc: [] }, |
|||
'Presenter' => { inc: [create_filename('%1$s', 'Model.h'), create_filename('%1$s', 'View.h')] }, |
|||
'View' => { inc: [] } |
|||
} |
|||
} |
|||
end |
|||
|
|||
############################ |
|||
def self.default_options |
|||
{ |
|||
pattern: 'src', |
|||
includes: { |
|||
src: [], |
|||
inc: [], |
|||
tst: [] |
|||
}, |
|||
update_svn: false, |
|||
boilerplates: {}, |
|||
test_prefix: 'Test', |
|||
mock_prefix: 'Mock' |
|||
} |
|||
end |
|||
|
|||
############################ |
|||
def self.grab_config(config_file) |
|||
options = default_options |
|||
unless config_file.nil? || config_file.empty? |
|||
require 'yaml' |
|||
yaml_guts = YAML.load_file(config_file) |
|||
options.merge!(yaml_guts[:unity] || yaml_guts[:cmock]) |
|||
raise "No :unity or :cmock section found in #{config_file}" unless options |
|||
end |
|||
options |
|||
end |
|||
|
|||
############################ |
|||
def files_to_operate_on(module_name, pattern = nil) |
|||
# strip any leading path information from the module name and save for later |
|||
subfolder = File.dirname(module_name) |
|||
module_name = File.basename(module_name) |
|||
|
|||
# create triad definition |
|||
prefix = @options[:test_prefix] || 'Test' |
|||
triad = [{ ext: '.c', path: @options[:path_src], prefix: '', template: TEMPLATE_SRC, inc: :src, boilerplate: @options[:boilerplates][:src] }, |
|||
{ ext: '.h', path: @options[:path_inc], prefix: '', template: TEMPLATE_INC, inc: :inc, boilerplate: @options[:boilerplates][:inc] }, |
|||
{ ext: '.c', path: @options[:path_tst], prefix: prefix, template: TEMPLATE_TST, inc: :tst, boilerplate: @options[:boilerplates][:tst] }] |
|||
|
|||
# prepare the pattern for use |
|||
pattern = (pattern || @options[:pattern] || 'src').downcase |
|||
patterns = @patterns[pattern] |
|||
raise "ERROR: The design pattern '#{pattern}' specified isn't one that I recognize!" if patterns.nil? |
|||
|
|||
# single file patterns (currently just 'test') can reject the other parts of the triad |
|||
triad.select! { |v| v[:inc] == :tst } if pattern == 'test' |
|||
|
|||
# Assemble the path/names of the files we need to work with. |
|||
files = [] |
|||
triad.each do |cfg| |
|||
patterns.each_pair do |pattern_file, pattern_traits| |
|||
submodule_name = create_filename(module_name, pattern_file) |
|||
filename = cfg[:prefix] + submodule_name + cfg[:ext] |
|||
files << { |
|||
path: (Pathname.new("#{cfg[:path]}#{subfolder}") + filename).cleanpath, |
|||
name: submodule_name, |
|||
template: cfg[:template], |
|||
boilerplate: cfg[:boilerplate], |
|||
includes: case (cfg[:inc]) |
|||
when :src then (@options[:includes][:src] || []) | (pattern_traits[:inc].map { |f| format(f, module_name) }) |
|||
when :inc then (@options[:includes][:inc] || []) |
|||
when :tst then (@options[:includes][:tst] || []) | (pattern_traits[:inc].map { |f| format("#{@options[:mock_prefix]}#{f}", module_name) }) |
|||
end |
|||
} |
|||
end |
|||
end |
|||
|
|||
files |
|||
end |
|||
|
|||
############################ |
|||
def create_filename(part1, part2 = '') |
|||
if part2.empty? |
|||
case (@options[:naming]) |
|||
when 'bumpy' then part1 |
|||
when 'camel' then part1 |
|||
when 'snake' then part1.downcase |
|||
when 'caps' then part1.upcase |
|||
else part1 |
|||
end |
|||
else |
|||
case (@options[:naming]) |
|||
when 'bumpy' then part1 + part2 |
|||
when 'camel' then part1 + part2 |
|||
when 'snake' then part1.downcase + '_' + part2.downcase |
|||
when 'caps' then part1.upcase + '_' + part2.upcase |
|||
else part1 + '_' + part2 |
|||
end |
|||
end |
|||
end |
|||
|
|||
############################ |
|||
def generate(module_name, pattern = nil) |
|||
files = files_to_operate_on(module_name, pattern) |
|||
|
|||
# Abort if all of the module files already exist |
|||
all_files_exist = true |
|||
files.each do |file| |
|||
all_files_exist = false unless File.exist?(file[:path]) |
|||
end |
|||
raise "ERROR: File #{files[0][:name]} already exists. Exiting." if all_files_exist |
|||
|
|||
# Create Source Modules |
|||
files.each_with_index do |file, _i| |
|||
# If this file already exists, don't overwrite it. |
|||
if File.exist?(file[:path]) |
|||
puts "File #{file[:path]} already exists!" |
|||
next |
|||
end |
|||
# Create the path first if necessary. |
|||
FileUtils.mkdir_p(File.dirname(file[:path]), verbose: false) |
|||
File.open(file[:path], 'w') do |f| |
|||
f.write("#{file[:boilerplate]}\n" % [file[:name]]) unless file[:boilerplate].nil? |
|||
f.write(file[:template] % [file[:name], |
|||
file[:includes].map { |ff| "#include \"#{ff}\"\n" }.join, |
|||
file[:name].upcase]) |
|||
end |
|||
if @options[:update_svn] |
|||
`svn add \"#{file[:path]}\"` |
|||
if $!.exitstatus.zero? |
|||
puts "File #{file[:path]} created and added to source control" |
|||
else |
|||
puts "File #{file[:path]} created but FAILED adding to source control!" |
|||
end |
|||
else |
|||
puts "File #{file[:path]} created" |
|||
end |
|||
end |
|||
puts 'Generate Complete' |
|||
end |
|||
|
|||
############################ |
|||
def destroy(module_name, pattern = nil) |
|||
files_to_operate_on(module_name, pattern).each do |filespec| |
|||
file = filespec[:path] |
|||
if File.exist?(file) |
|||
if @options[:update_svn] |
|||
`svn delete \"#{file}\" --force` |
|||
puts "File #{file} deleted and removed from source control" |
|||
else |
|||
FileUtils.remove(file) |
|||
puts "File #{file} deleted" |
|||
end |
|||
else |
|||
puts "File #{file} does not exist so cannot be removed." |
|||
end |
|||
end |
|||
puts 'Destroy Complete' |
|||
end |
|||
end |
|||
|
|||
############################ |
|||
# Handle As Command Line If Called That Way |
|||
if $0 == __FILE__ |
|||
destroy = false |
|||
options = {} |
|||
module_name = nil |
|||
|
|||
# Parse the command line parameters. |
|||
ARGV.each do |arg| |
|||
case arg |
|||
when /^-d/ then destroy = true |
|||
when /^-u/ then options[:update_svn] = true |
|||
when /^-p\"?(\w+)\"?/ then options[:pattern] = Regexp.last_match(1) |
|||
when /^-s\"?(.+)\"?/ then options[:path_src] = Regexp.last_match(1) |
|||
when /^-i\"?(.+)\"?/ then options[:path_inc] = Regexp.last_match(1) |
|||
when /^-t\"?(.+)\"?/ then options[:path_tst] = Regexp.last_match(1) |
|||
when /^-n\"?(.+)\"?/ then options[:naming] = Regexp.last_match(1) |
|||
when /^-y\"?(.+)\"?/ then options = UnityModuleGenerator.grab_config(Regexp.last_match(1)) |
|||
when /^(\w+)/ |
|||
raise "ERROR: You can't have more than one Module name specified!" unless module_name.nil? |
|||
module_name = arg |
|||
when /^-(h|-help)/ |
|||
ARGV = [].freeze |
|||
else |
|||
raise "ERROR: Unknown option specified '#{arg}'" |
|||
end |
|||
end |
|||
|
|||
unless ARGV[0] |
|||
puts ["\nGENERATE MODULE\n-------- ------", |
|||
"\nUsage: ruby generate_module [options] module_name", |
|||
" -i\"include\" sets the path to output headers to 'include' (DEFAULT ../src)", |
|||
" -s\"../src\" sets the path to output source to '../src' (DEFAULT ../src)", |
|||
" -t\"C:/test\" sets the path to output source to 'C:/test' (DEFAULT ../test)", |
|||
' -p"MCH" sets the output pattern to MCH.', |
|||
' dh - driver hardware.', |
|||
' dih - driver interrupt hardware.', |
|||
' mch - model conductor hardware.', |
|||
' mvp - model view presenter.', |
|||
' src - just a source module, header and test. (DEFAULT)', |
|||
' test - just a test file.', |
|||
' -d destroy module instead of creating it.', |
|||
' -n"camel" sets the file naming convention.', |
|||
' bumpy - BumpyCaseFilenames.', |
|||
' camel - camelCaseFilenames.', |
|||
' 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', |
|||
''].join("\n") |
|||
exit |
|||
end |
|||
|
|||
raise 'ERROR: You must have a Module name specified! (use option -h for help)' if module_name.nil? |
|||
if destroy |
|||
UnityModuleGenerator.new(options).destroy(module_name) |
|||
else |
|||
UnityModuleGenerator.new(options).generate(module_name) |
|||
end |
|||
|
|||
end |
@ -0,0 +1,475 @@ |
|||
# ========================================== |
|||
# Unity Project - A Test Framework for C |
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
# [Released under MIT License. Please refer to license.txt for details] |
|||
# ========================================== |
|||
|
|||
class UnityTestRunnerGenerator |
|||
def initialize(options = nil) |
|||
@options = UnityTestRunnerGenerator.default_options |
|||
case options |
|||
when NilClass then @options |
|||
when String then @options.merge!(UnityTestRunnerGenerator.grab_config(options)) |
|||
when Hash then @options.merge!(options) |
|||
else raise 'If you specify arguments, it should be a filename or a hash of options' |
|||
end |
|||
require_relative 'type_sanitizer' |
|||
end |
|||
|
|||
def self.default_options |
|||
{ |
|||
includes: [], |
|||
defines: [], |
|||
plugins: [], |
|||
framework: :unity, |
|||
test_prefix: 'test|spec|should', |
|||
mock_prefix: 'Mock', |
|||
mock_suffix: '', |
|||
setup_name: 'setUp', |
|||
teardown_name: 'tearDown', |
|||
test_reset_name: 'resetTest', |
|||
main_name: 'main', # set to :auto to automatically generate each time |
|||
main_export_decl: '', |
|||
cmdline_args: false, |
|||
use_param_tests: false |
|||
} |
|||
end |
|||
|
|||
def self.grab_config(config_file) |
|||
options = default_options |
|||
unless config_file.nil? || config_file.empty? |
|||
require 'yaml' |
|||
yaml_guts = YAML.load_file(config_file) |
|||
options.merge!(yaml_guts[:unity] || yaml_guts[:cmock]) |
|||
raise "No :unity or :cmock section found in #{config_file}" unless options |
|||
end |
|||
options |
|||
end |
|||
|
|||
def run(input_file, output_file, options = nil) |
|||
@options.merge!(options) unless options.nil? |
|||
|
|||
# pull required data from source file |
|||
source = File.read(input_file) |
|||
source = source.force_encoding('ISO-8859-1').encode('utf-8', replace: nil) |
|||
tests = find_tests(source) |
|||
headers = find_includes(source) |
|||
testfile_includes = (headers[:local] + headers[:system]) |
|||
used_mocks = find_mocks(testfile_includes) |
|||
testfile_includes = (testfile_includes - used_mocks) |
|||
testfile_includes.delete_if { |inc| inc =~ /(unity|cmock)/ } |
|||
|
|||
# build runner file |
|||
generate(input_file, output_file, tests, used_mocks, testfile_includes) |
|||
|
|||
# determine which files were used to return them |
|||
all_files_used = [input_file, output_file] |
|||
all_files_used += testfile_includes.map { |filename| filename + '.c' } unless testfile_includes.empty? |
|||
all_files_used += @options[:includes] unless @options[:includes].empty? |
|||
all_files_used += headers[:linkonly] unless headers[:linkonly].empty? |
|||
all_files_used.uniq |
|||
end |
|||
|
|||
def generate(input_file, output_file, tests, used_mocks, testfile_includes) |
|||
File.open(output_file, 'w') do |output| |
|||
create_header(output, used_mocks, testfile_includes) |
|||
create_externs(output, tests, used_mocks) |
|||
create_mock_management(output, used_mocks) |
|||
create_suite_setup(output) |
|||
create_suite_teardown(output) |
|||
create_reset(output, used_mocks) |
|||
create_main(output, input_file, tests, used_mocks) |
|||
end |
|||
|
|||
return unless @options[:header_file] && !@options[:header_file].empty? |
|||
|
|||
File.open(@options[:header_file], 'w') do |output| |
|||
create_h_file(output, @options[:header_file], tests, testfile_includes, used_mocks) |
|||
end |
|||
end |
|||
|
|||
def find_tests(source) |
|||
tests_and_line_numbers = [] |
|||
|
|||
# contains characters which will be substituted from within strings, doing |
|||
# this prevents these characters from interferring with scrubbers |
|||
# @ is not a valid C character, so there should be no clashes with files genuinely containing these markers |
|||
substring_subs = { '{' => '@co@', '}' => '@cc@', ';' => '@ss@', '/' => '@fs@' } |
|||
substring_re = Regexp.union(substring_subs.keys) |
|||
substring_unsubs = substring_subs.invert # the inverse map will be used to fix the strings afterwords |
|||
substring_unsubs['@quote@'] = '\\"' |
|||
substring_unsubs['@apos@'] = '\\\'' |
|||
substring_unre = Regexp.union(substring_unsubs.keys) |
|||
source_scrubbed = source.clone |
|||
source_scrubbed = source_scrubbed.gsub(/\\"/, '@quote@') # hide escaped quotes to allow capture of the full string/char |
|||
source_scrubbed = source_scrubbed.gsub(/\\'/, '@apos@') # hide escaped apostrophes to allow capture of the full string/char |
|||
source_scrubbed = source_scrubbed.gsub(/("[^"\n]*")|('[^'\n]*')/) { |s| s.gsub(substring_re, substring_subs) } # temporarily hide problematic |
|||
# characters within strings |
|||
source_scrubbed = source_scrubbed.gsub(/\/\/.*$/, '') # remove line comments |
|||
source_scrubbed = source_scrubbed.gsub(/\/\*.*?\*\//m, '') # remove block comments |
|||
lines = source_scrubbed.split(/(^\s*\#.*$) # Treat preprocessor directives as a logical line |
|||
| (;|\{|\}) /x) # Match ;, {, and } as end of lines |
|||
.map { |line| line.gsub(substring_unre, substring_unsubs) } # unhide the problematic characters previously removed |
|||
|
|||
lines.each_with_index do |line, _index| |
|||
# find tests |
|||
next unless line =~ /^((?:\s*TEST_CASE\s*\(.*?\)\s*)*)\s*void\s+((?:#{@options[:test_prefix]}).*)\s*\(\s*(.*)\s*\)/m |
|||
arguments = Regexp.last_match(1) |
|||
name = Regexp.last_match(2) |
|||
call = Regexp.last_match(3) |
|||
params = Regexp.last_match(4) |
|||
args = nil |
|||
if @options[:use_param_tests] && !arguments.empty? |
|||
args = [] |
|||
arguments.scan(/\s*TEST_CASE\s*\((.*)\)\s*$/) { |a| args << a[0] } |
|||
end |
|||
tests_and_line_numbers << { test: name, args: args, call: call, params: params, line_number: 0 } |
|||
end |
|||
tests_and_line_numbers.uniq! { |v| v[:test] } |
|||
|
|||
# determine line numbers and create tests to run |
|||
source_lines = source.split("\n") |
|||
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 =~ /\s+#{tests_and_line_numbers[i][:test]}(?:\s|\()/ |
|||
source_index += index |
|||
tests_and_line_numbers[i][:line_number] = source_index + 1 |
|||
break |
|||
end |
|||
end |
|||
|
|||
tests_and_line_numbers |
|||
end |
|||
|
|||
def find_includes(source) |
|||
# remove comments (block and line, in three steps to ensure correct precedence) |
|||
source.gsub!(/\/\/(?:.+\/\*|\*(?:$|[^\/])).*$/, '') # remove line comments that comment out the start of blocks |
|||
source.gsub!(/\/\*.*?\*\//m, '') # remove block comments |
|||
source.gsub!(/\/\/.*$/, '') # remove line comments (all that remain) |
|||
|
|||
# parse out includes |
|||
includes = { |
|||
local: source.scan(/^\s*#include\s+\"\s*(.+)\.[hH]\s*\"/).flatten, |
|||
system: source.scan(/^\s*#include\s+<\s*(.+)\s*>/).flatten.map { |inc| "<#{inc}>" }, |
|||
linkonly: source.scan(/^TEST_FILE\(\s*\"\s*(.+)\.[cC]\w*\s*\"/).flatten |
|||
} |
|||
includes |
|||
end |
|||
|
|||
def find_mocks(includes) |
|||
mock_headers = [] |
|||
includes.each do |include_path| |
|||
include_file = File.basename(include_path) |
|||
mock_headers << include_path if include_file =~ /^#{@options[:mock_prefix]}.*#{@options[:mock_suffix]}$/i |
|||
end |
|||
mock_headers |
|||
end |
|||
|
|||
def create_header(output, mocks, testfile_includes = []) |
|||
output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */') |
|||
create_runtest(output, mocks) |
|||
output.puts("\n/*=======Automagically Detected Files To Include=====*/") |
|||
output.puts('#ifdef __WIN32__') |
|||
output.puts('#define UNITY_INCLUDE_SETUP_STUBS') |
|||
output.puts('#endif') |
|||
output.puts("#include \"#{@options[:framework]}.h\"") |
|||
output.puts('#include "cmock.h"') unless mocks.empty? |
|||
output.puts('#ifndef UNITY_EXCLUDE_SETJMP_H') |
|||
output.puts('#include <setjmp.h>') |
|||
output.puts('#endif') |
|||
output.puts('#include <stdio.h>') |
|||
if @options[:defines] && !@options[:defines].empty? |
|||
@options[:defines].each { |d| output.puts("#ifndef #{d}\n#define #{d}\n#endif /* #{d} */") } |
|||
end |
|||
if @options[:header_file] && !@options[:header_file].empty? |
|||
output.puts("#include \"#{File.basename(@options[:header_file])}\"") |
|||
else |
|||
@options[:includes].flatten.uniq.compact.each do |inc| |
|||
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}") |
|||
end |
|||
testfile_includes.each do |inc| |
|||
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}") |
|||
end |
|||
end |
|||
mocks.each do |mock| |
|||
output.puts("#include \"#{mock.gsub('.h', '')}.h\"") |
|||
end |
|||
output.puts('#include "CException.h"') if @options[:plugins].include?(:cexception) |
|||
|
|||
return unless @options[:enforce_strict_ordering] |
|||
|
|||
output.puts('') |
|||
output.puts('int GlobalExpectCount;') |
|||
output.puts('int GlobalVerifyOrder;') |
|||
output.puts('char* GlobalOrderError;') |
|||
end |
|||
|
|||
def create_externs(output, tests, _mocks) |
|||
output.puts("\n/*=======External Functions This Runner Calls=====*/") |
|||
output.puts("extern void #{@options[:setup_name]}(void);") |
|||
output.puts("extern void #{@options[:teardown_name]}(void);") |
|||
output.puts("\n#ifdef __cplusplus\nextern \"C\"\n{\n#endif") if @options[:externc] |
|||
tests.each do |test| |
|||
output.puts("extern void #{test[:test]}(#{test[:call] || 'void'});") |
|||
end |
|||
output.puts("#ifdef __cplusplus\n}\n#endif") if @options[:externc] |
|||
output.puts('') |
|||
end |
|||
|
|||
def create_mock_management(output, mock_headers) |
|||
return if mock_headers.empty? |
|||
|
|||
output.puts("\n/*=======Mock Management=====*/") |
|||
output.puts('static void CMock_Init(void)') |
|||
output.puts('{') |
|||
|
|||
if @options[:enforce_strict_ordering] |
|||
output.puts(' GlobalExpectCount = 0;') |
|||
output.puts(' GlobalVerifyOrder = 0;') |
|||
output.puts(' GlobalOrderError = NULL;') |
|||
end |
|||
|
|||
mocks = mock_headers.map { |mock| File.basename(mock) } |
|||
mocks.each do |mock| |
|||
mock_clean = TypeSanitizer.sanitize_c_identifier(mock) |
|||
output.puts(" #{mock_clean}_Init();") |
|||
end |
|||
output.puts("}\n") |
|||
|
|||
output.puts('static void CMock_Verify(void)') |
|||
output.puts('{') |
|||
mocks.each do |mock| |
|||
mock_clean = TypeSanitizer.sanitize_c_identifier(mock) |
|||
output.puts(" #{mock_clean}_Verify();") |
|||
end |
|||
output.puts("}\n") |
|||
|
|||
output.puts('static void CMock_Destroy(void)') |
|||
output.puts('{') |
|||
mocks.each do |mock| |
|||
mock_clean = TypeSanitizer.sanitize_c_identifier(mock) |
|||
output.puts(" #{mock_clean}_Destroy();") |
|||
end |
|||
output.puts("}\n") |
|||
end |
|||
|
|||
def create_suite_setup(output) |
|||
output.puts("\n/*=======Suite Setup=====*/") |
|||
output.puts('static void suite_setup(void)') |
|||
output.puts('{') |
|||
if @options[:suite_setup].nil? |
|||
# New style, call suiteSetUp() if we can use weak symbols |
|||
output.puts('#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA)') |
|||
output.puts(' suiteSetUp();') |
|||
output.puts('#endif') |
|||
else |
|||
# Old style, C code embedded in the :suite_setup option |
|||
output.puts(@options[:suite_setup]) |
|||
end |
|||
output.puts('}') |
|||
end |
|||
|
|||
def create_suite_teardown(output) |
|||
output.puts("\n/*=======Suite Teardown=====*/") |
|||
output.puts('static int suite_teardown(int num_failures)') |
|||
output.puts('{') |
|||
if @options[:suite_teardown].nil? |
|||
# New style, call suiteTearDown() if we can use weak symbols |
|||
output.puts('#if defined(UNITY_WEAK_ATTRIBUTE) || defined(UNITY_WEAK_PRAGMA)') |
|||
output.puts(' return suiteTearDown(num_failures);') |
|||
output.puts('#else') |
|||
output.puts(' return num_failures;') |
|||
output.puts('#endif') |
|||
else |
|||
# Old style, C code embedded in the :suite_teardown option |
|||
output.puts(@options[:suite_teardown]) |
|||
end |
|||
output.puts('}') |
|||
end |
|||
|
|||
def create_runtest(output, used_mocks) |
|||
cexception = @options[:plugins].include? :cexception |
|||
va_args1 = @options[:use_param_tests] ? ', ...' : '' |
|||
va_args2 = @options[:use_param_tests] ? '__VA_ARGS__' : '' |
|||
output.puts("\n/*=======Test Runner Used To Run Each Test Below=====*/") |
|||
output.puts('#define RUN_TEST_NO_ARGS') if @options[:use_param_tests] |
|||
output.puts("#define RUN_TEST(TestFunc, TestLineNum#{va_args1}) \\") |
|||
output.puts('{ \\') |
|||
output.puts(" Unity.CurrentTestName = #TestFunc#{va_args2.empty? ? '' : " \"(\" ##{va_args2} \")\""}; \\") |
|||
output.puts(' Unity.CurrentTestLineNumber = TestLineNum; \\') |
|||
output.puts(' if (UnityTestMatches()) { \\') if @options[:cmdline_args] |
|||
output.puts(' Unity.NumberOfTests++; \\') |
|||
output.puts(' UNITY_EXEC_TIME_START(); \\') |
|||
output.puts(' CMock_Init(); \\') unless used_mocks.empty? |
|||
output.puts(' UNITY_CLR_DETAILS(); \\') unless used_mocks.empty? |
|||
output.puts(' if (TEST_PROTECT()) \\') |
|||
output.puts(' { \\') |
|||
output.puts(' CEXCEPTION_T e; \\') if cexception |
|||
output.puts(' Try { \\') if cexception |
|||
output.puts(" #{@options[:setup_name]}(); \\") |
|||
output.puts(" TestFunc(#{va_args2}); \\") |
|||
output.puts(' } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \\') if cexception |
|||
output.puts(' } \\') |
|||
output.puts(' if (TEST_PROTECT()) \\') |
|||
output.puts(' { \\') |
|||
output.puts(" #{@options[:teardown_name]}(); \\") |
|||
output.puts(' CMock_Verify(); \\') unless used_mocks.empty? |
|||
output.puts(' } \\') |
|||
output.puts(' CMock_Destroy(); \\') unless used_mocks.empty? |
|||
output.puts(' UNITY_EXEC_TIME_STOP(); \\') |
|||
output.puts(' UnityConcludeTest(); \\') |
|||
output.puts(' } \\') if @options[:cmdline_args] |
|||
output.puts("}\n") |
|||
end |
|||
|
|||
def create_reset(output, used_mocks) |
|||
output.puts("\n/*=======Test Reset Option=====*/") |
|||
output.puts("void #{@options[:test_reset_name]}(void);") |
|||
output.puts("void #{@options[:test_reset_name]}(void)") |
|||
output.puts('{') |
|||
output.puts(' CMock_Verify();') unless used_mocks.empty? |
|||
output.puts(' CMock_Destroy();') unless used_mocks.empty? |
|||
output.puts(" #{@options[:teardown_name]}();") |
|||
output.puts(' CMock_Init();') unless used_mocks.empty? |
|||
output.puts(" #{@options[:setup_name]}();") |
|||
output.puts('}') |
|||
end |
|||
|
|||
def create_main(output, filename, tests, used_mocks) |
|||
output.puts("\n\n/*=======MAIN=====*/") |
|||
main_name = @options[:main_name].to_sym == :auto ? "main_#{filename.gsub('.c', '')}" : (@options[:main_name]).to_s |
|||
if @options[:cmdline_args] |
|||
if main_name != 'main' |
|||
output.puts("#{@options[:main_export_decl]} int #{main_name}(int argc, char** argv);") |
|||
end |
|||
output.puts("#{@options[:main_export_decl]} int #{main_name}(int argc, char** argv)") |
|||
output.puts('{') |
|||
output.puts(' int parse_status = UnityParseOptions(argc, argv);') |
|||
output.puts(' if (parse_status != 0)') |
|||
output.puts(' {') |
|||
output.puts(' if (parse_status < 0)') |
|||
output.puts(' {') |
|||
output.puts(" UnityPrint(\"#{filename.gsub('.c', '')}.\");") |
|||
output.puts(' UNITY_PRINT_EOL();') |
|||
if @options[:use_param_tests] |
|||
tests.each do |test| |
|||
if test[:args].nil? || test[:args].empty? |
|||
output.puts(" UnityPrint(\" #{test[:test]}(RUN_TEST_NO_ARGS)\");") |
|||
output.puts(' UNITY_PRINT_EOL();') |
|||
else |
|||
test[:args].each do |args| |
|||
output.puts(" UnityPrint(\" #{test[:test]}(#{args})\");") |
|||
output.puts(' UNITY_PRINT_EOL();') |
|||
end |
|||
end |
|||
end |
|||
else |
|||
tests.each { |test| output.puts(" UnityPrint(\" #{test[:test]}\");\n UNITY_PRINT_EOL();") } |
|||
end |
|||
output.puts(' return 0;') |
|||
output.puts(' }') |
|||
output.puts(' return parse_status;') |
|||
output.puts(' }') |
|||
else |
|||
if main_name != 'main' |
|||
output.puts("#{@options[:main_export_decl]} int #{main_name}(void);") |
|||
end |
|||
output.puts("int #{main_name}(void)") |
|||
output.puts('{') |
|||
end |
|||
output.puts(' suite_setup();') |
|||
output.puts(" UnityBegin(\"#{filename.gsub(/\\/, '\\\\\\')}\");") |
|||
if @options[:use_param_tests] |
|||
tests.each do |test| |
|||
if test[:args].nil? || test[:args].empty? |
|||
output.puts(" RUN_TEST(#{test[:test]}, #{test[:line_number]}, RUN_TEST_NO_ARGS);") |
|||
else |
|||
test[:args].each { |args| output.puts(" RUN_TEST(#{test[:test]}, #{test[:line_number]}, #{args});") } |
|||
end |
|||
end |
|||
else |
|||
tests.each { |test| output.puts(" RUN_TEST(#{test[:test]}, #{test[:line_number]});") } |
|||
end |
|||
output.puts |
|||
output.puts(' CMock_Guts_MemFreeFinal();') unless used_mocks.empty? |
|||
output.puts(' return suite_teardown(UnityEnd());') |
|||
output.puts('}') |
|||
end |
|||
|
|||
def create_h_file(output, filename, tests, testfile_includes, used_mocks) |
|||
filename = File.basename(filename).gsub(/[-\/\\\.\,\s]/, '_').upcase |
|||
output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */') |
|||
output.puts("#ifndef _#{filename}") |
|||
output.puts("#define _#{filename}\n\n") |
|||
output.puts("#include \"#{@options[:framework]}.h\"") |
|||
output.puts('#include "cmock.h"') unless used_mocks.empty? |
|||
@options[:includes].flatten.uniq.compact.each do |inc| |
|||
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}") |
|||
end |
|||
testfile_includes.each do |inc| |
|||
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc.gsub('.h', '')}.h\""}") |
|||
end |
|||
output.puts "\n" |
|||
tests.each do |test| |
|||
if test[:params].nil? || test[:params].empty? |
|||
output.puts("void #{test[:test]}(void);") |
|||
else |
|||
output.puts("void #{test[:test]}(#{test[:params]});") |
|||
end |
|||
end |
|||
output.puts("#endif\n\n") |
|||
end |
|||
end |
|||
|
|||
if $0 == __FILE__ |
|||
options = { includes: [] } |
|||
|
|||
# parse out all the options first (these will all be removed as we go) |
|||
ARGV.reject! do |arg| |
|||
case arg |
|||
when '-cexception' |
|||
options[:plugins] = [:cexception] |
|||
true |
|||
when /\.*\.ya?ml/ |
|||
options = UnityTestRunnerGenerator.grab_config(arg) |
|||
true |
|||
when /--(\w+)=\"?(.*)\"?/ |
|||
options[Regexp.last_match(1).to_sym] = Regexp.last_match(2) |
|||
true |
|||
when /\.*\.h/ |
|||
options[:includes] << arg |
|||
true |
|||
else false |
|||
end |
|||
end |
|||
|
|||
# make sure there is at least one parameter left (the input file) |
|||
unless ARGV[0] |
|||
puts ["\nusage: ruby #{__FILE__} (files) (options) input_test_file (output)", |
|||
"\n input_test_file - this is the C file you want to create a runner for", |
|||
' output - this is the name of the runner file to generate', |
|||
' defaults to (input_test_file)_Runner', |
|||
' files:', |
|||
' *.yml / *.yaml - loads configuration from here in :unity or :cmock', |
|||
' *.h - header files are added as #includes in runner', |
|||
' options:', |
|||
' -cexception - include cexception support', |
|||
' -externc - add extern "C" for cpp support', |
|||
' --setup_name="" - redefine setUp func name to something else', |
|||
' --teardown_name="" - redefine tearDown func name to something else', |
|||
' --main_name="" - redefine main func name to something else', |
|||
' --test_prefix="" - redefine test prefix from default test|spec|should', |
|||
' --test_reset_name="" - redefine resetTest func name to something else', |
|||
' --suite_setup="" - code to execute for setup of entire suite', |
|||
' --suite_teardown="" - code to execute for teardown of entire suite', |
|||
' --use_param_tests=1 - enable parameterized tests (disabled by default)', |
|||
' --header_file="" - path/name of test header file to generate too'].join("\n") |
|||
exit 1 |
|||
end |
|||
|
|||
# create the default test runner name if not specified |
|||
ARGV[1] = ARGV[0].gsub('.c', '_Runner.c') unless ARGV[1] |
|||
|
|||
UnityTestRunnerGenerator.new(options).run(ARGV[0], ARGV[1]) |
|||
end |
@ -0,0 +1,322 @@ |
|||
#============================================================ |
|||
# Author: John Theofanopoulos |
|||
# A simple parser. Takes the output files generated during the |
|||
# build process and extracts information relating to the tests. |
|||
# |
|||
# Notes: |
|||
# To capture an output file under VS builds use the following: |
|||
# devenv [build instructions] > Output.txt & type Output.txt |
|||
# |
|||
# To capture an output file under Linux builds use the following: |
|||
# make | tee Output.txt |
|||
# |
|||
# This script can handle the following output formats: |
|||
# - normal output (raw unity) |
|||
# - fixture output (unity_fixture.h/.c) |
|||
# - fixture output with verbose flag set ("-v") |
|||
# |
|||
# To use this parser use the following command |
|||
# ruby parseOutput.rb [options] [file] |
|||
# options: -xml : produce a JUnit compatible XML file |
|||
# file: file to scan for results |
|||
#============================================================ |
|||
|
|||
# Parser class for handling the input file |
|||
class ParseOutput |
|||
def initialize |
|||
# internal data |
|||
@class_name_idx = 0 |
|||
@path_delim = nil |
|||
|
|||
# xml output related |
|||
@xml_out = false |
|||
@array_list = false |
|||
|
|||
# current suite name and statistics |
|||
@test_suite = nil |
|||
@total_tests = 0 |
|||
@test_passed = 0 |
|||
@test_failed = 0 |
|||
@test_ignored = 0 |
|||
end |
|||
|
|||
# Set the flag to indicate if there will be an XML output file or not |
|||
def set_xml_output |
|||
@xml_out = true |
|||
end |
|||
|
|||
# If write our output to XML |
|||
def write_xml_output |
|||
output = File.open('report.xml', 'w') |
|||
output << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" |
|||
@array_list.each do |item| |
|||
output << item << "\n" |
|||
end |
|||
end |
|||
|
|||
# Pushes the suite info as xml to the array list, which will be written later |
|||
def push_xml_output_suite_info |
|||
# Insert opening tag at front |
|||
heading = '<testsuite name="Unity" tests="' + @total_tests.to_s + '" failures="' + @test_failed.to_s + '"' + ' skips="' + @test_ignored.to_s + '">' |
|||
@array_list.insert(0, heading) |
|||
# Push back the closing tag |
|||
@array_list.push '</testsuite>' |
|||
end |
|||
|
|||
# Pushes xml output data to the array list, which will be written later |
|||
def push_xml_output_passed(test_name) |
|||
@array_list.push ' <testcase classname="' + @test_suite + '" name="' + test_name + '"/>' |
|||
end |
|||
|
|||
# Pushes xml output data to the array list, which will be written later |
|||
def push_xml_output_failed(test_name, reason) |
|||
@array_list.push ' <testcase classname="' + @test_suite + '" name="' + test_name + '">' |
|||
@array_list.push ' <failure type="ASSERT FAILED">' + reason + '</failure>' |
|||
@array_list.push ' </testcase>' |
|||
end |
|||
|
|||
# Pushes xml output data to the array list, which will be written later |
|||
def push_xml_output_ignored(test_name, reason) |
|||
@array_list.push ' <testcase classname="' + @test_suite + '" name="' + test_name + '">' |
|||
@array_list.push ' <skipped type="TEST IGNORED">' + reason + '</skipped>' |
|||
@array_list.push ' </testcase>' |
|||
end |
|||
|
|||
# This function will try and determine when the suite is changed. This is |
|||
# is the name that gets added to the classname parameter. |
|||
def test_suite_verify(test_suite_name) |
|||
# Split the path name |
|||
test_name = test_suite_name.split(@path_delim) |
|||
|
|||
# Remove the extension and extract the base_name |
|||
base_name = test_name[test_name.size - 1].split('.')[0] |
|||
|
|||
# Return if the test suite hasn't changed |
|||
return unless base_name.to_s != @test_suite.to_s |
|||
|
|||
@test_suite = base_name |
|||
printf "New Test: %s\n", @test_suite |
|||
end |
|||
|
|||
# Prepares the line for verbose fixture output ("-v") |
|||
def prepare_fixture_line(line) |
|||
line = line.sub('IGNORE_TEST(', '') |
|||
line = line.sub('TEST(', '') |
|||
line = line.sub(')', ',') |
|||
line = line.chomp |
|||
array = line.split(',') |
|||
array.map { |x| x.to_s.lstrip.chomp } |
|||
end |
|||
|
|||
# Test was flagged as having passed so format the output. |
|||
# This is using the Unity fixture output and not the original Unity output. |
|||
def test_passed_unity_fixture(array) |
|||
class_name = array[0] |
|||
test_name = array[1] |
|||
test_suite_verify(class_name) |
|||
printf "%-40s PASS\n", test_name |
|||
|
|||
push_xml_output_passed(test_name) if @xml_out |
|||
end |
|||
|
|||
# Test was flagged as having failed so format the output. |
|||
# This is using the Unity fixture output and not the original Unity output. |
|||
def test_failed_unity_fixture(array) |
|||
class_name = array[0] |
|||
test_name = array[1] |
|||
test_suite_verify(class_name) |
|||
reason_array = array[2].split(':') |
|||
reason = reason_array[-1].lstrip.chomp + ' at line: ' + reason_array[-4] |
|||
|
|||
printf "%-40s FAILED\n", test_name |
|||
|
|||
push_xml_output_failed(test_name, reason) if @xml_out |
|||
end |
|||
|
|||
# Test was flagged as being ignored so format the output. |
|||
# This is using the Unity fixture output and not the original Unity output. |
|||
def test_ignored_unity_fixture(array) |
|||
class_name = array[0] |
|||
test_name = array[1] |
|||
reason = 'No reason given' |
|||
if array.size > 2 |
|||
reason_array = array[2].split(':') |
|||
tmp_reason = reason_array[-1].lstrip.chomp |
|||
reason = tmp_reason == 'IGNORE' ? 'No reason given' : tmp_reason |
|||
end |
|||
test_suite_verify(class_name) |
|||
printf "%-40s IGNORED\n", test_name |
|||
|
|||
push_xml_output_ignored(test_name, reason) if @xml_out |
|||
end |
|||
|
|||
# Test was flagged as having passed so format the output |
|||
def test_passed(array) |
|||
last_item = array.length - 1 |
|||
test_name = array[last_item - 1] |
|||
test_suite_verify(array[@class_name_idx]) |
|||
printf "%-40s PASS\n", test_name |
|||
|
|||
return unless @xml_out |
|||
|
|||
push_xml_output_passed(test_name) if @xml_out |
|||
end |
|||
|
|||
# Test was flagged as having failed so format the line |
|||
def test_failed(array) |
|||
last_item = array.length - 1 |
|||
test_name = array[last_item - 2] |
|||
reason = array[last_item].chomp.lstrip + ' at line: ' + array[last_item - 3] |
|||
class_name = array[@class_name_idx] |
|||
|
|||
if test_name.start_with? 'TEST(' |
|||
array2 = test_name.split(' ') |
|||
|
|||
test_suite = array2[0].sub('TEST(', '') |
|||
test_suite = test_suite.sub(',', '') |
|||
class_name = test_suite |
|||
|
|||
test_name = array2[1].sub(')', '') |
|||
end |
|||
|
|||
test_suite_verify(class_name) |
|||
printf "%-40s FAILED\n", test_name |
|||
|
|||
push_xml_output_failed(test_name, reason) if @xml_out |
|||
end |
|||
|
|||
# Test was flagged as being ignored so format the output |
|||
def test_ignored(array) |
|||
last_item = array.length - 1 |
|||
test_name = array[last_item - 2] |
|||
reason = array[last_item].chomp.lstrip |
|||
class_name = array[@class_name_idx] |
|||
|
|||
if test_name.start_with? 'TEST(' |
|||
array2 = test_name.split(' ') |
|||
|
|||
test_suite = array2[0].sub('TEST(', '') |
|||
test_suite = test_suite.sub(',', '') |
|||
class_name = test_suite |
|||
|
|||
test_name = array2[1].sub(')', '') |
|||
end |
|||
|
|||
test_suite_verify(class_name) |
|||
printf "%-40s IGNORED\n", test_name |
|||
|
|||
push_xml_output_ignored(test_name, reason) if @xml_out |
|||
end |
|||
|
|||
# Adjusts the os specific members according to the current path style |
|||
# (Windows or Unix based) |
|||
def detect_os_specifics(line) |
|||
if line.include? '\\' |
|||
# Windows X:\Y\Z |
|||
@class_name_idx = 1 |
|||
@path_delim = '\\' |
|||
else |
|||
# Unix Based /X/Y/Z |
|||
@class_name_idx = 0 |
|||
@path_delim = '/' |
|||
end |
|||
end |
|||
|
|||
# Main function used to parse the file that was captured. |
|||
def process(file_name) |
|||
@array_list = [] |
|||
|
|||
puts 'Parsing file: ' + file_name |
|||
|
|||
@test_passed = 0 |
|||
@test_failed = 0 |
|||
@test_ignored = 0 |
|||
puts '' |
|||
puts '=================== RESULTS =====================' |
|||
puts '' |
|||
File.open(file_name).each do |line| |
|||
# Typical test lines look like these: |
|||
# ---------------------------------------------------- |
|||
# 1. normal output: |
|||
# <path>/<test_file>.c:36:test_tc1000_opsys:FAIL: Expected 1 Was 0 |
|||
# <path>/<test_file>.c:112:test_tc5004_initCanChannel:IGNORE: Not Yet Implemented |
|||
# <path>/<test_file>.c:115:test_tc5100_initCanVoidPtrs:PASS |
|||
# |
|||
# 2. fixture output |
|||
# <path>/<test_file>.c:63:TEST(<test_group>, <test_function>):FAIL: Expected 0x00001234 Was 0x00005A5A |
|||
# <path>/<test_file>.c:36:TEST(<test_group>, <test_function>):IGNORE |
|||
# Note: "PASS" information won't be generated in this mode |
|||
# |
|||
# 3. fixture output with verbose information ("-v") |
|||
# TEST(<test_group, <test_file>)<path>/<test_file>:168::FAIL: Expected 0x8D Was 0x8C |
|||
# TEST(<test_group>, <test_file>)<path>/<test_file>:22::IGNORE: This Test Was Ignored On Purpose |
|||
# IGNORE_TEST(<test_group, <test_file>) |
|||
# TEST(<test_group, <test_file>) PASS |
|||
# |
|||
# Note: Where path is different on Unix vs Windows devices (Windows leads with a drive letter)! |
|||
detect_os_specifics(line) |
|||
line_array = line.split(':') |
|||
|
|||
# If we were able to split the line then we can look to see if any of our target words |
|||
# were found. Case is important. |
|||
next unless (line_array.size >= 4) || (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(') |
|||
|
|||
# check if the output is fixture output (with verbose flag "-v") |
|||
if (line.start_with? 'TEST(') || (line.start_with? 'IGNORE_TEST(') |
|||
line_array = prepare_fixture_line(line) |
|||
if line.include? ' PASS' |
|||
test_passed_unity_fixture(line_array) |
|||
@test_passed += 1 |
|||
elsif line.include? 'FAIL' |
|||
test_failed_unity_fixture(line_array) |
|||
@test_failed += 1 |
|||
elsif line.include? 'IGNORE' |
|||
test_ignored_unity_fixture(line_array) |
|||
@test_ignored += 1 |
|||
end |
|||
# normal output / fixture output (without verbose "-v") |
|||
elsif line.include? ':PASS' |
|||
test_passed(line_array) |
|||
@test_passed += 1 |
|||
elsif line.include? ':FAIL' |
|||
test_failed(line_array) |
|||
@test_failed += 1 |
|||
elsif line.include? ':IGNORE:' |
|||
test_ignored(line_array) |
|||
@test_ignored += 1 |
|||
elsif line.include? ':IGNORE' |
|||
line_array.push('No reason given') |
|||
test_ignored(line_array) |
|||
@test_ignored += 1 |
|||
end |
|||
@total_tests = @test_passed + @test_failed + @test_ignored |
|||
end |
|||
puts '' |
|||
puts '=================== SUMMARY =====================' |
|||
puts '' |
|||
puts 'Tests Passed : ' + @test_passed.to_s |
|||
puts 'Tests Failed : ' + @test_failed.to_s |
|||
puts 'Tests Ignored : ' + @test_ignored.to_s |
|||
|
|||
return unless @xml_out |
|||
|
|||
# push information about the suite |
|||
push_xml_output_suite_info |
|||
# write xml output file |
|||
write_xml_output |
|||
end |
|||
end |
|||
|
|||
# If the command line has no values in, used a default value of Output.txt |
|||
parse_my_file = ParseOutput.new |
|||
|
|||
if ARGV.size >= 1 |
|||
ARGV.each do |arg| |
|||
if arg == '-xml' |
|||
parse_my_file.set_xml_output |
|||
else |
|||
parse_my_file.process(arg) |
|||
break |
|||
end |
|||
end |
|||
end |
@ -0,0 +1,248 @@ |
|||
#!/usr/bin/ruby |
|||
# |
|||
# unity_to_junit.rb |
|||
# |
|||
require 'fileutils' |
|||
require 'optparse' |
|||
require 'ostruct' |
|||
require 'set' |
|||
|
|||
require 'pp' |
|||
|
|||
VERSION = 1.0 |
|||
|
|||
class ArgvParser |
|||
# |
|||
# Return a structure describing the options. |
|||
# |
|||
def self.parse(args) |
|||
# The options specified on the command line will be collected in *options*. |
|||
# We set default values here. |
|||
options = OpenStruct.new |
|||
options.results_dir = '.' |
|||
options.root_path = '.' |
|||
options.out_file = 'results.xml' |
|||
|
|||
opts = OptionParser.new do |o| |
|||
o.banner = 'Usage: unity_to_junit.rb [options]' |
|||
|
|||
o.separator '' |
|||
o.separator 'Specific options:' |
|||
|
|||
o.on('-r', '--results <dir>', 'Look for Unity Results files here.') do |results| |
|||
# puts "results #{results}" |
|||
options.results_dir = results |
|||
end |
|||
|
|||
o.on('-p', '--root_path <path>', 'Prepend this path to files in results.') do |root_path| |
|||
options.root_path = root_path |
|||
end |
|||
|
|||
o.on('-o', '--output <filename>', 'XML file to generate.') do |out_file| |
|||
# puts "out_file: #{out_file}" |
|||
options.out_file = out_file |
|||
end |
|||
|
|||
o.separator '' |
|||
o.separator 'Common options:' |
|||
|
|||
# No argument, shows at tail. This will print an options summary. |
|||
o.on_tail('-h', '--help', 'Show this message') do |
|||
puts o |
|||
exit |
|||
end |
|||
|
|||
# Another typical switch to print the version. |
|||
o.on_tail('--version', 'Show version') do |
|||
puts "unity_to_junit.rb version #{VERSION}" |
|||
exit |
|||
end |
|||
end |
|||
|
|||
opts.parse!(args) |
|||
options |
|||
end |
|||
end |
|||
|
|||
class UnityToJUnit |
|||
include FileUtils::Verbose |
|||
attr_reader :report, :total_tests, :failures, :ignored |
|||
attr_writer :targets, :root, :out_file |
|||
|
|||
def initialize |
|||
@report = '' |
|||
@unit_name = '' |
|||
end |
|||
|
|||
def run |
|||
# Clean up result file names |
|||
results = @targets.map { |target| target.tr('\\', '/') } |
|||
# puts "Output File: #{@out_file}" |
|||
f = File.new(@out_file, 'w') |
|||
write_xml_header(f) |
|||
write_suites_header(f) |
|||
results.each do |result_file| |
|||
lines = File.readlines(result_file).map(&:chomp) |
|||
|
|||
raise "Empty test result file: #{result_file}" if lines.empty? |
|||
|
|||
result_output = get_details(result_file, lines) |
|||
tests, failures, ignored = parse_test_summary(lines) |
|||
result_output[:counts][:total] = tests |
|||
result_output[:counts][:failed] = failures |
|||
result_output[:counts][:ignored] = ignored |
|||
result_output[:counts][:passed] = (result_output[:counts][:total] - result_output[:counts][:failed] - result_output[:counts][:ignored]) |
|||
|
|||
# use line[0] from the test output to get the test_file path and name |
|||
test_file_str = lines[0].tr('\\', '/') |
|||
test_file_str = test_file_str.split(':') |
|||
test_file = if test_file_str.length < 2 |
|||
result_file |
|||
else |
|||
test_file_str[0] + ':' + test_file_str[1] |
|||
end |
|||
result_output[:source][:path] = File.dirname(test_file) |
|||
result_output[:source][:file] = File.basename(test_file) |
|||
|
|||
# save result_output |
|||
@unit_name = File.basename(test_file, '.*') |
|||
|
|||
write_suite_header(result_output[:counts], f) |
|||
write_failures(result_output, f) |
|||
write_tests(result_output, f) |
|||
write_ignored(result_output, f) |
|||
write_suite_footer(f) |
|||
end |
|||
write_suites_footer(f) |
|||
f.close |
|||
end |
|||
|
|||
def usage(err_msg = nil) |
|||
puts "\nERROR: " |
|||
puts err_msg if err_msg |
|||
puts 'Usage: unity_to_junit.rb [options]' |
|||
puts '' |
|||
puts 'Specific options:' |
|||
puts ' -r, --results <dir> Look for Unity Results files here.' |
|||
puts ' -p, --root_path <path> Prepend this path to files in results.' |
|||
puts ' -o, --output <filename> XML file to generate.' |
|||
puts '' |
|||
puts 'Common options:' |
|||
puts ' -h, --help Show this message' |
|||
puts ' --version Show version' |
|||
|
|||
exit 1 |
|||
end |
|||
|
|||
protected |
|||
|
|||
def get_details(_result_file, lines) |
|||
results = results_structure |
|||
lines.each do |line| |
|||
line = line.tr('\\', '/') |
|||
_src_file, src_line, test_name, status, msg = line.split(/:/) |
|||
case status |
|||
when 'IGNORE' then results[:ignores] << { test: test_name, line: src_line, message: msg } |
|||
when 'FAIL' then results[:failures] << { test: test_name, line: src_line, message: msg } |
|||
when 'PASS' then results[:successes] << { test: test_name, line: src_line, message: msg } |
|||
end |
|||
end |
|||
results |
|||
end |
|||
|
|||
def parse_test_summary(summary) |
|||
raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ } |
|||
[Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i] |
|||
end |
|||
|
|||
private |
|||
|
|||
def results_structure |
|||
{ |
|||
source: { path: '', file: '' }, |
|||
successes: [], |
|||
failures: [], |
|||
ignores: [], |
|||
counts: { total: 0, passed: 0, failed: 0, ignored: 0 }, |
|||
stdout: [] |
|||
} |
|||
end |
|||
|
|||
def write_xml_header(stream) |
|||
stream.puts "<?xml version='1.0' encoding='utf-8' ?>" |
|||
end |
|||
|
|||
def write_suites_header(stream) |
|||
stream.puts '<testsuites>' |
|||
end |
|||
|
|||
def write_suite_header(counts, stream) |
|||
stream.puts "\t<testsuite errors=\"0\" skipped=\"#{counts[:ignored]}\" failures=\"#{counts[:failed]}\" tests=\"#{counts[:total]}\" name=\"unity\">" |
|||
end |
|||
|
|||
def write_failures(results, stream) |
|||
result = results[:failures] |
|||
result.each do |item| |
|||
filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*')) |
|||
stream.puts "\t\t<testcase classname=\"#{@unit_name}\" name=\"#{item[:test]}\" time=\"0\">" |
|||
stream.puts "\t\t\t<failure message=\"#{item[:message]}\" type=\"Assertion\"/>" |
|||
stream.puts "\t\t\t<system-err>
[File] #{filename}
[Line] #{item[:line]}
</system-err>" |
|||
stream.puts "\t\t</testcase>" |
|||
end |
|||
end |
|||
|
|||
def write_tests(results, stream) |
|||
result = results[:successes] |
|||
result.each do |item| |
|||
stream.puts "\t\t<testcase classname=\"#{@unit_name}\" name=\"#{item[:test]}\" time=\"0\" />" |
|||
end |
|||
end |
|||
|
|||
def write_ignored(results, stream) |
|||
result = results[:ignores] |
|||
result.each do |item| |
|||
filename = File.join(results[:source][:path], File.basename(results[:source][:file], '.*')) |
|||
puts "Writing ignored tests for test harness: #{filename}" |
|||
stream.puts "\t\t<testcase classname=\"#{@unit_name}\" name=\"#{item[:test]}\" time=\"0\">" |
|||
stream.puts "\t\t\t<skipped message=\"#{item[:message]}\" type=\"Assertion\"/>" |
|||
stream.puts "\t\t\t<system-err>
[File] #{filename}
[Line] #{item[:line]}
</system-err>" |
|||
stream.puts "\t\t</testcase>" |
|||
end |
|||
end |
|||
|
|||
def write_suite_footer(stream) |
|||
stream.puts "\t</testsuite>" |
|||
end |
|||
|
|||
def write_suites_footer(stream) |
|||
stream.puts '</testsuites>' |
|||
end |
|||
end |
|||
|
|||
if $0 == __FILE__ |
|||
# parse out the command options |
|||
options = ArgvParser.parse(ARGV) |
|||
|
|||
# create an instance to work with |
|||
utj = UnityToJUnit.new |
|||
begin |
|||
# look in the specified or current directory for result files |
|||
targets = "#{options.results_dir.tr('\\', '/')}**/*.test*" |
|||
|
|||
results = Dir[targets] |
|||
raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty? |
|||
utj.targets = results |
|||
|
|||
# set the root path |
|||
utj.root = options.root_path |
|||
|
|||
# set the output XML file name |
|||
# puts "Output File from options: #{options.out_file}" |
|||
utj.out_file = options.out_file |
|||
|
|||
# run the summarizer |
|||
puts utj.run |
|||
rescue StandardError => e |
|||
utj.usage e.message |
|||
end |
|||
end |
@ -0,0 +1,25 @@ |
|||
# ========================================== |
|||
# Unity Project - A Test Framework for C |
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
# [Released under MIT License. Please refer to license.txt for details] |
|||
# ========================================== |
|||
|
|||
require'yaml' |
|||
|
|||
module RakefileHelpers |
|||
class TestFileFilter |
|||
def initialize(all_files = false) |
|||
@all_files = all_files |
|||
|
|||
return unless @all_files |
|||
return unless File.exist?('test_file_filter.yml') |
|||
|
|||
filters = YAML.load_file('test_file_filter.yml') |
|||
@all_files = filters[:all_files] |
|||
@only_files = filters[:only_files] |
|||
@exclude_files = filters[:exclude_files] |
|||
end |
|||
|
|||
attr_accessor :all_files, :only_files, :exclude_files |
|||
end |
|||
end |
@ -0,0 +1,6 @@ |
|||
module TypeSanitizer |
|||
def self.sanitize_c_identifier(unsanitized) |
|||
# convert filename to valid C identifier by replacing invalid chars with '_' |
|||
unsanitized.gsub(/[-\/\\\.\,\s]/, '_') |
|||
end |
|||
end |
@ -0,0 +1,139 @@ |
|||
#! python3 |
|||
# ========================================== |
|||
# Unity Project - A Test Framework for C |
|||
# Copyright (c) 2015 Alexander Mueller / XelaRellum@web.de |
|||
# [Released under MIT License. Please refer to license.txt for details] |
|||
# Based on the ruby script by Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
# ========================================== |
|||
import sys |
|||
import os |
|||
import re |
|||
from glob import glob |
|||
|
|||
class UnityTestSummary: |
|||
def __init__(self): |
|||
self.report = '' |
|||
self.total_tests = 0 |
|||
self.failures = 0 |
|||
self.ignored = 0 |
|||
|
|||
def run(self): |
|||
# Clean up result file names |
|||
results = [] |
|||
for target in self.targets: |
|||
results.append(target.replace('\\', '/')) |
|||
|
|||
# Dig through each result file, looking for details on pass/fail: |
|||
failure_output = [] |
|||
ignore_output = [] |
|||
|
|||
for result_file in results: |
|||
lines = list(map(lambda line: line.rstrip(), open(result_file, "r").read().split('\n'))) |
|||
if len(lines) == 0: |
|||
raise Exception("Empty test result file: %s" % result_file) |
|||
|
|||
details = self.get_details(result_file, lines) |
|||
failures = details['failures'] |
|||
ignores = details['ignores'] |
|||
if len(failures) > 0: failure_output.append('\n'.join(failures)) |
|||
if len(ignores) > 0: ignore_output.append('n'.join(ignores)) |
|||
tests,failures,ignored = self.parse_test_summary('\n'.join(lines)) |
|||
self.total_tests += tests |
|||
self.failures += failures |
|||
self.ignored += ignored |
|||
|
|||
if self.ignored > 0: |
|||
self.report += "\n" |
|||
self.report += "--------------------------\n" |
|||
self.report += "UNITY IGNORED TEST SUMMARY\n" |
|||
self.report += "--------------------------\n" |
|||
self.report += "\n".join(ignore_output) |
|||
|
|||
if self.failures > 0: |
|||
self.report += "\n" |
|||
self.report += "--------------------------\n" |
|||
self.report += "UNITY FAILED TEST SUMMARY\n" |
|||
self.report += "--------------------------\n" |
|||
self.report += '\n'.join(failure_output) |
|||
|
|||
self.report += "\n" |
|||
self.report += "--------------------------\n" |
|||
self.report += "OVERALL UNITY TEST SUMMARY\n" |
|||
self.report += "--------------------------\n" |
|||
self.report += "{total_tests} TOTAL TESTS {failures} TOTAL FAILURES {ignored} IGNORED\n".format(total_tests = self.total_tests, failures=self.failures, ignored=self.ignored) |
|||
self.report += "\n" |
|||
|
|||
return self.report |
|||
|
|||
def set_targets(self, target_array): |
|||
self.targets = target_array |
|||
|
|||
def set_root_path(self, path): |
|||
self.root = path |
|||
|
|||
def usage(self, err_msg=None): |
|||
print("\nERROR: ") |
|||
if err_msg: |
|||
print(err_msg) |
|||
print("\nUsage: unity_test_summary.py result_file_directory/ root_path/") |
|||
print(" result_file_directory - The location of your results files.") |
|||
print(" Defaults to current directory if not specified.") |
|||
print(" Should end in / if specified.") |
|||
print(" root_path - Helpful for producing more verbose output if using relative paths.") |
|||
sys.exit(1) |
|||
|
|||
def get_details(self, result_file, lines): |
|||
results = { 'failures': [], 'ignores': [], 'successes': [] } |
|||
for line in lines: |
|||
parts = line.split(':') |
|||
if len(parts) == 5: |
|||
src_file,src_line,test_name,status,msg = parts |
|||
elif len(parts) == 4: |
|||
src_file,src_line,test_name,status = parts |
|||
msg = '' |
|||
else: |
|||
continue |
|||
if len(self.root) > 0: |
|||
line_out = "%s%s" % (self.root, line) |
|||
else: |
|||
line_out = line |
|||
if status == 'IGNORE': |
|||
results['ignores'].append(line_out) |
|||
elif status == 'FAIL': |
|||
results['failures'].append(line_out) |
|||
elif status == 'PASS': |
|||
results['successes'].append(line_out) |
|||
return results |
|||
|
|||
def parse_test_summary(self, summary): |
|||
m = re.search(r"([0-9]+) Tests ([0-9]+) Failures ([0-9]+) Ignored", summary) |
|||
if not m: |
|||
raise Exception("Couldn't parse test results: %s" % summary) |
|||
|
|||
return int(m.group(1)), int(m.group(2)), int(m.group(3)) |
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
uts = UnityTestSummary() |
|||
try: |
|||
#look in the specified or current directory for result files |
|||
if len(sys.argv) > 1: |
|||
targets_dir = sys.argv[1] |
|||
else: |
|||
targets_dir = './' |
|||
targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '**/*.test*', recursive=True))) |
|||
if len(targets) == 0: |
|||
raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir) |
|||
uts.set_targets(targets) |
|||
|
|||
#set the root path |
|||
if len(sys.argv) > 2: |
|||
root_path = sys.argv[2] |
|||
else: |
|||
root_path = os.path.split(__file__)[0] |
|||
uts.set_root_path(root_path) |
|||
|
|||
#run the summarizer |
|||
print(uts.run()) |
|||
except Exception as e: |
|||
uts.usage(e) |
@ -0,0 +1,132 @@ |
|||
# ========================================== |
|||
# Unity Project - A Test Framework for C |
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
# [Released under MIT License. Please refer to license.txt for details] |
|||
# ========================================== |
|||
|
|||
# !/usr/bin/ruby |
|||
# |
|||
# unity_test_summary.rb |
|||
# |
|||
require 'fileutils' |
|||
require 'set' |
|||
|
|||
class UnityTestSummary |
|||
include FileUtils::Verbose |
|||
|
|||
attr_reader :report, :total_tests, :failures, :ignored |
|||
attr_writer :targets, :root |
|||
|
|||
def initialize(_opts = {}) |
|||
@report = '' |
|||
@total_tests = 0 |
|||
@failures = 0 |
|||
@ignored = 0 |
|||
end |
|||
|
|||
def run |
|||
# Clean up result file names |
|||
results = @targets.map { |target| target.tr('\\', '/') } |
|||
|
|||
# Dig through each result file, looking for details on pass/fail: |
|||
failure_output = [] |
|||
ignore_output = [] |
|||
|
|||
results.each do |result_file| |
|||
lines = File.readlines(result_file).map(&:chomp) |
|||
|
|||
raise "Empty test result file: #{result_file}" if lines.empty? |
|||
|
|||
output = get_details(result_file, lines) |
|||
failure_output << output[:failures] unless output[:failures].empty? |
|||
ignore_output << output[:ignores] unless output[:ignores].empty? |
|||
tests, failures, ignored = parse_test_summary(lines) |
|||
@total_tests += tests |
|||
@failures += failures |
|||
@ignored += ignored |
|||
end |
|||
|
|||
if @ignored > 0 |
|||
@report += "\n" |
|||
@report += "--------------------------\n" |
|||
@report += "UNITY IGNORED TEST SUMMARY\n" |
|||
@report += "--------------------------\n" |
|||
@report += ignore_output.flatten.join("\n") |
|||
end |
|||
|
|||
if @failures > 0 |
|||
@report += "\n" |
|||
@report += "--------------------------\n" |
|||
@report += "UNITY FAILED TEST SUMMARY\n" |
|||
@report += "--------------------------\n" |
|||
@report += failure_output.flatten.join("\n") |
|||
end |
|||
|
|||
@report += "\n" |
|||
@report += "--------------------------\n" |
|||
@report += "OVERALL UNITY TEST SUMMARY\n" |
|||
@report += "--------------------------\n" |
|||
@report += "#{@total_tests} TOTAL TESTS #{@failures} TOTAL FAILURES #{@ignored} IGNORED\n" |
|||
@report += "\n" |
|||
end |
|||
|
|||
def usage(err_msg = nil) |
|||
puts "\nERROR: " |
|||
puts err_msg if err_msg |
|||
puts "\nUsage: unity_test_summary.rb result_file_directory/ root_path/" |
|||
puts ' result_file_directory - The location of your results files.' |
|||
puts ' Defaults to current directory if not specified.' |
|||
puts ' Should end in / if specified.' |
|||
puts ' root_path - Helpful for producing more verbose output if using relative paths.' |
|||
exit 1 |
|||
end |
|||
|
|||
protected |
|||
|
|||
def get_details(_result_file, lines) |
|||
results = { failures: [], ignores: [], successes: [] } |
|||
lines.each do |line| |
|||
_src_file, _src_line, _test_name, status, _msg = line.split(/:/) |
|||
line_out = (@root && (@root != 0) ? "#{@root}#{line}" : line).gsub(/\//, '\\') |
|||
case status |
|||
when 'IGNORE' then results[:ignores] << line_out |
|||
when 'FAIL' then results[:failures] << line_out |
|||
when 'PASS' then results[:successes] << line_out |
|||
end |
|||
end |
|||
results |
|||
end |
|||
|
|||
def parse_test_summary(summary) |
|||
raise "Couldn't parse test results: #{summary}" unless summary.find { |v| v =~ /(\d+) Tests (\d+) Failures (\d+) Ignored/ } |
|||
[Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, Regexp.last_match(3).to_i] |
|||
end |
|||
end |
|||
|
|||
if $0 == __FILE__ |
|||
|
|||
# parse out the command options |
|||
opts, args = ARGV.partition { |v| v =~ /^--\w+/ } |
|||
opts.map! { |v| v[2..-1].to_sym } |
|||
|
|||
# create an instance to work with |
|||
uts = UnityTestSummary.new(opts) |
|||
|
|||
begin |
|||
# look in the specified or current directory for result files |
|||
args[0] ||= './' |
|||
targets = "#{ARGV[0].tr('\\', '/')}**/*.test*" |
|||
results = Dir[targets] |
|||
raise "No *.testpass, *.testfail, or *.testresults files found in '#{targets}'" if results.empty? |
|||
uts.targets = results |
|||
|
|||
# set the root path |
|||
args[1] ||= Dir.pwd + '/' |
|||
uts.root = ARGV[1] |
|||
|
|||
# run the summarizer |
|||
puts uts.run |
|||
rescue StandardError => e |
|||
uts.usage e.message |
|||
end |
|||
end |
@ -0,0 +1,146 @@ |
|||
import sys |
|||
import os |
|||
from glob import glob |
|||
|
|||
from pyparsing import * |
|||
from junit_xml import TestSuite, TestCase |
|||
|
|||
|
|||
class UnityTestSummary: |
|||
def __init__(self): |
|||
self.report = '' |
|||
self.total_tests = 0 |
|||
self.failures = 0 |
|||
self.ignored = 0 |
|||
self.targets = 0 |
|||
self.root = None |
|||
self.test_suites = dict() |
|||
|
|||
def run(self): |
|||
# Clean up result file names |
|||
results = [] |
|||
for target in self.targets: |
|||
results.append(target.replace('\\', '/')) |
|||
|
|||
# Dig through each result file, looking for details on pass/fail: |
|||
for result_file in results: |
|||
lines = list(map(lambda line: line.rstrip(), open(result_file, "r").read().split('\n'))) |
|||
if len(lines) == 0: |
|||
raise Exception("Empty test result file: %s" % result_file) |
|||
|
|||
# define an expression for your file reference |
|||
entry_one = Combine( |
|||
oneOf(list(alphas)) + ':/' + |
|||
Word(alphanums + '_-./')) |
|||
|
|||
entry_two = Word(printables + ' ', excludeChars=':') |
|||
entry = entry_one | entry_two |
|||
|
|||
delimiter = Literal(':').suppress() |
|||
tc_result_line = Group(entry.setResultsName('tc_file_name') + delimiter + entry.setResultsName( |
|||
'tc_line_nr') + delimiter + entry.setResultsName('tc_name') + delimiter + entry.setResultsName( |
|||
'tc_status') + Optional( |
|||
delimiter + entry.setResultsName('tc_msg'))).setResultsName("tc_line") |
|||
|
|||
eol = LineEnd().suppress() |
|||
sol = LineStart().suppress() |
|||
blank_line = sol + eol |
|||
|
|||
tc_summary_line = Group(Word(nums).setResultsName("num_of_tests") + "Tests" + Word(nums).setResultsName( |
|||
"num_of_fail") + "Failures" + Word(nums).setResultsName("num_of_ignore") + "Ignored").setResultsName( |
|||
"tc_summary") |
|||
tc_end_line = Or(Literal("FAIL"), Literal('Ok')).setResultsName("tc_result") |
|||
|
|||
# run it and see... |
|||
pp1 = tc_result_line | Optional(tc_summary_line | tc_end_line) |
|||
pp1.ignore(blank_line | OneOrMore("-")) |
|||
|
|||
result = list() |
|||
for l in lines: |
|||
result.append((pp1.parseString(l)).asDict()) |
|||
# delete empty results |
|||
result = filter(None, result) |
|||
|
|||
tc_list = list() |
|||
for r in result: |
|||
if 'tc_line' in r: |
|||
tmp_tc_line = r['tc_line'] |
|||
|
|||
# get only the file name which will be used as the classname |
|||
file_name = tmp_tc_line['tc_file_name'].split('\\').pop().split('/').pop().rsplit('.', 1)[0] |
|||
tmp_tc = TestCase(name=tmp_tc_line['tc_name'], classname=file_name) |
|||
if 'tc_status' in tmp_tc_line: |
|||
if str(tmp_tc_line['tc_status']) == 'IGNORE': |
|||
if 'tc_msg' in tmp_tc_line: |
|||
tmp_tc.add_skipped_info(message=tmp_tc_line['tc_msg'], |
|||
output=r'[File]={0}, [Line]={1}'.format( |
|||
tmp_tc_line['tc_file_name'], tmp_tc_line['tc_line_nr'])) |
|||
else: |
|||
tmp_tc.add_skipped_info(message=" ") |
|||
elif str(tmp_tc_line['tc_status']) == 'FAIL': |
|||
if 'tc_msg' in tmp_tc_line: |
|||
tmp_tc.add_failure_info(message=tmp_tc_line['tc_msg'], |
|||
output=r'[File]={0}, [Line]={1}'.format( |
|||
tmp_tc_line['tc_file_name'], tmp_tc_line['tc_line_nr'])) |
|||
else: |
|||
tmp_tc.add_failure_info(message=" ") |
|||
|
|||
tc_list.append((str(result_file), tmp_tc)) |
|||
|
|||
for k, v in tc_list: |
|||
try: |
|||
self.test_suites[k].append(v) |
|||
except KeyError: |
|||
self.test_suites[k] = [v] |
|||
ts = [] |
|||
for suite_name in self.test_suites: |
|||
ts.append(TestSuite(suite_name, self.test_suites[suite_name])) |
|||
|
|||
with open('result.xml', 'w') as f: |
|||
TestSuite.to_file(f, ts, prettyprint='True', encoding='utf-8') |
|||
|
|||
return self.report |
|||
|
|||
def set_targets(self, target_array): |
|||
self.targets = target_array |
|||
|
|||
def set_root_path(self, path): |
|||
self.root = path |
|||
|
|||
@staticmethod |
|||
def usage(err_msg=None): |
|||
print("\nERROR: ") |
|||
if err_msg: |
|||
print(err_msg) |
|||
print("\nUsage: unity_test_summary.py result_file_directory/ root_path/") |
|||
print(" result_file_directory - The location of your results files.") |
|||
print(" Defaults to current directory if not specified.") |
|||
print(" Should end in / if specified.") |
|||
print(" root_path - Helpful for producing more verbose output if using relative paths.") |
|||
sys.exit(1) |
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
uts = UnityTestSummary() |
|||
try: |
|||
# look in the specified or current directory for result files |
|||
if len(sys.argv) > 1: |
|||
targets_dir = sys.argv[1] |
|||
else: |
|||
targets_dir = './' |
|||
targets = list(map(lambda x: x.replace('\\', '/'), glob(targets_dir + '*.test*'))) |
|||
if len(targets) == 0: |
|||
raise Exception("No *.testpass or *.testfail files found in '%s'" % targets_dir) |
|||
uts.set_targets(targets) |
|||
|
|||
# set the root path |
|||
if len(sys.argv) > 2: |
|||
root_path = sys.argv[2] |
|||
else: |
|||
root_path = os.path.split(__file__)[0] |
|||
uts.set_root_path(root_path) |
|||
|
|||
# run the summarizer |
|||
print(uts.run()) |
|||
except Exception as e: |
|||
UnityTestSummary.usage(e) |
@ -0,0 +1,206 @@ |
|||
# ThrowTheSwitch.org Coding Standard |
|||
|
|||
Hi. Welcome to the coding standard for ThrowTheSwitch.org. For the most part, |
|||
we try to follow these standards to unify our contributors' code into a cohesive |
|||
unit (puns intended). You might find places where these standards aren't |
|||
followed. We're not perfect. Please be polite where you notice these discrepancies |
|||
and we'll try to be polite when we notice yours. |
|||
|
|||
;) |
|||
|
|||
|
|||
## Why Have A Coding Standard? |
|||
|
|||
Being consistent makes code easier to understand. We've tried to keep |
|||
our standard simple because we also believe that we can only expect someone to |
|||
follow something that is understandable. Please do your best. |
|||
|
|||
|
|||
## Our Philosophy |
|||
|
|||
Before we get into details on syntax, let's take a moment to talk about our |
|||
vision for these tools. We're C developers and embedded software developers. |
|||
These tools are great to test any C code, but catering to embedded software has |
|||
made us more tolerant of compiler quirks. There are a LOT of quirky compilers |
|||
out there. By quirky I mean "doesn't follow standards because they feel like |
|||
they have a license to do as they wish." |
|||
|
|||
Our philosophy is "support every compiler we can". Most often, this means that |
|||
we aim for writing C code that is standards compliant (often C89... that seems |
|||
to be a sweet spot that is almost always compatible). But it also means these |
|||
tools are tolerant of things that aren't common. Some that aren't even |
|||
compliant. There are configuration options to override the size of standard |
|||
types. There are configuration options to force Unity to not use certain |
|||
standard library functions. A lot of Unity is configurable and we have worked |
|||
hard to make it not TOO ugly in the process. |
|||
|
|||
Similarly, our tools that parse C do their best. They aren't full C parsers |
|||
(yet) and, even if they were, they would still have to accept non-standard |
|||
additions like gcc extensions or specifying `@0x1000` to force a variable to |
|||
compile to a particular location. It's just what we do, because we like |
|||
everything to Just Work™. |
|||
|
|||
Speaking of having things Just Work™, that's our second philosophy. By that, we |
|||
mean that we do our best to have EVERY configuration option have a logical |
|||
default. We believe that if you're working with a simple compiler and target, |
|||
you shouldn't need to configure very much... we try to make the tools guess as |
|||
much as they can, but give the user the power to override it when it's wrong. |
|||
|
|||
|
|||
## Naming Things |
|||
|
|||
Let's talk about naming things. Programming is all about naming things. We name |
|||
files, functions, variables, and so much more. While we're not always going to |
|||
find the best name for something, we actually put a bit of effort into |
|||
finding *What Something WANTS to be Called*™. |
|||
|
|||
When naming things, we follow this hierarchy, the first being the |
|||
most important to us (but we do all four when possible): |
|||
1. Readable |
|||
2. Descriptive |
|||
3. Consistent |
|||
4. Memorable |
|||
|
|||
|
|||
#### Readable |
|||
|
|||
We want to read our code. This means we like names and flow that are more |
|||
naturally read. We try to avoid double negatives. We try to avoid cryptic |
|||
abbreviations (sticking to ones we feel are common). |
|||
|
|||
|
|||
#### Descriptive |
|||
|
|||
We like descriptive names for things, especially functions and variables. |
|||
Finding the right name for something is an important endeavor. You might notice |
|||
from poking around our code that this often results in names that are a little |
|||
longer than the average. Guilty. We're okay with a bit more typing if it |
|||
means our code is easier to understand. |
|||
|
|||
There are two exceptions to this rule that we also stick to as religiously as |
|||
possible: |
|||
|
|||
First, while we realize hungarian notation (and similar systems for encoding |
|||
type information into variable names) is providing a more descriptive name, we |
|||
feel that (for the average developer) it takes away from readability and is to be avoided. |
|||
|
|||
Second, loop counters and other local throw-away variables often have a purpose |
|||
which is obvious. There's no need, therefore, to get carried away with complex |
|||
naming. We find i, j, and k are better loop counters than loopCounterVar or |
|||
whatnot. We only break this rule when we see that more description could improve |
|||
understanding of an algorithm. |
|||
|
|||
|
|||
#### Consistent |
|||
|
|||
We like consistency, but we're not really obsessed with it. We try to name our |
|||
configuration macros in a consistent fashion... you'll notice a repeated use of |
|||
UNITY_EXCLUDE_BLAH or UNITY_USES_BLAH macros. This helps users avoid having to |
|||
remember each macro's details. |
|||
|
|||
|
|||
#### Memorable |
|||
|
|||
Where ever it doesn't violate the above principles, we try to apply memorable |
|||
names. Sometimes this means using something that is simply descriptive, but |
|||
often we strive for descriptive AND unique... we like quirky names that stand |
|||
out in our memory and are easier to search for. Take a look through the file |
|||
names in Ceedling and you'll get a good idea of what we are talking about here. |
|||
Why use preprocess when you can use preprocessinator? Or what better describes a |
|||
module in charge of invoking tasks during releases than release_invoker? Don't |
|||
get carried away. The names are still descriptive and fulfill the above |
|||
requirements, but they don't feel stale. |
|||
|
|||
|
|||
## C and C++ Details |
|||
|
|||
We don't really want to add to the style battles out there. Tabs or spaces? |
|||
How many spaces? Where do the braces go? These are age-old questions that will |
|||
never be answered... or at least not answered in a way that will make everyone |
|||
happy. |
|||
|
|||
We've decided on our own style preferences. If you'd like to contribute to these |
|||
projects (and we hope that you do), then we ask if you do your best to follow |
|||
the same. It will only hurt a little. We promise. |
|||
|
|||
|
|||
#### Whitespace |
|||
|
|||
Our C-style is to use spaces and to use 4 of them per indent level. It's a nice |
|||
power-of-2 number that looks decent on a wide-screen. We have no more reason |
|||
than that. We break that rule when we have lines that wrap (macros or function |
|||
arguments or whatnot). When that happens, we like to indent further to line |
|||
things up in nice tidy columns. |
|||
|
|||
```C |
|||
if (stuff_happened) |
|||
{ |
|||
do_something(); |
|||
} |
|||
``` |
|||
|
|||
|
|||
#### Case |
|||
|
|||
- Files - all lower case with underscores. |
|||
- Variables - all lower case with underscores |
|||
- Macros - all caps with underscores. |
|||
- Typedefs - all caps with underscores. (also ends with _T). |
|||
- Functions - camel cased. Usually named ModuleName_FuncName |
|||
- Constants and Globals - camel cased. |
|||
|
|||
|
|||
#### Braces |
|||
|
|||
The left brace is on the next line after the declaration. The right brace is |
|||
directly below that. Everything in between in indented one level. If you're |
|||
catching an error and you have a one-line, go ahead and to it on the same line. |
|||
|
|||
```C |
|||
while (blah) |
|||
{ |
|||
//Like so. Even if only one line, we use braces. |
|||
} |
|||
``` |
|||
|
|||
|
|||
#### Comments |
|||
|
|||
Do you know what we hate? Old-school C block comments. BUT, we're using them |
|||
anyway. As we mentioned, our goal is to support every compiler we can, |
|||
especially embedded compilers. There are STILL C compilers out there that only |
|||
support old-school block comments. So that is what we're using. We apologize. We |
|||
think they are ugly too. |
|||
|
|||
|
|||
## Ruby Details |
|||
|
|||
Is there really such thing as a Ruby coding standard? Ruby is such a free form |
|||
language, it seems almost sacrilegious to suggest that people should comply to |
|||
one method! We'll keep it really brief! |
|||
|
|||
|
|||
#### Whitespace |
|||
|
|||
Our Ruby style is to use spaces and to use 2 of them per indent level. It's a |
|||
nice power-of-2 number that really grooves with Ruby's compact style. We have no |
|||
more reason than that. We break that rule when we have lines that wrap. When |
|||
that happens, we like to indent further to line things up in nice tidy columns. |
|||
|
|||
|
|||
#### Case |
|||
|
|||
- Files - all lower case with underscores. |
|||
- Variables - all lower case with underscores |
|||
- Classes, Modules, etc - Camel cased. |
|||
- Functions - all lower case with underscores |
|||
- Constants - all upper case with underscores |
|||
|
|||
|
|||
## Documentation |
|||
|
|||
Egad. Really? We use mark down and we like pdf files because they can be made to |
|||
look nice while still being portable. Good enough? |
|||
|
|||
|
|||
*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)* |
Binary file not shown.
@ -0,0 +1,814 @@ |
|||
# Unity Assertions Reference |
|||
|
|||
## Background and Overview |
|||
|
|||
### Super Condensed Version |
|||
|
|||
- An assertion establishes truth (i.e. boolean True) for a single condition. |
|||
Upon boolean False, an assertion stops execution and reports the failure. |
|||
- Unity is mainly a rich collection of assertions and the support to gather up |
|||
and easily execute those assertions. |
|||
- The structure of Unity allows you to easily separate test assertions from |
|||
source code in, well, test code. |
|||
- Unity's assertions: |
|||
- Come in many, many flavors to handle different C types and assertion cases. |
|||
- Use context to provide detailed and helpful failure messages. |
|||
- Document types, expected values, and basic behavior in your source code for |
|||
free. |
|||
|
|||
|
|||
### Unity Is Several Things But Mainly It's Assertions |
|||
|
|||
One way to think of Unity is simply as a rich collection of assertions you can |
|||
use to establish whether your source code behaves the way you think it does. |
|||
Unity provides a framework to easily organize and execute those assertions in |
|||
test code separate from your source code. |
|||
|
|||
|
|||
### What's an Assertion? |
|||
|
|||
At their core, assertions are an establishment of truth - boolean truth. Was this |
|||
thing equal to that thing? Does that code doohickey have such-and-such property |
|||
or not? You get the idea. Assertions are executable code (to appreciate the big |
|||
picture on this read up on the difference between |
|||
[link:Dynamic Verification and Static Analysis]). A failing assertion stops |
|||
execution and reports an error through some appropriate I/O channel (e.g. |
|||
stdout, GUI, file, blinky light). |
|||
|
|||
Fundamentally, for dynamic verification all you need is a single assertion |
|||
mechanism. In fact, that's what the [assert() macro in C's standard library](http://en.wikipedia.org/en/wiki/Assert.h) |
|||
is for. So why not just use it? Well, we can do far better in the reporting |
|||
department. C's `assert()` is pretty dumb as-is and is particularly poor for |
|||
handling common data types like arrays, structs, etc. And, without some other |
|||
support, it's far too tempting to litter source code with C's `assert()`'s. It's |
|||
generally much cleaner, manageable, and more useful to separate test and source |
|||
code in the way Unity facilitates. |
|||
|
|||
|
|||
### Unity's Assertions: Helpful Messages _and_ Free Source Code Documentation |
|||
|
|||
Asserting a simple truth condition is valuable, but using the context of the |
|||
assertion is even more valuable. For instance, if you know you're comparing bit |
|||
flags and not just integers, then why not use that context to give explicit, |
|||
readable, bit-level feedback when an assertion fails? |
|||
|
|||
That's what Unity's collection of assertions do - capture context to give you |
|||
helpful, meaningful assertion failure messages. In fact, the assertions |
|||
themselves also serve as executable documentation about types and values in your |
|||
source code. So long as your tests remain current with your source and all those |
|||
tests pass, you have a detailed, up-to-date view of the intent and mechanisms in |
|||
your source code. And due to a wondrous mystery, well-tested code usually tends |
|||
to be well designed code. |
|||
|
|||
|
|||
## Assertion Conventions and Configurations |
|||
|
|||
### Naming and Parameter Conventions |
|||
|
|||
The convention of assertion parameters generally follows this order: |
|||
|
|||
TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} ) |
|||
|
|||
The very simplest assertion possible uses only a single "actual" parameter (e.g. |
|||
a simple null check). |
|||
|
|||
"Actual" is the value being tested and unlike the other parameters in an |
|||
assertion construction is the only parameter present in all assertion variants. |
|||
"Modifiers" are masks, ranges, bit flag specifiers, floating point deltas. |
|||
"Expected" is your expected value (duh) to compare to an "actual" value; it's |
|||
marked as an optional parameter because some assertions only need a single |
|||
"actual" parameter (e.g. null check). |
|||
"Size/count" refers to string lengths, number of array elements, etc. |
|||
|
|||
Many of Unity's assertions are clear duplications in that the same data type |
|||
is handled by several assertions. The differences among these are in how failure |
|||
messages are presented. For instance, a `_HEX` variant of an assertion prints |
|||
the expected and actual values of that assertion formatted as hexadecimal. |
|||
|
|||
|
|||
#### TEST_ASSERT_X_MESSAGE Variants |
|||
|
|||
_All_ assertions are complemented with a variant that includes a simple string |
|||
message as a final parameter. The string you specify is appended to an assertion |
|||
failure message in Unity output. |
|||
|
|||
For brevity, the assertion variants with a message parameter are not listed |
|||
below. Just tack on `_MESSAGE` as the final component to any assertion name in |
|||
the reference list below and add a string as the final parameter. |
|||
|
|||
_Example:_ |
|||
|
|||
TEST_ASSERT_X( {modifiers}, {expected}, actual, {size/count} ) |
|||
|
|||
becomes messageified like thus... |
|||
|
|||
TEST_ASSERT_X_MESSAGE( {modifiers}, {expected}, actual, {size/count}, message ) |
|||
|
|||
Notes: |
|||
- The `_MESSAGE` variants intentionally do not support `printf` style formatting |
|||
since many embedded projects don't support or avoid `printf` for various reasons. |
|||
It is possible to use `sprintf` before the assertion to assemble a complex fail |
|||
message, if necessary. |
|||
- If you want to output a counter value within an assertion fail message (e.g. from |
|||
a loop) , building up an array of results and then using one of the `_ARRAY` |
|||
assertions (see below) might be a handy alternative to `sprintf`. |
|||
|
|||
|
|||
#### TEST_ASSERT_X_ARRAY Variants |
|||
|
|||
Unity provides a collection of assertions for arrays containing a variety of |
|||
types. These are documented in the Array section below. These are almost on par |
|||
with the `_MESSAGE`variants of Unity's Asserts in that for pretty much any Unity |
|||
type assertion you can tack on `_ARRAY` and run assertions on an entire block of |
|||
memory. |
|||
|
|||
TEST_ASSERT_EQUAL_TYPEX_ARRAY( expected, actual, {size/count} ) |
|||
|
|||
"Expected" is an array itself. |
|||
"Size/count" is one or two parameters necessary to establish the number of array |
|||
elements and perhaps the length of elements within the array. |
|||
|
|||
Notes: |
|||
- The `_MESSAGE` variant convention still applies here to array assertions. The |
|||
`_MESSAGE` variants of the `_ARRAY` assertions have names ending with |
|||
`_ARRAY_MESSAGE`. |
|||
- Assertions for handling arrays of floating point values are grouped with float |
|||
and double assertions (see immediately following section). |
|||
|
|||
|
|||
### TEST_ASSERT_EACH_EQUAL_X Variants |
|||
|
|||
Unity provides a collection of assertions for arrays containing a variety of |
|||
types which can be compared to a single value as well. These are documented in |
|||
the Each Equal section below. these are almost on par with the `_MESSAGE` |
|||
variants of Unity's Asserts in that for pretty much any Unity type assertion you |
|||
can inject _EACH_EQUAL and run assertions on an entire block of memory. |
|||
|
|||
TEST_ASSERT_EACH_EQUAL_TYPEX( expected, actual, {size/count} ) |
|||
|
|||
"Expected" is a single value to compare to. |
|||
"Actual" is an array where each element will be compared to the expected value. |
|||
"Size/count" is one of two parameters necessary to establish the number of array |
|||
elements and perhaps the length of elements within the array. |
|||
|
|||
Notes: |
|||
- The `_MESSAGE` variant convention still applies here to Each Equal assertions. |
|||
- Assertions for handling Each Equal of floating point values are grouped with |
|||
float and double assertions (see immediately following section). |
|||
|
|||
|
|||
### Configuration |
|||
|
|||
#### Floating Point Support Is Optional |
|||
|
|||
Support for floating point types is configurable. That is, by defining the |
|||
appropriate preprocessor symbols, floats and doubles can be individually enabled |
|||
or disabled in Unity code. This is useful for embedded targets with no floating |
|||
point math support (i.e. Unity compiles free of errors for fixed point only |
|||
platforms). See Unity documentation for specifics. |
|||
|
|||
|
|||
#### Maximum Data Type Width Is Configurable |
|||
|
|||
Not all targets support 64 bit wide types or even 32 bit wide types. Define the |
|||
appropriate preprocessor symbols and Unity will omit all operations from |
|||
compilation that exceed the maximum width of your target. See Unity |
|||
documentation for specifics. |
|||
|
|||
|
|||
## The Assertions in All Their Blessed Glory |
|||
|
|||
### Basic Fail and Ignore |
|||
|
|||
##### `TEST_FAIL()` |
|||
|
|||
This fella is most often used in special conditions where your test code is |
|||
performing logic beyond a simple assertion. That is, in practice, `TEST_FAIL()` |
|||
will always be found inside a conditional code block. |
|||
|
|||
_Examples:_ |
|||
- Executing a state machine multiple times that increments a counter your test |
|||
code then verifies as a final step. |
|||
- Triggering an exception and verifying it (as in Try / Catch / Throw - see the |
|||
[CException](https://github.com/ThrowTheSwitch/CException) project). |
|||
|
|||
##### `TEST_IGNORE()` |
|||
|
|||
Marks a test case (i.e. function meant to contain test assertions) as ignored. |
|||
Usually this is employed as a breadcrumb to come back and implement a test case. |
|||
An ignored test case has effects if other assertions are in the enclosing test |
|||
case (see Unity documentation for more). |
|||
|
|||
### Boolean |
|||
|
|||
##### `TEST_ASSERT (condition)` |
|||
|
|||
##### `TEST_ASSERT_TRUE (condition)` |
|||
|
|||
##### `TEST_ASSERT_FALSE (condition)` |
|||
|
|||
##### `TEST_ASSERT_UNLESS (condition)` |
|||
|
|||
A simple wording variation on `TEST_ASSERT_FALSE`.The semantics of |
|||
`TEST_ASSERT_UNLESS` aid readability in certain test constructions or |
|||
conditional statements. |
|||
|
|||
##### `TEST_ASSERT_NULL (pointer)` |
|||
|
|||
##### `TEST_ASSERT_NOT_NULL (pointer)` |
|||
|
|||
|
|||
### Signed and Unsigned Integers (of all sizes) |
|||
|
|||
Large integer sizes can be disabled for build targets that do not support them. |
|||
For example, if your target only supports up to 16 bit types, by defining the |
|||
appropriate symbols Unity can be configured to omit 32 and 64 bit operations |
|||
that would break compilation (see Unity documentation for more). Refer to |
|||
Advanced Asserting later in this document for advice on dealing with other word |
|||
sizes. |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT8 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT16 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT32 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT64 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_NOT_EQUAL (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT8 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT16 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT32 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT64 (expected, actual)` |
|||
|
|||
|
|||
### Unsigned Integers (of all sizes) in Hexadecimal |
|||
|
|||
All `_HEX` assertions are identical in function to unsigned integer assertions |
|||
but produce failure messages with the `expected` and `actual` values formatted |
|||
in hexadecimal. Unity output is big endian. |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX8 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX16 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX32 (expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX64 (expected, actual)` |
|||
|
|||
|
|||
### Masked and Bit-level Assertions |
|||
|
|||
Masked and bit-level assertions produce output formatted in hexadecimal. Unity |
|||
output is big endian. |
|||
|
|||
|
|||
##### `TEST_ASSERT_BITS (mask, expected, actual)` |
|||
|
|||
Only compares the masked (i.e. high) bits of `expected` and `actual` parameters. |
|||
|
|||
|
|||
##### `TEST_ASSERT_BITS_HIGH (mask, actual)` |
|||
|
|||
Asserts the masked bits of the `actual` parameter are high. |
|||
|
|||
|
|||
##### `TEST_ASSERT_BITS_LOW (mask, actual)` |
|||
|
|||
Asserts the masked bits of the `actual` parameter are low. |
|||
|
|||
|
|||
##### `TEST_ASSERT_BIT_HIGH (bit, actual)` |
|||
|
|||
Asserts the specified bit of the `actual` parameter is high. |
|||
|
|||
|
|||
##### `TEST_ASSERT_BIT_LOW (bit, actual)` |
|||
|
|||
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) |
|||
|
|||
These assertions verify that the `expected` parameter is within +/- `delta` |
|||
(inclusive) of the `actual` parameter. For example, if the expected value is 10 |
|||
and the delta is 3 then the assertion will fail for any value outside the range |
|||
of 7 - 13. |
|||
|
|||
##### `TEST_ASSERT_INT_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_INT8_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_INT16_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_INT32_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_INT64_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT8_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT16_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT32_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT64_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX8_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX16_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX32_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX64_WITHIN (delta, expected, actual)` |
|||
|
|||
### Structs and Strings |
|||
|
|||
##### `TEST_ASSERT_EQUAL_PTR (expected, actual)` |
|||
|
|||
Asserts that the pointers point to the same memory location. |
|||
|
|||
|
|||
##### `TEST_ASSERT_EQUAL_STRING (expected, actual)` |
|||
|
|||
Asserts that the null terminated (`'\0'`)strings are identical. If strings are |
|||
of different lengths or any portion of the strings before their terminators |
|||
differ, the assertion fails. Two NULL strings (i.e. zero length) are considered |
|||
equivalent. |
|||
|
|||
|
|||
##### `TEST_ASSERT_EQUAL_MEMORY (expected, actual, len)` |
|||
|
|||
Asserts that the contents of the memory specified by the `expected` and `actual` |
|||
pointers is identical. The size of the memory blocks in bytes is specified by |
|||
the `len` parameter. |
|||
|
|||
|
|||
### Arrays |
|||
|
|||
`expected` and `actual` parameters are both arrays. `num_elements` specifies the |
|||
number of elements in the arrays to compare. |
|||
|
|||
`_HEX` assertions produce failure messages with expected and actual array |
|||
contents formatted in hexadecimal. |
|||
|
|||
For array of strings comparison behavior, see comments for |
|||
`TEST_ASSERT_EQUAL_STRING` in the preceding section. |
|||
|
|||
Assertions fail upon the first element in the compared arrays found not to |
|||
match. Failure messages specify the array index of the failed comparison. |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT8_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT16_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT32_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_INT64_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT8_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT16_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT32_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_UINT64_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX8_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX16_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX32_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_HEX64_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_PTR_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_STRING_ARRAY (expected, actual, num_elements)` |
|||
|
|||
##### `TEST_ASSERT_EQUAL_MEMORY_ARRAY (expected, actual, len, num_elements)` |
|||
|
|||
`len` is the memory in bytes to be compared at each array element. |
|||
|
|||
### Integer Array Ranges (of all sizes) |
|||
|
|||
These assertions verify that the `expected` array parameter is within +/- `delta` |
|||
(inclusive) of the `actual` array parameter. For example, if the expected value is |
|||
\[10, 12\] and the delta is 3 then the assertion will fail for any value |
|||
outside the range of \[7 - 13, 9 - 15\]. |
|||
|
|||
##### `TEST_ASSERT_INT_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_INT8_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_INT16_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_INT32_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_INT64_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT8_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT16_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT32_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_UINT64_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX8_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX16_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX32_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
##### `TEST_ASSERT_HEX64_ARRAY_WITHIN (delta, expected, actual)` |
|||
|
|||
### Each Equal (Arrays to Single Value) |
|||
|
|||
`expected` are single values and `actual` are arrays. `num_elements` specifies |
|||
the number of elements in the arrays to compare. |
|||
|
|||
`_HEX` assertions produce failure messages with expected and actual array |
|||
contents formatted in hexadecimal. |
|||
|
|||
Assertions fail upon the first element in the compared arrays found not to |
|||
match. Failure messages specify the array index of the failed comparison. |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_INT (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_INT8 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_INT16 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_INT32 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_INT64 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_UINT (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_UINT8 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_UINT16 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_UINT32 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_UINT64 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_HEX (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_HEX8 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_HEX16 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_HEX32 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_HEX64 (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_PTR (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_STRING (expected, actual, num_elements)` |
|||
|
|||
#### `TEST_ASSERT_EACH_EQUAL_MEMORY (expected, actual, len, num_elements)` |
|||
|
|||
`len` is the memory in bytes to be compared at each array element. |
|||
|
|||
|
|||
### Floating Point (If enabled) |
|||
|
|||
##### `TEST_ASSERT_FLOAT_WITHIN (delta, expected, actual)` |
|||
|
|||
Asserts that the `actual` value is within +/- `delta` of the `expected` value. |
|||
The nature of floating point representation is such that exact evaluations of |
|||
equality are not guaranteed. |
|||
|
|||
|
|||
##### `TEST_ASSERT_EQUAL_FLOAT (expected, actual)` |
|||
|
|||
Asserts that the ?actual?value is "close enough to be considered equal" to the |
|||
`expected` value. If you are curious about the details, refer to the Advanced |
|||
Asserting section for more details on this. Omitting a user-specified delta in a |
|||
floating point assertion is both a shorthand convenience and a requirement of |
|||
code generation conventions for CMock. |
|||
|
|||
|
|||
##### `TEST_ASSERT_EQUAL_FLOAT_ARRAY (expected, actual, num_elements)` |
|||
|
|||
See Array assertion section for details. Note that individual array element |
|||
float comparisons are executed using T?EST_ASSERT_EQUAL_FLOAT?.That is, user |
|||
specified delta comparison values requires a custom-implemented floating point |
|||
array assertion. |
|||
|
|||
|
|||
##### `TEST_ASSERT_FLOAT_IS_INF (actual)` |
|||
|
|||
Asserts that `actual` parameter is equivalent to positive infinity floating |
|||
point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_FLOAT_IS_NEG_INF (actual)` |
|||
|
|||
Asserts that `actual` parameter is equivalent to negative infinity floating |
|||
point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_FLOAT_IS_NAN (actual)` |
|||
|
|||
Asserts that `actual` parameter is a Not A Number floating point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_FLOAT_IS_DETERMINATE (actual)` |
|||
|
|||
Asserts that ?actual?parameter is a floating point representation usable for |
|||
mathematical operations. That is, the `actual` parameter is neither positive |
|||
infinity nor negative infinity nor Not A Number floating point representations. |
|||
|
|||
|
|||
##### `TEST_ASSERT_FLOAT_IS_NOT_INF (actual)` |
|||
|
|||
Asserts that `actual` parameter is a value other than positive infinity floating |
|||
point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_FLOAT_IS_NOT_NEG_INF (actual)` |
|||
|
|||
Asserts that `actual` parameter is a value other than negative infinity floating |
|||
point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_FLOAT_IS_NOT_NAN (actual)` |
|||
|
|||
Asserts that `actual` parameter is a value other than Not A Number floating |
|||
point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE (actual)` |
|||
|
|||
Asserts that `actual` parameter is not usable for mathematical operations. That |
|||
is, the `actual` parameter is either positive infinity or negative infinity or |
|||
Not A Number floating point representations. |
|||
|
|||
|
|||
### Double (If enabled) |
|||
|
|||
##### `TEST_ASSERT_DOUBLE_WITHIN (delta, expected, actual)` |
|||
|
|||
Asserts that the `actual` value is within +/- `delta` of the `expected` value. |
|||
The nature of floating point representation is such that exact evaluations of |
|||
equality are not guaranteed. |
|||
|
|||
|
|||
##### `TEST_ASSERT_EQUAL_DOUBLE (expected, actual)` |
|||
|
|||
Asserts that the `actual` value is "close enough to be considered equal" to the |
|||
`expected` value. If you are curious about the details, refer to the Advanced |
|||
Asserting section for more details. Omitting a user-specified delta in a |
|||
floating point assertion is both a shorthand convenience and a requirement of |
|||
code generation conventions for CMock. |
|||
|
|||
|
|||
##### `TEST_ASSERT_EQUAL_DOUBLE_ARRAY (expected, actual, num_elements)` |
|||
|
|||
See Array assertion section for details. Note that individual array element |
|||
double comparisons are executed using `TEST_ASSERT_EQUAL_DOUBLE`.That is, user |
|||
specified delta comparison values requires a custom implemented double array |
|||
assertion. |
|||
|
|||
|
|||
##### `TEST_ASSERT_DOUBLE_IS_INF (actual)` |
|||
|
|||
Asserts that `actual` parameter is equivalent to positive infinity floating |
|||
point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_DOUBLE_IS_NEG_INF (actual)` |
|||
|
|||
Asserts that `actual` parameter is equivalent to negative infinity floating point |
|||
representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_DOUBLE_IS_NAN (actual)` |
|||
|
|||
Asserts that `actual` parameter is a Not A Number floating point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_DOUBLE_IS_DETERMINATE (actual)` |
|||
|
|||
Asserts that `actual` parameter is a floating point representation usable for |
|||
mathematical operations. That is, the ?actual?parameter is neither positive |
|||
infinity nor negative infinity nor Not A Number floating point representations. |
|||
|
|||
|
|||
##### `TEST_ASSERT_DOUBLE_IS_NOT_INF (actual)` |
|||
|
|||
Asserts that `actual` parameter is a value other than positive infinity floating |
|||
point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF (actual)` |
|||
|
|||
Asserts that `actual` parameter is a value other than negative infinity floating |
|||
point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_DOUBLE_IS_NOT_NAN (actual)` |
|||
|
|||
Asserts that `actual` parameter is a value other than Not A Number floating |
|||
point representation. |
|||
|
|||
|
|||
##### `TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE (actual)` |
|||
|
|||
Asserts that `actual` parameter is not usable for mathematical operations. That |
|||
is, the `actual` parameter is either positive infinity or negative infinity or |
|||
Not A Number floating point representations. |
|||
|
|||
|
|||
## Advanced Asserting: Details On Tricky Assertions |
|||
|
|||
This section helps you understand how to deal with some of the trickier |
|||
assertion situations you may run into. It will give you a glimpse into some of |
|||
the under-the-hood details of Unity's assertion mechanisms. If you're one of |
|||
those people who likes to know what is going on in the background, read on. If |
|||
not, feel free to ignore the rest of this document until you need it. |
|||
|
|||
|
|||
### How do the EQUAL assertions work for FLOAT and DOUBLE? |
|||
|
|||
As you may know, directly checking for equality between a pair of floats or a |
|||
pair of doubles is sloppy at best and an outright no-no at worst. Floating point |
|||
values can often be represented in multiple ways, particularly after a series of |
|||
operations on a value. Initializing a variable to the value of 2.0 is likely to |
|||
result in a floating point representation of 2 x 20,but a series of |
|||
mathematical operations might result in a representation of 8 x 2-2 |
|||
that also evaluates to a value of 2. At some point repeated operations cause |
|||
equality checks to fail. |
|||
|
|||
So Unity doesn't do direct floating point comparisons for equality. Instead, it |
|||
checks if two floating point values are "really close." If you leave Unity |
|||
running with defaults, "really close" means "within a significant bit or two." |
|||
Under the hood, `TEST_ASSERT_EQUAL_FLOAT` is really `TEST_ASSERT_FLOAT_WITHIN` |
|||
with the `delta` parameter calculated on the fly. For single precision, delta is |
|||
the expected value multiplied by 0.00001, producing a very small proportional |
|||
range around the expected value. |
|||
|
|||
If you are expecting a value of 20,000.0 the delta is calculated to be 0.2. So |
|||
any value between 19,999.8 and 20,000.2 will satisfy the equality check. This |
|||
works out to be roughly a single bit of range for a single-precision number, and |
|||
that's just about as tight a tolerance as you can reasonably get from a floating |
|||
point value. |
|||
|
|||
So what happens when it's zero? Zero - even more than other floating point |
|||
values - can be represented many different ways. It doesn't matter if you have |
|||
0 x 20 or 0 x 263.It's still zero, right? Luckily, if you |
|||
subtract these values from each other, they will always produce a difference of |
|||
zero, which will still fall between 0 plus or minus a delta of 0. So it still |
|||
works! |
|||
|
|||
Double precision floating point numbers use a much smaller multiplier, again |
|||
approximating a single bit of error. |
|||
|
|||
If you don't like these ranges and you want to make your floating point equality |
|||
assertions less strict, you can change these multipliers to whatever you like by |
|||
defining UNITY_FLOAT_PRECISION and UNITY_DOUBLE_PRECISION. See Unity |
|||
documentation for more. |
|||
|
|||
|
|||
### How do we deal with targets with non-standard int sizes? |
|||
|
|||
It's "fun" that C is a standard where something as fundamental as an integer |
|||
varies by target. According to the C standard, an `int` is to be the target's |
|||
natural register size, and it should be at least 16-bits and a multiple of a |
|||
byte. It also guarantees an order of sizes: |
|||
|
|||
```C |
|||
char <= short <= int <= long <= long long |
|||
``` |
|||
|
|||
Most often, `int` is 32-bits. In many cases in the embedded world, `int` is |
|||
16-bits. There are rare microcontrollers out there that have 24-bit integers, |
|||
and this remains perfectly standard C. |
|||
|
|||
To make things even more interesting, there are compilers and targets out there |
|||
that have a hard choice to make. What if their natural register size is 10-bits |
|||
or 12-bits? Clearly they can't fulfill _both_ the requirement to be at least |
|||
16-bits AND the requirement to match the natural register size. In these |
|||
situations, they often choose the natural register size, leaving us with |
|||
something like this: |
|||
|
|||
```C |
|||
char (8 bit) <= short (12 bit) <= int (12 bit) <= long (16 bit) |
|||
``` |
|||
|
|||
Um... yikes. It's obviously breaking a rule or two... but they had to break SOME |
|||
rules, so they made a choice. |
|||
|
|||
When the C99 standard rolled around, it introduced alternate standard-size types. |
|||
It also introduced macros for pulling in MIN/MAX values for your integer types. |
|||
It's glorious! Unfortunately, many embedded compilers can't be relied upon to |
|||
use the C99 types (Sometimes because they have weird register sizes as described |
|||
above. Sometimes because they don't feel like it?). |
|||
|
|||
A goal of Unity from the beginning was to support every combination of |
|||
microcontroller or microprocessor and C compiler. Over time, we've gotten really |
|||
close to this. There are a few tricks that you should be aware of, though, if |
|||
you're going to do this effectively on some of these more idiosyncratic targets. |
|||
|
|||
First, when setting up Unity for a new target, you're going to want to pay |
|||
special attention to the macros for automatically detecting types |
|||
(where available) or manually configuring them yourself. You can get information |
|||
on both of these in Unity's documentation. |
|||
|
|||
What about the times where you suddenly need to deal with something odd, like a |
|||
24-bit `int`? The simplest solution is to use the next size up. If you have a |
|||
24-bit `int`, configure Unity to use 32-bit integers. If you have a 12-bit |
|||
`int`, configure Unity to use 16 bits. There are two ways this is going to |
|||
affect you: |
|||
|
|||
1. When Unity displays errors for you, it's going to pad the upper unused bits |
|||
with zeros. |
|||
2. You're going to have to be careful of assertions that perform signed |
|||
operations, particularly `TEST_ASSERT_INT_WITHIN`.Such assertions might wrap |
|||
your `int` in the wrong place, and you could experience false failures. You can |
|||
always back down to a simple `TEST_ASSERT` and do the operations yourself. |
|||
|
|||
|
|||
*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)* |
@ -0,0 +1,520 @@ |
|||
# Unity Configuration Guide |
|||
|
|||
## C Standards, Compilers and Microcontrollers |
|||
|
|||
The embedded software world contains its challenges. Compilers support different |
|||
revisions of the C Standard. They ignore requirements in places, sometimes to |
|||
make the language more usable in some special regard. Sometimes it's to simplify |
|||
their support. Sometimes it's due to specific quirks of the microcontroller they |
|||
are targeting. Simulators add another dimension to this menagerie. |
|||
|
|||
Unity is designed to run on almost anything that is targeted by a C compiler. It |
|||
would be awesome if this could be done with zero configuration. While there are |
|||
some targets that come close to this dream, it is sadly not universal. It is |
|||
likely that you are going to need at least a couple of the configuration options |
|||
described in this document. |
|||
|
|||
All of Unity's configuration options are `#defines`. Most of these are simple |
|||
definitions. A couple are macros with arguments. They live inside the |
|||
unity_internals.h header file. We don't necessarily recommend opening that file |
|||
unless you really need to. That file is proof that a cross-platform library is |
|||
challenging to build. From a more positive perspective, it is also proof that a |
|||
great deal of complexity can be centralized primarily to one place to |
|||
provide a more consistent and simple experience elsewhere. |
|||
|
|||
|
|||
### Using These Options |
|||
|
|||
It doesn't matter if you're using a target-specific compiler and a simulator or |
|||
a native compiler. In either case, you've got a couple choices for configuring |
|||
these options: |
|||
|
|||
1. Because these options are specified via C defines, you can pass most of these |
|||
options to your compiler through command line compiler flags. Even if you're |
|||
using an embedded target that forces you to use their overbearing IDE for all |
|||
configuration, there will be a place somewhere in your project to configure |
|||
defines for your compiler. |
|||
2. You can create a custom `unity_config.h` configuration file (present in your |
|||
toolchain's search paths). In this file, you will list definitions and macros |
|||
specific to your target. All you must do is define `UNITY_INCLUDE_CONFIG_H` and |
|||
Unity will rely on `unity_config.h` for any further definitions it may need. |
|||
|
|||
|
|||
## The Options |
|||
|
|||
### Integer Types |
|||
|
|||
If you've been a C developer for long, you probably already know that C's |
|||
concept of an integer varies from target to target. The C Standard has rules |
|||
about the `int` matching the register size of the target microprocessor. It has |
|||
rules about the `int` and how its size relates to other integer types. An `int` |
|||
on one target might be 16 bits while on another target it might be 64. There are |
|||
more specific types in compilers compliant with C99 or later, but that's |
|||
certainly not every compiler you are likely to encounter. Therefore, Unity has a |
|||
number of features for helping to adjust itself to match your required integer |
|||
sizes. It starts off by trying to do it automatically. |
|||
|
|||
|
|||
##### `UNITY_EXCLUDE_STDINT_H` |
|||
|
|||
The first thing that Unity does to guess your types is check `stdint.h`. |
|||
This file includes defines like `UINT_MAX` that Unity can use to |
|||
learn a lot about your system. It's possible you don't want it to do this |
|||
(um. why not?) or (more likely) it's possible that your system doesn't |
|||
support `stdint.h`. If that's the case, you're going to want to define this. |
|||
That way, Unity will know to skip the inclusion of this file and you won't |
|||
be left with a compiler error. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_EXCLUDE_STDINT_H |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_EXCLUDE_LIMITS_H` |
|||
|
|||
The second attempt to guess your types is to check `limits.h`. Some compilers |
|||
that don't support `stdint.h` could include `limits.h` instead. If you don't |
|||
want Unity to check this file either, define this to make it skip the inclusion. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_EXCLUDE_LIMITS_H |
|||
``` |
|||
|
|||
If you've disabled both of the automatic options above, you're going to have to |
|||
do the configuration yourself. Don't worry. Even this isn't too bad... there are |
|||
just a handful of defines that you are going to specify if you don't like the |
|||
defaults. |
|||
|
|||
|
|||
##### `UNITY_INT_WIDTH` |
|||
|
|||
Define this to be the number of bits an `int` takes up on your system. The |
|||
default, if not autodetected, is 32 bits. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_INT_WIDTH 16 |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_LONG_WIDTH` |
|||
|
|||
Define this to be the number of bits a `long` takes up on your system. The |
|||
default, if not autodetected, is 32 bits. This is used to figure out what kind |
|||
of 64-bit support your system can handle. Does it need to specify a `long` or a |
|||
`long long` to get a 64-bit value. On 16-bit systems, this option is going to be |
|||
ignored. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_LONG_WIDTH 16 |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_POINTER_WIDTH` |
|||
|
|||
Define this to be the number of bits a pointer takes up on your system. The |
|||
default, if not autodetected, is 32-bits. If you're getting ugly compiler |
|||
warnings about casting from pointers, this is the one to look at. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_POINTER_WIDTH 64 |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_SUPPORT_64` |
|||
|
|||
Unity will automatically include 64-bit support if it auto-detects it, or if |
|||
your `int`, `long`, or pointer widths are greater than 32-bits. Define this to |
|||
enable 64-bit support if none of the other options already did it for you. There |
|||
can be a significant size and speed impact to enabling 64-bit support on small |
|||
targets, so don't define it if you don't need it. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_SUPPORT_64 |
|||
``` |
|||
|
|||
|
|||
### Floating Point Types |
|||
|
|||
In the embedded world, it's not uncommon for targets to have no support for |
|||
floating point operations at all or to have support that is limited to only |
|||
single precision. We are able to guess integer sizes on the fly because integers |
|||
are always available in at least one size. Floating point, on the other hand, is |
|||
sometimes not available at all. Trying to include `float.h` on these platforms |
|||
would result in an error. This leaves manual configuration as the only option. |
|||
|
|||
|
|||
##### `UNITY_INCLUDE_FLOAT` |
|||
|
|||
##### `UNITY_EXCLUDE_FLOAT` |
|||
|
|||
##### `UNITY_INCLUDE_DOUBLE` |
|||
|
|||
##### `UNITY_EXCLUDE_DOUBLE` |
|||
|
|||
By default, Unity guesses that you will want single precision floating point |
|||
support, but not double precision. It's easy to change either of these using the |
|||
include and exclude options here. You may include neither, either, or both, as |
|||
suits your needs. For features that are enabled, the following floating point |
|||
options also become available. |
|||
|
|||
_Example:_ |
|||
```C |
|||
//what manner of strange processor is this? |
|||
#define UNITY_EXCLUDE_FLOAT |
|||
#define UNITY_INCLUDE_DOUBLE |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_EXCLUDE_FLOAT_PRINT` |
|||
|
|||
Unity aims for as small of a footprint as possible and avoids most standard |
|||
library calls (some embedded platforms don’t have a standard library!). Because |
|||
of this, its routines for printing integer values are minimalist and hand-coded. |
|||
Therefore, the display of floating point values during a failure are optional. |
|||
By default, Unity will print the actual results of floating point assertion |
|||
failure (e.g. ”Expected 4.56 Was 4.68”). To not include this extra support, you |
|||
can use this define to instead respond to a failed assertion with a message like |
|||
”Values Not Within Delta”. If you would like verbose failure messages for floating |
|||
point assertions, use these options to give more explicit failure messages. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_EXCLUDE_FLOAT_PRINT |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_FLOAT_TYPE` |
|||
|
|||
If enabled, Unity assumes you want your `FLOAT` asserts to compare standard C |
|||
floats. If your compiler supports a specialty floating point type, you can |
|||
always override this behavior by using this definition. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_FLOAT_TYPE float16_t |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_DOUBLE_TYPE` |
|||
|
|||
If enabled, Unity assumes you want your `DOUBLE` asserts to compare standard C |
|||
doubles. If you would like to change this, you can specify something else by |
|||
using this option. For example, defining `UNITY_DOUBLE_TYPE` to `long double` |
|||
could enable gargantuan floating point types on your 64-bit processor instead of |
|||
the standard `double`. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_DOUBLE_TYPE long double |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_FLOAT_PRECISION` |
|||
|
|||
##### `UNITY_DOUBLE_PRECISION` |
|||
|
|||
If you look up `UNITY_ASSERT_EQUAL_FLOAT` and `UNITY_ASSERT_EQUAL_DOUBLE` as |
|||
documented in the big daddy Unity Assertion Guide, you will learn that they are |
|||
not really asserting that two values are equal but rather that two values are |
|||
"close enough" to equal. "Close enough" is controlled by these precision |
|||
configuration options. If you are working with 32-bit floats and/or 64-bit |
|||
doubles (the normal on most processors), you should have no need to change these |
|||
options. They are both set to give you approximately 1 significant bit in either |
|||
direction. The float precision is 0.00001 while the double is 10-12. |
|||
For further details on how this works, see the appendix of the Unity Assertion |
|||
Guide. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_FLOAT_PRECISION 0.001f |
|||
``` |
|||
|
|||
|
|||
### Miscellaneous |
|||
|
|||
##### `UNITY_EXCLUDE_STDDEF_H` |
|||
|
|||
Unity uses the `NULL` macro, which defines the value of a null pointer constant, |
|||
defined in `stddef.h` by default. If you want to provide |
|||
your own macro for this, you should exclude the `stddef.h` header file by adding this |
|||
define to your configuration. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_EXCLUDE_STDDEF_H |
|||
``` |
|||
|
|||
|
|||
#### `UNITY_INCLUDE_PRINT_FORMATTED` |
|||
|
|||
Unity provides a simple (and very basic) printf-like string output implementation, |
|||
which is able to print a string modified by the following format string modifiers: |
|||
|
|||
- __%d__ - signed value (decimal) |
|||
- __%i__ - same as __%i__ |
|||
- __%u__ - unsigned value (decimal) |
|||
- __%f__ - float/Double (if float support is activated) |
|||
- __%g__ - same as __%f__ |
|||
- __%b__ - binary prefixed with "0b" |
|||
- __%x__ - hexadecimal (upper case) prefixed with "0x" |
|||
- __%X__ - same as __%x__ |
|||
- __%p__ - pointer (same as __%x__ or __%X__) |
|||
- __%c__ - a single character |
|||
- __%s__ - a string (e.g. "string") |
|||
- __%%__ - The "%" symbol (escaped) |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_INCLUDE_PRINT_FORMATTED |
|||
|
|||
int a = 0xfab1; |
|||
UnityPrintFormatted("Decimal %d\n", -7); |
|||
UnityPrintFormatted("Unsigned %u\n", 987); |
|||
UnityPrintFormatted("Float %f\n", 3.1415926535897932384); |
|||
UnityPrintFormatted("Binary %b\n", 0xA); |
|||
UnityPrintFormatted("Hex %X\n", 0xFAB); |
|||
UnityPrintFormatted("Pointer %p\n", &a); |
|||
UnityPrintFormatted("Character %c\n", 'F'); |
|||
UnityPrintFormatted("String %s\n", "My string"); |
|||
UnityPrintFormatted("Percent %%\n"); |
|||
UnityPrintFormatted("Color Red \033[41mFAIL\033[00m\n"); |
|||
UnityPrintFormatted("\n"); |
|||
UnityPrintFormatted("Multiple (%d) (%i) (%u) (%x)\n", -100, 0, 200, 0x12345); |
|||
``` |
|||
|
|||
|
|||
### Toolset Customization |
|||
|
|||
In addition to the options listed above, there are a number of other options |
|||
which will come in handy to customize Unity's behavior for your specific |
|||
toolchain. It is possible that you may not need to touch any of these... but |
|||
certain platforms, particularly those running in simulators, may need to jump |
|||
through extra hoops to run properly. These macros will help in those |
|||
situations. |
|||
|
|||
|
|||
##### `UNITY_OUTPUT_CHAR(a)` |
|||
|
|||
##### `UNITY_OUTPUT_FLUSH()` |
|||
|
|||
##### `UNITY_OUTPUT_START()` |
|||
|
|||
##### `UNITY_OUTPUT_COMPLETE()` |
|||
|
|||
By default, Unity prints its results to `stdout` as it runs. This works |
|||
perfectly fine in most situations where you are using a native compiler for |
|||
testing. It works on some simulators as well so long as they have `stdout` |
|||
routed back to the command line. There are times, however, where the simulator |
|||
will lack support for dumping results or you will want to route results |
|||
elsewhere for other reasons. In these cases, you should define the |
|||
`UNITY_OUTPUT_CHAR` macro. This macro accepts a single character at a time (as |
|||
an `int`, since this is the parameter type of the standard C `putchar` function |
|||
most commonly used). You may replace this with whatever function call you like. |
|||
|
|||
_Example:_ |
|||
Say you are forced to run your test suite on an embedded processor with no |
|||
`stdout` option. You decide to route your test result output to a custom serial |
|||
`RS232_putc()` function you wrote like thus: |
|||
```C |
|||
#include "RS232_header.h" |
|||
... |
|||
#define UNITY_OUTPUT_CHAR(a) RS232_putc(a) |
|||
#define UNITY_OUTPUT_START() RS232_config(115200,1,8,0) |
|||
#define UNITY_OUTPUT_FLUSH() RS232_flush() |
|||
#define UNITY_OUTPUT_COMPLETE() RS232_close() |
|||
``` |
|||
|
|||
_Note:_ |
|||
`UNITY_OUTPUT_FLUSH()` can be set to the standard out flush function simply by |
|||
specifying `UNITY_USE_FLUSH_STDOUT`. No other defines are required. |
|||
|
|||
|
|||
##### `UNITY_WEAK_ATTRIBUTE` |
|||
|
|||
##### `UNITY_WEAK_PRAGMA` |
|||
|
|||
##### `UNITY_NO_WEAK` |
|||
|
|||
For some targets, Unity can make the otherwise required setUp() and tearDown() |
|||
functions optional. This is a nice convenience for test writers since setUp and |
|||
tearDown don’t often actually do anything. If you’re using gcc or clang, this |
|||
option is automatically defined for you. Other compilers can also support this |
|||
behavior, if they support a C feature called weak functions. A weak function is |
|||
a function that is compiled into your executable unless a non-weak version of |
|||
the same function is defined elsewhere. If a non-weak version is found, the weak |
|||
version is ignored as if it never existed. If your compiler supports this feature, |
|||
you can let Unity know by defining UNITY_WEAK_ATTRIBUTE or UNITY_WEAK_PRAGMA as |
|||
the function attributes that would need to be applied to identify a function as |
|||
weak. If your compiler lacks support for weak functions, you will always need to |
|||
define setUp and tearDown functions (though they can be and often will be just |
|||
empty). You can also force Unity to NOT use weak functions by defining |
|||
UNITY_NO_WEAK. The most common options for this feature are: |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_WEAK_ATTRIBUTE weak |
|||
#define UNITY_WEAK_ATTRIBUTE __attribute__((weak)) |
|||
#define UNITY_WEAK_PRAGMA |
|||
#define UNITY_NO_WEAK |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_PTR_ATTRIBUTE` |
|||
|
|||
Some compilers require a custom attribute to be assigned to pointers, like |
|||
`near` or `far`. In these cases, you can give Unity a safe default for these by |
|||
defining this option with the attribute you would like. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_PTR_ATTRIBUTE __attribute__((far)) |
|||
#define UNITY_PTR_ATTRIBUTE near |
|||
``` |
|||
|
|||
##### `UNITY_PRINT_EOL` |
|||
|
|||
By default, Unity outputs \n at the end of each line of output. This is easy |
|||
to parse by the scripts, by Ceedling, etc, but it might not be ideal for YOUR |
|||
system. Feel free to override this and to make it whatever you wish. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_PRINT_EOL { UNITY_OUTPUT_CHAR('\r'); UNITY_OUTPUT_CHAR('\n') } |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_EXCLUDE_DETAILS` |
|||
|
|||
This is an option for if you absolutely must squeeze every byte of memory out of |
|||
your system. Unity stores a set of internal scratchpads which are used to pass |
|||
extra detail information around. It's used by systems like CMock in order to |
|||
report which function or argument flagged an error. If you're not using CMock and |
|||
you're not using these details for other things, then you can exclude them. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_EXCLUDE_DETAILS |
|||
``` |
|||
|
|||
|
|||
##### `UNITY_EXCLUDE_SETJMP` |
|||
|
|||
If your embedded system doesn't support the standard library setjmp, you can |
|||
exclude Unity's reliance on this by using this define. This dropped dependence |
|||
comes at a price, though. You will be unable to use custom helper functions for |
|||
your tests, and you will be unable to use tools like CMock. Very likely, if your |
|||
compiler doesn't support setjmp, you wouldn't have had the memory space for those |
|||
things anyway, though... so this option exists for those situations. |
|||
|
|||
_Example:_ |
|||
```C |
|||
#define UNITY_EXCLUDE_SETJMP |
|||
``` |
|||
|
|||
##### `UNITY_OUTPUT_COLOR` |
|||
|
|||
If you want to add color using ANSI escape codes you can use this define. |
|||
t |
|||
_Example:_ |
|||
```C |
|||
#define UNITY_OUTPUT_COLOR |
|||
``` |
|||
|
|||
|
|||
## Getting Into The Guts |
|||
|
|||
There will be cases where the options above aren't quite going to get everything |
|||
perfect. They are likely sufficient for any situation where you are compiling |
|||
and executing your tests with a native toolchain (e.g. clang on Mac). These |
|||
options may even get you through the majority of cases encountered in working |
|||
with a target simulator run from your local command line. But especially if you |
|||
must run your test suite on your target hardware, your Unity configuration will |
|||
require special help. This special help will usually reside in one of two |
|||
places: the `main()` function or the `RUN_TEST` macro. Let's look at how these |
|||
work. |
|||
|
|||
|
|||
##### `main()` |
|||
|
|||
Each test module is compiled and run on its own, separate from the other test |
|||
files in your project. Each test file, therefore, has a `main` function. This |
|||
`main` function will need to contain whatever code is necessary to initialize |
|||
your system to a workable state. This is particularly true for situations where |
|||
you must set up a memory map or initialize a communication channel for the |
|||
output of your test results. |
|||
|
|||
A simple main function looks something like this: |
|||
|
|||
```C |
|||
int main(void) { |
|||
UNITY_BEGIN(); |
|||
RUN_TEST(test_TheFirst); |
|||
RUN_TEST(test_TheSecond); |
|||
RUN_TEST(test_TheThird); |
|||
return UNITY_END(); |
|||
} |
|||
``` |
|||
|
|||
You can see that our main function doesn't bother taking any arguments. For our |
|||
most barebones case, we'll never have arguments because we just run all the |
|||
tests each time. Instead, we start by calling `UNITY_BEGIN`. We run each test |
|||
(in whatever order we wish). Finally, we call `UNITY_END`, returning its return |
|||
value (which is the total number of failures). |
|||
|
|||
It should be easy to see that you can add code before any test cases are run or |
|||
after all the test cases have completed. This allows you to do any needed |
|||
system-wide setup or teardown that might be required for your special |
|||
circumstances. |
|||
|
|||
|
|||
##### `RUN_TEST` |
|||
|
|||
The `RUN_TEST` macro is called with each test case function. Its job is to |
|||
perform whatever setup and teardown is necessary for executing a single test |
|||
case function. This includes catching failures, calling the test module's |
|||
`setUp()` and `tearDown()` functions, and calling `UnityConcludeTest()`. If |
|||
using CMock or test coverage, there will be additional stubs in use here. A |
|||
simple minimalist RUN_TEST macro looks something like this: |
|||
|
|||
```C |
|||
#define RUN_TEST(testfunc) \ |
|||
UNITY_NEW_TEST(#testfunc) \ |
|||
if (TEST_PROTECT()) { \ |
|||
setUp(); \ |
|||
testfunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT() && (!TEST_IS_IGNORED)) \ |
|||
tearDown(); \ |
|||
UnityConcludeTest(); |
|||
``` |
|||
|
|||
So that's quite a macro, huh? It gives you a glimpse of what kind of stuff Unity |
|||
has to deal with for every single test case. For each test case, we declare that |
|||
it is a new test. Then we run `setUp` and our test function. These are run |
|||
within a `TEST_PROTECT` block, the function of which is to handle failures that |
|||
occur during the test. Then, assuming our test is still running and hasn't been |
|||
ignored, we run `tearDown`. No matter what, our last step is to conclude this |
|||
test before moving on to the next. |
|||
|
|||
Let's say you need to add a call to `fsync` to force all of your output data to |
|||
flush to a file after each test. You could easily insert this after your |
|||
`UnityConcludeTest` call. Maybe you want to write an xml tag before and after |
|||
each result set. Again, you could do this by adding lines to this macro. Updates |
|||
to this macro are for the occasions when you need an action before or after |
|||
every single test case throughout your entire suite of tests. |
|||
|
|||
|
|||
## Happy Porting |
|||
|
|||
The defines and macros in this guide should help you port Unity to just about |
|||
any C target we can imagine. If you run into a snag or two, don't be afraid of |
|||
asking for help on the forums. We love a good challenge! |
|||
|
|||
|
|||
*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)* |
@ -0,0 +1,250 @@ |
|||
# Unity - Getting Started |
|||
|
|||
## Welcome |
|||
|
|||
Congratulations. You're now the proud owner of your very own pile of bits! What |
|||
are you going to do with all these ones and zeros? This document should be able |
|||
to help you decide just that. |
|||
|
|||
Unity is a unit test framework. The goal has been to keep it small and |
|||
functional. The core Unity test framework is three files: a single C file and a |
|||
couple header files. These team up to provide functions and macros to make |
|||
testing easier. |
|||
|
|||
Unity was designed to be cross-platform. It works hard to stick with C standards |
|||
while still providing support for the many embedded C compilers that bend the |
|||
rules. Unity has been used with many compilers, including GCC, IAR, Clang, |
|||
Green Hills, Microchip, and MS Visual Studio. It's not much work to get it to |
|||
work with a new target. |
|||
|
|||
|
|||
### Overview of the Documents |
|||
|
|||
#### Unity Assertions reference |
|||
|
|||
This document will guide you through all the assertion options provided by |
|||
Unity. This is going to be your unit testing bread and butter. You'll spend more |
|||
time with assertions than any other part of Unity. |
|||
|
|||
|
|||
#### Unity Assertions Cheat Sheet |
|||
|
|||
This document contains an abridged summary of the assertions described in the |
|||
previous document. It's perfect for printing and referencing while you |
|||
familiarize yourself with Unity's options. |
|||
|
|||
|
|||
#### Unity Configuration Guide |
|||
|
|||
This document is the one to reference when you are going to use Unity with a new |
|||
target or compiler. It'll guide you through the configuration options and will |
|||
help you customize your testing experience to meet your needs. |
|||
|
|||
|
|||
#### Unity Helper Scripts |
|||
|
|||
This document describes the helper scripts that are available for simplifying |
|||
your testing workflow. It describes the collection of optional Ruby scripts |
|||
included in the auto directory of your Unity installation. Neither Ruby nor |
|||
these scripts are necessary for using Unity. They are provided as a convenience |
|||
for those who wish to use them. |
|||
|
|||
|
|||
#### Unity License |
|||
|
|||
What's an open source project without a license file? This brief document |
|||
describes the terms you're agreeing to when you use this software. Basically, we |
|||
want it to be useful to you in whatever context you want to use it, but please |
|||
don't blame us if you run into problems. |
|||
|
|||
|
|||
### Overview of the Folders |
|||
|
|||
If you have obtained Unity through Github or something similar, you might be |
|||
surprised by just how much stuff you suddenly have staring you in the face. |
|||
Don't worry, Unity itself is very small. The rest of it is just there to make |
|||
your life easier. You can ignore it or use it at your convenience. Here's an |
|||
overview of everything in the project. |
|||
|
|||
- `src` - This is the code you care about! This folder contains a C file and two |
|||
header files. These three files _are_ Unity. |
|||
- `docs` - You're reading this document, so it's possible you have found your way |
|||
into this folder already. This is where all the handy documentation can be |
|||
found. |
|||
- `examples` - This contains a few examples of using Unity. |
|||
- `extras` - These are optional add ons to Unity that are not part of the core |
|||
project. If you've reached us through James Grenning's book, you're going to |
|||
want to look here. |
|||
- `test` - This is how Unity and its scripts are all tested. If you're just using |
|||
Unity, you'll likely never need to go in here. If you are the lucky team member |
|||
who gets to port Unity to a new toolchain, this is a good place to verify |
|||
everything is configured properly. |
|||
- `auto` - Here you will find helpful Ruby scripts for simplifying your test |
|||
workflow. They are purely optional and are not required to make use of Unity. |
|||
|
|||
|
|||
## How to Create A Test File |
|||
|
|||
Test files are C files. Most often you will create a single test file for each C |
|||
module that you want to test. The test file should include unity.h and the |
|||
header for your C module to be tested. |
|||
|
|||
Next, a test file will include a `setUp()` and `tearDown()` function. The setUp |
|||
function can contain anything you would like to run before each test. The |
|||
tearDown function can contain anything you would like to run after each test. |
|||
Both functions accept no arguments and return nothing. You may leave either or |
|||
both of these blank if you have no need for them. If you're using a compiler |
|||
that is configured to make these functions optional, you may leave them off |
|||
completely. Not sure? Give it a try. If you compiler complains that it can't |
|||
find setUp or tearDown when it links, you'll know you need to at least include |
|||
an empty function for these. |
|||
|
|||
The majority of the file will be a series of test functions. Test functions |
|||
follow the convention of starting with the word "test_" or "spec_". You don't HAVE |
|||
to name them this way, but it makes it clear what functions are tests for other |
|||
developers. Also, the automated scripts that come with Unity or Ceedling will default |
|||
to looking for test functions to be prefixed this way. Test functions take no arguments |
|||
and return nothing. All test accounting is handled internally in Unity. |
|||
|
|||
Finally, at the bottom of your test file, you will write a `main()` function. |
|||
This function will call `UNITY_BEGIN()`, then `RUN_TEST` for each test, and |
|||
finally `UNITY_END()`.This is what will actually trigger each of those test |
|||
functions to run, so it is important that each function gets its own `RUN_TEST` |
|||
call. |
|||
|
|||
Remembering to add each test to the main function can get to be tedious. If you |
|||
enjoy using helper scripts in your build process, you might consider making use |
|||
of our handy [generate_test_runner.rb](../auto/generate_test_runner.rb) script. |
|||
This will create the main function and all the calls for you, assuming that you |
|||
have followed the suggested naming conventions. In this case, there is no need |
|||
for you to include the main function in your test file at all. |
|||
|
|||
When you're done, your test file will look something like this: |
|||
|
|||
```C |
|||
#include "unity.h" |
|||
#include "file_to_test.h" |
|||
|
|||
void setUp(void) { |
|||
// set stuff up here |
|||
} |
|||
|
|||
void tearDown(void) { |
|||
// clean stuff up here |
|||
} |
|||
|
|||
void test_function_should_doBlahAndBlah(void) { |
|||
//test stuff |
|||
} |
|||
|
|||
void test_function_should_doAlsoDoBlah(void) { |
|||
//more test stuff |
|||
} |
|||
|
|||
// not needed when using generate_test_runner.rb |
|||
int main(void) { |
|||
UNITY_BEGIN(); |
|||
RUN_TEST(test_function_should_doBlahAndBlah); |
|||
RUN_TEST(test_function_should_doAlsoDoBlah); |
|||
return UNITY_END(); |
|||
} |
|||
``` |
|||
|
|||
It's possible that you will need more customization than this, eventually. |
|||
For that sort of thing, you're going to want to look at the configuration guide. |
|||
This should be enough to get you going, though. |
|||
|
|||
### Running Test Functions |
|||
When writing your own `main()` functions, for a test-runner. There are two ways |
|||
to execute the test. |
|||
|
|||
The classic variant |
|||
``` c |
|||
RUN_TEST(func, linenum) |
|||
``` |
|||
or its simpler replacement that starts at the beginning of the function. |
|||
``` c |
|||
RUN_TEST(func) |
|||
``` |
|||
These macros perform the necessary setup before the test is called and |
|||
handles cleanup and result tabulation afterwards. |
|||
|
|||
### Ignoring Test Functions |
|||
There are times when a test is incomplete or not valid for some reason. |
|||
At these times, TEST_IGNORE can be called. Control will immediately be |
|||
returned to the caller of the test, and no failures will be returned. |
|||
This is useful when your test runners are automatically generated. |
|||
|
|||
``` c |
|||
TEST_IGNORE() |
|||
``` |
|||
|
|||
Ignore this test and return immediately |
|||
|
|||
``` c |
|||
TEST_IGNORE_MESSAGE (message) |
|||
``` |
|||
|
|||
Ignore this test and return immediately. Output a message stating why the test was ignored. |
|||
|
|||
### Aborting Tests |
|||
There are times when a test will contain an infinite loop on error conditions, or there may be reason to escape from the test early without executing the rest of the test. A pair of macros support this functionality in Unity. The first `TEST_PROTECT` sets up the feature, and handles emergency abort cases. `TEST_ABORT` can then be used at any time within the tests to return to the last `TEST_PROTECT` call. |
|||
|
|||
TEST_PROTECT() |
|||
|
|||
Setup and Catch macro |
|||
|
|||
TEST_ABORT() |
|||
|
|||
Abort Test macro |
|||
|
|||
Example: |
|||
|
|||
main() |
|||
{ |
|||
if (TEST_PROTECT()) |
|||
{ |
|||
MyTest(); |
|||
} |
|||
} |
|||
|
|||
If MyTest calls `TEST_ABORT`, program control will immediately return to `TEST_PROTECT` with a return value of zero. |
|||
|
|||
|
|||
|
|||
## How to Build and Run A Test File |
|||
|
|||
This is the single biggest challenge to picking up a new unit testing framework, |
|||
at least in a language like C or C++. These languages are REALLY good at getting |
|||
you "close to the metal" (why is the phrase metal? Wouldn't it be more accurate |
|||
to say "close to the silicon"?). While this feature is usually a good thing, it |
|||
can make testing more challenging. |
|||
|
|||
You have two really good options for toolchains. Depending on where you're |
|||
coming from, it might surprise you that neither of these options is running the |
|||
unit tests on your hardware. |
|||
There are many reasons for this, but here's a short version: |
|||
- On hardware, you have too many constraints (processing power, memory, etc), |
|||
- On hardware, you don't have complete control over all registers, |
|||
- On hardware, unit testing is more challenging, |
|||
- Unit testing isn't System testing. Keep them separate. |
|||
|
|||
Instead of running your tests on your actual hardware, most developers choose to |
|||
develop them as native applications (using gcc or MSVC for example) or as |
|||
applications running on a simulator. Either is a good option. Native apps have |
|||
the advantages of being faster and easier to set up. Simulator apps have the |
|||
advantage of working with the same compiler as your target application. The |
|||
options for configuring these are discussed in the configuration guide. |
|||
|
|||
To get either to work, you might need to make a few changes to the file |
|||
containing your register set (discussed later). |
|||
|
|||
In either case, a test is built by linking unity, the test file, and the C |
|||
file(s) being tested. These files create an executable which can be run as the |
|||
test set for that module. Then, this process is repeated for the next test file. |
|||
This flexibility of separating tests into individual executables allows us to |
|||
much more thoroughly unit test our system and it keeps all the test code out of |
|||
our final release! |
|||
|
|||
|
|||
*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)* |
@ -0,0 +1,266 @@ |
|||
# Unity Helper Scripts |
|||
|
|||
## With a Little Help From Our Friends |
|||
|
|||
Sometimes what it takes to be a really efficient C programmer is a little non-C. |
|||
The Unity project includes a couple of Ruby scripts for making your life just a tad |
|||
easier. They are completely optional. If you choose to use them, you'll need a |
|||
copy of Ruby, of course. Just install whatever the latest version is, and it is |
|||
likely to work. You can find Ruby at [ruby-lang.org](https://ruby-labg.org/). |
|||
|
|||
|
|||
### `generate_test_runner.rb` |
|||
|
|||
Are you tired of creating your own `main` function in your test file? Do you |
|||
keep forgetting to add a `RUN_TEST` call when you add a new test case to your |
|||
suite? Do you want to use CMock or other fancy add-ons but don't want to figure |
|||
out how to create your own `RUN_TEST` macro? |
|||
|
|||
Well then we have the perfect script for you! |
|||
|
|||
The `generate_test_runner` script processes a given test file and automatically |
|||
creates a separate test runner file that includes ?main?to execute the test |
|||
cases within the scanned test file. All you do then is add the generated runner |
|||
to your list of files to be compiled and linked, and presto you're done! |
|||
|
|||
This script searches your test file for void function signatures having a |
|||
function name beginning with "test" or "spec". It treats each of these |
|||
functions as a test case and builds up a test suite of them. For example, the |
|||
following includes three test cases: |
|||
|
|||
```C |
|||
void testVerifyThatUnityIsAwesomeAndWillMakeYourLifeEasier(void) |
|||
{ |
|||
ASSERT_TRUE(1); |
|||
} |
|||
void test_FunctionName_should_WorkProperlyAndReturn8(void) { |
|||
ASSERT_EQUAL_INT(8, FunctionName()); |
|||
} |
|||
void spec_Function_should_DoWhatItIsSupposedToDo(void) { |
|||
ASSERT_NOT_NULL(Function(5)); |
|||
} |
|||
``` |
|||
|
|||
You can run this script a couple of ways. The first is from the command line: |
|||
|
|||
```Shell |
|||
ruby generate_test_runner.rb TestFile.c NameOfRunner.c |
|||
``` |
|||
|
|||
Alternatively, if you include only the test file parameter, the script will copy |
|||
the name of the test file and automatically append "_Runner" to the name of the |
|||
generated file. The example immediately below will create TestFile_Runner.c. |
|||
|
|||
```Shell |
|||
ruby generate_test_runner.rb TestFile.c |
|||
``` |
|||
|
|||
You can also add a [YAML](http://www.yaml.org/) file to configure extra options. |
|||
Conveniently, this YAML file is of the same format as that used by Unity and |
|||
CMock. So if you are using YAML files already, you can simply pass the very same |
|||
file into the generator script. |
|||
|
|||
```Shell |
|||
ruby generate_test_runner.rb TestFile.c my_config.yml |
|||
``` |
|||
|
|||
The contents of the YAML file `my_config.yml` could look something like the |
|||
example below. If you're wondering what some of these options do, you're going |
|||
to love the next section of this document. |
|||
|
|||
```YAML |
|||
:unity: |
|||
:includes: |
|||
- stdio.h |
|||
- microdefs.h |
|||
:cexception: 1 |
|||
:suit_setup: "blah = malloc(1024);" |
|||
:suite_teardown: "free(blah);" |
|||
``` |
|||
|
|||
If you would like to force your generated test runner to include one or more |
|||
header files, you can just include those at the command line too. Just make sure |
|||
these are _after_ the YAML file, if you are using one: |
|||
|
|||
```Shell |
|||
ruby generate_test_runner.rb TestFile.c my_config.yml extras.h |
|||
``` |
|||
|
|||
Another option, particularly if you are already using Ruby to orchestrate your |
|||
builds - or more likely the Ruby-based build tool Rake - is requiring this |
|||
script directly. Anything that you would have specified in a YAML file can be |
|||
passed to the script as part of a hash. Let's push the exact same requirement |
|||
set as we did above but this time through Ruby code directly: |
|||
|
|||
```Ruby |
|||
require "generate_test_runner.rb" |
|||
options = { |
|||
:includes => ["stdio.h", "microdefs.h"], |
|||
:cexception => 1, |
|||
:suite_setup => "blah = malloc(1024);", |
|||
:suite_teardown => "free(blah);" |
|||
} |
|||
UnityTestRunnerGenerator.new.run(testfile, runner_name, options) |
|||
``` |
|||
|
|||
If you have multiple files to generate in a build script (such as a Rakefile), |
|||
you might want to instantiate a generator object with your options and call it |
|||
to generate each runner afterwards. Like thus: |
|||
|
|||
```Ruby |
|||
gen = UnityTestRunnerGenerator.new(options) |
|||
test_files.each do |f| |
|||
gen.run(f, File.basename(f,'.c')+"Runner.c" |
|||
end |
|||
``` |
|||
|
|||
#### Options accepted by generate_test_runner.rb: |
|||
|
|||
The following options are available when executing `generate_test_runner`. You |
|||
may pass these as a Ruby hash directly or specify them in a YAML file, both of |
|||
which are described above. In the `examples` directory, Example 3's Rakefile |
|||
demonstrates using a Ruby hash. |
|||
|
|||
|
|||
##### `:includes` |
|||
|
|||
This option specifies an array of file names to be `#include`'d at the top of |
|||
your runner C file. You might use it to reference custom types or anything else |
|||
universally needed in your generated runners. |
|||
|
|||
|
|||
##### `:suite_setup` |
|||
|
|||
Define this option with C code to be executed _before any_ test cases are run. |
|||
|
|||
Alternatively, if your C compiler supports weak symbols, you can leave this |
|||
option unset and instead provide a `void suiteSetUp(void)` function in your test |
|||
suite. The linker will look for this symbol and fall back to a Unity-provided |
|||
stub if it is not found. |
|||
|
|||
|
|||
##### `:suite_teardown` |
|||
|
|||
Define this option with C code to be executed _after all_ test cases have |
|||
finished. An integer variable `num_failures` is available for diagnostics. |
|||
The code should end with a `return` statement; the value returned will become |
|||
the exit code of `main`. You can normally just return `num_failures`. |
|||
|
|||
Alternatively, if your C compiler supports weak symbols, you can leave this |
|||
option unset and instead provide a `int suiteTearDown(int num_failures)` |
|||
function in your test suite. The linker will look for this symbol and fall |
|||
back to a Unity-provided stub if it is not found. |
|||
|
|||
|
|||
##### `:enforce_strict_ordering` |
|||
|
|||
This option should be defined if you have the strict order feature enabled in |
|||
CMock (see CMock documentation). This generates extra variables required for |
|||
everything to run smoothly. If you provide the same YAML to the generator as |
|||
used in CMock's configuration, you've already configured the generator properly. |
|||
|
|||
|
|||
##### `:externc` |
|||
|
|||
This option should be defined if you are mixing C and CPP and want your test |
|||
runners to automatically include extern "C" support when they are generated. |
|||
|
|||
##### `:mock_prefix` and `:mock_suffix` |
|||
|
|||
Unity automatically generates calls to Init, Verify and Destroy for every file |
|||
included in the main test file that starts with the given mock prefix and ends |
|||
with the given mock suffix, file extension not included. By default, Unity |
|||
assumes a `Mock` prefix and no suffix. |
|||
|
|||
##### `:plugins` |
|||
|
|||
This option specifies an array of plugins to be used (of course, the array can |
|||
contain only a single plugin). This is your opportunity to enable support for |
|||
CException support, which will add a check for unhandled exceptions in each |
|||
test, reporting a failure if one is detected. To enable this feature using Ruby: |
|||
|
|||
```Ruby |
|||
:plugins => [ :cexception ] |
|||
``` |
|||
|
|||
Or as a yaml file: |
|||
|
|||
```YAML |
|||
:plugins: |
|||
-:cexception |
|||
``` |
|||
|
|||
If you are using CMock, it is very likely that you are already passing an array |
|||
of plugins to CMock. You can just use the same array here. This script will just |
|||
ignore the plugins that don't require additional support. |
|||
|
|||
|
|||
### `unity_test_summary.rb` |
|||
|
|||
A Unity test file contains one or more test case functions. Each test case can |
|||
pass, fail, or be ignored. Each test file is run individually producing results |
|||
for its collection of test cases. A given project will almost certainly be |
|||
composed of multiple test files. Therefore, the suite of tests is comprised of |
|||
one or more test cases spread across one or more test files. This script |
|||
aggregates individual test file results to generate a summary of all executed |
|||
test cases. The output includes how many tests were run, how many were ignored, |
|||
and how many failed. In addition, the output includes a listing of which |
|||
specific tests were ignored and failed. A good example of the breadth and |
|||
details of these results can be found in the `examples` directory. Intentionally |
|||
ignored and failing tests in this project generate corresponding entries in the |
|||
summary report. |
|||
|
|||
If you're interested in other (prettier?) output formats, check into the |
|||
Ceedling build tool project (ceedling.sourceforge.net) that works with Unity and |
|||
CMock and supports xunit-style xml as well as other goodies. |
|||
|
|||
This script assumes the existence of files ending with the extensions |
|||
`.testpass` and `.testfail`.The contents of these files includes the test |
|||
results summary corresponding to each test file executed with the extension set |
|||
according to the presence or absence of failures for that test file. The script |
|||
searches a specified path for these files, opens each one it finds, parses the |
|||
results, and aggregates and prints a summary. Calling it from the command line |
|||
looks like this: |
|||
|
|||
```Shell |
|||
ruby unity_test_summary.rb build/test/ |
|||
``` |
|||
|
|||
You can optionally specify a root path as well. This is really helpful when you |
|||
are using relative paths in your tools' setup, but you want to pull the summary |
|||
into an IDE like Eclipse for clickable shortcuts. |
|||
|
|||
```Shell |
|||
ruby unity_test_summary.rb build/test/ ~/projects/myproject/ |
|||
``` |
|||
|
|||
Or, if you're more of a Windows sort of person: |
|||
|
|||
```Shell |
|||
ruby unity_test_summary.rb build\teat\ C:\projects\myproject\ |
|||
``` |
|||
|
|||
When configured correctly, you'll see a final summary, like so: |
|||
|
|||
```Shell |
|||
-------------------------- |
|||
UNITY IGNORED TEST SUMMARY |
|||
-------------------------- |
|||
blah.c:22:test_sandwiches_should_HaveBreadOnTwoSides:IGNORE |
|||
|
|||
------------------------- |
|||
UNITY FAILED TEST SUMMARY |
|||
------------------------- |
|||
blah.c:87:test_sandwiches_should_HaveCondiments:FAIL:Expected 1 was 0 |
|||
meh.c:38:test_soda_should_BeCalledPop:FAIL:Expected "pop" was "coke" |
|||
|
|||
-------------------------- |
|||
OVERALL UNITY TEST SUMMARY |
|||
-------------------------- |
|||
45 TOTAL TESTS 2 TOTAL FAILURES 1 IGNORED |
|||
``` |
|||
|
|||
How convenient is that? |
|||
|
|||
|
|||
*Find The Latest of This And More at [ThrowTheSwitch.org](https://throwtheswitch.org)* |
@ -0,0 +1,71 @@ |
|||
# ==========================================
|
|||
# Unity Project - A Test Framework for C
|
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
|
|||
# [Released under MIT License. Please refer to license.txt for details]
|
|||
# ==========================================
|
|||
|
|||
#We try to detect the OS we are running on, and adjust commands as needed
|
|||
ifeq ($(OS),Windows_NT) |
|||
ifeq ($(shell uname -s),) # not in a bash-like shell |
|||
CLEANUP = del /F /Q |
|||
MKDIR = mkdir |
|||
else # in a bash-like shell, like msys |
|||
CLEANUP = rm -f |
|||
MKDIR = mkdir -p |
|||
endif |
|||
TARGET_EXTENSION=.exe |
|||
else |
|||
CLEANUP = rm -f |
|||
MKDIR = mkdir -p |
|||
TARGET_EXTENSION=.out |
|||
endif |
|||
|
|||
C_COMPILER=gcc |
|||
ifeq ($(shell uname -s), Darwin) |
|||
C_COMPILER=clang |
|||
endif |
|||
|
|||
UNITY_ROOT=../.. |
|||
|
|||
CFLAGS=-std=c89 |
|||
CFLAGS += -Wall |
|||
CFLAGS += -Wextra |
|||
CFLAGS += -Wpointer-arith |
|||
CFLAGS += -Wcast-align |
|||
CFLAGS += -Wwrite-strings |
|||
CFLAGS += -Wswitch-default |
|||
CFLAGS += -Wunreachable-code |
|||
CFLAGS += -Winit-self |
|||
CFLAGS += -Wmissing-field-initializers |
|||
CFLAGS += -Wno-unknown-pragmas |
|||
CFLAGS += -Wstrict-prototypes |
|||
CFLAGS += -Wundef |
|||
CFLAGS += -Wold-style-definition |
|||
|
|||
TARGET_BASE1=test1 |
|||
TARGET_BASE2=test2 |
|||
TARGET1 = $(TARGET_BASE1)$(TARGET_EXTENSION) |
|||
TARGET2 = $(TARGET_BASE2)$(TARGET_EXTENSION) |
|||
SRC_FILES1=$(UNITY_ROOT)/src/unity.c src/ProductionCode.c test/TestProductionCode.c test/test_runners/TestProductionCode_Runner.c |
|||
SRC_FILES2=$(UNITY_ROOT)/src/unity.c src/ProductionCode2.c test/TestProductionCode2.c test/test_runners/TestProductionCode2_Runner.c |
|||
INC_DIRS=-Isrc -I$(UNITY_ROOT)/src |
|||
SYMBOLS= |
|||
|
|||
all: clean default |
|||
|
|||
default: $(SRC_FILES1) $(SRC_FILES2) |
|||
$(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES1) -o $(TARGET1) |
|||
$(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES2) -o $(TARGET2) |
|||
- ./$(TARGET1) |
|||
./$(TARGET2) |
|||
|
|||
test/test_runners/TestProductionCode_Runner.c: test/TestProductionCode.c |
|||
ruby $(UNITY_ROOT)/auto/generate_test_runner.rb test/TestProductionCode.c test/test_runners/TestProductionCode_Runner.c |
|||
test/test_runners/TestProductionCode2_Runner.c: test/TestProductionCode2.c |
|||
ruby $(UNITY_ROOT)/auto/generate_test_runner.rb test/TestProductionCode2.c test/test_runners/TestProductionCode2_Runner.c |
|||
|
|||
clean: |
|||
$(CLEANUP) $(TARGET1) $(TARGET2) |
|||
|
|||
ci: CFLAGS += -Werror |
|||
ci: default |
@ -0,0 +1,5 @@ |
|||
Example 1 |
|||
========= |
|||
|
|||
Close to the simplest possible example of Unity, using only basic features. |
|||
Run make to build & run the example tests. |
@ -0,0 +1,24 @@ |
|||
|
|||
#include "ProductionCode.h" |
|||
|
|||
int Counter = 0; |
|||
int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; /* some obnoxious array to search that is 1-based indexing instead of 0. */ |
|||
|
|||
/* This function is supposed to search through NumbersToFind and find a particular number.
|
|||
* If it finds it, the index is returned. Otherwise 0 is returned which sorta makes sense since |
|||
* NumbersToFind is indexed from 1. Unfortunately it's broken |
|||
* (and should therefore be caught by our tests) */ |
|||
int FindFunction_WhichIsBroken(int NumberToFind) |
|||
{ |
|||
int i = 0; |
|||
while (i < 8) /* Notice I should have been in braces */ |
|||
i++; |
|||
if (NumbersToFind[i] == NumberToFind) /* Yikes! I'm getting run after the loop finishes instead of during it! */ |
|||
return i; |
|||
return 0; |
|||
} |
|||
|
|||
int FunctionWhichReturnsLocalVariable(void) |
|||
{ |
|||
return Counter; |
|||
} |
@ -0,0 +1,3 @@ |
|||
|
|||
int FindFunction_WhichIsBroken(int NumberToFind); |
|||
int FunctionWhichReturnsLocalVariable(void); |
@ -0,0 +1,11 @@ |
|||
|
|||
#include "ProductionCode2.h" |
|||
|
|||
char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction) |
|||
{ |
|||
(void)Poor; |
|||
(void)LittleFunction; |
|||
/* Since There Are No Tests Yet, This Function Could Be Empty For All We Know.
|
|||
* Which isn't terribly useful... but at least we put in a TEST_IGNORE so we won't forget */ |
|||
return (char*)0; |
|||
} |
@ -0,0 +1,2 @@ |
|||
|
|||
char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction); |
@ -0,0 +1,62 @@ |
|||
|
|||
#include "ProductionCode.h" |
|||
#include "unity.h" |
|||
|
|||
/* sometimes you may want to get at local data in a module.
|
|||
* for example: If you plan to pass by reference, this could be useful |
|||
* however, it should often be avoided */ |
|||
extern int Counter; |
|||
|
|||
void setUp(void) |
|||
{ |
|||
/* This is run before EACH TEST */ |
|||
Counter = 0x5a5a; |
|||
} |
|||
|
|||
void tearDown(void) |
|||
{ |
|||
} |
|||
|
|||
void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void) |
|||
{ |
|||
/* All of these should pass */ |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(2)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1)); |
|||
} |
|||
|
|||
void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void) |
|||
{ |
|||
/* You should see this line fail in your test summary */ |
|||
TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34)); |
|||
|
|||
/* Notice the rest of these didn't get a chance to run because the line above failed.
|
|||
* Unit tests abort each test function on the first sign of trouble. |
|||
* Then NEXT test function runs as normal. */ |
|||
TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888)); |
|||
} |
|||
|
|||
void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void) |
|||
{ |
|||
/* This should be true because setUp set this up for us before this test */ |
|||
TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); |
|||
|
|||
/* This should be true because we can still change our answer */ |
|||
Counter = 0x1234; |
|||
TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); |
|||
} |
|||
|
|||
void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void) |
|||
{ |
|||
/* This should be true again because setup was rerun before this test (and after we changed it to 0x1234) */ |
|||
TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); |
|||
} |
|||
|
|||
void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void) |
|||
{ |
|||
/* Sometimes you get the test wrong. When that happens, you get a failure too... and a quick look should tell
|
|||
* you what actually happened...which in this case was a failure to setup the initial condition. */ |
|||
TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); |
|||
} |
@ -0,0 +1,31 @@ |
|||
|
|||
#include "ProductionCode2.h" |
|||
#include "unity.h" |
|||
|
|||
/* These should be ignored because they are commented out in various ways:
|
|||
#include "whatever.h" |
|||
#include "somethingelse.h" |
|||
*/ |
|||
|
|||
void setUp(void) |
|||
{ |
|||
} |
|||
|
|||
void tearDown(void) |
|||
{ |
|||
} |
|||
|
|||
void test_IgnoredTest(void) |
|||
{ |
|||
TEST_IGNORE_MESSAGE("This Test Was Ignored On Purpose"); |
|||
} |
|||
|
|||
void test_AnotherIgnoredTest(void) |
|||
{ |
|||
TEST_IGNORE_MESSAGE("These Can Be Useful For Leaving Yourself Notes On What You Need To Do Yet"); |
|||
} |
|||
|
|||
void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void) |
|||
{ |
|||
TEST_IGNORE(); /* Like This */ |
|||
} |
@ -0,0 +1,53 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
} \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "ProductionCode2.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_IgnoredTest(void); |
|||
extern void test_AnotherIgnoredTest(void); |
|||
extern void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void); |
|||
|
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
tearDown(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("test/TestProductionCode2.c"); |
|||
RUN_TEST(test_IgnoredTest, 18); |
|||
RUN_TEST(test_AnotherIgnoredTest, 23); |
|||
RUN_TEST(test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented, 28); |
|||
|
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,57 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
} \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "ProductionCode.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void); |
|||
extern void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void); |
|||
extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void); |
|||
extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void); |
|||
extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void); |
|||
|
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
tearDown(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("test/TestProductionCode.c"); |
|||
RUN_TEST(test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode, 20); |
|||
RUN_TEST(test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken, 30); |
|||
RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue, 41); |
|||
RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain, 51); |
|||
RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed, 57); |
|||
|
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,70 @@ |
|||
# ==========================================
|
|||
# Unity Project - A Test Framework for C
|
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
|
|||
# [Released under MIT License. Please refer to license.txt for details]
|
|||
# ==========================================
|
|||
|
|||
#We try to detect the OS we are running on, and adjust commands as needed
|
|||
ifeq ($(OS),Windows_NT) |
|||
ifeq ($(shell uname -s),) # not in a bash-like shell |
|||
CLEANUP = del /F /Q |
|||
MKDIR = mkdir |
|||
else # in a bash-like shell, like msys |
|||
CLEANUP = rm -f |
|||
MKDIR = mkdir -p |
|||
endif |
|||
TARGET_EXTENSION=.exe |
|||
else |
|||
CLEANUP = rm -f |
|||
MKDIR = mkdir -p |
|||
TARGET_EXTENSION=.out |
|||
endif |
|||
|
|||
C_COMPILER=gcc |
|||
ifeq ($(shell uname -s), Darwin) |
|||
C_COMPILER=clang |
|||
endif |
|||
|
|||
UNITY_ROOT=../.. |
|||
|
|||
CFLAGS=-std=c99 |
|||
CFLAGS += -Wall |
|||
CFLAGS += -Wextra |
|||
CFLAGS += -Wpointer-arith |
|||
CFLAGS += -Wcast-align |
|||
CFLAGS += -Wwrite-strings |
|||
CFLAGS += -Wswitch-default |
|||
CFLAGS += -Wunreachable-code |
|||
CFLAGS += -Winit-self |
|||
CFLAGS += -Wmissing-field-initializers |
|||
CFLAGS += -Wno-unknown-pragmas |
|||
CFLAGS += -Wstrict-prototypes |
|||
CFLAGS += -Wundef |
|||
CFLAGS += -Wold-style-definition |
|||
|
|||
TARGET_BASE1=all_tests |
|||
TARGET1 = $(TARGET_BASE1)$(TARGET_EXTENSION) |
|||
SRC_FILES1=\
|
|||
$(UNITY_ROOT)/src/unity.c \
|
|||
$(UNITY_ROOT)/extras/fixture/src/unity_fixture.c \
|
|||
src/ProductionCode.c \
|
|||
src/ProductionCode2.c \
|
|||
test/TestProductionCode.c \
|
|||
test/TestProductionCode2.c \
|
|||
test/test_runners/TestProductionCode_Runner.c \
|
|||
test/test_runners/TestProductionCode2_Runner.c \
|
|||
test/test_runners/all_tests.c |
|||
INC_DIRS=-Isrc -I$(UNITY_ROOT)/src -I$(UNITY_ROOT)/extras/fixture/src |
|||
SYMBOLS= |
|||
|
|||
all: clean default |
|||
|
|||
default: |
|||
$(C_COMPILER) $(CFLAGS) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES1) -o $(TARGET1) |
|||
- ./$(TARGET1) -v |
|||
|
|||
clean: |
|||
$(CLEANUP) $(TARGET1) |
|||
|
|||
ci: CFLAGS += -Werror |
|||
ci: default |
@ -0,0 +1,5 @@ |
|||
Example 2 |
|||
========= |
|||
|
|||
Same as the first example, but now using Unity's test fixture to group tests |
|||
together. Using the test fixture also makes writing test runners much easier. |
@ -0,0 +1,24 @@ |
|||
|
|||
#include "ProductionCode.h" |
|||
|
|||
int Counter = 0; |
|||
int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; //some obnoxious array to search that is 1-based indexing instead of 0.
|
|||
|
|||
// This function is supposed to search through NumbersToFind and find a particular number.
|
|||
// If it finds it, the index is returned. Otherwise 0 is returned which sorta makes sense since
|
|||
// NumbersToFind is indexed from 1. Unfortunately it's broken
|
|||
// (and should therefore be caught by our tests)
|
|||
int FindFunction_WhichIsBroken(int NumberToFind) |
|||
{ |
|||
int i = 0; |
|||
while (i <= 8) //Notice I should have been in braces
|
|||
i++; |
|||
if (NumbersToFind[i] == NumberToFind) //Yikes! I'm getting run after the loop finishes instead of during it!
|
|||
return i; |
|||
return 0; |
|||
} |
|||
|
|||
int FunctionWhichReturnsLocalVariable(void) |
|||
{ |
|||
return Counter; |
|||
} |
@ -0,0 +1,3 @@ |
|||
|
|||
int FindFunction_WhichIsBroken(int NumberToFind); |
|||
int FunctionWhichReturnsLocalVariable(void); |
@ -0,0 +1,11 @@ |
|||
|
|||
#include "ProductionCode2.h" |
|||
|
|||
char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction) |
|||
{ |
|||
(void)Poor; |
|||
(void)LittleFunction; |
|||
//Since There Are No Tests Yet, This Function Could Be Empty For All We Know.
|
|||
// Which isn't terribly useful... but at least we put in a TEST_IGNORE so we won't forget
|
|||
return (char*)0; |
|||
} |
@ -0,0 +1,2 @@ |
|||
|
|||
char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction); |
@ -0,0 +1,64 @@ |
|||
#include "ProductionCode.h" |
|||
#include "unity.h" |
|||
#include "unity_fixture.h" |
|||
|
|||
TEST_GROUP(ProductionCode); |
|||
|
|||
//sometimes you may want to get at local data in a module.
|
|||
//for example: If you plan to pass by reference, this could be useful
|
|||
//however, it should often be avoided
|
|||
extern int Counter; |
|||
|
|||
TEST_SETUP(ProductionCode) |
|||
{ |
|||
//This is run before EACH TEST
|
|||
Counter = 0x5a5a; |
|||
} |
|||
|
|||
TEST_TEAR_DOWN(ProductionCode) |
|||
{ |
|||
} |
|||
|
|||
TEST(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode) |
|||
{ |
|||
//All of these should pass
|
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(2)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1)); |
|||
} |
|||
|
|||
TEST(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken) |
|||
{ |
|||
// You should see this line fail in your test summary
|
|||
TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34)); |
|||
|
|||
// Notice the rest of these didn't get a chance to run because the line above failed.
|
|||
// Unit tests abort each test function on the first sign of trouble.
|
|||
// Then NEXT test function runs as normal.
|
|||
TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888)); |
|||
} |
|||
|
|||
TEST(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue) |
|||
{ |
|||
//This should be true because setUp set this up for us before this test
|
|||
TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); |
|||
|
|||
//This should be true because we can still change our answer
|
|||
Counter = 0x1234; |
|||
TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); |
|||
} |
|||
|
|||
TEST(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain) |
|||
{ |
|||
//This should be true again because setup was rerun before this test (and after we changed it to 0x1234)
|
|||
TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); |
|||
} |
|||
|
|||
TEST(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed) |
|||
{ |
|||
//Sometimes you get the test wrong. When that happens, you get a failure too... and a quick look should tell
|
|||
// you what actually happened...which in this case was a failure to setup the initial condition.
|
|||
TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); |
|||
} |
@ -0,0 +1,33 @@ |
|||
#include "ProductionCode2.h" |
|||
#include "unity.h" |
|||
#include "unity_fixture.h" |
|||
|
|||
TEST_GROUP(ProductionCode2); |
|||
|
|||
/* These should be ignored because they are commented out in various ways:
|
|||
#include "whatever.h" |
|||
*/ |
|||
//#include "somethingelse.h"
|
|||
|
|||
TEST_SETUP(ProductionCode2) |
|||
{ |
|||
} |
|||
|
|||
TEST_TEAR_DOWN(ProductionCode2) |
|||
{ |
|||
} |
|||
|
|||
TEST(ProductionCode2, IgnoredTest) |
|||
{ |
|||
TEST_IGNORE_MESSAGE("This Test Was Ignored On Purpose"); |
|||
} |
|||
|
|||
TEST(ProductionCode2, AnotherIgnoredTest) |
|||
{ |
|||
TEST_IGNORE_MESSAGE("These Can Be Useful For Leaving Yourself Notes On What You Need To Do Yet"); |
|||
} |
|||
|
|||
TEST(ProductionCode2, ThisFunctionHasNotBeenTested_NeedsToBeImplemented) |
|||
{ |
|||
TEST_IGNORE(); //Like This
|
|||
} |
@ -0,0 +1,9 @@ |
|||
#include "unity.h" |
|||
#include "unity_fixture.h" |
|||
|
|||
TEST_GROUP_RUNNER(ProductionCode2) |
|||
{ |
|||
RUN_TEST_CASE(ProductionCode2, IgnoredTest); |
|||
RUN_TEST_CASE(ProductionCode2, AnotherIgnoredTest); |
|||
RUN_TEST_CASE(ProductionCode2, ThisFunctionHasNotBeenTested_NeedsToBeImplemented); |
|||
} |
@ -0,0 +1,11 @@ |
|||
#include "unity.h" |
|||
#include "unity_fixture.h" |
|||
|
|||
TEST_GROUP_RUNNER(ProductionCode) |
|||
{ |
|||
RUN_TEST_CASE(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode); |
|||
RUN_TEST_CASE(ProductionCode, FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken); |
|||
RUN_TEST_CASE(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue); |
|||
RUN_TEST_CASE(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain); |
|||
RUN_TEST_CASE(ProductionCode, FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed); |
|||
} |
@ -0,0 +1,12 @@ |
|||
#include "unity_fixture.h" |
|||
|
|||
static void RunAllTests(void) |
|||
{ |
|||
RUN_TEST_GROUP(ProductionCode); |
|||
RUN_TEST_GROUP(ProductionCode2); |
|||
} |
|||
|
|||
int main(int argc, const char * argv[]) |
|||
{ |
|||
return UnityMain(argc, argv, RunAllTests); |
|||
} |
@ -0,0 +1,10 @@ |
|||
#include "unity.h" |
|||
#include "UnityHelper.h" |
|||
#include <stdio.h> |
|||
#include <string.h> |
|||
|
|||
void AssertEqualExampleStruct(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line) |
|||
{ |
|||
UNITY_TEST_ASSERT_EQUAL_INT(expected.x, actual.x, line, "Example Struct Failed For Field x"); |
|||
UNITY_TEST_ASSERT_EQUAL_INT(expected.y, actual.y, line, "Example Struct Failed For Field y"); |
|||
} |
@ -0,0 +1,12 @@ |
|||
#ifndef _TESTHELPER_H |
|||
#define _TESTHELPER_H |
|||
|
|||
#include "Types.h" |
|||
|
|||
void AssertEqualExampleStruct(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line); |
|||
|
|||
#define UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, line, message) AssertEqualExampleStruct(expected, actual, line); |
|||
|
|||
#define TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual) UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, __LINE__, NULL); |
|||
|
|||
#endif // _TESTHELPER_H
|
@ -0,0 +1,40 @@ |
|||
require 'rake' |
|||
require 'rake/clean' |
|||
require_relative 'rakefile_helper' |
|||
|
|||
TEMP_DIRS = [ |
|||
File.join(__dir__, 'build') |
|||
].freeze |
|||
|
|||
TEMP_DIRS.each do |dir| |
|||
directory(dir) |
|||
CLOBBER.include(dir) |
|||
end |
|||
|
|||
task prepare_for_tests: TEMP_DIRS |
|||
|
|||
include RakefileHelpers |
|||
|
|||
# Load default configuration, for now |
|||
DEFAULT_CONFIG_FILE = 'target_gcc_32.yml'.freeze |
|||
configure_toolchain(DEFAULT_CONFIG_FILE) |
|||
|
|||
task unit: [:prepare_for_tests] do |
|||
run_tests unit_test_files |
|||
end |
|||
|
|||
desc 'Generate test summary' |
|||
task :summary do |
|||
report_summary |
|||
end |
|||
|
|||
desc 'Build and test Unity' |
|||
task all: %i[clean unit summary] |
|||
task default: %i[clobber all] |
|||
task ci: [:default] |
|||
task cruise: [:default] |
|||
|
|||
desc 'Load configuration' |
|||
task :config, :config_file do |_t, args| |
|||
configure_toolchain(args[:config_file]) |
|||
end |
@ -0,0 +1,249 @@ |
|||
require 'yaml' |
|||
require 'fileutils' |
|||
require_relative '../../auto/unity_test_summary' |
|||
require_relative '../../auto/generate_test_runner' |
|||
require_relative '../../auto/colour_reporter' |
|||
|
|||
module RakefileHelpers |
|||
C_EXTENSION = '.c'.freeze |
|||
|
|||
def load_configuration(config_file) |
|||
$cfg_file = config_file |
|||
$cfg = YAML.load(File.read($cfg_file)) |
|||
end |
|||
|
|||
def configure_clean |
|||
CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil? |
|||
end |
|||
|
|||
def configure_toolchain(config_file = DEFAULT_CONFIG_FILE) |
|||
config_file += '.yml' unless config_file =~ /\.yml$/ |
|||
load_configuration(config_file) |
|||
configure_clean |
|||
end |
|||
|
|||
def unit_test_files |
|||
path = $cfg['compiler']['unit_tests_path'] + 'Test*' + C_EXTENSION |
|||
path.tr!('\\', '/') |
|||
FileList.new(path) |
|||
end |
|||
|
|||
def local_include_dirs |
|||
include_dirs = $cfg['compiler']['includes']['items'].dup |
|||
include_dirs.delete_if { |dir| dir.is_a?(Array) } |
|||
include_dirs |
|||
end |
|||
|
|||
def extract_headers(filename) |
|||
includes = [] |
|||
lines = File.readlines(filename) |
|||
lines.each do |line| |
|||
m = line.match(/^\s*#include\s+\"\s*(.+\.[hH])\s*\"/) |
|||
includes << m[1] unless m.nil? |
|||
end |
|||
includes |
|||
end |
|||
|
|||
def find_source_file(header, paths) |
|||
paths.each do |dir| |
|||
src_file = dir + header.ext(C_EXTENSION) |
|||
return src_file if File.exist?(src_file) |
|||
end |
|||
nil |
|||
end |
|||
|
|||
def tackit(strings) |
|||
result = if strings.is_a?(Array) |
|||
"\"#{strings.join}\"" |
|||
else |
|||
strings |
|||
end |
|||
result |
|||
end |
|||
|
|||
def squash(prefix, items) |
|||
result = '' |
|||
items.each { |item| result += " #{prefix}#{tackit(item)}" } |
|||
result |
|||
end |
|||
|
|||
def build_compiler_fields |
|||
command = tackit($cfg['compiler']['path']) |
|||
defines = if $cfg['compiler']['defines']['items'].nil? |
|||
'' |
|||
else |
|||
squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items']) |
|||
end |
|||
options = squash('', $cfg['compiler']['options']) |
|||
includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items']) |
|||
includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) |
|||
|
|||
{ command: command, defines: defines, options: options, includes: includes } |
|||
end |
|||
|
|||
def compile(file, _defines = []) |
|||
compiler = build_compiler_fields |
|||
cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{file} " \ |
|||
"#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}" |
|||
obj_file = "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}" |
|||
execute(cmd_str + obj_file) |
|||
obj_file |
|||
end |
|||
|
|||
def build_linker_fields |
|||
command = tackit($cfg['linker']['path']) |
|||
options = if $cfg['linker']['options'].nil? |
|||
'' |
|||
else |
|||
squash('', $cfg['linker']['options']) |
|||
end |
|||
includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil? |
|||
'' |
|||
else |
|||
squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items']) |
|||
end.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) |
|||
|
|||
{ command: command, options: options, includes: includes } |
|||
end |
|||
|
|||
def link_it(exe_name, obj_list) |
|||
linker = build_linker_fields |
|||
cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " + |
|||
(obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join + |
|||
$cfg['linker']['bin_files']['prefix'] + ' ' + |
|||
$cfg['linker']['bin_files']['destination'] + |
|||
exe_name + $cfg['linker']['bin_files']['extension'] |
|||
execute(cmd_str) |
|||
end |
|||
|
|||
def build_simulator_fields |
|||
return nil if $cfg['simulator'].nil? |
|||
command = if $cfg['simulator']['path'].nil? |
|||
'' |
|||
else |
|||
(tackit($cfg['simulator']['path']) + ' ') |
|||
end |
|||
pre_support = if $cfg['simulator']['pre_support'].nil? |
|||
'' |
|||
else |
|||
squash('', $cfg['simulator']['pre_support']) |
|||
end |
|||
post_support = if $cfg['simulator']['post_support'].nil? |
|||
'' |
|||
else |
|||
squash('', $cfg['simulator']['post_support']) |
|||
end |
|||
|
|||
{ command: command, pre_support: pre_support, post_support: post_support } |
|||
end |
|||
|
|||
def execute(command_string, verbose = true, raise_on_fail = true) |
|||
report command_string |
|||
output = `#{command_string}`.chomp |
|||
report(output) if verbose && !output.nil? && !output.empty? |
|||
if !$?.exitstatus.zero? && raise_on_fail |
|||
raise "Command failed. (Returned #{$?.exitstatus})" |
|||
end |
|||
output |
|||
end |
|||
|
|||
def report_summary |
|||
summary = UnityTestSummary.new |
|||
summary.root = __dir__ |
|||
results_glob = "#{$cfg['compiler']['build_path']}*.test*" |
|||
results_glob.tr!('\\', '/') |
|||
results = Dir[results_glob] |
|||
summary.targets = results |
|||
summary.run |
|||
fail_out 'FAIL: There were failures' if summary.failures > 0 |
|||
end |
|||
|
|||
def run_tests(test_files) |
|||
report 'Running system tests...' |
|||
|
|||
# Tack on TEST define for compiling unit tests |
|||
load_configuration($cfg_file) |
|||
test_defines = ['TEST'] |
|||
$cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil? |
|||
$cfg['compiler']['defines']['items'] << 'TEST' |
|||
|
|||
include_dirs = local_include_dirs |
|||
|
|||
# Build and execute each unit test |
|||
test_files.each do |test| |
|||
obj_list = [] |
|||
|
|||
# Detect dependencies and build required required modules |
|||
extract_headers(test).each do |header| |
|||
# Compile corresponding source file if it exists |
|||
src_file = find_source_file(header, include_dirs) |
|||
obj_list << compile(src_file, test_defines) unless src_file.nil? |
|||
end |
|||
|
|||
# Build the test runner (generate if configured to do so) |
|||
test_base = File.basename(test, C_EXTENSION) |
|||
runner_name = test_base + '_Runner.c' |
|||
if $cfg['compiler']['runner_path'].nil? |
|||
runner_path = $cfg['compiler']['build_path'] + runner_name |
|||
test_gen = UnityTestRunnerGenerator.new($cfg_file) |
|||
test_gen.run(test, runner_path) |
|||
else |
|||
runner_path = $cfg['compiler']['runner_path'] + runner_name |
|||
end |
|||
|
|||
obj_list << compile(runner_path, test_defines) |
|||
|
|||
# Build the test module |
|||
obj_list << compile(test, test_defines) |
|||
|
|||
# Link the test executable |
|||
link_it(test_base, obj_list) |
|||
|
|||
# Execute unit test and generate results file |
|||
simulator = build_simulator_fields |
|||
executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension'] |
|||
cmd_str = if simulator.nil? |
|||
executable |
|||
else |
|||
"#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}" |
|||
end |
|||
output = execute(cmd_str, true, false) |
|||
test_results = $cfg['compiler']['build_path'] + test_base |
|||
test_results += if output.match(/OK$/m).nil? |
|||
'.testfail' |
|||
else |
|||
'.testpass' |
|||
end |
|||
File.open(test_results, 'w') { |f| f.print output } |
|||
end |
|||
end |
|||
|
|||
def build_application(main) |
|||
report 'Building application...' |
|||
|
|||
obj_list = [] |
|||
load_configuration($cfg_file) |
|||
main_path = $cfg['compiler']['source_path'] + main + C_EXTENSION |
|||
|
|||
# Detect dependencies and build required required modules |
|||
include_dirs = get_local_include_dirs |
|||
extract_headers(main_path).each do |header| |
|||
src_file = find_source_file(header, include_dirs) |
|||
obj_list << compile(src_file) unless src_file.nil? |
|||
end |
|||
|
|||
# Build the main source file |
|||
main_base = File.basename(main_path, C_EXTENSION) |
|||
obj_list << compile(main_path) |
|||
|
|||
# Create the executable |
|||
link_it(main_base, obj_list) |
|||
end |
|||
|
|||
def fail_out(msg) |
|||
puts msg |
|||
puts 'Not returning exit code so continuous integration can pass' |
|||
# exit(-1) # Only removed to pass example_3, which has failing tests on purpose. |
|||
# Still fail if the build fails for any other reason. |
|||
end |
|||
end |
@ -0,0 +1,13 @@ |
|||
Example 3 |
|||
========= |
|||
|
|||
This example project gives an example of some passing, ignored, and failing tests. |
|||
It's simple and meant for you to look over and get an idea for what all of this stuff does. |
|||
|
|||
You can build and test using rake. The rake version will let you test with gcc or a couple |
|||
versions of IAR. You can tweak the yaml files to get those versions running. |
|||
|
|||
Ruby is required if you're using the rake version (obviously). This version shows off most of |
|||
Unity's advanced features (automatically creating test runners, fancy summaries, etc.) |
|||
Without ruby, you have to maintain your own test runners. Do that for a while and you'll learn |
|||
why you really want to start using the Ruby tools. |
@ -0,0 +1,24 @@ |
|||
|
|||
#include "ProductionCode.h" |
|||
|
|||
int Counter = 0; |
|||
int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; //some obnoxious array to search that is 1-based indexing instead of 0.
|
|||
|
|||
// This function is supposed to search through NumbersToFind and find a particular number.
|
|||
// If it finds it, the index is returned. Otherwise 0 is returned which sorta makes sense since
|
|||
// NumbersToFind is indexed from 1. Unfortunately it's broken
|
|||
// (and should therefore be caught by our tests)
|
|||
int FindFunction_WhichIsBroken(int NumberToFind) |
|||
{ |
|||
int i = 0; |
|||
while (i <= 8) //Notice I should have been in braces
|
|||
i++; |
|||
if (NumbersToFind[i] == NumberToFind) //Yikes! I'm getting run after the loop finishes instead of during it!
|
|||
return i; |
|||
return 0; |
|||
} |
|||
|
|||
int FunctionWhichReturnsLocalVariable(void) |
|||
{ |
|||
return Counter; |
|||
} |
@ -0,0 +1,3 @@ |
|||
|
|||
int FindFunction_WhichIsBroken(int NumberToFind); |
|||
int FunctionWhichReturnsLocalVariable(void); |
@ -0,0 +1,11 @@ |
|||
|
|||
#include "ProductionCode2.h" |
|||
|
|||
char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction) |
|||
{ |
|||
(void)Poor; |
|||
(void)LittleFunction; |
|||
//Since There Are No Tests Yet, This Function Could Be Empty For All We Know.
|
|||
// Which isn't terribly useful... but at least we put in a TEST_IGNORE so we won't forget
|
|||
return (char*)0; |
|||
} |
@ -0,0 +1,2 @@ |
|||
|
|||
char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction); |
@ -0,0 +1,47 @@ |
|||
# Copied from ~Unity/targets/gcc_32.yml |
|||
unity_root: &unity_root '../..' |
|||
unity_source: &unity_source '../../src/' |
|||
compiler: |
|||
path: gcc |
|||
source_path: &source_path 'src/' |
|||
unit_tests_path: &unit_tests_path 'test/' |
|||
build_path: &build_path 'build/' |
|||
options: |
|||
- '-c' |
|||
- '-m32' |
|||
- '-Wall' |
|||
- '-Wno-address' |
|||
- '-std=c99' |
|||
- '-pedantic' |
|||
includes: |
|||
prefix: '-I' |
|||
items: |
|||
- *source_path |
|||
- *unity_source |
|||
- *unit_tests_path |
|||
defines: |
|||
prefix: '-D' |
|||
items: |
|||
- UNITY_INCLUDE_DOUBLE |
|||
- UNITY_SUPPORT_TEST_CASES |
|||
object_files: |
|||
prefix: '-o' |
|||
extension: '.o' |
|||
destination: *build_path |
|||
linker: |
|||
path: gcc |
|||
options: |
|||
- -lm |
|||
- '-m32' |
|||
includes: |
|||
prefix: '-I' |
|||
object_files: |
|||
path: *build_path |
|||
extension: '.o' |
|||
bin_files: |
|||
prefix: '-o' |
|||
extension: '.exe' |
|||
destination: *build_path |
|||
colour: true |
|||
:unity: |
|||
:plugins: [] |
@ -0,0 +1,62 @@ |
|||
|
|||
#include "ProductionCode.h" |
|||
#include "unity.h" |
|||
|
|||
//sometimes you may want to get at local data in a module.
|
|||
//for example: If you plan to pass by reference, this could be useful
|
|||
//however, it should often be avoided
|
|||
extern int Counter; |
|||
|
|||
void setUp(void) |
|||
{ |
|||
//This is run before EACH TEST
|
|||
Counter = 0x5a5a; |
|||
} |
|||
|
|||
void tearDown(void) |
|||
{ |
|||
} |
|||
|
|||
void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void) |
|||
{ |
|||
//All of these should pass
|
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(1)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999)); |
|||
TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1)); |
|||
} |
|||
|
|||
void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void) |
|||
{ |
|||
// You should see this line fail in your test summary
|
|||
TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34)); |
|||
|
|||
// Notice the rest of these didn't get a chance to run because the line above failed.
|
|||
// Unit tests abort each test function on the first sign of trouble.
|
|||
// Then NEXT test function runs as normal.
|
|||
TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888)); |
|||
} |
|||
|
|||
void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void) |
|||
{ |
|||
//This should be true because setUp set this up for us before this test
|
|||
TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); |
|||
|
|||
//This should be true because we can still change our answer
|
|||
Counter = 0x1234; |
|||
TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); |
|||
} |
|||
|
|||
void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void) |
|||
{ |
|||
//This should be true again because setup was rerun before this test (and after we changed it to 0x1234)
|
|||
TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable()); |
|||
} |
|||
|
|||
void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void) |
|||
{ |
|||
//Sometimes you get the test wrong. When that happens, you get a failure too... and a quick look should tell
|
|||
// you what actually happened...which in this case was a failure to setup the initial condition.
|
|||
TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable()); |
|||
} |
@ -0,0 +1,31 @@ |
|||
|
|||
#include "ProductionCode2.h" |
|||
#include "unity.h" |
|||
|
|||
/* These should be ignored because they are commented out in various ways:
|
|||
#include "whatever.h" |
|||
*/ |
|||
//#include "somethingelse.h"
|
|||
|
|||
void setUp(void) |
|||
{ |
|||
} |
|||
|
|||
void tearDown(void) |
|||
{ |
|||
} |
|||
|
|||
void test_IgnoredTest(void) |
|||
{ |
|||
TEST_IGNORE_MESSAGE("This Test Was Ignored On Purpose"); |
|||
} |
|||
|
|||
void test_AnotherIgnoredTest(void) |
|||
{ |
|||
TEST_IGNORE_MESSAGE("These Can Be Useful For Leaving Yourself Notes On What You Need To Do Yet"); |
|||
} |
|||
|
|||
void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void) |
|||
{ |
|||
TEST_IGNORE(); //Like This
|
|||
} |
@ -0,0 +1,263 @@ |
|||
/* Unity Configuration
|
|||
* As of May 11th, 2016 at ThrowTheSwitch/Unity commit 837c529 |
|||
* Update: December 29th, 2016 |
|||
* See Also: Unity/docs/UnityConfigurationGuide.pdf |
|||
* |
|||
* Unity is designed to run on almost anything that is targeted by a C compiler. |
|||
* It would be awesome if this could be done with zero configuration. While |
|||
* there are some targets that come close to this dream, it is sadly not |
|||
* universal. It is likely that you are going to need at least a couple of the |
|||
* configuration options described in this document. |
|||
* |
|||
* All of Unity's configuration options are `#defines`. Most of these are simple |
|||
* definitions. A couple are macros with arguments. They live inside the |
|||
* unity_internals.h header file. We don't necessarily recommend opening that |
|||
* file unless you really need to. That file is proof that a cross-platform |
|||
* library is challenging to build. From a more positive perspective, it is also |
|||
* proof that a great deal of complexity can be centralized primarily to one |
|||
* place in order to provide a more consistent and simple experience elsewhere. |
|||
* |
|||
* Using These Options |
|||
* It doesn't matter if you're using a target-specific compiler and a simulator |
|||
* or a native compiler. In either case, you've got a couple choices for |
|||
* configuring these options: |
|||
* |
|||
* 1. Because these options are specified via C defines, you can pass most of |
|||
* these options to your compiler through command line compiler flags. Even |
|||
* if you're using an embedded target that forces you to use their |
|||
* overbearing IDE for all configuration, there will be a place somewhere in |
|||
* your project to configure defines for your compiler. |
|||
* 2. You can create a custom `unity_config.h` configuration file (present in |
|||
* your toolchain's search paths). In this file, you will list definitions |
|||
* and macros specific to your target. All you must do is define |
|||
* `UNITY_INCLUDE_CONFIG_H` and Unity will rely on `unity_config.h` for any |
|||
* further definitions it may need. |
|||
*/ |
|||
|
|||
#ifndef UNITY_CONFIG_H |
|||
#define UNITY_CONFIG_H |
|||
|
|||
/* ************************* AUTOMATIC INTEGER TYPES ***************************
|
|||
* C's concept of an integer varies from target to target. The C Standard has |
|||
* rules about the `int` matching the register size of the target |
|||
* microprocessor. It has rules about the `int` and how its size relates to |
|||
* other integer types. An `int` on one target might be 16 bits while on another |
|||
* target it might be 64. There are more specific types in compilers compliant |
|||
* with C99 or later, but that's certainly not every compiler you are likely to |
|||
* encounter. Therefore, Unity has a number of features for helping to adjust |
|||
* itself to match your required integer sizes. It starts off by trying to do it |
|||
* automatically. |
|||
**************************************************************************** */ |
|||
|
|||
/* The first attempt to guess your types is to check `limits.h`. Some compilers
|
|||
* that don't support `stdint.h` could include `limits.h`. If you don't |
|||
* want Unity to check this file, define this to make it skip the inclusion. |
|||
* Unity looks at UINT_MAX & ULONG_MAX, which were available since C89. |
|||
*/ |
|||
/* #define UNITY_EXCLUDE_LIMITS_H */ |
|||
|
|||
/* The second thing that Unity does to guess your types is check `stdint.h`.
|
|||
* This file defines `UINTPTR_MAX`, since C99, that Unity can make use of to |
|||
* learn about your system. It's possible you don't want it to do this or it's |
|||
* possible that your system doesn't support `stdint.h`. If that's the case, |
|||
* you're going to want to define this. That way, Unity will know to skip the |
|||
* inclusion of this file and you won't be left with a compiler error. |
|||
*/ |
|||
/* #define UNITY_EXCLUDE_STDINT_H */ |
|||
|
|||
/* ********************** MANUAL INTEGER TYPE DEFINITION ***********************
|
|||
* If you've disabled all of the automatic options above, you're going to have |
|||
* to do the configuration yourself. There are just a handful of defines that |
|||
* you are going to specify if you don't like the defaults. |
|||
**************************************************************************** */ |
|||
|
|||
/* Define this to be the number of bits an `int` takes up on your system. The
|
|||
* default, if not auto-detected, is 32 bits. |
|||
* |
|||
* Example: |
|||
*/ |
|||
/* #define UNITY_INT_WIDTH 16 */ |
|||
|
|||
/* Define this to be the number of bits a `long` takes up on your system. The
|
|||
* default, if not autodetected, is 32 bits. This is used to figure out what |
|||
* kind of 64-bit support your system can handle. Does it need to specify a |
|||
* `long` or a `long long` to get a 64-bit value. On 16-bit systems, this option |
|||
* is going to be ignored. |
|||
* |
|||
* Example: |
|||
*/ |
|||
/* #define UNITY_LONG_WIDTH 16 */ |
|||
|
|||
/* Define this to be the number of bits a pointer takes up on your system. The
|
|||
* default, if not autodetected, is 32-bits. If you're getting ugly compiler |
|||
* warnings about casting from pointers, this is the one to look at. |
|||
* |
|||
* Example: |
|||
*/ |
|||
/* #define UNITY_POINTER_WIDTH 64 */ |
|||
|
|||
/* Unity will automatically include 64-bit support if it auto-detects it, or if
|
|||
* your `int`, `long`, or pointer widths are greater than 32-bits. Define this |
|||
* to enable 64-bit support if none of the other options already did it for you. |
|||
* There can be a significant size and speed impact to enabling 64-bit support |
|||
* on small targets, so don't define it if you don't need it. |
|||
*/ |
|||
/* #define UNITY_INCLUDE_64 */ |
|||
|
|||
|
|||
/* *************************** FLOATING POINT TYPES ****************************
|
|||
* In the embedded world, it's not uncommon for targets to have no support for |
|||
* floating point operations at all or to have support that is limited to only |
|||
* single precision. We are able to guess integer sizes on the fly because |
|||
* integers are always available in at least one size. Floating point, on the |
|||
* other hand, is sometimes not available at all. Trying to include `float.h` on |
|||
* these platforms would result in an error. This leaves manual configuration as |
|||
* the only option. |
|||
**************************************************************************** */ |
|||
|
|||
/* By default, Unity guesses that you will want single precision floating point
|
|||
* support, but not double precision. It's easy to change either of these using |
|||
* the include and exclude options here. You may include neither, just float, |
|||
* or both, as suits your needs. |
|||
*/ |
|||
/* #define UNITY_EXCLUDE_FLOAT */ |
|||
/* #define UNITY_INCLUDE_DOUBLE */ |
|||
/* #define UNITY_EXCLUDE_DOUBLE */ |
|||
|
|||
/* For features that are enabled, the following floating point options also
|
|||
* become available. |
|||
*/ |
|||
|
|||
/* Unity aims for as small of a footprint as possible and avoids most standard
|
|||
* library calls (some embedded platforms don't have a standard library!). |
|||
* Because of this, its routines for printing integer values are minimalist and |
|||
* hand-coded. To keep Unity universal, though, we eventually chose to develop |
|||
* our own floating point print routines. Still, the display of floating point |
|||
* values during a failure are optional. By default, Unity will print the |
|||
* actual results of floating point assertion failures. So a failed assertion |
|||
* will produce a message like "Expected 4.0 Was 4.25". If you would like less |
|||
* verbose failure messages for floating point assertions, use this option to |
|||
* give a failure message `"Values Not Within Delta"` and trim the binary size. |
|||
*/ |
|||
/* #define UNITY_EXCLUDE_FLOAT_PRINT */ |
|||
|
|||
/* If enabled, Unity assumes you want your `FLOAT` asserts to compare standard C
|
|||
* floats. If your compiler supports a specialty floating point type, you can |
|||
* always override this behavior by using this definition. |
|||
* |
|||
* Example: |
|||
*/ |
|||
/* #define UNITY_FLOAT_TYPE float16_t */ |
|||
|
|||
/* If enabled, Unity assumes you want your `DOUBLE` asserts to compare standard
|
|||
* C doubles. If you would like to change this, you can specify something else |
|||
* by using this option. For example, defining `UNITY_DOUBLE_TYPE` to `long |
|||
* double` could enable gargantuan floating point types on your 64-bit processor |
|||
* instead of the standard `double`. |
|||
* |
|||
* Example: |
|||
*/ |
|||
/* #define UNITY_DOUBLE_TYPE long double */ |
|||
|
|||
/* If you look up `UNITY_ASSERT_EQUAL_FLOAT` and `UNITY_ASSERT_EQUAL_DOUBLE` as
|
|||
* documented in the Unity Assertion Guide, you will learn that they are not |
|||
* really asserting that two values are equal but rather that two values are |
|||
* "close enough" to equal. "Close enough" is controlled by these precision |
|||
* configuration options. If you are working with 32-bit floats and/or 64-bit |
|||
* doubles (the normal on most processors), you should have no need to change |
|||
* these options. They are both set to give you approximately 1 significant bit |
|||
* in either direction. The float precision is 0.00001 while the double is |
|||
* 10^-12. For further details on how this works, see the appendix of the Unity |
|||
* Assertion Guide. |
|||
* |
|||
* Example: |
|||
*/ |
|||
/* #define UNITY_FLOAT_PRECISION 0.001f */ |
|||
/* #define UNITY_DOUBLE_PRECISION 0.001f */ |
|||
|
|||
|
|||
/* *************************** MISCELLANEOUS ***********************************
|
|||
* Miscellaneous configuration options for Unity |
|||
**************************************************************************** */ |
|||
|
|||
/* Unity uses the stddef.h header included in the C standard library for the
|
|||
* "NULL" macro. Define this in order to disable the include of stddef.h. If you |
|||
* do this, you have to make sure to provide your own "NULL" definition. |
|||
*/ |
|||
/* #define UNITY_EXCLUDE_STDDEF_H */ |
|||
|
|||
/* Define this to enable the unity formatted print function:
|
|||
* "UnityPrintFormatted" |
|||
*/ |
|||
/* #define UNITY_INCLUDE_PRINT_FORMATTED */ |
|||
|
|||
|
|||
/* *************************** TOOLSET CUSTOMIZATION ***************************
|
|||
* In addition to the options listed above, there are a number of other options |
|||
* which will come in handy to customize Unity's behavior for your specific |
|||
* toolchain. It is possible that you may not need to touch any of these but |
|||
* certain platforms, particularly those running in simulators, may need to jump |
|||
* through extra hoops to operate properly. These macros will help in those |
|||
* situations. |
|||
**************************************************************************** */ |
|||
|
|||
/* By default, Unity prints its results to `stdout` as it runs. This works
|
|||
* perfectly fine in most situations where you are using a native compiler for |
|||
* testing. It works on some simulators as well so long as they have `stdout` |
|||
* routed back to the command line. There are times, however, where the |
|||
* simulator will lack support for dumping results or you will want to route |
|||
* results elsewhere for other reasons. In these cases, you should define the |
|||
* `UNITY_OUTPUT_CHAR` macro. This macro accepts a single character at a time |
|||
* (as an `int`, since this is the parameter type of the standard C `putchar` |
|||
* function most commonly used). You may replace this with whatever function |
|||
* call you like. |
|||
* |
|||
* Example: |
|||
* Say you are forced to run your test suite on an embedded processor with no |
|||
* `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_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 |
|||
* since `setUp` and `tearDown` don't often actually _do_ anything. If you're |
|||
* using gcc or clang, this option is automatically defined for you. Other |
|||
* compilers can also support this behavior, if they support a C feature called |
|||
* weak functions. A weak function is a function that is compiled into your |
|||
* executable _unless_ a non-weak version of the same function is defined |
|||
* elsewhere. If a non-weak version is found, the weak version is ignored as if |
|||
* it never existed. If your compiler supports this feature, you can let Unity |
|||
* know by defining `UNITY_SUPPORT_WEAK` as the function attributes that would |
|||
* need to be applied to identify a function as weak. If your compiler lacks |
|||
* support for weak functions, you will always need to define `setUp` and |
|||
* `tearDown` functions (though they can be and often will be just empty). The |
|||
* most common options for this feature are: |
|||
*/ |
|||
/* #define UNITY_SUPPORT_WEAK weak */ |
|||
/* #define UNITY_SUPPORT_WEAK __attribute__((weak)) */ |
|||
/* #define UNITY_NO_WEAK */ |
|||
|
|||
/* Some compilers require a custom attribute to be assigned to pointers, like
|
|||
* `near` or `far`. In these cases, you can give Unity a safe default for these |
|||
* by defining this option with the attribute you would like. |
|||
* |
|||
* Example: |
|||
*/ |
|||
/* #define UNITY_PTR_ATTRIBUTE __attribute__((far)) */ |
|||
/* #define UNITY_PTR_ATTRIBUTE near */ |
|||
|
|||
/* Print execution time of each test when executed in verbose mode
|
|||
* |
|||
* Example: |
|||
* |
|||
* TEST - PASS (10 ms) |
|||
*/ |
|||
/* #define UNITY_INCLUDE_EXEC_TIME */ |
|||
|
|||
#endif /* UNITY_CONFIG_H */ |
@ -0,0 +1,26 @@ |
|||
Eclipse error parsers |
|||
===================== |
|||
|
|||
These are a godsend for extracting & quickly navigating to |
|||
warnings & error messages from console output. Unforunately |
|||
I don't know how to write an Eclipse plugin so you'll have |
|||
to add them manually. |
|||
|
|||
To add a console parser to Eclipse, go to Window --> Preferences |
|||
--> C/C++ --> Build --> Settings. Click on the 'Error Parsers' |
|||
tab and then click the 'Add...' button. See the table below for |
|||
the parser fields to add. |
|||
|
|||
Eclipse will only parse the console output during a build, so |
|||
running your unit tests must be part of your build process. |
|||
Either add this to your make/rakefile, or add it as a post- |
|||
build step in your Eclipse project settings. |
|||
|
|||
|
|||
Unity unit test error parsers |
|||
----------------------------- |
|||
Severity Pattern File Line Description |
|||
------------------------------------------------------------------------------- |
|||
Error (\.+)(.*?):(\d+):(.*?):FAIL: (.*) $2 $3 $5 |
|||
Warning (\.+)(.*?):(\d+):(.*?):IGNORE: (.*) $2 $3 $5 |
|||
Warning (\.+)(.*?):(\d+):(.*?):IGNORE\s*$ $2 $3 Ignored test |
@ -0,0 +1,46 @@ |
|||
# ========================================== |
|||
# Unity Project - A Test Framework for C |
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
# [Released under MIT License. Please refer to license.txt for details] |
|||
# ========================================== |
|||
|
|||
require 'rake' |
|||
require 'rake/clean' |
|||
require 'rake/testtask' |
|||
require_relative 'rakefile_helper' |
|||
|
|||
TEMP_DIRS = [ |
|||
File.join(__dir__, 'build') |
|||
].freeze |
|||
|
|||
TEMP_DIRS.each do |dir| |
|||
directory(dir) |
|||
CLOBBER.include(dir) |
|||
end |
|||
|
|||
task prepare_for_tests: TEMP_DIRS |
|||
|
|||
include RakefileHelpers |
|||
|
|||
# Load default configuration, for now |
|||
DEFAULT_CONFIG_FILE = 'gcc_auto_stdint.yml'.freeze |
|||
configure_toolchain(DEFAULT_CONFIG_FILE) |
|||
|
|||
task unit: [:prepare_for_tests] do |
|||
run_tests |
|||
end |
|||
|
|||
desc 'Build and test Unity Framework' |
|||
task all: %i[clean unit] |
|||
task default: %i[clobber all] |
|||
task ci: %i[no_color default] |
|||
task cruise: %i[no_color default] |
|||
|
|||
desc 'Load configuration' |
|||
task :config, :config_file do |_t, args| |
|||
configure_toolchain(args[:config_file]) |
|||
end |
|||
|
|||
task :no_color do |
|||
$colour_output = false |
|||
end |
@ -0,0 +1,178 @@ |
|||
# ========================================== |
|||
# Unity Project - A Test Framework for C |
|||
# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
# [Released under MIT License. Please refer to license.txt for details] |
|||
# ========================================== |
|||
|
|||
require 'yaml' |
|||
require 'fileutils' |
|||
require_relative '../../auto/unity_test_summary' |
|||
require_relative '../../auto/generate_test_runner' |
|||
require_relative '../../auto/colour_reporter' |
|||
|
|||
module RakefileHelpers |
|||
C_EXTENSION = '.c'.freeze |
|||
|
|||
def load_configuration(config_file) |
|||
return if $configured |
|||
|
|||
$cfg_file = "#{__dir__}/../../test/targets/#{config_file}" unless config_file =~ /[\\|\/]/ |
|||
$cfg = YAML.load(File.read($cfg_file)) |
|||
$colour_output = false unless $cfg['colour'] |
|||
$configured = true if config_file != DEFAULT_CONFIG_FILE |
|||
end |
|||
|
|||
def configure_clean |
|||
CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil? |
|||
end |
|||
|
|||
def configure_toolchain(config_file = DEFAULT_CONFIG_FILE) |
|||
config_file += '.yml' unless config_file =~ /\.yml$/ |
|||
config_file = config_file unless config_file =~ /[\\|\/]/ |
|||
load_configuration(config_file) |
|||
configure_clean |
|||
end |
|||
|
|||
def tackit(strings) |
|||
result = if strings.is_a?(Array) |
|||
"\"#{strings.join}\"" |
|||
else |
|||
strings |
|||
end |
|||
result |
|||
end |
|||
|
|||
def squash(prefix, items) |
|||
result = '' |
|||
items.each { |item| result += " #{prefix}#{tackit(item)}" } |
|||
result |
|||
end |
|||
|
|||
def build_compiler_fields |
|||
command = tackit($cfg['compiler']['path']) |
|||
defines = if $cfg['compiler']['defines']['items'].nil? |
|||
'' |
|||
else |
|||
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']) |
|||
includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) |
|||
|
|||
{ command: command, defines: defines, options: options, includes: includes } |
|||
end |
|||
|
|||
def compile(file, _defines = []) |
|||
compiler = build_compiler_fields |
|||
unity_include = $cfg['compiler']['includes']['prefix'] + '../../src' |
|||
cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{unity_include} #{file} " \ |
|||
"#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}" \ |
|||
"#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}" |
|||
|
|||
execute(cmd_str) |
|||
end |
|||
|
|||
def build_linker_fields |
|||
command = tackit($cfg['linker']['path']) |
|||
options = if $cfg['linker']['options'].nil? |
|||
'' |
|||
else |
|||
squash('', $cfg['linker']['options']) |
|||
end |
|||
includes = if $cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil? |
|||
'' |
|||
else |
|||
squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items']) |
|||
end.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR) |
|||
|
|||
{ command: command, options: options, includes: includes } |
|||
end |
|||
|
|||
def link_it(exe_name, obj_list) |
|||
linker = build_linker_fields |
|||
cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " + |
|||
(obj_list.map { |obj| "#{$cfg['linker']['object_files']['path']}#{obj} " }).join + |
|||
$cfg['linker']['bin_files']['prefix'] + ' ' + |
|||
$cfg['linker']['bin_files']['destination'] + |
|||
exe_name + $cfg['linker']['bin_files']['extension'] |
|||
execute(cmd_str) |
|||
end |
|||
|
|||
def build_simulator_fields |
|||
return nil if $cfg['simulator'].nil? |
|||
command = if $cfg['simulator']['path'].nil? |
|||
'' |
|||
else |
|||
(tackit($cfg['simulator']['path']) + ' ') |
|||
end |
|||
pre_support = if $cfg['simulator']['pre_support'].nil? |
|||
'' |
|||
else |
|||
squash('', $cfg['simulator']['pre_support']) |
|||
end |
|||
post_support = if $cfg['simulator']['post_support'].nil? |
|||
'' |
|||
else |
|||
squash('', $cfg['simulator']['post_support']) |
|||
end |
|||
{ command: command, pre_support: pre_support, post_support: post_support } |
|||
end |
|||
|
|||
def execute(command_string, verbose = true) |
|||
report command_string |
|||
output = `#{command_string}`.chomp |
|||
report(output) if verbose && !output.nil? && !output.empty? |
|||
raise "Command failed. (Returned #{$?.exitstatus})" if $?.exitstatus != 0 |
|||
output |
|||
end |
|||
|
|||
def report_summary |
|||
summary = UnityTestSummary.new |
|||
summary.root = __dir__ |
|||
results_glob = "#{$cfg['compiler']['build_path']}*.test*" |
|||
results_glob.tr!('\\', '/') |
|||
results = Dir[results_glob] |
|||
summary.targets = results |
|||
summary.run |
|||
end |
|||
|
|||
def run_tests |
|||
report 'Running Unity system tests...' |
|||
|
|||
# Tack on TEST define for compiling unit tests |
|||
load_configuration($cfg_file) |
|||
test_defines = ['TEST'] |
|||
$cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil? |
|||
|
|||
# Get a list of all source files needed |
|||
src_files = Dir["#{__dir__}/src/*.c"] |
|||
src_files += Dir["#{__dir__}/test/*.c"] |
|||
src_files += Dir["#{__dir__}/test/main/*.c"] |
|||
src_files << '../../src/unity.c' |
|||
|
|||
# Build object files |
|||
src_files.each { |f| compile(f, test_defines) } |
|||
obj_list = src_files.map { |f| File.basename(f.ext($cfg['compiler']['object_files']['extension'])) } |
|||
|
|||
# Link the test executable |
|||
test_base = 'framework_test' |
|||
link_it(test_base, obj_list) |
|||
|
|||
# Execute unit test and generate results file |
|||
simulator = build_simulator_fields |
|||
executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension'] |
|||
cmd_str = if simulator.nil? |
|||
executable + ' -v -r' |
|||
else |
|||
"#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}" |
|||
end |
|||
output = execute(cmd_str) |
|||
test_results = $cfg['compiler']['build_path'] + test_base |
|||
test_results += if output.match(/OK$/m).nil? |
|||
'.testfail' |
|||
else |
|||
'.testpass' |
|||
end |
|||
File.open(test_results, 'w') { |f| f.print output } |
|||
end |
|||
end |
@ -0,0 +1,9 @@ |
|||
Copyright (c) 2010 James Grenning and Contributed to Unity Project |
|||
|
|||
Unity Project - A Test Framework for C |
|||
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
[Released under MIT License. Please refer to license.txt for details] |
|||
|
|||
This Framework is an optional add-on to Unity. By including unity_framework.h in place of unity.h, |
|||
you may now work with Unity in a manner similar to CppUTest. This framework adds the concepts of |
|||
test groups and gives finer control of your tests over the command line. |
@ -0,0 +1,455 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
#include "unity_fixture.h" |
|||
#include "unity_internals.h" |
|||
#include <string.h> |
|||
|
|||
struct UNITY_FIXTURE_T UnityFixture; |
|||
|
|||
/* If you decide to use the function pointer approach.
|
|||
* Build with -D UNITY_OUTPUT_CHAR=outputChar and include <stdio.h> |
|||
* int (*outputChar)(int) = putchar; */ |
|||
|
|||
#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA) |
|||
void setUp(void) { /*does nothing*/ } |
|||
void tearDown(void) { /*does nothing*/ } |
|||
#endif |
|||
|
|||
static void announceTestRun(unsigned int runNumber) |
|||
{ |
|||
UnityPrint("Unity test run "); |
|||
UnityPrintNumberUnsigned(runNumber+1); |
|||
UnityPrint(" of "); |
|||
UnityPrintNumberUnsigned(UnityFixture.RepeatCount); |
|||
UNITY_PRINT_EOL(); |
|||
} |
|||
|
|||
int UnityMain(int argc, const char* argv[], void (*runAllTests)(void)) |
|||
{ |
|||
int result = UnityGetCommandLineOptions(argc, argv); |
|||
unsigned int r; |
|||
if (result != 0) |
|||
return result; |
|||
|
|||
for (r = 0; r < UnityFixture.RepeatCount; r++) |
|||
{ |
|||
UnityBegin(argv[0]); |
|||
announceTestRun(r); |
|||
runAllTests(); |
|||
if (!UnityFixture.Verbose) UNITY_PRINT_EOL(); |
|||
UnityEnd(); |
|||
} |
|||
|
|||
return (int)Unity.TestFailures; |
|||
} |
|||
|
|||
static int selected(const char* filter, const char* name) |
|||
{ |
|||
if (filter == 0) |
|||
return 1; |
|||
return strstr(name, filter) ? 1 : 0; |
|||
} |
|||
|
|||
static int testSelected(const char* test) |
|||
{ |
|||
return selected(UnityFixture.NameFilter, test); |
|||
} |
|||
|
|||
static int groupSelected(const char* group) |
|||
{ |
|||
return selected(UnityFixture.GroupFilter, group); |
|||
} |
|||
|
|||
void UnityTestRunner(unityfunction* setup, |
|||
unityfunction* testBody, |
|||
unityfunction* teardown, |
|||
const char* printableName, |
|||
const char* group, |
|||
const char* name, |
|||
const char* file, |
|||
unsigned int line) |
|||
{ |
|||
if (testSelected(name) && groupSelected(group)) |
|||
{ |
|||
Unity.TestFile = file; |
|||
Unity.CurrentTestName = printableName; |
|||
Unity.CurrentTestLineNumber = line; |
|||
if (UnityFixture.Verbose) |
|||
{ |
|||
UnityPrint(printableName); |
|||
#ifndef UNITY_REPEAT_TEST_NAME |
|||
Unity.CurrentTestName = NULL; |
|||
#endif |
|||
} |
|||
else if (UnityFixture.Silent) |
|||
{ |
|||
/* Do Nothing */ |
|||
} |
|||
else |
|||
{ |
|||
UNITY_OUTPUT_CHAR('.'); |
|||
} |
|||
|
|||
Unity.NumberOfTests++; |
|||
UnityMalloc_StartTest(); |
|||
UnityPointer_Init(); |
|||
|
|||
UNITY_EXEC_TIME_START(); |
|||
|
|||
if (TEST_PROTECT()) |
|||
{ |
|||
setup(); |
|||
testBody(); |
|||
} |
|||
if (TEST_PROTECT()) |
|||
{ |
|||
teardown(); |
|||
} |
|||
if (TEST_PROTECT()) |
|||
{ |
|||
UnityPointer_UndoAllSets(); |
|||
if (!Unity.CurrentTestFailed) |
|||
UnityMalloc_EndTest(); |
|||
} |
|||
UnityConcludeFixtureTest(); |
|||
} |
|||
} |
|||
|
|||
void UnityIgnoreTest(const char* printableName, const char* group, const char* name) |
|||
{ |
|||
if (testSelected(name) && groupSelected(group)) |
|||
{ |
|||
Unity.NumberOfTests++; |
|||
Unity.TestIgnores++; |
|||
if (UnityFixture.Verbose) |
|||
{ |
|||
UnityPrint(printableName); |
|||
UNITY_PRINT_EOL(); |
|||
} |
|||
else if (UnityFixture.Silent) |
|||
{ |
|||
/* Do Nothing */ |
|||
} |
|||
else |
|||
{ |
|||
UNITY_OUTPUT_CHAR('!'); |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
/*------------------------------------------------- */ |
|||
/* Malloc and free stuff */ |
|||
#define MALLOC_DONT_FAIL -1 |
|||
static int malloc_count; |
|||
static int malloc_fail_countdown = MALLOC_DONT_FAIL; |
|||
|
|||
void UnityMalloc_StartTest(void) |
|||
{ |
|||
malloc_count = 0; |
|||
malloc_fail_countdown = MALLOC_DONT_FAIL; |
|||
} |
|||
|
|||
void UnityMalloc_EndTest(void) |
|||
{ |
|||
malloc_fail_countdown = MALLOC_DONT_FAIL; |
|||
if (malloc_count != 0) |
|||
{ |
|||
UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!"); |
|||
} |
|||
} |
|||
|
|||
void UnityMalloc_MakeMallocFailAfterCount(int countdown) |
|||
{ |
|||
malloc_fail_countdown = countdown; |
|||
} |
|||
|
|||
/* These definitions are always included from unity_fixture_malloc_overrides.h */ |
|||
/* We undef to use them or avoid conflict with <stdlib.h> per the C standard */ |
|||
#undef malloc |
|||
#undef free |
|||
#undef calloc |
|||
#undef realloc |
|||
|
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC |
|||
static unsigned char unity_heap[UNITY_INTERNAL_HEAP_SIZE_BYTES]; |
|||
static size_t heap_index; |
|||
#else |
|||
#include <stdlib.h> |
|||
#endif |
|||
|
|||
typedef struct GuardBytes |
|||
{ |
|||
size_t size; |
|||
size_t guard_space; |
|||
} Guard; |
|||
|
|||
|
|||
static const char end[] = "END"; |
|||
|
|||
void* unity_malloc(size_t size) |
|||
{ |
|||
char* mem; |
|||
Guard* guard; |
|||
size_t total_size = size + sizeof(Guard) + sizeof(end); |
|||
|
|||
if (malloc_fail_countdown != MALLOC_DONT_FAIL) |
|||
{ |
|||
if (malloc_fail_countdown == 0) |
|||
return NULL; |
|||
malloc_fail_countdown--; |
|||
} |
|||
|
|||
if (size == 0) return NULL; |
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC |
|||
if (heap_index + total_size > UNITY_INTERNAL_HEAP_SIZE_BYTES) |
|||
{ |
|||
guard = NULL; |
|||
} |
|||
else |
|||
{ |
|||
guard = (Guard*)&unity_heap[heap_index]; |
|||
heap_index += total_size; |
|||
} |
|||
#else |
|||
guard = (Guard*)UNITY_FIXTURE_MALLOC(total_size); |
|||
#endif |
|||
if (guard == NULL) return NULL; |
|||
malloc_count++; |
|||
guard->size = size; |
|||
guard->guard_space = 0; |
|||
mem = (char*)&(guard[1]); |
|||
memcpy(&mem[size], end, sizeof(end)); |
|||
|
|||
return (void*)mem; |
|||
} |
|||
|
|||
static int isOverrun(void* mem) |
|||
{ |
|||
Guard* guard = (Guard*)mem; |
|||
char* memAsChar = (char*)mem; |
|||
guard--; |
|||
|
|||
return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0; |
|||
} |
|||
|
|||
static void release_memory(void* mem) |
|||
{ |
|||
Guard* guard = (Guard*)mem; |
|||
guard--; |
|||
|
|||
malloc_count--; |
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC |
|||
if (mem == unity_heap + heap_index - guard->size - sizeof(end)) |
|||
{ |
|||
heap_index -= (guard->size + sizeof(Guard) + sizeof(end)); |
|||
} |
|||
#else |
|||
UNITY_FIXTURE_FREE(guard); |
|||
#endif |
|||
} |
|||
|
|||
void unity_free(void* mem) |
|||
{ |
|||
int overrun; |
|||
|
|||
if (mem == NULL) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
overrun = isOverrun(mem); |
|||
release_memory(mem); |
|||
if (overrun) |
|||
{ |
|||
UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()"); |
|||
} |
|||
} |
|||
|
|||
void* unity_calloc(size_t num, size_t size) |
|||
{ |
|||
void* mem = unity_malloc(num * size); |
|||
if (mem == NULL) return NULL; |
|||
memset(mem, 0, num * size); |
|||
return mem; |
|||
} |
|||
|
|||
void* unity_realloc(void* oldMem, size_t size) |
|||
{ |
|||
Guard* guard = (Guard*)oldMem; |
|||
void* newMem; |
|||
|
|||
if (oldMem == NULL) return unity_malloc(size); |
|||
|
|||
guard--; |
|||
if (isOverrun(oldMem)) |
|||
{ |
|||
release_memory(oldMem); |
|||
UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()"); |
|||
} |
|||
|
|||
if (size == 0) |
|||
{ |
|||
release_memory(oldMem); |
|||
return NULL; |
|||
} |
|||
|
|||
if (guard->size >= size) return oldMem; |
|||
|
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */ |
|||
if (oldMem == unity_heap + heap_index - guard->size - sizeof(end) && |
|||
heap_index + size - guard->size <= UNITY_INTERNAL_HEAP_SIZE_BYTES) |
|||
{ |
|||
release_memory(oldMem); /* Not thread-safe, like unity_heap generally */ |
|||
return unity_malloc(size); /* No memcpy since data is in place */ |
|||
} |
|||
#endif |
|||
newMem = unity_malloc(size); |
|||
if (newMem == NULL) return NULL; /* Do not release old memory */ |
|||
memcpy(newMem, oldMem, guard->size); |
|||
release_memory(oldMem); |
|||
return newMem; |
|||
} |
|||
|
|||
|
|||
/*-------------------------------------------------------- */ |
|||
/*Automatic pointer restoration functions */ |
|||
struct PointerPair |
|||
{ |
|||
void** pointer; |
|||
void* old_value; |
|||
}; |
|||
|
|||
static struct PointerPair pointer_store[UNITY_MAX_POINTERS]; |
|||
static int pointer_index = 0; |
|||
|
|||
void UnityPointer_Init(void) |
|||
{ |
|||
pointer_index = 0; |
|||
} |
|||
|
|||
void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line) |
|||
{ |
|||
if (pointer_index >= UNITY_MAX_POINTERS) |
|||
{ |
|||
UNITY_TEST_FAIL(line, "Too many pointers set"); |
|||
} |
|||
else |
|||
{ |
|||
pointer_store[pointer_index].pointer = pointer; |
|||
pointer_store[pointer_index].old_value = *pointer; |
|||
*pointer = newValue; |
|||
pointer_index++; |
|||
} |
|||
} |
|||
|
|||
void UnityPointer_UndoAllSets(void) |
|||
{ |
|||
while (pointer_index > 0) |
|||
{ |
|||
pointer_index--; |
|||
*(pointer_store[pointer_index].pointer) = |
|||
pointer_store[pointer_index].old_value; |
|||
} |
|||
} |
|||
|
|||
int UnityGetCommandLineOptions(int argc, const char* argv[]) |
|||
{ |
|||
int i; |
|||
UnityFixture.Verbose = 0; |
|||
UnityFixture.Silent = 0; |
|||
UnityFixture.GroupFilter = 0; |
|||
UnityFixture.NameFilter = 0; |
|||
UnityFixture.RepeatCount = 1; |
|||
|
|||
if (argc == 1) |
|||
return 0; |
|||
|
|||
for (i = 1; i < argc; ) |
|||
{ |
|||
if (strcmp(argv[i], "-v") == 0) |
|||
{ |
|||
UnityFixture.Verbose = 1; |
|||
i++; |
|||
} |
|||
else if (strcmp(argv[i], "-s") == 0) |
|||
{ |
|||
UnityFixture.Silent = 1; |
|||
i++; |
|||
} |
|||
else if (strcmp(argv[i], "-g") == 0) |
|||
{ |
|||
i++; |
|||
if (i >= argc) |
|||
return 1; |
|||
UnityFixture.GroupFilter = argv[i]; |
|||
i++; |
|||
} |
|||
else if (strcmp(argv[i], "-n") == 0) |
|||
{ |
|||
i++; |
|||
if (i >= argc) |
|||
return 1; |
|||
UnityFixture.NameFilter = argv[i]; |
|||
i++; |
|||
} |
|||
else if (strcmp(argv[i], "-r") == 0) |
|||
{ |
|||
UnityFixture.RepeatCount = 2; |
|||
i++; |
|||
if (i < argc) |
|||
{ |
|||
if (*(argv[i]) >= '0' && *(argv[i]) <= '9') |
|||
{ |
|||
unsigned int digit = 0; |
|||
UnityFixture.RepeatCount = 0; |
|||
while (argv[i][digit] >= '0' && argv[i][digit] <= '9') |
|||
{ |
|||
UnityFixture.RepeatCount *= 10; |
|||
UnityFixture.RepeatCount += (unsigned int)argv[i][digit++] - '0'; |
|||
} |
|||
i++; |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
/* ignore unknown parameter */ |
|||
i++; |
|||
} |
|||
} |
|||
return 0; |
|||
} |
|||
|
|||
void UnityConcludeFixtureTest(void) |
|||
{ |
|||
if (Unity.CurrentTestIgnored) |
|||
{ |
|||
Unity.TestIgnores++; |
|||
UNITY_PRINT_EOL(); |
|||
} |
|||
else if (!Unity.CurrentTestFailed) |
|||
{ |
|||
if (UnityFixture.Verbose) |
|||
{ |
|||
UnityPrint(" "); |
|||
UnityPrint(UnityStrPass); |
|||
UNITY_EXEC_TIME_STOP(); |
|||
UNITY_PRINT_EXEC_TIME(); |
|||
UNITY_PRINT_EOL(); |
|||
} |
|||
} |
|||
else /* Unity.CurrentTestFailed */ |
|||
{ |
|||
Unity.TestFailures++; |
|||
UNITY_PRINT_EOL(); |
|||
} |
|||
|
|||
Unity.CurrentTestFailed = 0; |
|||
Unity.CurrentTestIgnored = 0; |
|||
} |
@ -0,0 +1,83 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
#ifndef UNITY_FIXTURE_H_ |
|||
#define UNITY_FIXTURE_H_ |
|||
|
|||
#include "unity.h" |
|||
#include "unity_internals.h" |
|||
#include "unity_fixture_malloc_overrides.h" |
|||
#include "unity_fixture_internals.h" |
|||
|
|||
int UnityMain(int argc, const char* argv[], void (*runAllTests)(void)); |
|||
|
|||
|
|||
#define TEST_GROUP(group)\ |
|||
static const char* TEST_GROUP_##group = #group |
|||
|
|||
#define TEST_SETUP(group) void TEST_##group##_SETUP(void);\ |
|||
void TEST_##group##_SETUP(void) |
|||
|
|||
#define TEST_TEAR_DOWN(group) void TEST_##group##_TEAR_DOWN(void);\ |
|||
void TEST_##group##_TEAR_DOWN(void) |
|||
|
|||
|
|||
#define TEST(group, name) \ |
|||
void TEST_##group##_##name##_(void);\ |
|||
void TEST_##group##_##name##_run(void);\ |
|||
void TEST_##group##_##name##_run(void)\ |
|||
{\ |
|||
UnityTestRunner(TEST_##group##_SETUP,\ |
|||
TEST_##group##_##name##_,\ |
|||
TEST_##group##_TEAR_DOWN,\ |
|||
"TEST(" #group ", " #name ")",\ |
|||
TEST_GROUP_##group, #name,\ |
|||
__FILE__, __LINE__);\ |
|||
}\ |
|||
void TEST_##group##_##name##_(void) |
|||
|
|||
#define IGNORE_TEST(group, name) \ |
|||
void TEST_##group##_##name##_(void);\ |
|||
void TEST_##group##_##name##_run(void);\ |
|||
void TEST_##group##_##name##_run(void)\ |
|||
{\ |
|||
UnityIgnoreTest("IGNORE_TEST(" #group ", " #name ")", TEST_GROUP_##group, #name);\ |
|||
}\ |
|||
void TEST_##group##_##name##_(void) |
|||
|
|||
/* Call this for each test, insider the group runner */ |
|||
#define RUN_TEST_CASE(group, name) \ |
|||
{ void TEST_##group##_##name##_run(void);\ |
|||
TEST_##group##_##name##_run(); } |
|||
|
|||
/* This goes at the bottom of each test file or in a separate c file */ |
|||
#define TEST_GROUP_RUNNER(group)\ |
|||
void TEST_##group##_GROUP_RUNNER(void);\ |
|||
void TEST_##group##_GROUP_RUNNER(void) |
|||
|
|||
/* Call this from main */ |
|||
#define RUN_TEST_GROUP(group)\ |
|||
{ void TEST_##group##_GROUP_RUNNER(void);\ |
|||
TEST_##group##_GROUP_RUNNER(); } |
|||
|
|||
/* CppUTest Compatibility Macros */ |
|||
#ifndef UNITY_EXCLUDE_CPPUTEST_ASSERTS |
|||
/* Sets a pointer and automatically restores it to its old value after teardown */ |
|||
#define UT_PTR_SET(ptr, newPointerValue) UnityPointer_Set((void**)&(ptr), (void*)(newPointerValue), __LINE__) |
|||
#define TEST_ASSERT_POINTERS_EQUAL(expected, actual) TEST_ASSERT_EQUAL_PTR((expected), (actual)) |
|||
#define TEST_ASSERT_BYTES_EQUAL(expected, actual) TEST_ASSERT_EQUAL_HEX8(0xff & (expected), 0xff & (actual)) |
|||
#define FAIL(message) TEST_FAIL_MESSAGE((message)) |
|||
#define CHECK(condition) TEST_ASSERT_TRUE((condition)) |
|||
#define LONGS_EQUAL(expected, actual) TEST_ASSERT_EQUAL_INT((expected), (actual)) |
|||
#define STRCMP_EQUAL(expected, actual) TEST_ASSERT_EQUAL_STRING((expected), (actual)) |
|||
#define DOUBLES_EQUAL(expected, actual, delta) TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual)) |
|||
#endif |
|||
|
|||
/* You must compile with malloc replacement, as defined in unity_fixture_malloc_overrides.h */ |
|||
void UnityMalloc_MakeMallocFailAfterCount(int countdown); |
|||
|
|||
#endif /* UNITY_FIXTURE_H_ */ |
@ -0,0 +1,52 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
#ifndef UNITY_FIXTURE_INTERNALS_H_ |
|||
#define UNITY_FIXTURE_INTERNALS_H_ |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" |
|||
{ |
|||
#endif |
|||
|
|||
struct UNITY_FIXTURE_T |
|||
{ |
|||
int Verbose; |
|||
int Silent; |
|||
unsigned int RepeatCount; |
|||
const char* NameFilter; |
|||
const char* GroupFilter; |
|||
}; |
|||
extern struct UNITY_FIXTURE_T UnityFixture; |
|||
|
|||
typedef void unityfunction(void); |
|||
void UnityTestRunner(unityfunction* setup, |
|||
unityfunction* testBody, |
|||
unityfunction* teardown, |
|||
const char* printableName, |
|||
const char* group, |
|||
const char* name, |
|||
const char* file, unsigned int line); |
|||
|
|||
void UnityIgnoreTest(const char* printableName, const char* group, const char* name); |
|||
void UnityMalloc_StartTest(void); |
|||
void UnityMalloc_EndTest(void); |
|||
int UnityGetCommandLineOptions(int argc, const char* argv[]); |
|||
void UnityConcludeFixtureTest(void); |
|||
|
|||
void UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line); |
|||
void UnityPointer_UndoAllSets(void); |
|||
void UnityPointer_Init(void); |
|||
#ifndef UNITY_MAX_POINTERS |
|||
#define UNITY_MAX_POINTERS 5 |
|||
#endif |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif /* UNITY_FIXTURE_INTERNALS_H_ */ |
@ -0,0 +1,47 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
#ifndef UNITY_FIXTURE_MALLOC_OVERRIDES_H_ |
|||
#define UNITY_FIXTURE_MALLOC_OVERRIDES_H_ |
|||
|
|||
#include <stddef.h> |
|||
|
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC |
|||
/* Define this macro to remove the use of stdlib.h, malloc, and free.
|
|||
* Many embedded systems do not have a heap or malloc/free by default. |
|||
* This internal unity_malloc() provides allocated memory deterministically from |
|||
* the end of an array only, unity_free() only releases from end-of-array, |
|||
* blocks are not coalesced, and memory not freed in LIFO order is stranded. */ |
|||
#ifndef UNITY_INTERNAL_HEAP_SIZE_BYTES |
|||
#define UNITY_INTERNAL_HEAP_SIZE_BYTES 256 |
|||
#endif |
|||
#endif |
|||
|
|||
/* These functions are used by the Unity Fixture to allocate and release memory
|
|||
* on the heap and can be overridden with platform-specific implementations. |
|||
* For example, when using FreeRTOS UNITY_FIXTURE_MALLOC becomes pvPortMalloc() |
|||
* and UNITY_FIXTURE_FREE becomes vPortFree(). */ |
|||
#if !defined(UNITY_FIXTURE_MALLOC) || !defined(UNITY_FIXTURE_FREE) |
|||
#include <stdlib.h> |
|||
#define UNITY_FIXTURE_MALLOC(size) malloc(size) |
|||
#define UNITY_FIXTURE_FREE(ptr) free(ptr) |
|||
#else |
|||
extern void* UNITY_FIXTURE_MALLOC(size_t size); |
|||
extern void UNITY_FIXTURE_FREE(void* ptr); |
|||
#endif |
|||
|
|||
#define malloc unity_malloc |
|||
#define calloc unity_calloc |
|||
#define realloc unity_realloc |
|||
#define free unity_free |
|||
|
|||
void* unity_malloc(size_t size); |
|||
void* unity_calloc(size_t num, size_t size); |
|||
void* unity_realloc(void * oldMem, size_t size); |
|||
void unity_free(void * mem); |
|||
|
|||
#endif /* UNITY_FIXTURE_MALLOC_OVERRIDES_H_ */ |
@ -0,0 +1,75 @@ |
|||
CC = gcc |
|||
ifeq ($(shell uname -s), Darwin) |
|||
CC = clang |
|||
endif |
|||
#DEBUG = -O0 -g
|
|||
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 \
|
|||
unity_fixture_TestRunner.c \
|
|||
unity_output_Spy.c \
|
|||
main/AllTests.c |
|||
|
|||
INC_DIR = -I../src -I../../../src/ |
|||
BUILD_DIR = ../build |
|||
TARGET = ../build/fixture_tests.exe |
|||
|
|||
all: default noStdlibMalloc 32bits |
|||
|
|||
default: $(BUILD_DIR) |
|||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_SUPPORT_64 |
|||
@ echo "default build" |
|||
./$(TARGET) |
|||
|
|||
32bits: $(BUILD_DIR) |
|||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -m32 |
|||
@ echo "32bits build" |
|||
./$(TARGET) |
|||
|
|||
noStdlibMalloc: $(BUILD_DIR) |
|||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC |
|||
@ echo "build with noStdlibMalloc" |
|||
./$(TARGET) |
|||
|
|||
C89: CFLAGS += -D UNITY_EXCLUDE_STDINT_H # C89 did not have type 'long long', <stdint.h>
|
|||
C89: $(BUILD_DIR) |
|||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -std=c89 && ./$(TARGET) |
|||
$(CC) $(CFLAGS) $(DEFINES) $(SRC) $(INC_DIR) -o $(TARGET) -D UNITY_EXCLUDE_STDLIB_MALLOC -std=c89 |
|||
./$(TARGET) |
|||
|
|||
$(BUILD_DIR): |
|||
mkdir -p $(BUILD_DIR) |
|||
|
|||
clean: |
|||
rm -f $(TARGET) $(BUILD_DIR)/*.gc* |
|||
|
|||
cov: $(BUILD_DIR) |
|||
cd $(BUILD_DIR) && \
|
|||
$(CC) $(DEFINES) $(foreach i, $(SRC), ../test/$(i)) $(INC_DIR) -o $(TARGET) -fprofile-arcs -ftest-coverage |
|||
rm -f $(BUILD_DIR)/*.gcda |
|||
./$(TARGET) > /dev/null ; ./$(TARGET) -v > /dev/null |
|||
cd $(BUILD_DIR) && \
|
|||
gcov unity_fixture.c | head -3 |
|||
grep '###' $(BUILD_DIR)/unity_fixture.c.gcov -C2 || true # Show uncovered lines |
|||
|
|||
# These extended flags DO get included before any target build runs
|
|||
CFLAGS += -Wbad-function-cast |
|||
CFLAGS += -Wcast-qual |
|||
CFLAGS += -Wconversion |
|||
CFLAGS += -Wformat=2 |
|||
CFLAGS += -Wmissing-prototypes |
|||
CFLAGS += -Wold-style-definition |
|||
CFLAGS += -Wpointer-arith |
|||
CFLAGS += -Wshadow |
|||
CFLAGS += -Wstrict-overflow=5 |
|||
CFLAGS += -Wstrict-prototypes |
|||
CFLAGS += -Wswitch-default |
|||
CFLAGS += -Wundef |
|||
CFLAGS += -Wno-error=undef # Warning only, this should not stop the build |
|||
CFLAGS += -Wunreachable-code |
|||
CFLAGS += -Wunused |
|||
CFLAGS += -fstrict-aliasing |
@ -0,0 +1,22 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
#include "unity_fixture.h" |
|||
|
|||
static void runAllTests(void) |
|||
{ |
|||
RUN_TEST_GROUP(UnityFixture); |
|||
RUN_TEST_GROUP(UnityCommandOptions); |
|||
RUN_TEST_GROUP(LeakDetection); |
|||
RUN_TEST_GROUP(InternalMalloc); |
|||
} |
|||
|
|||
int main(int argc, const char* argv[]) |
|||
{ |
|||
return UnityMain(argc, argv, runAllTests); |
|||
} |
|||
|
@ -0,0 +1,39 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
#include "unity_fixture.h" |
|||
|
|||
static int data = -1; |
|||
|
|||
TEST_GROUP(mygroup); |
|||
|
|||
TEST_SETUP(mygroup) |
|||
{ |
|||
data = 0; |
|||
} |
|||
|
|||
TEST_TEAR_DOWN(mygroup) |
|||
{ |
|||
data = -1; |
|||
} |
|||
|
|||
TEST(mygroup, test1) |
|||
{ |
|||
TEST_ASSERT_EQUAL_INT(0, data); |
|||
} |
|||
|
|||
TEST(mygroup, test2) |
|||
{ |
|||
TEST_ASSERT_EQUAL_INT(0, data); |
|||
data = 5; |
|||
} |
|||
|
|||
TEST(mygroup, test3) |
|||
{ |
|||
data = 7; |
|||
TEST_ASSERT_EQUAL_INT(7, data); |
|||
} |
@ -0,0 +1,543 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
#include "unity_fixture.h" |
|||
#include "unity_output_Spy.h" |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
|
|||
TEST_GROUP(UnityFixture); |
|||
|
|||
TEST_SETUP(UnityFixture) |
|||
{ |
|||
} |
|||
|
|||
TEST_TEAR_DOWN(UnityFixture) |
|||
{ |
|||
} |
|||
|
|||
static int* pointer1 = 0; |
|||
static int* pointer2 = (int*)2; |
|||
static int* pointer3 = (int*)3; |
|||
static int int1; |
|||
static int int2; |
|||
static int int3; |
|||
static int int4; |
|||
|
|||
TEST(UnityFixture, PointerSetting) |
|||
{ |
|||
TEST_ASSERT_POINTERS_EQUAL(pointer1, 0); |
|||
UT_PTR_SET(pointer1, &int1); |
|||
UT_PTR_SET(pointer2, &int2); |
|||
UT_PTR_SET(pointer3, &int3); |
|||
TEST_ASSERT_POINTERS_EQUAL(pointer1, &int1); |
|||
TEST_ASSERT_POINTERS_EQUAL(pointer2, &int2); |
|||
TEST_ASSERT_POINTERS_EQUAL(pointer3, &int3); |
|||
UT_PTR_SET(pointer1, &int4); |
|||
UnityPointer_UndoAllSets(); |
|||
TEST_ASSERT_POINTERS_EQUAL(pointer1, 0); |
|||
TEST_ASSERT_POINTERS_EQUAL(pointer2, (int*)2); |
|||
TEST_ASSERT_POINTERS_EQUAL(pointer3, (int*)3); |
|||
} |
|||
|
|||
TEST(UnityFixture, ForceMallocFail) |
|||
{ |
|||
void* m; |
|||
void* mfails; |
|||
UnityMalloc_MakeMallocFailAfterCount(1); |
|||
m = malloc(10); |
|||
CHECK(m); |
|||
mfails = malloc(10); |
|||
TEST_ASSERT_POINTERS_EQUAL(0, mfails); |
|||
free(m); |
|||
} |
|||
|
|||
TEST(UnityFixture, ReallocSmallerIsUnchanged) |
|||
{ |
|||
void* m1 = malloc(10); |
|||
void* m2 = realloc(m1, 5); |
|||
TEST_ASSERT_POINTERS_EQUAL(m1, m2); |
|||
free(m2); |
|||
} |
|||
|
|||
TEST(UnityFixture, ReallocSameIsUnchanged) |
|||
{ |
|||
void* m1 = malloc(10); |
|||
void* m2 = realloc(m1, 10); |
|||
TEST_ASSERT_POINTERS_EQUAL(m1, m2); |
|||
free(m2); |
|||
} |
|||
|
|||
TEST(UnityFixture, ReallocLargerNeeded) |
|||
{ |
|||
void* m1 = malloc(10); |
|||
void* m2; |
|||
CHECK(m1); |
|||
strcpy((char*)m1, "123456789"); |
|||
m2 = realloc(m1, 15); |
|||
/* CHECK(m1 != m2); //Depends on implementation */ |
|||
STRCMP_EQUAL("123456789", m2); |
|||
free(m2); |
|||
} |
|||
|
|||
TEST(UnityFixture, ReallocNullPointerIsLikeMalloc) |
|||
{ |
|||
void* m = realloc(0, 15); |
|||
CHECK(m != 0); |
|||
free(m); |
|||
} |
|||
|
|||
TEST(UnityFixture, ReallocSizeZeroFreesMemAndReturnsNullPointer) |
|||
{ |
|||
void* m1 = malloc(10); |
|||
void* m2 = realloc(m1, 0); |
|||
TEST_ASSERT_POINTERS_EQUAL(0, m2); |
|||
} |
|||
|
|||
TEST(UnityFixture, CallocFillsWithZero) |
|||
{ |
|||
void* m = calloc(3, sizeof(char)); |
|||
char* s = (char*)m; |
|||
CHECK(m); |
|||
TEST_ASSERT_BYTES_EQUAL(0, s[0]); |
|||
TEST_ASSERT_BYTES_EQUAL(0, s[1]); |
|||
TEST_ASSERT_BYTES_EQUAL(0, s[2]); |
|||
free(m); |
|||
} |
|||
|
|||
static char *p1; |
|||
static char *p2; |
|||
|
|||
TEST(UnityFixture, PointerSet) |
|||
{ |
|||
char c1; |
|||
char c2; |
|||
char newC1; |
|||
char newC2; |
|||
p1 = &c1; |
|||
p2 = &c2; |
|||
|
|||
UnityPointer_Init(); |
|||
UT_PTR_SET(p1, &newC1); |
|||
UT_PTR_SET(p2, &newC2); |
|||
TEST_ASSERT_POINTERS_EQUAL(&newC1, p1); |
|||
TEST_ASSERT_POINTERS_EQUAL(&newC2, p2); |
|||
UnityPointer_UndoAllSets(); |
|||
TEST_ASSERT_POINTERS_EQUAL(&c1, p1); |
|||
TEST_ASSERT_POINTERS_EQUAL(&c2, p2); |
|||
} |
|||
|
|||
TEST(UnityFixture, FreeNULLSafety) |
|||
{ |
|||
free(NULL); |
|||
} |
|||
|
|||
TEST(UnityFixture, ConcludeTestIncrementsFailCount) |
|||
{ |
|||
UNITY_UINT savedFails = Unity.TestFailures; |
|||
UNITY_UINT savedIgnores = Unity.TestIgnores; |
|||
UnityOutputCharSpy_Enable(1); |
|||
Unity.CurrentTestFailed = 1; |
|||
UnityConcludeFixtureTest(); /* Resets TestFailed for this test to pass */ |
|||
Unity.CurrentTestIgnored = 1; |
|||
UnityConcludeFixtureTest(); /* Resets TestIgnored */ |
|||
UnityOutputCharSpy_Enable(0); |
|||
TEST_ASSERT_EQUAL(savedFails + 1, Unity.TestFailures); |
|||
TEST_ASSERT_EQUAL(savedIgnores + 1, Unity.TestIgnores); |
|||
Unity.TestFailures = savedFails; |
|||
Unity.TestIgnores = savedIgnores; |
|||
} |
|||
|
|||
/*------------------------------------------------------------ */ |
|||
|
|||
TEST_GROUP(UnityCommandOptions); |
|||
|
|||
static int savedVerbose; |
|||
static unsigned int savedRepeat; |
|||
static const char* savedName; |
|||
static const char* savedGroup; |
|||
|
|||
TEST_SETUP(UnityCommandOptions) |
|||
{ |
|||
savedVerbose = UnityFixture.Verbose; |
|||
savedRepeat = UnityFixture.RepeatCount; |
|||
savedName = UnityFixture.NameFilter; |
|||
savedGroup = UnityFixture.GroupFilter; |
|||
} |
|||
|
|||
TEST_TEAR_DOWN(UnityCommandOptions) |
|||
{ |
|||
UnityFixture.Verbose = savedVerbose; |
|||
UnityFixture.RepeatCount= savedRepeat; |
|||
UnityFixture.NameFilter = savedName; |
|||
UnityFixture.GroupFilter = savedGroup; |
|||
} |
|||
|
|||
|
|||
static const char* noOptions[] = { |
|||
"testrunner.exe" |
|||
}; |
|||
|
|||
TEST(UnityCommandOptions, DefaultOptions) |
|||
{ |
|||
UnityGetCommandLineOptions(1, noOptions); |
|||
TEST_ASSERT_EQUAL(0, UnityFixture.Verbose); |
|||
TEST_ASSERT_POINTERS_EQUAL(0, UnityFixture.GroupFilter); |
|||
TEST_ASSERT_POINTERS_EQUAL(0, UnityFixture.NameFilter); |
|||
TEST_ASSERT_EQUAL(1, UnityFixture.RepeatCount); |
|||
} |
|||
|
|||
static const char* verbose[] = { |
|||
"testrunner.exe", |
|||
"-v" |
|||
}; |
|||
|
|||
TEST(UnityCommandOptions, OptionVerbose) |
|||
{ |
|||
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(2, verbose)); |
|||
TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); |
|||
} |
|||
|
|||
static const char* group[] = { |
|||
"testrunner.exe", |
|||
"-g", "groupname" |
|||
}; |
|||
|
|||
TEST(UnityCommandOptions, OptionSelectTestByGroup) |
|||
{ |
|||
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, group)); |
|||
STRCMP_EQUAL("groupname", UnityFixture.GroupFilter); |
|||
} |
|||
|
|||
static const char* name[] = { |
|||
"testrunner.exe", |
|||
"-n", "testname" |
|||
}; |
|||
|
|||
TEST(UnityCommandOptions, OptionSelectTestByName) |
|||
{ |
|||
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, name)); |
|||
STRCMP_EQUAL("testname", UnityFixture.NameFilter); |
|||
} |
|||
|
|||
static const char* repeat[] = { |
|||
"testrunner.exe", |
|||
"-r", "99" |
|||
}; |
|||
|
|||
TEST(UnityCommandOptions, OptionSelectRepeatTestsDefaultCount) |
|||
{ |
|||
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(2, repeat)); |
|||
TEST_ASSERT_EQUAL(2, UnityFixture.RepeatCount); |
|||
} |
|||
|
|||
TEST(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount) |
|||
{ |
|||
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(3, repeat)); |
|||
TEST_ASSERT_EQUAL(99, UnityFixture.RepeatCount); |
|||
} |
|||
|
|||
static const char* multiple[] = { |
|||
"testrunner.exe", |
|||
"-v", |
|||
"-g", "groupname", |
|||
"-n", "testname", |
|||
"-r", "98" |
|||
}; |
|||
|
|||
TEST(UnityCommandOptions, MultipleOptions) |
|||
{ |
|||
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(8, multiple)); |
|||
TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); |
|||
STRCMP_EQUAL("groupname", UnityFixture.GroupFilter); |
|||
STRCMP_EQUAL("testname", UnityFixture.NameFilter); |
|||
TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount); |
|||
} |
|||
|
|||
static const char* dashRNotLast[] = { |
|||
"testrunner.exe", |
|||
"-v", |
|||
"-g", "gggg", |
|||
"-r", |
|||
"-n", "tttt", |
|||
}; |
|||
|
|||
TEST(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified) |
|||
{ |
|||
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(7, dashRNotLast)); |
|||
TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); |
|||
STRCMP_EQUAL("gggg", UnityFixture.GroupFilter); |
|||
STRCMP_EQUAL("tttt", UnityFixture.NameFilter); |
|||
TEST_ASSERT_EQUAL(2, UnityFixture.RepeatCount); |
|||
} |
|||
|
|||
static const char* unknownCommand[] = { |
|||
"testrunner.exe", |
|||
"-v", |
|||
"-g", "groupname", |
|||
"-n", "testname", |
|||
"-r", "98", |
|||
"-z" |
|||
}; |
|||
TEST(UnityCommandOptions, UnknownCommandIsIgnored) |
|||
{ |
|||
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(9, unknownCommand)); |
|||
TEST_ASSERT_EQUAL(1, UnityFixture.Verbose); |
|||
STRCMP_EQUAL("groupname", UnityFixture.GroupFilter); |
|||
STRCMP_EQUAL("testname", UnityFixture.NameFilter); |
|||
TEST_ASSERT_EQUAL(98, UnityFixture.RepeatCount); |
|||
} |
|||
|
|||
TEST(UnityCommandOptions, GroupOrNameFilterWithoutStringFails) |
|||
{ |
|||
TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(3, unknownCommand)); |
|||
TEST_ASSERT_EQUAL(1, UnityGetCommandLineOptions(5, unknownCommand)); |
|||
TEST_ASSERT_EQUAL(1, UnityMain(3, unknownCommand, NULL)); |
|||
} |
|||
|
|||
TEST(UnityCommandOptions, GroupFilterReallyFilters) |
|||
{ |
|||
UNITY_UINT saved = Unity.NumberOfTests; |
|||
TEST_ASSERT_EQUAL(0, UnityGetCommandLineOptions(4, unknownCommand)); |
|||
UnityIgnoreTest(NULL, "non-matching", NULL); |
|||
TEST_ASSERT_EQUAL(saved, Unity.NumberOfTests); |
|||
} |
|||
|
|||
IGNORE_TEST(UnityCommandOptions, TestShouldBeIgnored) |
|||
{ |
|||
TEST_FAIL_MESSAGE("This test should not run!"); |
|||
} |
|||
|
|||
/*------------------------------------------------------------ */ |
|||
|
|||
TEST_GROUP(LeakDetection); |
|||
|
|||
TEST_SETUP(LeakDetection) |
|||
{ |
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC |
|||
UnityOutputCharSpy_Create(200); |
|||
#else |
|||
UnityOutputCharSpy_Create(1000); |
|||
#endif |
|||
} |
|||
|
|||
TEST_TEAR_DOWN(LeakDetection) |
|||
{ |
|||
UnityOutputCharSpy_Destroy(); |
|||
} |
|||
|
|||
#define EXPECT_ABORT_BEGIN \ |
|||
{ \ |
|||
jmp_buf TestAbortFrame; \ |
|||
memcpy(TestAbortFrame, Unity.AbortFrame, sizeof(jmp_buf)); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ |
|||
|
|||
#define EXPECT_ABORT_END \ |
|||
} \ |
|||
memcpy(Unity.AbortFrame, TestAbortFrame, sizeof(jmp_buf)); \ |
|||
} |
|||
|
|||
/* This tricky set of defines lets us see if we are using the Spy, returns 1 if true */ |
|||
#ifdef __STDC_VERSION__ |
|||
|
|||
#if __STDC_VERSION__ >= 199901L |
|||
#define USING_SPY_AS(a) EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0) |
|||
#define ASSIGN_VALUE(a) VAL_##a |
|||
#define VAL_UnityOutputCharSpy_OutputChar 0, 1 |
|||
#define EXPAND_AND_USE_2ND(a, b) SECOND_PARAM(a, b, throwaway) |
|||
#define SECOND_PARAM(a, b, ...) b |
|||
#if USING_SPY_AS(UNITY_OUTPUT_CHAR) |
|||
#define USING_OUTPUT_SPY /* UNITY_OUTPUT_CHAR = UnityOutputCharSpy_OutputChar */ |
|||
#endif |
|||
#endif /* >= 199901 */ |
|||
|
|||
#else /* __STDC_VERSION__ else */ |
|||
#define UnityOutputCharSpy_OutputChar 42 |
|||
#if UNITY_OUTPUT_CHAR == UnityOutputCharSpy_OutputChar /* Works if no -Wundef -Werror */ |
|||
#define USING_OUTPUT_SPY |
|||
#endif |
|||
#undef UnityOutputCharSpy_OutputChar |
|||
#endif /* __STDC_VERSION__ */ |
|||
|
|||
TEST(LeakDetection, DetectsLeak) |
|||
{ |
|||
#ifndef USING_OUTPUT_SPY |
|||
TEST_IGNORE_MESSAGE("Build with '-D UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar' to enable tests"); |
|||
#else |
|||
void* m = malloc(10); |
|||
TEST_ASSERT_NOT_NULL(m); |
|||
UnityOutputCharSpy_Enable(1); |
|||
EXPECT_ABORT_BEGIN |
|||
UnityMalloc_EndTest(); |
|||
EXPECT_ABORT_END |
|||
UnityOutputCharSpy_Enable(0); |
|||
Unity.CurrentTestFailed = 0; |
|||
CHECK(strstr(UnityOutputCharSpy_Get(), "This test leaks!")); |
|||
free(m); |
|||
#endif |
|||
} |
|||
|
|||
TEST(LeakDetection, BufferOverrunFoundDuringFree) |
|||
{ |
|||
#ifndef USING_OUTPUT_SPY |
|||
TEST_IGNORE(); |
|||
#else |
|||
void* m = malloc(10); |
|||
char* s = (char*)m; |
|||
TEST_ASSERT_NOT_NULL(m); |
|||
s[10] = (char)0xFF; |
|||
UnityOutputCharSpy_Enable(1); |
|||
EXPECT_ABORT_BEGIN |
|||
free(m); |
|||
EXPECT_ABORT_END |
|||
UnityOutputCharSpy_Enable(0); |
|||
Unity.CurrentTestFailed = 0; |
|||
CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()")); |
|||
#endif |
|||
} |
|||
|
|||
TEST(LeakDetection, BufferOverrunFoundDuringRealloc) |
|||
{ |
|||
#ifndef USING_OUTPUT_SPY |
|||
TEST_IGNORE(); |
|||
#else |
|||
void* m = malloc(10); |
|||
char* s = (char*)m; |
|||
TEST_ASSERT_NOT_NULL(m); |
|||
s[10] = (char)0xFF; |
|||
UnityOutputCharSpy_Enable(1); |
|||
EXPECT_ABORT_BEGIN |
|||
m = realloc(m, 100); |
|||
EXPECT_ABORT_END |
|||
UnityOutputCharSpy_Enable(0); |
|||
Unity.CurrentTestFailed = 0; |
|||
CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()")); |
|||
#endif |
|||
} |
|||
|
|||
TEST(LeakDetection, BufferGuardWriteFoundDuringFree) |
|||
{ |
|||
#ifndef USING_OUTPUT_SPY |
|||
TEST_IGNORE(); |
|||
#else |
|||
void* m = malloc(10); |
|||
char* s = (char*)m; |
|||
TEST_ASSERT_NOT_NULL(m); |
|||
s[-1] = (char)0x00; /* Will not detect 0 */ |
|||
s[-2] = (char)0x01; |
|||
UnityOutputCharSpy_Enable(1); |
|||
EXPECT_ABORT_BEGIN |
|||
free(m); |
|||
EXPECT_ABORT_END |
|||
UnityOutputCharSpy_Enable(0); |
|||
Unity.CurrentTestFailed = 0; |
|||
CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during free()")); |
|||
#endif |
|||
} |
|||
|
|||
TEST(LeakDetection, BufferGuardWriteFoundDuringRealloc) |
|||
{ |
|||
#ifndef USING_OUTPUT_SPY |
|||
TEST_IGNORE(); |
|||
#else |
|||
void* m = malloc(10); |
|||
char* s = (char*)m; |
|||
TEST_ASSERT_NOT_NULL(m); |
|||
s[-1] = (char)0x0A; |
|||
UnityOutputCharSpy_Enable(1); |
|||
EXPECT_ABORT_BEGIN |
|||
m = realloc(m, 100); |
|||
EXPECT_ABORT_END |
|||
UnityOutputCharSpy_Enable(0); |
|||
Unity.CurrentTestFailed = 0; |
|||
CHECK(strstr(UnityOutputCharSpy_Get(), "Buffer overrun detected during realloc()")); |
|||
#endif |
|||
} |
|||
|
|||
TEST(LeakDetection, PointerSettingMax) |
|||
{ |
|||
#ifndef USING_OUTPUT_SPY |
|||
TEST_IGNORE(); |
|||
#else |
|||
int i; |
|||
for (i = 0; i < UNITY_MAX_POINTERS; i++) UT_PTR_SET(pointer1, &int1); |
|||
UnityOutputCharSpy_Enable(1); |
|||
EXPECT_ABORT_BEGIN |
|||
UT_PTR_SET(pointer1, &int1); |
|||
EXPECT_ABORT_END |
|||
UnityOutputCharSpy_Enable(0); |
|||
Unity.CurrentTestFailed = 0; |
|||
CHECK(strstr(UnityOutputCharSpy_Get(), "Too many pointers set")); |
|||
#endif |
|||
} |
|||
|
|||
/*------------------------------------------------------------ */ |
|||
|
|||
TEST_GROUP(InternalMalloc); |
|||
#define TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(first_mem_ptr, ptr) \ |
|||
ptr = malloc(10); free(ptr); \ |
|||
TEST_ASSERT_EQUAL_PTR_MESSAGE(first_mem_ptr, ptr, "Memory was stranded, free in LIFO order"); |
|||
|
|||
|
|||
TEST_SETUP(InternalMalloc) { } |
|||
TEST_TEAR_DOWN(InternalMalloc) { } |
|||
|
|||
TEST(InternalMalloc, MallocPastBufferFails) |
|||
{ |
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC |
|||
void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); |
|||
void* n = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2); |
|||
free(m); |
|||
TEST_ASSERT_NOT_NULL(m); |
|||
TEST_ASSERT_NULL(n); |
|||
TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n); |
|||
#endif |
|||
} |
|||
|
|||
TEST(InternalMalloc, CallocPastBufferFails) |
|||
{ |
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC |
|||
void* m = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); |
|||
void* n = calloc(1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2); |
|||
free(m); |
|||
TEST_ASSERT_NOT_NULL(m); |
|||
TEST_ASSERT_NULL(n); |
|||
TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n); |
|||
#endif |
|||
} |
|||
|
|||
TEST(InternalMalloc, MallocThenReallocGrowsMemoryInPlace) |
|||
{ |
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC |
|||
void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); |
|||
void* n = realloc(m, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 9); |
|||
free(n); |
|||
TEST_ASSERT_NOT_NULL(m); |
|||
TEST_ASSERT_EQUAL(m, n); |
|||
TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n); |
|||
#endif |
|||
} |
|||
|
|||
TEST(InternalMalloc, ReallocFailDoesNotFreeMem) |
|||
{ |
|||
#ifdef UNITY_EXCLUDE_STDLIB_MALLOC |
|||
void* m = malloc(UNITY_INTERNAL_HEAP_SIZE_BYTES/2); |
|||
void* n1 = malloc(10); |
|||
void* out_of_mem = realloc(n1, UNITY_INTERNAL_HEAP_SIZE_BYTES/2 + 1); |
|||
void* n2 = malloc(10); |
|||
|
|||
free(n2); |
|||
if (out_of_mem == NULL) free(n1); |
|||
free(m); |
|||
|
|||
TEST_ASSERT_NOT_NULL(m); /* Got a real memory location */ |
|||
TEST_ASSERT_NULL(out_of_mem); /* The realloc should have failed */ |
|||
TEST_ASSERT_NOT_EQUAL(n2, n1); /* If n1 != n2 then realloc did not free n1 */ |
|||
TEST_ASSERT_MEMORY_ALL_FREE_LIFO_ORDER(m, n2); |
|||
#endif |
|||
} |
@ -0,0 +1,57 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
#include "unity_fixture.h" |
|||
|
|||
TEST_GROUP_RUNNER(UnityFixture) |
|||
{ |
|||
RUN_TEST_CASE(UnityFixture, PointerSetting); |
|||
RUN_TEST_CASE(UnityFixture, ForceMallocFail); |
|||
RUN_TEST_CASE(UnityFixture, ReallocSmallerIsUnchanged); |
|||
RUN_TEST_CASE(UnityFixture, ReallocSameIsUnchanged); |
|||
RUN_TEST_CASE(UnityFixture, ReallocLargerNeeded); |
|||
RUN_TEST_CASE(UnityFixture, ReallocNullPointerIsLikeMalloc); |
|||
RUN_TEST_CASE(UnityFixture, ReallocSizeZeroFreesMemAndReturnsNullPointer); |
|||
RUN_TEST_CASE(UnityFixture, CallocFillsWithZero); |
|||
RUN_TEST_CASE(UnityFixture, PointerSet); |
|||
RUN_TEST_CASE(UnityFixture, FreeNULLSafety); |
|||
RUN_TEST_CASE(UnityFixture, ConcludeTestIncrementsFailCount); |
|||
} |
|||
|
|||
TEST_GROUP_RUNNER(UnityCommandOptions) |
|||
{ |
|||
RUN_TEST_CASE(UnityCommandOptions, DefaultOptions); |
|||
RUN_TEST_CASE(UnityCommandOptions, OptionVerbose); |
|||
RUN_TEST_CASE(UnityCommandOptions, OptionSelectTestByGroup); |
|||
RUN_TEST_CASE(UnityCommandOptions, OptionSelectTestByName); |
|||
RUN_TEST_CASE(UnityCommandOptions, OptionSelectRepeatTestsDefaultCount); |
|||
RUN_TEST_CASE(UnityCommandOptions, OptionSelectRepeatTestsSpecificCount); |
|||
RUN_TEST_CASE(UnityCommandOptions, MultipleOptions); |
|||
RUN_TEST_CASE(UnityCommandOptions, MultipleOptionsDashRNotLastAndNoValueSpecified); |
|||
RUN_TEST_CASE(UnityCommandOptions, UnknownCommandIsIgnored); |
|||
RUN_TEST_CASE(UnityCommandOptions, GroupOrNameFilterWithoutStringFails); |
|||
RUN_TEST_CASE(UnityCommandOptions, GroupFilterReallyFilters); |
|||
RUN_TEST_CASE(UnityCommandOptions, TestShouldBeIgnored); |
|||
} |
|||
|
|||
TEST_GROUP_RUNNER(LeakDetection) |
|||
{ |
|||
RUN_TEST_CASE(LeakDetection, DetectsLeak); |
|||
RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringFree); |
|||
RUN_TEST_CASE(LeakDetection, BufferOverrunFoundDuringRealloc); |
|||
RUN_TEST_CASE(LeakDetection, BufferGuardWriteFoundDuringFree); |
|||
RUN_TEST_CASE(LeakDetection, BufferGuardWriteFoundDuringRealloc); |
|||
RUN_TEST_CASE(LeakDetection, PointerSettingMax); |
|||
} |
|||
|
|||
TEST_GROUP_RUNNER(InternalMalloc) |
|||
{ |
|||
RUN_TEST_CASE(InternalMalloc, MallocPastBufferFails); |
|||
RUN_TEST_CASE(InternalMalloc, CallocPastBufferFails); |
|||
RUN_TEST_CASE(InternalMalloc, MallocThenReallocGrowsMemoryInPlace); |
|||
RUN_TEST_CASE(InternalMalloc, ReallocFailDoesNotFreeMem); |
|||
} |
@ -0,0 +1,57 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
|
|||
#include "unity_output_Spy.h" |
|||
#include "unity_fixture.h" |
|||
|
|||
#include <stdio.h> |
|||
#include <string.h> |
|||
|
|||
static int size; |
|||
static int count; |
|||
static char* buffer; |
|||
static int spy_enable; |
|||
|
|||
void UnityOutputCharSpy_Create(int s) |
|||
{ |
|||
size = (s > 0) ? s : 0; |
|||
count = 0; |
|||
spy_enable = 0; |
|||
buffer = malloc((size_t)size); |
|||
TEST_ASSERT_NOT_NULL_MESSAGE(buffer, "Internal malloc failed in Spy Create():" __FILE__); |
|||
memset(buffer, 0, (size_t)size); |
|||
} |
|||
|
|||
void UnityOutputCharSpy_Destroy(void) |
|||
{ |
|||
size = 0; |
|||
free(buffer); |
|||
} |
|||
|
|||
void UnityOutputCharSpy_OutputChar(int c) |
|||
{ |
|||
if (spy_enable) |
|||
{ |
|||
if (count < (size-1)) |
|||
buffer[count++] = (char)c; |
|||
} |
|||
else |
|||
{ |
|||
putchar(c); |
|||
} |
|||
} |
|||
|
|||
const char * UnityOutputCharSpy_Get(void) |
|||
{ |
|||
return buffer; |
|||
} |
|||
|
|||
void UnityOutputCharSpy_Enable(int enable) |
|||
{ |
|||
spy_enable = enable; |
|||
} |
@ -0,0 +1,17 @@ |
|||
/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
|
|||
* ========================================== |
|||
* Unity Project - A Test Framework for C |
|||
* Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
* [Released under MIT License. Please refer to license.txt for details] |
|||
* ========================================== */ |
|||
|
|||
#ifndef D_unity_output_Spy_H |
|||
#define D_unity_output_Spy_H |
|||
|
|||
void UnityOutputCharSpy_Create(int s); |
|||
void UnityOutputCharSpy_Destroy(void); |
|||
void UnityOutputCharSpy_OutputChar(int c); |
|||
const char * UnityOutputCharSpy_Get(void); |
|||
void UnityOutputCharSpy_Enable(int enable); |
|||
|
|||
#endif |
@ -0,0 +1,2 @@ |
|||
122 |
|||
|
@ -0,0 +1,2 @@ |
|||
2.4.3 |
|||
|
File diff suppressed because it is too large
@ -0,0 +1,539 @@ |
|||
/* ==========================================
|
|||
Unity Project - A Test Framework for C |
|||
Copyright (c) 2007-19 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
[Released under MIT License. Please refer to license.txt for details] |
|||
========================================== */ |
|||
|
|||
#ifndef UNITY_FRAMEWORK_H |
|||
#define UNITY_FRAMEWORK_H |
|||
#define UNITY |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" |
|||
{ |
|||
#endif |
|||
|
|||
#include "unity_internals.h" |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Test Setup / Teardown |
|||
*-------------------------------------------------------*/ |
|||
|
|||
/* These functions are intended to be called before and after each test. */ |
|||
void setUp(void); |
|||
void tearDown(void); |
|||
|
|||
/* These functions are intended to be called at the beginning and end of an
|
|||
* entire test suite. suiteTearDown() is passed the number of tests that |
|||
* failed, and its return value becomes the exit code of main(). */ |
|||
void suiteSetUp(void); |
|||
int suiteTearDown(int num_failures); |
|||
|
|||
/* If the compiler supports it, the following block provides stub
|
|||
* implementations of the above functions as weak symbols. Note that on |
|||
* some platforms (MinGW for example), weak function implementations need |
|||
* to be in the same translation unit they are called from. This can be |
|||
* achieved by defining UNITY_INCLUDE_SETUP_STUBS before including unity.h. */ |
|||
#ifdef UNITY_INCLUDE_SETUP_STUBS |
|||
#ifdef UNITY_WEAK_ATTRIBUTE |
|||
UNITY_WEAK_ATTRIBUTE void setUp(void) { } |
|||
UNITY_WEAK_ATTRIBUTE void tearDown(void) { } |
|||
UNITY_WEAK_ATTRIBUTE void suiteSetUp(void) { } |
|||
UNITY_WEAK_ATTRIBUTE int suiteTearDown(int num_failures) { return num_failures; } |
|||
#elif defined(UNITY_WEAK_PRAGMA) |
|||
#pragma weak setUp |
|||
void setUp(void) { } |
|||
#pragma weak tearDown |
|||
void tearDown(void) { } |
|||
#pragma weak suiteSetUp |
|||
void suiteSetUp(void) { } |
|||
#pragma weak suiteTearDown |
|||
int suiteTearDown(int num_failures) { return num_failures; } |
|||
#endif |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Configuration Options |
|||
*------------------------------------------------------- |
|||
* All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above. |
|||
|
|||
* Integers/longs/pointers |
|||
* - Unity attempts to automatically discover your integer sizes |
|||
* - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in <stdint.h> |
|||
* - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in <limits.h> |
|||
* - If you cannot use the automatic methods above, you can force Unity by using these options: |
|||
* - define UNITY_SUPPORT_64 |
|||
* - set UNITY_INT_WIDTH |
|||
* - set UNITY_LONG_WIDTH |
|||
* - set UNITY_POINTER_WIDTH |
|||
|
|||
* Floats |
|||
* - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons |
|||
* - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT |
|||
* - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats |
|||
* - define UNITY_INCLUDE_DOUBLE to allow double floating point comparisons |
|||
* - define UNITY_EXCLUDE_DOUBLE to disallow double floating point comparisons (default) |
|||
* - define UNITY_DOUBLE_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_DOUBLE |
|||
* - define UNITY_DOUBLE_TYPE to specify something other than double |
|||
* - define UNITY_EXCLUDE_FLOAT_PRINT to trim binary size, won't print floating point values in errors |
|||
|
|||
* Output |
|||
* - by default, Unity prints to standard out with putchar. define UNITY_OUTPUT_CHAR(a) with a different function if desired |
|||
* - define UNITY_DIFFERENTIATE_FINAL_FAIL to print FAILED (vs. FAIL) at test end summary - for automated search for failure |
|||
|
|||
* Optimization |
|||
* - by default, line numbers are stored in unsigned shorts. Define UNITY_LINE_TYPE with a different type if your files are huge |
|||
* - by default, test and failure counters are unsigned shorts. Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests. |
|||
|
|||
* Test Cases |
|||
* - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script |
|||
|
|||
* Parameterized Tests |
|||
* - you'll want to create a define of TEST_CASE(...) which basically evaluates to nothing |
|||
|
|||
* Tests with Arguments |
|||
* - you'll want to define UNITY_USE_COMMAND_LINE_ARGS if you have the test runner passing arguments to Unity |
|||
|
|||
*------------------------------------------------------- |
|||
* Basic Fail and Ignore |
|||
*-------------------------------------------------------*/ |
|||
|
|||
#define TEST_FAIL_MESSAGE(message) UNITY_TEST_FAIL(__LINE__, (message)) |
|||
#define TEST_FAIL() UNITY_TEST_FAIL(__LINE__, NULL) |
|||
#define TEST_IGNORE_MESSAGE(message) UNITY_TEST_IGNORE(__LINE__, (message)) |
|||
#define TEST_IGNORE() UNITY_TEST_IGNORE(__LINE__, NULL) |
|||
#define TEST_ONLY() |
|||
|
|||
/* It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails.
|
|||
* This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test. */ |
|||
#define TEST_PASS() TEST_ABORT() |
|||
|
|||
/* This macro does nothing, but it is useful for build tools (like Ceedling) to make use of this to figure out
|
|||
* which files should be linked to in order to perform a test. Use it like TEST_FILE("sandwiches.c") */ |
|||
#define TEST_FILE(a) |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Test Asserts (simple) |
|||
*-------------------------------------------------------*/ |
|||
|
|||
/* Boolean */ |
|||
#define TEST_ASSERT(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expression Evaluated To FALSE") |
|||
#define TEST_ASSERT_TRUE(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expected TRUE Was FALSE") |
|||
#define TEST_ASSERT_UNLESS(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expression Evaluated To TRUE") |
|||
#define TEST_ASSERT_FALSE(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expected FALSE Was TRUE") |
|||
#define TEST_ASSERT_NULL(pointer) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, " Expected NULL") |
|||
#define TEST_ASSERT_NOT_NULL(pointer) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL") |
|||
|
|||
/* Integers (of all sizes) */ |
|||
#define TEST_ASSERT_EQUAL_INT(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_INT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_INT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_INT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_INT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal") |
|||
#define TEST_ASSERT_EQUAL_UINT(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_UINT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_UINT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_UINT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_UINT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX8(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX16(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX32(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX64(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_BITS(mask, expected, actual) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_BITS_HIGH(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (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) |
|||
|
|||
/* 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_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT64((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_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((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_GREATER_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((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_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((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_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((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) |
|||
#define TEST_ASSERT_LESS_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, NULL) |
|||
|
|||
#define TEST_ASSERT_GREATER_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) |
|||
|
|||
#define TEST_ASSERT_LESS_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((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) |
|||
#define TEST_ASSERT_INT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_INT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_INT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
|
|||
/* Integer Array Ranges (of all sizes) */ |
|||
#define TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
#define TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) |
|||
|
|||
|
|||
/* Structs and Strings */ |
|||
#define TEST_ASSERT_EQUAL_PTR(expected, actual) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_STRING(expected, actual) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, NULL) |
|||
|
|||
/* Arrays */ |
|||
#define TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_PTR_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) |
|||
|
|||
/* 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) |
|||
#define TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, NULL) |
|||
|
|||
/* Floating Point (If Enabled) */ |
|||
#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_FLOAT_IS_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_FLOAT_IS_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_FLOAT_IS_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_FLOAT_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_FLOAT_IS_NOT_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_FLOAT_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, NULL) |
|||
|
|||
/* Double (If Enabled) */ |
|||
#define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, NULL) |
|||
#define TEST_ASSERT_DOUBLE_IS_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_DOUBLE_IS_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_DOUBLE_IS_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_DOUBLE_IS_NOT_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, NULL) |
|||
#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, NULL) |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Test Asserts (with additional messages) |
|||
*-------------------------------------------------------*/ |
|||
|
|||
/* Boolean */ |
|||
#define TEST_ASSERT_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) |
|||
#define TEST_ASSERT_TRUE_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) |
|||
#define TEST_ASSERT_UNLESS_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) |
|||
#define TEST_ASSERT_FALSE_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) |
|||
#define TEST_ASSERT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, (message)) |
|||
#define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, (message)) |
|||
|
|||
/* Integers (of all sizes) */ |
|||
#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (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)) |
|||
|
|||
/* 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_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT64((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_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((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_GREATER_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((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_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((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_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((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)) |
|||
#define TEST_ASSERT_LESS_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, (message)) |
|||
|
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) |
|||
|
|||
#define TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_LESS_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((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)) |
|||
#define TEST_ASSERT_INT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_INT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_INT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
|
|||
/* Integer Array Ranges (of all sizes) */ |
|||
#define TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_INT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
#define TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) |
|||
|
|||
|
|||
/* Structs and Strings */ |
|||
#define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, (message)) |
|||
|
|||
/* Arrays */ |
|||
#define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_INT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_PTR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, (message)) |
|||
|
|||
/* Arrays Compared To Single Value*/ |
|||
#define TEST_ASSERT_EACH_EQUAL_INT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_INT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_INT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_INT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_INT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_UINT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_HEX64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_PTR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_STRING_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_MEMORY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, (message)) |
|||
|
|||
/* Floating Point (If Enabled) */ |
|||
#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_FLOAT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_FLOAT_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_FLOAT_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_FLOAT_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_FLOAT_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_FLOAT_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_FLOAT_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, (message)) |
|||
|
|||
/* Double (If Enabled) */ |
|||
#define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_EACH_EQUAL_DOUBLE_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, (message)) |
|||
#define TEST_ASSERT_DOUBLE_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_DOUBLE_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_DOUBLE_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_DOUBLE_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_DOUBLE_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_DOUBLE_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, (message)) |
|||
#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, (message)) |
|||
|
|||
/* end of UNITY_FRAMEWORK_H */ |
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
@ -0,0 +1,990 @@ |
|||
/* ==========================================
|
|||
Unity Project - A Test Framework for C |
|||
Copyright (c) 2007-19 Mike Karlesky, Mark VanderVoord, Greg Williams |
|||
[Released under MIT License. Please refer to license.txt for details] |
|||
========================================== */ |
|||
|
|||
#ifndef UNITY_INTERNALS_H |
|||
#define UNITY_INTERNALS_H |
|||
|
|||
#ifdef UNITY_INCLUDE_CONFIG_H |
|||
#include "unity_config.h" |
|||
#endif |
|||
|
|||
#ifndef UNITY_EXCLUDE_SETJMP_H |
|||
#include <setjmp.h> |
|||
#endif |
|||
|
|||
#ifndef UNITY_EXCLUDE_MATH_H |
|||
#include <math.h> |
|||
#endif |
|||
|
|||
#ifndef UNITY_EXCLUDE_STDDEF_H |
|||
#include <stddef.h> |
|||
#endif |
|||
|
|||
#ifdef UNITY_INCLUDE_PRINT_FORMATTED |
|||
#include <stdarg.h> |
|||
#endif |
|||
|
|||
/* Unity Attempts to Auto-Detect Integer Types
|
|||
* Attempt 1: UINT_MAX, ULONG_MAX in <limits.h>, or default to 32 bits |
|||
* Attempt 2: UINTPTR_MAX in <stdint.h>, or default to same size as long |
|||
* The user may override any of these derived constants: |
|||
* UNITY_INT_WIDTH, UNITY_LONG_WIDTH, UNITY_POINTER_WIDTH */ |
|||
#ifndef UNITY_EXCLUDE_STDINT_H |
|||
#include <stdint.h> |
|||
#endif |
|||
|
|||
#ifndef UNITY_EXCLUDE_LIMITS_H |
|||
#include <limits.h> |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Guess Widths If Not Specified |
|||
*-------------------------------------------------------*/ |
|||
|
|||
/* Determine the size of an int, if not already specified.
|
|||
* We cannot use sizeof(int), because it is not yet defined |
|||
* at this stage in the translation of the C program. |
|||
* Therefore, infer it from UINT_MAX if possible. */ |
|||
#ifndef UNITY_INT_WIDTH |
|||
#ifdef UINT_MAX |
|||
#if (UINT_MAX == 0xFFFF) |
|||
#define UNITY_INT_WIDTH (16) |
|||
#elif (UINT_MAX == 0xFFFFFFFF) |
|||
#define UNITY_INT_WIDTH (32) |
|||
#elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF) |
|||
#define UNITY_INT_WIDTH (64) |
|||
#endif |
|||
#else /* Set to default */ |
|||
#define UNITY_INT_WIDTH (32) |
|||
#endif /* UINT_MAX */ |
|||
#endif |
|||
|
|||
/* Determine the size of a long, if not already specified. */ |
|||
#ifndef UNITY_LONG_WIDTH |
|||
#ifdef ULONG_MAX |
|||
#if (ULONG_MAX == 0xFFFF) |
|||
#define UNITY_LONG_WIDTH (16) |
|||
#elif (ULONG_MAX == 0xFFFFFFFF) |
|||
#define UNITY_LONG_WIDTH (32) |
|||
#elif (ULONG_MAX == 0xFFFFFFFFFFFFFFFF) |
|||
#define UNITY_LONG_WIDTH (64) |
|||
#endif |
|||
#else /* Set to default */ |
|||
#define UNITY_LONG_WIDTH (32) |
|||
#endif /* ULONG_MAX */ |
|||
#endif |
|||
|
|||
/* Determine the size of a pointer, if not already specified. */ |
|||
#ifndef UNITY_POINTER_WIDTH |
|||
#ifdef UINTPTR_MAX |
|||
#if (UINTPTR_MAX <= 0xFFFF) |
|||
#define UNITY_POINTER_WIDTH (16) |
|||
#elif (UINTPTR_MAX <= 0xFFFFFFFF) |
|||
#define UNITY_POINTER_WIDTH (32) |
|||
#elif (UINTPTR_MAX <= 0xFFFFFFFFFFFFFFFF) |
|||
#define UNITY_POINTER_WIDTH (64) |
|||
#endif |
|||
#else /* Set to default */ |
|||
#define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH |
|||
#endif /* UINTPTR_MAX */ |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Int Support (Define types based on detected sizes) |
|||
*-------------------------------------------------------*/ |
|||
|
|||
#if (UNITY_INT_WIDTH == 32) |
|||
typedef unsigned char UNITY_UINT8; |
|||
typedef unsigned short UNITY_UINT16; |
|||
typedef unsigned int UNITY_UINT32; |
|||
typedef signed char UNITY_INT8; |
|||
typedef signed short UNITY_INT16; |
|||
typedef signed int UNITY_INT32; |
|||
#elif (UNITY_INT_WIDTH == 16) |
|||
typedef unsigned char UNITY_UINT8; |
|||
typedef unsigned int UNITY_UINT16; |
|||
typedef unsigned long UNITY_UINT32; |
|||
typedef signed char UNITY_INT8; |
|||
typedef signed int UNITY_INT16; |
|||
typedef signed long UNITY_INT32; |
|||
#else |
|||
#error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported) |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* 64-bit Support |
|||
*-------------------------------------------------------*/ |
|||
|
|||
/* Auto-detect 64 Bit Support */ |
|||
#ifndef UNITY_SUPPORT_64 |
|||
#if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64 |
|||
#define UNITY_SUPPORT_64 |
|||
#endif |
|||
#endif |
|||
|
|||
/* 64-Bit Support Dependent Configuration */ |
|||
#ifndef UNITY_SUPPORT_64 |
|||
/* No 64-bit Support */ |
|||
typedef UNITY_UINT32 UNITY_UINT; |
|||
typedef UNITY_INT32 UNITY_INT; |
|||
#define UNITY_MAX_NIBBLES (8) /* Maximum number of nibbles in a UNITY_(U)INT */ |
|||
#else |
|||
/* 64-bit Support */ |
|||
#if (UNITY_LONG_WIDTH == 32) |
|||
typedef unsigned long long UNITY_UINT64; |
|||
typedef signed long long UNITY_INT64; |
|||
#elif (UNITY_LONG_WIDTH == 64) |
|||
typedef unsigned long UNITY_UINT64; |
|||
typedef signed long UNITY_INT64; |
|||
#else |
|||
#error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported) |
|||
#endif |
|||
typedef UNITY_UINT64 UNITY_UINT; |
|||
typedef UNITY_INT64 UNITY_INT; |
|||
#define UNITY_MAX_NIBBLES (16) /* Maximum number of nibbles in a UNITY_(U)INT */ |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Pointer Support |
|||
*-------------------------------------------------------*/ |
|||
|
|||
#if (UNITY_POINTER_WIDTH == 32) |
|||
#define UNITY_PTR_TO_INT UNITY_INT32 |
|||
#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32 |
|||
#elif (UNITY_POINTER_WIDTH == 64) |
|||
#define UNITY_PTR_TO_INT UNITY_INT64 |
|||
#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64 |
|||
#elif (UNITY_POINTER_WIDTH == 16) |
|||
#define UNITY_PTR_TO_INT UNITY_INT16 |
|||
#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16 |
|||
#else |
|||
#error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported) |
|||
#endif |
|||
|
|||
#ifndef UNITY_PTR_ATTRIBUTE |
|||
#define UNITY_PTR_ATTRIBUTE |
|||
#endif |
|||
|
|||
#ifndef UNITY_INTERNAL_PTR |
|||
#define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void* |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Float Support |
|||
*-------------------------------------------------------*/ |
|||
|
|||
#ifdef UNITY_EXCLUDE_FLOAT |
|||
|
|||
/* No Floating Point Support */ |
|||
#ifndef UNITY_EXCLUDE_DOUBLE |
|||
#define UNITY_EXCLUDE_DOUBLE /* Remove double when excluding float support */ |
|||
#endif |
|||
#ifndef UNITY_EXCLUDE_FLOAT_PRINT |
|||
#define UNITY_EXCLUDE_FLOAT_PRINT |
|||
#endif |
|||
|
|||
#else |
|||
|
|||
/* Floating Point Support */ |
|||
#ifndef UNITY_FLOAT_PRECISION |
|||
#define UNITY_FLOAT_PRECISION (0.00001f) |
|||
#endif |
|||
#ifndef UNITY_FLOAT_TYPE |
|||
#define UNITY_FLOAT_TYPE float |
|||
#endif |
|||
typedef UNITY_FLOAT_TYPE UNITY_FLOAT; |
|||
|
|||
/* isinf & isnan macros should be provided by math.h */ |
|||
#ifndef isinf |
|||
/* The value of Inf - Inf is NaN */ |
|||
#define isinf(n) (isnan((n) - (n)) && !isnan(n)) |
|||
#endif |
|||
|
|||
#ifndef isnan |
|||
/* NaN is the only floating point value that does NOT equal itself.
|
|||
* Therefore if n != n, then it is NaN. */ |
|||
#define isnan(n) ((n != n) ? 1 : 0) |
|||
#endif |
|||
|
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Double Float Support |
|||
*-------------------------------------------------------*/ |
|||
|
|||
/* unlike float, we DON'T include by default */ |
|||
#if defined(UNITY_EXCLUDE_DOUBLE) || !defined(UNITY_INCLUDE_DOUBLE) |
|||
|
|||
/* No Floating Point Support */ |
|||
#ifndef UNITY_EXCLUDE_DOUBLE |
|||
#define UNITY_EXCLUDE_DOUBLE |
|||
#else |
|||
#undef UNITY_INCLUDE_DOUBLE |
|||
#endif |
|||
|
|||
#ifndef UNITY_EXCLUDE_FLOAT |
|||
#ifndef UNITY_DOUBLE_TYPE |
|||
#define UNITY_DOUBLE_TYPE double |
|||
#endif |
|||
typedef UNITY_FLOAT UNITY_DOUBLE; |
|||
/* For parameter in UnityPrintFloat(UNITY_DOUBLE), which aliases to double or float */ |
|||
#endif |
|||
|
|||
#else |
|||
|
|||
/* Double Floating Point Support */ |
|||
#ifndef UNITY_DOUBLE_PRECISION |
|||
#define UNITY_DOUBLE_PRECISION (1e-12) |
|||
#endif |
|||
|
|||
#ifndef UNITY_DOUBLE_TYPE |
|||
#define UNITY_DOUBLE_TYPE double |
|||
#endif |
|||
typedef UNITY_DOUBLE_TYPE UNITY_DOUBLE; |
|||
|
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Output Method: stdout (DEFAULT) |
|||
*-------------------------------------------------------*/ |
|||
#ifndef UNITY_OUTPUT_CHAR |
|||
/* Default to using putchar, which is defined in stdio.h */ |
|||
#include <stdio.h> |
|||
#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 */ |
|||
#ifdef UNITY_OUTPUT_CHAR_HEADER_DECLARATION |
|||
extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION; |
|||
#endif |
|||
#endif |
|||
|
|||
#ifndef UNITY_OUTPUT_FLUSH |
|||
#ifdef UNITY_USE_FLUSH_STDOUT |
|||
/* We want to use the stdout flush utility */ |
|||
#include <stdio.h> |
|||
#define UNITY_OUTPUT_FLUSH() (void)fflush(stdout) |
|||
#else |
|||
/* We've specified nothing, therefore flush should just be ignored */ |
|||
#define UNITY_OUTPUT_FLUSH() |
|||
#endif |
|||
#else |
|||
/* If defined as something else, make sure we declare it here so it's ready for use */ |
|||
#ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION |
|||
extern void UNITY_OUTPUT_FLUSH_HEADER_DECLARATION; |
|||
#endif |
|||
#endif |
|||
|
|||
#ifndef UNITY_OUTPUT_FLUSH |
|||
#define UNITY_FLUSH_CALL() |
|||
#else |
|||
#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH() |
|||
#endif |
|||
|
|||
#ifndef UNITY_PRINT_EOL |
|||
#define UNITY_PRINT_EOL() UNITY_OUTPUT_CHAR('\n') |
|||
#endif |
|||
|
|||
#ifndef UNITY_OUTPUT_START |
|||
#define UNITY_OUTPUT_START() |
|||
#endif |
|||
|
|||
#ifndef UNITY_OUTPUT_COMPLETE |
|||
#define UNITY_OUTPUT_COMPLETE() |
|||
#endif |
|||
|
|||
#ifdef UNITY_INCLUDE_EXEC_TIME |
|||
#if !defined(UNITY_EXEC_TIME_START) && \ |
|||
!defined(UNITY_EXEC_TIME_STOP) && \ |
|||
!defined(UNITY_PRINT_EXEC_TIME) && \ |
|||
!defined(UNITY_TIME_TYPE) |
|||
/* If none any of these macros are defined then try to provide a default implementation */ |
|||
|
|||
#if defined(UNITY_CLOCK_MS) |
|||
/* This is a simple way to get a default implementation on platforms that support getting a millisecond counter */ |
|||
#define UNITY_TIME_TYPE UNITY_UINT |
|||
#define UNITY_EXEC_TIME_START() Unity.CurrentTestStartTime = UNITY_CLOCK_MS() |
|||
#define UNITY_EXEC_TIME_STOP() Unity.CurrentTestStopTime = UNITY_CLOCK_MS() |
|||
#define UNITY_PRINT_EXEC_TIME() { \ |
|||
UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ |
|||
UnityPrint(" ("); \ |
|||
UnityPrintNumberUnsigned(execTimeMs); \ |
|||
UnityPrint(" ms)"); \ |
|||
} |
|||
#elif defined(_WIN32) |
|||
#include <time.h> |
|||
#define UNITY_TIME_TYPE clock_t |
|||
#define UNITY_GET_TIME(t) t = (clock_t)((clock() * 1000) / CLOCKS_PER_SEC) |
|||
#define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) |
|||
#define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) |
|||
#define UNITY_PRINT_EXEC_TIME() { \ |
|||
UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ |
|||
UnityPrint(" ("); \ |
|||
UnityPrintNumberUnsigned(execTimeMs); \ |
|||
UnityPrint(" ms)"); \ |
|||
} |
|||
#elif defined(__unix__) |
|||
#include <time.h> |
|||
#define UNITY_TIME_TYPE struct timespec |
|||
#define UNITY_GET_TIME(t) clock_gettime(CLOCK_MONOTONIC, &t) |
|||
#define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) |
|||
#define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) |
|||
#define UNITY_PRINT_EXEC_TIME() { \ |
|||
UNITY_UINT execTimeMs = ((Unity.CurrentTestStopTime.tv_sec - Unity.CurrentTestStartTime.tv_sec) * 1000L); \ |
|||
execTimeMs += ((Unity.CurrentTestStopTime.tv_nsec - Unity.CurrentTestStartTime.tv_nsec) / 1000000L); \ |
|||
UnityPrint(" ("); \ |
|||
UnityPrintNumberUnsigned(execTimeMs); \ |
|||
UnityPrint(" ms)"); \ |
|||
} |
|||
#endif |
|||
#endif |
|||
#endif |
|||
|
|||
#ifndef UNITY_EXEC_TIME_START |
|||
#define UNITY_EXEC_TIME_START() do{}while(0) |
|||
#endif |
|||
|
|||
#ifndef UNITY_EXEC_TIME_STOP |
|||
#define UNITY_EXEC_TIME_STOP() do{}while(0) |
|||
#endif |
|||
|
|||
#ifndef UNITY_TIME_TYPE |
|||
#define UNITY_TIME_TYPE UNITY_UINT |
|||
#endif |
|||
|
|||
#ifndef UNITY_PRINT_EXEC_TIME |
|||
#define UNITY_PRINT_EXEC_TIME() do{}while(0) |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Footprint |
|||
*-------------------------------------------------------*/ |
|||
|
|||
#ifndef UNITY_LINE_TYPE |
|||
#define UNITY_LINE_TYPE UNITY_UINT |
|||
#endif |
|||
|
|||
#ifndef UNITY_COUNTER_TYPE |
|||
#define UNITY_COUNTER_TYPE UNITY_UINT |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Language Features Available |
|||
*-------------------------------------------------------*/ |
|||
#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA) |
|||
# if defined(__GNUC__) || defined(__ghs__) /* __GNUC__ includes clang */ |
|||
# if !(defined(__WIN32__) && defined(__clang__)) && !defined(__TMS470__) |
|||
# define UNITY_WEAK_ATTRIBUTE __attribute__((weak)) |
|||
# endif |
|||
# endif |
|||
#endif |
|||
|
|||
#ifdef UNITY_NO_WEAK |
|||
# undef UNITY_WEAK_ATTRIBUTE |
|||
# undef UNITY_WEAK_PRAGMA |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Internal Structs Needed |
|||
*-------------------------------------------------------*/ |
|||
|
|||
typedef void (*UnityTestFunction)(void); |
|||
|
|||
#define UNITY_DISPLAY_RANGE_INT (0x10) |
|||
#define UNITY_DISPLAY_RANGE_UINT (0x20) |
|||
#define UNITY_DISPLAY_RANGE_HEX (0x40) |
|||
|
|||
typedef enum |
|||
{ |
|||
UNITY_DISPLAY_STYLE_INT = sizeof(int) + UNITY_DISPLAY_RANGE_INT, |
|||
UNITY_DISPLAY_STYLE_INT8 = 1 + UNITY_DISPLAY_RANGE_INT, |
|||
UNITY_DISPLAY_STYLE_INT16 = 2 + UNITY_DISPLAY_RANGE_INT, |
|||
UNITY_DISPLAY_STYLE_INT32 = 4 + UNITY_DISPLAY_RANGE_INT, |
|||
#ifdef UNITY_SUPPORT_64 |
|||
UNITY_DISPLAY_STYLE_INT64 = 8 + UNITY_DISPLAY_RANGE_INT, |
|||
#endif |
|||
|
|||
UNITY_DISPLAY_STYLE_UINT = sizeof(unsigned) + UNITY_DISPLAY_RANGE_UINT, |
|||
UNITY_DISPLAY_STYLE_UINT8 = 1 + UNITY_DISPLAY_RANGE_UINT, |
|||
UNITY_DISPLAY_STYLE_UINT16 = 2 + UNITY_DISPLAY_RANGE_UINT, |
|||
UNITY_DISPLAY_STYLE_UINT32 = 4 + UNITY_DISPLAY_RANGE_UINT, |
|||
#ifdef UNITY_SUPPORT_64 |
|||
UNITY_DISPLAY_STYLE_UINT64 = 8 + UNITY_DISPLAY_RANGE_UINT, |
|||
#endif |
|||
|
|||
UNITY_DISPLAY_STYLE_HEX8 = 1 + UNITY_DISPLAY_RANGE_HEX, |
|||
UNITY_DISPLAY_STYLE_HEX16 = 2 + UNITY_DISPLAY_RANGE_HEX, |
|||
UNITY_DISPLAY_STYLE_HEX32 = 4 + UNITY_DISPLAY_RANGE_HEX, |
|||
#ifdef UNITY_SUPPORT_64 |
|||
UNITY_DISPLAY_STYLE_HEX64 = 8 + UNITY_DISPLAY_RANGE_HEX, |
|||
#endif |
|||
|
|||
UNITY_DISPLAY_STYLE_UNKNOWN |
|||
} UNITY_DISPLAY_STYLE_T; |
|||
|
|||
typedef enum |
|||
{ |
|||
UNITY_WITHIN = 0x0, |
|||
UNITY_EQUAL_TO = 0x1, |
|||
UNITY_GREATER_THAN = 0x2, |
|||
UNITY_GREATER_OR_EQUAL = 0x2 + UNITY_EQUAL_TO, |
|||
UNITY_SMALLER_THAN = 0x4, |
|||
UNITY_SMALLER_OR_EQUAL = 0x4 + UNITY_EQUAL_TO, |
|||
UNITY_UNKNOWN |
|||
} UNITY_COMPARISON_T; |
|||
|
|||
#ifndef UNITY_EXCLUDE_FLOAT |
|||
typedef enum UNITY_FLOAT_TRAIT |
|||
{ |
|||
UNITY_FLOAT_IS_NOT_INF = 0, |
|||
UNITY_FLOAT_IS_INF, |
|||
UNITY_FLOAT_IS_NOT_NEG_INF, |
|||
UNITY_FLOAT_IS_NEG_INF, |
|||
UNITY_FLOAT_IS_NOT_NAN, |
|||
UNITY_FLOAT_IS_NAN, |
|||
UNITY_FLOAT_IS_NOT_DET, |
|||
UNITY_FLOAT_IS_DET, |
|||
UNITY_FLOAT_INVALID_TRAIT |
|||
} UNITY_FLOAT_TRAIT_T; |
|||
#endif |
|||
|
|||
typedef enum |
|||
{ |
|||
UNITY_ARRAY_TO_VAL = 0, |
|||
UNITY_ARRAY_TO_ARRAY, |
|||
UNITY_ARRAY_UNKNOWN |
|||
} UNITY_FLAGS_T; |
|||
|
|||
struct UNITY_STORAGE_T |
|||
{ |
|||
const char* TestFile; |
|||
const char* CurrentTestName; |
|||
#ifndef UNITY_EXCLUDE_DETAILS |
|||
const char* CurrentDetail1; |
|||
const char* CurrentDetail2; |
|||
#endif |
|||
UNITY_LINE_TYPE CurrentTestLineNumber; |
|||
UNITY_COUNTER_TYPE NumberOfTests; |
|||
UNITY_COUNTER_TYPE TestFailures; |
|||
UNITY_COUNTER_TYPE TestIgnores; |
|||
UNITY_COUNTER_TYPE CurrentTestFailed; |
|||
UNITY_COUNTER_TYPE CurrentTestIgnored; |
|||
#ifdef UNITY_INCLUDE_EXEC_TIME |
|||
UNITY_TIME_TYPE CurrentTestStartTime; |
|||
UNITY_TIME_TYPE CurrentTestStopTime; |
|||
#endif |
|||
#ifndef UNITY_EXCLUDE_SETJMP_H |
|||
jmp_buf AbortFrame; |
|||
#endif |
|||
}; |
|||
|
|||
extern struct UNITY_STORAGE_T Unity; |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Test Suite Management |
|||
*-------------------------------------------------------*/ |
|||
|
|||
void UnityBegin(const char* filename); |
|||
int UnityEnd(void); |
|||
void UnityConcludeTest(void); |
|||
void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum); |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Details Support |
|||
*-------------------------------------------------------*/ |
|||
|
|||
#ifdef UNITY_EXCLUDE_DETAILS |
|||
#define UNITY_CLR_DETAILS() |
|||
#define UNITY_SET_DETAIL(d1) |
|||
#define UNITY_SET_DETAILS(d1,d2) |
|||
#else |
|||
#define UNITY_CLR_DETAILS() { Unity.CurrentDetail1 = 0; Unity.CurrentDetail2 = 0; } |
|||
#define UNITY_SET_DETAIL(d1) { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = 0; } |
|||
#define UNITY_SET_DETAILS(d1,d2) { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = (d2); } |
|||
|
|||
#ifndef UNITY_DETAIL1_NAME |
|||
#define UNITY_DETAIL1_NAME "Function" |
|||
#endif |
|||
|
|||
#ifndef UNITY_DETAIL2_NAME |
|||
#define UNITY_DETAIL2_NAME "Argument" |
|||
#endif |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Test Output |
|||
*-------------------------------------------------------*/ |
|||
|
|||
void UnityPrint(const char* string); |
|||
|
|||
#ifdef UNITY_INCLUDE_PRINT_FORMATTED |
|||
void UnityPrintFormatted(const char* format, ...); |
|||
#endif |
|||
|
|||
void UnityPrintLen(const char* string, const UNITY_UINT32 length); |
|||
void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number); |
|||
void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style); |
|||
void UnityPrintNumber(const UNITY_INT number_to_print); |
|||
void UnityPrintNumberUnsigned(const UNITY_UINT number); |
|||
void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print); |
|||
|
|||
#ifndef UNITY_EXCLUDE_FLOAT_PRINT |
|||
void UnityPrintFloat(const UNITY_DOUBLE input_number); |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Test Assertion Functions |
|||
*------------------------------------------------------- |
|||
* Use the macros below this section instead of calling |
|||
* these directly. The macros have a consistent naming |
|||
* convention and will pull in file and line information |
|||
* for you. */ |
|||
|
|||
void UnityAssertEqualNumber(const UNITY_INT expected, |
|||
const UNITY_INT actual, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_DISPLAY_STYLE_T style); |
|||
|
|||
void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, |
|||
const UNITY_INT actual, |
|||
const UNITY_COMPARISON_T compare, |
|||
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, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_DISPLAY_STYLE_T style, |
|||
const UNITY_FLAGS_T flags); |
|||
|
|||
void UnityAssertBits(const UNITY_INT mask, |
|||
const UNITY_INT expected, |
|||
const UNITY_INT actual, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber); |
|||
|
|||
void UnityAssertEqualString(const char* expected, |
|||
const char* actual, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber); |
|||
|
|||
void UnityAssertEqualStringLen(const char* expected, |
|||
const char* actual, |
|||
const UNITY_UINT32 length, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber); |
|||
|
|||
void UnityAssertEqualStringArray( UNITY_INTERNAL_PTR expected, |
|||
const char** actual, |
|||
const UNITY_UINT32 num_elements, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_FLAGS_T flags); |
|||
|
|||
void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected, |
|||
UNITY_INTERNAL_PTR actual, |
|||
const UNITY_UINT32 length, |
|||
const UNITY_UINT32 num_elements, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_FLAGS_T flags); |
|||
|
|||
void UnityAssertNumbersWithin(const UNITY_UINT delta, |
|||
const UNITY_INT expected, |
|||
const UNITY_INT actual, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_DISPLAY_STYLE_T style); |
|||
|
|||
void UnityAssertNumbersArrayWithin(const UNITY_UINT delta, |
|||
UNITY_INTERNAL_PTR expected, |
|||
UNITY_INTERNAL_PTR actual, |
|||
const UNITY_UINT32 num_elements, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_DISPLAY_STYLE_T style, |
|||
const UNITY_FLAGS_T flags); |
|||
|
|||
void UnityFail(const char* message, const UNITY_LINE_TYPE line); |
|||
|
|||
void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); |
|||
|
|||
#ifndef UNITY_EXCLUDE_FLOAT |
|||
void UnityAssertFloatsWithin(const UNITY_FLOAT delta, |
|||
const UNITY_FLOAT expected, |
|||
const UNITY_FLOAT actual, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber); |
|||
|
|||
void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, |
|||
UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, |
|||
const UNITY_UINT32 num_elements, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_FLAGS_T flags); |
|||
|
|||
void UnityAssertFloatSpecial(const UNITY_FLOAT actual, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_FLOAT_TRAIT_T style); |
|||
#endif |
|||
|
|||
#ifndef UNITY_EXCLUDE_DOUBLE |
|||
void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, |
|||
const UNITY_DOUBLE expected, |
|||
const UNITY_DOUBLE actual, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber); |
|||
|
|||
void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, |
|||
UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, |
|||
const UNITY_UINT32 num_elements, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_FLAGS_T flags); |
|||
|
|||
void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, |
|||
const char* msg, |
|||
const UNITY_LINE_TYPE lineNumber, |
|||
const UNITY_FLOAT_TRAIT_T style); |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Helpers |
|||
*-------------------------------------------------------*/ |
|||
|
|||
UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size); |
|||
#ifndef UNITY_EXCLUDE_FLOAT |
|||
UNITY_INTERNAL_PTR UnityFloatToPtr(const float num); |
|||
#endif |
|||
#ifndef UNITY_EXCLUDE_DOUBLE |
|||
UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num); |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Error Strings We Might Need |
|||
*-------------------------------------------------------*/ |
|||
|
|||
extern const char UnityStrOk[]; |
|||
extern const char UnityStrPass[]; |
|||
extern const char UnityStrFail[]; |
|||
extern const char UnityStrIgnore[]; |
|||
|
|||
extern const char UnityStrErrFloat[]; |
|||
extern const char UnityStrErrDouble[]; |
|||
extern const char UnityStrErr64[]; |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Test Running Macros |
|||
*-------------------------------------------------------*/ |
|||
|
|||
#ifndef UNITY_EXCLUDE_SETJMP_H |
|||
#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0) |
|||
#define TEST_ABORT() longjmp(Unity.AbortFrame, 1) |
|||
#else |
|||
#define TEST_PROTECT() 1 |
|||
#define TEST_ABORT() return |
|||
#endif |
|||
|
|||
/* This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__) */ |
|||
#ifndef RUN_TEST |
|||
#ifdef __STDC_VERSION__ |
|||
#if __STDC_VERSION__ >= 199901L |
|||
#define RUN_TEST(...) UnityDefaultTestRun(RUN_TEST_FIRST(__VA_ARGS__), RUN_TEST_SECOND(__VA_ARGS__)) |
|||
#define RUN_TEST_FIRST(...) RUN_TEST_FIRST_HELPER(__VA_ARGS__, throwaway) |
|||
#define RUN_TEST_FIRST_HELPER(first, ...) (first), #first |
|||
#define RUN_TEST_SECOND(...) RUN_TEST_SECOND_HELPER(__VA_ARGS__, __LINE__, throwaway) |
|||
#define RUN_TEST_SECOND_HELPER(first, second, ...) (second) |
|||
#endif |
|||
#endif |
|||
#endif |
|||
|
|||
/* If we can't do the tricky version, we'll just have to require them to always include the line number */ |
|||
#ifndef RUN_TEST |
|||
#ifdef CMOCK |
|||
#define RUN_TEST(func, num) UnityDefaultTestRun(func, #func, num) |
|||
#else |
|||
#define RUN_TEST(func) UnityDefaultTestRun(func, #func, __LINE__) |
|||
#endif |
|||
#endif |
|||
|
|||
#define TEST_LINE_NUM (Unity.CurrentTestLineNumber) |
|||
#define TEST_IS_IGNORED (Unity.CurrentTestIgnored) |
|||
#define UNITY_NEW_TEST(a) \ |
|||
Unity.CurrentTestName = (a); \ |
|||
Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)(__LINE__); \ |
|||
Unity.NumberOfTests++; |
|||
|
|||
#ifndef UNITY_BEGIN |
|||
#define UNITY_BEGIN() UnityBegin(__FILE__) |
|||
#endif |
|||
|
|||
#ifndef UNITY_END |
|||
#define UNITY_END() UnityEnd() |
|||
#endif |
|||
|
|||
/*-----------------------------------------------
|
|||
* Command Line Argument Support |
|||
*-----------------------------------------------*/ |
|||
|
|||
#ifdef UNITY_USE_COMMAND_LINE_ARGS |
|||
int UnityParseOptions(int argc, char** argv); |
|||
int UnityTestMatches(void); |
|||
#endif |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Basic Fail and Ignore |
|||
*-------------------------------------------------------*/ |
|||
|
|||
#define UNITY_TEST_FAIL(line, message) UnityFail( (message), (UNITY_LINE_TYPE)(line)) |
|||
#define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)(line)) |
|||
|
|||
/*-------------------------------------------------------
|
|||
* Test Asserts |
|||
*-------------------------------------------------------*/ |
|||
|
|||
#define UNITY_TEST_ASSERT(condition, line, message) if (condition) {} else {UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), (message));} |
|||
#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (UNITY_LINE_TYPE)(line), (message)) |
|||
#define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) != NULL), (UNITY_LINE_TYPE)(line), (message)) |
|||
|
|||
#define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) |
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) |
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) |
|||
#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) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) |
|||
|
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) |
|||
|
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) |
|||
|
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (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) |
|||
#define UNITY_TEST_ASSERT_INT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) |
|||
#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) |
|||
#define UNITY_TEST_ASSERT_UINT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) |
|||
#define UNITY_TEST_ASSERT_UINT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) |
|||
#define UNITY_TEST_ASSERT_UINT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) |
|||
#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) |
|||
#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) |
|||
#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) |
|||
|
|||
|
|||
#define UNITY_TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) |
|||
|
|||
|
|||
#define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_PTR_TO_INT)(expected), (UNITY_PTR_TO_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER) |
|||
#define UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, line, message) UnityAssertEqualString((const char*)(expected), (const char*)(actual), (message), (UNITY_LINE_TYPE)(line)) |
|||
#define UNITY_TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len, line, message) UnityAssertEqualStringLen((const char*)(expected), (const char*)(actual), (UNITY_UINT32)(len), (message), (UNITY_LINE_TYPE)(line)) |
|||
#define UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), 1, (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) |
|||
|
|||
#define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) |
|||
|
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), sizeof(int)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), sizeof(unsigned int)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT16)(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT32)(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_PTR_TO_INT) (expected), sizeof(int*)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) |
|||
|
|||
#ifdef UNITY_SUPPORT_64 |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) |
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) |
|||
#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) |
|||
#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) |
|||
#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) |
|||
#else |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) |
|||
#endif |
|||
|
|||
#ifdef UNITY_EXCLUDE_FLOAT |
|||
#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) |
|||
#else |
|||
#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line)) |
|||
#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) |
|||
#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray((UNITY_FLOAT*)(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray(UnityFloatToPtr(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) |
|||
#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) |
|||
#endif |
|||
|
|||
#ifdef UNITY_EXCLUDE_DOUBLE |
|||
#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) |
|||
#else |
|||
#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line)) |
|||
#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) |
|||
#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray((UNITY_DOUBLE*)(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) |
|||
#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray(UnityDoubleToPtr(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) |
|||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) |
|||
#endif |
|||
|
|||
/* End of UNITY_INTERNALS_H */ |
|||
#endif |
@ -0,0 +1,58 @@ |
|||
# This is the configuration used to check the rubocop source code. |
|||
|
|||
#inherit_from: .rubocop_todo.yml |
|||
|
|||
AllCops: |
|||
TargetRubyVersion: 2.1 |
|||
|
|||
# These are areas where ThrowTheSwitch's coding style diverges from the Ruby standard |
|||
Style/SpecialGlobalVars: |
|||
EnforcedStyle: use_perl_names |
|||
Style/FormatString: |
|||
Enabled: false |
|||
Style/GlobalVars: |
|||
Enabled: false |
|||
Style/RegexpLiteral: |
|||
AllowInnerSlashes: true |
|||
Style/HashSyntax: |
|||
EnforcedStyle: no_mixed_keys |
|||
|
|||
# This is disabled because it seems to get confused over nested hashes |
|||
Layout/AlignHash: |
|||
Enabled: false |
|||
EnforcedHashRocketStyle: table |
|||
EnforcedColonStyle: table |
|||
|
|||
# We purposefully use these insecure features because they're what makes Ruby awesome |
|||
Security/Eval: |
|||
Enabled: false |
|||
Security/YAMLLoad: |
|||
Enabled: false |
|||
|
|||
# At this point, we're not ready to enforce inline documentation requirements |
|||
Style/Documentation: |
|||
Enabled: false |
|||
Style/DocumentationMethod: |
|||
Enabled: false |
|||
|
|||
# At this point, we're not ready to enforce any metrics |
|||
Metrics/AbcSize: |
|||
Enabled: false |
|||
Metrics/BlockLength: |
|||
Enabled: false |
|||
Metrics/BlockNesting: |
|||
Enabled: false |
|||
Metrics/ClassLength: |
|||
Enabled: false |
|||
Metrics/CyclomaticComplexity: |
|||
Enabled: false |
|||
Metrics/LineLength: |
|||
Enabled: false |
|||
Metrics/MethodLength: |
|||
Enabled: false |
|||
Metrics/ModuleLength: |
|||
Enabled: false |
|||
Metrics/ParameterLists: |
|||
Enabled: false |
|||
Metrics/PerceivedComplexity: |
|||
Enabled: false |
@ -0,0 +1,68 @@ |
|||
CC = gcc |
|||
ifeq ($(shell uname -s), Darwin) |
|||
CC = clang |
|||
endif |
|||
ifeq ($(findstring clang, $(CC)), clang) |
|||
E = -Weverything |
|||
CFLAGS += $E -Wno-unknown-warning-option -Wno-missing-prototypes |
|||
CFLAGS += -Wno-unused-macros -Wno-padded -Wno-missing-noreturn |
|||
endif |
|||
CFLAGS += -std=c99 -pedantic -Wall -Wextra -Wconversion -Werror |
|||
CFLAGS += -Wno-switch-enum -Wno-double-promotion |
|||
CFLAGS += -Wbad-function-cast -Wcast-qual -Wold-style-definition -Wshadow -Wstrict-overflow \
|
|||
-Wstrict-prototypes -Wswitch-default -Wundef |
|||
#DEBUG = -O0 -g
|
|||
CFLAGS += $(DEBUG) |
|||
DEFINES = -D UNITY_OUTPUT_CHAR=putcharSpy |
|||
DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\) |
|||
DEFINES += -D UNITY_OUTPUT_FLUSH=flushSpy |
|||
DEFINES += -D UNITY_OUTPUT_FLUSH_HEADER_DECLARATION=flushSpy\(void\) |
|||
DEFINES += $(UNITY_SUPPORT_64) $(UNITY_INCLUDE_DOUBLE) |
|||
UNITY_SUPPORT_64 = -D UNITY_SUPPORT_64 |
|||
UNITY_INCLUDE_DOUBLE = -D UNITY_INCLUDE_DOUBLE |
|||
SRC = ../src/unity.c tests/testunity.c build/testunityRunner.c |
|||
INC_DIR = -I ../src |
|||
COV_FLAGS = -fprofile-arcs -ftest-coverage -I ../../src |
|||
BUILD_DIR = build |
|||
TARGET = build/testunity-cov.exe |
|||
|
|||
# To generate coverage, call 'make -s', the default target runs.
|
|||
# For verbose output of all the tests, run 'make test'.
|
|||
default: coverage |
|||
.PHONY: default coverage test clean |
|||
coverage: DEFINES += -D UNITY_NO_WEAK |
|||
coverage: $(BUILD_DIR)/testunityRunner.c |
|||
cd $(BUILD_DIR) && \
|
|||
$(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC), ../$i) $(COV_FLAGS) -o ../$(TARGET) |
|||
rm -f $(BUILD_DIR)/*.gcda |
|||
./$(TARGET) | grep 'Tests\|]]]' -A1 |
|||
cd $(BUILD_DIR) && \
|
|||
gcov unity.c | head -3 |
|||
grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true |
|||
|
|||
test: $(BUILD_DIR)/testunityRunner.c |
|||
$(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC) -o $(TARGET) |
|||
./$(TARGET) |
|||
|
|||
# Compile only, for testing that preprocessor detection works
|
|||
UNITY_C_ONLY =-c ../src/unity.c -o $(BUILD_DIR)/unity.o |
|||
intDetection: |
|||
$(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_STDINT_H |
|||
$(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_LIMITS_H |
|||
|
|||
$(BUILD_DIR)/testunityRunner.c: tests/testunity.c | $(BUILD_DIR) |
|||
awk $(AWK_SCRIPT) tests/testunity.c > $@ |
|||
|
|||
AWK_SCRIPT=\
|
|||
'/^void test/{ declarations[d++]=$$0; gsub(/\(?void\)? ?/,""); tests[t++]=$$0; line[u++]=NR } \
|
|||
END{ print "\#include \"unity.h\" /* Autogenerated by awk in Makefile */" ; \
|
|||
for (i=0; i<d; i++) { print declarations[i] ";" } \
|
|||
print "int main(void)\n{\n UnityBegin(\"" FILENAME "\");" ; \
|
|||
for (i=0; i<t; i++) { print " RUN_TEST(" tests[i] ", " line[i] ");" } \
|
|||
print " return UNITY_END();\n}" }' |
|||
|
|||
$(BUILD_DIR): |
|||
mkdir -p $(BUILD_DIR) |
|||
|
|||
clean: |
|||
rm -f $(TARGET) $(BUILD_DIR)/*.gc* $(BUILD_DIR)/testunityRunner.c |
@ -0,0 +1,61 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
CEXCEPTION_T e; \ |
|||
Try { \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
} \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "CException.h" |
|||
#include "funky.h" |
|||
#include "stanky.h" |
|||
#include <setjmp.h> |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
extern void test_TheThirdThingToTest(void); |
|||
extern void test_TheFourthThingToTest(void); |
|||
|
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
tearDown(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/testsample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
RUN_TEST(test_TheThirdThingToTest, 53); |
|||
RUN_TEST(test_TheFourthThingToTest, 58); |
|||
|
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,57 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
} \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "funky.h" |
|||
#include "stanky.h" |
|||
#include <setjmp.h> |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
extern void test_TheThirdThingToTest(void); |
|||
extern void test_TheFourthThingToTest(void); |
|||
|
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
tearDown(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/testsample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
RUN_TEST(test_TheThirdThingToTest, 53); |
|||
RUN_TEST(test_TheFourthThingToTest, 58); |
|||
|
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,55 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
} \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "testsample_head1.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
extern void test_TheThirdThingToTest(void); |
|||
extern void test_TheFourthThingToTest(void); |
|||
|
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
tearDown(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/testsample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
RUN_TEST(test_TheThirdThingToTest, 53); |
|||
RUN_TEST(test_TheFourthThingToTest, 58); |
|||
|
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,15 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
#ifndef _TESTSAMPLE_HEAD1_H |
|||
#define _TESTSAMPLE_HEAD1_H |
|||
|
|||
#include "unity.h" |
|||
#include "funky.h" |
|||
#include "stanky.h" |
|||
#include <setjmp.h> |
|||
|
|||
void test_TheFirstThingToTest(void); |
|||
void test_TheSecondThingToTest(void); |
|||
void test_TheThirdThingToTest(void); |
|||
void test_TheFourthThingToTest(void); |
|||
#endif |
|||
|
@ -0,0 +1,80 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
CMock_Init(); \ |
|||
UNITY_CLR_DETAILS(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
CEXCEPTION_T e; \ |
|||
Try { \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
CMock_Verify(); \ |
|||
} \ |
|||
CMock_Destroy(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "CException.h" |
|||
#include "funky.h" |
|||
#include <setjmp.h> |
|||
#include "Mockstanky.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
|
|||
|
|||
/*=======Mock Management=====*/ |
|||
static void CMock_Init(void) |
|||
{ |
|||
Mockstanky_Init(); |
|||
} |
|||
static void CMock_Verify(void) |
|||
{ |
|||
Mockstanky_Verify(); |
|||
} |
|||
static void CMock_Destroy(void) |
|||
{ |
|||
Mockstanky_Destroy(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
CMock_Verify(); |
|||
CMock_Destroy(); |
|||
tearDown(); |
|||
CMock_Init(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/mocksample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
|
|||
CMock_Guts_MemFreeFinal(); |
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,76 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
CMock_Init(); \ |
|||
UNITY_CLR_DETAILS(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
CMock_Verify(); \ |
|||
} \ |
|||
CMock_Destroy(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "funky.h" |
|||
#include <setjmp.h> |
|||
#include "Mockstanky.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
|
|||
|
|||
/*=======Mock Management=====*/ |
|||
static void CMock_Init(void) |
|||
{ |
|||
Mockstanky_Init(); |
|||
} |
|||
static void CMock_Verify(void) |
|||
{ |
|||
Mockstanky_Verify(); |
|||
} |
|||
static void CMock_Destroy(void) |
|||
{ |
|||
Mockstanky_Destroy(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
CMock_Verify(); |
|||
CMock_Destroy(); |
|||
tearDown(); |
|||
CMock_Init(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/mocksample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
|
|||
CMock_Guts_MemFreeFinal(); |
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,75 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
CMock_Init(); \ |
|||
UNITY_CLR_DETAILS(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
CMock_Verify(); \ |
|||
} \ |
|||
CMock_Destroy(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "testsample_mock_head1.h" |
|||
#include "Mockstanky.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
|
|||
|
|||
/*=======Mock Management=====*/ |
|||
static void CMock_Init(void) |
|||
{ |
|||
Mockstanky_Init(); |
|||
} |
|||
static void CMock_Verify(void) |
|||
{ |
|||
Mockstanky_Verify(); |
|||
} |
|||
static void CMock_Destroy(void) |
|||
{ |
|||
Mockstanky_Destroy(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
CMock_Verify(); |
|||
CMock_Destroy(); |
|||
tearDown(); |
|||
CMock_Init(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/mocksample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
|
|||
CMock_Guts_MemFreeFinal(); |
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,13 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
#ifndef _TESTSAMPLE_MOCK_HEAD1_H |
|||
#define _TESTSAMPLE_MOCK_HEAD1_H |
|||
|
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include "funky.h" |
|||
#include <setjmp.h> |
|||
|
|||
void test_TheFirstThingToTest(void); |
|||
void test_TheSecondThingToTest(void); |
|||
#endif |
|||
|
@ -0,0 +1,89 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
CMock_Init(); \ |
|||
UNITY_CLR_DETAILS(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
CEXCEPTION_T e; \ |
|||
Try { \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
CMock_Verify(); \ |
|||
} \ |
|||
CMock_Destroy(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "CException.h" |
|||
#include "one.h" |
|||
#include "two.h" |
|||
#include "funky.h" |
|||
#include <setjmp.h> |
|||
#include "Mockstanky.h" |
|||
|
|||
int GlobalExpectCount; |
|||
int GlobalVerifyOrder; |
|||
char* GlobalOrderError; |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
|
|||
|
|||
/*=======Mock Management=====*/ |
|||
static void CMock_Init(void) |
|||
{ |
|||
GlobalExpectCount = 0; |
|||
GlobalVerifyOrder = 0; |
|||
GlobalOrderError = NULL; |
|||
Mockstanky_Init(); |
|||
} |
|||
static void CMock_Verify(void) |
|||
{ |
|||
Mockstanky_Verify(); |
|||
} |
|||
static void CMock_Destroy(void) |
|||
{ |
|||
Mockstanky_Destroy(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
CMock_Verify(); |
|||
CMock_Destroy(); |
|||
tearDown(); |
|||
CMock_Init(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/mocksample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
|
|||
CMock_Guts_MemFreeFinal(); |
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,89 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
CMock_Init(); \ |
|||
UNITY_CLR_DETAILS(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
CMock_Verify(); \ |
|||
} \ |
|||
CMock_Destroy(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "funky.h" |
|||
#include <setjmp.h> |
|||
#include "Mockstanky.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
|
|||
|
|||
/*=======Mock Management=====*/ |
|||
static void CMock_Init(void) |
|||
{ |
|||
Mockstanky_Init(); |
|||
} |
|||
static void CMock_Verify(void) |
|||
{ |
|||
Mockstanky_Verify(); |
|||
} |
|||
static void CMock_Destroy(void) |
|||
{ |
|||
Mockstanky_Destroy(); |
|||
} |
|||
|
|||
/*=======Suite Setup=====*/ |
|||
static int suite_setup(void) |
|||
{ |
|||
a_custom_setup(); |
|||
} |
|||
|
|||
/*=======Suite Teardown=====*/ |
|||
static int suite_teardown(int num_failures) |
|||
{ |
|||
a_custom_teardown(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
CMock_Verify(); |
|||
CMock_Destroy(); |
|||
tearDown(); |
|||
CMock_Init(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
suite_setup(); |
|||
UnityBegin("testdata/mocksample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
|
|||
CMock_Guts_MemFreeFinal(); |
|||
return suite_teardown(UnityEnd()); |
|||
} |
@ -0,0 +1,77 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST_NO_ARGS |
|||
#define RUN_TEST(TestFunc, TestLineNum, ...) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc "(" #__VA_ARGS__ ")"; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
CMock_Init(); \ |
|||
UNITY_CLR_DETAILS(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(__VA_ARGS__); \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
CMock_Verify(); \ |
|||
} \ |
|||
CMock_Destroy(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "funky.h" |
|||
#include <setjmp.h> |
|||
#include "Mockstanky.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
|
|||
|
|||
/*=======Mock Management=====*/ |
|||
static void CMock_Init(void) |
|||
{ |
|||
Mockstanky_Init(); |
|||
} |
|||
static void CMock_Verify(void) |
|||
{ |
|||
Mockstanky_Verify(); |
|||
} |
|||
static void CMock_Destroy(void) |
|||
{ |
|||
Mockstanky_Destroy(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
CMock_Verify(); |
|||
CMock_Destroy(); |
|||
tearDown(); |
|||
CMock_Init(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/mocksample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21, RUN_TEST_NO_ARGS); |
|||
RUN_TEST(test_TheSecondThingToTest, 43, RUN_TEST_NO_ARGS); |
|||
|
|||
CMock_Guts_MemFreeFinal(); |
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,89 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
CMock_Init(); \ |
|||
UNITY_CLR_DETAILS(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
CEXCEPTION_T e; \ |
|||
Try { \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
CMock_Verify(); \ |
|||
} \ |
|||
CMock_Destroy(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "CException.h" |
|||
#include "one.h" |
|||
#include "two.h" |
|||
#include "funky.h" |
|||
#include <setjmp.h> |
|||
#include "Mockstanky.h" |
|||
|
|||
int GlobalExpectCount; |
|||
int GlobalVerifyOrder; |
|||
char* GlobalOrderError; |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
|
|||
|
|||
/*=======Mock Management=====*/ |
|||
static void CMock_Init(void) |
|||
{ |
|||
GlobalExpectCount = 0; |
|||
GlobalVerifyOrder = 0; |
|||
GlobalOrderError = NULL; |
|||
Mockstanky_Init(); |
|||
} |
|||
static void CMock_Verify(void) |
|||
{ |
|||
Mockstanky_Verify(); |
|||
} |
|||
static void CMock_Destroy(void) |
|||
{ |
|||
Mockstanky_Destroy(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
CMock_Verify(); |
|||
CMock_Destroy(); |
|||
tearDown(); |
|||
CMock_Init(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/mocksample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
|
|||
CMock_Guts_MemFreeFinal(); |
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,89 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
CMock_Init(); \ |
|||
UNITY_CLR_DETAILS(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
CMock_Verify(); \ |
|||
} \ |
|||
CMock_Destroy(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "funky.h" |
|||
#include <setjmp.h> |
|||
#include "Mockstanky.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
|
|||
|
|||
/*=======Mock Management=====*/ |
|||
static void CMock_Init(void) |
|||
{ |
|||
Mockstanky_Init(); |
|||
} |
|||
static void CMock_Verify(void) |
|||
{ |
|||
Mockstanky_Verify(); |
|||
} |
|||
static void CMock_Destroy(void) |
|||
{ |
|||
Mockstanky_Destroy(); |
|||
} |
|||
|
|||
/*=======Suite Setup=====*/ |
|||
static int suite_setup(void) |
|||
{ |
|||
a_custom_setup(); |
|||
} |
|||
|
|||
/*=======Suite Teardown=====*/ |
|||
static int suite_teardown(int num_failures) |
|||
{ |
|||
a_custom_teardown(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
CMock_Verify(); |
|||
CMock_Destroy(); |
|||
tearDown(); |
|||
CMock_Init(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
suite_setup(); |
|||
UnityBegin("testdata/mocksample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
|
|||
CMock_Guts_MemFreeFinal(); |
|||
return suite_teardown(UnityEnd()); |
|||
} |
@ -0,0 +1,90 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
CMock_Init(); \ |
|||
UNITY_CLR_DETAILS(); \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
CEXCEPTION_T e; \ |
|||
Try { \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
CMock_Verify(); \ |
|||
} \ |
|||
CMock_Destroy(); \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include "cmock.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "CException.h" |
|||
#include "two.h" |
|||
#include "three.h" |
|||
#include <four.h> |
|||
#include "funky.h" |
|||
#include <setjmp.h> |
|||
#include "Mockstanky.h" |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
|
|||
|
|||
/*=======Mock Management=====*/ |
|||
static void CMock_Init(void) |
|||
{ |
|||
Mockstanky_Init(); |
|||
} |
|||
static void CMock_Verify(void) |
|||
{ |
|||
Mockstanky_Verify(); |
|||
} |
|||
static void CMock_Destroy(void) |
|||
{ |
|||
Mockstanky_Destroy(); |
|||
} |
|||
|
|||
/*=======Suite Setup=====*/ |
|||
static int suite_setup(void) |
|||
{ |
|||
a_yaml_setup(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
CMock_Verify(); |
|||
CMock_Destroy(); |
|||
tearDown(); |
|||
CMock_Init(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
suite_setup(); |
|||
UnityBegin("testdata/mocksample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
|
|||
CMock_Guts_MemFreeFinal(); |
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,67 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
CEXCEPTION_T e; \ |
|||
Try { \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
} \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "CException.h" |
|||
#include "one.h" |
|||
#include "two.h" |
|||
#include "funky.h" |
|||
#include "stanky.h" |
|||
#include <setjmp.h> |
|||
|
|||
int GlobalExpectCount; |
|||
int GlobalVerifyOrder; |
|||
char* GlobalOrderError; |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
extern void test_TheThirdThingToTest(void); |
|||
extern void test_TheFourthThingToTest(void); |
|||
|
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
tearDown(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
UnityBegin("testdata/testsample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
RUN_TEST(test_TheThirdThingToTest, 53); |
|||
RUN_TEST(test_TheFourthThingToTest, 58); |
|||
|
|||
return (UnityEnd()); |
|||
} |
@ -0,0 +1,70 @@ |
|||
/* AUTOGENERATED FILE. DO NOT EDIT. */ |
|||
|
|||
/*=======Test Runner Used To Run Each Test Below=====*/ |
|||
#define RUN_TEST(TestFunc, TestLineNum) \ |
|||
{ \ |
|||
Unity.CurrentTestName = #TestFunc; \ |
|||
Unity.CurrentTestLineNumber = TestLineNum; \ |
|||
Unity.NumberOfTests++; \ |
|||
if (TEST_PROTECT()) \ |
|||
{ \ |
|||
setUp(); \ |
|||
TestFunc(); \ |
|||
} \ |
|||
if (TEST_PROTECT() && !TEST_IS_IGNORED) \ |
|||
{ \ |
|||
tearDown(); \ |
|||
} \ |
|||
UnityConcludeTest(); \ |
|||
} |
|||
|
|||
/*=======Automagically Detected Files To Include=====*/ |
|||
#include "unity.h" |
|||
#include <setjmp.h> |
|||
#include <stdio.h> |
|||
#include "funky.h" |
|||
#include "stanky.h" |
|||
#include <setjmp.h> |
|||
|
|||
/*=======External Functions This Runner Calls=====*/ |
|||
extern void setUp(void); |
|||
extern void tearDown(void); |
|||
extern void test_TheFirstThingToTest(void); |
|||
extern void test_TheSecondThingToTest(void); |
|||
extern void test_TheThirdThingToTest(void); |
|||
extern void test_TheFourthThingToTest(void); |
|||
|
|||
|
|||
/*=======Suite Setup=====*/ |
|||
static int suite_setup(void) |
|||
{ |
|||
a_custom_setup(); |
|||
} |
|||
|
|||
/*=======Suite Teardown=====*/ |
|||
static int suite_teardown(int num_failures) |
|||
{ |
|||
a_custom_teardown(); |
|||
} |
|||
|
|||
/*=======Test Reset Option=====*/ |
|||
void resetTest(void); |
|||
void resetTest(void) |
|||
{ |
|||
tearDown(); |
|||
setUp(); |
|||
} |
|||
|
|||
|
|||
/*=======MAIN=====*/ |
|||
int main(void) |
|||
{ |
|||
suite_setup(); |
|||
UnityBegin("testdata/testsample.c"); |
|||
RUN_TEST(test_TheFirstThingToTest, 21); |
|||
RUN_TEST(test_TheSecondThingToTest, 43); |
|||
RUN_TEST(test_TheThirdThingToTest, 53); |
|||
RUN_TEST(test_TheFourthThingToTest, 58); |
|||
|
|||
return suite_teardown(UnityEnd()); |
|||
} |
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue