/* * Copyright © 2016 Google, Inc. * Copyright © 2018 Ebrahim Byagowi * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Google Author(s): Sascha Brawer */ #include "hb-test.h" #include /* Unit tests for hb-ot-color.h */ /* Test font with the following CPAL v0 table, as TTX and manual disassembly: 0 | 0000 # version=0 2 | 0002 # numPaletteEntries=2 4 | 0002 # numPalettes=2 6 | 0004 # numColorRecords=4 8 | 00000010 # offsetToFirstColorRecord=16 12 | 0000 0002 # colorRecordIndex=[0, 2] 16 | 000000ff ffcc66ff # colorRecord #0, #1 (BGRA) 24 | 000000ff 000080ff # colorRecord #2, #3 (BGRA) */ static hb_face_t *cpal_v0 = NULL; /* Test font with the following CPAL v1 table, as TTX and manual disassembly: 0 | 0001 # version=1 2 | 0002 # numPaletteEntries=2 4 | 0003 # numPalettes=3 6 | 0006 # numColorRecords=6 8 | 0000001e # offsetToFirstColorRecord=30 12 | 0000 0002 0004 # colorRecordIndex=[0, 2, 4] 18 | 00000036 # offsetToPaletteTypeArray=54 22 | 00000042 # offsetToPaletteLabelArray=66 26 | 00000048 # offsetToPaletteEntryLabelArray=72 30 | 000000ff ffcc66ff 000000ff # colorRecord #0, #1, #2 (BGRA) 42 | 66ccffff 000000ff 000080ff # colorRecord #3, #4, #5 (BGRA) 54 | 00000002 00000001 00000000 # paletteFlags=[2, 1, 0] 66 | 0101 ffff 0102 # paletteName=[257, 0xffff, 258] 72 | ffff 0100 # paletteEntryLabel=[0xffff, 256] */ static hb_face_t *cpal_v1 = NULL; static hb_face_t *cpal = NULL; static hb_face_t *cbdt = NULL; static hb_face_t *sbix = NULL; static hb_face_t *svg = NULL; static hb_face_t *empty = NULL; static hb_face_t *colr_v1 = NULL; static hb_face_t *colr_v1_2 = NULL; #define assert_color_rgba(colors, i, r, g, b, a) G_STMT_START { \ const hb_color_t *_colors = (colors); \ const size_t _i = (i); \ const uint8_t red = (r), green = (g), blue = (b), alpha = (a); \ if (hb_color_get_red (_colors[_i]) != red) { \ g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ "colors[" #i "]", _colors[_i], "==", red, 'x'); \ } \ if (hb_color_get_green (_colors[_i]) != green) { \ g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ "colors[" #i "]", _colors[_i], "==", green, 'x'); \ } \ if (hb_color_get_blue (_colors[_i]) != blue) { \ g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ "colors[" #i "]", colors[_i], "==", blue, 'x'); \ } \ if (hb_color_get_alpha (_colors[_i]) != alpha) { \ g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ "colors[" #i "]", _colors[_i], "==", alpha, 'x'); \ } \ } G_STMT_END static void test_hb_ot_color_palette_get_count (void) { g_assert_cmpint (hb_ot_color_palette_get_count (hb_face_get_empty()), ==, 0); g_assert_cmpint (hb_ot_color_palette_get_count (cpal_v0), ==, 2); g_assert_cmpint (hb_ot_color_palette_get_count (cpal_v1), ==, 3); } static void test_hb_ot_color_palette_get_name_id_empty (void) { /* numPalettes=0, so all calls are for out-of-bounds palette indices */ g_assert_cmpint (hb_ot_color_palette_get_name_id (hb_face_get_empty(), 0), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpint (hb_ot_color_palette_get_name_id (hb_face_get_empty(), 1), ==, HB_OT_NAME_ID_INVALID); } static void test_hb_ot_color_palette_get_name_id_v0 (void) { g_assert_cmpint (hb_ot_color_palette_get_name_id (cpal_v0, 0), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpint (hb_ot_color_palette_get_name_id (cpal_v0, 1), ==, HB_OT_NAME_ID_INVALID); /* numPalettes=2, so palette #2 is out of bounds */ g_assert_cmpint (hb_ot_color_palette_get_name_id (cpal_v0, 2), ==, HB_OT_NAME_ID_INVALID); } static void test_hb_ot_color_palette_get_name_id_v1 (void) { g_assert_cmpint (hb_ot_color_palette_get_name_id (cpal_v1, 0), ==, 257); g_assert_cmpint (hb_ot_color_palette_get_name_id (cpal_v1, 1), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpint (hb_ot_color_palette_get_name_id (cpal_v1, 2), ==, 258); /* numPalettes=3, so palette #3 is out of bounds */ g_assert_cmpint (hb_ot_color_palette_get_name_id (cpal_v1, 3), ==, HB_OT_NAME_ID_INVALID); } static void test_hb_ot_color_palette_get_flags_empty (void) { /* numPalettes=0, so all calls are for out-of-bounds palette indices */ g_assert_cmpint (hb_ot_color_palette_get_flags (hb_face_get_empty(), 0), ==, HB_OT_COLOR_PALETTE_FLAG_DEFAULT); g_assert_cmpint (hb_ot_color_palette_get_flags (hb_face_get_empty(), 1), ==, HB_OT_COLOR_PALETTE_FLAG_DEFAULT); } static void test_hb_ot_color_palette_get_flags_v0 (void) { g_assert_cmpint (hb_ot_color_palette_get_flags (cpal_v0, 0), ==, HB_OT_COLOR_PALETTE_FLAG_DEFAULT); g_assert_cmpint (hb_ot_color_palette_get_flags (cpal_v0, 1), ==, HB_OT_COLOR_PALETTE_FLAG_DEFAULT); /* numPalettes=2, so palette #2 is out of bounds */ g_assert_cmpint (hb_ot_color_palette_get_flags (cpal_v0, 2), ==, HB_OT_COLOR_PALETTE_FLAG_DEFAULT); } static void test_hb_ot_color_palette_get_flags_v1 (void) { g_assert_cmpint (hb_ot_color_palette_get_flags (cpal_v1, 0), ==, HB_OT_COLOR_PALETTE_FLAG_USABLE_WITH_DARK_BACKGROUND); g_assert_cmpint (hb_ot_color_palette_get_flags (cpal_v1, 1), ==, HB_OT_COLOR_PALETTE_FLAG_USABLE_WITH_LIGHT_BACKGROUND); g_assert_cmpint (hb_ot_color_palette_get_flags (cpal_v0, 2), ==, HB_OT_COLOR_PALETTE_FLAG_DEFAULT); /* numPalettes=3, so palette #3 is out of bounds */ g_assert_cmpint (hb_ot_color_palette_get_flags (cpal_v0, 3), ==, HB_OT_COLOR_PALETTE_FLAG_DEFAULT); } static void test_hb_ot_color_palette_get_colors_empty (void) { g_assert_cmpint (hb_ot_color_palette_get_colors (empty, 0, 0, NULL, NULL), ==, 0); } static void test_hb_ot_color_palette_get_colors_v0 (void) { unsigned int num_colors = hb_ot_color_palette_get_colors (cpal_v0, 0, 0, NULL, NULL); hb_color_t *colors = (hb_color_t*) malloc (num_colors * sizeof (hb_color_t)); size_t colors_size = num_colors * sizeof(*colors); g_assert_cmpint (num_colors, ==, 2); /* Palette #0, start_index=0 */ g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v0, 0, 0, &num_colors, colors), ==, 2); g_assert_cmpint (num_colors, ==, 2); assert_color_rgba (colors, 0, 0x00, 0x00, 0x00, 0xff); assert_color_rgba (colors, 1, 0x66, 0xcc, 0xff, 0xff); /* Palette #1, start_index=0 */ g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v0, 1, 0, &num_colors, colors), ==, 2); g_assert_cmpint (num_colors, ==, 2); assert_color_rgba (colors, 0, 0x00, 0x00, 0x00, 0xff); assert_color_rgba (colors, 1, 0x80, 0x00, 0x00, 0xff); /* Palette #2 (there are only #0 and #1 in the font, so this is out of bounds) */ g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v0, 2, 0, &num_colors, colors), ==, 0); /* Palette #0, start_index=1 */ memset(colors, 0x33, colors_size); num_colors = 2; g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v0, 0, 1, &num_colors, colors), ==, 2); g_assert_cmpint (num_colors, ==, 1); assert_color_rgba (colors, 0, 0x66, 0xcc, 0xff, 0xff); assert_color_rgba (colors, 1, 0x33, 0x33, 0x33, 0x33); /* untouched */ /* Palette #0, start_index=0, pretend that we have only allocated space for 1 color */ memset(colors, 0x44, colors_size); num_colors = 1; g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v0, 0, 0, &num_colors, colors), ==, 2); g_assert_cmpint (num_colors, ==, 1); assert_color_rgba (colors, 0, 0x00, 0x00, 0x00, 0xff); assert_color_rgba (colors, 1, 0x44, 0x44, 0x44, 0x44); /* untouched */ /* start_index > numPaletteEntries */ memset (colors, 0x44, colors_size); num_colors = 2; g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v0, 0, 9876, &num_colors, colors), ==, 2); g_assert_cmpint (num_colors, ==, 0); assert_color_rgba (colors, 0, 0x44, 0x44, 0x44, 0x44); /* untouched */ assert_color_rgba (colors, 1, 0x44, 0x44, 0x44, 0x44); /* untouched */ free (colors); } static void test_hb_ot_color_palette_get_colors_v1 (void) { hb_color_t colors[3]; unsigned int num_colors = hb_ot_color_palette_get_colors (cpal_v1, 0, 0, NULL, NULL); size_t colors_size = 3 * sizeof (hb_color_t); g_assert_cmpint (num_colors, ==, 2); /* Palette #0, start_index=0 */ memset (colors, 0x77, colors_size); g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v1, 0, 0, &num_colors, colors), ==, 2); g_assert_cmpint (num_colors, ==, 2); assert_color_rgba (colors, 0, 0x00, 0x00, 0x00, 0xff); assert_color_rgba (colors, 1, 0x66, 0xcc, 0xff, 0xff); assert_color_rgba (colors, 2, 0x77, 0x77, 0x77, 0x77); /* untouched */ /* Palette #1, start_index=0 */ memset (colors, 0x77, colors_size); g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v1, 1, 0, &num_colors, colors), ==, 2); g_assert_cmpint (num_colors, ==, 2); assert_color_rgba (colors, 0, 0x00, 0x00, 0x00, 0xff); assert_color_rgba (colors, 1, 0xff, 0xcc, 0x66, 0xff); assert_color_rgba (colors, 2, 0x77, 0x77, 0x77, 0x77); /* untouched */ /* Palette #2, start_index=0 */ memset (colors, 0x77, colors_size); g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v1, 2, 0, &num_colors, colors), ==, 2); g_assert_cmpint (num_colors, ==, 2); assert_color_rgba (colors, 0, 0x00, 0x00, 0x00, 0xff); assert_color_rgba (colors, 1, 0x80, 0x00, 0x00, 0xff); assert_color_rgba (colors, 2, 0x77, 0x77, 0x77, 0x77); /* untouched */ /* Palette #3 (out of bounds), start_index=0 */ memset (colors, 0x77, colors_size); g_assert_cmpint (hb_ot_color_palette_get_colors (cpal_v1, 3, 0, &num_colors, colors), ==, 0); g_assert_cmpint (num_colors, ==, 0); assert_color_rgba (colors, 0, 0x77, 0x77, 0x77, 0x77); /* untouched */ assert_color_rgba (colors, 1, 0x77, 0x77, 0x77, 0x77); /* untouched */ assert_color_rgba (colors, 2, 0x77, 0x77, 0x77, 0x77); /* untouched */ } static void test_hb_ot_color_palette_color_get_name_id (void) { g_assert_cmpuint (hb_ot_color_palette_color_get_name_id (empty, 0), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpuint (hb_ot_color_palette_color_get_name_id (empty, 1), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpuint (hb_ot_color_palette_color_get_name_id (empty, 2), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpuint (hb_ot_color_palette_color_get_name_id (cpal_v0, 0), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpuint (hb_ot_color_palette_color_get_name_id (cpal_v0, 1), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpuint (hb_ot_color_palette_color_get_name_id (cpal_v0, 2), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpuint (hb_ot_color_palette_color_get_name_id (cpal_v1, 0), ==, HB_OT_NAME_ID_INVALID); g_assert_cmpuint (hb_ot_color_palette_color_get_name_id (cpal_v1, 1), ==, 256); g_assert_cmpuint (hb_ot_color_palette_color_get_name_id (cpal_v1, 2), ==, HB_OT_NAME_ID_INVALID); } static void test_hb_ot_color_glyph_get_layers (void) { hb_ot_color_layer_t layers[1]; unsigned int count = 1; unsigned int num_layers; g_assert_cmpuint (hb_ot_color_glyph_get_layers (cpal_v1, 0, 0, NULL, NULL), ==, 0); g_assert_cmpuint (hb_ot_color_glyph_get_layers (cpal_v1, 1, 0, NULL, NULL), ==, 0); g_assert_cmpuint (hb_ot_color_glyph_get_layers (cpal_v1, 2, 0, NULL, NULL), ==, 2); num_layers = hb_ot_color_glyph_get_layers (cpal_v1, 2, 0, &count, layers); g_assert_cmpuint (num_layers, ==, 2); g_assert_cmpuint (count, ==, 1); g_assert_cmpuint (layers[0].glyph, ==, 3); g_assert_cmpuint (layers[0].color_index, ==, 1); count = 1; hb_ot_color_glyph_get_layers (cpal_v1, 2, 1, &count, layers); g_assert_cmpuint (num_layers, ==, 2); g_assert_cmpuint (count, ==, 1); g_assert_cmpuint (layers[0].glyph, ==, 4); g_assert_cmpuint (layers[0].color_index, ==, 0); } static void test_hb_ot_color_has_data (void) { g_assert (hb_ot_color_has_layers (empty) == FALSE); g_assert (hb_ot_color_has_layers (cpal_v0) == TRUE); g_assert (hb_ot_color_has_layers (cpal_v1) == TRUE); g_assert (hb_ot_color_has_layers (cpal) == TRUE); g_assert (hb_ot_color_has_layers (cbdt) == FALSE); g_assert (hb_ot_color_has_layers (sbix) == FALSE); g_assert (hb_ot_color_has_layers (svg) == FALSE); g_assert (hb_ot_color_has_palettes (empty) == FALSE); g_assert (hb_ot_color_has_palettes (cpal_v0) == TRUE); g_assert (hb_ot_color_has_palettes (cpal_v1) == TRUE); g_assert (hb_ot_color_has_palettes (cpal) == TRUE); g_assert (hb_ot_color_has_palettes (cbdt) == FALSE); g_assert (hb_ot_color_has_palettes (sbix) == FALSE); g_assert (hb_ot_color_has_palettes (svg) == FALSE); g_assert (hb_ot_color_has_svg (empty) == FALSE); g_assert (hb_ot_color_has_svg (cpal_v0) == FALSE); g_assert (hb_ot_color_has_svg (cpal_v1) == FALSE); g_assert (hb_ot_color_has_svg (cpal) == FALSE); g_assert (hb_ot_color_has_svg (cbdt) == FALSE); g_assert (hb_ot_color_has_svg (sbix) == FALSE); g_assert (hb_ot_color_has_svg (svg) == TRUE); g_assert (hb_ot_color_has_png (empty) == FALSE); g_assert (hb_ot_color_has_png (cpal_v0) == FALSE); g_assert (hb_ot_color_has_png (cpal_v1) == FALSE); g_assert (hb_ot_color_has_png (cpal) == FALSE); g_assert (hb_ot_color_has_png (cbdt) == TRUE); g_assert (hb_ot_color_has_png (sbix) == TRUE); g_assert (hb_ot_color_has_png (svg) == FALSE); } static void test_hb_ot_color_svg (void) { hb_blob_t *blob; unsigned int length; const char *data; blob = hb_ot_color_glyph_reference_svg (svg, 0); g_assert (hb_blob_get_length (blob) == 0); blob = hb_ot_color_glyph_reference_svg (svg, 1); data = hb_blob_get_data (blob, &length); g_assert_cmpuint (length, ==, 146); g_assert (strncmp (data, "", 5) == 0); hb_blob_destroy (blob); blob = hb_ot_color_glyph_reference_svg (empty, 0); g_assert (hb_blob_get_length (blob) == 0); } static void test_hb_ot_color_png (void) { hb_blob_t *blob; unsigned int length; const char *data; hb_glyph_extents_t extents; hb_font_t *cbdt_font; /* sbix */ hb_font_t *sbix_font; sbix_font = hb_font_create (sbix); blob = hb_ot_color_glyph_reference_png (sbix_font, 0); hb_font_get_glyph_extents (sbix_font, 0, &extents); g_assert_cmpint (extents.x_bearing, ==, 0); g_assert_cmpint (extents.y_bearing, ==, 0); g_assert_cmpint (extents.width, ==, 0); g_assert_cmpint (extents.height, ==, 0); g_assert (hb_blob_get_length (blob) == 0); blob = hb_ot_color_glyph_reference_png (sbix_font, 1); data = hb_blob_get_data (blob, &length); g_assert_cmpuint (length, ==, 224); g_assert (strncmp (data + 1, "PNG", 3) == 0); hb_font_get_glyph_extents (sbix_font, 1, &extents); g_assert_cmpint (extents.x_bearing, ==, 0); g_assert_cmpint (extents.y_bearing, ==, 800); g_assert_cmpint (extents.width, ==, 800); g_assert_cmpint (extents.height, ==, -800); hb_blob_destroy (blob); hb_font_destroy (sbix_font); /* cbdt */ cbdt_font = hb_font_create (cbdt); blob = hb_ot_color_glyph_reference_png (cbdt_font, 0); g_assert (hb_blob_get_length (blob) == 0); blob = hb_ot_color_glyph_reference_png (cbdt_font, 1); data = hb_blob_get_data (blob, &length); g_assert_cmpuint (length, ==, 88); g_assert (strncmp (data + 1, "PNG", 3) == 0); hb_font_get_glyph_extents (cbdt_font, 1, &extents); g_assert_cmpint (extents.x_bearing, ==, 0); g_assert_cmpint (extents.y_bearing, ==, 1024); g_assert_cmpint (extents.width, ==, 1024); g_assert_cmpint (extents.height, ==, -1024); hb_blob_destroy (blob); hb_font_destroy (cbdt_font); } /* ---- */ typedef struct { int level; GString *string; } paint_data_t; static void print (paint_data_t *data, const char *format, ...) { va_list args; g_string_append_printf (data->string, "%*s", 2 * data->level, ""); va_start (args, format); g_string_append_vprintf (data->string, format, args); va_end (args); g_string_append (data->string, "\n"); } static void push_transform (hb_paint_funcs_t *funcs, void *paint_data, float xx, float yx, float xy, float yy, float dx, float dy, void *user_data) { paint_data_t *data = user_data; print (data, "start transform %f %f %f %f %f %f", xx, yx, xy, yy, dx, dy); data->level++; } static void pop_transform (hb_paint_funcs_t *funcs, void *paint_data, void *user_data) { paint_data_t *data = user_data; data->level--; print (data, "end transform"); } static void push_clip_glyph (hb_paint_funcs_t *funcs, void *paint_data, hb_codepoint_t glyph, void *user_data) { paint_data_t *data = user_data; print (data, "start clip glyph %u", glyph); data->level++; } static void push_clip_rectangle (hb_paint_funcs_t *funcs, void *paint_data, float xmin, float ymin, float xmax, float ymax, void *user_data) { paint_data_t *data = user_data; print (data, "start clip rectangle %f %f %f %f", xmin, ymin, xmax, ymax); data->level++; } static void pop_clip (hb_paint_funcs_t *funcs, void *paint_data, void *user_data) { paint_data_t *data = user_data; data->level--; print (data, "end clip"); } static void paint_color (hb_paint_funcs_t *funcs, void *paint_data, unsigned int color_index, float alpha, void *user_data) { paint_data_t *data = user_data; print (data, "solid %u %f", color_index, alpha); } static void paint_image (hb_paint_funcs_t *funcs, void *paint_data, hb_blob_t *blob, hb_tag_t format, hb_glyph_extents_t *extents, void *user_data) { paint_data_t *data = user_data; char buf[5] = { 0, }; hb_tag_to_string (format, buf); print (data, "image type %s extents %d %d %d %d\n", buf, extents->x_bearing, extents->y_bearing, extents->width, extents->height); } static void print_color_line (paint_data_t *data, hb_color_line_t *color_line) { hb_color_stop_t *stops; unsigned int len; len = hb_color_line_get_color_stops (color_line, 0, NULL, NULL); stops = alloca (len * sizeof (hb_color_stop_t)); hb_color_line_get_color_stops (color_line, 0, &len, stops); print (data, "colors"); data->level += 1; for (unsigned int i = 0; i < len; i++) print (data, "%f %u %f", stops[i].offset, stops[i].color_index, stops[i].alpha); data->level -= 1; } static void paint_linear_gradient (hb_paint_funcs_t *funcs, void *paint_data, hb_color_line_t *color_line, float x0, float y0, float x1, float y1, float x2, float y2, void *user_data) { paint_data_t *data = user_data; print (data, "linear gradient"); data->level += 1; print (data, "p0 %f %f", x0, y0); print (data, "p1 %f %f", x1, y1); print (data, "p2 %f %f", x2, y2); print_color_line (data, color_line); data->level -= 1; } static void paint_radial_gradient (hb_paint_funcs_t *funcs, void *paint_data, hb_color_line_t *color_line, float x0, float y0, float r0, float x1, float y1, float r1, void *user_data) { paint_data_t *data = user_data; print (data, "radial gradient"); data->level += 1; print (data, "p0 %f %f radius %f", x0, y0, r0); print (data, "p1 %f %f radius %f", x1, y1, r1); print_color_line (data, color_line); data->level -= 1; } static void paint_sweep_gradient (hb_paint_funcs_t *funcs, void *paint_data, hb_color_line_t *color_line, float cx, float cy, float start_angle, float end_angle, void *user_data) { paint_data_t *data = user_data; print (data, "sweep gradient"); data->level++; print (data, "center %f %f", cx, cy); print (data, "angles %f %f", start_angle, end_angle); print_color_line (data, color_line); data->level -= 1; } static void push_group (hb_paint_funcs_t *funcs, void *paint_data, void *user_data) { paint_data_t *data = user_data; print (data, "push group"); data->level++; } static void pop_group (hb_paint_funcs_t *funcs, void *paint_data, hb_paint_composite_mode_t mode, void *user_data) { paint_data_t *data = user_data; data->level--; print (data, "pop group mode %d", mode); } typedef struct { const char *font_file; int scale; float slant; hb_codepoint_t glyph; const char *output; } colrv1_test_t; #define NOTO_HAND "fonts/noto_handwriting-cff2_colr_1.otf" #define TEST_GLYPHS "fonts/test_glyphs-glyf_colr_1.ttf" static colrv1_test_t colrv1_tests[] = { { NOTO_HAND, 20, 0., 10, "results/hand-20-0-10.txt" }, { NOTO_HAND, 20, 0.2, 10, "results/hand-20-0.2-10.txt" }, { TEST_GLYPHS, 20, 0, 6, "results/test-20-0-6.txt" }, { TEST_GLYPHS, 20, 0, 10, "results/test-20-0-10.txt" }, { TEST_GLYPHS, 20, 0, 92, "results/test-20-0-92.txt" }, { TEST_GLYPHS, 20, 0, 106, "results/test-20-0-106.txt" }, { TEST_GLYPHS, 20, 0, 116, "results/test-20-0-116.txt" }, { TEST_GLYPHS, 20, 0, 123, "results/test-20-0-123.txt" }, { TEST_GLYPHS, 20, 0, 165, "results/test-20-0-165.txt" }, { TEST_GLYPHS, 20, 0, 175, "results/test-20-0-175.txt" }, }; static void test_hb_ot_color_colr_v1 (gconstpointer d) { const colrv1_test_t *test = d; hb_face_t *face; hb_font_t *font; hb_paint_funcs_t *funcs; paint_data_t data; char *file; char *buffer; gsize len; GError *error = NULL; face = hb_test_open_font_file (test->font_file); font = hb_font_create (face); hb_font_set_scale (font, test->scale, test->scale); hb_font_set_synthetic_slant (font, test->slant); funcs = hb_paint_funcs_create (); hb_paint_funcs_set_push_transform_func (funcs, push_transform, &data, NULL); hb_paint_funcs_set_pop_transform_func (funcs, pop_transform, &data, NULL); hb_paint_funcs_set_push_clip_glyph_func (funcs, push_clip_glyph, &data, NULL); hb_paint_funcs_set_push_clip_rectangle_func (funcs, push_clip_rectangle, &data, NULL); hb_paint_funcs_set_pop_clip_func (funcs, pop_clip, &data, NULL); hb_paint_funcs_set_push_group_func (funcs, push_group, &data, NULL); hb_paint_funcs_set_pop_group_func (funcs, pop_group, &data, NULL); hb_paint_funcs_set_color_func (funcs, paint_color, &data, NULL); hb_paint_funcs_set_image_func (funcs, paint_image, &data, NULL); hb_paint_funcs_set_linear_gradient_func (funcs, paint_linear_gradient, &data, NULL); hb_paint_funcs_set_radial_gradient_func (funcs, paint_radial_gradient, &data, NULL); hb_paint_funcs_set_sweep_gradient_func (funcs, paint_sweep_gradient, &data, NULL); data.string = g_string_new (""); data.level = 0; hb_font_paint_glyph (font, test->glyph, funcs, &data); /* Run * * GENERATE_DATA=1 G_TEST_SRCDIR=./test/api ./build/test/api/test-ot-color -p TESTCASE > test/api/results/OUTPUT * * to produce the expected results file. */ if (getenv ("GENERATE_DATA")) { g_print ("%s\n", data.string->str); exit (0); } file = g_test_build_filename (G_TEST_DIST, test->output, NULL); if (!g_file_get_contents (file, &buffer, &len, &error)) { g_test_fail (); return; } char **lines = g_strsplit (data.string->str, "\n", 0); char **expected; if (strstr (buffer, "\r\n")) expected = g_strsplit (buffer, "\r\n", 0); else expected = g_strsplit (buffer, "\n", 0); if (g_strv_length (lines) != g_strv_length (expected)) { g_test_message ("Unexpected number of lines in output (%d instead of %d)", g_strv_length (lines), g_strv_length (expected)); g_test_fail (); } else { unsigned int length = g_strv_length (lines); for (unsigned int i = 0; i < length; i++) { if (strcmp (lines[i], expected[i]) != 0) { int pos; for (pos = 0; lines[i][pos]; pos++) if (lines[i][pos] != expected[i][pos]) break; g_test_message ("Unxpected output at %d:%d (%#x instead of %#x):\n%s", i, pos, (unsigned int)lines[i][pos], (unsigned int)expected[i][pos], data.string->str); g_test_fail (); } } } g_strfreev (lines); g_strfreev (expected); g_free (buffer); g_free (file); g_string_free (data.string, TRUE); hb_paint_funcs_destroy (funcs); hb_font_destroy (font); hb_face_destroy (face); } int main (int argc, char **argv) { int status = 0; hb_test_init (&argc, &argv); cpal_v0 = hb_test_open_font_file ("fonts/cpal-v0.ttf"); cpal_v1 = hb_test_open_font_file ("fonts/cpal-v1.ttf"); cpal = hb_test_open_font_file ("fonts/chromacheck-colr.ttf"); cbdt = hb_test_open_font_file ("fonts/chromacheck-cbdt.ttf"); sbix = hb_test_open_font_file ("fonts/chromacheck-sbix.ttf"); svg = hb_test_open_font_file ("fonts/chromacheck-svg.ttf"); colr_v1 = hb_test_open_font_file ("fonts/noto_handwriting-cff2_colr_1.otf"); colr_v1_2 = hb_test_open_font_file ("fonts/test_glyphs-glyf_colr_1.ttf"); empty = hb_face_get_empty (); hb_test_add (test_hb_ot_color_palette_get_count); hb_test_add (test_hb_ot_color_palette_get_name_id_empty); hb_test_add (test_hb_ot_color_palette_get_name_id_v0); hb_test_add (test_hb_ot_color_palette_get_name_id_v1); hb_test_add (test_hb_ot_color_palette_get_flags_empty); hb_test_add (test_hb_ot_color_palette_get_flags_v0); hb_test_add (test_hb_ot_color_palette_get_flags_v1); hb_test_add (test_hb_ot_color_palette_get_colors_empty); hb_test_add (test_hb_ot_color_palette_get_colors_v0); hb_test_add (test_hb_ot_color_palette_get_colors_v1); hb_test_add (test_hb_ot_color_palette_color_get_name_id); hb_test_add (test_hb_ot_color_glyph_get_layers); hb_test_add (test_hb_ot_color_has_data); hb_test_add (test_hb_ot_color_png); hb_test_add (test_hb_ot_color_svg); for (unsigned int i = 0; i < G_N_ELEMENTS (colrv1_tests); i++) { char buf[10] = { 0, }; g_snprintf (buf, 10, "%d", i); hb_test_add_data_flavor (&colrv1_tests[i], buf, test_hb_ot_color_colr_v1); } status = hb_test_run(); hb_face_destroy (cpal_v0); hb_face_destroy (cpal_v1); hb_face_destroy (cpal); hb_face_destroy (cbdt); hb_face_destroy (sbix); hb_face_destroy (svg); hb_face_destroy (colr_v1); hb_face_destroy (colr_v1_2); return status; }