mirrors/lvgl
0
0
Fork 0
mirror of https://github.com/lvgl/lvgl.git synced 2024-11-23 09:43:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat(test) first experiement with Unity test engine

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi 2021-06-02 15:41:47 +02:00
parent 428db9494d
commit c26bcf1cc6
37 changed files with 4759 additions and 5582 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
*.out
*_Runner.c

19
tests/Makefile
View File

@ -16,25 +16,16 @@ WARNINGS += -Wpedantic -pedantic-errors
#-Wno-unused-value -Wno-unused-parameter
OPTIMIZATION ?= -O3 -g0
CFLAGS ?= -I$(LVGL_DIR)/ $(DEFINES) $(WARNINGS) $(OPTIMIZATION) -I$(LVGL_DIR) -I.
CFLAGS ?= -I$(LVGL_DIR)/ -Iunity $(DEFINES) $(WARNINGS) $(OPTIMIZATION) -I$(LVGL_DIR) -I.
LDFLAGS ?= -lpng
BIN ?= demo
#Collect the files to compile
MAINSRC = ./lv_test_main.c
BIN ?= test
include ../lvgl.mk
CSRCS += lv_test_assert.c
CSRCS += lv_test_core/lv_test_core.c
CSRCS += lv_test_core/lv_test_obj.c
CSRCS += lv_test_core/lv_test_style.c
CSRCS += lv_test_core/lv_test_font_loader.c
CSRCS += lv_test_widgets/lv_test_label.c
CSRCS += lv_test_fonts/font_1.c
CSRCS += lv_test_fonts/font_2.c
CSRCS += lv_test_fonts/font_3.c
CSRCS += ${TEST_SRC}
CSRCS += unity/unity.c
CSRCS += lv_test_init.c
OBJEXT ?= .o

176
tests/build.py
View File

@ -9,7 +9,7 @@ lvgldirname = '"' + lvgldirname + '"'
base_defines = '"-DLV_CONF_PATH=' + lvgldirname +'/tests/lv_test_conf.h -DLV_BUILD_TEST"'
optimization = '"-O3 -g0"'
def build(name, defines):
def build(name, defines, test_name):
global base_defines, optimization
print("=============================")
@ -22,13 +22,10 @@ def build(name, defines):
d_all += " -D" + d + "=" + str(defines[d])
d_all += '"'
cmd = "make -j8 BIN=test.bin LVGL_DIR_NAME=" + lvgldirname + " DEFINES=" + d_all + " OPTIMIZATION=" + optimization
test_file_name = test_name + ".c"
test_file_runner_name = test_name + "_Runner.c"
cmd = "make -j8 BIN=test.bin MAINSRC=" + test_file_name + " TEST_SRC=" + test_file_runner_name + " LVGL_DIR_NAME=" + lvgldirname + " DEFINES=" + d_all + " OPTIMIZATION=" + optimization
print("---------------------------")
print("Clean")
print("---------------------------")
os.system("make clean LVGL_DIR_NAME=" + lvgldirname)
os.system("rm -f ./test.bin")
print("---------------------------")
print("Build")
print("---------------------------")
@ -49,162 +46,9 @@ def build(name, defines):
print("Finished")
print("---------------------------")
minimal_monochrome = {
"LV_COLOR_DEPTH":1,
"LV_MEM_SIZE":64 * 1024,
"LV_DPI_DEF":40,
"LV_DRAW_COMPLEX":0,
"LV_USE_LOG":1,
"LV_USE_ASSERT_NULL":0,
"LV_USE_ASSERT_MALLOC":0,
"LV_USE_ASSERT_MEM_INTEGRITY":0,
"LV_USE_ASSERT_OBJ":0,
"LV_USE_ASSERT_STYLE":0,
"LV_USE_USER_DATA": 0,
"LV_FONT_UNSCII_8":1,
"LV_USE_BIDI": 0,
"LV_USE_ARABIC_PERSIAN_CHARS":0,
"LV_BUILD_EXAMPLES":1,
"LV_FONT_DEFAULT":"\\\"&lv_font_montserrat_14\\\"",
}
minimal_16bit = {
"LV_COLOR_DEPTH":16,
"LV_MEM_CUSTOM":1,
"LV_DPI_DEF":40,
"LV_DRAW_COMPLEX":0,
"LV_USE_LOG":1,
"LV_USE_ASSERT_NULL":0,
"LV_USE_ASSERT_MALLOC":0,
"LV_USE_ASSERT_MEM_INTEGRITY":0,
"LV_USE_ASSERT_OBJ":0,
"LV_USE_ASSERT_STYLE":0,
"LV_USE_USER_DATA": 0,
"LV_FONT_UNSCII_8":1,
"LV_USE_BIDI": 0,
"LV_USE_ARABIC_PERSIAN_CHARS":0,
"LV_BUILD_EXAMPLES":1,
"LV_FONT_DEFAULT":"\\\"&lv_font_montserrat_14\\\"",
}
minimal_16bit_swap = {
"LV_COLOR_DEPTH":16,
"LV_COLOR_16_SWAP":1,
"LV_MEM_SIZE":64 * 1024,
"LV_DPI_DEF":40,
"LV_DRAW_COMPLEX":0,
"LV_USE_LOG":1,
"LV_USE_ASSERT_NULL":0,
"LV_USE_ASSERT_MALLOC":0,
"LV_USE_ASSERT_MEM_INTEGRITY":0,
"LV_USE_ASSERT_OBJ":0,
"LV_USE_ASSERT_STYLE":0,
"LV_USE_USER_DATA": 0,
"LV_FONT_UNSCII_8":1,
"LV_USE_FONT_SUBPX": 1,
"LV_USE_BIDI": 0,
"LV_USE_ARABIC_PERSIAN_CHARS":0,
"LV_BUILD_EXAMPLES":1,
"LV_FONT_DEFAULT":"\\\"&lv_font_montserrat_14\\\"",
}
full_32bit = {
"LV_COLOR_DEPTH":32,
"LV_MEM_SIZE":8 * 1024 * 1024,
"LV_DPI_DEF":160,
"LV_DRAW_COMPLEX":1,
"LV_SHADOW_CACHE_SIZE":1,
"LV_IMG_CACHE_DEF_SIZE":32,
"LV_USE_LOG":1,
"LV_LOG_PRINTF":1,
"LV_USE_FONT_SUBPX": 1,
"LV_FONT_SUBPX_BGR":1,
"LV_USE_PERF_MONITOR":1,
"LV_USE_ASSERT_NULL":1,
"LV_USE_ASSERT_MALLOC":1,
"LV_USE_ASSERT_MEM_INTEGRITY":1,
"LV_USE_ASSERT_OBJ":1,
"LV_USE_ASSERT_STYLE":1,
"LV_USE_USER_DATA": 1,
"LV_USE_LARGE_COORD": 1,
"LV_FONT_MONTSERRAT_8":1,
"LV_FONT_MONTSERRAT_10":1,
"LV_FONT_MONTSERRAT_12":1,
"LV_FONT_MONTSERRAT_14":1,
"LV_FONT_MONTSERRAT_16":1,
"LV_FONT_MONTSERRAT_18":1,
"LV_FONT_MONTSERRAT_20":1,
"LV_FONT_MONTSERRAT_22":1,
"LV_FONT_MONTSERRAT_24":1,
"LV_FONT_MONTSERRAT_26":1,
"LV_FONT_MONTSERRAT_28":1,
"LV_FONT_MONTSERRAT_30":1,
"LV_FONT_MONTSERRAT_32":1,
"LV_FONT_MONTSERRAT_34":1,
"LV_FONT_MONTSERRAT_36":1,
"LV_FONT_MONTSERRAT_38":1,
"LV_FONT_MONTSERRAT_40":1,
"LV_FONT_MONTSERRAT_42":1,
"LV_FONT_MONTSERRAT_44":1,
"LV_FONT_MONTSERRAT_46":1,
"LV_FONT_MONTSERRAT_48":1,
"LV_FONT_MONTSERRAT_12_SUBPX":1,
"LV_FONT_MONTSERRAT_28_COMPRESSED":1,
"LV_FONT_DEJAVU_16_PERSIAN_HEBREW":1,
"LV_FONT_SIMSUN_16_CJK":1,
"LV_FONT_UNSCII_8":1,
"LV_FONT_UNSCII_16":1,
"LV_FONT_FMT_TXT_LARGE":1,
"LV_USE_FONT_COMPRESSED":1,
"LV_USE_BIDI": 1,
"LV_USE_ARABIC_PERSIAN_CHARS":1,
"LV_USE_PERF_MONITOR":1,
"LV_USE_MEM_MONITOR":1,
"LV_LABEL_TEXT_SELECTION":1,
"LV_BUILD_EXAMPLES":1,
"LV_FONT_DEFAULT":"\\\"&lv_font_montserrat_32\\\"",
}
build("Minimal config monochrome", minimal_monochrome)
build("Minimal config, 16 bit color depth", minimal_16bit)
build("Minimal config, 16 bit color depth swapped", minimal_16bit_swap)
build("Full config, 32 bit color depth", full_32bit)
def clean():
print("---------------------------")
print("Clean")
print("---------------------------")
os.system("make clean LVGL_DIR_NAME=" + lvgldirname)
os.system("rm -f ./test.bin")

5
tests/config.yml Normal file
View File

@ -0,0 +1,5 @@
:unity:
:includes:
- lv_test_init.h
:suite_setup: "lv_test_init();"
:suite_teardown: "lv_test_deinit();return num_failures;"

155
tests/defines.py Normal file
View File

@ -0,0 +1,155 @@
minimal_monochrome = {
"LV_COLOR_DEPTH":1,
"LV_MEM_SIZE":64 * 1024,
"LV_DPI_DEF":40,
"LV_DRAW_COMPLEX":0,
"LV_USE_LOG":1,
"LV_USE_ASSERT_NULL":0,
"LV_USE_ASSERT_MALLOC":0,
"LV_USE_ASSERT_MEM_INTEGRITY":0,
"LV_USE_ASSERT_OBJ":0,
"LV_USE_ASSERT_STYLE":0,
"LV_USE_USER_DATA": 0,
"LV_FONT_UNSCII_8":1,
"LV_USE_BIDI": 0,
"LV_USE_ARABIC_PERSIAN_CHARS":0,
"LV_BUILD_EXAMPLES":1,
"LV_FONT_DEFAULT":"\\\"&lv_font_montserrat_14\\\"",
}
minimal_16bit = {
"LV_COLOR_DEPTH":16,
"LV_MEM_CUSTOM":1,
"LV_DPI_DEF":40,
"LV_DRAW_COMPLEX":0,
"LV_USE_LOG":1,
"LV_USE_ASSERT_NULL":0,
"LV_USE_ASSERT_MALLOC":0,
"LV_USE_ASSERT_MEM_INTEGRITY":0,
"LV_USE_ASSERT_OBJ":0,
"LV_USE_ASSERT_STYLE":0,
"LV_USE_USER_DATA": 0,
"LV_FONT_UNSCII_8":1,
"LV_USE_BIDI": 0,
"LV_USE_ARABIC_PERSIAN_CHARS":0,
"LV_BUILD_EXAMPLES":1,
"LV_FONT_DEFAULT":"\\\"&lv_font_montserrat_14\\\"",
}
minimal_16bit_swap = {
"LV_COLOR_DEPTH":16,
"LV_COLOR_16_SWAP":1,
"LV_MEM_SIZE":64 * 1024,
"LV_DPI_DEF":40,
"LV_DRAW_COMPLEX":0,
"LV_USE_LOG":1,
"LV_USE_ASSERT_NULL":0,
"LV_USE_ASSERT_MALLOC":0,
"LV_USE_ASSERT_MEM_INTEGRITY":0,
"LV_USE_ASSERT_OBJ":0,
"LV_USE_ASSERT_STYLE":0,
"LV_USE_USER_DATA": 0,
"LV_FONT_UNSCII_8":1,
"LV_USE_FONT_SUBPX": 1,
"LV_USE_BIDI": 0,
"LV_USE_ARABIC_PERSIAN_CHARS":0,
"LV_BUILD_EXAMPLES":1,
"LV_FONT_DEFAULT":"\\\"&lv_font_montserrat_14\\\"",
}
full_32bit = {
"LV_COLOR_DEPTH":32,
"LV_MEM_SIZE":8 * 1024 * 1024,
"LV_DPI_DEF":160,
"LV_DRAW_COMPLEX":1,
"LV_SHADOW_CACHE_SIZE":1,
"LV_IMG_CACHE_DEF_SIZE":32,
"LV_USE_LOG":1,
"LV_LOG_PRINTF":1,
"LV_USE_FONT_SUBPX": 1,
"LV_FONT_SUBPX_BGR":1,
"LV_USE_PERF_MONITOR":1,
"LV_USE_ASSERT_NULL":1,
"LV_USE_ASSERT_MALLOC":1,
"LV_USE_ASSERT_MEM_INTEGRITY":1,
"LV_USE_ASSERT_OBJ":1,
"LV_USE_ASSERT_STYLE":1,
"LV_USE_USER_DATA": 1,
"LV_USE_LARGE_COORD": 1,
"LV_FONT_MONTSERRAT_8":1,
"LV_FONT_MONTSERRAT_10":1,
"LV_FONT_MONTSERRAT_12":1,
"LV_FONT_MONTSERRAT_14":1,
"LV_FONT_MONTSERRAT_16":1,
"LV_FONT_MONTSERRAT_18":1,
"LV_FONT_MONTSERRAT_20":1,
"LV_FONT_MONTSERRAT_22":1,
"LV_FONT_MONTSERRAT_24":1,
"LV_FONT_MONTSERRAT_26":1,
"LV_FONT_MONTSERRAT_28":1,
"LV_FONT_MONTSERRAT_30":1,
"LV_FONT_MONTSERRAT_32":1,
"LV_FONT_MONTSERRAT_34":1,
"LV_FONT_MONTSERRAT_36":1,
"LV_FONT_MONTSERRAT_38":1,
"LV_FONT_MONTSERRAT_40":1,
"LV_FONT_MONTSERRAT_42":1,
"LV_FONT_MONTSERRAT_44":1,
"LV_FONT_MONTSERRAT_46":1,
"LV_FONT_MONTSERRAT_48":1,
"LV_FONT_MONTSERRAT_12_SUBPX":1,
"LV_FONT_MONTSERRAT_28_COMPRESSED":1,
"LV_FONT_DEJAVU_16_PERSIAN_HEBREW":1,
"LV_FONT_SIMSUN_16_CJK":1,
"LV_FONT_UNSCII_8":1,
"LV_FONT_UNSCII_16":1,
"LV_FONT_FMT_TXT_LARGE":1,
"LV_USE_FONT_COMPRESSED":1,
"LV_USE_BIDI": 1,
"LV_USE_ARABIC_PERSIAN_CHARS":1,
"LV_USE_PERF_MONITOR":1,
"LV_USE_MEM_MONITOR":1,
"LV_LABEL_TEXT_SELECTION":1,
"LV_BUILD_EXAMPLES":1,
"LV_FONT_DEFAULT":"\\\"&lv_font_montserrat_32\\\"",
}

BIN
tests/font_1.fnt
View File

Binary file not shown.

BIN
tests/font_2.fnt
View File

Binary file not shown.

BIN
tests/font_3.fnt
View File

Binary file not shown.

BIN
tests/icon.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.7 KiB

BIN
tests/icon2.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.8 KiB

383
tests/lv_test_assert.c
View File

@ -1,383 +0,0 @@
/**
* @file lv_test_assert.c
*
* Copyright 2002-2010 Guillaume Cottenceau.
*
* This software may be freely redistributed under the terms
* of the X11 license.
*
*/
/*********************
* INCLUDES
*********************/
#include "lv_test_assert.h"
#include "../lvgl.h"
#if LV_BUILD_TEST
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#define PNG_DEBUG 3
#include <png.h>
/*********************
* DEFINES
*********************/
//#define REF_IMGS_PATH "lvgl/tests/lv_test_ref_imgs/"
#define REF_IMGS_PATH "lv_test_ref_imgs/"
/**********************
* TYPEDEFS
**********************/
typedef struct {
int width, height;
png_byte color_type;
png_byte bit_depth;
png_structp png_ptr;
png_infop info_ptr;
int number_of_passes;
png_bytep * row_pointers;
}png_img_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void read_png_file(png_img_t * p, const char* file_name);
//static void write_png_file(png_img_t * p, const char* file_name);
static void png_release(png_img_t * p);
//static void process_file(png_img_t * p);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_test_print(const char * s, ...)
{
va_list args;
va_start(args, s);
vfprintf(stdout, s, args);
fprintf(stdout, "\n");
va_end(args);
}
void lv_test_exit(const char * s, ...)
{
va_list args;
va_start(args, s);
vfprintf(stderr, s, args);
fprintf(stderr, "\n");
va_end(args);
exit(1);
}
void lv_test_error(const char * s, ...)
{
va_list args;
va_start(args, s);
vfprintf(stderr, s, args);
fprintf(stderr, "\n");
va_end(args);
exit(1);
}
void lv_test_assert_true(int32_t expression, const char * s)
{
if(!expression) {
lv_test_error(" FAIL: %s. (Expected: not zero)", s, expression);
} else {
lv_test_print(" PASS: %s. (Expected: not zero)", s, expression);
}
}
void lv_test_assert_int_eq(int32_t n_ref, int32_t n_act, const char * s)
{
if(n_ref != n_act) {
lv_test_error(" FAIL: %s. (Expected: %d, Actual: %d)", s, n_ref, n_act);
} else {
lv_test_print(" PASS: %s. (Expected: %d)", s, n_ref);
}
}
void lv_test_assert_int_gt(int32_t n_ref, int32_t n_act, const char * s)
{
if(n_act <= n_ref) {
lv_test_error(" FAIL: %s. (Expected: > %d, Actual: %d)", s, n_ref, n_act);
} else {
lv_test_print(" PASS: %s. (Expected: > %d, , Actual: %d)", s, n_ref, n_act);
}
}
void lv_test_assert_int_lt(int32_t n_ref, int32_t n_act, const char * s)
{
if(n_act >= n_ref) {
lv_test_error(" FAIL: %s. (Expected: < %d, Actual: %d)", s, n_ref, n_act);
} else {
lv_test_print(" PASS: %s. (Expected: < %d, , Actual: %d)", s, n_ref, n_act);
}
}
void lv_test_assert_str_eq(const char * s_ref, const char * s_act, const char * s)
{
if(strcmp(s_ref, s_act) != 0) {
lv_test_error(" FAIL: %s. (Expected: %s, Actual: %s)", s, s_ref, s_act);
} else {
lv_test_print(" PASS: %s. (Expected: %s)", s, s_ref);
}
}
void lv_test_assert_array_eq(const uint8_t *p_ref, const uint8_t *p_act, int32_t size, const char * s)
{
if(memcmp(p_ref, p_act, size) != 0) {
lv_test_error(" FAIL: %s. (Expected: all %d bytes should be equal)", s, size);
} else {
lv_test_print(" PASS: %s. (Expected: all %d bytes should be equal)", s, size);
}
}
void lv_test_assert_ptr_eq(const void * p_ref, const void * p_act, const char * s)
{
if(p_ref != p_act) {
lv_test_error(" FAIL: %s. (Expected: 0x%lx, Actual: 0x%lx)", s, p_ref, p_act);
} else {
lv_test_print(" PASS: %s. (Expected: 0x%lx)", s, p_ref);
}
}
void lv_test_assert_color_eq(lv_color_t c_ref, lv_color_t c_act, const char * s)
{
#if LV_COLOR_16_SWAP == 0
if(c_ref.full != c_act.full) {
lv_test_error(" FAIL: %s. (Expected: R:%02x, G:%02x, B:%02x, Actual: R:%02x, G:%02x, B:%02x)", s,
c_ref.ch.red, c_ref.ch.green, c_ref.ch.blue,
c_act.ch.red, c_act.ch.green, c_act.ch.blue);
} else {
lv_test_print(" PASS: %s. (Expected: R:%02x, G:%02x, B:%02x)", s,
c_ref.ch.red, c_ref.ch.green, c_ref.ch.blue);
}
#else
LV_UNUSED(c_ref);
LV_UNUSED(c_act);
LV_UNUSED(s);
lv_test_print(" SKIP");
#endif
}
void lv_test_assert_img_eq(const char * fn_ref, const char * s)
{
#if LV_COLOR_DEPTH != 32
lv_test_print(" SKIP: Can't compare '%s' because LV_COLOR_DEPTH != 32", fn_ref);
return;
#endif
if (LV_HOR_RES != 800 || LV_VER_RES != 480) {
lv_test_print(" SKIP: Can't compare '%s' because the resolution needs to be 800x480", fn_ref);
return;
}
char fn_ref_full[512];
sprintf(fn_ref_full, "%s%s", REF_IMGS_PATH, fn_ref);
png_img_t p;
read_png_file(&p, fn_ref_full);
uint8_t * screen_buf;
lv_disp_t * disp = lv_disp_get_default();
lv_obj_invalidate(lv_disp_get_scr_act(disp));
lv_refr_now(disp);
extern lv_color_t test_fb[];
screen_buf = (uint8_t *)test_fb;
uint8_t * ptr_act = NULL;
const png_byte* ptr_ref = NULL;
bool err = false;
int x, y, i_buf = 0;
for (y=0; y<p.height; y++) {
png_byte* row = p.row_pointers[y];
for (x=0; x<p.width; x++) {
ptr_ref = &(row[x*3]);
ptr_act = &(screen_buf[i_buf*4]);
uint8_t tmp = ptr_act[0];
ptr_act[0] = ptr_act[2];
ptr_act[2] = tmp;
if(memcmp(ptr_act, ptr_ref, 3) != 0) {
err = true;
break;
}
i_buf++;
}
if(err) break;
}
png_release(&p);
if(err) {
uint32_t ref_px = 0;
uint32_t act_px = 0;
memcpy(&ref_px, ptr_ref, 3);
memcpy(&act_px, ptr_act, 3);
lv_test_error(" FAIL: %s. (Expected: %s, diff. at (%d;%d), %08x instead of %08x)", s, fn_ref, x, y, act_px, ref_px);
} else {
lv_test_print(" PASS: %s. (Expected: %s)", s, fn_ref);
}
}
/**********************
* STATIC FUNCTIONS
**********************/
static void read_png_file(png_img_t * p, const char* file_name)
{
char header[8]; // 8 is the maximum size that can be checked
/*open file and test for it being a png*/
FILE *fp = fopen(file_name, "rb");
if (!fp)
lv_test_exit("[read_png_file] File %s could not be opened for reading", file_name);
size_t rcnt = fread(header, 1, 8, fp);
if (rcnt != 8 || png_sig_cmp((png_const_bytep)header, 0, 8))
lv_test_exit("[read_png_file] File %s is not recognized as a PNG file", file_name);
/*initialize stuff*/
p->png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!p->png_ptr)
lv_test_exit("[read_png_file] png_create_read_struct failed");
p->info_ptr = png_create_info_struct(p->png_ptr);
if (!p->info_ptr)
lv_test_exit("[read_png_file] png_create_info_struct failed");
if (setjmp(png_jmpbuf(p->png_ptr)))
lv_test_exit("[read_png_file] Error during init_io");
png_init_io(p->png_ptr, fp);
png_set_sig_bytes(p->png_ptr, 8);
png_read_info(p->png_ptr, p->info_ptr);
p->width = png_get_image_width(p->png_ptr, p->info_ptr);
p->height = png_get_image_height(p->png_ptr, p->info_ptr);
p->color_type = png_get_color_type(p->png_ptr, p->info_ptr);
p->bit_depth = png_get_bit_depth(p->png_ptr, p->info_ptr);
p->number_of_passes = png_set_interlace_handling(p->png_ptr);
png_read_update_info(p->png_ptr, p->info_ptr);
/*read file*/
if (setjmp(png_jmpbuf(p->png_ptr)))
lv_test_exit("[read_png_file] Error during read_image");
p->row_pointers = (png_bytep*) malloc(sizeof(png_bytep) * p->height);
int y;
for (y=0; y<p->height; y++)
p->row_pointers[y] = (png_byte*) malloc(png_get_rowbytes(p->png_ptr,p->info_ptr));
png_read_image(p->png_ptr, p->row_pointers);
fclose(fp);
}
//
//
//static void write_png_file(png_img_t * p, const char* file_name)
//{
// /*create file*/
// FILE *fp = fopen(file_name, "wb");
// if (!fp)
// lv_test_exit("[write_png_file] File %s could not be opened for writing", file_name);
//
//
// /*initialize stuff*/
// p->png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
//
// if (!p->png_ptr)
// lv_test_exit("[write_png_file] png_create_write_struct failed");
//
// p->info_ptr = png_create_info_struct(p->png_ptr);
// if (!p->info_ptr)
// lv_test_exit("[write_png_file] png_create_info_struct failed");
//
// if (setjmp(png_jmpbuf(p->png_ptr)))
// lv_test_exit("[write_png_file] Error during init_io");
//
// png_init_io(p->png_ptr, fp);
//
//
// /*write header*/
// if (setjmp(png_jmpbuf(p->png_ptr)))
// lv_test_exit("[write_png_file] Error during writing header");
//
// png_set_IHDR(p->png_ptr, p->info_ptr, p->width, p->height,
// p->bit_depth, p->color_type, PNG_INTERLACE_NONE,
// PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
//
// png_write_info(p->png_ptr, p->info_ptr);
//
//
// /*write bytes*/
// if (setjmp(png_jmpbuf(p->png_ptr)))
// lv_test_exit("[write_png_file] Error during writing bytes");
//
// png_write_image(p->png_ptr, p->row_pointers);
//
//
// /*end write*/
// if (setjmp(png_jmpbuf(p->png_ptr)))
// lv_test_exit("[write_png_file] Error during end of write");
//
// png_write_end(p->png_ptr, NULL);
//
// fclose(fp);
//}
//
static void png_release(png_img_t * p)
{
int y;
for (y=0; y<p->height; y++)
free(p->row_pointers[y]);
free(p->row_pointers);
}
//static void process_file(png_img_t * p)
//{
// if (png_get_color_type(p->png_ptr, p->info_ptr) == PNG_COLOR_TYPE_RGB)
// lv_test_exit("[process_file] input file is PNG_COLOR_TYPE_RGB but must be PNG_COLOR_TYPE_RGBA "
// "(lacks the alpha channel)");
//
// if (png_get_color_type(p->png_ptr, p->info_ptr) != PNG_COLOR_TYPE_RGBA)
// lv_test_exit("[process_file] color_type of input file must be PNG_COLOR_TYPE_RGBA (%d) (is %d)",
// PNG_COLOR_TYPE_RGBA, png_get_color_type(p->png_ptr, p->info_ptr));
//
// int x, y;
// for (y=0; y<p->height; y++) {
// png_byte* row = p->row_pointers[y];
// for (x=0; x<p->width; x++) {
// png_byte* ptr = &(row[x*4]);
// printf("Pixel at position [ %d - %d ] has RGBA values: %d - %d - %d - %d\n",
// x, y, ptr[0], ptr[1], ptr[2], ptr[3]);
//
// /*set red value to 0 and green value to the blue one*/
// ptr[0] = 0;
// ptr[1] = ptr[2];
// }
// }
//}
#endif

53
tests/lv_test_assert.h
View File

@ -1,53 +0,0 @@
/**
* @file lv_test_assert.h
*
*/
#ifndef LV_TEST_ASSERT_H
#define LV_TEST_ASSERT_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#include <stdint.h>
#include "../lvgl.h"
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void lv_test_print(const char * s, ...);
void lv_test_exit(const char * s, ...);
void lv_test_error(const char * s, ...);
void lv_test_assert_true(int32_t expression, const char * s);
void lv_test_assert_int_eq(int32_t n1, int32_t n2, const char * s);
void lv_test_assert_int_gt(int32_t n_ref, int32_t n_act, const char * s);
void lv_test_assert_int_lt(int32_t n_ref, int32_t n_act, const char * s);
void lv_test_assert_str_eq(const char * str1, const char * str2, const char * s);
void lv_test_assert_ptr_eq(const void * p_ref, const void * p_act, const char * s);
void lv_test_assert_color_eq(lv_color_t c_ref, lv_color_t c_act, const char * s);
void lv_test_assert_img_eq(const char * ref_img_fn, const char * s);
void lv_test_assert_array_eq(const uint8_t *p_ref, const uint8_t *p_act, int32_t size, const char * s);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif /*LV_TEST_ASSERT_H*/

56
tests/lv_test_core/lv_test_core.c
View File

@ -1,56 +0,0 @@
/**
* @file lv_test_core.c
*
*/
/*********************
* INCLUDES
*********************/
#include "../lv_test_assert.h"
#if LV_BUILD_TEST
#include "lv_test_core.h"
#include "lv_test_obj.h"
#include "lv_test_style.h"
#include "lv_test_font_loader.h"
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_test_core(void)
{
lv_test_print("");
lv_test_print("*******************");
lv_test_print("Start lv_core tests");
lv_test_print("*******************");
lv_test_obj();
// lv_test_style();
lv_test_font_loader();
}
/**********************
* STATIC FUNCTIONS
**********************/
#endif

38
tests/lv_test_core/lv_test_core.h
View File

@ -1,38 +0,0 @@
/**
* @file lv_test_core.h
*
*/
#ifndef LV_TEST_CORE_H
#define LV_TEST_CORE_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void lv_test_core(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif /*LV_TEST_CORE_H*/

210
tests/lv_test_core/lv_test_font_loader.c
View File

@ -1,210 +0,0 @@
/**
* @file lv_test_font_loader.c
*
*/
/*********************
* INCLUDES
*********************/
#include "../../lvgl.h"
#if LV_BUILD_TEST
#include "../lv_test_assert.h"
#include "../../src/font/lv_font_fmt_txt.h"
#include "../../src/font/lv_font.h"
#include "../../src/font/lv_font_loader.h"
#include "lv_test_font_loader.h"
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static int compare_fonts(lv_font_t * f1, lv_font_t * f2);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
extern lv_font_t font_1;
extern lv_font_t font_2;
extern lv_font_t font_3;
void lv_test_font_loader(void)
{
lv_font_t * font_1_bin = lv_font_load("F:font_1.fnt");
lv_font_t * font_2_bin = lv_font_load("F:font_2.fnt");
lv_font_t * font_3_bin = lv_font_load("F:font_3.fnt");
compare_fonts(&font_1, font_1_bin);
compare_fonts(&font_2, font_2_bin);
compare_fonts(&font_3, font_3_bin);
lv_font_free(font_1_bin);
lv_font_free(font_2_bin);
lv_font_free(font_3_bin);
}
static int compare_fonts(lv_font_t * f1, lv_font_t * f2)
{
lv_test_assert_true(f1 != NULL && f2 != NULL, "font not null");
// Skip these test because -Wpedantic tells
// ISO C forbids passing argument 1 of ‘lv_test_assert_ptr_eq’ between function pointer and ‘void *’
// lv_test_assert_ptr_eq(f1->get_glyph_dsc, f2->get_glyph_dsc, "glyph_dsc");
// lv_test_assert_ptr_eq(f1->get_glyph_bitmap, f2->get_glyph_bitmap, "glyph_bitmap");
lv_test_assert_int_eq(f1->line_height, f2->line_height, "line_height");
lv_test_assert_int_eq(f1->base_line, f2->base_line, "base_line");
#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0)
lv_test_assert_int_eq(f1->subpx, f2->subpx, "subpx");
#endif
lv_font_fmt_txt_dsc_t * dsc1 = (lv_font_fmt_txt_dsc_t *)f1->dsc;
lv_font_fmt_txt_dsc_t * dsc2 = (lv_font_fmt_txt_dsc_t *)f2->dsc;
lv_test_assert_int_eq(dsc1->kern_scale, dsc2->kern_scale, "kern_scale");
lv_test_assert_int_eq(dsc1->cmap_num, dsc2->cmap_num, "cmap_num");
lv_test_assert_int_eq(dsc1->bpp, dsc2->bpp, "bpp");
lv_test_assert_int_eq(dsc1->kern_classes, dsc2->kern_classes, "kern_classes");
lv_test_assert_int_eq(dsc1->bitmap_format, dsc2->bitmap_format, "bitmap_format");
// cmaps
int total_glyphs = 0;
for(int i = 0; i < dsc1->cmap_num; ++i) {
lv_font_fmt_txt_cmap_t * cmaps1 = (lv_font_fmt_txt_cmap_t *)&dsc1->cmaps[i];
lv_font_fmt_txt_cmap_t * cmaps2 = (lv_font_fmt_txt_cmap_t *)&dsc2->cmaps[i];
lv_test_assert_int_eq(cmaps1->range_start, cmaps2->range_start, "range_start");
lv_test_assert_int_eq(cmaps1->range_length, cmaps2->range_length, "range_length");
lv_test_assert_int_eq(cmaps1->glyph_id_start, cmaps2->glyph_id_start, "glyph_id_start");
lv_test_assert_int_eq(cmaps1->type, cmaps2->type, "type");
lv_test_assert_int_eq(cmaps1->list_length, cmaps2->list_length, "list_length");
if(cmaps1->unicode_list != NULL && cmaps2->unicode_list != NULL) {
lv_test_assert_true(cmaps1->unicode_list && cmaps2->unicode_list, "unicode_list");
lv_test_assert_array_eq(
(uint8_t *)cmaps1->unicode_list,
(uint8_t *)cmaps2->unicode_list,
sizeof(uint16_t) * cmaps1->list_length,
"unicode_list");
total_glyphs += cmaps1->list_length;
}
else {
total_glyphs += cmaps1->range_length;
lv_test_assert_ptr_eq(cmaps1->unicode_list, cmaps2->unicode_list, "unicode_list");
}
if(cmaps1->glyph_id_ofs_list != NULL && cmaps2->glyph_id_ofs_list != NULL) {
uint8_t * ids1 = (uint8_t *)cmaps1->glyph_id_ofs_list;
uint8_t * ids2 = (uint8_t *)cmaps2->glyph_id_ofs_list;
lv_test_assert_array_eq(ids1, ids2, cmaps1->list_length, "glyph_id_ofs_list");
}
else {
lv_test_assert_ptr_eq(cmaps1->glyph_id_ofs_list, cmaps2->glyph_id_ofs_list, "glyph_id_ofs_list");
}
}
// kern_dsc
if (dsc1->kern_classes == 1 && dsc2->kern_classes == 1) {
lv_font_fmt_txt_kern_classes_t * kern1 = (lv_font_fmt_txt_kern_classes_t *)dsc1->kern_dsc;
lv_font_fmt_txt_kern_classes_t * kern2 = (lv_font_fmt_txt_kern_classes_t *)dsc2->kern_dsc;
if (kern1 != NULL && kern2 != NULL) {
lv_test_assert_int_eq(kern1->right_class_cnt, kern2->right_class_cnt, "right_class_cnt");
lv_test_assert_int_eq(kern1->left_class_cnt, kern2->left_class_cnt, "left_class_cnt");
lv_test_assert_array_eq(
(uint8_t *)kern1->left_class_mapping,
(uint8_t *)kern2->left_class_mapping,
kern1->left_class_cnt,
"left_class_mapping");
lv_test_assert_array_eq(
(uint8_t *)kern1->right_class_mapping,
(uint8_t *)kern2->right_class_mapping,
kern1->right_class_cnt,
"right_class_mapping");
lv_test_assert_array_eq(
(uint8_t *)kern1->class_pair_values,
(uint8_t *)kern2->class_pair_values,
kern1->right_class_cnt * kern1->left_class_cnt,
"class_pair_values");
}
else {
lv_test_assert_ptr_eq(kern1, kern2, "kern");
}
}
else if (dsc1->kern_classes == 0 && dsc2->kern_classes == 0) {
lv_font_fmt_txt_kern_pair_t * kern1 = (lv_font_fmt_txt_kern_pair_t *)dsc1->kern_dsc;
lv_font_fmt_txt_kern_pair_t * kern2 = (lv_font_fmt_txt_kern_pair_t *)dsc2->kern_dsc;
if (kern1 != NULL && kern2 != NULL) {
lv_test_assert_int_eq(kern1->glyph_ids_size, kern2->glyph_ids_size, "glyph_ids_size");
lv_test_assert_int_eq(kern1->pair_cnt, kern2->pair_cnt, "pair_cnt");
int ids_size;
if (kern1->glyph_ids_size == 0) {
ids_size = sizeof(int8_t) * 2 * kern1->pair_cnt;
}
else {
ids_size = sizeof(int16_t) * 2 * kern1->pair_cnt;
}
lv_test_assert_array_eq(kern1->glyph_ids, kern2->glyph_ids, ids_size, "glyph_ids");
lv_test_assert_array_eq(
(uint8_t * ) kern1->values,
(uint8_t * ) kern2->values,
kern1->pair_cnt,
"glyph_values");
}
}
lv_font_fmt_txt_glyph_dsc_t * glyph_dsc1 = (lv_font_fmt_txt_glyph_dsc_t *)dsc1->glyph_dsc;
lv_font_fmt_txt_glyph_dsc_t * glyph_dsc2 = (lv_font_fmt_txt_glyph_dsc_t *)dsc2->glyph_dsc;
for(int i = 0; i < total_glyphs; ++i) {
if (i < total_glyphs - 1) {
int size1 = glyph_dsc1[i+1].bitmap_index - glyph_dsc1[i].bitmap_index;
if (size1 > 0) {
lv_test_assert_array_eq(
dsc1->glyph_bitmap + glyph_dsc1[i].bitmap_index,
dsc2->glyph_bitmap + glyph_dsc2[i].bitmap_index,
size1 - 1, "glyph_bitmap");
}
}
lv_test_assert_int_eq(glyph_dsc1[i].adv_w, glyph_dsc2[i].adv_w, "adv_w");
lv_test_assert_int_eq(glyph_dsc1[i].box_w, glyph_dsc2[i].box_w, "box_w");
lv_test_assert_int_eq(glyph_dsc1[i].box_h, glyph_dsc2[i].box_h, "box_h");
lv_test_assert_int_eq(glyph_dsc1[i].ofs_x, glyph_dsc2[i].ofs_x, "ofs_x");
lv_test_assert_int_eq(glyph_dsc1[i].ofs_y, glyph_dsc2[i].ofs_y, "ofs_y");
}
LV_LOG_INFO("No differences found!");
return 0;
}
/**********************
* STATIC FUNCTIONS
**********************/
#endif // LV_BUILD_TEST

38
tests/lv_test_core/lv_test_font_loader.h
View File

@ -1,38 +0,0 @@
/**
* @file lv_test_font_loader.h
*
*/
#ifndef LV_TEST_FONT_LOADER_H
#define LV_TEST_FONT_LOADER_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void lv_test_font_loader(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif /*LV_TEST_FONT_LOADER_H*/

88
tests/lv_test_core/lv_test_obj.c
View File

@ -1,88 +0,0 @@
/**
* @file lv_test_obj.c
*
*/
/*********************
* INCLUDES
*********************/
#include "../../lvgl.h"
#include "../lv_test_assert.h"
#include "lv_test_obj.h"
#if LV_BUILD_TEST
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static void create_delete_change_parent(void);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_test_obj(void)
{
lv_test_print("");
lv_test_print("==================");
lv_test_print("Start lv_obj tests");
lv_test_print("==================");
create_delete_change_parent();
}
/**********************
* STATIC FUNCTIONS
**********************/
static void create_delete_change_parent(void)
{
lv_test_print("");
lv_test_print("Create, delete, change parent of a simple object:");
lv_test_print("-------------------------------------------------");
lv_test_print("Create an object on the default screen");
lv_test_assert_int_eq(0, lv_obj_get_child_cnt(lv_scr_act()), "Screen's children count before creation");
lv_obj_t * obj = lv_obj_create(lv_scr_act());
lv_test_assert_int_eq(1, lv_obj_get_child_cnt(lv_scr_act()), "Screen's children count after creation");
lv_test_assert_int_eq(0, lv_obj_get_child_cnt(obj), "New object's children count after creation");
lv_test_print("Delete the created object");
lv_obj_del(obj);
obj = NULL;
lv_test_assert_int_eq(0, lv_obj_get_child_cnt(lv_scr_act()), "Screen's children count after delete");
lv_test_print("Create two objects");
lv_obj_t * obj_parent = lv_obj_create(lv_scr_act());
lv_obj_t * obj_child = lv_obj_create(lv_scr_act());
lv_test_assert_int_eq(2, lv_obj_get_child_cnt(lv_scr_act()), "Screen's children count after creation");
lv_test_print("Change the parent of the second object to the first");
lv_obj_set_parent(obj_child, obj_parent);
lv_test_assert_int_eq(1, lv_obj_get_child_cnt(lv_scr_act()), "Screen's children count after parent change");
lv_test_assert_int_eq(1, lv_obj_get_child_cnt(obj_parent), "Parent object's children count after parent change");
lv_test_assert_int_eq(0, lv_obj_get_child_cnt(obj_child), "Child object's children count after parent change");
lv_test_print("Remove the parent object");
lv_obj_del(obj_parent);
lv_test_assert_int_eq(0, lv_obj_get_child_cnt(lv_scr_act()), "Screen's children count after delete");
}
#endif

38
tests/lv_test_core/lv_test_obj.h
View File

@ -1,38 +0,0 @@
/**
* @file lv_test_obj.h
*
*/
#ifndef LV_TEST_OBJ_H
#define LV_TEST_OBJ_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void lv_test_obj(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif /*LV_TEST_OBJ_H*/

618
tests/lv_test_core/lv_test_style.c
View File

@ -1,618 +0,0 @@
typedef int _keep_pedantic_happy;
///**
// * @file lv_test_style.c
// *
// */
//
///*********************
// * INCLUDES
// *********************/
//#include "../../lvgl.h"
//#include "../lv_test_assert.h"
//#include "lv_test_style.h"
//
//#if LV_BUILD_TEST
//
///*********************
// * DEFINES
// *********************/
//
///**********************
// * TYPEDEFS
// **********************/
//
///**********************
// * STATIC PROTOTYPES
// **********************/
//static void empty_style(void);
//static void add_remove_read_prop(void);
//static void cascade(void);
//static void copy(void);
//static void states(void);
//static void mem_leak(void);
//
///**********************
// * STATIC VARIABLES
// **********************/
//
///**********************
// * MACROS
// **********************/
//
///**********************
// * GLOBAL FUNCTIONS
// **********************/
//
//void lv_test_style(void)
//{
// lv_test_print("");
// lv_test_print("====================");
// lv_test_print("Start lv_style tests");
// lv_test_print("====================");
//
// empty_style();
// add_remove_read_prop();
// cascade();
// copy();
// states();
// mem_leak();
//}
//
///**********************
// * STATIC FUNCTIONS
// **********************/
//
//static void empty_style(void)
//{
// lv_test_print("");
// lv_test_print("Test empty styles:");
// lv_test_print("-----------------");
//
// lv_res_t found;
// lv_coord_t value;
// lv_opa_t opa;
// const void * ptr;
// lv_color_t color;
//
// lv_test_print("Get a properties from an empty style");
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get an 'int' property");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA, &opa);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get an 'opa' property");
//
// found = _lv_style_list_get_ptr(&style_list, LV_STYLE_TEXT_FONT, &ptr);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get a 'ptr' property");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR, &color);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get a 'color' property");
//}
//
//static void add_remove_read_prop(void)
//{
// lv_test_print("");
// lv_test_print("Add, remove and read properties:");
// lv_test_print("--------------------------------");
//
// lv_style_list_t style_list;
// lv_style_list_init(&style_list);
//
// lv_style_t style;
// lv_style_init(&style);
//
// _lv_style_list_add_style(&style_list, &style);
//
// lv_res_t found;
// lv_coord_t value;
// lv_opa_t opa;
// const void * ptr;
// lv_color_t color;
//
// lv_test_print("Add an empty style and read properties");
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get a non existing 'int' property");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA, &opa);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get a non existing 'opa' property");
//
// found = _lv_style_list_get_ptr(&style_list, LV_STYLE_TEXT_FONT, &ptr);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get a non existing 'ptr' property");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR, &color);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get a non existing 'color' property");
//
// lv_test_print("Set properties and read back the values");
// _lv_style_set_int(&style, LV_STYLE_TEXT_LINE_SPACE, 5);
// _lv_style_set_opa(&style, LV_STYLE_BG_OPA, LV_OPA_50);
// _lv_style_set_ptr(&style, LV_STYLE_TEXT_FONT, LV_THEME_DEFAULT_FONT_NORMAL);
// _lv_style_set_color(&style, LV_STYLE_BG_COLOR, lv_palette_main(LV_PALETTE_RED));
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an existing 'int' property");
// lv_test_assert_int_eq(5, value, "Get the value of an 'int' property");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA, &opa);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an existing 'opa' property");
// lv_test_assert_int_eq(LV_OPA_50, opa, "Get the value of an 'opa' property");
//
// found = _lv_style_list_get_ptr(&style_list, LV_STYLE_TEXT_FONT, &ptr);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an existing 'ptr' property");
// lv_test_assert_ptr_eq(LV_THEME_DEFAULT_FONT_NORMAL, ptr, "Get the value of a 'ptr' property");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an existing 'color' property");
// lv_test_assert_color_eq(lv_palette_main(LV_PALETTE_RED), color, "Get the value of a 'color' property");
//
// lv_test_print("Reset the style");
// lv_style_reset(&style);
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get an 'int' property from a reseted style");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA, &opa);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get an 'opa' property from a reseted style");
//
// found = _lv_style_list_get_ptr(&style_list, LV_STYLE_TEXT_FONT, &ptr);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get an 'ptr' property from a reseted style");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR, &color);
// lv_test_assert_int_eq(LV_RES_INV, found, "Get an 'color' property from a reseted style");
//
// /*Clean-up*/
// _lv_style_list_reset(&style_list);
//}
//
//static void cascade(void)
//{
// lv_test_print("");
// lv_test_print("Cascade style styles:");
// lv_test_print("----------------------");
//
// lv_style_list_t style_list;
// lv_style_list_init(&style_list);
//
// lv_style_t style_first;
// lv_style_init(&style_first);
// _lv_style_list_add_style(&style_list, &style_first);
//
// lv_style_t style_second;
// lv_style_init(&style_second);
// _lv_style_list_add_style(&style_list, &style_second);
//
// lv_res_t found;
// lv_coord_t value;
// lv_opa_t opa;
// const void * ptr;
// lv_color_t color;
//
// lv_test_print("Read properties set only in the firstly added style");
//
// _lv_style_set_int(&style_first, LV_STYLE_TEXT_LINE_SPACE, 5);
// _lv_style_set_opa(&style_first, LV_STYLE_BG_OPA, LV_OPA_50);
// _lv_style_set_ptr(&style_first, LV_STYLE_TEXT_FONT, LV_THEME_DEFAULT_FONT_NORMAL);
// _lv_style_set_color(&style_first, LV_STYLE_BG_COLOR, lv_palette_main(LV_PALETTE_RED));
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'int' property");
// lv_test_assert_int_eq(5, value, "Get the value of an 'int' property");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA, &opa);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'opa' property");
// lv_test_assert_int_eq(LV_OPA_50, opa, "Get the value of an 'opa' property");
//
// found = _lv_style_list_get_ptr(&style_list, LV_STYLE_TEXT_FONT, &ptr);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'ptr' property");
// lv_test_assert_ptr_eq(LV_THEME_DEFAULT_FONT_NORMAL, ptr, "Get the value of a 'ptr' property");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'color' property");
// lv_test_assert_color_eq(lv_palette_main(LV_PALETTE_RED), color, "Get the value of a 'color' property");
//
// lv_test_print("Overwrite the properties from the second style");
//
// _lv_style_set_int(&style_second, LV_STYLE_TEXT_LINE_SPACE, 10);
// _lv_style_set_opa(&style_second, LV_STYLE_BG_OPA, LV_OPA_60);
// _lv_style_set_ptr(&style_second, LV_STYLE_TEXT_FONT, LV_THEME_DEFAULT_FONT_NORMAL + 1);
// _lv_style_set_color(&style_second, LV_STYLE_BG_COLOR, lv_palette_main(LV_PALETTE_BLUE));
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an overwritten 'int' property");
// lv_test_assert_int_eq(10, value, "Get the value of an overwritten 'int' property");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA, &opa);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an overwritten 'opa' property");
// lv_test_assert_int_eq(LV_OPA_60, opa, "Get the value of an overwritten 'opa' property");
//
// found = _lv_style_list_get_ptr(&style_list, LV_STYLE_TEXT_FONT, &ptr);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an overwritten 'ptr' property");
// lv_test_assert_ptr_eq(LV_THEME_DEFAULT_FONT_NORMAL + 1, ptr, "Get the value of an overwritten 'ptr' property");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an overwritten 'color' property");
// lv_test_assert_color_eq(lv_palette_main(LV_PALETTE_BLUE), color, "Get the value of an overwritten 'color' property");
//
// lv_test_print("Overwrite the properties with the local style");
// _lv_style_list_set_local_int(&style_list, LV_STYLE_TEXT_LINE_SPACE, 20);
// _lv_style_list_set_local_opa(&style_list, LV_STYLE_BG_OPA, LV_OPA_70);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_TEXT_FONT, LV_THEME_DEFAULT_FONT_NORMAL + 2);
// _lv_style_list_set_local_color(&style_list, LV_STYLE_BG_COLOR, LV_COLOR_LIME);
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a local 'int' property");
// lv_test_assert_int_eq(20, value, "Get the value of a local 'int' property");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA, &opa);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a local 'opa' property");
// lv_test_assert_int_eq(LV_OPA_70, opa, "Get the value of a local 'opa' property");
//
// found = _lv_style_list_get_ptr(&style_list, LV_STYLE_TEXT_FONT, &ptr);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a local 'ptr' property");
// lv_test_assert_ptr_eq(LV_THEME_DEFAULT_FONT_NORMAL + 2, ptr, "Get the value of a local'ptr' property");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a local 'color' property");
// lv_test_assert_color_eq(LV_COLOR_LIME, color, "Get the value of a local'color' property");
//
// /*Clean-up*/
// _lv_style_list_reset(&style_list);
//}
//
//static void copy(void)
//{
// lv_test_print("");
// lv_test_print("Copy styles and style lists");
// lv_test_print("---------------------------");
//
// lv_test_print("Copy a style");
// lv_style_t style_src;
// lv_style_init(&style_src);
// _lv_style_set_int(&style_src, LV_STYLE_TEXT_LINE_SPACE, 5);
//
// lv_style_t style_dest;
// lv_style_init(&style_dest);
// lv_style_copy(&style_dest, &style_src);
//
// int16_t weight;
// lv_coord_t value;
//
// weight = _lv_style_get_int(&style_dest, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(0, weight, "Get a copied property from a style");
// lv_test_assert_int_eq(5, value, "Get the value of a copied from a property");
//
// lv_test_print("Copy a style list");
// lv_style_list_t list_src;
// lv_style_list_init(&list_src);
// _lv_style_list_add_style(&list_src, &style_src);
// _lv_style_list_set_local_int(&list_src, LV_STYLE_LINE_DASH_WIDTH, 20);
//
// lv_style_list_t list_dest;
// lv_style_list_init(&list_dest);
// lv_style_list_copy(&list_dest, &list_src);
//
// lv_res_t found;
// found = _lv_style_list_get_int(&list_dest, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a copied property from a list");
// lv_test_assert_int_eq(5, value, "Get the value of a copied property from a list");
// found = _lv_style_list_get_int(&list_dest, LV_STYLE_LINE_DASH_WIDTH, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a copied local property from a list");
// lv_test_assert_int_eq(20, value, "Get the value of a copied local property from a list");
//
// /*Clean up*/
// _lv_style_list_reset(&list_dest);
// _lv_style_list_reset(&list_src);
//
// lv_style_reset(&style_dest);
// lv_style_reset(&style_src);
//}
//
//static void states(void)
//{
// lv_test_print("");
// lv_test_print("Test style states:");
// lv_test_print("------------------");
//
// lv_style_list_t style_list;
// lv_style_list_init(&style_list);
//
// lv_style_t style_first;
// lv_style_init(&style_first);
// _lv_style_list_add_style(&style_list, &style_first);
//
// lv_style_t style_second;
// lv_style_init(&style_second);
// _lv_style_list_add_style(&style_list, &style_second);
//
// lv_test_print("Test state precedence in 1 style");
// _lv_style_set_int(&style_first, LV_STYLE_TEXT_LINE_SPACE, 5);
// _lv_style_set_int(&style_first, LV_STYLE_TEXT_LINE_SPACE | (LV_STATE_CHECKED) << LV_STYLE_STATE_POS, 6);
// _lv_style_set_int(&style_first, LV_STYLE_TEXT_LINE_SPACE | (LV_STATE_PRESSED) << LV_STYLE_STATE_POS, 7);
//
// lv_res_t found;
// lv_coord_t value;
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'int' property in normal state");
// lv_test_assert_int_eq(5, value, "Get the value of an 'int' property in normal state");
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE | (LV_STATE_CHECKED) << LV_STYLE_STATE_POS, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'int' property in checked state");
// lv_test_assert_int_eq(6, value, "Get the value of an 'int' in checked state");
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE | (LV_STATE_PRESSED) << LV_STYLE_STATE_POS, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'int' property in pressed state");
// lv_test_assert_int_eq(7, value, "Get the value of an 'int' in pressed state");
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE | (LV_STATE_HOVERED) << LV_STYLE_STATE_POS, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'int' property in hover (unspecified) state");
// lv_test_assert_int_eq(5, value, "Get the value of an 'int' in hover (unspecified) state");
//
// found = _lv_style_list_get_int(&style_list, LV_STYLE_TEXT_LINE_SPACE | (LV_STATE_CHECKED | LV_STATE_PRESSED | LV_STATE_HOVERED) << LV_STYLE_STATE_POS, &value);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'int' property in checked pressed hovered state");
// lv_test_assert_int_eq(7, value, "Get the value of an 'int' in checked pressed hovered state");
//
// lv_test_print("Test state precedence in 1 style with combined states");
// _lv_style_set_opa(&style_first, LV_STYLE_BG_OPA, LV_OPA_50);
// _lv_style_set_opa(&style_first, LV_STYLE_BG_OPA | (LV_STATE_CHECKED | LV_STATE_PRESSED) << LV_STYLE_STATE_POS, LV_OPA_60);
//
// lv_opa_t opa;
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA , &opa);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'opa' property in normal state");
// lv_test_assert_int_eq(LV_OPA_50, opa, "Get the value of an 'int' in normal state");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA | (LV_STATE_CHECKED) << LV_STYLE_STATE_POS, &opa);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'opa' property in checked (unspecified) state");
// lv_test_assert_int_eq(LV_OPA_50, opa, "Get the value of an 'int' in checked (unspecified) state");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA | (LV_STATE_CHECKED | LV_STATE_PRESSED) << LV_STYLE_STATE_POS, &opa);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'opa' property in checked pressed state");
// lv_test_assert_int_eq(LV_OPA_60, opa, "Get the value of an 'int' in checked pressed state");
//
// found = _lv_style_list_get_opa(&style_list, LV_STYLE_BG_OPA | (LV_STATE_CHECKED | LV_STATE_PRESSED | LV_STATE_HOVERED) << LV_STYLE_STATE_POS, &opa);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get an 'opa' property in checked pressed hovered state");
// lv_test_assert_int_eq(LV_OPA_60, opa, "Get the value of an 'int' in checked pressed hovered state");
//
// lv_test_print("Test state precedence in 2 styles");
// _lv_style_set_color(&style_first, LV_STYLE_BG_COLOR, LV_COLOR_YELLOW);
// _lv_style_set_color(&style_first, LV_STYLE_BG_COLOR | (LV_STATE_HOVERED) << LV_STYLE_STATE_POS, lv_palette_main(LV_PALETTE_RED));
// _lv_style_set_color(&style_second, LV_STYLE_BG_COLOR | (LV_STATE_CHECKED) << LV_STYLE_STATE_POS, LV_COLOR_LIME);
// _lv_style_set_color(&style_second, LV_STYLE_BG_COLOR | (LV_STATE_HOVERED | LV_STATE_PRESSED) << LV_STYLE_STATE_POS, lv_palette_main(LV_PALETTE_BLUE));
//
// lv_color_t color;
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a 'color' property in normal state");
// lv_test_assert_color_eq(LV_COLOR_YELLOW, color, "Get the value of a 'color' property in normal state");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR | (LV_STATE_HOVERED) << LV_STYLE_STATE_POS, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a 'color' property in hovered state");
// lv_test_assert_color_eq(lv_palette_main(LV_PALETTE_RED), color, "Get the value of a 'color' in hovered state");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR | (LV_STATE_CHECKED) << LV_STYLE_STATE_POS, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a 'color' property in checked state");
// lv_test_assert_color_eq(LV_COLOR_LIME, color, "Get the value of a 'color' in checked state");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR | (LV_STATE_HOVERED | LV_STATE_PRESSED) << LV_STYLE_STATE_POS, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a 'color' property in hover pressed state");
// lv_test_assert_color_eq(lv_palette_main(LV_PALETTE_BLUE), color, "Get the value of a 'color' in hover pressed state");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR | (LV_STATE_EDITED) << LV_STYLE_STATE_POS, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a 'color' property in edit (unspecified) state");
// lv_test_assert_color_eq(LV_COLOR_YELLOW, color, "Get the value of a 'color' in edit (unspecified) state");
//
// found = _lv_style_list_get_color(&style_list, LV_STYLE_BG_COLOR | (LV_STATE_CHECKED | LV_STATE_EDITED) << LV_STYLE_STATE_POS, &color);
// lv_test_assert_int_eq(LV_RES_OK, found, "Get a 'color' property in checked edit state");
// lv_test_assert_color_eq(LV_COLOR_LIME, color, "Get the value of a 'color' in checked edit state");
//
// /*Clean-up*/
// _lv_style_list_reset(&style_list);
//}
//
//static void mem_leak(void)
//{
//
// lv_test_print("");
// lv_test_print("Test style set, add, remove memory leak");
// lv_test_print("----------------------------------------");
//
// lv_mem_monitor_t mon_start;
// lv_mem_monitor_t mon_end;
//
// lv_style_list_t style_list;
// lv_style_list_init(&style_list);
//
// lv_style_t style1;
// lv_style_init(&style1);
//
// lv_style_t style2;
// lv_style_init(&style2);
//
// lv_style_t style3;
// lv_style_init(&style3);
//
// uint32_t i;
//
// lv_test_print("Set style properties");
// lv_mem_monitor(&mon_start);
// for(i = 0; i < 100; i++) {
// _lv_style_set_color(&style2, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
//
// _lv_style_set_color(&style3, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
// _lv_style_set_color(&style3, LV_STYLE_LINE_COLOR | (LV_STATE_EDITED) << LV_STYLE_STATE_POS, lv_palette_main(LV_PALETTE_BLUE));
// _lv_style_set_color(&style3, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_BLUE));
// _lv_style_set_color(&style3, LV_STYLE_LINE_COLOR | (LV_STATE_EDITED | LV_STATE_FOCUSED) << LV_STYLE_STATE_POS, LV_COLOR_GREEN);
//
// _lv_style_set_color(&style3, LV_STYLE_BG_COLOR, lv_palette_main(LV_PALETTE_RED));
//
// _lv_style_set_color(&style3, LV_STYLE_IMAGE_RECOLOR, lv_palette_main(LV_PALETTE_RED));
//
// lv_style_reset(&style1);
// lv_style_reset(&style2);
// lv_style_reset(&style3);
//
// }
//
// lv_test_assert_int_eq(LV_RES_OK, lv_mem_test(), "Memory integrity check");
// lv_mem_monitor(&mon_end);
// lv_test_assert_int_lt(sizeof(void*) * 8, mon_start.free_size - mon_end.free_size, "Style memory leak");
//
// lv_test_print("Use local style");
// lv_mem_monitor(&mon_start);
// for(i = 0; i < 100; i++) {
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED) << LV_STYLE_STATE_POS, LV_THEME_DEFAULT_FONT_NORMAL);
//
// _lv_style_list_reset(&style_list);
//
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED) << LV_STYLE_STATE_POS, NULL);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
//
// _lv_style_list_reset(&style_list);
// }
//
// _lv_style_list_reset(&style_list);
// lv_test_assert_int_eq(LV_RES_OK, lv_mem_test(), "Memory integrity check");
// lv_mem_monitor(&mon_end);
// lv_test_assert_int_lt(sizeof(void*) * 8, mon_start.free_size - mon_end.free_size, "Style memory leak");
//
// lv_test_print("Add styles");
// lv_mem_monitor(&mon_start);
// for(i = 0; i < 100; i++) {
// _lv_style_set_color(&style1, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
// _lv_style_set_color(&style2, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
// _lv_style_set_color(&style3, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
//
// _lv_style_list_add_style(&style_list, &style1);
// _lv_style_list_remove_style(&style_list, &style1);
//
// _lv_style_list_add_style(&style_list, &style2);
// _lv_style_list_add_style(&style_list, &style3);
//
// _lv_style_list_remove_style(&style_list, &style2);
// _lv_style_list_add_style(&style_list, &style1);
//
// _lv_style_list_reset(&style_list);
// lv_style_reset(&style1);
// lv_style_reset(&style2);
// lv_style_reset(&style3);
// }
//
// lv_test_assert_int_eq(LV_RES_OK, lv_mem_test(), "Memory integrity check");
// lv_mem_monitor(&mon_end);
// lv_test_assert_int_lt(sizeof(void*) * 8, mon_start.free_size - mon_end.free_size, "Style memory leak");
//
// lv_test_print("Add styles and use local style");
// lv_mem_monitor(&mon_start);
// for(i = 0; i < 100; i++) {
// _lv_style_set_color(&style1, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
// _lv_style_set_color(&style2, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
// _lv_style_set_color(&style3, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
//
// if(i % 2 == 0) _lv_style_list_set_local_color(&style_list, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
//
// _lv_style_list_add_style(&style_list, &style1);
// _lv_style_list_remove_style(&style_list, &style1);
//
// _lv_style_list_add_style(&style_list, &style2);
// _lv_style_list_add_style(&style_list, &style3);
//
// _lv_style_list_remove_style(&style_list, &style2);
// _lv_style_list_add_style(&style_list, &style1);
//
// if(i % 2 != 0) _lv_style_list_set_local_color(&style_list, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
//
// _lv_style_list_reset(&style_list);
// lv_style_reset(&style1);
// lv_style_reset(&style2);
// lv_style_reset(&style3);
// }
//
// lv_test_assert_int_eq(LV_RES_OK, lv_mem_test(), "Memory integrity check");
// lv_mem_monitor(&mon_end);
// lv_test_assert_int_lt(sizeof(void*) * 8, mon_start.free_size - mon_end.free_size, "Style memory leak");
//
// lv_test_print("Complex test");
//
// lv_mem_monitor(&mon_start);
//
// for(i = 0; i < 100; i++) {
// if(i % 2 == 0) {
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_CLOSE);
// }
//
// _lv_style_set_color(&style1, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_RED));
// _lv_style_set_color(&style1, LV_STYLE_LINE_COLOR | (LV_STATE_EDITED) << LV_STYLE_STATE_POS, lv_palette_main(LV_PALETTE_BLUE));
// _lv_style_set_color(&style1, LV_STYLE_LINE_COLOR, lv_palette_main(LV_PALETTE_BLUE));
// _lv_style_set_color(&style1, LV_STYLE_LINE_COLOR | (LV_STATE_EDITED | LV_STATE_FOCUSED) << LV_STYLE_STATE_POS, LV_COLOR_GREEN);
//
// _lv_style_list_add_style(&style_list, &style1);
//
// if(i % 4 == 0) {
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_CLOSE);
// }
//
// _lv_style_list_remove_style(&style_list, &style1);
//
// _lv_style_set_opa(&style2, LV_STYLE_TEXT_OPA, LV_OPA_10);
// _lv_style_set_opa(&style2, LV_STYLE_TEXT_OPA, LV_OPA_20);
// _lv_style_set_opa(&style2, LV_STYLE_TEXT_OPA, LV_OPA_30);
// _lv_style_set_opa(&style2, LV_STYLE_TEXT_OPA, LV_OPA_40);
// _lv_style_set_opa(&style2, LV_STYLE_TEXT_OPA, LV_OPA_50);
// _lv_style_set_opa(&style2, LV_STYLE_TEXT_OPA, LV_OPA_60);
//
// _lv_style_list_add_style(&style_list, &style2);
//
// if(i % 8 == 0) {
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_CLOSE);
// }
//
// _lv_style_list_add_style(&style_list, &style2);
// _lv_style_list_add_style(&style_list, &style2);
// _lv_style_list_add_style(&style_list, &style2);
// _lv_style_list_add_style(&style_list, &style2);
// _lv_style_list_remove_style(&style_list, &style2);
//
// _lv_style_set_int(&style3, LV_STYLE_PAD_LEFT, 10);
// _lv_style_set_int(&style3, LV_STYLE_PAD_RIGHT, 20);
// _lv_style_set_int(&style3, LV_STYLE_PAD_LEFT, 11);
// _lv_style_set_int(&style3, LV_STYLE_PAD_RIGHT, 21);
// _lv_style_set_int(&style3, LV_STYLE_PAD_LEFT, 12);
// _lv_style_set_int(&style3, LV_STYLE_PAD_RIGHT, 22);
// _lv_style_set_int(&style3, LV_STYLE_PAD_LEFT, 12);
// _lv_style_set_int(&style3, LV_STYLE_PAD_RIGHT, 23);
//
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED) << LV_STYLE_STATE_POS, LV_THEME_DEFAULT_FONT_NORMAL);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED) << LV_STYLE_STATE_POS, NULL);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
// _lv_style_list_set_local_ptr(&style_list, LV_STYLE_PATTERN_IMAGE, LV_SYMBOL_OK);
//
// _lv_style_list_add_style(&style_list, &style3);
// _lv_style_list_add_style(&style_list, &style2);
// _lv_style_list_add_style(&style_list, &style1);
//
// _lv_style_list_reset(&style_list);
// lv_style_reset(&style1);
// lv_style_reset(&style2);
// lv_style_reset(&style3);
//
// }
//
// _lv_style_list_reset(&style_list);
// lv_style_reset(&style1);
// lv_style_reset(&style2);
// lv_style_reset(&style3);
//
// lv_test_assert_int_eq(LV_RES_OK, lv_mem_test(), "Memory integrity check");
// lv_mem_monitor(&mon_end);
// lv_test_assert_int_lt(sizeof(void*) * 8, mon_start.free_size - mon_end.free_size, "Style memory leak");
//}
//#endif

38
tests/lv_test_core/lv_test_style.h
View File

@ -1,38 +0,0 @@
/**
* @file lv_test_style.h
*
*/
#ifndef LV_TEST_STYLE_H
#define LV_TEST_STYLE_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void lv_test_style(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif /*LV_TEST_STYLE_H*/

1378
tests/lv_test_fonts/font_1.c
View File

File diff suppressed because it is too large Load Diff

1408
tests/lv_test_fonts/font_2.c
View File

File diff suppressed because it is too large Load Diff

946
tests/lv_test_fonts/font_3.c
View File

@ -1,946 +0,0 @@
#include "../../lvgl.h"
/*******************************************************************************
* Size: 20 px
* Bpp: 4
* Opts: --bpp 4 --size 20 --font ../RobotoMono-Regular.ttf -r 0x20-0x7f --format lvgl -o ..\generated_fonts/font_3.c
******************************************************************************/
#ifndef FONT_3
#define FONT_3 1
#endif
#if FONT_3
/*-----------------
* BITMAPS
*----------------*/
/*Store the image of the glyphs*/
static LV_ATTRIBUTE_LARGE_CONST const uint8_t gylph_bitmap[] = {
/* U+20 " " */
/* U+21 "!" */
0x1f, 0xb0, 0xf, 0xfe, 0x69, 0x10, 0x76, 0x40,
0x30, 0x81, 0x76, 0x98, 0xb0,
/* U+22 "\"" */
0x8e, 0x0, 0x7b, 0x0, 0x7c, 0x60, 0x11, 0x80,
0x80, 0x43, 0xca, 0x0, 0x37,
/* U+23 "#" */
0x0, 0xc5, 0xe6, 0x7, 0xe6, 0x1, 0xc8, 0x6,
0xa, 0x6, 0x1, 0xde, 0x40, 0xf, 0x30, 0xf,
0x2a, 0x0, 0x15, 0x40, 0x15, 0x7f, 0x8d, 0xbf,
0xc6, 0xde, 0xe1, 0xd2, 0xe0, 0xf2, 0xe0, 0xf2,
0x80, 0x8d, 0x81, 0x2d, 0xa1, 0x2c, 0x60, 0x11,
0x88, 0x80, 0x84, 0x40, 0x1d, 0xc4, 0x0, 0xd2,
0x0, 0xc2, 0x25, 0x61, 0x13, 0x30, 0x40, 0xd,
0xdc, 0x35, 0xee, 0x1a, 0xf6, 0x3, 0xdd, 0x4,
0x5c, 0x84, 0xdf, 0x80, 0xa0, 0x1, 0x90, 0xc1,
0x90, 0xc0, 0x2d, 0x21, 0xd, 0x20, 0xf, 0x1b,
0x80, 0x11, 0x0, 0x18,
/* U+24 "$" */
0x0, 0xcb, 0xe2, 0x1, 0xff, 0xc4, 0x78, 0xb,
0x40, 0xd, 0xb0, 0x64, 0xb6, 0xe0, 0x8, 0x27,
0xed, 0xd0, 0xc0, 0x82, 0x4, 0x0, 0xa, 0x41,
0xc0, 0x40, 0x38, 0xc8, 0x0, 0xe0, 0xe0, 0x12,
0x6b, 0x5, 0x84, 0x5a, 0x0, 0x70, 0xe9, 0xa5,
0xea, 0x80, 0x62, 0xcc, 0x29, 0x54, 0x80, 0x71,
0xd6, 0x93, 0x21, 0x29, 0x0, 0x45, 0x21, 0xaf,
0x4a, 0x1, 0x9c, 0xd, 0x2, 0x44, 0x2, 0xa0,
0xd1, 0x71, 0xf8, 0x86, 0x31, 0x38, 0x44, 0x9b,
0xb8, 0x97, 0x0, 0x26, 0xd6, 0x1e, 0xa1, 0x0,
0xe1, 0x0, 0xe0,
/* U+25 "%" */
0x7, 0xee, 0x40, 0x7, 0xc9, 0x10, 0xb7, 0x50,
0xf, 0x61, 0x32, 0xa7, 0x80, 0xf1, 0x80, 0x42,
0x1, 0xd2, 0x66, 0x0, 0x69, 0x98, 0x97, 0x45,
0xe0, 0x2, 0x55, 0x66, 0xab, 0xc1, 0x28, 0x6,
0xae, 0xe5, 0x8b, 0x48, 0x7, 0x84, 0x41, 0x6,
0x80, 0x1f, 0x89, 0xa0, 0x3, 0xfa, 0x11, 0x13,
0xdc, 0x70, 0xc, 0x6b, 0xc, 0xca, 0x88, 0x20,
0x5, 0x8, 0x78, 0xa8, 0xc5, 0x80, 0x13, 0x40,
0x7, 0xfb, 0x4c, 0x31, 0x51, 0x8b, 0x0, 0x3c,
0xcc, 0xa8, 0x82, 0x0,
/* U+26 "&" */
0x0, 0x26, 0x7e, 0xb0, 0x7, 0x15, 0x9b, 0xc,
0xa8, 0x6, 0xa0, 0xa9, 0xc1, 0xe0, 0xc, 0x40,
0xe0, 0x13, 0x80, 0x63, 0x7, 0x6, 0x1b, 0x0,
0xd4, 0x12, 0xf2, 0xae, 0x1, 0x8d, 0x8e, 0x1a,
0x80, 0x38, 0x90, 0x1, 0x40, 0x1c, 0x38, 0x50,
0x1a, 0x20, 0xbc, 0x70, 0x32, 0xf2, 0x34, 0x1a,
0x22, 0x40, 0x60, 0x65, 0x47, 0x51, 0x23, 0x10,
0xa, 0x8a, 0xa, 0x41, 0x5, 0x0, 0x2a, 0x0,
0x30, 0x40, 0x5d, 0x45, 0xc0, 0x84, 0x1, 0x6a,
0xa3, 0xb4, 0x71, 0xb2, 0x0,
/* U+27 "'" */
0x2f, 0x50, 0xe, 0x10, 0x3, 0x81, 0x88,
/* U+28 "(" */
0x0, 0xe1, 0x0, 0xd9, 0x20, 0x15, 0x8c, 0x80,
0x1d, 0x38, 0x40, 0x10, 0xa6, 0x0, 0x70, 0x90,
0xa, 0xc4, 0xc0, 0x2, 0x68, 0x1, 0x28, 0x68,
0x4, 0x40, 0x20, 0x10, 0x81, 0x80, 0x70, 0x80,
0x42, 0x2, 0x1, 0x18, 0x18, 0x4, 0xe1, 0xe0,
0x11, 0xa, 0x80, 0x67, 0x31, 0x0, 0xac, 0x24,
0x2, 0x25, 0x60, 0xd, 0x61, 0x40, 0x10, 0xea,
0xb8, 0x4, 0x7a, 0x80,
/* U+29 ")" */
0x20, 0xe, 0xe9, 0x0, 0xde, 0xd0, 0x1, 0x1c,
0x39, 0x80, 0x4e, 0x5e, 0x1, 0xa8, 0xcc, 0x1,
0x28, 0x50, 0x4, 0x42, 0x80, 0x19, 0x48, 0x40,
0x21, 0x2, 0x0, 0x8c, 0x1c, 0x2, 0x10, 0xe,
0x10, 0x70, 0x8, 0xc0, 0x80, 0x27, 0x11, 0x0,
0x44, 0x80, 0x12, 0x87, 0x80, 0x5c, 0x2a, 0x0,
0x34, 0x80, 0xb, 0x8d, 0x80, 0x14, 0x1a, 0x1,
0x7e, 0x8, 0x4,
/* U+2A "*" */
0x0, 0xd3, 0xe2, 0x1, 0xf0, 0x80, 0x80, 0x61,
0x0, 0x78, 0x6, 0x12, 0xeb, 0x41, 0x10, 0x36,
0xc0, 0xaa, 0xae, 0x47, 0xe4, 0xc0, 0xeb, 0xb0,
0x0, 0xdb, 0xd2, 0x1, 0x50, 0xab, 0x98, 0x6,
0x66, 0x45, 0x8d, 0x0, 0x43, 0x24, 0xc3, 0x8,
0xe0, 0x1, 0xbe, 0x0, 0x3b, 0xc0,
/* U+2B "+" */
0x0, 0xd1, 0x0, 0xf, 0xca, 0xc0, 0x1f, 0xfd,
0x6d, 0xff, 0x88, 0x7f, 0xee, 0x62, 0x28, 0x0,
0x45, 0xaf, 0x76, 0x21, 0xdd, 0xb0, 0x3, 0xff,
0xa4,
/* U+2C "," */
0xa, 0xf4, 0x1, 0x0, 0x9c, 0x18, 0x8, 0x49,
0x46, 0x1, 0x69, 0x80,
/* U+2D "-" */
0x78, 0x8f, 0x25, 0x3b, 0xfb, 0x40,
/* U+2E "." */
0x8, 0xc3, 0x17, 0x39, 0x14, 0xf,
/* U+2F "/" */
0x0, 0xf6, 0x68, 0x7, 0x88, 0xe8, 0x3, 0xd4,
0xc, 0x1, 0xe6, 0x41, 0x0, 0xe4, 0x1e, 0x0,
0xf7, 0x2, 0x80, 0x79, 0x58, 0x3, 0xcc, 0x14,
0x1, 0xed, 0x23, 0x0, 0xe1, 0x4a, 0x0, 0xf3,
0x2, 0x80, 0x7a, 0x90, 0x80, 0x38, 0xcb, 0x40,
0x3d, 0x40, 0xc0, 0x1e, 0x65, 0x0, 0xf2, 0x87,
0x0, 0x78,
/* U+30 "0" */
0x0, 0x25, 0xff, 0xb1, 0x0, 0x25, 0xb5, 0x66,
0x15, 0xa8, 0x2, 0xc7, 0xe6, 0x5e, 0x34, 0x8,
0x32, 0x20, 0x1, 0x90, 0x53, 0x2, 0x0, 0xc2,
0x1b, 0xe0, 0xc0, 0x14, 0x48, 0x8, 0x80, 0x21,
0xb7, 0x50, 0xe, 0x3c, 0x4b, 0x80, 0xd, 0x58,
0x1a, 0x80, 0x10, 0x83, 0x2e, 0x90, 0x8, 0x3,
0xc1, 0xe8, 0x3, 0x84, 0xc3, 0xc0, 0x32, 0x86,
0xa0, 0xc8, 0x80, 0x56, 0xa, 0x16, 0x3f, 0x32,
0xe2, 0x90, 0x2, 0xda, 0xb3, 0xa, 0xd8, 0x0,
/* U+31 "1" */
0x0, 0xc4, 0x80, 0x6, 0xcd, 0xc9, 0xf9, 0x30,
0x3, 0x25, 0xd8, 0x1, 0xd6, 0x8e, 0x0, 0x10,
0xf, 0xff, 0x78,
/* U+32 "2" */
0x0, 0xc, 0xf7, 0xf4, 0x0, 0x62, 0xf6, 0x56,
0x27, 0xd0, 0xa, 0x46, 0xed, 0x38, 0xa4, 0xe0,
0x4, 0x34, 0x0, 0xa0, 0x30, 0x5, 0xe4, 0x3,
0x18, 0x4, 0x30, 0xa0, 0x19, 0x3, 0x0, 0x3f,
0x40, 0x30, 0x7, 0xd2, 0x52, 0x20, 0x1e, 0x76,
0x56, 0x0, 0xf2, 0x41, 0xd0, 0x7, 0x8e, 0xcb,
0x40, 0x3c, 0x3a, 0x3e, 0x20, 0x1e, 0xc1, 0xd2,
0x0, 0xf5, 0x91, 0xa3, 0xbf, 0x18, 0x28, 0x1c,
0x47, 0x94,
/* U+33 "3" */
0x0, 0xc, 0xf7, 0xf4, 0x0, 0x43, 0xec, 0xae,
0xaf, 0xa0, 0xb, 0x1a, 0xb8, 0xb7, 0x26, 0x4,
0x15, 0x0, 0xa8, 0x30, 0x3b, 0x80, 0x1f, 0xfc,
0x2b, 0xf, 0x0, 0x85, 0xe7, 0x59, 0xd4, 0x2,
0x38, 0x62, 0x1c, 0x0, 0xc5, 0xfe, 0xb3, 0xb4,
0x0, 0xf2, 0x78, 0x78, 0x8, 0x80, 0x31, 0xa,
0x87, 0x60, 0x7, 0x9, 0x81, 0x92, 0x0, 0x4c,
0x8, 0x1c, 0x17, 0x68, 0xb9, 0x28, 0x2, 0xe6,
0x57, 0x57, 0xd1,
/* U+34 "4" */
0x0, 0xf1, 0xff, 0x80, 0x3f, 0x78, 0x7, 0xf3,
0x18, 0x7, 0xe1, 0x94, 0x30, 0xf, 0xac, 0x28,
0x3, 0xe4, 0x58, 0x10, 0xf, 0xa4, 0x9c, 0x3,
0xe7, 0x29, 0x0, 0xf8, 0xa1, 0x50, 0x3, 0xe9,
0xb, 0x0, 0xf8, 0xd0, 0x3b, 0xfe, 0x30, 0xff,
0xc, 0x47, 0x84, 0x1e, 0x9, 0xdf, 0xc4, 0x10,
0xe0, 0x1f, 0xfc, 0xa0,
/* U+35 "5" */
0x0, 0x7f, 0xfc, 0xa0, 0x20, 0x26, 0x7c, 0x20,
0x60, 0xd9, 0x9c, 0x80, 0xc1, 0xc0, 0x1f, 0x8,
0x18, 0x7, 0xc4, 0x7, 0x15, 0x6, 0x1, 0x78,
0x4b, 0xab, 0xe3, 0x80, 0x38, 0xa7, 0xb9, 0x21,
0x4, 0xd, 0xac, 0x22, 0x68, 0xa, 0x0, 0xf9,
0x40, 0xc0, 0x3e, 0x30, 0x0, 0xfd, 0x80, 0x62,
0x2, 0x13, 0x43, 0x0, 0xa0, 0x30, 0x38, 0x32,
0xa7, 0x51, 0xa, 0x5, 0xaa, 0x8c, 0xf, 0x60,
/* U+36 "6" */
0x0, 0x86, 0x37, 0xd4, 0x3, 0x27, 0x39, 0xa3,
0x0, 0x45, 0x61, 0x5d, 0x66, 0x1, 0x48, 0x52,
0x80, 0x70, 0xa1, 0xa8, 0x7, 0x90, 0x2c, 0x59,
0xd4, 0x2, 0x20, 0xde, 0x98, 0xad, 0x10, 0xe0,
0x58, 0xee, 0x31, 0x50, 0x5, 0xe, 0x22, 0x92,
0x41, 0x0, 0x20, 0x6, 0x50, 0x51, 0x6, 0x0,
0xde, 0x3, 0x81, 0xa0, 0x1b, 0x41, 0x90, 0x9c,
0x80, 0x4, 0xa2, 0x61, 0xc1, 0xb5, 0x4d, 0xa,
0x0, 0x1e, 0x22, 0xa9, 0x31, 0x0,
/* U+37 "7" */
0xef, 0xff, 0xd6, 0xec, 0xde, 0x40, 0x39, 0x9f,
0x88, 0x24, 0x3, 0xc2, 0xca, 0x20, 0x1e, 0x60,
0x90, 0xf, 0xa4, 0x8c, 0x3, 0xca, 0x36, 0x1,
0xf4, 0x8b, 0x0, 0x78, 0xcc, 0xc0, 0x1f, 0x48,
0x50, 0x7, 0x85, 0x50, 0x80, 0x3d, 0x21, 0xe0,
0x1f, 0x31, 0x20, 0x7, 0x98, 0x68, 0x3, 0xeb,
0x6, 0x0, 0xe0,
/* U+38 "8" */
0x0, 0x15, 0x77, 0xea, 0x80, 0x43, 0xaa, 0x8c,
0x15, 0x20, 0xb, 0xa, 0xa4, 0xe9, 0x31, 0x2,
0x2, 0x80, 0x54, 0x8, 0x6, 0x1, 0xf1, 0x82,
0x2, 0x80, 0x54, 0x8, 0x12, 0x75, 0x49, 0xd2,
0xa1, 0x0, 0x50, 0x2b, 0x11, 0xa0, 0x1, 0xe5,
0x77, 0xe8, 0xb0, 0x42, 0xa, 0x88, 0x16, 0xc9,
0x8c, 0x10, 0x3, 0x20, 0x60, 0x0, 0xc0, 0x31,
0x80, 0xc, 0x54, 0x80, 0x2b, 0xd, 0xa, 0xd,
0xa8, 0xc6, 0x36, 0x4, 0xc4, 0x57, 0x17, 0xc0,
/* U+39 "9" */
0x0, 0x26, 0x7f, 0x51, 0x0, 0x4d, 0x64, 0xca,
0xac, 0x10, 0x4, 0x8f, 0xcd, 0xc8, 0xd8, 0x28,
0x48, 0x80, 0x18, 0x94, 0x34, 0xc, 0x3, 0x28,
0x27, 0x80, 0x7b, 0x80, 0x48, 0xc, 0x3, 0x70,
0x1a, 0x4, 0x88, 0x0, 0xdc, 0xc, 0x5c, 0x7e,
0x6b, 0x4, 0x4, 0x22, 0x4d, 0x9e, 0x1c, 0x18,
0x0, 0xdb, 0xfa, 0xea, 0x24, 0x1, 0xe3, 0x33,
0x80, 0x79, 0x34, 0x60, 0x2, 0x5b, 0xeb, 0xd,
0x10, 0xb, 0x54, 0x9f, 0xcc, 0x0,
/* U+3A ":" */
0x5f, 0xb0, 0xf0, 0x42, 0x93, 0x62, 0x3c, 0x90,
0xf, 0xfe, 0x29, 0xe4, 0x4, 0x9b, 0x97, 0x81,
0x90,
/* U+3B ";" */
0x6, 0xfa, 0x0, 0x68, 0x28, 0x3, 0xcd, 0xc0,
0x9, 0x90, 0x1, 0xff, 0xcf, 0x4a, 0x60, 0x1,
0x2f, 0x0, 0x4, 0x3, 0x70, 0x60, 0x1, 0x9,
0x0, 0xf, 0xc0, 0x0,
/* U+3C "<" */
0x0, 0xf9, 0x2c, 0x3, 0x9b, 0x6d, 0x40, 0x2,
0xfd, 0x26, 0xd8, 0x33, 0xd0, 0x55, 0xd2, 0x48,
0xc3, 0x78, 0xa0, 0x12, 0x28, 0xdd, 0x20, 0x4,
0x35, 0xac, 0xb7, 0xae, 0x20, 0x2, 0x9e, 0x83,
0x8f, 0x0, 0xc2, 0xfd, 0x24, 0x1, 0xf3, 0x60,
/* U+3D "=" */
0x39, 0x9f, 0xc6, 0xec, 0xdf, 0x95, 0x3f, 0xff,
0x30, 0x7, 0xf8, 0xa6, 0x7f, 0x1b, 0x37, 0xf2,
0x80,
/* U+3E ">" */
0x3a, 0x30, 0xf, 0x9d, 0x73, 0xa, 0x1, 0xc9,
0x8c, 0x75, 0xae, 0x1, 0x8e, 0x7e, 0x9a, 0x3e,
0x44, 0x3, 0x2d, 0xe1, 0x32, 0x0, 0x65, 0xbc,
0x25, 0x40, 0x28, 0xea, 0x57, 0xea, 0x13, 0xd7,
0x39, 0xe8, 0x10, 0x3, 0xa5, 0xeb, 0x0, 0x72,
0x5a, 0x0, 0x7c,
/* U+3F "?" */
0x0, 0x1d, 0xf7, 0xea, 0x80, 0x4b, 0x88, 0xaa,
0x3a, 0x80, 0x5, 0x86, 0xdd, 0x78, 0xb8, 0x89,
0xe0, 0x80, 0x2, 0xe0, 0x43, 0x2e, 0x1, 0x8c,
0x4, 0x3, 0xc4, 0xa4, 0x40, 0xf, 0x70, 0x48,
0x7, 0xb0, 0xe1, 0x0, 0x3a, 0x4d, 0xdc, 0x1,
0xe7, 0x18, 0x0, 0xf8, 0x9c, 0x3, 0xf6, 0x48,
0x7, 0xe1, 0x10, 0x7, 0xc3, 0xde, 0x1, 0xf8,
0x48, 0x3, 0x0,
/* U+40 "@" */
0x0, 0xd1, 0xbf, 0xae, 0x1, 0xc3, 0xab, 0x76,
0xa9, 0xb0, 0xd, 0x4d, 0xac, 0x8f, 0xea, 0xc0,
0x4, 0x5b, 0x9, 0xfd, 0x3b, 0xb0, 0x3, 0xe4,
0x25, 0x2d, 0x95, 0x44, 0x20, 0x8a, 0x2d, 0xc8,
0x2, 0x4, 0x43, 0x2, 0x41, 0x30, 0x72, 0x1,
0x77, 0x8, 0x12, 0x80, 0x5, 0xc0, 0x21, 0x30,
0xe2, 0x0, 0x10, 0x80, 0xb0, 0x98, 0x0, 0xc0,
0x40, 0xc4, 0xc9, 0x44, 0x5e, 0x88, 0xa0, 0x29,
0x40, 0x12, 0x67, 0xb, 0x26, 0xc5, 0xb0, 0x5,
0xc9, 0xf7, 0x26, 0x5d, 0xa2, 0x0, 0x64, 0xd8,
0x44, 0x3a, 0x80, 0x75, 0x4a, 0x55, 0xd9, 0xc0,
0x20,
/* U+41 "A" */
0x0, 0xec, 0xf0, 0xf, 0xe1, 0x30, 0x50, 0xf,
0xce, 0x0, 0xf0, 0xf, 0xda, 0x8, 0x80, 0xf,
0xc8, 0xba, 0x26, 0x1, 0xe4, 0xc, 0x70, 0xb0,
0xf, 0x68, 0x38, 0x92, 0x80, 0x79, 0xcc, 0x41,
0x48, 0x80, 0x18, 0xc6, 0xc0, 0x16, 0xa, 0x1,
0xac, 0x32, 0x66, 0xc, 0x0, 0xca, 0x8, 0xcc,
0x50, 0x41, 0x0, 0x11, 0x1b, 0xff, 0x50, 0x20,
0x1, 0x43, 0x40, 0x32, 0x7, 0x80, 0x30, 0x10,
0x3, 0x9, 0xa0, 0xa, 0x20, 0x3, 0xc8, 0x28,
/* U+42 "B" */
0x4f, 0xfd, 0xd8, 0xa0, 0x18, 0xd9, 0x88, 0x55,
0x40, 0xa, 0xe6, 0x55, 0xc6, 0xa8, 0x1, 0xf4,
0x86, 0x0, 0x7c, 0x61, 0xe0, 0x1e, 0x1b, 0x5,
0x0, 0x5c, 0x42, 0x7c, 0xa8, 0x80, 0x6, 0xee,
0x61, 0x36, 0x0, 0xa3, 0xfe, 0xb1, 0xc3, 0x0,
0xf2, 0x70, 0x40, 0x7, 0xc6, 0xa, 0x1, 0xf0,
0x81, 0x80, 0x7d, 0x0, 0xa0, 0xb, 0x88, 0x4e,
0xb1, 0xc0, 0x0, 0xdd, 0xcc, 0x11, 0x80,
/* U+43 "C" */
0x0, 0x15, 0xff, 0xb1, 0x80, 0x24, 0xd5, 0x53,
0x14, 0xc8, 0x1, 0x43, 0xf5, 0x3c, 0x6c, 0x6c,
0x30, 0x20, 0x17, 0x84, 0xe8, 0x38, 0x6, 0x35,
0x36, 0x11, 0x0, 0x75, 0x49, 0x18, 0x7, 0xff,
0x40, 0x8c, 0x3, 0xf3, 0x8, 0x80, 0x3a, 0x63,
0x41, 0xc0, 0x31, 0xb1, 0x30, 0xc0, 0x80, 0x50,
0x12, 0x14, 0x3f, 0x32, 0xd4, 0x73, 0x4, 0xc5,
0x76, 0x19, 0x80,
/* U+44 "D" */
0x7f, 0xfb, 0xb1, 0x80, 0x3c, 0xae, 0xe1, 0x9d,
0x10, 0xd, 0xf1, 0x3b, 0x25, 0x80, 0x1f, 0x99,
0x84, 0xc0, 0x1f, 0xa0, 0x34, 0x3, 0xf0, 0x92,
0x0, 0x7f, 0x8, 0x7, 0xf9, 0xc0, 0x40, 0x3f,
0x38, 0x8, 0x7, 0xe1, 0x0, 0xfe, 0x12, 0x40,
0xf, 0xd0, 0x1a, 0x1, 0xf3, 0xb1, 0xb0, 0x5,
0xf1, 0x3b, 0x5, 0xa0, 0x19, 0x5d, 0xc3, 0x3a,
0x20, 0x0,
/* U+45 "E" */
0x3f, 0xff, 0xcc, 0x0, 0x26, 0x6f, 0x28, 0x1,
0x26, 0x7c, 0x60, 0x1f, 0xfd, 0xe6, 0xff, 0xe8,
0x0, 0x89, 0xdf, 0xb0, 0x2, 0x48, 0x8e, 0x40,
0xf, 0xfe, 0xaa, 0x44, 0x79, 0x0, 0x4, 0xef,
0xec,
/* U+46 "F" */
0x2f, 0xff, 0xd2, 0x0, 0x26, 0x6f, 0x60, 0x1,
0xe6, 0x7c, 0xa0, 0x1f, 0xfd, 0xe5, 0xff, 0xe9,
0x0, 0x89, 0xdf, 0xb0, 0x2, 0x78, 0x8e, 0x50,
0xf, 0xff, 0x38,
/* U+47 "G" */
0x0, 0x8a, 0xff, 0xd8, 0xa0, 0x19, 0x35, 0x10,
0xa5, 0x52, 0x1, 0x50, 0xed, 0xd7, 0x1b, 0x20,
0x38, 0xc1, 0x0, 0x5e, 0x1e, 0x18, 0xe, 0x1,
0x8e, 0x78, 0x14, 0x44, 0x1, 0xcc, 0xa0, 0x24,
0x1, 0xff, 0xc2, 0x68, 0x89, 0xc0, 0x3d, 0xae,
0xf4, 0x80, 0x90, 0x5, 0x7f, 0xe2, 0x0, 0x28,
0x88, 0x3, 0xf6, 0x84, 0x80, 0x7e, 0x62, 0x74,
0x0, 0x88, 0x80, 0x17, 0x8d, 0xda, 0x6f, 0x42,
0x80, 0x5, 0xec, 0xac, 0xc7, 0xd4,
/* U+48 "H" */
0x9f, 0x10, 0xc, 0x3f, 0x20, 0x1f, 0xff, 0x2e,
0xff, 0xdc, 0x1, 0x99, 0xdf, 0x30, 0x6, 0x88,
0xf0, 0x7, 0xff, 0xa0,
/* U+49 "I" */
0x4f, 0xff, 0xc8, 0xcd, 0x80, 0xc, 0xd8, 0xa6,
0x60, 0x19, 0x98, 0x80, 0x3f, 0xff, 0xe0, 0x1f,
0xfc, 0xd2, 0x99, 0x80, 0x66, 0x62, 0x66, 0xc0,
0x6, 0x6c,
/* U+4A "J" */
0x0, 0xfd, 0x3e, 0x60, 0x1f, 0xff, 0xf0, 0xf,
0xfe, 0x6b, 0xb0, 0x7, 0x18, 0x5, 0x52, 0x1,
0xce, 0x6, 0x14, 0x12, 0x1, 0x39, 0x28, 0x1,
0xcd, 0xb6, 0x72, 0xa, 0xc0, 0x2c, 0x80, 0x62,
0x6c, 0x10,
/* U+4B "K" */
0x4f, 0x80, 0xc, 0x9f, 0xa0, 0x1f, 0x15, 0x7,
0x80, 0x7d, 0xc3, 0x44, 0x1, 0xe9, 0x36, 0x50,
0xf, 0x2b, 0x14, 0x80, 0x78, 0xa8, 0x3c, 0x3,
0xc3, 0xc1, 0x4, 0x1, 0xe6, 0x30, 0xa0, 0xf,
0xc8, 0xa5, 0x0, 0x1e, 0x2a, 0xb1, 0x72, 0x0,
0xe5, 0x11, 0x40, 0x70, 0x7, 0xe6, 0x33, 0x30,
0x7, 0xee, 0x8, 0x10, 0xf, 0x89, 0xc6, 0xc0,
0x3f, 0x41, 0x2a, 0x0,
/* U+4C "L" */
0xf, 0xb0, 0xf, 0xff, 0xf8, 0x7, 0xff, 0xa9,
0x62, 0x3c, 0xc0, 0x1, 0x77, 0xf6, 0x0,
/* U+4D "M" */
0x8f, 0xd0, 0xd, 0x5f, 0x60, 0x2, 0x20, 0x4,
0xa0, 0x1c, 0xa0, 0x5, 0x0, 0xe2, 0xb0, 0x7,
0x88, 0x80, 0x24, 0x31, 0x5, 0x60, 0xd, 0xa0,
0xea, 0x16, 0x1, 0x98, 0xb7, 0xc4, 0xc4, 0x3,
0x2a, 0x2b, 0x80, 0x7a, 0xc0, 0x1a, 0x1, 0xc2,
0x62, 0x24, 0x0, 0xf9, 0x98, 0x1, 0xfa, 0x20,
0x1, 0xff, 0xd6,
/* U+4E "N" */
0x9f, 0x70, 0xc, 0x7f, 0x20, 0x9, 0x0, 0xfe,
0x17, 0x0, 0xfe, 0x90, 0xf, 0xca, 0x2e, 0x1,
0xf7, 0xc, 0x80, 0x7c, 0xf0, 0x2c, 0x1, 0xf3,
0xc, 0x0, 0x7e, 0x81, 0x60, 0xf, 0x98, 0x61,
0xc0, 0x3e, 0x91, 0xe0, 0xf, 0x9c, 0x54, 0x3,
0xf4, 0x80, 0x7f, 0x38, 0x80, 0x7f, 0x48, 0x0,
/* U+4F "O" */
0x0, 0x1d, 0xff, 0xac, 0x80, 0x24, 0xc4, 0x33,
0x26, 0x98, 0x2, 0x87, 0x73, 0x20, 0xd0, 0x61,
0x92, 0x0, 0x1c, 0xb, 0x60, 0x30, 0x6, 0x60,
0xc7, 0x11, 0x0, 0x61, 0x13, 0x91, 0x80, 0x78,
0xcc, 0x2, 0x1, 0xf0, 0x80, 0x80, 0x7c, 0x24,
0x60, 0x1e, 0x33, 0x38, 0x88, 0x3, 0x8, 0x9f,
0x1, 0x80, 0x33, 0x6, 0x30, 0xc1, 0x80, 0xa,
0x45, 0x82, 0x83, 0x2e, 0xda, 0x34, 0x0, 0x4d,
0x44, 0xd8, 0x80,
/* U+50 "P" */
0x2f, 0xfe, 0xe9, 0x10, 0xc, 0x4e, 0xf2, 0xb7,
0x90, 0x4, 0xf1, 0x15, 0xc8, 0xc8, 0x7, 0xe6,
0x24, 0x10, 0xf, 0xce, 0x6, 0x1, 0xf9, 0x80,
0xc0, 0x3e, 0x53, 0x41, 0x0, 0x3c, 0x45, 0x74,
0x32, 0x1, 0x13, 0xbc, 0xad, 0xe4, 0x1, 0x2f,
0xfd, 0xd2, 0x20, 0x1f, 0xfe, 0xd0,
/* U+51 "Q" */
0x0, 0x8e, 0xff, 0xd6, 0x60, 0x1c, 0x98, 0x86,
0x64, 0xc4, 0x0, 0x86, 0xc7, 0x73, 0x1a, 0x36,
0x20, 0x6, 0x8, 0x20, 0x1, 0x58, 0x30, 0x2,
0xc1, 0x80, 0x32, 0x85, 0x80, 0xc, 0x80, 0x3c,
0x46, 0x1, 0x30, 0x7, 0x98, 0x0, 0x20, 0x1f,
0xe1, 0x10, 0x7, 0xf8, 0x40, 0xc, 0x1, 0xe6,
0x0, 0x8c, 0x80, 0x3c, 0x46, 0x0, 0xb0, 0x50,
0xc, 0xa1, 0x60, 0x6, 0xb, 0x20, 0x1, 0x58,
0x30, 0x0, 0x6c, 0x76, 0xed, 0xa3, 0x42, 0x1,
0x26, 0x22, 0x42, 0x1a, 0x1, 0xc7, 0x7f, 0xf1,
0xbd, 0x0, 0x7e, 0x1c, 0x47, 0x10, 0xf, 0xeb,
0xd1,
/* U+52 "R" */
0x3f, 0xfe, 0xc6, 0x0, 0xe3, 0x77, 0x31, 0x4d,
0x0, 0x64, 0x88, 0x4f, 0x1a, 0xa8, 0x3, 0xf7,
0x87, 0x80, 0x7e, 0x20, 0x10, 0xf, 0xc4, 0x2,
0x1, 0xfb, 0xc3, 0x80, 0x24, 0x88, 0x4f, 0x1b,
0x20, 0x4, 0x6e, 0xe6, 0x19, 0x90, 0x6, 0x7f,
0xf5, 0x7, 0x0, 0x7e, 0x51, 0x71, 0x0, 0xfd,
0x0, 0xc0, 0x1f, 0x98, 0x64, 0x3, 0xfa, 0x45,
0xc0, 0x3f, 0x30, 0x48, 0x0,
/* U+53 "S" */
0x0, 0x1d, 0xf7, 0xe2, 0x80, 0x65, 0xc4, 0x55,
0x15, 0x58, 0x0, 0x68, 0x76, 0xeb, 0x91, 0xe,
0x8, 0xc, 0x40, 0x14, 0x85, 0x0, 0x42, 0x1,
0x8a, 0x6c, 0x10, 0x19, 0x40, 0x33, 0x30, 0x6,
0xc2, 0xb1, 0x84, 0x3, 0x93, 0x50, 0xe7, 0xa0,
0x3, 0x8a, 0xfa, 0x5, 0xf4, 0x3, 0xc2, 0xfc,
0xa5, 0x40, 0xac, 0x1, 0xd4, 0xa, 0x1d, 0x28,
0x1, 0xfb, 0xc2, 0x44, 0x2, 0x70, 0x40, 0x47,
0x2e, 0xa9, 0xc8, 0x19, 0x0, 0x45, 0xa2, 0x18,
0x63, 0xc8, 0x0,
/* U+54 "T" */
0x3f, 0xff, 0xf2, 0xb, 0x36, 0x0, 0x33, 0x71,
0x4c, 0xe2, 0x19, 0x9c, 0x40, 0x1f, 0xff, 0xf0,
0xf, 0xff, 0xc8,
/* U+55 "U" */
0xaf, 0x10, 0xc, 0x5f, 0x20, 0x1f, 0xfc, 0x73,
0x0, 0xff, 0xef, 0x18, 0x7, 0xff, 0x3c, 0xc0,
0x40, 0x30, 0x81, 0xf8, 0x20, 0x6, 0x40, 0xf7,
0x9, 0x20, 0x1, 0x48, 0x38, 0xd0, 0xed, 0x53,
0x46, 0x84, 0x17, 0x11, 0x54, 0x98, 0xa0,
/* U+56 "V" */
0x2f, 0xc0, 0xf, 0x6f, 0x89, 0x10, 0xc0, 0x38,
0x48, 0xc4, 0x10, 0x14, 0x3, 0x38, 0x58, 0x3,
0x43, 0x0, 0x36, 0x2, 0x0, 0x10, 0x1c, 0x3,
0x20, 0x98, 0x4, 0xa2, 0x40, 0x3, 0x17, 0x0,
0xde, 0x8, 0x0, 0xb0, 0xd0, 0xc, 0x81, 0xa0,
0x4, 0x4, 0x0, 0xc2, 0x68, 0x2, 0x68, 0x1,
0xeb, 0x4, 0x40, 0x68, 0x7, 0x94, 0x33, 0xc1,
0xc0, 0x3c, 0x44, 0x54, 0x31, 0x0, 0xf9, 0x8,
0x50, 0x3, 0xf6, 0x80, 0x2c, 0x3, 0xf2, 0x0,
0x98, 0x6,
/* U+57 "W" */
0x3f, 0x70, 0x5, 0xf8, 0x0, 0xfd, 0xc8, 0x38,
0x0, 0xa0, 0x40, 0xc0, 0x42, 0x6, 0x2, 0x20,
0x70, 0x30, 0x10, 0x16, 0x2, 0x0, 0x68, 0x70,
0x30, 0x11, 0x1, 0x40, 0xc8, 0x4, 0x8, 0x18,
0x43, 0xc9, 0x5c, 0x8, 0x40, 0x4, 0x2, 0x4f,
0xe4, 0xc, 0x40, 0xe, 0x3, 0x52, 0x20, 0x11,
0xb0, 0x0, 0x81, 0xc7, 0x54, 0x1c, 0x48, 0x0,
0xe1, 0x80, 0xc2, 0x2c, 0xf, 0x0, 0x10, 0x38,
0x18, 0x13, 0x81, 0x0, 0x4, 0x4, 0x80, 0xa,
0x20, 0xc0, 0x11, 0x3, 0x0, 0x38, 0x0, 0x40,
0x13, 0x1, 0x80, 0xc, 0x0, 0x20, 0x11, 0x7,
0x0, 0x14, 0x8, 0x0,
/* U+58 "X" */
0xc, 0xf5, 0x0, 0xc3, 0xfe, 0x10, 0xf0, 0x80,
0xd, 0x61, 0x2, 0x6, 0xa4, 0xc0, 0x2, 0x51,
0x70, 0xa, 0x2, 0x0, 0x12, 0x16, 0x1, 0x89,
0xc5, 0xcd, 0xd, 0x40, 0x3a, 0x46, 0x7c, 0x3c,
0x3, 0xc3, 0x2, 0x68, 0x60, 0x1f, 0x38, 0x3,
0x80, 0x3f, 0x48, 0x2, 0x40, 0x3e, 0x17, 0x26,
0x35, 0x0, 0xf5, 0x84, 0x40, 0x20, 0x3, 0x8d,
0x49, 0x45, 0xc9, 0x80, 0x37, 0x84, 0x80, 0x24,
0x20, 0x40, 0xa, 0x66, 0x40, 0x0, 0xb8, 0xc8,
0x2, 0x3, 0xc0, 0x34, 0xb, 0x90,
/* U+59 "Y" */
0x2f, 0xd0, 0xe, 0x1f, 0xe0, 0x24, 0x25, 0x0,
0xd2, 0x12, 0x0, 0x80, 0x90, 0xc, 0xc0, 0xc0,
0x3, 0x3c, 0x0, 0x61, 0x71, 0x0, 0xa0, 0x24,
0x1, 0x61, 0x20, 0x19, 0x9, 0x45, 0x49, 0x84,
0x3, 0xa0, 0x26, 0x41, 0x60, 0x1e, 0x52, 0x73,
0x52, 0x0, 0xfa, 0xc0, 0x12, 0x1, 0xf9, 0x80,
0xcc, 0x1, 0xff, 0xd6, 0x70, 0xf, 0xfe, 0x88,
/* U+5A "Z" */
0xcf, 0xff, 0xc9, 0x6c, 0xde, 0x0, 0x33, 0xcc,
0xf6, 0x2, 0x90, 0x7, 0xac, 0x2c, 0x3, 0xd0,
0x30, 0x20, 0x1c, 0x4e, 0x4e, 0x1, 0xe9, 0x9,
0x0, 0xf2, 0x21, 0x50, 0x3, 0xd2, 0x16, 0x1,
0xe7, 0x28, 0x10, 0xe, 0x18, 0x27, 0x0, 0xf5,
0x84, 0x0, 0x79, 0x15, 0x14, 0x3, 0xd0, 0x0,
0x88, 0xf2, 0x8, 0x23, 0xbf, 0xb0,
/* U+5B "[" */
0x68, 0x88, 0x2d, 0xde, 0x0, 0x17, 0xf8, 0x3,
0xff, 0xfe, 0x0, 0x28, 0x80, 0x4, 0xee, 0x0,
/* U+5C "\\" */
0x9f, 0x10, 0xe, 0xa0, 0x60, 0xe, 0x32, 0xa0,
0xf, 0x51, 0x18, 0x7, 0x30, 0x58, 0x7, 0xa,
0x30, 0x7, 0xb8, 0x50, 0x3, 0x94, 0x78, 0x3,
0xce, 0xa2, 0x1, 0xd4, 0xe, 0x1, 0xc6, 0x54,
0x1, 0xea, 0x32, 0x0, 0xe6, 0xa, 0x0, 0xe1,
0x46, 0x0, 0xf7, 0xa, 0x0, 0x72, 0x87, 0x0,
/* U+5D "]" */
0x8, 0x89, 0x81, 0xde, 0xb0, 0xff, 0x10, 0x7,
0xff, 0xfc, 0x1, 0x10, 0x20, 0x3, 0xb8, 0x0,
/* U+5E "^" */
0x0, 0xb7, 0x40, 0x1c, 0x64, 0x43, 0x0, 0xd4,
0x0, 0xa0, 0xc, 0xca, 0xa6, 0x0, 0x98, 0x3b,
0x80, 0xa0, 0xa, 0x14, 0x40, 0xc8, 0x11, 0xb0,
0x1, 0x8c, 0xa8, 0x28, 0x1, 0x41, 0x40,
/* U+5F "_" */
0x37, 0x7f, 0xc6, 0x91, 0x1f, 0x90,
/* U+60 "`" */
0x57, 0x30, 0x4a, 0xe0, 0x1f, 0x39,
/* U+61 "a" */
0x0, 0x26, 0x7f, 0x62, 0x80, 0x4d, 0x62, 0xee,
0x3a, 0x60, 0x19, 0x2d, 0x89, 0xd0, 0x90, 0x4,
0x48, 0x4, 0x48, 0x4, 0x2e, 0x80, 0x18, 0x40,
0x21, 0x9d, 0xff, 0x94, 0x2, 0xc6, 0x4a, 0xbc,
0x40, 0x3, 0x14, 0x4a, 0xa1, 0x88, 0x7, 0xe1,
0x70, 0x3, 0x8c, 0x4b, 0xcf, 0x90, 0x8, 0xb1,
0x5e, 0x16, 0x1c, 0x14,
/* U+62 "b" */
0x4f, 0x80, 0xf, 0xfe, 0xe3, 0xef, 0xeb, 0x0,
0x67, 0x87, 0x53, 0x97, 0x0, 0x87, 0x6a, 0x98,
0x30, 0x20, 0x6, 0x20, 0x1, 0x48, 0x38, 0x7,
0xc8, 0x1e, 0x1, 0xf0, 0x81, 0x80, 0x7c, 0x20,
0x60, 0x1f, 0x28, 0x78, 0x1, 0x40, 0x35, 0x83,
0x80, 0xb, 0x5d, 0xb0, 0xa0, 0x40, 0x10, 0xb3,
0x21, 0x97, 0x0,
/* U+63 "c" */
0x0, 0x1d, 0xf7, 0xea, 0x80, 0x49, 0x88, 0xec,
0x15, 0x20, 0xa, 0xc, 0x99, 0x6a, 0x31, 0xa8,
0xb9, 0x80, 0x5e, 0x4b, 0xa1, 0x80, 0x19, 0x35,
0x84, 0x1c, 0x3, 0xe1, 0x7, 0x0, 0xfb, 0x43,
0x0, 0x31, 0x42, 0x28, 0xb9, 0x0, 0x50, 0xee,
0xa, 0xd, 0x98, 0xd5, 0x73, 0x4, 0xc4, 0x77,
0xd, 0xc0, 0x0,
/* U+64 "d" */
0x0, 0xfa, 0x3d, 0x0, 0x3f, 0xfa, 0x8b, 0xbf,
0xce, 0x1, 0x9a, 0x89, 0x52, 0x1c, 0x0, 0x32,
0x3b, 0x54, 0xd1, 0x0, 0x38, 0x31, 0x0, 0x9,
0x80, 0x1e, 0x18, 0x1, 0xf1, 0x83, 0x80, 0x7c,
0x60, 0xe0, 0x1f, 0x78, 0x60, 0x7, 0xce, 0xc,
0x40, 0x1, 0x50, 0x0, 0xc8, 0xed, 0x53, 0xc8,
0x2, 0x6a, 0x25, 0x46, 0x80, 0x0,
/* U+65 "e" */
0x0, 0x15, 0x77, 0xe2, 0x80, 0x47, 0xaa, 0x8e,
0x55, 0x0, 0xd, 0x1d, 0xa8, 0xe3, 0x72, 0x61,
0x92, 0x0, 0xa4, 0x17, 0xc3, 0x26, 0x77, 0x87,
0x18, 0x23, 0x36, 0x50, 0x30, 0x6, 0x7f, 0xfa,
0xb4, 0x2c, 0x3, 0xe6, 0x7, 0x40, 0x8, 0xac,
0x86, 0xc2, 0xea, 0x2b, 0x54, 0xc1, 0x35, 0x51,
0xde, 0xf1,
/* U+66 "f" */
0x0, 0xe2, 0x68, 0x74, 0x0, 0xe7, 0xd9, 0x78,
0xb0, 0xc, 0x70, 0x57, 0xfe, 0xd0, 0xd, 0x61,
0x8, 0x0, 0x20, 0xc, 0x20, 0xc0, 0x1d, 0x1f,
0xe6, 0xc, 0xff, 0x90, 0x2e, 0x64, 0x60, 0xf3,
0x32, 0x81, 0xb3, 0x14, 0x2d, 0x9a, 0x10, 0xf,
0xff, 0xf8, 0x7, 0xff, 0x8,
/* U+67 "g" */
0x0, 0x36, 0xff, 0x43, 0xfa, 0x3, 0xc8, 0x44,
0xa4, 0x0, 0x6, 0x7, 0x1d, 0xd8, 0x60, 0x7,
0x9, 0x10, 0x9, 0x0, 0x1e, 0x6, 0x1, 0xfc,
0xe0, 0x1f, 0xce, 0x1, 0xf7, 0x86, 0x0, 0x7c,
0xe0, 0xc4, 0x0, 0x16, 0x0, 0xc, 0x8e, 0xd5,
0x3c, 0x40, 0x26, 0xa2, 0x57, 0x67, 0x0, 0xcb,
0xbf, 0xb0, 0x40, 0xc1, 0xa, 0x1, 0x12, 0x91,
0x0, 0xea, 0xe2, 0xb4, 0x24, 0x1, 0x72, 0xee,
0x54, 0xc4, 0x0,
/* U+68 "h" */
0x4f, 0x70, 0xf, 0xfe, 0xe1, 0xdf, 0xf4, 0x88,
0x5, 0x78, 0xc, 0x6d, 0xa0, 0x11, 0x6d, 0xce,
0x91, 0x98, 0x0, 0xc4, 0x1, 0x50, 0x28, 0x3,
0xc0, 0x30, 0x80, 0x7f, 0x18, 0x7, 0xff, 0xa0,
/* U+69 "i" */
0x0, 0xcd, 0xe8, 0x1, 0xf7, 0x1, 0x0, 0x7d,
0x1c, 0xc0, 0x1f, 0x84, 0x3, 0xbf, 0xf9, 0x80,
0x33, 0x34, 0x60, 0x1e, 0x99, 0xa8, 0x3, 0xff,
0xed, 0x33, 0x50, 0x54, 0xc9, 0xc1, 0x9a, 0x30,
0x36, 0x65, 0x0,
/* U+6A "j" */
0x0, 0xd3, 0xc4, 0x1, 0x8c, 0x44, 0x1, 0xab,
0x8c, 0x3, 0x84, 0x7, 0xff, 0x8c, 0x59, 0xa2,
0x0, 0xa6, 0x65, 0x0, 0xff, 0xf9, 0x10, 0x7,
0xa, 0x81, 0xc4, 0x27, 0xc2, 0x1, 0x5d, 0x8a,
0x9c, 0x0,
/* U+6B "k" */
0x4f, 0x80, 0xf, 0xff, 0x1a, 0xfe, 0x88, 0x7,
0x92, 0x8b, 0x4, 0x3, 0x92, 0xc7, 0xc4, 0x3,
0x8e, 0xc7, 0x8, 0x3, 0x8b, 0x42, 0xc8, 0x3,
0xca, 0x21, 0x20, 0x1f, 0xad, 0x4e, 0x40, 0x3c,
0xe9, 0x64, 0xca, 0x1, 0xf0, 0xf0, 0x51, 0x0,
0x7c, 0x72, 0x1e, 0x1, 0xf9, 0x94, 0xa8, 0x0,
/* U+6C "l" */
0xf, 0xfe, 0x60, 0xc, 0xcd, 0x18, 0x7, 0xa6,
0x6a, 0x0, 0xff, 0xff, 0x80, 0x7f, 0xf4, 0xe6,
0x6a, 0xa, 0x99, 0x38, 0x33, 0x46, 0x6, 0xcc,
0xa0,
/* U+6D "m" */
0x1f, 0x9b, 0xfd, 0x5b, 0xfd, 0x30, 0x9, 0xb1,
0xca, 0x8a, 0xb, 0x80, 0x25, 0x78, 0x11, 0x4b,
0xa9, 0x0, 0x46, 0x0, 0x33, 0x0, 0xc, 0x4,
0x3, 0xff, 0xfe, 0x1, 0xfc,
/* U+6E "n" */
0x4f, 0x54, 0xcf, 0xd9, 0x10, 0xb, 0xad, 0x98,
0xd, 0xa0, 0x12, 0xed, 0x4e, 0x99, 0x88, 0x0,
0xc4, 0x1, 0x58, 0x38, 0x3, 0xc0, 0x30, 0x81,
0x80, 0x7f, 0xfc, 0x0,
/* U+6F "o" */
0x0, 0x25, 0xff, 0xad, 0x0, 0x26, 0xb5, 0x66,
0x2d, 0xb0, 0x14, 0x97, 0xcc, 0xbc, 0xa4, 0xa8,
0x2c, 0x40, 0x3, 0x61, 0x46, 0xe, 0x1, 0x90,
0xd, 0xc0, 0x40, 0x31, 0x3, 0xb8, 0x4, 0x3,
0x8, 0x39, 0x82, 0x0, 0x64, 0x3, 0xa0, 0x81,
0x0, 0xc, 0x5, 0x14, 0x97, 0xcc, 0xbc, 0xa4,
0x81, 0xac, 0x99, 0x85, 0x6c, 0x0,
/* U+70 "p" */
0x4f, 0x67, 0xdf, 0xd6, 0x0, 0xd1, 0x2e, 0xa5,
0x2e, 0x1, 0x1f, 0xd5, 0x30, 0x20, 0x40, 0xa,
0x20, 0x3, 0x70, 0x70, 0x7, 0x80, 0x6c, 0xe,
0x0, 0xf9, 0xc0, 0x40, 0x3e, 0x70, 0x10, 0xf,
0xb0, 0x34, 0x1, 0x60, 0x11, 0x30, 0x20, 0x0,
0xf6, 0x65, 0xa3, 0x2, 0x0, 0x75, 0x76, 0x29,
0x70, 0xb, 0xe3, 0xbf, 0x58, 0x3, 0xff, 0xa8,
/* U+71 "q" */
0x0, 0x2e, 0xff, 0x4c, 0x7a, 0x3, 0xd0, 0x4c,
0x2b, 0x80, 0x6, 0x7, 0x19, 0x98, 0x80, 0x7,
0x9, 0x10, 0x8, 0xc0, 0x1e, 0x6, 0x1, 0xfc,
0xe0, 0x1f, 0xce, 0x1, 0xf7, 0x86, 0x0, 0x7c,
0xe0, 0xc4, 0x0, 0x15, 0x0, 0xc, 0xe, 0x4c,
0xbc, 0x80, 0x27, 0xa3, 0x67, 0x67, 0x0, 0xcb,
0xbf, 0xd0, 0x1, 0xff, 0xd5,
/* U+72 "r" */
0xcf, 0x6, 0xdf, 0xe5, 0x0, 0x4c, 0x88, 0x82,
0x20, 0x3, 0xdf, 0xef, 0xa0, 0x2, 0xd0, 0x3,
0xca, 0x1, 0xff, 0xe9,
/* U+73 "s" */
0x0, 0x1d, 0xf7, 0xeb, 0x80, 0x49, 0x8a, 0xec,
0x11, 0x60, 0x9, 0xf, 0x99, 0x6a, 0x24, 0x1,
0x8, 0x5, 0x34, 0xc1, 0x61, 0xce, 0x60, 0x4a,
0x40, 0xd6, 0xb1, 0x9f, 0x44, 0x1, 0x25, 0xfd,
0xb2, 0xe0, 0x93, 0xa0, 0x1, 0x26, 0x42, 0xc7,
0x12, 0x20, 0x10, 0x80, 0x8a, 0xb, 0xe6, 0x2e,
0x9, 0x81, 0xe9, 0x59, 0xd9, 0xf0, 0x0,
/* U+74 "t" */
0x0, 0x99, 0xc0, 0x3f, 0x5c, 0x0, 0x7f, 0xf0,
0xe7, 0xfc, 0x41, 0xff, 0x83, 0x66, 0x42, 0x13,
0x38, 0x11, 0x98, 0x60, 0xcd, 0x80, 0x3f, 0xfd,
0x4c, 0x8, 0x1, 0xf7, 0x5, 0xd4, 0xd9, 0x80,
0x4b, 0x44, 0xac, 0xe0,
/* U+75 "u" */
0x3f, 0x80, 0xd, 0x1e, 0x80, 0x1f, 0xfe, 0x81,
0x0, 0xf8, 0x40, 0x3f, 0x88, 0x1c, 0x3, 0x28,
0x4, 0xe3, 0x6c, 0xfa, 0x60, 0x14, 0x41, 0x66,
0xae, 0x0, 0x0,
/* U+76 "v" */
0xd, 0xf0, 0xe, 0x1f, 0xc0, 0xa0, 0x50, 0xc,
0xe1, 0x40, 0xc1, 0xc0, 0x1a, 0x81, 0x80, 0x55,
0x4, 0x0, 0x26, 0xc0, 0x17, 0x3, 0x0, 0x18,
0x28, 0x2, 0x42, 0xa0, 0x5, 0x11, 0x80, 0x6a,
0x22, 0xd4, 0x1, 0xcc, 0x15, 0x40, 0x60, 0xe,
0x14, 0x65, 0x50, 0x80, 0x7b, 0xc4, 0xb8, 0x3,
0xe4, 0x11, 0x20, 0x4,
/* U+77 "w" */
0x6f, 0x20, 0x5, 0x58, 0x5, 0xf0, 0xa0, 0xe0,
0x4, 0x40, 0x0, 0xc3, 0x4c, 0x34, 0x8, 0x40,
0xc1, 0x41, 0x0, 0x88, 0xe, 0x24, 0x81, 0xc2,
0x20, 0x47, 0xc, 0x57, 0xc0, 0x35, 0x0, 0x79,
0x2, 0x66, 0x14, 0x14, 0xc0, 0xa, 0x8, 0x48,
0x81, 0x31, 0xc0, 0x1, 0x87, 0x1, 0x90, 0xd0,
0x28, 0x4, 0x6a, 0x80, 0x4, 0x71, 0x10, 0x4,
0xa1, 0x80, 0xc, 0x15, 0x0, 0xde, 0x6, 0x0,
0x40, 0xc0, 0x0,
/* U+78 "x" */
0x7f, 0x90, 0xc, 0xff, 0x40, 0xe8, 0xca, 0x0,
0x38, 0x2a, 0x0, 0x50, 0xd8, 0x87, 0x7, 0x0,
0x43, 0x43, 0x52, 0x50, 0x60, 0x19, 0x1d, 0x19,
0x1c, 0x3, 0xd2, 0x0, 0xf0, 0xf, 0xac, 0x1,
0x20, 0x1e, 0x65, 0x54, 0x94, 0x80, 0x62, 0x91,
0xa6, 0x46, 0x40, 0xb, 0x83, 0x40, 0x14, 0x34,
0x21, 0x6, 0xe6, 0x0, 0x1b, 0x1a, 0x0,
/* U+79 "y" */
0x1f, 0xe0, 0xf, 0x77, 0x88, 0x94, 0x54, 0x3,
0x28, 0xa8, 0x84, 0x87, 0x0, 0x6e, 0x9, 0x0,
0x19, 0x90, 0x80, 0x2, 0x86, 0x60, 0xa, 0x42,
0xc0, 0xc, 0x12, 0x1, 0x94, 0x98, 0x1, 0x22,
0xa0, 0x1d, 0x60, 0xc8, 0x32, 0x1, 0xe6, 0x1b,
0xe0, 0x60, 0xf, 0x98, 0x95, 0x84, 0x3, 0xe9,
0x0, 0x58, 0x7, 0xe1, 0x12, 0x10, 0x7, 0xe7,
0x1f, 0x0, 0xfc, 0x50, 0x48, 0x1, 0xe3, 0xac,
0xe, 0x0, 0xf9, 0x54, 0x76, 0x60, 0x1e,
/* U+7A "z" */
0x5f, 0xff, 0xc6, 0xef, 0xe5, 0x0, 0x11, 0x22,
0x39, 0xc2, 0x84, 0x3, 0xa8, 0x9d, 0x40, 0x39,
0x94, 0xe0, 0x3, 0x8e, 0x47, 0x40, 0x38, 0x74,
0x34, 0x40, 0x3a, 0x86, 0x4c, 0x3, 0xa1, 0x15,
0x80, 0x39, 0x1c, 0x9, 0xdf, 0x90, 0x80, 0xf,
0x11, 0xda,
/* U+7B "{" */
0x0, 0xc9, 0x92, 0x1, 0x1d, 0xb5, 0x80, 0x50,
0x14, 0x40, 0x12, 0x20, 0x3, 0x8, 0x7, 0xe1,
0x0, 0xc6, 0x1, 0xe4, 0xd, 0x0, 0x13, 0x41,
0x30, 0x3, 0xe4, 0xf0, 0x40, 0x12, 0xc5, 0x40,
0x12, 0x4c, 0x22, 0x80, 0x64, 0xc, 0x0, 0xc4,
0x6, 0x1, 0xe1, 0x0, 0xc2, 0xe, 0x1, 0xc6,
0x60, 0xe, 0x80, 0x90, 0xc, 0x94, 0xd4, 0x1,
0x97, 0xec,
/* U+7C "|" */
0xbb, 0x0, 0x7f, 0xf6, 0x0,
/* U+7D "}" */
0xac, 0x30, 0xd, 0xf, 0x86, 0x1, 0x15, 0x4,
0x80, 0x61, 0x24, 0x0, 0xe1, 0x10, 0x7, 0xff,
0x1, 0xc0, 0x40, 0x31, 0x82, 0x80, 0x69, 0x1a,
0x52, 0x0, 0xe, 0x5, 0x48, 0x5, 0xc2, 0xfe,
0x0, 0x73, 0x98, 0x40, 0x6, 0x3, 0x80, 0x67,
0x1, 0x0, 0xff, 0x84, 0x40, 0x18, 0x49, 0x40,
0x35, 0x4, 0x0, 0x58, 0xb6, 0x60, 0x16, 0xf2,
0x0, 0x60,
/* U+7E "~" */
0x3, 0xdf, 0xd5, 0x0, 0xcc, 0x63, 0xa6, 0xa7,
0x52, 0x0, 0x29, 0x57, 0x1f, 0xae, 0x56, 0xea,
0xc1, 0x64, 0xa1, 0x0, 0x54, 0x9a, 0x96, 0x0
};
/*---------------------
* GLYPH DESCRIPTION
*--------------------*/
static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = {
{.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */,
{.bitmap_index = 0, .adv_w = 192, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 0, .adv_w = 192, .box_w = 3, .box_h = 15, .ofs_x = 4, .ofs_y = 0},
{.bitmap_index = 13, .adv_w = 192, .box_w = 6, .box_h = 5, .ofs_x = 3, .ofs_y = 10},
{.bitmap_index = 26, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 110, .adv_w = 192, .box_w = 10, .box_h = 19, .ofs_x = 1, .ofs_y = -2},
{.bitmap_index = 193, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 269, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 346, .adv_w = 192, .box_w = 3, .box_h = 5, .ofs_x = 4, .ofs_y = 10},
{.bitmap_index = 353, .adv_w = 192, .box_w = 6, .box_h = 22, .ofs_x = 3, .ofs_y = -5},
{.bitmap_index = 413, .adv_w = 192, .box_w = 6, .box_h = 22, .ofs_x = 3, .ofs_y = -5},
{.bitmap_index = 472, .adv_w = 192, .box_w = 10, .box_h = 10, .ofs_x = 1, .ofs_y = 5},
{.bitmap_index = 518, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 1},
{.bitmap_index = 543, .adv_w = 192, .box_w = 4, .box_h = 6, .ofs_x = 3, .ofs_y = -4},
{.bitmap_index = 555, .adv_w = 192, .box_w = 8, .box_h = 2, .ofs_x = 2, .ofs_y = 6},
{.bitmap_index = 561, .adv_w = 192, .box_w = 4, .box_h = 3, .ofs_x = 4, .ofs_y = 0},
{.bitmap_index = 567, .adv_w = 192, .box_w = 9, .box_h = 16, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 617, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 689, .adv_w = 192, .box_w = 6, .box_h = 15, .ofs_x = 2, .ofs_y = 0},
{.bitmap_index = 708, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 774, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 841, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 893, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 957, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1027, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1078, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1150, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1220, .adv_w = 192, .box_w = 4, .box_h = 11, .ofs_x = 5, .ofs_y = 0},
{.bitmap_index = 1237, .adv_w = 192, .box_w = 5, .box_h = 15, .ofs_x = 4, .ofs_y = -4},
{.bitmap_index = 1265, .adv_w = 192, .box_w = 9, .box_h = 10, .ofs_x = 1, .ofs_y = 1},
{.bitmap_index = 1305, .adv_w = 192, .box_w = 10, .box_h = 6, .ofs_x = 1, .ofs_y = 4},
{.bitmap_index = 1322, .adv_w = 192, .box_w = 10, .box_h = 10, .ofs_x = 1, .ofs_y = 1},
{.bitmap_index = 1365, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1424, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1513, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1585, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1648, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1707, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1765, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1798, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1825, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1895, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1915, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1941, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1975, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2035, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2050, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2101, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2149, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2216, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2262, .adv_w = 192, .box_w = 12, .box_h = 18, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 2351, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2412, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2487, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2506, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2545, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2619, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2711, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2789, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2845, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2899, .adv_w = 192, .box_w = 5, .box_h = 20, .ofs_x = 4, .ofs_y = -3},
{.bitmap_index = 2915, .adv_w = 192, .box_w = 8, .box_h = 16, .ofs_x = 2, .ofs_y = -1},
{.bitmap_index = 2963, .adv_w = 192, .box_w = 5, .box_h = 20, .ofs_x = 3, .ofs_y = -3},
{.bitmap_index = 2979, .adv_w = 192, .box_w = 8, .box_h = 8, .ofs_x = 2, .ofs_y = 7},
{.bitmap_index = 3010, .adv_w = 192, .box_w = 10, .box_h = 2, .ofs_x = 1, .ofs_y = -1},
{.bitmap_index = 3016, .adv_w = 192, .box_w = 4, .box_h = 3, .ofs_x = 4, .ofs_y = 12},
{.bitmap_index = 3022, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3074, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3125, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3176, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3230, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3280, .adv_w = 192, .box_w = 11, .box_h = 16, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3325, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = -4},
{.bitmap_index = 3392, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3424, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3459, .adv_w = 192, .box_w = 7, .box_h = 19, .ofs_x = 2, .ofs_y = -4},
{.bitmap_index = 3493, .adv_w = 192, .box_w = 11, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3541, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3566, .adv_w = 192, .box_w = 12, .box_h = 11, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3595, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3623, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3677, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = -4},
{.bitmap_index = 3733, .adv_w = 192, .box_w = 10, .box_h = 15, .ofs_x = 1, .ofs_y = -4},
{.bitmap_index = 3786, .adv_w = 192, .box_w = 8, .box_h = 11, .ofs_x = 3, .ofs_y = 0},
{.bitmap_index = 3806, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3861, .adv_w = 192, .box_w = 10, .box_h = 14, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3897, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3924, .adv_w = 192, .box_w = 11, .box_h = 11, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3976, .adv_w = 192, .box_w = 12, .box_h = 11, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4043, .adv_w = 192, .box_w = 11, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4098, .adv_w = 192, .box_w = 12, .box_h = 15, .ofs_x = 0, .ofs_y = -4},
{.bitmap_index = 4169, .adv_w = 192, .box_w = 10, .box_h = 11, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4211, .adv_w = 192, .box_w = 7, .box_h = 20, .ofs_x = 3, .ofs_y = -4},
{.bitmap_index = 4269, .adv_w = 192, .box_w = 2, .box_h = 19, .ofs_x = 5, .ofs_y = -4},
{.bitmap_index = 4274, .adv_w = 192, .box_w = 7, .box_h = 20, .ofs_x = 3, .ofs_y = -4},
{.bitmap_index = 4332, .adv_w = 192, .box_w = 12, .box_h = 4, .ofs_x = 0, .ofs_y = 4}
};
/*---------------------
* CHARACTER MAPPING
*--------------------*/
/*Collect the unicode lists and glyph_id offsets*/
static const lv_font_fmt_txt_cmap_t cmaps[] =
{
{
.range_start = 32, .range_length = 95, .glyph_id_start = 1,
.unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY
}
};
/*--------------------
* ALL CUSTOM DATA
*--------------------*/
/*Store all the custom data of the font*/
static lv_font_fmt_txt_dsc_t font_dsc = {
.glyph_bitmap = gylph_bitmap,
.glyph_dsc = glyph_dsc,
.cmaps = cmaps,
.kern_dsc = NULL,
.kern_scale = 0,
.cmap_num = 1,
.bpp = 4,
.kern_classes = 0,
.bitmap_format = 1
};
/*-----------------
* PUBLIC FONT
*----------------*/
/*Initialize a public general font descriptor*/
lv_font_t font_3 = {
.get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/
.get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/
.line_height = 22, /*The maximum line height required by the font*/
.base_line = 5, /*Baseline measured from the bottom of the line*/
#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0)
.subpx = LV_FONT_SUBPX_NONE,
#endif
.dsc = &font_dsc /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */
};
#endif /*#if FONT_3*/

146
tests/lv_test_init.c Normal file
View File

@ -0,0 +1,146 @@
#include "../lvgl.h"
#if LV_BUILD_TEST
#include "lv_test_init.h"
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#define HOR_RES 800
#define VER_RES 480
static void hal_init(void);
static void dummy_flush_cb(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p);
lv_color_t test_fb[HOR_RES * VER_RES];
static lv_color_t disp_buf1[HOR_RES * VER_RES];
void lv_test_init(void)
{
printf("Call lv_init...\n");
lv_init();
hal_init();
}
void lv_test_deinit(void)
{
printf("Call lv_deinit...\n");
lv_mem_deinit();
}
static void * open_cb(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
{
(void) drv;
(void) mode;
FILE * fp = fopen(path, "rb"); // only reading is supported
return fp;
}
static lv_fs_res_t close_cb(lv_fs_drv_t * drv, void * file_p)
{
(void) drv;
fclose(file_p);
return LV_FS_RES_OK;
}
static lv_fs_res_t read_cb(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
{
(void) drv;
*br = fread(buf, 1, btr, file_p);
return (*br <= 0) ? LV_FS_RES_UNKNOWN : LV_FS_RES_OK;
}
static lv_fs_res_t seek_cb(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t w)
{
(void) drv;
uint32_t w2;
switch(w) {
case LV_FS_SEEK_SET:
w2 = SEEK_SET;
break;
case LV_FS_SEEK_CUR:
w2 = SEEK_CUR;
break;
case LV_FS_SEEK_END:
w2 = SEEK_END;
break;
default:
w2 = SEEK_SET;
}
fseek (file_p, pos, w2);
return LV_FS_RES_OK;
}
static lv_fs_res_t tell_cb(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
{
(void) drv;
*pos_p = ftell(file_p);
return LV_FS_RES_OK;
}
static void hal_init(void)
{
static lv_disp_draw_buf_t draw_buf;
lv_disp_draw_buf_init(&draw_buf, disp_buf1, NULL, LV_HOR_RES * LV_VER_RES);
static lv_disp_drv_t disp_drv;
lv_disp_drv_init(&disp_drv);
disp_drv.draw_buf = &draw_buf;
disp_drv.flush_cb = dummy_flush_cb;
disp_drv.hor_res = HOR_RES;
disp_drv.ver_res = VER_RES;
lv_disp_drv_register(&disp_drv);
static lv_fs_drv_t drv;
lv_fs_drv_init(&drv); /*Basic initialization*/
drv.letter = 'F'; /*An uppercase letter to identify the drive*/
drv.open_cb = open_cb; /*Callback to open a file*/
drv.close_cb = close_cb; /*Callback to close a file*/
drv.read_cb = read_cb; /*Callback to read a file*/
drv.seek_cb = seek_cb; /*Callback to seek in a file (Move cursor)*/
drv.tell_cb = tell_cb; /*Callback to tell the cursor position*/
lv_fs_drv_register(&drv); /*Finally register the drive*/
}
#include <stdio.h>
static void dummy_flush_cb(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
{
LV_UNUSED(area);
LV_UNUSED(color_p);
memcpy(test_fb, color_p, lv_area_get_size(area) * sizeof(lv_color_t));
lv_disp_flush_ready(disp_drv);
}
uint32_t custom_tick_get(void)
{
static uint64_t start_ms = 0;
if(start_ms == 0) {
struct timeval tv_start;
gettimeofday(&tv_start, NULL);
start_ms = (tv_start.tv_sec * 1000000 + tv_start.tv_usec) / 1000;
}
struct timeval tv_now;
gettimeofday(&tv_now, NULL);
uint64_t now_ms;
now_ms = (tv_now.tv_sec * 1000000 + tv_now.tv_usec) / 1000;
uint32_t time_ms = now_ms - start_ms;
return time_ms;
}
#endif

19
tests/lv_test_init.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef LV_TEST_INIT_H
#define LV_TEST_INIT_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
void lv_test_init(void);
void lv_test_deinit(void);
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif /*LV_TEST_INIT_H*/

BIN
tests/lv_test_ref_imgs/lv_test_img32_label_1.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.5 KiB

71
tests/lv_test_widgets/lv_test_label.c
View File

@ -1,71 +0,0 @@
typedef int _keep_pedantic_happy;
///**
// * @file lv_test_label.c
// *
// */
//
///*********************
// * INCLUDES
// *********************/
//#include "../../lvgl.h"
//#include "../lv_test_assert.h"
//#include "lv_test_label.h"
//
//#if LV_BUILD_TEST
//
///*********************
// * DEFINES
// *********************/
//
///**********************
// * TYPEDEFS
// **********************/
//
///**********************
// * STATIC PROTOTYPES
// **********************/
//static void create_copy(void);
//
///**********************
// * STATIC VARIABLES
// **********************/
//
///**********************
// * MACROS
// **********************/
//
///**********************
// * GLOBAL FUNCTIONS
// **********************/
//
//void lv_test_label(void)
//{
// lv_test_print("");
// lv_test_print("===================");
// lv_test_print("Start lv_label tests");
// lv_test_print("===================");
//
//#if LV_USE_LABEL
// create_copy();
//#else
// lv_test_print("Skip label test: LV_USE_LABEL == 0");
//#endif
//}
//
///**********************
// * STATIC FUNCTIONS
// **********************/
//
//static void create_copy(void)
//{
// lv_test_print("");
// lv_test_print("Create a label");
// lv_test_print("---------------------------");
//
// lv_label_create(lv_scr_act());
//#if LV_COLOR_DEPTH == 32
// lv_test_assert_img_eq("lv_test_img32_label_1.png", "Create a label and leave the default settings");
//#endif
//}
//#endif

38
tests/lv_test_widgets/lv_test_label.h
View File

@ -1,38 +0,0 @@
/**
* @file lv_test_label.h
*
*/
#ifndef LV_TEST_LABEL_H
#define LV_TEST_LABEL_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void lv_test_label(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /*extern "C"*/
#endif
#endif /*LV_TEST_CONT_H*/

18
tests/main.py Executable file
View File

@ -0,0 +1,18 @@
#!/usr/bin/env python3
import defines
import build
import test
files = test.prepare()
for f in files:
name = f[:-2] #test_foo.c -> test_foo
build.build("Minimal config, 16 bit color depth", defines.minimal_16bit, name)
#build("Minimal config monochrome", minimal_monochrome)
#build.build("Minimal config, 16 bit color depth", defines.minimal_16bit, "test_obj_tree")
#build("Minimal config, 16 bit color depth swapped", minimal_16bit_swap)
#build("Full config, 32 bit color depth", full_32bit)

9
tests/test.py Normal file
View File

@ -0,0 +1,9 @@
import os
import glob
def prepare():
os.system("rm test_*_Runner.c")
files = glob.glob("./test_*.c")
for f in files:
os.system("ruby unity/generate_test_runner.rb " + f + " config.yml")
return files

25
tests/test_obj_tree.c Normal file
View File

@ -0,0 +1,25 @@
#include "../lvgl.h"
#include "unity/unity.h"
void test_obj_tree_1(void);
void test_obj_tree_2(void);
void test_obj_tree_1(void)
{
TEST_ASSERT_EQUAL(lv_obj_get_child_cnt(lv_scr_act()), 0);
}
void test_obj_tree_2(void)
{
return;
lv_obj_create(lv_scr_act());
lv_obj_t * o2 = lv_obj_create(lv_scr_act());
lv_obj_create(lv_scr_act());
TEST_ASSERT_EQUAL(lv_obj_get_child_cnt(lv_scr_act()), 3);
lv_obj_del(o2);
TEST_ASSERT_EQUAL(lv_obj_get_child_cnt(lv_scr_act()), 2);
lv_obj_clean(lv_scr_act());
TEST_ASSERT_EQUAL(lv_obj_get_child_cnt(lv_scr_act()), 0);
}

511
tests/unity/generate_test_runner.rb Normal file
View File

@ -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(/\[\s*(-?\d+.?\d*),\s*(-?\d+.?\d*),\s*(-?\d+.?\d*)\s*\]/).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

37
tests/unity/run_test.erb Normal file
View File

@ -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();
}

6
tests/unity/type_sanitizer.rb Normal file
View File

@ -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

2110
tests/unity/unity.c Normal file
View File

File diff suppressed because it is too large Load Diff

661
tests/unity/unity.h Normal file
View 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

1039
tests/unity/unity_internals.h Normal file
View File

File diff suppressed because it is too large Load Diff