Implementing missing formats for font loading.

tests/Makefile

@@ -31,6 +31,9 @@ CSRCS += lv_test_core/lv_test_core.c
 CSRCS += lv_test_core/lv_test_obj.c
 CSRCS += lv_test_core/lv_test_style.c
 CSRCS += lv_test_core/lv_test_font_loader.c
+CSRCS += lv_test_fonts/font_1.c
+CSRCS += lv_test_fonts/font_2.c
+CSRCS += lv_test_fonts/font_3.c
 
 OBJEXT ?= .o
 

tests/lv_test_assert.c

@@ -143,6 +143,17 @@ void lv_test_assert_str_eq(const char * s_ref, const char * s_act, const char *
     }
 }
 
+
+void lv_test_assert_array_eq(const uint8_t *p_ref, const uint8_t *p_act, int32_t size, const char * s)
+{
+    if(memcmp(p_ref, p_act, size) != 0) {
+        lv_test_error("   FAIL: %s. (Expected: all %d bytes should be equal)", s, size);
+    } else {
+        lv_test_print("   PASS: %s. (Expected: all %d bytes should be equal)", s, size);
+    }
+}
+
+
 void lv_test_assert_ptr_eq(const void * p_ref, const void * p_act, const char * s)
 {
     if(p_ref != p_act) {

tests/lv_test_assert.h

@@ -40,6 +40,7 @@ void lv_test_assert_str_eq(const char * str1, const char * str2, const char * s)
 void lv_test_assert_ptr_eq(const void * p_ref, const void * p_act, const char * s);
 void lv_test_assert_color_eq(lv_color_t c_ref, lv_color_t c_act, const char * s);
 void lv_test_assert_img_eq(const char * ref_img_fn, const char * s);
+void lv_test_assert_array_eq(const uint8_t *p_ref, const uint8_t *p_act, int32_t size, const char * s);
 
 /**********************
  *      MACROS

tests/lv_test_core/lv_test_font_loader.c

@@ -42,15 +42,28 @@ static int compare_fonts(lv_font_t * f1, lv_font_t * f2);
  *   GLOBAL FUNCTIONS
  **********************/
 
+extern lv_font_t font_1;
+extern lv_font_t font_2;
+extern lv_font_t font_3;
+
 void lv_test_font_loader(void)
 {
-    lv_font_t * montserrat_12_bin = lv_font_load("f:lv_font_montserrat_12.bin");
-    compare_fonts(&lv_font_montserrat_12, montserrat_12_bin);
+    lv_font_t * font_1_bin = lv_font_load("f:font_1.fnt");
+    lv_font_t * font_2_bin = lv_font_load("f:font_2.fnt");
+    lv_font_t * font_3_bin = lv_font_load("f:font_3.fnt");
+
+    compare_fonts(&font_1, font_1_bin);
+    compare_fonts(&font_2, font_2_bin);
+    compare_fonts(&font_3, font_3_bin);
+
+    lv_font_free(font_1_bin);
+    lv_font_free(font_2_bin);
+    lv_font_free(font_3_bin);
 }
 
 static int compare_fonts(lv_font_t * f1, lv_font_t * f2)
 {
-    lv_test_assert_true(f1 != NULL && f2 != NULL, "error loading font");
+    lv_test_assert_true(f1 != NULL && f2 != NULL, "font not null");
 
     lv_test_assert_ptr_eq(f1->get_glyph_dsc, f2->get_glyph_dsc, "glyph_dsc");
     lv_test_assert_ptr_eq(f1->get_glyph_bitmap, f2->get_glyph_bitmap, "glyph_bitmap");
@@ -83,9 +96,11 @@ static int compare_fonts(lv_font_t * f1, lv_font_t * f2)
         if(cmaps1->unicode_list != NULL && cmaps2->unicode_list != NULL) {
             lv_test_assert_true(cmaps1->unicode_list && cmaps2->unicode_list, "unicode_list");
 
-            for(int k = 0; k < cmaps1->list_length; ++k) {
-                lv_test_assert_int_eq(cmaps1->unicode_list[k], cmaps2->unicode_list[k], "unicode_list");
-            }
+            lv_test_assert_array_eq(
+                    (uint8_t *) cmaps1->unicode_list,
+                    (uint8_t *) cmaps2->unicode_list,
+                    sizeof(uint16_t) * cmaps1->list_length,
+                    "unicode_list");
             total_glyphs += cmaps1->list_length;
         }
         else {
@@ -97,9 +112,7 @@ static int compare_fonts(lv_font_t * f1, lv_font_t * f2)
             uint8_t * ids1 = (uint8_t *) cmaps1->glyph_id_ofs_list;
             uint8_t * ids2 = (uint8_t *) cmaps2->glyph_id_ofs_list;
 
-            for(int j = 0; j < cmaps1->range_length; j++) {
-                lv_test_assert_int_eq(ids1[j], ids2[j], "glyph_id_ofs_list");
-            }
+            lv_test_assert_array_eq(ids1, ids2, cmaps1->list_length, "glyph_id_ofs_list");
         }
         else {
             lv_test_assert_ptr_eq(cmaps1->glyph_id_ofs_list, cmaps2->glyph_id_ofs_list, "glyph_id_ofs_list");
@@ -107,37 +120,74 @@ static int compare_fonts(lv_font_t * f1, lv_font_t * f2)
     }
 
     // kern_dsc
-    lv_font_fmt_txt_kern_classes_t * kern1 = (lv_font_fmt_txt_kern_classes_t *) dsc1->kern_dsc;
-    lv_font_fmt_txt_kern_classes_t * kern2 = (lv_font_fmt_txt_kern_classes_t *) dsc2->kern_dsc;
-    if (kern1 != NULL && kern2 != NULL) {
-        lv_test_assert_int_eq(kern1->right_class_cnt, kern2->right_class_cnt, "right_class_cnt");
-        lv_test_assert_int_eq(kern1->left_class_cnt, kern2->left_class_cnt, "left_class_cnt");
+    if (dsc1->kern_classes == 1 && dsc2->kern_classes == 1) {
+        lv_font_fmt_txt_kern_classes_t * kern1 = (lv_font_fmt_txt_kern_classes_t *) dsc1->kern_dsc;
+        lv_font_fmt_txt_kern_classes_t * kern2 = (lv_font_fmt_txt_kern_classes_t *) dsc2->kern_dsc;
+        if (kern1 != NULL && kern2 != NULL) {
+            lv_test_assert_int_eq(kern1->right_class_cnt, kern2->right_class_cnt, "right_class_cnt");
+            lv_test_assert_int_eq(kern1->left_class_cnt, kern2->left_class_cnt, "left_class_cnt");
 
-        for(int i = 0; i < kern1->left_class_cnt; ++i) {
-            lv_test_assert_int_eq(kern1->left_class_mapping[i],
-                    kern2->left_class_mapping[i], "left_class_mapping");
-        }
-        for(int i = 0; i < kern1->right_class_cnt; ++i) {
-            lv_test_assert_int_eq(kern1->right_class_mapping[i],
-                    kern2->right_class_mapping[i], "right_class_mapping");
-        }
+            lv_test_assert_array_eq(
+                    (uint8_t *) kern1->left_class_mapping,
+                    (uint8_t *) kern2->left_class_mapping,
+                    kern1->left_class_cnt,
+                    "left_class_mapping");
 
-        for(int i = 0; i < kern1->right_class_cnt * kern1->left_class_cnt; ++i) {
-            lv_test_assert_int_eq(kern1->class_pair_values[i],
-                    kern2->class_pair_values[i], "class_pair_values");
+            lv_test_assert_array_eq(
+                    (uint8_t *) kern1->right_class_mapping,
+                    (uint8_t *) kern2->right_class_mapping,
+                    kern1->right_class_cnt,
+                    "right_class_mapping");
+
+            lv_test_assert_array_eq(
+                    (uint8_t *) kern1->class_pair_values,
+                    (uint8_t *) kern2->class_pair_values,
+                    kern1->right_class_cnt * kern1->left_class_cnt,
+                    "class_pair_values");
+        }
+        else {
+            lv_test_assert_ptr_eq(kern1, kern2, "kern");
         }
     }
-    else {
-        lv_test_assert_ptr_eq(kern1, kern2, "kern");
-    }
+    else if (dsc1->kern_classes == 0 && dsc2->kern_classes == 0) {
+        lv_font_fmt_txt_kern_pair_t * kern1 = (lv_font_fmt_txt_kern_pair_t *) dsc1->kern_dsc;
+        lv_font_fmt_txt_kern_pair_t * kern2 = (lv_font_fmt_txt_kern_pair_t *) dsc2->kern_dsc;
+        if (kern1 != NULL && kern2 != NULL) {
+            lv_test_assert_int_eq(kern1->glyph_ids_size, kern2->glyph_ids_size, "glyph_ids_size");
+            lv_test_assert_int_eq(kern1->pair_cnt, kern2->pair_cnt, "pair_cnt");
 
-    // TODO: glyph_bitmap
+            int ids_size;
+
+            if (kern1->glyph_ids_size == 0) {
+                ids_size = sizeof(int8_t) * 2 * kern1->pair_cnt;
+            }
+            else {
+                ids_size = sizeof(int16_t) * 2 * kern1->pair_cnt;
+            }
+
+            lv_test_assert_array_eq(kern1->glyph_ids, kern2->glyph_ids, ids_size, "glyph_ids");
+            lv_test_assert_array_eq(
+                    (uint8_t * ) kern1->values,
+                    (uint8_t * ) kern2->values,
+                    kern1->pair_cnt,
+                    "glyph_values");
+        }
+    }
 
     lv_font_fmt_txt_glyph_dsc_t * glyph_dsc1 = (lv_font_fmt_txt_glyph_dsc_t *) dsc1->glyph_dsc;
     lv_font_fmt_txt_glyph_dsc_t * glyph_dsc2 = (lv_font_fmt_txt_glyph_dsc_t *) dsc2->glyph_dsc;
 
     for(int i = 0; i < total_glyphs; ++i) {
-        //lv_test_assert_int_eq(glyph_dsc1[i].bitmap_index, glyph_dsc2[i].bitmap_index, "bitmap_index");
+        if (i < total_glyphs - 1) {
+            int size1 = glyph_dsc1[i+1].bitmap_index - glyph_dsc1[i].bitmap_index;
+
+            if (size1 > 0) {
+                lv_test_assert_array_eq(
+                        dsc1->glyph_bitmap + glyph_dsc1[i].bitmap_index,
+                        dsc2->glyph_bitmap + glyph_dsc2[i].bitmap_index,
+                        size1 - 1, "glyph_bitmap");
+            }
+        }
         lv_test_assert_int_eq(glyph_dsc1[i].adv_w, glyph_dsc2[i].adv_w, "adv_w");
         lv_test_assert_int_eq(glyph_dsc1[i].box_w, glyph_dsc2[i].box_w, "box_w");
         lv_test_assert_int_eq(glyph_dsc1[i].box_h, glyph_dsc2[i].box_h, "box_h");