mirror of
https://github.com/Dominocs/Project_Cymple.git
synced 2025-11-04 14:49:40 +08:00
updatesoftware
This commit is contained in:
commit
7d69dab39a
32
eyeTracker/software/.gitignore
vendored
Normal file
32
eyeTracker/software/.gitignore
vendored
Normal file
@ -0,0 +1,32 @@
|
||||
# Prerequisites
|
||||
*.d
|
||||
|
||||
# Compiled Object files
|
||||
*.slo
|
||||
*.lo
|
||||
*.o
|
||||
*.obj
|
||||
|
||||
# Precompiled Headers
|
||||
*.gch
|
||||
*.pch
|
||||
|
||||
# Compiled Dynamic libraries
|
||||
*.so
|
||||
*.dylib
|
||||
*.dll
|
||||
|
||||
# Fortran module files
|
||||
*.mod
|
||||
*.smod
|
||||
|
||||
# Compiled Static libraries
|
||||
*.lai
|
||||
*.la
|
||||
*.a
|
||||
*.lib
|
||||
|
||||
# Executables
|
||||
*.exe
|
||||
*.out
|
||||
*.app
|
||||
BIN
eyeTracker/software/.pio/build/esp32-cam/.sconsign39.dblite
Normal file
BIN
eyeTracker/software/.pio/build/esp32-cam/.sconsign39.dblite
Normal file
Binary file not shown.
BIN
eyeTracker/software/.pio/build/esp32-cam/bootloader.bin
Normal file
BIN
eyeTracker/software/.pio/build/esp32-cam/bootloader.bin
Normal file
Binary file not shown.
BIN
eyeTracker/software/.pio/build/esp32-cam/firmware.bin
Normal file
BIN
eyeTracker/software/.pio/build/esp32-cam/firmware.bin
Normal file
Binary file not shown.
BIN
eyeTracker/software/.pio/build/esp32-cam/firmware.elf
Normal file
BIN
eyeTracker/software/.pio/build/esp32-cam/firmware.elf
Normal file
Binary file not shown.
98330
eyeTracker/software/.pio/build/esp32-cam/firmware.map
Normal file
98330
eyeTracker/software/.pio/build/esp32-cam/firmware.map
Normal file
File diff suppressed because one or more lines are too long
1
eyeTracker/software/.pio/build/esp32-cam/idedata.json
Normal file
1
eyeTracker/software/.pio/build/esp32-cam/idedata.json
Normal file
File diff suppressed because one or more lines are too long
BIN
eyeTracker/software/.pio/build/esp32-cam/partitions.bin
Normal file
BIN
eyeTracker/software/.pio/build/esp32-cam/partitions.bin
Normal file
Binary file not shown.
1
eyeTracker/software/.pio/build/project.checksum
Normal file
1
eyeTracker/software/.pio/build/project.checksum
Normal file
@ -0,0 +1 @@
|
||||
9c89819b7abf174b3208257e6fd4cfe19c79c217
|
||||
@ -0,0 +1 @@
|
||||
me-no-dev/AsyncTCP@^1.1.1
|
||||
@ -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
|
||||
31
eyeTracker/software/.pio/libdeps/featheresp32/Unity/.gitattributes
vendored
Normal file
31
eyeTracker/software/.pio/libdeps/featheresp32/Unity/.gitattributes
vendored
Normal file
@ -0,0 +1,31 @@
|
||||
* 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
|
||||
meson.build 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
|
||||
32
eyeTracker/software/.pio/libdeps/featheresp32/Unity/.github/workflows/main.yml
vendored
Normal file
32
eyeTracker/software/.pio/libdeps/featheresp32/Unity/.github/workflows/main.yml
vendored
Normal file
@ -0,0 +1,32 @@
|
||||
---
|
||||
# Continuous Integration Workflow: Test case suite run + validation build check
|
||||
name: CI
|
||||
|
||||
# Controls when the action will run.
|
||||
# Triggers the workflow on push or pull request events but only for the master branch
|
||||
on:
|
||||
push:
|
||||
branches: [ master ]
|
||||
pull_request:
|
||||
branches: [ master ]
|
||||
|
||||
jobs:
|
||||
# Job: Unit test suite
|
||||
unit-tests:
|
||||
name: "Unit Tests"
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
# Install Ruby Testing Tools
|
||||
- name: Setup Ruby Testing Tools
|
||||
run: |
|
||||
sudo gem install rspec
|
||||
sudo gem install rubocop -v 0.57.2
|
||||
|
||||
# Checks out repository under $GITHUB_WORKSPACE
|
||||
- name: Checkout Latest Repo
|
||||
uses: actions/checkout@v2
|
||||
|
||||
# Run Tests
|
||||
- name: Run All Unit Tests
|
||||
run: |
|
||||
cd test && rake ci
|
||||
13
eyeTracker/software/.pio/libdeps/featheresp32/Unity/.gitignore
vendored
Normal file
13
eyeTracker/software/.pio/libdeps/featheresp32/Unity/.gitignore
vendored
Normal file
@ -0,0 +1,13 @@
|
||||
build/
|
||||
builddir/
|
||||
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
|
||||
examples/example_4/builddir
|
||||
*.sublime-project
|
||||
*.sublime-workspace
|
||||
@ -0,0 +1 @@
|
||||
{"type": "library", "name": "Unity", "version": "2.5.2", "spec": {"owner": "throwtheswitch", "id": 13894, "name": "Unity", "requirements": null, "uri": null}}
|
||||
@ -0,0 +1,159 @@
|
||||
###################################################################################
|
||||
# #
|
||||
# NAME: CMakeLists.txt #
|
||||
# #
|
||||
# AUTHOR: Mike Karlesky, Mark VanderVoord, Greg Williams. #
|
||||
# WRITTEN BY: Michael Brockus. #
|
||||
# #
|
||||
# License: MIT #
|
||||
# #
|
||||
###################################################################################
|
||||
|
||||
cmake_minimum_required(VERSION 3.12)
|
||||
|
||||
# Read src/unity.h file and get project version from it
|
||||
set(UNITY_HEADER "src/unity.h")
|
||||
|
||||
file(STRINGS "${UNITY_HEADER}" UNITY_HEADER_CONTENT
|
||||
REGEX "^#define UNITY_VERSION_(MAJOR|MINOR|BUILD) +[0-9]+$"
|
||||
)
|
||||
|
||||
set(UNITY_HEADER_VERSION_MAJOR 0)
|
||||
set(UNITY_HEADER_VERSION_MINOR 0)
|
||||
set(UNITY_HEADER_VERSION_BUILD 0)
|
||||
|
||||
foreach(VERSION_LINE IN LISTS UNITY_HEADER_CONTENT)
|
||||
foreach(VERSION_PART MAJOR MINOR BUILD)
|
||||
string(CONCAT REGEX_STRING "#define UNITY_VERSION_"
|
||||
"${VERSION_PART}"
|
||||
" +([0-9]+)"
|
||||
)
|
||||
|
||||
if(VERSION_LINE MATCHES "${REGEX_STRING}")
|
||||
set(UNITY_HEADER_VERSION_${VERSION_PART} "${CMAKE_MATCH_1}")
|
||||
endif()
|
||||
endforeach()
|
||||
endforeach()
|
||||
|
||||
project(unity
|
||||
VERSION ${UNITY_HEADER_VERSION_MAJOR}.${UNITY_HEADER_VERSION_MINOR}.${UNITY_HEADER_VERSION_BUILD}
|
||||
LANGUAGES C
|
||||
DESCRIPTION "C Unit testing framework."
|
||||
)
|
||||
|
||||
# Options to Build With Extras -------------------------------------------------
|
||||
option(UNITY_EXTENSION_FIXTURE "Compiles Unity with the \"fixture\" extension." OFF)
|
||||
option(UNITY_EXTENSION_MEMORY "Compiles Unity with the \"memory\" extension." OFF)
|
||||
|
||||
set(UNITY_EXTENSION_FIXTURE_ENABLED $<BOOL:${UNITY_EXTENSION_FIXTURE}>)
|
||||
set(UNITY_EXTENSION_MEMORY_ENABLED $<OR:${UNITY_EXTENSION_FIXTURE_ENABLED},$<BOOL:${UNITY_EXTENSION_MEMORY}>>)
|
||||
|
||||
if(${UNITY_EXTENSION_FIXTURE})
|
||||
message(STATUS "Unity: Bulding with the fixture extension.")
|
||||
endif()
|
||||
|
||||
if(${UNITY_EXTENSION_MEMORY})
|
||||
message(STATUS "Unity: Bulding with the memory extension.")
|
||||
endif()
|
||||
|
||||
# Main target ------------------------------------------------------------------
|
||||
add_library(${PROJECT_NAME} STATIC)
|
||||
add_library(${PROJECT_NAME}::framework ALIAS ${PROJECT_NAME})
|
||||
|
||||
# Includes ---------------------------------------------------------------------
|
||||
include(GNUInstallDirs)
|
||||
include(CMakePackageConfigHelpers)
|
||||
|
||||
target_sources(${PROJECT_NAME}
|
||||
PRIVATE
|
||||
src/unity.c
|
||||
$<$<BOOL:${UNITY_EXTENSION_FIXTURE_ENABLED}>:extras/fixture/src/unity_fixture.c>
|
||||
$<$<BOOL:${UNITY_EXTENSION_MEMORY_ENABLED}>:extras/memory/src/unity_memory.c>
|
||||
)
|
||||
|
||||
target_include_directories(${PROJECT_NAME}
|
||||
PUBLIC
|
||||
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
|
||||
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
|
||||
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}>
|
||||
$<BUILD_INTERFACE:$<$<BOOL:${UNITY_EXTENSION_MEMORY_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/memory/src>>
|
||||
$<BUILD_INTERFACE:$<$<BOOL:${UNITY_EXTENSION_FIXTURE_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src>>
|
||||
)
|
||||
|
||||
set(${PROJECT_NAME}_PUBLIC_HEADERS
|
||||
src/unity.h
|
||||
src/unity_internals.h
|
||||
$<$<BOOL:${UNITY_EXTENSION_FIXTURE_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src/unity_fixture.h>
|
||||
$<$<BOOL:${UNITY_EXTENSION_FIXTURE_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/fixture/src/unity_fixture_internals.h>
|
||||
$<$<BOOL:${UNITY_EXTENSION_MEMORY_ENABLED}>:${CMAKE_CURRENT_SOURCE_DIR}/extras/memory/src/unity_memory.h>
|
||||
)
|
||||
|
||||
set_target_properties(${PROJECT_NAME}
|
||||
PROPERTIES
|
||||
C_STANDARD 11
|
||||
C_STANDARD_REQUIRED ON
|
||||
C_EXTENSIONS OFF
|
||||
PUBLIC_HEADER "${${PROJECT_NAME}_PUBLIC_HEADERS}"
|
||||
EXPORT_NAME framework
|
||||
)
|
||||
|
||||
target_compile_options(${PROJECT_NAME}
|
||||
PRIVATE
|
||||
$<$<C_COMPILER_ID:Clang>:-Wcast-align
|
||||
-Wcast-qual
|
||||
-Wconversion
|
||||
-Wexit-time-destructors
|
||||
-Wglobal-constructors
|
||||
-Wmissing-noreturn
|
||||
-Wmissing-prototypes
|
||||
-Wno-missing-braces
|
||||
-Wold-style-cast
|
||||
-Wshadow
|
||||
-Wweak-vtables
|
||||
-Werror
|
||||
-Wall>
|
||||
$<$<C_COMPILER_ID:GNU>:-Waddress
|
||||
-Waggregate-return
|
||||
-Wformat-nonliteral
|
||||
-Wformat-security
|
||||
-Wformat
|
||||
-Winit-self
|
||||
-Wmissing-declarations
|
||||
-Wmissing-include-dirs
|
||||
-Wno-multichar
|
||||
-Wno-parentheses
|
||||
-Wno-type-limits
|
||||
-Wno-unused-parameter
|
||||
-Wunreachable-code
|
||||
-Wwrite-strings
|
||||
-Wpointer-arith
|
||||
-Werror
|
||||
-Wall>
|
||||
$<$<C_COMPILER_ID:MSVC>:/Wall>
|
||||
)
|
||||
|
||||
write_basic_package_version_file(${PROJECT_NAME}ConfigVersion.cmake
|
||||
VERSION ${PROJECT_VERSION}
|
||||
COMPATIBILITY SameMajorVersion
|
||||
)
|
||||
|
||||
## Target installation
|
||||
install(TARGETS ${PROJECT_NAME}
|
||||
EXPORT ${PROJECT_NAME}Targets
|
||||
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
|
||||
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
|
||||
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}
|
||||
COMPONENT library
|
||||
)
|
||||
|
||||
## Target's cmake files: targets export
|
||||
install(EXPORT ${PROJECT_NAME}Targets
|
||||
NAMESPACE ${PROJECT_NAME}::
|
||||
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
|
||||
)
|
||||
|
||||
## Target's cmake files: config and version config for find_package()
|
||||
install(FILES ${PROJECT_NAME}Config.cmake
|
||||
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
|
||||
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
|
||||
)
|
||||
@ -0,0 +1,21 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) <year> 2007-21 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.
|
||||
200
eyeTracker/software/.pio/libdeps/featheresp32/Unity/README.md
Normal file
200
eyeTracker/software/.pio/libdeps/featheresp32/Unity/README.md
Normal file
@ -0,0 +1,200 @@
|
||||
Unity Test 
|
||||
==========
|
||||
__Copyright (c) 2007 - 2021 Unity Project by Mike Karlesky, Mark VanderVoord, and Greg Williams__
|
||||
|
||||
Welcome to the Unity Test Project, one of the main projects of ThrowTheSwitch.org. Unity Test is a
|
||||
unit testing framework built for C, with a focus on working with embedded toolchains.
|
||||
|
||||
This project is made to test code targetting microcontrollers big and small. The core project is a
|
||||
single C file and a pair of headers, allowing it to the added to your existing build setup without
|
||||
too much headache. You may use any compiler you wish, and may use most existing build systems
|
||||
including make, cmake, etc. If you'd like to leave the hard work to us, you might be interested
|
||||
in Ceedling, a build tool also by ThrowTheSwitch.org.
|
||||
|
||||
If you're new to Unity, we encourage you to tour the [getting started guide](docs/UnityGettingStartedGuide.md)
|
||||
|
||||
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,119 @@
|
||||
# ==========================================
|
||||
# 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,313 @@
|
||||
# ==========================================
|
||||
# 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 ||= '#ifdef TEST
|
||||
|
||||
#include "unity.h"
|
||||
|
||||
%2$s#include "%1$s.h"
|
||||
|
||||
void setUp(void)
|
||||
{
|
||||
}
|
||||
|
||||
void tearDown(void)
|
||||
{
|
||||
}
|
||||
|
||||
void test_%4$s_NeedToImplement(void)
|
||||
{
|
||||
TEST_IGNORE_MESSAGE("Need to Implement %1$s");
|
||||
}
|
||||
|
||||
#endif // TEST
|
||||
'.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 neutralize_filename(name, start_cap = true)
|
||||
return name if name.empty?
|
||||
name = name.split(/(?:\s+|_|(?=[A-Z][a-z]))|(?<=[a-z])(?=[A-Z])/).map { |v| v.capitalize }.join('_')
|
||||
name = name[0].downcase + name[1..-1] unless start_cap
|
||||
return name
|
||||
end
|
||||
|
||||
############################
|
||||
def create_filename(part1, part2 = '')
|
||||
name = part2.empty? ? part1 : part1 + '_' + part2
|
||||
case (@options[:naming])
|
||||
when 'bumpy' then neutralize_filename(name,false).delete('_')
|
||||
when 'camel' then neutralize_filename(name).delete('_')
|
||||
when 'snake' then neutralize_filename(name).downcase
|
||||
when 'caps' then neutralize_filename(name).upcase
|
||||
else name
|
||||
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.gsub(/-/, '_'),
|
||||
file[:name].gsub(/-/, '_')])
|
||||
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,511 @@
|
||||
# ==========================================
|
||||
# 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
|
||||
@options
|
||||
when String
|
||||
@options.merge!(UnityTestRunnerGenerator.grab_config(options))
|
||||
when Hash
|
||||
# Check if some of these have been specified
|
||||
@options[:has_setup] = !options[:setup_name].nil?
|
||||
@options[:has_teardown] = !options[:teardown_name].nil?
|
||||
@options[:has_suite_setup] = !options[:suite_setup].nil?
|
||||
@options[:has_suite_teardown] = !options[:suite_teardown].nil?
|
||||
@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',
|
||||
test_verify_name: 'verifyTest',
|
||||
main_name: 'main', # set to :auto to automatically generate each time
|
||||
main_export_decl: '',
|
||||
cmdline_args: false,
|
||||
omit_begin_end: false,
|
||||
use_param_tests: false,
|
||||
include_extensions: '(?:hpp|hh|H|h)',
|
||||
source_extensions: '(?:cpp|cc|ino|C|c)'
|
||||
}
|
||||
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)/ }
|
||||
find_setup_and_teardown(source)
|
||||
|
||||
# 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_setup(output)
|
||||
create_teardown(output)
|
||||
create_suite_setup(output)
|
||||
create_suite_teardown(output)
|
||||
create_reset(output)
|
||||
create_run_test(output) unless tests.empty?
|
||||
create_args_wrappers(output, tests)
|
||||
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 interfering 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 that comment out the start of blocks
|
||||
source_scrubbed = source_scrubbed.gsub(/\/\*.*?\*\//m, '') # remove block comments
|
||||
source_scrubbed = source_scrubbed.gsub(/\/\/.*$/, '') # remove line comments (all that remain)
|
||||
lines = source_scrubbed.split(/(^\s*\#.*$) | (;|\{|\}) /x) # Treat preprocessor directives as a logical line. 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|TEST_RANGE)\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] }
|
||||
|
||||
arguments.scan(/\s*TEST_RANGE\s*\((.*)\)\s*$/).flatten.each do |range_str|
|
||||
args += range_str.scan(/\[(-?\d+.?\d*), *(-?\d+.?\d*), *(-?\d+.?\d*)\]/).map do |arg_values_str|
|
||||
arg_values_str.map do |arg_value_str|
|
||||
arg_value_str.include?('.') ? arg_value_str.to_f : arg_value_str.to_i
|
||||
end
|
||||
end.map do |arg_values|
|
||||
(arg_values[0]..arg_values[1]).step(arg_values[2]).to_a
|
||||
end.reduce do |result, arg_range_expanded|
|
||||
result.product(arg_range_expanded)
|
||||
end.map do |arg_combinations|
|
||||
arg_combinations.flatten.join(', ')
|
||||
end
|
||||
end
|
||||
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*(.+\.#{@options[:include_extensions]})\s*\"/).flatten,
|
||||
system: source.scan(/^\s*#include\s+<\s*(.+)\s*>/).flatten.map { |inc| "<#{inc}>" },
|
||||
linkonly: source.scan(/^TEST_FILE\(\s*\"\s*(.+\.#{@options[:source_extensions]})\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]}\.h$/i
|
||||
end
|
||||
mock_headers
|
||||
end
|
||||
|
||||
def find_setup_and_teardown(source)
|
||||
@options[:has_setup] = source =~ /void\s+#{@options[:setup_name]}\s*\(/
|
||||
@options[:has_teardown] = source =~ /void\s+#{@options[:teardown_name]}\s*\(/
|
||||
@options[:has_suite_setup] ||= (source =~ /void\s+suiteSetUp\s*\(/)
|
||||
@options[:has_suite_teardown] ||= (source =~ /int\s+suiteTearDown\s*\(int\s+([a-zA-Z0-9_])+\s*\)/)
|
||||
end
|
||||
|
||||
def create_header(output, mocks, testfile_includes = [])
|
||||
output.puts('/* AUTOGENERATED FILE. DO NOT EDIT. */')
|
||||
output.puts("\n/*=======Automagically Detected Files To Include=====*/")
|
||||
output.puts("#include \"#{@options[:framework]}.h\"")
|
||||
output.puts('#include "cmock.h"') unless mocks.empty?
|
||||
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}\""}")
|
||||
end
|
||||
testfile_includes.each do |inc|
|
||||
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc}\""}")
|
||||
end
|
||||
end
|
||||
mocks.each do |mock|
|
||||
output.puts("#include \"#{mock}\"")
|
||||
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)
|
||||
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_setup(output)
|
||||
return if @options[:has_setup]
|
||||
|
||||
output.puts("\n/*=======Setup (stub)=====*/")
|
||||
output.puts("void #{@options[:setup_name]}(void) {}")
|
||||
end
|
||||
|
||||
def create_teardown(output)
|
||||
return if @options[:has_teardown]
|
||||
|
||||
output.puts("\n/*=======Teardown (stub)=====*/")
|
||||
output.puts("void #{@options[:teardown_name]}(void) {}")
|
||||
end
|
||||
|
||||
def create_suite_setup(output)
|
||||
return if @options[:suite_setup].nil?
|
||||
|
||||
output.puts("\n/*=======Suite Setup=====*/")
|
||||
output.puts('void suiteSetUp(void)')
|
||||
output.puts('{')
|
||||
output.puts(@options[:suite_setup])
|
||||
output.puts('}')
|
||||
end
|
||||
|
||||
def create_suite_teardown(output)
|
||||
return if @options[:suite_teardown].nil?
|
||||
|
||||
output.puts("\n/*=======Suite Teardown=====*/")
|
||||
output.puts('int suiteTearDown(int num_failures)')
|
||||
output.puts('{')
|
||||
output.puts(@options[:suite_teardown])
|
||||
output.puts('}')
|
||||
end
|
||||
|
||||
def create_reset(output)
|
||||
output.puts("\n/*=======Test Reset Options=====*/")
|
||||
output.puts("void #{@options[:test_reset_name]}(void);")
|
||||
output.puts("void #{@options[:test_reset_name]}(void)")
|
||||
output.puts('{')
|
||||
output.puts(" #{@options[:teardown_name]}();")
|
||||
output.puts(' CMock_Verify();')
|
||||
output.puts(' CMock_Destroy();')
|
||||
output.puts(' CMock_Init();')
|
||||
output.puts(" #{@options[:setup_name]}();")
|
||||
output.puts('}')
|
||||
output.puts("void #{@options[:test_verify_name]}(void);")
|
||||
output.puts("void #{@options[:test_verify_name]}(void)")
|
||||
output.puts('{')
|
||||
output.puts(' CMock_Verify();')
|
||||
output.puts('}')
|
||||
end
|
||||
|
||||
def create_run_test(output)
|
||||
require 'erb'
|
||||
template = ERB.new(File.read(File.join(__dir__, 'run_test.erb')), nil, '<>')
|
||||
output.puts("\n" + template.result(binding))
|
||||
end
|
||||
|
||||
def create_args_wrappers(output, tests)
|
||||
return unless @options[:use_param_tests]
|
||||
|
||||
output.puts("\n/*=======Parameterized Test Wrappers=====*/")
|
||||
tests.each do |test|
|
||||
next if test[:args].nil? || test[:args].empty?
|
||||
|
||||
test[:args].each.with_index(1) do |args, idx|
|
||||
output.puts("static void runner_args#{idx}_#{test[:test]}(void)")
|
||||
output.puts('{')
|
||||
output.puts(" #{test[:test]}(#{args});")
|
||||
output.puts("}\n")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def create_main(output, filename, tests, used_mocks)
|
||||
output.puts("\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();')
|
||||
tests.each do |test|
|
||||
if (!@options[:use_param_tests]) || test[:args].nil? || test[:args].empty?
|
||||
output.puts(" UnityPrint(\" #{test[:test]}\");")
|
||||
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
|
||||
output.puts(' return 0;')
|
||||
output.puts(' }')
|
||||
output.puts(' return parse_status;')
|
||||
output.puts(' }')
|
||||
else
|
||||
main_return = @options[:omit_begin_end] ? 'void' : 'int'
|
||||
if main_name != 'main'
|
||||
output.puts("#{@options[:main_export_decl]} #{main_return} #{main_name}(void);")
|
||||
end
|
||||
output.puts("#{main_return} #{main_name}(void)")
|
||||
output.puts('{')
|
||||
end
|
||||
output.puts(' suiteSetUp();') if @options[:has_suite_setup]
|
||||
if @options[:omit_begin_end]
|
||||
output.puts(" UnitySetTestFile(\"#{filename.gsub(/\\/, '\\\\\\')}\");")
|
||||
else
|
||||
output.puts(" UnityBegin(\"#{filename.gsub(/\\/, '\\\\\\')}\");")
|
||||
end
|
||||
tests.each do |test|
|
||||
if (!@options[:use_param_tests]) || test[:args].nil? || test[:args].empty?
|
||||
output.puts(" run_test(#{test[:test]}, \"#{test[:test]}\", #{test[:line_number]});")
|
||||
else
|
||||
test[:args].each.with_index(1) do |args, idx|
|
||||
wrapper = "runner_args#{idx}_#{test[:test]}"
|
||||
testname = "#{test[:test]}(#{args})".dump
|
||||
output.puts(" run_test(#{wrapper}, #{testname}, #{test[:line_number]});")
|
||||
end
|
||||
end
|
||||
end
|
||||
output.puts
|
||||
output.puts(' CMock_Guts_MemFreeFinal();') unless used_mocks.empty?
|
||||
if @options[:has_suite_teardown]
|
||||
if @options[:omit_begin_end]
|
||||
output.puts(' (void) suite_teardown(0);')
|
||||
else
|
||||
output.puts(' return suiteTearDown(UnityEnd());')
|
||||
end
|
||||
else
|
||||
output.puts(' return UnityEnd();') unless @options[:omit_begin_end]
|
||||
end
|
||||
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}\""}")
|
||||
end
|
||||
testfile_includes.each do |inc|
|
||||
output.puts("#include #{inc.include?('<') ? inc : "\"#{inc}\""}")
|
||||
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 /\.*\.(?:hpp|hh|H|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',
|
||||
' --test_verify_name="" - redefine verifyTest 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)',
|
||||
' --omit_begin_end=1 - omit calls to UnityBegin and UnityEnd (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,37 @@
|
||||
/*=======Test Runner Used To Run Each Test=====*/
|
||||
static void run_test(UnityTestFunction func, const char* name, UNITY_LINE_TYPE line_num)
|
||||
{
|
||||
Unity.CurrentTestName = name;
|
||||
Unity.CurrentTestLineNumber = line_num;
|
||||
#ifdef UNITY_USE_COMMAND_LINE_ARGS
|
||||
if (!UnityTestMatches())
|
||||
return;
|
||||
#endif
|
||||
Unity.NumberOfTests++;
|
||||
UNITY_CLR_DETAILS();
|
||||
UNITY_EXEC_TIME_START();
|
||||
CMock_Init();
|
||||
if (TEST_PROTECT())
|
||||
{
|
||||
<% if @options[:plugins].include?(:cexception) %>
|
||||
CEXCEPTION_T e;
|
||||
Try {
|
||||
<%= @options[:setup_name] %>();
|
||||
func();
|
||||
} Catch(e) {
|
||||
TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!");
|
||||
}
|
||||
<% else %>
|
||||
<%= @options[:setup_name] %>();
|
||||
func();
|
||||
<% end %>
|
||||
}
|
||||
if (TEST_PROTECT())
|
||||
{
|
||||
<%= @options[:teardown_name] %>();
|
||||
CMock_Verify();
|
||||
}
|
||||
CMock_Destroy();
|
||||
UNITY_EXEC_TIME_STOP();
|
||||
UnityConcludeTest();
|
||||
}
|
||||
@ -0,0 +1,251 @@
|
||||
#!/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,135 @@
|
||||
# ==========================================
|
||||
# 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,72 @@
|
||||
# ==========================================
|
||||
# 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
|
||||
#CFLAGS += -Wno-misleading-indentation
|
||||
|
||||
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,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=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
|
||||
#CFLAGS += -Wno-misleading-indentation
|
||||
|
||||
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=-DUNITY_FIXTURE_NO_EXTRAS
|
||||
|
||||
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,38 @@
|
||||
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
|
||||
|
||||
# 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,250 @@
|
||||
require 'yaml'
|
||||
require 'fileutils'
|
||||
require_relative '../../auto/unity_test_summary'
|
||||
require_relative '../../auto/generate_test_runner'
|
||||
require_relative '../../auto/colour_reporter'
|
||||
|
||||
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 !$?.nil? && !$?.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
|
||||
@ -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,12 @@
|
||||
#
|
||||
# build script written by : Michael Brockus.
|
||||
# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
|
||||
#
|
||||
# license: MIT
|
||||
#
|
||||
project('example-4', 'c')
|
||||
|
||||
unity_dep = dependency('unity', fallback : ['unity', 'unity_dep'])
|
||||
|
||||
subdir('src')
|
||||
subdir('test')
|
||||
@ -0,0 +1,15 @@
|
||||
Example 4
|
||||
=========
|
||||
|
||||
Close to the simplest possible example of Unity, using only basic features.
|
||||
to build this example run "meson setup <build dir name>".
|
||||
|
||||
Meson uses the Ninja build system to actually build the code. To start the
|
||||
build, simply type the following command.
|
||||
|
||||
"ninja -C <build dir name>"
|
||||
|
||||
Meson provides native support for running tests. The command to do that is simple.
|
||||
|
||||
"meson test -C <build dir name>".
|
||||
|
||||
@ -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,16 @@
|
||||
#
|
||||
# build script written by : Michael Brockus.
|
||||
# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
|
||||
#
|
||||
# license: MIT
|
||||
#
|
||||
inc_dir = include_directories('.')
|
||||
lib_list = {'a': ['ProductionCode.c' ], 'b': ['ProductionCode2.c']}
|
||||
|
||||
foreach lib, src : lib_list
|
||||
set_variable(lib + '_lib',
|
||||
static_library(lib + '_lib', sources: src, include_directories: inc_dir))
|
||||
endforeach
|
||||
|
||||
a_dep = declare_dependency(link_with: a_lib, include_directories: inc_dir)
|
||||
b_dep = declare_dependency(link_with: b_lib, include_directories: inc_dir)
|
||||
@ -0,0 +1,4 @@
|
||||
[wrap-git]
|
||||
directory = unity
|
||||
url = https://github.com/ThrowTheSwitch/Unity.git
|
||||
revision = head
|
||||
@ -0,0 +1,63 @@
|
||||
|
||||
#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,35 @@
|
||||
|
||||
#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);
|
||||
void test_AnotherIgnoredTest(void);
|
||||
void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(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,7 @@
|
||||
#
|
||||
# build script written by : Michael Brockus.
|
||||
# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
|
||||
#
|
||||
# license: MIT
|
||||
#
|
||||
subdir('test_runners')
|
||||
@ -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,13 @@
|
||||
#
|
||||
# build script written by : Michael Brockus.
|
||||
# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
|
||||
#
|
||||
# license: MIT
|
||||
#
|
||||
cases = [
|
||||
['TestProductionCode_Runner.c', join_paths('..' ,'TestProductionCode.c' )],
|
||||
['TestProductionCode2_Runner.c', join_paths('..' ,'TestProductionCode2.c')]
|
||||
]
|
||||
|
||||
test('Running: 01-test-case', executable('01-test-case', cases[0], dependencies: [ a_dep, unity_dep ]))
|
||||
test('Running: 02-test-case', executable('02-test-case', cases[1], dependencies: [ b_dep, unity_dep ]))
|
||||
@ -0,0 +1,244 @@
|
||||
/* 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 macro:
|
||||
* "TEST_PRINTF"
|
||||
*/
|
||||
/* #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() */
|
||||
|
||||
/* 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,18 @@
|
||||
{
|
||||
"name": "Unity",
|
||||
"version": "2.5.2",
|
||||
"keywords": "unit-testing, testing, tdd, testing-framework",
|
||||
"description": "Simple Unit Testing for C",
|
||||
"homepage": "http://www.throwtheswitch.org/unity",
|
||||
"license": "MIT",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/ThrowTheSwitch/Unity.git"
|
||||
},
|
||||
"frameworks": "*",
|
||||
"platforms": "*",
|
||||
"headers": "unity.h",
|
||||
"build": {
|
||||
"extraScript": "platformio-build.py"
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,14 @@
|
||||
#
|
||||
# build script written by : Michael Brockus.
|
||||
# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
|
||||
#
|
||||
# license: MIT
|
||||
#
|
||||
project('unity', 'c',
|
||||
license: 'MIT',
|
||||
meson_version: '>=0.53.0',
|
||||
default_options: ['werror=true', 'c_std=c11']
|
||||
)
|
||||
|
||||
subdir('src')
|
||||
unity_dep = declare_dependency(link_with: unity_lib, include_directories: unity_dir)
|
||||
@ -0,0 +1,16 @@
|
||||
import os
|
||||
|
||||
Import("env")
|
||||
|
||||
env.Append(CPPDEFINES=["UNITY_INCLUDE_CONFIG_H"])
|
||||
|
||||
# import "unity_config.h" folder to the library builder
|
||||
try:
|
||||
Import("projenv")
|
||||
|
||||
for p in projenv["CPPPATH"]:
|
||||
p = projenv.subst(p)
|
||||
if os.path.isfile(os.path.join(p, "unity_config.h")):
|
||||
env.Prepend(CPPPATH=[p])
|
||||
except:
|
||||
pass
|
||||
@ -0,0 +1,11 @@
|
||||
#
|
||||
# build script written by : Michael Brockus.
|
||||
# github repo author: Mike Karlesky, Mark VanderVoord, Greg Williams.
|
||||
#
|
||||
# license: MIT
|
||||
#
|
||||
unity_dir = include_directories('.')
|
||||
|
||||
unity_lib = static_library(meson.project_name(),
|
||||
files('unity.c'),
|
||||
include_directories: unity_dir)
|
||||
2108
eyeTracker/software/.pio/libdeps/featheresp32/Unity/src/unity.c
Normal file
2108
eyeTracker/software/.pio/libdeps/featheresp32/Unity/src/unity.c
Normal file
File diff suppressed because it is too large
Load Diff
661
eyeTracker/software/.pio/libdeps/featheresp32/Unity/src/unity.h
Normal file
661
eyeTracker/software/.pio/libdeps/featheresp32/Unity/src/unity.h
Normal file
@ -0,0 +1,661 @@
|
||||
/* ==========================================
|
||||
Unity Project - A Test Framework for C
|
||||
Copyright (c) 2007-21 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
|
||||
|
||||
#define UNITY_VERSION_MAJOR 2
|
||||
#define UNITY_VERSION_MINOR 5
|
||||
#define UNITY_VERSION_BUILD 2
|
||||
#define UNITY_VERSION ((UNITY_VERSION_MAJOR << 16) | (UNITY_VERSION_MINOR << 8) | UNITY_VERSION_BUILD)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include "unity_internals.h"
|
||||
|
||||
/*-------------------------------------------------------
|
||||
* Test Setup / Teardown
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
/* These functions are intended to be called before and after each test.
|
||||
* If using unity directly, these will need to be provided for each test
|
||||
* executable built. If you are using the test runner generator and/or
|
||||
* Ceedling, these are optional. */
|
||||
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(). If using
|
||||
* Unity directly, you're in charge of calling these if they are desired.
|
||||
* If using Ceedling or the test runner generator, these will be called
|
||||
* automatically if they exist. */
|
||||
void suiteSetUp(void);
|
||||
int suiteTearDown(int num_failures);
|
||||
|
||||
/*-------------------------------------------------------
|
||||
* Test Reset and Verify
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
/* These functions are intended to be called before during tests in order
|
||||
* to support complex test loops, etc. Both are NOT built into Unity. Instead
|
||||
* the test runner generator will create them. resetTest will run teardown and
|
||||
* setup again, verifying any end-of-test needs between. verifyTest will only
|
||||
* run the verification. */
|
||||
void resetTest(void);
|
||||
void verifyTest(void);
|
||||
|
||||
/*-------------------------------------------------------
|
||||
* 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_MESSAGE(message) UnityMessage((message), __LINE__)
|
||||
#define TEST_ONLY()
|
||||
#ifdef UNITY_INCLUDE_PRINT_FORMATTED
|
||||
#define TEST_PRINTF(message, ...) UnityPrintF(__LINE__, (message), __VA_ARGS__)
|
||||
#endif
|
||||
|
||||
/* 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()
|
||||
#define TEST_PASS_MESSAGE(message) do { UnityMessage((message), __LINE__); TEST_ABORT(); } while(0)
|
||||
|
||||
/* 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")
|
||||
#define TEST_ASSERT_EMPTY(pointer) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, " Expected Empty")
|
||||
#define TEST_ASSERT_NOT_EMPTY(pointer) UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, " Expected Non-Empty")
|
||||
|
||||
/* 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_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_size_t(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT((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_EQUAL_CHAR(expected, actual) UNITY_TEST_ASSERT_EQUAL_CHAR((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_UINT)(-1), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(0), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(-1), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(0), (actual), __LINE__, NULL)
|
||||
|
||||
/* Integer Not Equal To (of all sizes) */
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (actual), __LINE__, NULL)
|
||||
|
||||
/* Integer Greater Than/ Less Than (of all sizes) */
|
||||
#define TEST_ASSERT_GREATER_THAN(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_GREATER_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL)
|
||||
#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_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((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_GREATER_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((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_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((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_LESS_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((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_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((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_GREATER_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((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_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((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)
|
||||
#define TEST_ASSERT_LESS_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((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_size_t_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_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)
|
||||
#define TEST_ASSERT_CHAR_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_CHAR_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_size_t_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_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)
|
||||
#define TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_CHAR_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_size_t_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_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)
|
||||
#define TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (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_size_t(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((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)
|
||||
#define TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (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)
|
||||
|
||||
/* Shorthand */
|
||||
#ifdef UNITY_SHORTHAND_AS_OLD
|
||||
#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")
|
||||
#endif
|
||||
#ifdef UNITY_SHORTHAND_AS_INT
|
||||
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
|
||||
#endif
|
||||
#ifdef UNITY_SHORTHAND_AS_MEM
|
||||
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, NULL)
|
||||
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
|
||||
#endif
|
||||
#ifdef UNITY_SHORTHAND_AS_RAW
|
||||
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, " Expected Equal")
|
||||
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal")
|
||||
#endif
|
||||
#ifdef UNITY_SHORTHAND_AS_NONE
|
||||
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
|
||||
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
|
||||
#endif
|
||||
|
||||
/*-------------------------------------------------------
|
||||
* 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))
|
||||
#define TEST_ASSERT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_EMPTY((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_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_size_t_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (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))
|
||||
#define TEST_ASSERT_EQUAL_CHAR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, (message))
|
||||
|
||||
/* Integer Not Equal To (of all sizes) */
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_NOT_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (actual), __LINE__, (message))
|
||||
|
||||
|
||||
/* Integer Greater Than/ Less Than (of all sizes) */
|
||||
#define TEST_ASSERT_GREATER_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message))
|
||||
#define TEST_ASSERT_GREATER_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message))
|
||||
#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_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((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_GREATER_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((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_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((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_LESS_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((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_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((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_GREATER_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((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_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((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))
|
||||
#define TEST_ASSERT_LESS_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((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_size_t_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_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))
|
||||
#define TEST_ASSERT_CHAR_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_CHAR_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_size_t_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_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))
|
||||
#define TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_CHAR_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_size_t_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_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))
|
||||
#define TEST_ASSERT_EQUAL_CHAR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (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_size_t_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((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))
|
||||
#define TEST_ASSERT_EACH_EQUAL_CHAR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (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))
|
||||
|
||||
/* Shorthand */
|
||||
#ifdef UNITY_SHORTHAND_AS_OLD
|
||||
#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))
|
||||
#endif
|
||||
#ifdef UNITY_SHORTHAND_AS_INT
|
||||
#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_FAIL(__LINE__, UnityStrErrShorthand)
|
||||
#endif
|
||||
#ifdef UNITY_SHORTHAND_AS_MEM
|
||||
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, message)
|
||||
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
|
||||
#endif
|
||||
#ifdef UNITY_SHORTHAND_AS_RAW
|
||||
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, message)
|
||||
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, message)
|
||||
#endif
|
||||
#ifdef UNITY_SHORTHAND_AS_NONE
|
||||
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
|
||||
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand)
|
||||
#endif
|
||||
|
||||
/* end of UNITY_FRAMEWORK_H */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1 @@
|
||||
include(${CMAKE_CURRENT_LIST_DIR}/unityTargets.cmake)
|
||||
501
eyeTracker/software/.vscode/c_cpp_properties.json
vendored
Normal file
501
eyeTracker/software/.vscode/c_cpp_properties.json
vendored
Normal file
@ -0,0 +1,501 @@
|
||||
//
|
||||
// !!! WARNING !!! AUTO-GENERATED FILE!
|
||||
// PLEASE DO NOT MODIFY IT AND USE "platformio.ini":
|
||||
// https://docs.platformio.org/page/projectconf/section_env_build.html#build-flags
|
||||
//
|
||||
{
|
||||
"configurations": [
|
||||
{
|
||||
"name": "PlatformIO",
|
||||
"includePath": [
|
||||
"E:/Project_Cymple/cympleFace_Esp/include",
|
||||
"E:/Project_Cymple/cympleFace_Esp/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/AsyncUDP/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/WiFi/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/EEPROM/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/newlib/platform_include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freertos/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freertos/include/esp_additions/freertos",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freertos/port/xtensa/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freertos/include/esp_additions",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/include/soc",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/include/soc/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/port/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/port/esp32/private_include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/heap/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/log/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/include/apps",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/include/apps/sntp",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/lwip/src/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/port/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/port/esp32/include/arch",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/soc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/soc/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/soc/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/hal/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/hal/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/hal/platform_port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_rom/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_rom/include/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_rom/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_system/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_system/port/soc",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_system/port/public_compat",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/xtensa/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/xtensa/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/driver/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/driver/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_pm/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_ringbuf/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/efuse/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/efuse/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/vfs/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_wifi/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_event/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_netif/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_eth/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/tcpip_adapter/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_phy/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_phy/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_ipc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/app_trace/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_timer/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mbedtls/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mbedtls/mbedtls/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mbedtls/esp_crt_bundle/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/app_update/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/spi_flash/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bootloader_support/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/nvs_flash/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/pthread/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_gdbstub/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_gdbstub/xtensa",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_gdbstub/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espcoredump/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espcoredump/include/port/xtensa",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wpa_supplicant/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wpa_supplicant/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wpa_supplicant/esp_supplicant/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/ieee802154/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/console",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/asio/asio/asio/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/asio/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/common/osi/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/include/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/common/api/include/api",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/common/btc/profile/esp/blufi/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/common/btc/profile/esp/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/host/bluedroid/api/include/api",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_common/tinycrypt/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_core",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_core/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_core/storage",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/btc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_models/common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_models/client/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_models/server/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/api/core/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/api/models/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/api",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/cbor/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/unity/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/unity/unity/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/cmock/CMock/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/coap/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/coap/libcoap/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/nghttp/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/nghttp/nghttp2/lib/includes",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-tls",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-tls/esp-tls-crypto",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_adc_cal/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hid/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/tcp_transport/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_http_client/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_http_server/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_https_ota/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_https_server/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_lcd/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_lcd/interface",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/protobuf-c/protobuf-c",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/protocomm/include/common",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/protocomm/include/security",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/protocomm/include/transports",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mdns/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_local_ctrl/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/sdmmc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_serial_slave_link/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_websocket_client/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/expat/expat/expat/lib",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/expat/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wear_levelling/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/fatfs/diskio",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/fatfs/vfs",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/fatfs/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freemodbus/freemodbus/common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/idf_test/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/idf_test/include/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/jsmn/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/json/cJSON",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/libsodium/libsodium/src/libsodium/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/libsodium/port_include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mqtt/esp-mqtt/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/openssl/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/perfmon/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/spiffs/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/ulp/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wifi_provisioning/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/rmaker_common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_diagnostics/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/rtc_store/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_insights/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/json_parser/upstream/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/json_parser/upstream",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/json_generator/upstream",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_schedule/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp_secure_cert_mgr/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_rainmaker/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/gpio_button/button/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/qrcode/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/ws2812_led",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_littlefs/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/tool",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/typedef",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/image",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/math",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/nn",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/layer",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/detect",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/model_zoo",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp32-camera/driver/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp32-camera/conversions/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/dotprod/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/support/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/support/mem/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/hann/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/blackman/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/blackman_harris/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/blackman_nuttall/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/nuttall/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/flat_top/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/iir/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/fir/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/add/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/sub/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/mul/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/addc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/mulc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/sqrt/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/matrix/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/fft/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/dct/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/conv/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/kalman/ekf/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/kalman/ekf_imu13states/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/fb_gfx/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/dio_qspi/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/cores/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/variants/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/ArduinoOTA/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/BLE/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/BluetoothSerial/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/DNSServer/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/ESP32/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/ESPmDNS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Ethernet/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/FFat/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/FS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/HTTPClient/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/HTTPUpdate/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/HTTPUpdateServer/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/I2S/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Insights/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/LittleFS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/NetBIOS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Preferences/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/RainMaker/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SD/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SD_MMC/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SPI/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SPIFFS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SimpleBLE/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Ticker/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/USB/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Update/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/WebServer/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/WiFiClientSecure/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/WiFiProv/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Wire/src",
|
||||
""
|
||||
],
|
||||
"browse": {
|
||||
"limitSymbolsToIncludedHeaders": true,
|
||||
"path": [
|
||||
"E:/Project_Cymple/cympleFace_Esp/include",
|
||||
"E:/Project_Cymple/cympleFace_Esp/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/AsyncUDP/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/WiFi/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/EEPROM/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/newlib/platform_include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freertos/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freertos/include/esp_additions/freertos",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freertos/port/xtensa/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freertos/include/esp_additions",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/include/soc",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/include/soc/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/port/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hw_support/port/esp32/private_include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/heap/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/log/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/include/apps",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/include/apps/sntp",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/lwip/src/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/port/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/lwip/port/esp32/include/arch",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/soc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/soc/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/soc/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/hal/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/hal/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/hal/platform_port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_rom/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_rom/include/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_rom/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_system/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_system/port/soc",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_system/port/public_compat",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/xtensa/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/xtensa/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/driver/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/driver/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_pm/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_ringbuf/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/efuse/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/efuse/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/vfs/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_wifi/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_event/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_netif/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_eth/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/tcpip_adapter/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_phy/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_phy/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_ipc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/app_trace/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_timer/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mbedtls/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mbedtls/mbedtls/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mbedtls/esp_crt_bundle/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/app_update/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/spi_flash/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bootloader_support/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/nvs_flash/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/pthread/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_gdbstub/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_gdbstub/xtensa",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_gdbstub/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espcoredump/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espcoredump/include/port/xtensa",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wpa_supplicant/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wpa_supplicant/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wpa_supplicant/esp_supplicant/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/ieee802154/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/console",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/asio/asio/asio/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/asio/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/common/osi/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/include/esp32/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/common/api/include/api",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/common/btc/profile/esp/blufi/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/common/btc/profile/esp/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/host/bluedroid/api/include/api",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_common/tinycrypt/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_core",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_core/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_core/storage",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/btc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_models/common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_models/client/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/mesh_models/server/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/api/core/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/api/models/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/bt/esp_ble_mesh/api",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/cbor/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/unity/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/unity/unity/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/cmock/CMock/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/coap/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/coap/libcoap/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/nghttp/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/nghttp/nghttp2/lib/includes",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-tls",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-tls/esp-tls-crypto",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_adc_cal/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_hid/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/tcp_transport/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_http_client/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_http_server/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_https_ota/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_https_server/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_lcd/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_lcd/interface",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/protobuf-c/protobuf-c",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/protocomm/include/common",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/protocomm/include/security",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/protocomm/include/transports",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mdns/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_local_ctrl/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/sdmmc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_serial_slave_link/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_websocket_client/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/expat/expat/expat/lib",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/expat/port/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wear_levelling/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/fatfs/diskio",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/fatfs/vfs",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/fatfs/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/freemodbus/freemodbus/common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/idf_test/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/idf_test/include/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/jsmn/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/json/cJSON",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/libsodium/libsodium/src/libsodium/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/libsodium/port_include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/mqtt/esp-mqtt/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/openssl/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/perfmon/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/spiffs/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/ulp/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/wifi_provisioning/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/rmaker_common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_diagnostics/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/rtc_store/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_insights/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/json_parser/upstream/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/json_parser/upstream",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/json_generator/upstream",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_schedule/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp_secure_cert_mgr/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_rainmaker/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/gpio_button/button/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/qrcode/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/ws2812_led",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp_littlefs/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/tool",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/typedef",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/image",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/math",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/nn",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/layer",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/detect",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp-dl/include/model_zoo",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp32-camera/driver/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/esp32-camera/conversions/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/dotprod/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/support/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/support/mem/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/hann/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/blackman/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/blackman_harris/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/blackman_nuttall/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/nuttall/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/windows/flat_top/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/iir/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/fir/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/add/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/sub/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/mul/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/addc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/mulc/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/math/sqrt/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/matrix/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/fft/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/dct/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/conv/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/common/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/kalman/ekf/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/espressif__esp-dsp/modules/kalman/ekf_imu13states/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/include/fb_gfx/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/tools/sdk/esp32/dio_qspi/include",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/cores/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/variants/esp32",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/ArduinoOTA/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/BLE/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/BluetoothSerial/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/DNSServer/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/ESP32/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/ESPmDNS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Ethernet/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/FFat/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/FS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/HTTPClient/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/HTTPUpdate/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/HTTPUpdateServer/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/I2S/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Insights/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/LittleFS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/NetBIOS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Preferences/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/RainMaker/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SD/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SD_MMC/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SPI/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SPIFFS/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/SimpleBLE/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Ticker/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/USB/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Update/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/WebServer/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/WiFiClientSecure/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/WiFiProv/src",
|
||||
"C:/Users/Administrator/.platformio/packages/framework-arduinoespressif32/libraries/Wire/src",
|
||||
""
|
||||
]
|
||||
},
|
||||
"defines": [
|
||||
"PLATFORMIO=60111",
|
||||
"ARDUINO_ESP32_DEV",
|
||||
"BOARD_HAS_PSRAM",
|
||||
"HAVE_CONFIG_H",
|
||||
"MBEDTLS_CONFIG_FILE=\"mbedtls/esp_config.h\"",
|
||||
"UNITY_INCLUDE_CONFIG_H",
|
||||
"WITH_POSIX",
|
||||
"_GNU_SOURCE",
|
||||
"IDF_VER=\"v4.4.5\"",
|
||||
"ESP_PLATFORM",
|
||||
"_POSIX_READER_WRITER_LOCKS",
|
||||
"ARDUINO_ARCH_ESP32",
|
||||
"ESP32",
|
||||
"F_CPU=240000000L",
|
||||
"ARDUINO=10812",
|
||||
"ARDUINO_VARIANT=\"esp32\"",
|
||||
"ARDUINO_BOARD=\"AI Thinker ESP32-CAM\"",
|
||||
"ARDUINO_PARTITION_default",
|
||||
""
|
||||
],
|
||||
"cStandard": "gnu99",
|
||||
"cppStandard": "gnu++11",
|
||||
"compilerPath": "C:/Users/Administrator/.platformio/packages/toolchain-xtensa-esp32@8.4.0+2021r2-patch5/bin/xtensa-esp32-elf-gcc.exe",
|
||||
"compilerArgs": [
|
||||
"-mfix-esp32-psram-cache-issue",
|
||||
"-mlongcalls",
|
||||
""
|
||||
]
|
||||
}
|
||||
],
|
||||
"version": 4
|
||||
}
|
||||
10
eyeTracker/software/.vscode/extensions.json
vendored
Normal file
10
eyeTracker/software/.vscode/extensions.json
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
{
|
||||
// See http://go.microsoft.com/fwlink/?LinkId=827846
|
||||
// for the documentation about the extensions.json format
|
||||
"recommendations": [
|
||||
"platformio.platformio-ide"
|
||||
],
|
||||
"unwantedRecommendations": [
|
||||
"ms-vscode.cpptools-extension-pack"
|
||||
]
|
||||
}
|
||||
44
eyeTracker/software/.vscode/launch.json
vendored
Normal file
44
eyeTracker/software/.vscode/launch.json
vendored
Normal file
@ -0,0 +1,44 @@
|
||||
// AUTOMATICALLY GENERATED FILE. PLEASE DO NOT MODIFY IT MANUALLY
|
||||
//
|
||||
// PIO Unified Debugger
|
||||
//
|
||||
// Documentation: https://docs.platformio.org/page/plus/debugging.html
|
||||
// Configuration: https://docs.platformio.org/page/projectconf/section_env_debug.html
|
||||
|
||||
{
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
"type": "platformio-debug",
|
||||
"request": "launch",
|
||||
"name": "PIO Debug",
|
||||
"executable": "E:/Project_Cymple/cympleFace_Esp/.pio/build/esp32-cam/firmware.elf",
|
||||
"projectEnvName": "esp32-cam",
|
||||
"toolchainBinDir": "C:/Users/Administrator/.platformio/packages/toolchain-xtensa-esp32@8.4.0+2021r2-patch5/bin",
|
||||
"internalConsoleOptions": "openOnSessionStart",
|
||||
"preLaunchTask": {
|
||||
"type": "PlatformIO",
|
||||
"task": "Pre-Debug"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "platformio-debug",
|
||||
"request": "launch",
|
||||
"name": "PIO Debug (skip Pre-Debug)",
|
||||
"executable": "E:/Project_Cymple/cympleFace_Esp/.pio/build/esp32-cam/firmware.elf",
|
||||
"projectEnvName": "esp32-cam",
|
||||
"toolchainBinDir": "C:/Users/Administrator/.platformio/packages/toolchain-xtensa-esp32@8.4.0+2021r2-patch5/bin",
|
||||
"internalConsoleOptions": "openOnSessionStart"
|
||||
},
|
||||
{
|
||||
"type": "platformio-debug",
|
||||
"request": "launch",
|
||||
"name": "PIO Debug (without uploading)",
|
||||
"executable": "E:/Project_Cymple/cympleFace_Esp/.pio/build/esp32-cam/firmware.elf",
|
||||
"projectEnvName": "esp32-cam",
|
||||
"toolchainBinDir": "C:/Users/Administrator/.platformio/packages/toolchain-xtensa-esp32@8.4.0+2021r2-patch5/bin",
|
||||
"internalConsoleOptions": "openOnSessionStart",
|
||||
"loadMode": "manual"
|
||||
}
|
||||
]
|
||||
}
|
||||
5
eyeTracker/software/.vscode/settings.json
vendored
Normal file
5
eyeTracker/software/.vscode/settings.json
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
{
|
||||
"files.associations": {
|
||||
"new": "cpp"
|
||||
}
|
||||
}
|
||||
674
eyeTracker/software/LICENSE
Normal file
674
eyeTracker/software/LICENSE
Normal file
@ -0,0 +1,674 @@
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The GNU General Public License is a free, copyleft license for
|
||||
software and other kinds of works.
|
||||
|
||||
The licenses for most software and other practical works are designed
|
||||
to take away your freedom to share and change the works. By contrast,
|
||||
the GNU General Public License is intended to guarantee your freedom to
|
||||
share and change all versions of a program--to make sure it remains free
|
||||
software for all its users. We, the Free Software Foundation, use the
|
||||
GNU General Public License for most of our software; it applies also to
|
||||
any other work released this way by its authors. You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
them if you wish), that you receive source code or can get it if you
|
||||
want it, that you can change the software or use pieces of it in new
|
||||
free programs, and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to prevent others from denying you
|
||||
these rights or asking you to surrender the rights. Therefore, you have
|
||||
certain responsibilities if you distribute copies of the software, or if
|
||||
you modify it: responsibilities to respect the freedom of others.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must pass on to the recipients the same
|
||||
freedoms that you received. You must make sure that they, too, receive
|
||||
or can get the source code. And you must show them these terms so they
|
||||
know their rights.
|
||||
|
||||
Developers that use the GNU GPL protect your rights with two steps:
|
||||
(1) assert copyright on the software, and (2) offer you this License
|
||||
giving you legal permission to copy, distribute and/or modify it.
|
||||
|
||||
For the developers' and authors' protection, the GPL clearly explains
|
||||
that there is no warranty for this free software. For both users' and
|
||||
authors' sake, the GPL requires that modified versions be marked as
|
||||
changed, so that their problems will not be attributed erroneously to
|
||||
authors of previous versions.
|
||||
|
||||
Some devices are designed to deny users access to install or run
|
||||
modified versions of the software inside them, although the manufacturer
|
||||
can do so. This is fundamentally incompatible with the aim of
|
||||
protecting users' freedom to change the software. The systematic
|
||||
pattern of such abuse occurs in the area of products for individuals to
|
||||
use, which is precisely where it is most unacceptable. Therefore, we
|
||||
have designed this version of the GPL to prohibit the practice for those
|
||||
products. If such problems arise substantially in other domains, we
|
||||
stand ready to extend this provision to those domains in future versions
|
||||
of the GPL, as needed to protect the freedom of users.
|
||||
|
||||
Finally, every program is threatened constantly by software patents.
|
||||
States should not allow patents to restrict development and use of
|
||||
software on general-purpose computers, but in those that do, we wish to
|
||||
avoid the special danger that patents applied to a free program could
|
||||
make it effectively proprietary. To prevent this, the GPL assures that
|
||||
patents cannot be used to render the program non-free.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
TERMS AND CONDITIONS
|
||||
|
||||
0. Definitions.
|
||||
|
||||
"This License" refers to version 3 of the GNU General Public License.
|
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of
|
||||
works, such as semiconductor masks.
|
||||
|
||||
"The Program" refers to any copyrightable work licensed under this
|
||||
License. Each licensee is addressed as "you". "Licensees" and
|
||||
"recipients" may be individuals or organizations.
|
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work
|
||||
in a fashion requiring copyright permission, other than the making of an
|
||||
exact copy. The resulting work is called a "modified version" of the
|
||||
earlier work or a work "based on" the earlier work.
|
||||
|
||||
A "covered work" means either the unmodified Program or a work based
|
||||
on the Program.
|
||||
|
||||
To "propagate" a work means to do anything with it that, without
|
||||
permission, would make you directly or secondarily liable for
|
||||
infringement under applicable copyright law, except executing it on a
|
||||
computer or modifying a private copy. Propagation includes copying,
|
||||
distribution (with or without modification), making available to the
|
||||
public, and in some countries other activities as well.
|
||||
|
||||
To "convey" a work means any kind of propagation that enables other
|
||||
parties to make or receive copies. Mere interaction with a user through
|
||||
a computer network, with no transfer of a copy, is not conveying.
|
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices"
|
||||
to the extent that it includes a convenient and prominently visible
|
||||
feature that (1) displays an appropriate copyright notice, and (2)
|
||||
tells the user that there is no warranty for the work (except to the
|
||||
extent that warranties are provided), that licensees may convey the
|
||||
work under this License, and how to view a copy of this License. If
|
||||
the interface presents a list of user commands or options, such as a
|
||||
menu, a prominent item in the list meets this criterion.
|
||||
|
||||
1. Source Code.
|
||||
|
||||
The "source code" for a work means the preferred form of the work
|
||||
for making modifications to it. "Object code" means any non-source
|
||||
form of a work.
|
||||
|
||||
A "Standard Interface" means an interface that either is an official
|
||||
standard defined by a recognized standards body, or, in the case of
|
||||
interfaces specified for a particular programming language, one that
|
||||
is widely used among developers working in that language.
|
||||
|
||||
The "System Libraries" of an executable work include anything, other
|
||||
than the work as a whole, that (a) is included in the normal form of
|
||||
packaging a Major Component, but which is not part of that Major
|
||||
Component, and (b) serves only to enable use of the work with that
|
||||
Major Component, or to implement a Standard Interface for which an
|
||||
implementation is available to the public in source code form. A
|
||||
"Major Component", in this context, means a major essential component
|
||||
(kernel, window system, and so on) of the specific operating system
|
||||
(if any) on which the executable work runs, or a compiler used to
|
||||
produce the work, or an object code interpreter used to run it.
|
||||
|
||||
The "Corresponding Source" for a work in object code form means all
|
||||
the source code needed to generate, install, and (for an executable
|
||||
work) run the object code and to modify the work, including scripts to
|
||||
control those activities. However, it does not include the work's
|
||||
System Libraries, or general-purpose tools or generally available free
|
||||
programs which are used unmodified in performing those activities but
|
||||
which are not part of the work. For example, Corresponding Source
|
||||
includes interface definition files associated with source files for
|
||||
the work, and the source code for shared libraries and dynamically
|
||||
linked subprograms that the work is specifically designed to require,
|
||||
such as by intimate data communication or control flow between those
|
||||
subprograms and other parts of the work.
|
||||
|
||||
The Corresponding Source need not include anything that users
|
||||
can regenerate automatically from other parts of the Corresponding
|
||||
Source.
|
||||
|
||||
The Corresponding Source for a work in source code form is that
|
||||
same work.
|
||||
|
||||
2. Basic Permissions.
|
||||
|
||||
All rights granted under this License are granted for the term of
|
||||
copyright on the Program, and are irrevocable provided the stated
|
||||
conditions are met. This License explicitly affirms your unlimited
|
||||
permission to run the unmodified Program. The output from running a
|
||||
covered work is covered by this License only if the output, given its
|
||||
content, constitutes a covered work. This License acknowledges your
|
||||
rights of fair use or other equivalent, as provided by copyright law.
|
||||
|
||||
You may make, run and propagate covered works that you do not
|
||||
convey, without conditions so long as your license otherwise remains
|
||||
in force. You may convey covered works to others for the sole purpose
|
||||
of having them make modifications exclusively for you, or provide you
|
||||
with facilities for running those works, provided that you comply with
|
||||
the terms of this License in conveying all material for which you do
|
||||
not control copyright. Those thus making or running the covered works
|
||||
for you must do so exclusively on your behalf, under your direction
|
||||
and control, on terms that prohibit them from making any copies of
|
||||
your copyrighted material outside their relationship with you.
|
||||
|
||||
Conveying under any other circumstances is permitted solely under
|
||||
the conditions stated below. Sublicensing is not allowed; section 10
|
||||
makes it unnecessary.
|
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
||||
|
||||
No covered work shall be deemed part of an effective technological
|
||||
measure under any applicable law fulfilling obligations under article
|
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
||||
similar laws prohibiting or restricting circumvention of such
|
||||
measures.
|
||||
|
||||
When you convey a covered work, you waive any legal power to forbid
|
||||
circumvention of technological measures to the extent such circumvention
|
||||
is effected by exercising rights under this License with respect to
|
||||
the covered work, and you disclaim any intention to limit operation or
|
||||
modification of the work as a means of enforcing, against the work's
|
||||
users, your or third parties' legal rights to forbid circumvention of
|
||||
technological measures.
|
||||
|
||||
4. Conveying Verbatim Copies.
|
||||
|
||||
You may convey verbatim copies of the Program's source code as you
|
||||
receive it, in any medium, provided that you conspicuously and
|
||||
appropriately publish on each copy an appropriate copyright notice;
|
||||
keep intact all notices stating that this License and any
|
||||
non-permissive terms added in accord with section 7 apply to the code;
|
||||
keep intact all notices of the absence of any warranty; and give all
|
||||
recipients a copy of this License along with the Program.
|
||||
|
||||
You may charge any price or no price for each copy that you convey,
|
||||
and you may offer support or warranty protection for a fee.
|
||||
|
||||
5. Conveying Modified Source Versions.
|
||||
|
||||
You may convey a work based on the Program, or the modifications to
|
||||
produce it from the Program, in the form of source code under the
|
||||
terms of section 4, provided that you also meet all of these conditions:
|
||||
|
||||
a) The work must carry prominent notices stating that you modified
|
||||
it, and giving a relevant date.
|
||||
|
||||
b) The work must carry prominent notices stating that it is
|
||||
released under this License and any conditions added under section
|
||||
7. This requirement modifies the requirement in section 4 to
|
||||
"keep intact all notices".
|
||||
|
||||
c) You must license the entire work, as a whole, under this
|
||||
License to anyone who comes into possession of a copy. This
|
||||
License will therefore apply, along with any applicable section 7
|
||||
additional terms, to the whole of the work, and all its parts,
|
||||
regardless of how they are packaged. This License gives no
|
||||
permission to license the work in any other way, but it does not
|
||||
invalidate such permission if you have separately received it.
|
||||
|
||||
d) If the work has interactive user interfaces, each must display
|
||||
Appropriate Legal Notices; however, if the Program has interactive
|
||||
interfaces that do not display Appropriate Legal Notices, your
|
||||
work need not make them do so.
|
||||
|
||||
A compilation of a covered work with other separate and independent
|
||||
works, which are not by their nature extensions of the covered work,
|
||||
and which are not combined with it such as to form a larger program,
|
||||
in or on a volume of a storage or distribution medium, is called an
|
||||
"aggregate" if the compilation and its resulting copyright are not
|
||||
used to limit the access or legal rights of the compilation's users
|
||||
beyond what the individual works permit. Inclusion of a covered work
|
||||
in an aggregate does not cause this License to apply to the other
|
||||
parts of the aggregate.
|
||||
|
||||
6. Conveying Non-Source Forms.
|
||||
|
||||
You may convey a covered work in object code form under the terms
|
||||
of sections 4 and 5, provided that you also convey the
|
||||
machine-readable Corresponding Source under the terms of this License,
|
||||
in one of these ways:
|
||||
|
||||
a) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by the
|
||||
Corresponding Source fixed on a durable physical medium
|
||||
customarily used for software interchange.
|
||||
|
||||
b) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by a
|
||||
written offer, valid for at least three years and valid for as
|
||||
long as you offer spare parts or customer support for that product
|
||||
model, to give anyone who possesses the object code either (1) a
|
||||
copy of the Corresponding Source for all the software in the
|
||||
product that is covered by this License, on a durable physical
|
||||
medium customarily used for software interchange, for a price no
|
||||
more than your reasonable cost of physically performing this
|
||||
conveying of source, or (2) access to copy the
|
||||
Corresponding Source from a network server at no charge.
|
||||
|
||||
c) Convey individual copies of the object code with a copy of the
|
||||
written offer to provide the Corresponding Source. This
|
||||
alternative is allowed only occasionally and noncommercially, and
|
||||
only if you received the object code with such an offer, in accord
|
||||
with subsection 6b.
|
||||
|
||||
d) Convey the object code by offering access from a designated
|
||||
place (gratis or for a charge), and offer equivalent access to the
|
||||
Corresponding Source in the same way through the same place at no
|
||||
further charge. You need not require recipients to copy the
|
||||
Corresponding Source along with the object code. If the place to
|
||||
copy the object code is a network server, the Corresponding Source
|
||||
may be on a different server (operated by you or a third party)
|
||||
that supports equivalent copying facilities, provided you maintain
|
||||
clear directions next to the object code saying where to find the
|
||||
Corresponding Source. Regardless of what server hosts the
|
||||
Corresponding Source, you remain obligated to ensure that it is
|
||||
available for as long as needed to satisfy these requirements.
|
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided
|
||||
you inform other peers where the object code and Corresponding
|
||||
Source of the work are being offered to the general public at no
|
||||
charge under subsection 6d.
|
||||
|
||||
A separable portion of the object code, whose source code is excluded
|
||||
from the Corresponding Source as a System Library, need not be
|
||||
included in conveying the object code work.
|
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any
|
||||
tangible personal property which is normally used for personal, family,
|
||||
or household purposes, or (2) anything designed or sold for incorporation
|
||||
into a dwelling. In determining whether a product is a consumer product,
|
||||
doubtful cases shall be resolved in favor of coverage. For a particular
|
||||
product received by a particular user, "normally used" refers to a
|
||||
typical or common use of that class of product, regardless of the status
|
||||
of the particular user or of the way in which the particular user
|
||||
actually uses, or expects or is expected to use, the product. A product
|
||||
is a consumer product regardless of whether the product has substantial
|
||||
commercial, industrial or non-consumer uses, unless such uses represent
|
||||
the only significant mode of use of the product.
|
||||
|
||||
"Installation Information" for a User Product means any methods,
|
||||
procedures, authorization keys, or other information required to install
|
||||
and execute modified versions of a covered work in that User Product from
|
||||
a modified version of its Corresponding Source. The information must
|
||||
suffice to ensure that the continued functioning of the modified object
|
||||
code is in no case prevented or interfered with solely because
|
||||
modification has been made.
|
||||
|
||||
If you convey an object code work under this section in, or with, or
|
||||
specifically for use in, a User Product, and the conveying occurs as
|
||||
part of a transaction in which the right of possession and use of the
|
||||
User Product is transferred to the recipient in perpetuity or for a
|
||||
fixed term (regardless of how the transaction is characterized), the
|
||||
Corresponding Source conveyed under this section must be accompanied
|
||||
by the Installation Information. But this requirement does not apply
|
||||
if neither you nor any third party retains the ability to install
|
||||
modified object code on the User Product (for example, the work has
|
||||
been installed in ROM).
|
||||
|
||||
The requirement to provide Installation Information does not include a
|
||||
requirement to continue to provide support service, warranty, or updates
|
||||
for a work that has been modified or installed by the recipient, or for
|
||||
the User Product in which it has been modified or installed. Access to a
|
||||
network may be denied when the modification itself materially and
|
||||
adversely affects the operation of the network or violates the rules and
|
||||
protocols for communication across the network.
|
||||
|
||||
Corresponding Source conveyed, and Installation Information provided,
|
||||
in accord with this section must be in a format that is publicly
|
||||
documented (and with an implementation available to the public in
|
||||
source code form), and must require no special password or key for
|
||||
unpacking, reading or copying.
|
||||
|
||||
7. Additional Terms.
|
||||
|
||||
"Additional permissions" are terms that supplement the terms of this
|
||||
License by making exceptions from one or more of its conditions.
|
||||
Additional permissions that are applicable to the entire Program shall
|
||||
be treated as though they were included in this License, to the extent
|
||||
that they are valid under applicable law. If additional permissions
|
||||
apply only to part of the Program, that part may be used separately
|
||||
under those permissions, but the entire Program remains governed by
|
||||
this License without regard to the additional permissions.
|
||||
|
||||
When you convey a copy of a covered work, you may at your option
|
||||
remove any additional permissions from that copy, or from any part of
|
||||
it. (Additional permissions may be written to require their own
|
||||
removal in certain cases when you modify the work.) You may place
|
||||
additional permissions on material, added by you to a covered work,
|
||||
for which you have or can give appropriate copyright permission.
|
||||
|
||||
Notwithstanding any other provision of this License, for material you
|
||||
add to a covered work, you may (if authorized by the copyright holders of
|
||||
that material) supplement the terms of this License with terms:
|
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the
|
||||
terms of sections 15 and 16 of this License; or
|
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or
|
||||
author attributions in that material or in the Appropriate Legal
|
||||
Notices displayed by works containing it; or
|
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or
|
||||
requiring that modified versions of such material be marked in
|
||||
reasonable ways as different from the original version; or
|
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or
|
||||
authors of the material; or
|
||||
|
||||
e) Declining to grant rights under trademark law for use of some
|
||||
trade names, trademarks, or service marks; or
|
||||
|
||||
f) Requiring indemnification of licensors and authors of that
|
||||
material by anyone who conveys the material (or modified versions of
|
||||
it) with contractual assumptions of liability to the recipient, for
|
||||
any liability that these contractual assumptions directly impose on
|
||||
those licensors and authors.
|
||||
|
||||
All other non-permissive additional terms are considered "further
|
||||
restrictions" within the meaning of section 10. If the Program as you
|
||||
received it, or any part of it, contains a notice stating that it is
|
||||
governed by this License along with a term that is a further
|
||||
restriction, you may remove that term. If a license document contains
|
||||
a further restriction but permits relicensing or conveying under this
|
||||
License, you may add to a covered work material governed by the terms
|
||||
of that license document, provided that the further restriction does
|
||||
not survive such relicensing or conveying.
|
||||
|
||||
If you add terms to a covered work in accord with this section, you
|
||||
must place, in the relevant source files, a statement of the
|
||||
additional terms that apply to those files, or a notice indicating
|
||||
where to find the applicable terms.
|
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the
|
||||
form of a separately written license, or stated as exceptions;
|
||||
the above requirements apply either way.
|
||||
|
||||
8. Termination.
|
||||
|
||||
You may not propagate or modify a covered work except as expressly
|
||||
provided under this License. Any attempt otherwise to propagate or
|
||||
modify it is void, and will automatically terminate your rights under
|
||||
this License (including any patent licenses granted under the third
|
||||
paragraph of section 11).
|
||||
|
||||
However, if you cease all violation of this License, then your
|
||||
license from a particular copyright holder is reinstated (a)
|
||||
provisionally, unless and until the copyright holder explicitly and
|
||||
finally terminates your license, and (b) permanently, if the copyright
|
||||
holder fails to notify you of the violation by some reasonable means
|
||||
prior to 60 days after the cessation.
|
||||
|
||||
Moreover, your license from a particular copyright holder is
|
||||
reinstated permanently if the copyright holder notifies you of the
|
||||
violation by some reasonable means, this is the first time you have
|
||||
received notice of violation of this License (for any work) from that
|
||||
copyright holder, and you cure the violation prior to 30 days after
|
||||
your receipt of the notice.
|
||||
|
||||
Termination of your rights under this section does not terminate the
|
||||
licenses of parties who have received copies or rights from you under
|
||||
this License. If your rights have been terminated and not permanently
|
||||
reinstated, you do not qualify to receive new licenses for the same
|
||||
material under section 10.
|
||||
|
||||
9. Acceptance Not Required for Having Copies.
|
||||
|
||||
You are not required to accept this License in order to receive or
|
||||
run a copy of the Program. Ancillary propagation of a covered work
|
||||
occurring solely as a consequence of using peer-to-peer transmission
|
||||
to receive a copy likewise does not require acceptance. However,
|
||||
nothing other than this License grants you permission to propagate or
|
||||
modify any covered work. These actions infringe copyright if you do
|
||||
not accept this License. Therefore, by modifying or propagating a
|
||||
covered work, you indicate your acceptance of this License to do so.
|
||||
|
||||
10. Automatic Licensing of Downstream Recipients.
|
||||
|
||||
Each time you convey a covered work, the recipient automatically
|
||||
receives a license from the original licensors, to run, modify and
|
||||
propagate that work, subject to this License. You are not responsible
|
||||
for enforcing compliance by third parties with this License.
|
||||
|
||||
An "entity transaction" is a transaction transferring control of an
|
||||
organization, or substantially all assets of one, or subdividing an
|
||||
organization, or merging organizations. If propagation of a covered
|
||||
work results from an entity transaction, each party to that
|
||||
transaction who receives a copy of the work also receives whatever
|
||||
licenses to the work the party's predecessor in interest had or could
|
||||
give under the previous paragraph, plus a right to possession of the
|
||||
Corresponding Source of the work from the predecessor in interest, if
|
||||
the predecessor has it or can get it with reasonable efforts.
|
||||
|
||||
You may not impose any further restrictions on the exercise of the
|
||||
rights granted or affirmed under this License. For example, you may
|
||||
not impose a license fee, royalty, or other charge for exercise of
|
||||
rights granted under this License, and you may not initiate litigation
|
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that
|
||||
any patent claim is infringed by making, using, selling, offering for
|
||||
sale, or importing the Program or any portion of it.
|
||||
|
||||
11. Patents.
|
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this
|
||||
License of the Program or a work on which the Program is based. The
|
||||
work thus licensed is called the contributor's "contributor version".
|
||||
|
||||
A contributor's "essential patent claims" are all patent claims
|
||||
owned or controlled by the contributor, whether already acquired or
|
||||
hereafter acquired, that would be infringed by some manner, permitted
|
||||
by this License, of making, using, or selling its contributor version,
|
||||
but do not include claims that would be infringed only as a
|
||||
consequence of further modification of the contributor version. For
|
||||
purposes of this definition, "control" includes the right to grant
|
||||
patent sublicenses in a manner consistent with the requirements of
|
||||
this License.
|
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free
|
||||
patent license under the contributor's essential patent claims, to
|
||||
make, use, sell, offer for sale, import and otherwise run, modify and
|
||||
propagate the contents of its contributor version.
|
||||
|
||||
In the following three paragraphs, a "patent license" is any express
|
||||
agreement or commitment, however denominated, not to enforce a patent
|
||||
(such as an express permission to practice a patent or covenant not to
|
||||
sue for patent infringement). To "grant" such a patent license to a
|
||||
party means to make such an agreement or commitment not to enforce a
|
||||
patent against the party.
|
||||
|
||||
If you convey a covered work, knowingly relying on a patent license,
|
||||
and the Corresponding Source of the work is not available for anyone
|
||||
to copy, free of charge and under the terms of this License, through a
|
||||
publicly available network server or other readily accessible means,
|
||||
then you must either (1) cause the Corresponding Source to be so
|
||||
available, or (2) arrange to deprive yourself of the benefit of the
|
||||
patent license for this particular work, or (3) arrange, in a manner
|
||||
consistent with the requirements of this License, to extend the patent
|
||||
license to downstream recipients. "Knowingly relying" means you have
|
||||
actual knowledge that, but for the patent license, your conveying the
|
||||
covered work in a country, or your recipient's use of the covered work
|
||||
in a country, would infringe one or more identifiable patents in that
|
||||
country that you have reason to believe are valid.
|
||||
|
||||
If, pursuant to or in connection with a single transaction or
|
||||
arrangement, you convey, or propagate by procuring conveyance of, a
|
||||
covered work, and grant a patent license to some of the parties
|
||||
receiving the covered work authorizing them to use, propagate, modify
|
||||
or convey a specific copy of the covered work, then the patent license
|
||||
you grant is automatically extended to all recipients of the covered
|
||||
work and works based on it.
|
||||
|
||||
A patent license is "discriminatory" if it does not include within
|
||||
the scope of its coverage, prohibits the exercise of, or is
|
||||
conditioned on the non-exercise of one or more of the rights that are
|
||||
specifically granted under this License. You may not convey a covered
|
||||
work if you are a party to an arrangement with a third party that is
|
||||
in the business of distributing software, under which you make payment
|
||||
to the third party based on the extent of your activity of conveying
|
||||
the work, and under which the third party grants, to any of the
|
||||
parties who would receive the covered work from you, a discriminatory
|
||||
patent license (a) in connection with copies of the covered work
|
||||
conveyed by you (or copies made from those copies), or (b) primarily
|
||||
for and in connection with specific products or compilations that
|
||||
contain the covered work, unless you entered into that arrangement,
|
||||
or that patent license was granted, prior to 28 March 2007.
|
||||
|
||||
Nothing in this License shall be construed as excluding or limiting
|
||||
any implied license or other defenses to infringement that may
|
||||
otherwise be available to you under applicable patent law.
|
||||
|
||||
12. No Surrender of Others' Freedom.
|
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot convey a
|
||||
covered work so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you may
|
||||
not convey it at all. For example, if you agree to terms that obligate you
|
||||
to collect a royalty for further conveying from those to whom you convey
|
||||
the Program, the only way you could satisfy both those terms and this
|
||||
License would be to refrain entirely from conveying the Program.
|
||||
|
||||
13. Use with the GNU Affero General Public License.
|
||||
|
||||
Notwithstanding any other provision of this License, you have
|
||||
permission to link or combine any covered work with a work licensed
|
||||
under version 3 of the GNU Affero General Public License into a single
|
||||
combined work, and to convey the resulting work. The terms of this
|
||||
License will continue to apply to the part which is the covered work,
|
||||
but the special requirements of the GNU Affero General Public License,
|
||||
section 13, concerning interaction through a network will apply to the
|
||||
combination as such.
|
||||
|
||||
14. Revised Versions of this License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of
|
||||
the GNU General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Program specifies that a certain numbered version of the GNU General
|
||||
Public License "or any later version" applies to it, you have the
|
||||
option of following the terms and conditions either of that numbered
|
||||
version or of any later version published by the Free Software
|
||||
Foundation. If the Program does not specify a version number of the
|
||||
GNU General Public License, you may choose any version ever published
|
||||
by the Free Software Foundation.
|
||||
|
||||
If the Program specifies that a proxy can decide which future
|
||||
versions of the GNU General Public License can be used, that proxy's
|
||||
public statement of acceptance of a version permanently authorizes you
|
||||
to choose that version for the Program.
|
||||
|
||||
Later license versions may give you additional or different
|
||||
permissions. However, no additional obligations are imposed on any
|
||||
author or copyright holder as a result of your choosing to follow a
|
||||
later version.
|
||||
|
||||
15. Disclaimer of Warranty.
|
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. Limitation of Liability.
|
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGES.
|
||||
|
||||
17. Interpretation of Sections 15 and 16.
|
||||
|
||||
If the disclaimer of warranty and limitation of liability provided
|
||||
above cannot be given local legal effect according to their terms,
|
||||
reviewing courts shall apply local law that most closely approximates
|
||||
an absolute waiver of all civil liability in connection with the
|
||||
Program, unless a warranty or assumption of liability accompanies a
|
||||
copy of the Program in return for a fee.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
state the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program does terminal interaction, make it output a short
|
||||
notice like this when it starts in an interactive mode:
|
||||
|
||||
<program> Copyright (C) <year> <name of author>
|
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, your program's commands
|
||||
might be different; for a GUI interface, you would use an "about box".
|
||||
|
||||
You should also get your employer (if you work as a programmer) or school,
|
||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
For more information on this, and how to apply and follow the GNU GPL, see
|
||||
<https://www.gnu.org/licenses/>.
|
||||
|
||||
The GNU General Public License does not permit incorporating your program
|
||||
into proprietary programs. If your program is a subroutine library, you
|
||||
may consider it more useful to permit linking proprietary applications with
|
||||
the library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License. But first, please read
|
||||
<https://www.gnu.org/licenses/why-not-lgpl.html>.
|
||||
39
eyeTracker/software/include/README
Normal file
39
eyeTracker/software/include/README
Normal file
@ -0,0 +1,39 @@
|
||||
|
||||
This directory is intended for project header files.
|
||||
|
||||
A header file is a file containing C declarations and macro definitions
|
||||
to be shared between several project source files. You request the use of a
|
||||
header file in your project source file (C, C++, etc) located in `src` folder
|
||||
by including it, with the C preprocessing directive `#include'.
|
||||
|
||||
```src/main.c
|
||||
|
||||
#include "header.h"
|
||||
|
||||
int main (void)
|
||||
{
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
Including a header file produces the same results as copying the header file
|
||||
into each source file that needs it. Such copying would be time-consuming
|
||||
and error-prone. With a header file, the related declarations appear
|
||||
in only one place. If they need to be changed, they can be changed in one
|
||||
place, and programs that include the header file will automatically use the
|
||||
new version when next recompiled. The header file eliminates the labor of
|
||||
finding and changing all the copies as well as the risk that a failure to
|
||||
find one copy will result in inconsistencies within a program.
|
||||
|
||||
In C, the usual convention is to give header files names that end with `.h'.
|
||||
It is most portable to use only letters, digits, dashes, and underscores in
|
||||
header file names, and at most one dot.
|
||||
|
||||
Read more about using header files in official GCC documentation:
|
||||
|
||||
* Include Syntax
|
||||
* Include Operation
|
||||
* Once-Only Headers
|
||||
* Computed Includes
|
||||
|
||||
https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html
|
||||
46
eyeTracker/software/lib/README
Normal file
46
eyeTracker/software/lib/README
Normal file
@ -0,0 +1,46 @@
|
||||
|
||||
This directory is intended for project specific (private) libraries.
|
||||
PlatformIO will compile them to static libraries and link into executable file.
|
||||
|
||||
The source code of each library should be placed in a an own separate directory
|
||||
("lib/your_library_name/[here are source files]").
|
||||
|
||||
For example, see a structure of the following two libraries `Foo` and `Bar`:
|
||||
|
||||
|--lib
|
||||
| |
|
||||
| |--Bar
|
||||
| | |--docs
|
||||
| | |--examples
|
||||
| | |--src
|
||||
| | |- Bar.c
|
||||
| | |- Bar.h
|
||||
| | |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
|
||||
| |
|
||||
| |--Foo
|
||||
| | |- Foo.c
|
||||
| | |- Foo.h
|
||||
| |
|
||||
| |- README --> THIS FILE
|
||||
|
|
||||
|- platformio.ini
|
||||
|--src
|
||||
|- main.c
|
||||
|
||||
and a contents of `src/main.c`:
|
||||
```
|
||||
#include <Foo.h>
|
||||
#include <Bar.h>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
...
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
PlatformIO Library Dependency Finder will find automatically dependent
|
||||
libraries scanning project source files.
|
||||
|
||||
More information about PlatformIO Library Dependency Finder
|
||||
- https://docs.platformio.org/page/librarymanager/ldf.html
|
||||
15
eyeTracker/software/platformio.ini
Normal file
15
eyeTracker/software/platformio.ini
Normal file
@ -0,0 +1,15 @@
|
||||
; PlatformIO Project Configuration File
|
||||
;
|
||||
; Build options: build flags, source filter
|
||||
; Upload options: custom upload port, speed and extra flags
|
||||
; Library options: dependencies, extra library storages
|
||||
; Advanced options: extra scripting
|
||||
;
|
||||
; Please visit documentation for the other options and examples
|
||||
; https://docs.platformio.org/page/projectconf.html
|
||||
|
||||
[env:esp32-cam]
|
||||
platform = espressif32 @~6.4.0
|
||||
framework = arduino
|
||||
board = esp32cam
|
||||
; build_flags = -DBOARD_HAS_PSRAM -mfix-esp32-psram-cache-issue
|
||||
19
eyeTracker/software/src/battery/battery.cpp
Normal file
19
eyeTracker/software/src/battery/battery.cpp
Normal file
@ -0,0 +1,19 @@
|
||||
#include <Arduino.h>
|
||||
#include "battery.h"
|
||||
#include "../config.h"
|
||||
|
||||
batteryClass *pbattery = NULL;
|
||||
void batteryClass::updateBattery()
|
||||
{
|
||||
unsigned long currentTime = millis();
|
||||
if(currentTime - ulTimer > BATTERY_UPDATE_TIME){
|
||||
int sensorValue = analogRead(BATTERY_PIN);
|
||||
float battery = (float)sensorValue / BATEERY_ADC_MAX; //分压电压
|
||||
battery = battery / BATTERY_DOT; //电源实际电压
|
||||
battery = battery < BATTERY_MAX?battery:BATTERY_MAX;
|
||||
battery = battery > BATTERY_MIN?battery:BATTERY_MIN;
|
||||
ucBattery = ceil((battery - BATTERY_MIN) / (BATTERY_MAX - BATTERY_MIN) * 100);
|
||||
ulTimer = currentTime;
|
||||
}
|
||||
}
|
||||
|
||||
15
eyeTracker/software/src/battery/battery.h
Normal file
15
eyeTracker/software/src/battery/battery.h
Normal file
@ -0,0 +1,15 @@
|
||||
#ifndef _BATTERY_H
|
||||
#define _BATTERY_H
|
||||
#include <Arduino.h>
|
||||
class batteryClass{
|
||||
private:
|
||||
unsigned long ulTimer = 0;
|
||||
uint8_t ucBattery = 0;
|
||||
public:
|
||||
void updateBattery();
|
||||
uint8_t getBattery(){
|
||||
return ucBattery;
|
||||
}
|
||||
};
|
||||
extern batteryClass *pbattery;
|
||||
#endif
|
||||
35
eyeTracker/software/src/camCfg.h
Normal file
35
eyeTracker/software/src/camCfg.h
Normal file
@ -0,0 +1,35 @@
|
||||
#ifndef _CAM_PINS_DEF_H_
|
||||
#define _CAM_PINS_DEF_H_
|
||||
#include <esp_camera.h>
|
||||
#include "config.h"
|
||||
/** @brief Pin definition for AI Thinker ESP32-CAM. */
|
||||
constexpr camera_config_t camconfig{
|
||||
.pin_pwdn = 32,
|
||||
.pin_reset = -1,
|
||||
.pin_xclk = 0,
|
||||
.pin_sccb_sda = 26,
|
||||
.pin_sccb_scl = 27,
|
||||
.pin_d7 = 35,
|
||||
.pin_d6 = 34,
|
||||
.pin_d5 = 39,
|
||||
.pin_d4 = 36,
|
||||
.pin_d3 = 21,
|
||||
.pin_d2 = 19,
|
||||
.pin_d1 = 18,
|
||||
.pin_d0 = 5,
|
||||
.pin_vsync = 25,
|
||||
.pin_href = 23,
|
||||
.pin_pclk = 22,
|
||||
//XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
|
||||
.xclk_freq_hz = 20000000,
|
||||
.ledc_timer = LEDC_TIMER_0,
|
||||
.ledc_channel = LEDC_CHANNEL_0,
|
||||
|
||||
.pixel_format = PIXFORMAT_JPEG, //YUV422,GRAYSCALE,RGB565,JPEG
|
||||
.frame_size = FRAMESIZE_HVGA, //QQVGA-UXGA, For ESP32, do not use sizes above QVGA when not JPEG. The performance of the ESP32-S series has improved a lot, but JPEG mode always gives better frame rates.
|
||||
|
||||
.jpeg_quality = 5, //0-63, for OV series camera sensors, lower number means higher quality(图片过大可能会导致堆栈溢出)
|
||||
.fb_count = 2, //When jpeg mode is used, if fb_count more than one, the driver will work in continuous mode.
|
||||
.grab_mode = CAMERA_GRAB_LATEST,
|
||||
};
|
||||
#endif
|
||||
15
eyeTracker/software/src/common.h
Normal file
15
eyeTracker/software/src/common.h
Normal file
@ -0,0 +1,15 @@
|
||||
#ifndef COMMON_H
|
||||
#define COMMON_H
|
||||
#include <Arduino.h>
|
||||
#define CYMPLEFACE_CAM_PORT 23302
|
||||
#define CYMPLEFACE_SERVER_PORT 23303
|
||||
#define SSID_LENGTH 32
|
||||
#define WIFI_PASSWORD_LENGTH 16
|
||||
#define WLAN_HEARTBEAT_TIMEOUT 5000
|
||||
#define OFFSET(structure, member) ((int32_t)&((structure*)0)->member)
|
||||
typedef struct{
|
||||
uint16_t uiType;
|
||||
uint16_t uiLength;
|
||||
}TLV_S;
|
||||
|
||||
#endif
|
||||
17
eyeTracker/software/src/config.h
Normal file
17
eyeTracker/software/src/config.h
Normal file
@ -0,0 +1,17 @@
|
||||
#ifndef CONFIG_HPP
|
||||
#define CONFIG_HPP
|
||||
#include <Arduino.h>
|
||||
enum board{
|
||||
esp32cam,
|
||||
cympleeye,
|
||||
};
|
||||
#define BOARD_DEF cympleeye
|
||||
/* LED配置 */
|
||||
#define LED_PIN 33 /* GPIO33 for espcam*/
|
||||
#define BATTERY_UPDATE_TIME 10000//10S刷新一次
|
||||
#define BATTERY_PIN A0 //A0
|
||||
#define BATEERY_ADC_MAX 1024.0 //ADC读出值范围为0-1024
|
||||
#define BATTERY_MAX 4.2 //电池满电电压
|
||||
#define BATTERY_MIN 3.7 //电池零电电压
|
||||
#define BATTERY_DOT (10.0/(47.0 + 10.0)) //分压
|
||||
#endif /* CONFIG_HPP */
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user