init lvgl code

LVGL.Simulator/lvgl/tests/src/lv_test_conf.h

@@ -0,0 +1,44 @@
+/**
+ * @file lv_test_conf.h
+ *
+ */
+
+#ifndef LV_TEST_CONF_H
+#define LV_TEST_CONF_H
+
+#define LV_CONF_SUPPRESS_DEFINE_CHECK 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+uint32_t custom_tick_get(void);
+#define LV_TICK_CUSTOM_SYS_TIME_EXPR custom_tick_get()
+
+typedef void * lv_user_data_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_TEST_CONF_H*/

LVGL.Simulator/lvgl/tests/src/lv_test_helpers.h

@@ -0,0 +1,23 @@
+#ifndef LV_TEST_HELPERS_H
+#define LV_TEST_HELPERS_H
+
+#ifdef LVGL_CI_USING_SYS_HEAP
+/* Skip checking heap as we don't have the info available */
+#define LV_HEAP_CHECK(x) do {} while(0)
+/* Pick a non-zero value */
+#define lv_test_get_free_mem() (65536)
+#else
+#define LV_HEAP_CHECK(x) x
+
+static inline uint32_t lv_test_get_free_mem(void)
+{
+    lv_mem_monitor_t m1;
+    lv_mem_monitor(&m1);
+    return m1.free_size;
+}
+#endif /* LVGL_CI_USING_SYS_HEAP */
+
+
+#endif /*LV_TEST_HELPERS_H*/
+
+

LVGL.Simulator/lvgl/tests/src/lv_test_indev.c

@@ -0,0 +1,140 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sys/time.h>
+#include "lv_test_indev.h"
+#include "lv_test_init.h"
+
+static lv_coord_t x_act;
+static lv_coord_t y_act;
+static uint32_t key_act;
+static int32_t diff_act;
+static bool mouse_pressed;
+static bool key_pressed;
+static bool enc_pressed;
+
+void lv_test_mouse_read_cb(lv_indev_drv_t * drv, lv_indev_data_t * data)
+{
+  LV_UNUSED(drv);
+  data->point.x = x_act;
+  data->point.y = y_act;
+  data->state = mouse_pressed ? LV_INDEV_STATE_PRESSED : LV_INDEV_STATE_RELEASED;
+}
+
+void lv_test_mouse_move_to(lv_coord_t x, lv_coord_t y)
+{
+  x_act = x;
+  y_act = y;
+}
+
+void lv_test_mouse_move_by(lv_coord_t x, lv_coord_t y)
+{
+  x_act += x;
+  y_act += y;
+}
+
+void lv_test_mouse_press(void)
+{
+  mouse_pressed = true;
+}
+
+void lv_test_mouse_release(void)
+{
+  mouse_pressed = false;
+}
+
+void lv_test_mouse_click_at(lv_coord_t x, lv_coord_t y)
+{
+  lv_test_mouse_release();
+  lv_test_indev_wait(50);
+  lv_test_mouse_move_to(x, y);
+  lv_test_mouse_press();
+  lv_test_indev_wait(50);
+  lv_test_mouse_release();
+  lv_test_indev_wait(50);
+}
+
+
+void lv_test_keypad_read_cb(lv_indev_drv_t * drv, lv_indev_data_t * data)
+{
+  LV_UNUSED(drv);
+  data->key = key_act;
+  data->state = key_pressed ? LV_INDEV_STATE_PRESSED : LV_INDEV_STATE_RELEASED;
+}
+
+void lv_test_key_press(uint32_t k)
+{
+  key_act = k;
+  key_pressed = true;
+}
+
+void lv_test_key_release(void)
+{
+  key_pressed = false;
+}
+
+void lv_test_key_hit(uint32_t k)
+{
+  lv_test_key_release();
+  lv_test_indev_wait(50);
+  lv_test_key_press(k);
+  lv_test_mouse_press();
+  lv_test_indev_wait(50);
+  lv_test_key_release();
+  lv_test_indev_wait(50);
+}
+
+void lv_test_encoder_read_cb(lv_indev_drv_t * drv, lv_indev_data_t * data)
+{
+  LV_UNUSED(drv);
+  data->enc_diff = diff_act;
+  data->state = enc_pressed ? LV_INDEV_STATE_PRESSED : LV_INDEV_STATE_RELEASED;
+  diff_act = 0;
+}
+
+void lv_test_encoder_add_diff(int32_t d)
+{
+  diff_act += d;
+}
+
+void lv_test_encoder_turn(int32_t d)
+{
+  diff_act += d;
+  lv_test_indev_wait(50);
+}
+
+
+void lv_test_encoder_press(void)
+{
+  enc_pressed = true;
+}
+
+void lv_test_encoder_release(void)
+{
+  enc_pressed = false;
+}
+
+void lv_test_encoder_click(void)
+{
+  lv_test_encoder_release();
+  lv_test_indev_wait(50);
+  lv_test_encoder_press();
+  lv_test_indev_wait(50);
+  lv_test_encoder_release();
+  lv_test_indev_wait(50);
+}
+
+
+void lv_test_indev_wait(uint32_t ms)
+{
+  uint32_t t = lv_tick_get();
+  while(lv_tick_elaps(t) < ms) {
+    lv_timer_handler();
+    lv_tick_inc(1);
+  }
+}
+
+
+#endif

LVGL.Simulator/lvgl/tests/src/lv_test_indev.h

@@ -0,0 +1,54 @@
+
+#ifndef LV_TEST_INDEV_H
+#define LV_TEST_INDEV_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include "../lvgl.h"
+
+void lv_test_mouse_read_cb(lv_indev_drv_t * drv, lv_indev_data_t * data);
+
+void lv_test_mouse_move_to(lv_coord_t x, lv_coord_t y);
+void lv_test_mouse_move_by(lv_coord_t x, lv_coord_t y);
+void lv_test_mouse_press(void);
+void lv_test_mouse_release(void);
+void lv_test_mouse_click_at(lv_coord_t x, lv_coord_t y);
+
+void lv_test_keypad_read_cb(lv_indev_drv_t * drv, lv_indev_data_t * data);
+
+void lv_test_key_press(uint32_t k);
+void lv_test_key_release(void);
+void lv_test_key_hit(uint32_t k);
+
+/* encoder read callback */
+void lv_test_encoder_read_cb(lv_indev_drv_t * drv, lv_indev_data_t * data) ;
+
+/* Simulate encoder rotation, use positive parameter to rotate to the right
+ * and negative to rotate to the left */
+void lv_test_encoder_add_diff(int32_t d);
+/* Same as lv_test_encoder_add_diff but with additional delay */
+void lv_test_encoder_turn(int32_t d);
+/* Set encoder to pressed */
+void lv_test_encoder_press(void);
+/* Set encoder to released */
+void lv_test_encoder_release(void);
+/* Simulate release+press+release (including delays) */
+void lv_test_encoder_click(void);
+
+/* Simulate delay */
+void lv_test_indev_wait(uint32_t ms);
+
+extern lv_indev_t * lv_test_mouse_indev;
+extern lv_indev_t * lv_test_keypad_indev;
+extern lv_indev_t * lv_test_encoder_indev;
+
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_TEST_INDEV_H*/
+

LVGL.Simulator/lvgl/tests/src/lv_test_init.c

@@ -0,0 +1,166 @@
+
+#if LV_BUILD_TEST
+#include "lv_test_init.h"
+#include "lv_test_indev.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_indev_t * lv_test_mouse_indev;
+lv_indev_t * lv_test_keypad_indev;
+lv_indev_t * lv_test_encoder_indev;
+
+lv_color_t test_fb[HOR_RES * VER_RES];
+static lv_color_t disp_buf1[HOR_RES * VER_RES];
+
+void lv_test_init(void)
+{
+    lv_init();
+    hal_init();
+}
+
+void lv_test_deinit(void)
+{
+    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, HOR_RES * 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_indev_drv_t indev_mouse_drv;
+    lv_indev_drv_init(&indev_mouse_drv);
+    indev_mouse_drv.type = LV_INDEV_TYPE_POINTER;
+    indev_mouse_drv.read_cb = lv_test_mouse_read_cb;
+    lv_test_mouse_indev = lv_indev_drv_register(&indev_mouse_drv);
+
+    static lv_indev_drv_t indev_keypad_drv;
+    lv_indev_drv_init(&indev_keypad_drv);
+    indev_keypad_drv.type = LV_INDEV_TYPE_KEYPAD;
+    indev_keypad_drv.read_cb = lv_test_keypad_read_cb;
+    lv_test_keypad_indev = lv_indev_drv_register(&indev_keypad_drv);
+
+    static lv_indev_drv_t indev_encoder_drv;
+    lv_indev_drv_init(&indev_encoder_drv);
+    indev_encoder_drv.type = LV_INDEV_TYPE_ENCODER;
+    indev_encoder_drv.read_cb = lv_test_encoder_read_cb;
+    lv_test_encoder_indev = lv_indev_drv_register(&indev_encoder_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*/
+}
+
+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

LVGL.Simulator/lvgl/tests/src/lv_test_init.h

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

LVGL.Simulator/lvgl/tests/src/test_cases/_test_template.c

@@ -0,0 +1,21 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+void setUp(void)
+{
+    /* Function run before every test */
+}
+
+void tearDown(void)
+{
+    /* Function run after every test */
+}
+
+void test_func_1(void)
+{
+    TEST_FAIL();
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_arc.c

@@ -0,0 +1,167 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+#include "lv_test_indev.h"
+
+/* This function runs before each test */
+void setUp(void);
+
+void test_arc_creation_successfull(void);
+void test_arc_should_truncate_to_max_range_when_new_value_exceeds_it(void);
+void test_arc_should_truncate_to_min_range_when_new_value_is_inferior(void);
+void test_arc_should_update_value_after_updating_range(void);
+void test_arc_should_update_angles_when_changing_to_symmetrical_mode(void);
+void test_arc_should_update_angles_when_changing_to_symmetrical_mode_value_more_than_middle_range(void);
+void test_arc_angles_when_reversed(void);
+
+static lv_obj_t * active_screen = NULL;
+static lv_obj_t * arc = NULL;
+static uint32_t event_cnt;
+
+static void dummy_event_cb(lv_event_t * e);
+
+void setUp(void)
+{
+    active_screen = lv_scr_act();
+}
+
+void test_arc_creation_successfull(void)
+{
+    arc = lv_arc_create(active_screen);
+
+    TEST_ASSERT_NOT_NULL(arc);
+}
+
+void test_arc_should_truncate_to_max_range_when_new_value_exceeds_it(void)
+{
+    /* Default max range is 100 */
+    int16_t value_after_truncation = 100;
+
+    arc = lv_arc_create(active_screen);
+
+    lv_arc_set_value(arc, 200);
+
+    TEST_ASSERT_EQUAL_INT16(value_after_truncation, lv_arc_get_value(arc));
+}
+
+void test_arc_should_truncate_to_min_range_when_new_value_is_inferior(void)
+{
+    /* Default min range is 100 */
+    int16_t value_after_truncation = 0;
+
+    arc = lv_arc_create(active_screen);
+
+    lv_arc_set_value(arc, 0);
+
+    TEST_ASSERT_EQUAL_INT16(value_after_truncation, lv_arc_get_value(arc));
+}
+
+void test_arc_should_update_value_after_updating_range(void)
+{
+    int16_t value_after_updating_max_range = 50;
+    int16_t value_after_updating_min_range = 30;
+
+    arc = lv_arc_create(active_screen);
+
+    lv_arc_set_value(arc, 80);
+    lv_arc_set_range(arc, 1, 50);
+
+    TEST_ASSERT_EQUAL_INT16(value_after_updating_max_range, lv_arc_get_value(arc));
+
+    lv_arc_set_value(arc, 10);
+    lv_arc_set_range(arc, 30, 50);
+
+    TEST_ASSERT_EQUAL_INT16(value_after_updating_min_range, lv_arc_get_value(arc));
+}
+
+void test_arc_should_update_angles_when_changing_to_symmetrical_mode(void)
+{
+    int16_t expected_angle_start = 135;
+    int16_t expected_angle_end = 270;
+
+    /* start angle is 135, end angle is 45 at creation */
+    arc = lv_arc_create(active_screen);
+    lv_arc_set_mode(arc, LV_ARC_MODE_SYMMETRICAL);
+
+    TEST_ASSERT_EQUAL_INT16(expected_angle_start, lv_arc_get_angle_start(arc));
+    TEST_ASSERT_EQUAL_INT16(expected_angle_end, lv_arc_get_angle_end(arc));
+}
+
+void test_arc_should_update_angles_when_changing_to_symmetrical_mode_value_more_than_middle_range(void)
+{
+    int16_t expected_angle_start = 270;
+    int16_t expected_angle_end = 45;
+
+    /* start angle is 135, end angle is 45 at creation */
+    arc = lv_arc_create(active_screen);
+    lv_arc_set_value(arc, 100);
+    lv_arc_set_mode(arc, LV_ARC_MODE_SYMMETRICAL);
+
+    TEST_ASSERT_EQUAL_INT16(expected_angle_start, lv_arc_get_angle_start(arc));
+    TEST_ASSERT_EQUAL_INT16(expected_angle_end, lv_arc_get_angle_end(arc));
+}
+
+/* See #2522 for more information */
+void test_arc_angles_when_reversed(void)
+{
+    uint16_t expected_start_angle = 36;
+    uint16_t expected_end_angle = 90;
+    int16_t expected_value = 40;
+
+    lv_obj_t * arcBlack;
+    arcBlack = lv_arc_create(lv_scr_act());
+
+    lv_arc_set_mode(arcBlack, LV_ARC_MODE_REVERSE);
+
+    lv_arc_set_bg_angles(arcBlack, 0, 90);
+
+    lv_arc_set_value(arcBlack, expected_value);
+
+    TEST_ASSERT_EQUAL_UINT16(expected_start_angle, lv_arc_get_angle_start(arcBlack));
+    TEST_ASSERT_EQUAL_UINT16(expected_end_angle, lv_arc_get_angle_end(arcBlack));
+    TEST_ASSERT_EQUAL_INT16(expected_value, lv_arc_get_value(arcBlack));
+}
+
+void test_arc_click_area_with_adv_hittest(void)
+{
+    arc = lv_arc_create(lv_scr_act());
+    lv_obj_set_size(arc, 100, 100);
+    lv_obj_set_style_arc_width(arc, 10, 0);
+    lv_obj_add_flag(arc, LV_OBJ_FLAG_ADV_HITTEST);
+    lv_obj_add_event_cb(arc, dummy_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
+    lv_obj_set_ext_click_area(arc, 5);
+
+    /*No click detected at the middle*/
+    event_cnt = 0;
+    lv_test_mouse_click_at(50, 50);
+    TEST_ASSERT_EQUAL_UINT32(0, event_cnt);
+
+    /*No click close to the radius - bg_arc - ext_click_area*/
+    event_cnt = 0;
+    lv_test_mouse_click_at(83, 50);
+    TEST_ASSERT_EQUAL_UINT32(0, event_cnt);
+
+    /*Click on the radius - bg_arc - ext_click_area*/
+    event_cnt = 0;
+    lv_test_mouse_click_at(86, 50);
+    TEST_ASSERT_GREATER_THAN(0, event_cnt);
+
+    /*Click on the radius + ext_click_area*/
+    event_cnt = 0;
+    lv_test_mouse_click_at(104, 50);
+    TEST_ASSERT_GREATER_THAN(0, event_cnt);
+
+    /*No click beyond to the radius + ext_click_area*/
+    event_cnt = 0;
+    lv_test_mouse_click_at(106, 50);
+    TEST_ASSERT_EQUAL_UINT32(0, event_cnt);
+}
+
+static void dummy_event_cb(lv_event_t * e)
+{
+    LV_UNUSED(e);
+    event_cnt++;
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_bar.c

@@ -0,0 +1,253 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+#include "lv_test_indev.h"
+
+static lv_obj_t * active_screen = NULL;
+static lv_obj_t * bar = NULL;
+
+void setUp(void)
+{
+    active_screen = lv_scr_act();
+    bar = lv_bar_create(active_screen);
+}
+
+void tearDown(void)
+{
+}
+
+void test_bar_should_have_valid_default_attributes(void)
+{
+    TEST_ASSERT_EQUAL(0, lv_bar_get_min_value(bar));
+    TEST_ASSERT_EQUAL(100, lv_bar_get_max_value(bar));
+    TEST_ASSERT_EQUAL(LV_BAR_MODE_NORMAL, lv_bar_get_mode(bar));
+}
+
+/*
+ * Bar has two parts, main and indicator, coordinates of the latter are
+ * calculated based on:
+ * - Bar size
+ * - Bar (main part) padding
+ * - Bar value
+ * - Bar coordinates
+ * - Bar base direction
+ * See Boxing model in docs for reference.
+ *
+ * Bar properties assumed:
+ * - mode: LV_BAR_MODE_NORMAL
+ * - min value: 0
+ * - max value: 100
+ * - base direction: LTR
+ */
+void test_bar_should_update_indicator_right_coordinate_based_on_bar_value(void)
+{
+    lv_bar_t * bar_ptr = (lv_bar_t *) bar;
+
+    static lv_style_t bar_style;
+
+    const lv_coord_t style_padding = 5u;
+    const lv_coord_t bar_width = 200u;
+    const lv_coord_t bar_height = 20u;
+    int32_t bar_value = 10u;
+
+    lv_style_init(&bar_style);
+    lv_style_set_pad_all(&bar_style, style_padding);
+
+    /* Setup new style */
+    lv_obj_remove_style_all(bar);
+    lv_obj_add_style(bar, &bar_style, LV_PART_MAIN);
+
+    /* Set properties */
+    lv_obj_set_size(bar, bar_width, bar_height);
+    lv_bar_set_value(bar, bar_value, LV_ANIM_OFF);
+
+    /* FIXME: Remove wait */
+    lv_test_indev_wait(50);
+
+    int32_t actual_coord = lv_area_get_width(&bar_ptr->indic_area);
+
+    /* Calculate bar indicator right coordinate, using rule of 3 */
+    lv_coord_t bar_max_value = lv_bar_get_max_value(bar);
+    lv_coord_t indicator_part_width = lv_obj_get_content_width(bar);
+    lv_coord_t sides_padding = lv_obj_get_style_pad_left(bar, LV_PART_MAIN);
+    sides_padding += lv_obj_get_style_pad_right(bar, LV_PART_MAIN);
+
+    int32_t expected_coord = (bar_value * indicator_part_width) / bar_max_value;
+    /* NOTE: Add 1 to calculation because the coordinates start at 0 */
+    expected_coord += 1;
+
+    TEST_ASSERT_EQUAL_INT32(expected_coord, actual_coord);
+}
+
+/*
+ * Bar has two parts, main and indicator, coordinates of the latter are
+ * calculated based on:
+ * - Bar size
+ * - Bar (main part) padding
+ * - Bar value
+ * - Bar coordinates
+ * - Bar base direction
+ * See Boxing model in docs for reference.
+ *
+ * Bar properties assumed:
+ * - mode: LV_BAR_MODE_NORMAL
+ * - min value: 0
+ * - max value: 100
+ */
+void test_bar_rtl_should_update_indicator_left_coordinate_based_on_bar_value(void)
+{
+    lv_bar_t * bar_ptr = (lv_bar_t *) bar;
+
+    static lv_style_t bar_style;
+
+    const lv_coord_t style_padding = 5u;
+    const lv_coord_t bar_width = 200u;
+    const lv_coord_t bar_height = 20u;
+    int32_t bar_value = 10u;
+
+    lv_style_init(&bar_style);
+    lv_style_set_pad_all(&bar_style, style_padding);
+
+    /* Setup new style */
+    lv_obj_remove_style_all(bar);
+    lv_obj_add_style(bar, &bar_style, LV_PART_MAIN);
+
+    /* Set properties */
+    lv_obj_set_size(bar, bar_width, bar_height);
+    lv_bar_set_value(bar, bar_value, LV_ANIM_OFF);
+    lv_obj_set_style_base_dir(bar, LV_BASE_DIR_RTL, 0);
+
+    /* FIXME: Remove wait */
+    lv_test_indev_wait(50);
+
+    int32_t actual_coord = bar_ptr->indic_area.x1;
+
+    /* Calculate current indicator width */
+    lv_coord_t bar_max_value = lv_bar_get_max_value(bar);
+    lv_coord_t indicator_part_width = lv_obj_get_content_width(bar);
+    lv_coord_t right_padding = lv_obj_get_style_pad_right(bar, LV_PART_MAIN);
+    int32_t indicator_width = (bar_value * indicator_part_width) / bar_max_value;
+
+    int32_t expected_coord = (bar_width - right_padding) - indicator_width;
+    expected_coord -= 1;
+
+    TEST_ASSERT_EQUAL_INT32(expected_coord, actual_coord);
+}
+
+void test_bar_indicator_area_should_get_smaller_when_padding_is_increased(void)
+{
+    lv_bar_t * bar_ptr = (lv_bar_t *) bar;
+
+    const lv_coord_t style_padding = 10u;
+    static lv_style_t bar_style;
+
+    int32_t new_height = 0u;
+    int32_t new_width = 0u;
+    int32_t original_height = 0u;
+    int32_t original_width = 0u;
+
+    lv_bar_set_value(bar, 50, LV_ANIM_OFF);
+    lv_test_indev_wait(50);
+
+    original_width = lv_area_get_width(&bar_ptr->indic_area);
+    original_height = lv_area_get_height(&bar_ptr->indic_area);
+
+    /* Setup new padding */
+    lv_style_init(&bar_style);
+    lv_style_set_pad_all(&bar_style, style_padding);
+    lv_obj_set_size(bar, 100, 50);
+
+    /* Apply new style  */
+    lv_obj_remove_style_all(bar);
+    lv_obj_add_style(bar, &bar_style, LV_PART_MAIN);
+
+    /* Notify LVGL of style change */
+    lv_obj_report_style_change(&bar_style);
+    lv_test_indev_wait(50);
+
+    new_height = lv_area_get_height(&bar_ptr->indic_area);
+    new_width = lv_area_get_width(&bar_ptr->indic_area);
+
+    TEST_ASSERT_LESS_THAN_INT32(original_height, new_height);
+    TEST_ASSERT_LESS_THAN_INT32(original_width, new_width);
+}
+
+void test_bar_start_value_should_only_change_when_in_range_mode(void)
+{
+    int32_t new_start_value = 20u;
+
+    lv_bar_set_value(bar, 90, LV_ANIM_OFF);
+    lv_bar_set_start_value(bar, new_start_value, LV_ANIM_OFF);
+
+    /* Start value shouldn't be updated when not in RANGE mode */
+    TEST_ASSERT_EQUAL_INT32(0u, lv_bar_get_start_value(bar));
+
+    /* Set bar in RANGE mode so we can edit the start value */
+    lv_bar_set_mode(bar, LV_BAR_MODE_RANGE);
+    lv_bar_set_start_value(bar, new_start_value, LV_ANIM_OFF);
+
+    TEST_ASSERT_EQUAL_INT32(new_start_value, lv_bar_get_start_value(bar));
+}
+
+void test_bar_start_value_should_be_smaller_than_current_value_in_range_mode(void)
+{
+    /* Set bar in RANGE mode so we can edit the start value */
+    lv_bar_set_mode(bar, LV_BAR_MODE_RANGE);
+    lv_bar_set_value(bar, 50, LV_ANIM_OFF);
+    lv_bar_set_start_value(bar, 100u, LV_ANIM_OFF);
+
+    TEST_ASSERT_EQUAL_INT32(lv_bar_get_value(bar), lv_bar_get_start_value(bar));
+}
+
+void test_bar_current_value_should_be_truncated_to_max_value_when_exceeds_it(void)
+{
+    int32_t max_value = lv_bar_get_max_value(bar);
+    int32_t new_value = max_value + 1u;
+
+    lv_bar_set_value(bar, new_value, LV_ANIM_OFF);
+    TEST_ASSERT_EQUAL_INT32(max_value, lv_bar_get_value(bar));
+}
+
+void test_bar_current_value_should_be_truncated_to_min_value_when_it_is_below_it(void)
+{
+    int32_t min_value = lv_bar_get_min_value(bar);
+    int32_t new_value = min_value - 1u;
+
+    lv_bar_set_value(bar, new_value, LV_ANIM_OFF);
+    TEST_ASSERT_EQUAL_INT32(min_value, lv_bar_get_value(bar));
+}
+
+/** When in symmetrical mode, the bar indicator has to be drawn towards the min
+ * range value. Requires a negative min range value and a positive max range
+ * value.
+ *
+ * Bar properties assumed:
+ * - base direction: LTR
+ */
+void test_bar_indicator_should_be_drawn_towards_the_min_range_side_after_setting_a_more_negative_value(void)
+{
+    lv_bar_t * bar_ptr = (lv_bar_t *) bar;
+
+    /* Setup bar properties */
+    lv_obj_set_size(bar, 100, 50);
+    lv_bar_set_mode(bar, LV_BAR_MODE_SYMMETRICAL);
+    lv_bar_set_range(bar, -100, 100);
+
+    /* Set bar value to 1, so it gets drawn at the middle of the bar */
+    lv_bar_set_value(bar, 1, LV_ANIM_OFF);
+    lv_test_indev_wait(50);
+
+    lv_coord_t original_pos = bar_ptr->indic_area.x1;
+
+    /* Set bar to a more negative value */
+    lv_bar_set_value(bar, -50, LV_ANIM_OFF);
+    lv_test_indev_wait(50);
+
+    lv_coord_t final_pos = bar_ptr->indic_area.x1;
+
+    TEST_ASSERT_LESS_THAN(original_pos, final_pos);
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_checkbox.c

@@ -0,0 +1,96 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+#include "lv_test_helpers.h"
+#include "lv_test_indev.h"
+
+void test_checkbox_creation_successfull(void);
+void test_checkbox_should_call_event_handler_on_click_when_enabled(void);
+void test_checkbox_should_have_default_text_when_created(void);
+void test_checkbox_should_return_dinamically_allocated_text(void);
+void test_checkbox_should_allocate_memory_for_static_text(void);
+
+static lv_obj_t * active_screen = NULL;
+static lv_obj_t * checkbox = NULL;
+
+static volatile bool event_called = false;
+
+static void event_handler(lv_event_t * e)
+{
+    lv_event_code_t code = lv_event_get_code(e);
+
+    if(LV_EVENT_VALUE_CHANGED == code) {
+        event_called = true;
+    }
+}
+
+void test_checkbox_creation_successfull(void)
+{
+    active_screen = lv_scr_act();
+    checkbox = lv_checkbox_create(active_screen);
+
+    TEST_ASSERT_NOT_NULL(checkbox);
+}
+
+void test_checkbox_should_call_event_handler_on_click_when_enabled(void)
+{
+    active_screen = lv_scr_act();
+    checkbox = lv_checkbox_create(active_screen);
+
+    lv_obj_add_state(checkbox, LV_STATE_CHECKED);
+    lv_obj_add_event_cb(checkbox, event_handler, LV_EVENT_ALL, NULL);
+
+    lv_test_mouse_click_at(checkbox->coords.x1, checkbox->coords.y1);
+
+    TEST_ASSERT_TRUE(event_called);
+
+    event_called = false;
+}
+
+void test_checkbox_should_have_default_text_when_created(void)
+{
+    const char * default_text = "Check box";
+
+    active_screen = lv_scr_act();
+    checkbox = lv_checkbox_create(active_screen);
+
+    TEST_ASSERT_EQUAL_STRING(default_text, lv_checkbox_get_text(checkbox));
+    TEST_ASSERT_NOT_NULL(lv_checkbox_get_text(checkbox));
+}
+
+void test_checkbox_should_return_dinamically_allocated_text(void)
+{
+    const char * message = "Hello World!";
+
+    active_screen = lv_scr_act();
+    checkbox = lv_checkbox_create(active_screen);
+
+    lv_checkbox_set_text(checkbox, message);
+
+    TEST_ASSERT_EQUAL_STRING(message, lv_checkbox_get_text(checkbox));
+    TEST_ASSERT_NOT_NULL(lv_checkbox_get_text(checkbox));
+}
+
+void test_checkbox_should_allocate_memory_for_static_text(void)
+{
+    uint32_t initial_available_memory = 0;
+    const char * static_text = "Keep me while you exist";
+
+    lv_mem_monitor_t m1;
+    lv_mem_monitor(&m1);
+
+    active_screen = lv_scr_act();
+    checkbox = lv_checkbox_create(active_screen);
+
+    initial_available_memory = m1.free_size;
+
+    lv_checkbox_set_text_static(checkbox, static_text);
+
+    lv_mem_monitor(&m1);
+
+    LV_HEAP_CHECK(TEST_ASSERT_LESS_THAN(initial_available_memory, m1.free_size));
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_config.c

@@ -0,0 +1,19 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+void test_config(void);
+
+void test_config(void)
+{
+    TEST_ASSERT_EQUAL(130, LV_DPI_DEF);
+    TEST_ASSERT_EQUAL(130, lv_disp_get_dpi(NULL));
+    TEST_ASSERT_EQUAL(800, LV_HOR_RES);
+    TEST_ASSERT_EQUAL(800, lv_disp_get_hor_res(NULL));
+    TEST_ASSERT_EQUAL(480, LV_VER_RES);
+    TEST_ASSERT_EQUAL(480, lv_disp_get_ver_res(NULL));
+    TEST_ASSERT_EQUAL(32, LV_COLOR_DEPTH);
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_demo_stress.c

@@ -0,0 +1,32 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+#include "../demos/lv_demos.h"
+
+#include "unity/unity.h"
+
+#include "lv_test_helpers.h"
+#include "lv_test_indev.h"
+
+static void loop_through_stress_test(void)
+{
+#if LV_USE_DEMO_STRESS
+    lv_test_indev_wait(LV_DEMO_STRESS_TIME_STEP * 33); /* FIXME: remove magic number of states */
+#endif
+}
+void test_demo_stress(void)
+{
+#if LV_USE_DEMO_STRESS
+    lv_demo_stress();
+#endif
+    /* loop once to allow objects to be created */
+    loop_through_stress_test();
+    uint32_t mem_before = lv_test_get_free_mem();
+    /* loop 10 more times */
+    for(uint32_t i = 0; i < 10; i++) {
+        loop_through_stress_test();
+    }
+    TEST_ASSERT_EQUAL(mem_before, lv_test_get_free_mem());
+}
+
+#endif
+

LVGL.Simulator/lvgl/tests/src/test_cases/test_demo_widgets.c

@@ -0,0 +1,18 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+#include "../demos/lv_demos.h"
+
+#include "unity/unity.h"
+
+#include "lv_test_helpers.h"
+#include "lv_test_indev.h"
+
+void test_demo_widgets(void)
+{
+#if LV_USE_DEMO_WIDGETS
+    lv_demo_widgets();
+#endif
+}
+
+#endif
+

LVGL.Simulator/lvgl/tests/src/test_cases/test_dropdown.c

@@ -0,0 +1,445 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+#include "lv_test_indev.h"
+
+void setUp(void)
+{
+    /* Function run before every test */
+}
+
+void tearDown(void)
+{
+    /* Function run after every test */
+    lv_obj_clean(lv_scr_act());
+}
+void test_dropdown_create_delete(void)
+{
+    lv_dropdown_create(lv_scr_act());
+    TEST_ASSERT_EQUAL(2, lv_obj_get_child_cnt(lv_scr_act()));
+
+    lv_obj_t * dd2 = lv_dropdown_create(lv_scr_act());
+    lv_obj_set_pos(dd2, 200, 0);
+    TEST_ASSERT_EQUAL(4, lv_obj_get_child_cnt(lv_scr_act()));
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd2));
+    lv_dropdown_open(dd2);
+    TEST_ASSERT_EQUAL(4, lv_obj_get_child_cnt(lv_scr_act()));
+    TEST_ASSERT_TRUE(lv_dropdown_is_open(dd2));
+    lv_dropdown_open(dd2);    /*Try to open again*/
+    TEST_ASSERT_EQUAL(4, lv_obj_get_child_cnt(lv_scr_act()));
+
+    lv_obj_t * dd3 = lv_dropdown_create(lv_scr_act());
+    lv_obj_set_pos(dd3, 400, 0);
+    TEST_ASSERT_EQUAL(6, lv_obj_get_child_cnt(lv_scr_act()));
+    lv_dropdown_open(dd3);
+    TEST_ASSERT_EQUAL(6, lv_obj_get_child_cnt(lv_scr_act()));
+    lv_dropdown_close(dd3);
+    TEST_ASSERT_EQUAL(6, lv_obj_get_child_cnt(lv_scr_act()));
+    lv_dropdown_close(dd3);   /*Try to close again*/
+    TEST_ASSERT_EQUAL(6, lv_obj_get_child_cnt(lv_scr_act()));
+
+    lv_obj_del(dd2);
+    TEST_ASSERT_EQUAL(4, lv_obj_get_child_cnt(lv_scr_act()));
+
+    lv_obj_clean(lv_scr_act());
+    TEST_ASSERT_EQUAL(0, lv_obj_get_child_cnt(lv_scr_act()));
+
+}
+
+void test_dropdown_set_options(void)
+{
+
+    lv_mem_monitor_t m1;
+    lv_mem_monitor(&m1);
+
+    lv_obj_t * dd1 = lv_dropdown_create(lv_scr_act());
+    TEST_ASSERT_EQUAL_STRING("Option 1\nOption 2\nOption 3", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(3, lv_dropdown_get_option_cnt(dd1));
+
+    lv_dropdown_set_options(dd1, "a1\nb2\nc3\nd4\ne5\nf6");
+    TEST_ASSERT_EQUAL_STRING("a1\nb2\nc3\nd4\ne5\nf6", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(6, lv_dropdown_get_option_cnt(dd1));
+
+    lv_obj_set_width(dd1, 200);
+    lv_dropdown_open(dd1);
+    lv_obj_update_layout(dd1);
+    TEST_ASSERT_EQUAL(200, lv_obj_get_width(lv_dropdown_get_list(dd1)));
+
+    lv_dropdown_close(dd1);
+
+    lv_dropdown_add_option(dd1, "x0", 0);
+    TEST_ASSERT_EQUAL_STRING("x0\na1\nb2\nc3\nd4\ne5\nf6", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(7, lv_dropdown_get_option_cnt(dd1));
+
+    lv_dropdown_add_option(dd1, "y0", 3);
+    TEST_ASSERT_EQUAL_STRING("x0\na1\nb2\ny0\nc3\nd4\ne5\nf6", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(8, lv_dropdown_get_option_cnt(dd1));
+
+    lv_dropdown_add_option(dd1, "z0", LV_DROPDOWN_POS_LAST);
+    TEST_ASSERT_EQUAL_STRING("x0\na1\nb2\ny0\nc3\nd4\ne5\nf6\nz0", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(9, lv_dropdown_get_option_cnt(dd1));
+
+    lv_dropdown_clear_options(dd1);
+    TEST_ASSERT_EQUAL_STRING("", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(0, lv_dropdown_get_option_cnt(dd1));
+
+    lv_dropdown_set_options(dd1, "o1\no2"); /*Just to add some content before lv_dropdown_set_options_static*/
+
+    lv_dropdown_set_options_static(dd1, "a1\nb2\nc3\nd4\ne5\nf6");
+    TEST_ASSERT_EQUAL_STRING("a1\nb2\nc3\nd4\ne5\nf6", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(6, lv_dropdown_get_option_cnt(dd1));
+
+    lv_dropdown_add_option(dd1, "x0", 0);
+    TEST_ASSERT_EQUAL_STRING("x0\na1\nb2\nc3\nd4\ne5\nf6", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(7, lv_dropdown_get_option_cnt(dd1));
+
+    lv_dropdown_add_option(dd1, "y0", 3);
+    TEST_ASSERT_EQUAL_STRING("x0\na1\nb2\ny0\nc3\nd4\ne5\nf6", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(8, lv_dropdown_get_option_cnt(dd1));
+
+    lv_dropdown_add_option(dd1, "z0", LV_DROPDOWN_POS_LAST);
+    TEST_ASSERT_EQUAL_STRING("x0\na1\nb2\ny0\nc3\nd4\ne5\nf6\nz0", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(9, lv_dropdown_get_option_cnt(dd1));
+
+    lv_dropdown_clear_options(dd1);
+    TEST_ASSERT_EQUAL_STRING("", lv_dropdown_get_options(dd1));
+    TEST_ASSERT_EQUAL(0, lv_dropdown_get_option_cnt(dd1));
+
+    lv_obj_del(dd1);
+
+    lv_mem_monitor_t m2;
+    lv_mem_monitor(&m2);
+    TEST_ASSERT_UINT32_WITHIN(48, m1.free_size, m2.free_size);
+}
+
+void test_dropdown_select(void)
+{
+    lv_obj_t * dd1 = lv_dropdown_create(lv_scr_act());
+    lv_dropdown_set_selected(dd1, 2);
+
+    TEST_ASSERT_EQUAL(2, lv_dropdown_get_selected(dd1));
+
+    char buf[32];
+    memset(buf, 0x00, sizeof(buf));
+    lv_dropdown_get_selected_str(dd1, buf, sizeof(buf));
+    TEST_ASSERT_EQUAL_STRING("Option 3", buf);
+
+    memset(buf, 0x00, sizeof(buf));
+    lv_dropdown_get_selected_str(dd1, buf, 4);
+    TEST_ASSERT_EQUAL_STRING("Opt", buf);
+
+    /*Out of range*/
+    lv_dropdown_set_selected(dd1, 3);
+    TEST_ASSERT_EQUAL(2, lv_dropdown_get_selected(dd1));
+}
+
+void test_dropdown_click(void)
+{
+    lv_obj_clean(lv_scr_act());
+    lv_obj_t * dd1 = lv_dropdown_create(lv_scr_act());
+    lv_obj_update_layout(dd1);
+
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    lv_test_mouse_click_at(dd1->coords.x1 + 5, dd1->coords.y1 + 5);
+    TEST_ASSERT_TRUE(lv_dropdown_is_open(dd1));
+
+    lv_obj_t * list = lv_dropdown_get_list(dd1);
+    TEST_ASSERT_EQUAL(0, lv_dropdown_get_selected(dd1));
+    lv_test_mouse_click_at(list->coords.x1 + 5, list->coords.y2 - 25);
+    TEST_ASSERT_EQUAL(2, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+}
+
+static uint32_t event_cnt;
+static void dd_event(lv_event_t * e)
+{
+    LV_UNUSED(e);
+    event_cnt++;
+}
+
+void test_dropdown_keypad(void)
+{
+    lv_obj_clean(lv_scr_act());
+
+    lv_group_t * g = lv_group_create();
+    lv_indev_set_group(lv_test_keypad_indev, g);
+
+    lv_obj_t * dd1 = lv_dropdown_create(lv_scr_act());
+    lv_obj_set_pos(dd1, 20, 20);
+    lv_dropdown_set_options(dd1, "1\n2\n3\n4\n5\n6\n7\n8");
+    lv_group_add_obj(g, dd1);
+    lv_obj_add_event_cb(dd1, dd_event, LV_EVENT_VALUE_CHANGED, NULL);
+
+    lv_obj_t * dd2 = lv_dropdown_create(lv_scr_act());
+    lv_obj_set_pos(dd2, 300, 20);
+    lv_group_add_obj(g, dd2);
+
+    event_cnt = 0;
+
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd2));
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_TRUE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd2));
+
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_RIGHT);  /*Same as down*/
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_EQUAL(2, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(1, event_cnt);
+
+    lv_test_key_hit(LV_KEY_DOWN); /*Open the list too*/
+    TEST_ASSERT_NOT_NULL(lv_dropdown_get_list(dd1));
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_EQUAL(3, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(2, event_cnt);
+
+    lv_test_key_hit(LV_KEY_RIGHT); /*Open the list too*/
+    TEST_ASSERT_NOT_NULL(lv_dropdown_get_list(dd1));
+    lv_test_key_hit(LV_KEY_RIGHT);
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_EQUAL(4, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(3, event_cnt);
+
+    lv_test_key_hit(LV_KEY_LEFT); /*Open the list too*/
+    TEST_ASSERT_TRUE(lv_dropdown_is_open(dd1));
+    lv_test_key_hit(LV_KEY_LEFT);
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_EQUAL(3, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(4, event_cnt);
+
+    lv_test_key_hit(LV_KEY_UP); /*Open the list too*/
+    TEST_ASSERT_NOT_NULL(lv_dropdown_get_list(dd1));
+    lv_test_key_hit(LV_KEY_UP);
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_EQUAL(2, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(5, event_cnt);
+
+    lv_test_key_hit(LV_KEY_UP);
+    lv_test_key_hit(LV_KEY_UP);
+    lv_test_key_hit(LV_KEY_UP);
+    lv_test_key_hit(LV_KEY_UP);
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_EQUAL(0, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(6, event_cnt);
+
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_DOWN);
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_EQUAL(7, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(7, event_cnt);
+
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_TRUE(lv_dropdown_is_open(dd1));
+
+    lv_test_key_hit(LV_KEY_NEXT);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd2));
+
+    lv_test_key_hit(LV_KEY_ENTER);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_NOT_NULL(lv_dropdown_get_list(dd2));
+
+    lv_indev_set_group(lv_test_keypad_indev, NULL);
+    lv_group_del(g);
+}
+
+
+void test_dropdown_encoder(void)
+{
+    lv_obj_clean(lv_scr_act());
+
+    lv_group_t * g = lv_group_create();
+    lv_indev_set_group(lv_test_encoder_indev, g);
+
+    lv_obj_t * dd1 = lv_dropdown_create(lv_scr_act());
+    lv_obj_set_pos(dd1, 20, 20);
+    lv_dropdown_set_options(dd1, "1\n2\n3\n4\n5\n6\n7\n8");
+    lv_group_add_obj(g, dd1);
+    lv_obj_add_event_cb(dd1, dd_event, LV_EVENT_VALUE_CHANGED, NULL);
+
+    lv_obj_t * dd2 = lv_dropdown_create(lv_scr_act());
+    lv_obj_set_pos(dd2, 300, 20);
+    lv_group_add_obj(g, dd2);
+
+    event_cnt = 0;
+
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd2));
+    lv_test_encoder_click();
+    TEST_ASSERT_TRUE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd2));
+
+    lv_test_encoder_turn(5);
+    lv_test_encoder_click();
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_EQUAL(5, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(1, event_cnt);
+
+    lv_test_encoder_click();
+    lv_test_encoder_turn(-1);
+    lv_test_encoder_click();
+    TEST_ASSERT_EQUAL(4, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(2, event_cnt);
+
+    lv_test_encoder_click();
+    lv_test_encoder_turn(2);
+    lv_test_encoder_press();
+    lv_test_indev_wait(1000);  //Long press
+    lv_test_encoder_release();
+    lv_test_indev_wait(50);
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_EQUAL(4, lv_dropdown_get_selected(dd1));
+    TEST_ASSERT_EQUAL(2, event_cnt);
+
+    lv_test_encoder_turn(1);
+    lv_test_encoder_click();
+    TEST_ASSERT_FALSE(lv_dropdown_is_open(dd1));
+    TEST_ASSERT_TRUE(lv_dropdown_is_open(dd2));
+
+    lv_indev_set_group(lv_test_encoder_indev, NULL);
+    lv_group_del(g);
+}
+
+
+void test_dropdown_render_1(void)
+{
+    lv_obj_clean(lv_scr_act());
+
+    lv_obj_t * dd1 = lv_dropdown_create(lv_scr_act());
+    lv_obj_set_pos(dd1, 10, 10);
+    lv_dropdown_set_selected(dd1, 1);
+
+    lv_obj_t * dd2 = lv_dropdown_create(lv_scr_act());
+    lv_obj_set_pos(dd2, 200, 10);
+    lv_obj_set_width(dd2, 200);
+    lv_dropdown_set_selected(dd2, 2);
+    lv_dropdown_open(dd2);
+    TEST_ASSERT_TRUE(lv_dropdown_get_selected_highlight(dd2));
+    lv_dropdown_set_selected_highlight(dd2, false);
+    TEST_ASSERT_FALSE(lv_dropdown_get_selected_highlight(dd2));
+
+    lv_obj_t * dd3 = lv_dropdown_create(lv_scr_act());
+    lv_obj_set_style_pad_hor(dd3, 5, 0);
+    lv_obj_set_style_pad_ver(dd3, 20, 0);
+    lv_obj_set_pos(dd3, 500, 150);
+    TEST_ASSERT_EQUAL_PTR(NULL, lv_dropdown_get_text(dd3));
+    lv_dropdown_set_text(dd3, "A text");
+    TEST_ASSERT_EQUAL_STRING("A text", lv_dropdown_get_text(dd3));
+
+    lv_dropdown_set_selected(dd3, 2);
+
+    TEST_ASSERT_EQUAL(LV_DIR_BOTTOM, lv_dropdown_get_dir(dd3));
+    lv_dropdown_set_dir(dd3, LV_DIR_LEFT);
+    TEST_ASSERT_EQUAL(LV_DIR_LEFT, lv_dropdown_get_dir(dd3));
+
+    TEST_ASSERT_EQUAL_STRING(LV_SYMBOL_DOWN, lv_dropdown_get_symbol(dd3));
+    lv_dropdown_set_symbol(dd3, LV_SYMBOL_LEFT);
+    TEST_ASSERT_EQUAL_STRING(LV_SYMBOL_LEFT, lv_dropdown_get_symbol(dd3));
+
+    lv_dropdown_set_options(dd3, "a0\na1\na2\na3\na4\na5\na6\na7\na8\na9\na10\na11\na12\na13\na14\na15\na16");
+    lv_dropdown_open(dd3);
+    lv_dropdown_set_selected(dd3, 3);
+    lv_obj_t * list = lv_dropdown_get_list(dd3);
+    lv_obj_set_style_text_line_space(list, 5, 0);
+    lv_obj_set_style_bg_color(list, lv_color_hex3(0xf00), LV_PART_SELECTED | LV_STATE_CHECKED);
+
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("dropdown_1.png");
+}
+
+void test_dropdown_render_2(void)
+{
+    lv_obj_clean(lv_scr_act());
+    LV_IMG_DECLARE(img_caret_down);
+    lv_obj_t * dd1 = lv_dropdown_create(lv_scr_act());
+    lv_dropdown_set_text(dd1, "Short");
+    lv_dropdown_set_options(dd1, "1\n2");
+    lv_dropdown_set_symbol(dd1, &img_caret_down);
+    lv_dropdown_open(dd1);
+
+    lv_obj_t * dd2 = lv_dropdown_create(lv_scr_act());
+    lv_dropdown_set_text(dd2, "Go Up");
+    lv_dropdown_set_options(dd2, "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15");
+    lv_dropdown_set_symbol(dd2, NULL);
+    lv_obj_align(dd2, LV_ALIGN_LEFT_MID, 150, 50);
+    lv_dropdown_open(dd2);
+
+    lv_obj_t * dd3 = lv_dropdown_create(lv_scr_act());
+    lv_dropdown_set_text(dd3, "Limit Down");
+    lv_dropdown_set_options(dd3, "1aaaaaaaaaaaaaaaa\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15");
+    lv_obj_align(dd3, LV_ALIGN_LEFT_MID, 300, -10);
+    lv_dropdown_open(dd3);
+
+    lv_obj_t * dd4 = lv_dropdown_create(lv_scr_act());
+    lv_dropdown_set_text(dd4, "Limit Top");
+    lv_dropdown_set_options(dd4, "1aaaaaaaaaaaaaaaa\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15");
+    lv_obj_align(dd4, LV_ALIGN_LEFT_MID, 450, 10);
+    lv_dropdown_set_dir(dd4, LV_DIR_TOP);
+    lv_dropdown_set_symbol(dd4, LV_SYMBOL_UP);
+    lv_dropdown_open(dd4);
+
+    lv_obj_t * dd5 = lv_dropdown_create(lv_scr_act());
+    lv_dropdown_set_text(dd5, "Go Down");
+    lv_dropdown_set_options(dd5, "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15");
+    lv_dropdown_set_dir(dd5, LV_DIR_TOP);
+    lv_dropdown_set_symbol(dd5, LV_SYMBOL_UP);
+    lv_obj_align(dd5, LV_ALIGN_LEFT_MID, 650, -200);
+    lv_dropdown_open(dd5);
+
+    lv_obj_t * dd6 = lv_dropdown_create(lv_scr_act());
+    lv_dropdown_set_text(dd6, "Right");
+    lv_dropdown_set_options(dd6, "1aaa\n2aa\n3aa");
+    lv_dropdown_set_dir(dd6, LV_DIR_RIGHT);
+    lv_dropdown_set_symbol(dd6, LV_SYMBOL_RIGHT);
+    lv_obj_align(dd6, LV_ALIGN_BOTTOM_LEFT, 20, -20);
+    lv_dropdown_open(dd6);
+    lv_obj_set_style_text_align(lv_dropdown_get_list(dd6), LV_TEXT_ALIGN_RIGHT, 0);
+
+    lv_obj_t * dd7 = lv_dropdown_create(lv_scr_act());
+    lv_dropdown_set_text(dd7, "Left");
+    lv_dropdown_set_options(dd7, "1aaa\n2\n3");
+    lv_dropdown_set_dir(dd7, LV_DIR_LEFT);
+    lv_dropdown_set_symbol(dd7, LV_SYMBOL_LEFT);
+    lv_obj_align(dd7, LV_ALIGN_BOTTOM_RIGHT, -20, -20);
+    lv_dropdown_open(dd7);
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("dropdown_2.png");
+}
+
+/* See #2893 */
+void test_dropdown_should_list_on_top(void)
+{
+    lv_obj_t * cont1 = lv_obj_create(lv_scr_act());
+    lv_obj_set_size(cont1, 200, 100);
+
+    lv_obj_t * dd = lv_dropdown_create(cont1);
+
+    lv_obj_t * cont2 = lv_obj_create(lv_scr_act());
+    lv_obj_set_size(cont2, 200, 100);
+    lv_obj_set_pos(cont2, 0, 100);
+
+    lv_dropdown_open(dd);
+    lv_obj_t * list = lv_dropdown_get_list(dd);
+    TEST_ASSERT_EQUAL_PTR(lv_scr_act(), lv_obj_get_parent(list));
+    TEST_ASSERT_EQUAL_INT(2, lv_obj_get_index(list));
+}
+
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_event.c

@@ -0,0 +1,27 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+static void event_object_deletion_cb(const lv_obj_class_t * cls, lv_event_t * e)
+{
+    LV_UNUSED(cls);
+    if(lv_event_get_code(e) == LV_EVENT_VALUE_CHANGED) {
+        lv_obj_del(lv_event_get_current_target(e));
+    }
+}
+
+static const lv_obj_class_t event_object_deletion_class = {
+    .event_cb = event_object_deletion_cb,
+    .base_class = &lv_obj_class
+};
+
+
+/* Checks for memory leaks/invalid memory accesses on deleted objects */
+void test_event_object_deletion(void)
+{
+    lv_obj_t * obj = lv_obj_class_create_obj(&event_object_deletion_class, lv_scr_act());
+    lv_event_send(obj, LV_EVENT_VALUE_CHANGED, NULL);
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_font_loader.c

@@ -0,0 +1,206 @@
+/**
+ * @file test_font_loader.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#if LV_BUILD_TEST
+#include "../../lvgl.h"
+
+#include "unity/unity.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static int compare_fonts(lv_font_t * f1, lv_font_t * f2);
+void test_font_loader(void);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+extern lv_font_t font_1;
+extern lv_font_t font_2;
+extern lv_font_t font_3;
+
+void test_font_loader(void)
+{
+    lv_font_t * font_1_bin = lv_font_load("F:src/test_fonts/font_1.fnt");
+    lv_font_t * font_2_bin = lv_font_load("F:src/test_fonts/font_2.fnt");
+    lv_font_t * font_3_bin = lv_font_load("F:src/test_fonts/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)
+{
+    TEST_ASSERT_NOT_NULL_MESSAGE(f1, "font not null");
+    TEST_ASSERT_NOT_NULL_MESSAGE(f2, "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 *’
+    //    TEST_ASSERT_EQUAL_PTR_MESSAGE(f1->get_glyph_dsc, f2->get_glyph_dsc, "glyph_dsc");
+    //    TEST_ASSERT_EQUAL_PTR_MESSAGE(f1->get_glyph_bitmap, f2->get_glyph_bitmap, "glyph_bitmap");
+
+    TEST_ASSERT_EQUAL_INT_MESSAGE(f1->line_height, f2->line_height, "line_height");
+    TEST_ASSERT_EQUAL_INT_MESSAGE(f1->base_line, f2->base_line, "base_line");
+    TEST_ASSERT_EQUAL_INT_MESSAGE(f1->subpx, f2->subpx, "subpx");
+    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;
+
+    TEST_ASSERT_EQUAL_INT_MESSAGE(dsc1->kern_scale, dsc2->kern_scale, "kern_scale");
+    TEST_ASSERT_EQUAL_INT_MESSAGE(dsc1->cmap_num, dsc2->cmap_num, "cmap_num");
+    TEST_ASSERT_EQUAL_INT_MESSAGE(dsc1->bpp, dsc2->bpp, "bpp");
+    TEST_ASSERT_EQUAL_INT_MESSAGE(dsc1->kern_classes, dsc2->kern_classes, "kern_classes");
+    TEST_ASSERT_EQUAL_INT_MESSAGE(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];
+
+        TEST_ASSERT_EQUAL_INT_MESSAGE(cmaps1->range_start, cmaps2->range_start, "range_start");
+        TEST_ASSERT_EQUAL_INT_MESSAGE(cmaps1->range_length, cmaps2->range_length, "range_length");
+        TEST_ASSERT_EQUAL_INT_MESSAGE(cmaps1->glyph_id_start, cmaps2->glyph_id_start, "glyph_id_start");
+        TEST_ASSERT_EQUAL_INT_MESSAGE(cmaps1->type, cmaps2->type, "type");
+        TEST_ASSERT_EQUAL_INT_MESSAGE(cmaps1->list_length, cmaps2->list_length, "list_length");
+
+        if(cmaps1->unicode_list != NULL && cmaps2->unicode_list != NULL) {
+            TEST_ASSERT_TRUE_MESSAGE(cmaps1->unicode_list && cmaps2->unicode_list, "unicode_list");
+
+            TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(
+                (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;
+            TEST_ASSERT_EQUAL_PTR_MESSAGE(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;
+
+            TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(ids1, ids2, cmaps1->list_length, "glyph_id_ofs_list");
+        }
+        else {
+            TEST_ASSERT_EQUAL_PTR_MESSAGE(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) {
+            TEST_ASSERT_EQUAL_INT_MESSAGE(kern1->right_class_cnt, kern2->right_class_cnt, "right_class_cnt");
+            TEST_ASSERT_EQUAL_INT_MESSAGE(kern1->left_class_cnt, kern2->left_class_cnt, "left_class_cnt");
+
+            TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(
+                (uint8_t *)kern1->left_class_mapping,
+                (uint8_t *)kern2->left_class_mapping,
+                kern1->left_class_cnt,
+                "left_class_mapping");
+
+            TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(
+                (uint8_t *)kern1->right_class_mapping,
+                (uint8_t *)kern2->right_class_mapping,
+                kern1->right_class_cnt,
+                "right_class_mapping");
+
+            TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(
+                (uint8_t *)kern1->class_pair_values,
+                (uint8_t *)kern2->class_pair_values,
+                kern1->right_class_cnt * kern1->left_class_cnt,
+                "class_pair_values");
+        }
+        else {
+            TEST_ASSERT_EQUAL_PTR_MESSAGE(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) {
+            TEST_ASSERT_EQUAL_INT_MESSAGE(kern1->glyph_ids_size, kern2->glyph_ids_size, "glyph_ids_size");
+            TEST_ASSERT_EQUAL_INT_MESSAGE(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;
+            }
+
+            TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(kern1->glyph_ids, kern2->glyph_ids, ids_size, "glyph_ids");
+            TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(
+                (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) {
+                TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(
+                    dsc1->glyph_bitmap + glyph_dsc1[i].bitmap_index,
+                    dsc2->glyph_bitmap + glyph_dsc2[i].bitmap_index,
+                    size1 - 1, "glyph_bitmap");
+            }
+        }
+        TEST_ASSERT_EQUAL_INT_MESSAGE(glyph_dsc1[i].adv_w, glyph_dsc2[i].adv_w, "adv_w");
+        TEST_ASSERT_EQUAL_INT_MESSAGE(glyph_dsc1[i].box_w, glyph_dsc2[i].box_w, "box_w");
+        TEST_ASSERT_EQUAL_INT_MESSAGE(glyph_dsc1[i].box_h, glyph_dsc2[i].box_h, "box_h");
+        TEST_ASSERT_EQUAL_INT_MESSAGE(glyph_dsc1[i].ofs_x, glyph_dsc2[i].ofs_x, "ofs_x");
+        TEST_ASSERT_EQUAL_INT_MESSAGE(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
+

LVGL.Simulator/lvgl/tests/src/test_cases/test_line.c

@@ -0,0 +1,95 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+static lv_obj_t * active_screen = NULL;
+static lv_obj_t * line = NULL;
+
+static const uint16_t default_point_num = 0U;
+static const lv_coord_t initial_extra_draw_size = 5U;
+static const lv_coord_t final_extra_draw_size = 10U;
+
+void setUp(void)
+{
+    active_screen = lv_scr_act();
+    line = lv_line_create(active_screen);
+}
+
+void tearDown(void)
+{
+    lv_obj_clean(active_screen);
+}
+
+void test_line_should_have_valid_documented_default_values(void)
+{
+    lv_line_t * line_ptr = (lv_line_t *) line;
+    TEST_ASSERT_EQUAL_UINT16(default_point_num, line_ptr->point_num);
+    TEST_ASSERT_NULL(line_ptr->point_array);
+    TEST_ASSERT_FALSE(lv_line_get_y_invert(line));
+    TEST_ASSERT_FALSE(lv_obj_has_flag(line, LV_OBJ_FLAG_CLICKABLE));
+    /* line doesn't have any points, so it's 0,0 in size */
+    TEST_ASSERT_EQUAL_UINT16(0U, lv_obj_get_self_width(line));
+    TEST_ASSERT_EQUAL_UINT16(0U, lv_obj_get_self_height(line));
+}
+
+void test_line_should_return_valid_y_invert(void)
+{
+    lv_line_set_y_invert(line, true);
+    TEST_ASSERT_TRUE(lv_line_get_y_invert(line));
+}
+
+void test_line_size_should_be_updated_after_adding_points(void)
+{
+    static lv_point_t points[] = { {5, 5} };
+    uint16_t point_cnt = (uint16_t) sizeof(points) / sizeof(lv_point_t);
+    lv_line_set_points(line, points, point_cnt);
+
+    lv_coord_t calculated_width = 0;
+    lv_coord_t calculated_height = 0;
+
+    /* Get the biggest coordinate on both axis */
+    uint16_t point_idx = 0;
+    for(point_idx = 0; point_idx < point_cnt; point_idx++) {
+        calculated_width = LV_MAX(points[point_idx].x, calculated_width);
+        calculated_height = LV_MAX(points[point_idx].y, calculated_height);
+    }
+    /* Add style line width */
+    lv_coord_t line_width = lv_obj_get_style_line_width(line, LV_PART_MAIN);
+    calculated_width += line_width;
+    calculated_height += line_width;
+
+    TEST_ASSERT_EQUAL_UINT16(calculated_width, lv_obj_get_self_width(line));
+    TEST_ASSERT_EQUAL_UINT16(calculated_height, lv_obj_get_self_height(line));
+}
+
+static void line_event_cb(lv_event_t * e)
+{
+    lv_event_code_t code = lv_event_get_code(e);
+
+    if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
+        /* Set the new line extra draw size */
+        lv_event_set_ext_draw_size(e, initial_extra_draw_size);
+    }
+}
+
+void test_line_should_update_extra_draw_size_based_on_style(void)
+{
+    /* Setup an event handler for line extra draw size event */
+    lv_obj_add_event_cb(line, line_event_cb, LV_EVENT_ALL, NULL);
+    /* Trigger the extra draw size event */
+    lv_obj_refresh_ext_draw_size(line);
+
+    TEST_ASSERT_EQUAL(initial_extra_draw_size, _lv_obj_get_ext_draw_size(line));
+
+    /* Update line width style, the event handler should set the extra draw size
+     * to the line width */
+    lv_obj_set_style_line_width(line, final_extra_draw_size, LV_PART_MAIN);
+
+    /* Trigger the extra draw size event */
+    lv_obj_refresh_ext_draw_size(line);
+
+    TEST_ASSERT_EQUAL(final_extra_draw_size, _lv_obj_get_ext_draw_size(line));
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_obj_tree.c

@@ -0,0 +1,39 @@
+#if LV_BUILD_TEST
+#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)
+{
+
+    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);
+
+    lv_color_t c1 = lv_color_hex(0x444444);
+    lv_color_t c2 = lv_color_hex3(0x444);
+    TEST_ASSERT_EQUAL_COLOR(c1, c2);
+
+    lv_obj_remove_style_all(lv_scr_act());
+    lv_obj_set_style_bg_color(lv_scr_act(), lv_color_hex(0x112233), 0);
+    lv_obj_set_style_bg_opa(lv_scr_act(), LV_OPA_COVER, 0);
+
+    //TEST_ASSERT_EQUAL_SCREENSHOT("scr1.png")
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_slider.c

@@ -0,0 +1,214 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+#include "lv_test_indev.h"
+
+static lv_obj_t * active_screen = NULL;
+static lv_obj_t * slider = NULL;
+static lv_obj_t * sliderRangeMode = NULL;
+static lv_obj_t * sliderNormalMode = NULL;
+static lv_obj_t * sliderSymmetricalMode = NULL;
+static lv_group_t * g = NULL;
+
+void setUp(void)
+{
+    active_screen = lv_scr_act();
+    slider = lv_slider_create(active_screen);
+    sliderRangeMode = lv_slider_create(active_screen);
+    sliderNormalMode = lv_slider_create(active_screen);
+    sliderSymmetricalMode = lv_slider_create(active_screen);
+
+    lv_slider_set_mode(sliderRangeMode, LV_SLIDER_MODE_RANGE);
+    lv_slider_set_mode(sliderNormalMode, LV_SLIDER_MODE_NORMAL);
+    lv_slider_set_mode(sliderSymmetricalMode, LV_SLIDER_MODE_SYMMETRICAL);
+
+    g = lv_group_create();
+    lv_indev_set_group(lv_test_encoder_indev, g);
+}
+
+void tearDown(void)
+{
+    lv_obj_clean(active_screen);
+}
+
+void test_textarea_should_have_valid_documented_default_values(void)
+{
+    lv_coord_t objw = lv_obj_get_width(slider);
+    lv_coord_t objh = lv_obj_get_height(slider);
+
+    /* Horizontal slider */
+    TEST_ASSERT_TRUE(objw >= objh);
+    TEST_ASSERT_FALSE(lv_obj_has_flag(slider, LV_OBJ_FLAG_SCROLL_CHAIN));
+    TEST_ASSERT_FALSE(lv_obj_has_flag(slider, LV_OBJ_FLAG_SCROLLABLE));
+}
+
+void test_slider_event_keys_right_and_up_increment_value_by_one(void)
+{
+    char key = LV_KEY_RIGHT;
+    lv_slider_set_value(slider, 10, LV_ANIM_OFF);
+    int32_t value = lv_slider_get_value(slider);
+
+    lv_event_send(slider, LV_EVENT_KEY, (void *) &key);
+
+    int32_t new_value = lv_slider_get_value(slider);
+    TEST_ASSERT_EQUAL_INT32(value + 1, new_value);
+
+    key = LV_KEY_UP;
+    lv_event_send(slider, LV_EVENT_KEY, (void *) &key);
+    TEST_ASSERT_EQUAL_INT32(new_value + 1, lv_slider_get_value(slider));
+}
+
+void test_slider_event_keys_left_and_down_decrement_value_by_one(void)
+{
+    char key = LV_KEY_LEFT;
+    lv_slider_set_value(slider, 10, LV_ANIM_OFF);
+    int32_t value = lv_slider_get_value(slider);
+
+    lv_event_send(slider, LV_EVENT_KEY, (void *) &key);
+
+    int32_t new_value = lv_slider_get_value(slider);
+    TEST_ASSERT_EQUAL_INT32(value - 1, new_value);
+
+    key = LV_KEY_DOWN;
+    lv_event_send(slider, LV_EVENT_KEY, (void *) &key);
+    TEST_ASSERT_EQUAL_INT32(new_value - 1, lv_slider_get_value(slider));
+}
+
+void test_slider_event_invalid_key_should_not_change_values(void)
+{
+    char key = LV_KEY_ENTER;
+    lv_slider_set_value(slider, 10, LV_ANIM_OFF);
+    int32_t value = lv_slider_get_value(slider);
+
+    lv_event_send(slider, LV_EVENT_KEY, (void *) &key);
+
+    TEST_ASSERT_EQUAL_INT32(value, lv_slider_get_value(slider));
+}
+
+void test_slider_range_mode_should_leave_edit_mode_if_released(void)
+{
+    lv_slider_t * ptr = (lv_slider_t *) sliderRangeMode;
+
+    /* Setup group and encoder indev */
+    lv_group_add_obj(g, sliderNormalMode);
+    lv_group_set_editing(g, true);
+
+    lv_test_encoder_click();
+
+    /* Always executed when handling LV_EVENT_RELEASED or
+     * LV_EVENT_PRESS_LOST */
+    TEST_ASSERT_FALSE(ptr->dragging);
+    TEST_ASSERT_NULL(ptr->value_to_set);
+    TEST_ASSERT_EQUAL(0U, ptr->left_knob_focus);
+
+    /* Group leaved edit mode */
+    TEST_ASSERT_FALSE(lv_group_get_editing(g));
+}
+
+void test_slider_range_mode_should_not_leave_edit_mode_if_released_with_no_left_knob_focus(void)
+{
+    lv_slider_t * ptr = (lv_slider_t *) sliderRangeMode;
+
+    /* Setup group and encoder indev */
+    lv_group_add_obj(g, sliderRangeMode);
+    lv_group_set_editing(g, true);
+
+    lv_test_encoder_release();
+    lv_test_indev_wait(50);
+
+    /* Always executed when handling LV_EVENT_RELEASED or
+     * LV_EVENT_PRESS_LOST */
+    TEST_ASSERT_FALSE(ptr->dragging);
+    TEST_ASSERT_NULL(ptr->value_to_set);
+
+    TEST_ASSERT(lv_group_get_editing(g));
+}
+
+void test_slider_normal_mode_should_leave_edit_mode_if_released(void)
+{
+    lv_slider_t * ptr = (lv_slider_t *) sliderNormalMode;
+    ptr->left_knob_focus = 1;
+
+    /* Setup group and encoder indev */
+    lv_group_add_obj(g, sliderNormalMode);
+    lv_group_set_editing(g, true);
+
+    lv_test_encoder_click();
+
+    /* Always executed when handling LV_EVENT_RELEASED or
+     * LV_EVENT_PRESS_LOST */
+    TEST_ASSERT_FALSE(ptr->dragging);
+    TEST_ASSERT_NULL(ptr->value_to_set);
+    TEST_ASSERT_EQUAL(0U, ptr->left_knob_focus);
+
+    /* Group leaved edit mode */
+    TEST_ASSERT_FALSE(lv_group_get_editing(g));
+}
+
+void test_ranged_mode_adjust_with_encoder(void)
+{
+    lv_slider_set_value(sliderRangeMode, 90, LV_ANIM_OFF);
+    lv_slider_set_left_value(sliderRangeMode, 10, LV_ANIM_OFF);
+
+    /* Setup group and encoder indev */
+    lv_group_add_obj(g, sliderRangeMode);
+    lv_group_set_editing(g, false);
+
+    /*Go the edit mode*/
+    lv_test_encoder_click();
+
+    /*Adjust the right knob*/
+    lv_test_encoder_turn(-10);
+    TEST_ASSERT_EQUAL(80, lv_slider_get_value(sliderRangeMode));  /*Updated?*/
+    TEST_ASSERT_EQUAL(10, lv_slider_get_left_value(sliderRangeMode));     /*Maintained?*/
+
+    /*Focus the left knob*/
+    lv_test_encoder_click();
+
+    /*Adjust the left knob*/
+    lv_test_encoder_turn(5);
+    TEST_ASSERT_EQUAL(80, lv_slider_get_value(sliderRangeMode));  /*Maintained?*/
+    TEST_ASSERT_EQUAL(15, lv_slider_get_left_value(sliderRangeMode));  /*Updated?*/
+
+}
+
+void test_normal_mode_slider_hit_test(void)
+{
+    /* Validate if point 0,0 can click in the slider */
+    lv_point_t point = {
+        .x = 0,
+        .y = 0
+    };
+
+    lv_hit_test_info_t info = {
+        .res = false,
+        .point = &point
+    };
+
+    lv_slider_set_value(sliderNormalMode, 100, LV_ANIM_OFF);
+    lv_event_send(sliderNormalMode, LV_EVENT_HIT_TEST, (void *) &info);
+
+    /* point can click slider */
+    TEST_ASSERT(info.res);
+}
+
+void test_slider_range_event_hit_test(void)
+{
+    /* Validate if point 0,0 can click in the slider */
+    lv_point_t point = {
+        .x = 0,
+        .y = 0
+    };
+
+    lv_hit_test_info_t info = {
+        .res = false,
+        .point = &point
+    };
+    lv_event_send(sliderRangeMode, LV_EVENT_HIT_TEST, (void *) &info);
+
+    /* point can click slider in the left knob */
+    TEST_ASSERT(info.res);
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_snapshot.c

@@ -0,0 +1,47 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#if LV_USE_SNAPSHOT
+
+#include "unity/unity.h"
+
+
+#define NUM_SNAPSHOTS 1
+
+void test_snapshot_should_not_leak_memory(void)
+{
+    uint32_t idx = 0;
+    uint32_t initial_available_memory = 0;
+    uint32_t final_available_memory = 0;
+    lv_mem_monitor_t monitor;
+
+    lv_img_dsc_t * snapshots[NUM_SNAPSHOTS] = {NULL};
+
+    lv_mem_monitor(&monitor);
+    initial_available_memory = monitor.free_size;
+
+    for(idx = 0; idx < NUM_SNAPSHOTS; idx++) {
+        snapshots[idx] = lv_snapshot_take(lv_scr_act(), LV_IMG_CF_TRUE_COLOR_ALPHA);
+        TEST_ASSERT_NOT_NULL(snapshots[idx]);
+    }
+
+    for(idx = 0; idx < NUM_SNAPSHOTS; idx++) {
+        lv_snapshot_free(snapshots[idx]);
+    }
+
+    lv_mem_monitor(&monitor);
+    final_available_memory = monitor.free_size;
+
+    TEST_ASSERT_EQUAL(initial_available_memory, final_available_memory);
+}
+
+#else /*LV_USE_SNAPSHOT*/
+
+void test_snapshot_should_not_leak_memory(void)
+{
+
+}
+
+#endif
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_style.c

@@ -0,0 +1,73 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+#include <unistd.h>
+
+static void obj_set_height_helper(void * obj, int32_t height)
+{
+    lv_obj_set_height((lv_obj_t *)obj, (lv_coord_t)height);
+}
+
+void test_gradient_vertical_misalignment(void)
+{
+    lv_obj_t * obj = lv_obj_create(lv_scr_act());
+    lv_obj_set_style_bg_grad_dir(obj, LV_GRAD_DIR_VER, 0);
+    lv_obj_set_style_bg_grad_color(obj, lv_color_hex(0xff0000), 0);
+    lv_obj_set_style_bg_color(obj, lv_color_hex(0x00ff00), 0);
+
+    lv_obj_set_size(obj, 300, 100);
+
+    lv_refr_now(NULL);
+    lv_obj_set_style_bg_grad_color(obj, lv_color_hex(0xffff00), 0);
+    lv_obj_set_style_bg_color(obj, lv_color_hex(0x00ffff), 0);
+
+    lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_var(&a, obj);
+    lv_anim_set_exec_cb(&a, obj_set_height_helper);
+    lv_anim_set_time(&a, 3000);
+    lv_anim_set_playback_time(&a, 3000);
+    lv_anim_set_repeat_count(&a, 100);
+    lv_anim_set_values(&a, 0, 300);
+    lv_anim_start(&a);
+
+    uint32_t i;
+    for(i = 0; i < 1000; i++) {
+        lv_timer_handler();
+        lv_tick_inc(100);
+        usleep(1000);
+    }
+}
+
+void test_custom_prop_ids(void)
+{
+    uint8_t fake_flag = 0;
+    uint32_t initial_custom_props = lv_style_get_num_custom_props();
+    uint32_t max_props_to_register = 64;
+    for(uint32_t i = 0; i < max_props_to_register; i++) {
+        lv_style_prop_t prop = lv_style_register_prop(fake_flag);
+        /* Should have a higher index than the last built-in prop */
+        TEST_ASSERT_GREATER_THAN(_LV_STYLE_LAST_BUILT_IN_PROP, prop);
+        if(i == 0) {
+            /* Should be equal to the first expected index of a custom prop */
+            TEST_ASSERT_EQUAL(_LV_STYLE_NUM_BUILT_IN_PROPS + initial_custom_props, prop);
+        }
+        /*We should find our flags*/
+        TEST_ASSERT_EQUAL(fake_flag, _lv_style_prop_lookup_flags(prop));
+        if(fake_flag == 0xff)
+            fake_flag = 0;
+        else
+            fake_flag++;
+    }
+    TEST_ASSERT_EQUAL(initial_custom_props + max_props_to_register, lv_style_get_num_custom_props());
+    /*
+     * Check that the resizing algorithm works correctly, given that 64 props
+     * were registered + whatever's built-in. A failure here may just indicate
+     * that LVGL registers more built-in properties now and this needs adjustment.
+     */
+    extern uint32_t _lv_style_custom_prop_flag_lookup_table_size;
+    TEST_ASSERT_EQUAL(_lv_style_custom_prop_flag_lookup_table_size, 96);
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_switch.c

@@ -0,0 +1,140 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+#include "lv_test_helpers.h"
+#include "lv_test_indev.h"
+
+#define SWITCHES_CNT    10
+
+uint8_t value_changed_event_cnt = 0;
+lv_obj_t * scr = NULL;
+lv_obj_t * sw = NULL;
+
+void setUp(void)
+{
+    /* Function run before every test */
+    scr = lv_scr_act();
+    sw = lv_switch_create(scr);
+}
+
+void tearDown(void)
+{
+    /* Function run after every test */
+    value_changed_event_cnt = 0;
+}
+
+static void mouse_click_on_switch(void)
+{
+    lv_test_mouse_click_at(sw->coords.x1, sw->coords.y1);
+}
+
+static void event_handler(lv_event_t * e)
+{
+    lv_event_code_t event = lv_event_get_code(e);
+
+    if(LV_EVENT_VALUE_CHANGED == event) {
+        value_changed_event_cnt++;
+    }
+
+}
+
+void test_switch_should_have_default_state_after_being_created(void)
+{
+    lv_state_t state = lv_obj_get_state(sw);
+    TEST_ASSERT_EQUAL(state, LV_STATE_DEFAULT);
+}
+
+void test_switch_should_not_leak_memory_after_deletion(void)
+{
+    size_t idx = 0;
+    uint32_t initial_available_memory = 0;
+    uint32_t final_available_memory = 0;
+    lv_mem_monitor_t monitor;
+    lv_obj_t * switches[SWITCHES_CNT] = {NULL};
+
+    lv_mem_monitor(&monitor);
+    initial_available_memory = monitor.free_size;
+
+    for(idx = 0; idx < SWITCHES_CNT; idx++) {
+        switches[idx] = lv_switch_create(scr);
+    }
+
+    for(idx = 0; idx < SWITCHES_CNT; idx++) {
+        lv_obj_del(switches[idx]);
+    }
+
+    lv_mem_monitor(&monitor);
+    final_available_memory = monitor.free_size;
+
+    LV_HEAP_CHECK(TEST_ASSERT_LESS_THAN(initial_available_memory, final_available_memory));
+}
+
+void test_switch_animation(void)
+{
+    lv_switch_t * anim_sw = (lv_switch_t *) sw;
+    int32_t initial_anim_state = anim_sw->anim_state;
+
+    /* Trigger animation */
+    mouse_click_on_switch();
+    /* Wait some time  */
+    lv_test_indev_wait(50);
+
+    int32_t checked_anim_state = anim_sw->anim_state;
+    TEST_ASSERT_GREATER_THAN(initial_anim_state, checked_anim_state);
+    TEST_ASSERT(lv_obj_has_state(sw, LV_STATE_CHECKED));
+
+    mouse_click_on_switch();
+    lv_test_indev_wait(50);
+
+    TEST_ASSERT_LESS_THAN(checked_anim_state, anim_sw->anim_state);
+    TEST_ASSERT_FALSE(lv_obj_has_state(sw, LV_STATE_CHECKED));
+}
+
+void test_switch_should_not_have_extra_draw_size_at_creation(void)
+{
+    lv_coord_t extra_size = _lv_obj_get_ext_draw_size(sw);
+
+    TEST_ASSERT_EQUAL(0, extra_size);
+}
+
+void test_switch_should_update_extra_draw_size_after_editing_padding(void)
+{
+    lv_coord_t pad = 6;
+    lv_coord_t actual = 0;
+    lv_coord_t expected = pad + _LV_SWITCH_KNOB_EXT_AREA_CORRECTION;
+
+    static lv_style_t style_knob;
+    lv_style_init(&style_knob);
+    lv_style_set_pad_all(&style_knob, pad);
+
+    lv_obj_remove_style_all(sw);
+    lv_obj_add_style(sw, &style_knob, LV_PART_KNOB);
+    lv_obj_center(sw);
+
+    /* Get extra draw size */
+    actual = _lv_obj_get_ext_draw_size(sw);
+
+    TEST_ASSERT_EQUAL(expected, actual);
+}
+
+/* See #2330 for context */
+void test_switch_should_trigger_value_changed_event_only_once(void)
+{
+    lv_obj_add_event_cb(sw, event_handler, LV_EVENT_ALL, NULL);
+    mouse_click_on_switch();
+
+    TEST_ASSERT_EQUAL(1, value_changed_event_cnt);
+}
+
+/* See #2785 for context */
+void test_switch_should_state_change_when_event_bubbling_is_enabled(void)
+{
+    lv_obj_add_flag(sw, LV_OBJ_FLAG_EVENT_BUBBLE);
+    mouse_click_on_switch();
+
+    TEST_ASSERT(lv_obj_has_state(sw, LV_STATE_CHECKED));
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_table.c

@@ -0,0 +1,247 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+static lv_obj_t * scr = NULL;
+static lv_obj_t * table = NULL;
+
+void setUp(void)
+{
+    scr = lv_scr_act();
+    table = lv_table_create(scr);
+}
+
+void tearDown(void)
+{
+    lv_obj_clean(lv_scr_act());
+}
+
+void test_table_should_return_assigned_cell_value(void)
+{
+    uint16_t row = 0;
+    uint16_t column = 0;
+    const char * value = "LVGL";
+
+    lv_table_set_cell_value(table, row, column, value);
+
+    TEST_ASSERT_EQUAL_STRING(value, lv_table_get_cell_value(table, row, column));
+}
+
+void test_table_should_grow_columns_automatically_when_setting_formatted_cell_value(void)
+{
+    /* Newly created tables have 1 column and 1 row */
+    uint16_t original_column_count = lv_table_get_col_cnt(table);
+    TEST_ASSERT_EQUAL_UINT16(1, original_column_count);
+
+    /* Table currently only has a cell at 0,0 (row, colum) */
+    lv_table_set_cell_value_fmt(table, 0, 1, "LVGL %s", "Rocks!");
+
+    /* Table now should have cells at 0,0 and 0,1, so 2 columns */
+    uint16_t expected_column_count = original_column_count + 1;
+    TEST_ASSERT_EQUAL_UINT16(expected_column_count, lv_table_get_col_cnt(table));
+}
+
+void test_table_should_identify_cell_with_ctrl(void)
+{
+    bool has_ctrl = false;
+
+    has_ctrl = lv_table_has_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+
+    TEST_ASSERT_FALSE(has_ctrl);
+
+    lv_table_add_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    has_ctrl = lv_table_has_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    TEST_ASSERT_TRUE(has_ctrl);
+}
+
+void test_table_should_clear_selected_cell_ctrl(void)
+{
+    bool has_ctrl = false;
+
+    lv_table_add_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    has_ctrl = lv_table_has_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    TEST_ASSERT_TRUE(has_ctrl);
+
+    lv_table_clear_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    has_ctrl = lv_table_has_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    TEST_ASSERT_FALSE(has_ctrl);
+}
+
+void test_table_should_keep_not_selected_cell_ctrl(void)
+{
+    bool has_ctrl = false;
+
+    lv_table_add_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT | LV_TABLE_CELL_CTRL_TEXT_CROP);
+
+    lv_table_clear_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    has_ctrl = lv_table_has_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    TEST_ASSERT_FALSE(has_ctrl);
+
+    has_ctrl = lv_table_has_cell_ctrl(table, 0, 0, LV_TABLE_CELL_CTRL_TEXT_CROP);
+    TEST_ASSERT_TRUE(has_ctrl);
+}
+
+/* We're using a newly created table */
+void test_table_cell_value_should_return_empty_string_when_cell_is_empty(void)
+{
+    TEST_ASSERT_EQUAL_STRING("", lv_table_get_cell_value(table, 0, 0));
+}
+
+void test_table_row_height_should_increase_with_multiline_cell_value(void)
+{
+    lv_table_t * table_ptr = (lv_table_t *) table;
+    const char * singleline_value = "LVGL";
+    const char * multiline_value = "LVGL\nRocks";
+
+    lv_table_set_cell_value(table, 0, 0, singleline_value);
+    lv_coord_t singleline_row_height = table_ptr->row_h[0];
+
+    lv_table_set_cell_value(table, 0, 0, multiline_value);
+    lv_coord_t multiline_row_height = table_ptr->row_h[0];
+
+    TEST_ASSERT_GREATER_THAN(singleline_row_height, multiline_row_height);
+}
+
+void test_table_should_wrap_long_texts(void)
+{
+    lv_table_t * table_ptr = (lv_table_t *) table;
+    const char * long_text = "Testing automatic text wrap with a very long text";
+    const char * small_text = "Hi";
+
+    lv_table_set_col_width(table, 0, 50);
+
+    lv_table_set_cell_value(table, 0, 0, small_text);
+    lv_coord_t row_height = table_ptr->row_h[0];
+
+    lv_table_set_cell_value(table, 0, 0, long_text);
+    lv_coord_t wrapped_row_height = table_ptr->row_h[0];
+
+    /* Row height on cells with wrapped text is bigger than cells with small texts */
+    TEST_ASSERT_GREATER_THAN(row_height, wrapped_row_height);
+}
+
+static void draw_part_event_cb(lv_event_t * e)
+{
+    lv_obj_t * obj = lv_event_get_target(e);
+    lv_obj_draw_part_dsc_t * dsc = lv_event_get_param(e);
+    /*If the cells are drawn...*/
+    if(dsc->part == LV_PART_ITEMS) {
+        uint32_t row = dsc->id /  lv_table_get_col_cnt(obj);
+        uint32_t col = dsc->id - row * lv_table_get_col_cnt(obj);
+
+        /*Make the texts in the first cell center aligned*/
+        if(row == 0) {
+            dsc->label_dsc->align = LV_TEXT_ALIGN_CENTER;
+            dsc->rect_dsc->bg_color = lv_color_mix(lv_palette_main(LV_PALETTE_BLUE), dsc->rect_dsc->bg_color, LV_OPA_40);
+            dsc->rect_dsc->bg_opa = LV_OPA_COVER;
+        }
+        /*In the first column align the texts to the right*/
+        else if(col == 0) {
+            dsc->label_dsc->align = LV_TEXT_ALIGN_RIGHT;
+        }
+
+        /*Make every 2nd row grayish*/
+        if(row != 0 && (row % 2 == 0)) {
+            dsc->rect_dsc->bg_color = lv_color_mix(lv_palette_main(LV_PALETTE_RED), dsc->rect_dsc->bg_color, LV_OPA_30);
+            dsc->rect_dsc->bg_opa = LV_OPA_COVER;
+        }
+    }
+}
+
+void test_table_rendering(void)
+{
+    lv_obj_center(table);
+    lv_obj_add_event_cb(table, draw_part_event_cb, LV_EVENT_DRAW_PART_BEGIN, NULL);
+    lv_obj_set_style_border_side(table, LV_BORDER_SIDE_FULL, LV_PART_ITEMS);
+    lv_obj_set_style_pad_all(table, 10, LV_PART_ITEMS);
+    lv_obj_set_style_border_width(table, 5, LV_PART_ITEMS);
+    lv_table_set_col_cnt(table, 5);
+    lv_table_set_row_cnt(table, 5);
+    lv_table_set_col_width(table, 1, 60);
+    lv_table_set_col_width(table, 2, 100);
+
+    lv_table_add_cell_ctrl(table, 0, 1, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    lv_table_set_cell_value(table, 0, 1, "2 cells are merged");
+
+    lv_table_add_cell_ctrl(table, 1, 0, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    lv_table_add_cell_ctrl(table, 1, 1, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    lv_table_add_cell_ctrl(table, 1, 2, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    lv_table_add_cell_ctrl(table, 1, 3, LV_TABLE_CELL_CTRL_MERGE_RIGHT);
+    lv_table_set_cell_value(table, 1, 0, "5 cells are merged");
+
+    uint32_t i;
+    for(i = 0; i < 5; i++) {
+        lv_table_set_cell_value_fmt(table, 3, i, "%d", i);
+    }
+
+    lv_table_set_cell_value_fmt(table, 2, 3, "Multi\nline text");
+    lv_table_set_cell_value_fmt(table, 2, 4, "Very long text wrapped automatically");
+
+    lv_table_add_cell_ctrl(table, 4, 3, LV_TABLE_CELL_CTRL_TEXT_CROP);
+    lv_table_set_cell_value_fmt(table, 4, 3, "crop crop crop crop crop crop crop crop ");
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("table_1.png");
+}
+
+/* See #3120 for context */
+void test_table_should_reduce_cells(void)
+{
+    const uint16_t initial_col_num = 8;
+    const uint16_t initial_row_num = 1;
+    const uint16_t final_col_num = 4;
+    const uint16_t final_row_num = 1;
+
+    lv_obj_center(table);
+
+    lv_table_set_col_cnt(table, initial_col_num);
+    lv_table_set_row_cnt(table, initial_row_num);
+
+    uint32_t row_idx, col_idx;
+    for(row_idx = 0; row_idx < initial_row_num; row_idx++) {
+        for(col_idx = 0; col_idx < initial_col_num; col_idx++) {
+            lv_table_set_cell_value(table, row_idx, col_idx, "00");
+        }
+    }
+
+    lv_table_set_col_cnt(table, final_col_num);
+    lv_table_set_row_cnt(table, final_row_num);
+
+    for(row_idx = 0; row_idx < final_row_num; row_idx++) {
+        for(col_idx = 0; col_idx < final_col_num; col_idx++) {
+            lv_table_set_cell_value(table, row_idx, col_idx, "00");
+        }
+    }
+}
+
+/* See #3120 for context */
+void test_table_should_reduce_cells_with_more_than_one_row(void)
+{
+    const uint16_t initial_col_num = 8;
+    const uint16_t initial_row_num = 2;
+    const uint16_t final_col_num = 4;
+    const uint16_t final_row_num = 1;
+
+    lv_obj_center(table);
+
+    lv_table_set_col_cnt(table, initial_col_num);
+    lv_table_set_row_cnt(table, initial_row_num);
+
+    uint32_t row_idx, col_idx;
+    for(row_idx = 0; row_idx < initial_row_num; row_idx++) {
+        for(col_idx = 0; col_idx < initial_col_num; col_idx++) {
+            lv_table_set_cell_value(table, row_idx, col_idx, "00");
+        }
+    }
+
+    lv_table_set_col_cnt(table, final_col_num);
+    lv_table_set_row_cnt(table, final_row_num);
+
+    for(row_idx = 0; row_idx < final_row_num; row_idx++) {
+        for(col_idx = 0; col_idx < final_col_num; col_idx++) {
+            lv_table_set_cell_value(table, row_idx, col_idx, "00");
+        }
+    }
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_textarea.c

@@ -0,0 +1,107 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+static lv_obj_t * active_screen = NULL;
+static lv_obj_t * textarea = NULL;
+
+static const char * textarea_default_text = "";
+
+void setUp(void)
+{
+    active_screen = lv_scr_act();
+    textarea = lv_textarea_create(active_screen);
+}
+
+void tearDown(void)
+{
+    /* Function run after every test */
+}
+
+void test_textarea_should_have_valid_documented_defualt_values(void)
+{
+    TEST_ASSERT(lv_textarea_get_cursor_click_pos(textarea));
+    TEST_ASSERT_EQUAL(0U, lv_textarea_get_one_line(textarea));
+    /* No placeholder text should be set on widget creation */
+    TEST_ASSERT_EQUAL_STRING(textarea_default_text, lv_textarea_get_placeholder_text(textarea));
+    TEST_ASSERT_EQUAL_STRING(textarea_default_text, lv_textarea_get_text(textarea));
+}
+
+/* When in password mode the lv_textarea_get_text function returns
+ * the actual text, not the bullet characters. */
+void test_textarea_should_return_actual_text_when_password_mode_is_enabled(void)
+{
+    const char * text = "Hello LVGL!";
+
+    lv_textarea_add_text(textarea, text);
+    lv_textarea_set_password_mode(textarea, true);
+
+    TEST_ASSERT_TRUE(lv_textarea_get_password_mode(textarea));
+    TEST_ASSERT_EQUAL_STRING(text, lv_textarea_get_text(textarea));
+}
+
+void test_textarea_should_update_label_style_with_one_line_enabled(void)
+{
+    lv_textarea_t * txt_ptr = (lv_textarea_t *) textarea;
+
+    lv_textarea_add_text(textarea, "Hi");
+    lv_textarea_set_one_line(textarea, true);
+
+    lv_coord_t left_padding = lv_obj_get_style_pad_left(txt_ptr->label, LV_PART_MAIN);
+    lv_coord_t right_padding = lv_obj_get_style_pad_right(txt_ptr->label, LV_PART_MAIN);
+    lv_coord_t line_width = lv_obj_get_width(txt_ptr->label);
+    lv_coord_t expected_size = left_padding + right_padding + line_width;
+
+    TEST_ASSERT(lv_textarea_get_one_line(textarea));
+    TEST_ASSERT_EQUAL_UINT16(expected_size, lv_obj_get_width(txt_ptr->label));
+    TEST_ASSERT_EQUAL_UINT16(lv_pct(100), lv_obj_get_style_min_width(txt_ptr->label, LV_PART_MAIN));
+}
+
+void test_textarea_cursor_click_pos_field_update(void)
+{
+    lv_textarea_set_cursor_click_pos(textarea, false);
+
+    TEST_ASSERT_FALSE(lv_textarea_get_cursor_click_pos(textarea));
+}
+
+void test_textarea_should_update_placeholder_text(void)
+{
+    const char * new_placeholder = "LVGL Rocks!!!!!";
+    const char * text = "Hello LVGL!";
+
+    /* Allocating memory for placeholder text */
+    lv_textarea_set_placeholder_text(textarea, text);
+    TEST_ASSERT_EQUAL_STRING(text, lv_textarea_get_placeholder_text(textarea));
+
+    /* Reallocating memory for the new placeholder text */
+    lv_textarea_set_placeholder_text(textarea, new_placeholder);
+    TEST_ASSERT_EQUAL_STRING(new_placeholder, lv_textarea_get_placeholder_text(textarea));
+
+    /* Freeing allocated memory for placeholder text */
+    lv_textarea_set_placeholder_text(textarea, "");
+    TEST_ASSERT_EQUAL_STRING("", lv_textarea_get_placeholder_text(textarea));
+}
+
+void test_textarea_should_keep_only_accepted_chars(void)
+{
+    const char * accepted_list = "abcd";
+
+    lv_textarea_set_accepted_chars(textarea, accepted_list);
+    lv_textarea_set_text(textarea, "abcde");
+
+    TEST_ASSERT_EQUAL_STRING(accepted_list, lv_textarea_get_text(textarea));
+}
+
+void test_textarea_in_one_line_mode_should_ignore_line_break_characters(void)
+{
+    lv_textarea_set_one_line(textarea, true);
+
+    lv_textarea_add_char(textarea, '\n');
+    TEST_ASSERT_EQUAL_STRING(textarea_default_text, lv_textarea_get_text(textarea));
+
+    lv_textarea_add_char(textarea, '\r');
+    TEST_ASSERT_EQUAL_STRING(textarea_default_text, lv_textarea_get_text(textarea));
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_cases/test_txt.c

@@ -0,0 +1,207 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+static const char color_cmd = LV_TXT_COLOR_CMD[0];
+
+void test_txt_should_identify_valid_start_of_command(void)
+{
+    uint32_t character = color_cmd;
+    lv_text_cmd_state_t state = LV_TEXT_CMD_STATE_WAIT;
+
+    bool is_cmd = _lv_txt_is_cmd(&state, character);
+
+    TEST_ASSERT_TRUE(is_cmd);
+    TEST_ASSERT_EQUAL_UINT8(state, LV_TEXT_CMD_STATE_PAR);
+}
+
+void test_txt_should_identify_invalid_start_of_command(void)
+{
+    uint32_t character = '$';
+    lv_text_cmd_state_t state = LV_TEXT_CMD_STATE_WAIT;
+
+    bool is_cmd = _lv_txt_is_cmd(&state, character);
+
+    TEST_ASSERT_FALSE(is_cmd);
+    TEST_ASSERT_EQUAL_UINT8(state, LV_TEXT_CMD_STATE_WAIT);
+}
+
+void test_txt_should_identify_scaped_command_in_parameter(void)
+{
+    uint32_t character = color_cmd;
+    lv_text_cmd_state_t state = LV_TEXT_CMD_STATE_PAR;
+
+    bool is_cmd = _lv_txt_is_cmd(&state, character);
+
+    TEST_ASSERT_FALSE(is_cmd);
+    TEST_ASSERT_EQUAL_UINT8(state, LV_TEXT_CMD_STATE_WAIT);
+}
+
+void test_txt_should_skip_color_parameter_in_parameter(void)
+{
+    uint32_t character = '$';
+    lv_text_cmd_state_t state = LV_TEXT_CMD_STATE_PAR;
+
+    bool is_cmd = _lv_txt_is_cmd(&state, character);
+
+    TEST_ASSERT_TRUE(is_cmd);
+    TEST_ASSERT_EQUAL_UINT8(state, LV_TEXT_CMD_STATE_PAR);
+}
+
+void test_txt_should_reset_state_when_receiving_color_cmd_while_processing_commands(void)
+{
+    uint32_t character = color_cmd;
+    lv_text_cmd_state_t state = LV_TEXT_CMD_STATE_IN;
+
+    bool is_cmd = _lv_txt_is_cmd(&state, character);
+
+    TEST_ASSERT_TRUE(is_cmd);
+    TEST_ASSERT_EQUAL_UINT8(state, LV_TEXT_CMD_STATE_WAIT);
+}
+
+void test_txt_should_identify_space_after_parameter(void)
+{
+    uint32_t character = ' ';
+    lv_text_cmd_state_t state = LV_TEXT_CMD_STATE_PAR;
+
+    bool is_cmd = _lv_txt_is_cmd(&state, character);
+
+    TEST_ASSERT_TRUE(is_cmd);
+    TEST_ASSERT_EQUAL_UINT8(state, LV_TEXT_CMD_STATE_IN);
+}
+
+void test_txt_should_insert_string_into_another(void)
+{
+    const char * msg = "Hello ";
+    const char * suffix = "World";
+    char target[20] = {0};
+    size_t msg_len = strlen(msg);
+
+    strcpy(target, msg);
+
+    _lv_txt_ins(target, msg_len, suffix);
+
+    TEST_ASSERT_EQUAL_STRING("Hello World", target);
+}
+
+void test_txt_should_handle_null_pointers_when_inserting(void)
+{
+    const char * msg = "Hello ";
+    char target[20] = {0};
+    size_t msg_len = strlen(msg);
+
+    strcpy(target, msg);
+
+    _lv_txt_ins(target, msg_len, NULL);
+
+    TEST_ASSERT_EQUAL_STRING("Hello ", target);
+}
+
+void test_txt_cut_should_handle_null_pointer_to_txt(void)
+{
+    _lv_txt_cut(NULL, 0, 6);
+}
+
+void test_txt_cut_happy_path(void)
+{
+    char msg[] = "Hello World";
+
+    _lv_txt_cut(msg, 0, 6);
+
+    TEST_ASSERT_EQUAL_STRING("World", msg);
+}
+
+void test_txt_cut_should_handle_len_longer_than_string_length(void)
+{
+    char msg[] = "Hello World";
+
+    _lv_txt_cut(msg, 0, 30);
+
+    TEST_ASSERT_EQUAL_UINT8(msg[0], 0x00);
+}
+
+void test_txt_get_encoded_next_should_decode_valid_ascii(void)
+{
+    char msg[] = "Hello World!";
+    uint32_t result = 0;
+
+    result = _lv_txt_encoded_next(msg, NULL);
+
+    TEST_ASSERT_EQUAL_UINT32((uint32_t) 'H', result);
+}
+
+void test_txt_get_encoded_next_detect_valid_2_byte_input(void)
+{
+    char msg[] = "\xc3\xb1";
+    uint32_t result = 0;
+
+    result = _lv_txt_encoded_next(msg, NULL);
+
+    TEST_ASSERT_EQUAL_UINT32(241, result);
+}
+
+void test_txt_get_encoded_next_detect_invalid_2_byte_input(void)
+{
+    char msg[] = "\xc3\x28";
+    uint32_t result = 0;
+
+    result = _lv_txt_encoded_next(msg, NULL);
+
+    TEST_ASSERT_EQUAL_UINT32(0, result);
+}
+
+void test_txt_get_encoded_next_detect_valid_3_byte_input(void)
+{
+    char msg[] = "\xe2\x82\xa1";
+    uint32_t result = 0;
+
+    result = _lv_txt_encoded_next(msg, NULL);
+
+    TEST_ASSERT_EQUAL_UINT32(8353, result);
+}
+
+void test_txt_get_encoded_next_detect_invalid_3_byte_input(void)
+{
+    char msg[] = "\xe2\x28\xa1";
+    uint32_t result = 0;
+
+    result = _lv_txt_encoded_next(msg, NULL);
+
+    TEST_ASSERT_EQUAL_UINT32(0, result);
+}
+
+void test_txt_get_encoded_next_detect_valid_4_byte_input(void)
+{
+    char msg[] = "\xf0\x90\x8c\xbc";
+    uint32_t result = 0;
+
+    result = _lv_txt_encoded_next(msg, NULL);
+
+    TEST_ASSERT_EQUAL_UINT32(66364, result);
+}
+
+void test_txt_get_encoded_next_detect_invalid_4_byte_input(void)
+{
+    char msg[] = "\xf0\x28\x8c\x28";
+    uint32_t result = 0;
+
+    result = _lv_txt_encoded_next(msg, NULL);
+
+    TEST_ASSERT_EQUAL_UINT32(0, result);
+}
+
+/* See #2615 for more information */
+void test_txt_next_line_should_handle_empty_string(void)
+{
+    const lv_font_t * font_ptr = NULL;
+    lv_coord_t letter_space = 0;
+    lv_coord_t max_width = 0;
+    lv_text_flag_t flag = LV_TEXT_FLAG_NONE;
+
+    uint32_t next_line = _lv_txt_get_next_line("", font_ptr, letter_space, max_width, NULL, flag);
+
+    TEST_ASSERT_EQUAL_UINT32(0, next_line);
+}
+
+#endif

LVGL.Simulator/lvgl/tests/src/test_fonts/font_3.c

@@ -0,0 +1,948 @@
+#if LV_BUILD_TEST
+#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*/
+#endif