andry/EMS-ESP32
1
0
Fork 0
mirror of https://github.com/emsesp/EMS-ESP32.git synced 2025-12-06 07:49:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

support Unity testing

Browse Source
This commit is contained in:
proddy
2024-08-01 22:13:52 +02:00
parent 4ec5739b67
commit b38ec2f25e
16 changed files with 598 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
test/README.txt
View File

@@ -1,6 +0,0 @@
This folder contains the default data used when testing in standalone mode, purely for reference purposes.
It is used for simulation and testing and can be invoked by compiling with -DEMSESP_TEST and from the Console using the command `test general` or via an API call like http://ems-esp.local/api?device=system&cmd=test&data=general
To run in standalone mode without an ESP32 microcontroller use `make run` or `pio run -e standalone -t exec`

168
test/api_test.http
View File

@@ -1,168 +0,0 @@
# testing EMS-ESP API
# to be used with "REST Client" extension in Visual Studio Code (https://marketplace.visualstudio.com/items?itemName=humao.rest-client)
# Open this file in VSC, modify the token, go to the API call and click on 'Send Request' (or Ctrl+Alt+R)
# The response will be shown in the right panel
@host = http://ems-esp.local
@host_dev = http://10.10.10.173
@host_standalone = http://localhost:3080
@host_standalone2 = http://localhost:3082
@token = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImFkbWluIiwiYWRtaW4iOnRydWV9.2bHpWya2C7Q12WjNUBD6_7N3RCD7CMl-EGhyQVzFdDg
GET {{host}}/api/system/info
###
GET {{host}}/api/thermostat/seltemp
###
POST {{host}}/api/thermostat/seltemp
Content-Type: application/json
Authorization: Bearer {{token}}
{
"value" : 21.0
}
###
POST {{host}}/api/thermostat
Content-Type: application/json
Authorization: Bearer {{token}}
{
"entity" : "seltemp",
"value" : 21.0
}
###
POST {{host}}/api
Content-Type: application/json
Authorization: Bearer {{token}}
{
"device" : "boiler",
"entity" : "dhw/tapactivated",
"value" : "on"
}
###
GET {{host}}/api/system/restart
Authorization: Bearer {{token}}
###
GET {{host}}/api/boiler/coldshot
Authorization: Bearer {{token}}
###
GET {{host}}/api/temperaturesensor/info
###
GET {{host}}/rest/deviceData?id=3
Content-Type: application/json
Authorization: Bearer {{token}}
###
GET {{host}}/api/boiler/commands
#
# Test on dev
#
GET {{host_dev}}/api/system/info
# Run a test. EMS-ESP must be compiled with -DEMSESP_TEST
# Use this to load up a dummy thermostat and boiler with data
###
GET {{host_dev}}/api?device=system&cmd=test&data=general
###
GET {{host_dev}}/api/boiler/info
###
GET {{host_dev}}/api/boiler/values
###
GET {{host_dev}}/api/analogsensor/info
###
GET {{host_dev}}/api/boiler/coldshot
Authorization: Bearer {{token}}
###
GET {{host_dev}}/api/system/commands
###
POST {{host_dev}}/api/thermostat/seltemp
Content-Type: application/json
Authorization: Bearer {{token}}
{
"value" : 21.0
}
###
GET {{host_dev}}/api/thermostat/seltemp
###
POST {{host_dev}}/rest/signIn
Content-Type: application/json
{
"username" : "admin",
"password" : "admin"
}
#### STANDALONE ####
GET {{host_standalone}}/api/system/info
###
POST {{host_standalone2}}/rest/uploadFile
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="text"
title
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="file"; filename="emsesp_settings.json"
Content-Type: application/json
< ./standalone_file_export/emsesp_settings.json
------WebKitFormBoundary7MA4YWxkTrZu0gW--
# test calling Home Assistant script
# https://developers.home-assistant.io/docs/api/rest/#post-apiservicesdomainservice
POST {{host_standalone}}/api
# HA
@ha = http://192.168.1.42:8123
@ha_token = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiIwMzMyZjU1MjhlZmM0NGIyOTgyMjIxNThiODU1NDkyNSIsImlhdCI6MTcyMTMwNDg2NSwiZXhwIjoyMDM2NjY0ODY1fQ.Q-Y7E_i7clH3ff4Ma-OMmhZfbN7aMi_CahKwmoar
###
GET {{ha}}/api/services
Content-Type: application/json
Authorization: Bearer {{ha_token}}
###
POST {{ha}}/api/services/script/test_notify
Content-Type: application/json
Authorization: Bearer {{ha_token}}

16
test/api_test.sh
View File

@@ -1,16 +0,0 @@
#!/bin/sh
# API
curl -X GET http://ems-esp.local/api/system/info
echo "\n"
# HA
ha_url="http://192.168.1.42:8123"
ha_token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiIwMzMyZjU1MjhlZmM0NGIyOTgyMjIxNThiODU1NDkyNSIsImlhdCI6MTcyMTMwNDg2NSwiZXhwIjoyMDM2NjY0ODY1fQ.Q-Y7E_i7clH3ff4Ma-OMmhZfbN7aMi_CahKwmoar"
curl -X POST \
${ha_url}/api/services/script/test_notify \
-H "Authorization: Bearer ${ha_token}" \
-H "Content-Type: application/json" \

28
test/standalone_file_export/emsesp_customizations.json
View File

@@ -1,28 +0,0 @@
{
"type": "customizations",
"Customizations": {
"ts": [
{
"id": "01_0203_0405_0607",
"name": "test_sensor1",
"offset": 0
},
{
"id": "0B_0C0D_0E0F_1011",
"name": "test_sensor2",
"offset": 4
}
],
"as": [],
"masked_entities": [
{
"product_id": 123,
"device_id": 8,
"custom_name": "Trendline",
"entity_ids": [
"08heatingactive|is my heating on?"
]
}
]
}
}

44
test/standalone_file_export/emsesp_entities.json
View File

@@ -1,44 +0,0 @@
{
"type": "entities",
"Entities": {
"entities": [
{
"id": 0,
"ram": 0,
"device_id": 8,
"type_id": 24,
"offset": 0,
"factor": 1,
"name": "test_custom",
"uom": 1,
"value_type": 1,
"writeable": true
},
{
"id": 1,
"ram": 0,
"device_id": 24,
"type_id": 677,
"offset": 3,
"factor": 1,
"name": "test_read_only",
"uom": 0,
"value_type": 2,
"writeable": false
},
{
"id": 2,
"ram": 1,
"device_id": 0,
"type_id": 0,
"offset": 0,
"factor": 1,
"name": "test_ram",
"uom": 0,
"value_type": 8,
"writeable": true,
"value": "14"
}
]
}
}

16
test/standalone_file_export/emsesp_schedule.json
View File

@@ -1,16 +0,0 @@
{
"type": "schedule",
"Schedule": {
"schedule": [
{
"id": 0,
"active": true,
"flags": 1,
"time": "12:00",
"cmd": "system/fetch",
"value": "10",
"name": "test_scheduler"
}
]
}
}

122
test/standalone_file_export/emsesp_settings.json
View File

@@ -1,122 +0,0 @@
{
"type": "settings",
"System": {
"version": "3.7.0"
},
"Network": {
"ssid": "fake",
"bssid": "",
"password": "fake",
"hostname": "ems-esp",
"static_ip_config": false,
"bandwidth20": false,
"tx_power": 0,
"nosleep": false,
"enableMDNS": true,
"enableCORS": false,
"CORSOrigin": "*"
},
"AP": {
"provision_mode": 1,
"ssid": "ems-esp",
"password": "ems-esp-neo",
"channel": 1,
"ssid_hidden": false,
"max_clients": 4,
"local_ip": "192.168.4.1",
"gateway_ip": "192.168.4.1",
"subnet_mask": "255.255.255.0"
},
"MQTT": {
"enabled": true,
"host": "192.168.1.200",
"port": 1883,
"base": "ems-espS",
"username": "fake",
"password": "fake",
"client_id": "ems-esp",
"keep_alive": 60,
"clean_session": false,
"entity_format": 1,
"publish_time_boiler": 10,
"publish_time_thermostat": 10,
"publish_time_solar": 10,
"publish_time_mixer": 10,
"publish_time_other": 10,
"publish_time_sensor": 10,
"publish_time_heartbeat": 60,
"mqtt_qos": 0,
"mqtt_retain": false,
"ha_enabled": true,
"nested_format": 1,
"discovery_prefix": "homeassistant",
"discovery_type": 0,
"publish_single": false,
"publish_single2cmd": false,
"send_response": false
},
"NTP": {
"enabled": false,
"server": "time.google.com",
"tz_label": "Europe/Amsterdam",
"tz_format": "CET-1CEST,M3.5.0,M10.5.0/3"
},
"Security": {
"jwt_secret": "ems-esp-neo",
"users": [
{
"username": "admin",
"password": "admin",
"admin": true
},
{
"username": "guest",
"password": "guest",
"admin": false
}
]
},
"Settings": {
"version": "3.7.0",
"locale": "en",
"tx_mode": 1,
"ems_bus_id": 11,
"syslog_enabled": false,
"syslog_level": 3,
"trace_raw": false,
"syslog_mark_interval": 0,
"syslog_host": "",
"syslog_port": 514,
"boiler_heatingoff": false,
"shower_timer": false,
"shower_alert": false,
"shower_alert_coldshot": 10,
"shower_alert_trigger": 7,
"rx_gpio": 23,
"tx_gpio": 5,
"dallas_gpio": 18,
"dallas_parasite": false,
"led_gpio": 2,
"hide_led": false,
"low_clock": false,
"telnet_enabled": true,
"notoken_api": false,
"readonly_mode": false,
"analog_enabled": true,
"pbutton_gpio": 0,
"solar_maxflow": 30,
"board_profile": "S32",
"fahrenheit": false,
"bool_format": 1,
"bool_dashboard": 1,
"enum_format": 1,
"weblog_level": 6,
"weblog_buffer": 50,
"weblog_compact": true,
"phy_type": 0,
"eth_power": 0,
"eth_phy_addr": 0,
"eth_clock_mode": 0,
"platform": "ESP32"
}
}

166
test/test_api/test_api.cpp Normal file
View File

@@ -0,0 +1,166 @@
#include <Arduino.h>
#include <unity.h>
#include <emsesp.h>
#include "ESPAsyncWebServer.h"
#include "ESP8266React.h"
#include "web/WebAPIService.h"
using namespace emsesp;
AsyncWebServer * webServer;
ESP8266React * esp8266React;
WebAPIService * webAPIService;
AsyncWebServerRequest request;
EMSESP application;
FS dummyFS;
// simulates a telegram straight from UART, but without the CRC which is added automatically
void uart_telegram(const std::vector<uint8_t> & rx_data) {
uint8_t len = rx_data.size();
uint8_t data[50];
uint8_t i = 0;
while (len--) {
data[i] = rx_data[i];
i++;
}
data[i] = EMSESP::rxservice_.calculate_crc(data, i);
EMSESP::incoming_telegram(data, i + 1);
}
void uart_telegram(const char * rx_data) {
// since the telegram data is a const, make a copy. add 1 to grab the \0 EOS
char telegram[(EMS_MAX_TELEGRAM_LENGTH * 3) + 1];
for (uint8_t i = 0; i < strlen(rx_data); i++) {
telegram[i] = rx_data[i];
}
telegram[strlen(rx_data)] = '\0'; // make sure its terminated
uint8_t count = 0;
char * p;
char value[10] = {0};
uint8_t data[EMS_MAX_TELEGRAM_LENGTH];
// get first value, which should be the src
if ((p = strtok(telegram, " ,"))) { // delimiter
strlcpy(value, p, 10);
data[0] = (uint8_t)strtol(value, 0, 16);
}
// and iterate until end
while (p != 0) {
if ((p = strtok(nullptr, " ,"))) {
strlcpy(value, p, 10);
uint8_t val = (uint8_t)strtol(value, 0, 16);
data[++count] = val;
}
}
if (count == 0) {
return; // nothing to send
}
data[count + 1] = EMSESP::rxservice_.calculate_crc(data, count + 1); // add CRC
EMSESP::incoming_telegram(data, count + 2);
}
void add_device(uint8_t device_id, uint8_t product_id) {
uart_telegram({device_id, 0x0B, EMSdevice::EMS_TYPE_VERSION, 0, product_id, 1, 0});
}
void setUp() {
JsonDocument doc;
JsonVariant json;
webServer = new AsyncWebServer(80);
esp8266React = new ESP8266React(webServer, &dummyFS);
webAPIService = new WebAPIService(webServer, esp8266React->getSecurityManager());
application.start(); // calls begin()
EMSESP::webCustomEntityService.test(); // custom entities
EMSESP::webCustomizationService.test(); // set customizations - this will overwrite any settings in the FS
EMSESP::temperaturesensor_.test(); // add temperature sensors
EMSESP::webSchedulerService.test(); // run scheduler tests, and conditions
//
// boiler
//
add_device(0x08, 123); // Nefit Trendline
// UBAuptime
uart_telegram({0x08, 0x0B, 0x14, 00, 0x3C, 0x1F, 0xAC, 0x70});
// Boiler -> Me, UBAMonitorFast(0x18), telegram: 08 00 18 00 00 02 5A 73 3D 0A 10 65 40 02 1A 80 00 01 E1 01 76 0E 3D 48 00 C9 44 02 00 (#data=25)
uart_telegram({0x08, 0x00, 0x18, 0x00, 0x00, 0x02, 0x5A, 0x73, 0x3D, 0x0A, 0x10, 0x65, 0x40, 0x02, 0x1A,
0x80, 0x00, 0x01, 0xE1, 0x01, 0x76, 0x0E, 0x3D, 0x48, 0x00, 0xC9, 0x44, 0x02, 0x00});
// Boiler -> Me, UBAParameterWW(0x33), telegram: 08 0B 33 00 08 FF 34 FB 00 28 00 00 46 00 FF FF 00 (#data=13)
uart_telegram({0x08, 0x0B, 0x33, 0x00, 0x08, 0xFF, 0x34, 0xFB, 0x00, 0x28, 0x00, 0x00, 0x46, 0x00, 0xFF, 0xFF, 0x00});
//
// thermostat
//
add_device(0x10, 192); // FW120
// HC1 - 3
uart_telegram({0x90, 0x00, 0xFF, 0x00, 0x00, 0x6F, 0x03, 0x02, 0x00, 0xCD, 0x00, 0xE4});
uart_telegram({0x90, 0x00, 0xFF, 0x00, 0x00, 0x70, 0x02, 0x01, 0x00, 0xCE, 0x00, 0xE5});
uart_telegram({0x90, 0x00, 0xFF, 0x00, 0x00, 0x71, 0x01, 0x02, 0x00, 0xCF, 0x00, 0xE6});
// send the telegrams
EMSESP::rxservice_.loop();
}
void tearDown() {
}
void get_url(const char * url) {
request.method(HTTP_GET);
request.url(url);
webAPIService->webAPIService(&request);
}
void test1() {
get_url("/api/system");
// escape strings with https://dolitools.com/text-tools/escape-unescape-string/
auto a =
"[{\"system\":{\"version\":\"3.7.0-dev.28\",\"uptime\":\"000+00:00:00.000\",\"uptimeSec\":0,\"resetReason\":\"Unknown / "
"Unknown\"},\"network\":{\"network\":\"WiFi\",\"hostname\":\"ems-esp\",\"RSSI\":-23,\"TxPowerSetting\":0,\"staticIP\":false,\"lowBandwidth\":false,"
"\"disableSleep\":false,\"enableMDNS\":true,\"enableCORS\":false},\"ntp\":{},\"mqtt\":{\"MQTTStatus\":\"disconnected\",\"MQTTPublishes\":0,"
"\"MQTTQueued\":0,\"MQTTPublishFails\":0,\"MQTTConnects\":1,\"enabled\":true,\"clientID\":\"ems-esp\",\"keepAlive\":60,\"cleanSession\":false,"
"\"entityFormat\":1,\"base\":\"ems-esp\",\"discoveryPrefix\":\"homeassistant\",\"discoveryType\":0,\"nestedFormat\":1,\"haEnabled\":true,\"mqttQos\":0,"
"\"mqttRetain\":false,\"publishTimeHeartbeat\":60,\"publishTimeBoiler\":10,\"publishTimeThermostat\":10,\"publishTimeSolar\":10,\"publishTimeMixer\":"
"10,\"publishTimeWater\":0,\"publishTimeOther\":10,\"publishTimeSensor\":10,\"publishSingle\":false,\"publish2command\":false,\"sendResponse\":false},"
"\"syslog\":{\"enabled\":false},\"sensor\":{\"temperatureSensors\":2,\"temperatureSensorReads\":0,\"temperatureSensorFails\":0,\"analogSensors\":2,"
"\"analogSensorReads\":0,\"analogSensorFails\":0},\"api\":{\"APICalls\":0,\"APIFails\":0},\"bus\":{\"busStatus\":\"connected\",\"busProtocol\":"
"\"Buderus\",\"busTelegramsReceived\":8,\"busReads\":0,\"busWrites\":0,\"busIncompleteTelegrams\":0,\"busReadsFailed\":0,\"busWritesFailed\":0,"
"\"busRxLineQuality\":100,\"busTxLineQuality\":100},\"settings\":{\"boardProfile\":\"S32\",\"locale\":\"en\",\"txMode\":8,\"emsBusID\":11,"
"\"showerTimer\":false,\"showerMinDuration\":180,\"showerAlert\":false,\"hideLed\":false,\"noTokenApi\":false,\"readonlyMode\":false,\"fahrenheit\":"
"false,\"dallasParasite\":false,\"boolFormat\":1,\"boolDashboard\":1,\"enumFormat\":1,\"analogEnabled\":true,\"telnetEnabled\":true,"
"\"maxWebLogBuffer\":50,\"webLogBuffer\":33,\"modbusEnabled\":false},\"devices\":[{\"type\":\"boiler\",\"name\":\"Custom "
"Name!!\",\"deviceID\":\"0x08\",\"productID\":123,\"brand\":\"\",\"version\":\"01.00\",\"entities\":37,\"handlersReceived\":\"0x18\","
"\"handlersFetched\":\"0x14 0x33\",\"handlersPending\":\"0xBF 0x10 0x11 0xC2 0x15 0x1C 0x19 0x1A 0x35 0x34 0x2A 0xD1 0xE3 0xE4 0xE5 0xE9 0x2E "
"0x3B\"},{\"type\":\"thermostat\",\"name\":\"FW120\",\"deviceID\":\"0x10\",\"productID\":192,\"brand\":\"\",\"version\":\"01.00\",\"entities\":15,"
"\"handlersReceived\":\"0x016F\",\"handlersFetched\":\"0x0170 0x0171\",\"handlersPending\":\"0xA3 0x06 0xA2 0x12 0x13 0x0172 0x0165 0x0168\"}]}]";
TEST_ASSERT_EQUAL_STRING(a, webAPIService->getResponse());
}
void test2() {
get_url("/api/custom");
auto a = "[{\"test_custom\":0.00,\"test_read_only\":0.00,\"test_ram\":\"14\",\"seltemp\":\"14\"}]";
TEST_ASSERT_EQUAL_STRING(a, webAPIService->getResponse());
}
int main() {
UNITY_BEGIN();
RUN_TEST(test1);
RUN_TEST(test2);
return UNITY_END();
}

251
test/unity_config.h Normal file
View File

@@ -0,0 +1,251 @@
/* =========================================================================
Unity - A Test Framework for C
ThrowTheSwitch.org
Copyright (c) 2007-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
SPDX-License-Identifier: MIT
========================================================================= */
/* 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 */