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 |
.PHONY: runners |
||||
RM = rm -f |
.PHONY: clean |
||||
CFLAGS_DEBUG=-O0 -ggdb3 -Wall -Werror -pedantic -D_FORTIFY_SOURCE=2 -fasynchronous-unwind-tables -grecord-gcc-switches -Werror=implicit-function-declaration -I. |
.PHONY: test |
||||
CFLAGS=-O2 -Wall -Werror -pedantic -I. |
|
||||
|
|
||||
TESTS_SRC = $(wildcard test/*.c) |
PATHU = unity/src/ |
||||
EXECS_SRC = $(wildcard zaqar/*.c) |
PATHS = src/ |
||||
DEPS_SRC = $(wildcard lib/*.c) |
PATHT = test/ |
||||
|
PATHTR = test/runners/ |
||||
|
PATHL = lib/ |
||||
|
PATHB = build/ |
||||
|
PATHD = build/depends/ |
||||
|
PATHO = build/objs/ |
||||
|
PATHR = build/results/ |
||||
|
|
||||
DEPS_OBJ = $(DEPS_SRC:.c=.o) |
BUILD_PATHS = $(PATHB) $(PATHD) $(PATHO) $(PATHR) $(PATHL) |
||||
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) |
|
||||
|
|
||||
DEPS_TRACK = $(OBJ:.o=.d) |
RUNNERS = $(patsubst $(PATHT)%.c,$(PATHTR)%_Runner.c, $(wildcard $(PATHT)*.c)) |
||||
|
|
||||
TESTS = test/test_circ_buff |
runners: $(RUNNERS) test |
||||
EXECUTABLES = zaqar |
|
||||
|
|
||||
.PHONY: all |
SRCTR = $(wildcard $(PATHTR)*.c) |
||||
|
|
||||
all: $(TESTS) $(EXECUTABLES) |
COMPILE = gcc -c |
||||
execs: $(EXECUTABLES) |
LINK = gcc |
||||
tests: $(TESTS) |
DEPEND = gcc -MM -MG -MF |
||||
|
CFLAGS = -I. -I$(PATHU) -I$(PATHS) -I$(PATHL) -DTEST |
||||
|
|
||||
$(TESTS): $(TESTS_OBJ) |
CFLAGS += -std=c99 |
||||
$(CC) -o $@ $^ $(CFLAGS) |
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) |
RESULTS = $(patsubst $(PATHTR)test_%_Runner.c,$(PATHR)test_%.txt,$(SRCTR)) |
||||
$(CC) -o $@ $^ $(CFLAGS) |
|
||||
|
|
||||
-include $(DEPS_TRACK) |
PASSED = `grep -s PASS $(PATHR)*.txt` |
||||
|
FAIL = `grep -s FAIL $(PATHR)*.txt` |
||||
|
IGNORE = `grep -s IGNORE $(PATHR)*.txt` |
||||
|
|
||||
%.d: %.c |
test: $(BUILD_PATHS) $(RESULTS) |
||||
@$(CPP) $(CFLAGS) $< -MM -MT $(@:.d=.o) >$@ |
@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: |
clean: |
||||
rm -f $(ALL_OBJ) $(TESTS) $(EXECUTABLES) |
$(CLEANUP) $(PATHO)*.o |
||||
|
$(CLEANUP) $(PATHB)*.$(TARGET_EXTENSION) |
||||
|
$(CLEANUP) $(PATHR)*.txt |
||||
|
|
||||
.PHONY: cleandep |
.PRECIOUS: $(PATHB)test_%.$(TARGET_EXTENSION) |
||||
cleandep: |
.PRECIOUS: $(PATHD)%.d |
||||
rm -f $(DEPS_TRACK) |
.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