/* * Copyright © 2026 Google, Inc. * * 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. */ #include "hb-test.h" #include "hb-subset-test.h" #include static void draw_move_to (hb_draw_funcs_t *funcs HB_UNUSED, void *data, hb_draw_state_t *state HB_UNUSED, float x, float y, void *user_data HB_UNUSED) { g_string_append_printf ((GString *) data, "M%.9g,%.9g", x, y); } static void draw_line_to (hb_draw_funcs_t *funcs HB_UNUSED, void *data, hb_draw_state_t *state HB_UNUSED, float x, float y, void *user_data HB_UNUSED) { g_string_append_printf ((GString *) data, "L%.9g,%.9g", x, y); } static void draw_quadratic_to (hb_draw_funcs_t *funcs HB_UNUSED, void *data, hb_draw_state_t *state HB_UNUSED, float cx, float cy, float x, float y, void *user_data HB_UNUSED) { g_string_append_printf ((GString *) data, "Q%.9g,%.9g %.9g,%.9g", cx, cy, x, y); } static void draw_cubic_to (hb_draw_funcs_t *funcs HB_UNUSED, void *data, hb_draw_state_t *state HB_UNUSED, float c1x, float c1y, float c2x, float c2y, float x, float y, void *user_data HB_UNUSED) { g_string_append_printf ((GString *) data, "C%.9g,%.9g %.9g,%.9g %.9g,%.9g", c1x, c1y, c2x, c2y, x, y); } static void draw_close_path (hb_draw_funcs_t *funcs HB_UNUSED, void *data, hb_draw_state_t *state HB_UNUSED, void *user_data HB_UNUSED) { g_string_append_c ((GString *) data, 'Z'); } static char * draw_glyph (hb_font_t *font, hb_codepoint_t gid) { hb_draw_funcs_t *funcs = hb_draw_funcs_create (); hb_draw_funcs_set_move_to_func (funcs, draw_move_to, NULL, NULL); hb_draw_funcs_set_line_to_func (funcs, draw_line_to, NULL, NULL); hb_draw_funcs_set_quadratic_to_func (funcs, draw_quadratic_to, NULL, NULL); hb_draw_funcs_set_cubic_to_func (funcs, draw_cubic_to, NULL, NULL); hb_draw_funcs_set_close_path_func (funcs, draw_close_path, NULL, NULL); GString *path = g_string_new (NULL); hb_font_draw_glyph (font, gid, funcs, path); hb_draw_funcs_destroy (funcs); return g_string_free (path, false); } static char * draw_unicode_at (hb_face_t *face, hb_codepoint_t unicode, const hb_variation_t *variations, unsigned variation_count) { hb_font_t *font = hb_font_create (face); hb_font_set_variations (font, variations, variation_count); hb_codepoint_t gid; g_assert_true (hb_font_get_nominal_glyph (font, unicode, &gid)); char *path = draw_glyph (font, gid); hb_font_destroy (font); return path; } static char * draw_unicode (hb_face_t *face, hb_codepoint_t unicode) { return draw_unicode_at (face, unicode, NULL, 0); } static void assert_paths_close (const char *a, const char *b) { /* Baking gvar deltas changes floating-point summation order. */ while (*a && *b) { char *a_end, *b_end; double x = g_ascii_strtod (a, &a_end); double y = g_ascii_strtod (b, &b_end); if (a_end != a || b_end != b) { g_assert_true (a_end != a && b_end != b); g_assert_cmpfloat (fabs (x - y), <, 0.001); a = a_end; b = b_end; } else g_assert_cmpint (*a++, ==, *b++); } g_assert_cmpint (*a, ==, *b); } static void assert_has_varc (hb_face_t *face, hb_bool_t expected) { hb_blob_t *blob = hb_face_reference_table (face, HB_TAG ('V','A','R','C')); g_assert_cmpint (hb_blob_get_length (blob) != 0, ==, expected); hb_blob_destroy (blob); } static unsigned varc_length (hb_face_t *face) { hb_blob_t *blob = hb_face_reference_table (face, HB_TAG ('V','A','R','C')); unsigned length = hb_blob_get_length (blob); hb_blob_destroy (blob); return length; } static hb_face_t * subset_varc (hb_face_t *face, hb_codepoint_t unicode) { hb_set_t *unicodes = hb_set_create (); hb_set_add (unicodes, unicode); hb_face_t *subset = hb_subset_test_create_subset ( face, hb_subset_test_create_input (unicodes)); hb_set_destroy (unicodes); return subset; } static void test_subset_varc_closure_and_remap (void) { hb_face_t *face = hb_test_open_font_file ("fonts/varc-ac00-ac01.ttf"); hb_face_t *ac00 = subset_varc (face, 0xAC00); g_assert_cmpuint (hb_face_get_glyph_count (ac00), ==, 6); assert_has_varc (ac00, true); g_assert_cmpuint (varc_length (ac00), <, varc_length (face)); hb_face_t *ac01 = subset_varc (face, 0xAC01); g_assert_cmpuint (hb_face_get_glyph_count (ac01), ==, 8); assert_has_varc (ac01, true); g_assert_cmpuint (varc_length (ac01), <, varc_length (face)); hb_face_destroy (ac01); hb_face_destroy (ac00); hb_face_destroy (face); } static void test_subset_varc_draw_equivalence (void) { hb_face_t *face = hb_test_open_font_file ("fonts/varc-ac00-ac01.ttf"); hb_face_t *subset = subset_varc (face, 0xAC01); char *source_path = draw_unicode (face, 0xAC01); char *subset_path = draw_unicode (subset, 0xAC01); hb_variation_t variations[] = { {HB_TAG ('w','g','h','t'), 840.3f}, {HB_TAG ('o','p','s','z'), 1.f}, }; char *varied_source_path = draw_unicode_at (face, 0xAC01, variations, G_N_ELEMENTS (variations)); char *varied_subset_path = draw_unicode_at (subset, 0xAC01, variations, G_N_ELEMENTS (variations)); g_assert_cmpstr (source_path, !=, ""); g_assert_cmpstr (subset_path, ==, source_path); g_assert_cmpstr (varied_source_path, !=, source_path); g_assert_cmpstr (varied_subset_path, ==, varied_source_path); g_free (varied_subset_path); g_free (varied_source_path); g_free (subset_path); g_free (source_path); hb_face_destroy (subset); hb_face_destroy (face); } static void test_subset_varc_condition_closure (void) { hb_face_t *face = hb_test_open_font_file ("fonts/varc-ac01-conditional.ttf"); hb_face_t *subset = subset_varc (face, 0xAC01); /* Closure conservatively retains components regardless of their condition. */ g_assert_cmpuint (hb_face_get_glyph_count (subset), ==, 8); assert_has_varc (subset, true); hb_face_destroy (subset); hb_face_destroy (face); } static void test_subset_varc_mismatched_coverage_and_records (void) { const char *fonts[] = { "fonts/varc-coverage-longer.ttf", "fonts/varc-records-longer.ttf", }; for (unsigned i = 0; i < G_N_ELEMENTS (fonts); i++) { hb_face_t *face = hb_test_open_font_file (fonts[i]); hb_face_t *subset = subset_varc (face, 0xAC00); g_assert_nonnull (subset); g_assert_cmpuint (hb_face_get_glyph_count (subset), ==, 6); assert_has_varc (subset, true); hb_face_destroy (subset); hb_face_destroy (face); } } static void test_subset_varc_no_variation_index (void) { const struct { const char *font; hb_codepoint_t unicode; unsigned glyph_count; } tests[] = { {"fonts/varc-no-variation-index.ttf", 0xAC00, 6}, {"fonts/varc-condition-no-variation-index.ttf", 0xAC01, 8}, }; for (unsigned i = 0; i < G_N_ELEMENTS (tests); i++) { hb_face_t *face = hb_test_open_font_file (tests[i].font); hb_face_t *subset = subset_varc (face, tests[i].unicode); g_assert_nonnull (subset); g_assert_cmpuint (hb_face_get_glyph_count (subset), ==, tests[i].glyph_count); assert_has_varc (subset, true); hb_face_destroy (subset); hb_face_destroy (face); } } static void test_subset_varc_retain_gids (void) { hb_face_t *face = hb_test_open_font_file ("fonts/varc-ac00-ac01.ttf"); hb_subset_input_t *input = hb_subset_input_create_or_fail (); hb_set_add (hb_subset_input_unicode_set (input), 0xAC00); hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_RETAIN_GIDS); hb_face_t *subset = hb_subset_test_create_subset (face, input); g_assert_cmpuint (hb_face_get_glyph_count (subset), ==, 7); assert_has_varc (subset, true); hb_font_t *source_font = hb_font_create (face); hb_font_t *subset_font = hb_font_create (subset); hb_codepoint_t old_gid; hb_codepoint_t subset_gid; g_assert_true (hb_font_get_nominal_glyph (source_font, 0xAC00, &old_gid)); g_assert_true (hb_font_get_nominal_glyph (subset_font, 0xAC00, &subset_gid)); g_assert_cmpuint (subset_gid, ==, old_gid); char *source_path = draw_glyph (source_font, old_gid); char *subset_path = draw_glyph (subset_font, old_gid); g_assert_cmpstr (source_path, !=, ""); g_assert_cmpstr (subset_path, ==, source_path); g_free (subset_path); g_free (source_path); hb_font_destroy (subset_font); hb_font_destroy (source_font); hb_face_destroy (subset); hb_face_destroy (face); } static void test_subset_varc_fails_when_instancing (void) { const char *fonts[] = { "fonts/varc-unrelated-axis.ttf", "fonts/varc-unrelated-axis-avar2.ttf", }; const hb_tag_t tags[] = { HB_TAG ('w','g','h','t'), /* MultiVarStore */ HB_TAG ('o','p','s','z'), /* MultiVarStore */ HB_TAG ('0','0','0','0'), /* Component coordinates */ HB_TAG ('C','O','N','D'), /* Nested conditions only */ }; for (unsigned f = 0; f < G_N_ELEMENTS (fonts); f++) { hb_face_t *face = hb_test_open_font_file (fonts[f]); for (unsigned i = 0; i < G_N_ELEMENTS (tags); i++) for (unsigned restrict_range = 0; restrict_range < 2; restrict_range++) { hb_subset_input_t *input = hb_subset_input_create_or_fail (); hb_set_add (hb_subset_input_unicode_set (input), 0xAC01); hb_ot_var_axis_info_t axis; g_assert_true (hb_ot_var_find_axis_info (face, tags[i], &axis)); if (restrict_range) g_assert_true (hb_subset_input_set_axis_range ( input, face, tags[i], axis.min_value, (axis.default_value + axis.max_value) / 2, axis.default_value)); else g_assert_true (hb_subset_input_pin_axis_to_default (input, face, tags[i])); g_assert_null (hb_subset_or_fail (face, input)); hb_subset_input_destroy (input); } hb_subset_input_t *input = hb_subset_input_create_or_fail (); hb_set_add (hb_subset_input_unicode_set (input), 0xAC01); g_assert_true (hb_subset_input_pin_all_axes_to_default (input, face)); g_assert_null (hb_subset_or_fail (face, input)); hb_subset_input_destroy (input); hb_face_destroy (face); } } static void test_subset_varc_original_axis_ranges (void) { const char *fonts[] = { "fonts/varc-unrelated-axis.ttf", "fonts/varc-unrelated-axis-avar2.ttf", }; const hb_tag_t tags[] = { HB_TAG ('w','g','h','t'), HB_TAG ('o','p','s','z'), HB_TAG ('0','0','0','0'), HB_TAG ('C','O','N','D'), }; for (unsigned f = 0; f < G_N_ELEMENTS (fonts); f++) { hb_face_t *face = hb_test_open_font_file (fonts[f]); for (unsigned pin = 0; pin < 2; pin++) { hb_subset_input_t *input = hb_subset_input_create_or_fail (); hb_set_add (hb_subset_input_unicode_set (input), 0xAC01); if (pin) g_assert_true (hb_subset_input_pin_axis_location (input, face, HB_TAG ('D','U','M','Y'), 0.5f)); hb_face_t *expected = hb_subset_test_create_subset (face, input); for (unsigned request = 0; request <= G_N_ELEMENTS (tags); request++) { input = hb_subset_input_create_or_fail (); hb_set_add (hb_subset_input_unicode_set (input), 0xAC01); if (pin) g_assert_true (hb_subset_input_pin_axis_location (input, face, HB_TAG ('D','U','M','Y'), 0.5f)); for (unsigned i = 0; i < G_N_ELEMENTS (tags); i++) if (i == request || request == G_N_ELEMENTS (tags)) { hb_ot_var_axis_info_t axis; g_assert_true (hb_ot_var_find_axis_info (face, tags[i], &axis)); g_assert_true (hb_subset_input_set_axis_range ( input, face, tags[i], axis.min_value, axis.max_value, axis.default_value)); } hb_face_t *subset = hb_subset_test_create_subset (face, input); hb_subset_test_check (expected, subset, HB_TAG ('V','A','R','C')); hb_subset_test_check (expected, subset, HB_TAG ('f','v','a','r')); hb_variation_t variations[] = { {HB_TAG ('w','g','h','t'), 840.3f}, {HB_TAG ('C','O','N','D'), 0.75f}, {HB_TAG ('0','0','0','0'), -0.5f}, }; char *expected_path = draw_unicode_at (expected, 0xAC01, variations, G_N_ELEMENTS (variations)); char *actual_path = draw_unicode_at (subset, 0xAC01, variations, G_N_ELEMENTS (variations)); assert_paths_close (actual_path, expected_path); g_free (actual_path); g_free (expected_path); hb_face_destroy (subset); } hb_face_destroy (expected); } hb_face_destroy (face); } } static void test_subset_varc_instance_unrelated_axis (void) { const char *fonts[] = { "fonts/varc-unrelated-axis.ttf", "fonts/varc-unrelated-axis-avar2.ttf", }; hb_tag_t dummy = HB_TAG ('D','U','M','Y'); for (unsigned f = 0; f < G_N_ELEMENTS (fonts); f++) { hb_face_t *face = hb_test_open_font_file (fonts[f]); for (unsigned mode = 0; mode < 3; mode++) { hb_bool_t restrict_range = mode == 1; hb_subset_input_t *input = hb_subset_input_create_or_fail (); hb_set_add (hb_subset_input_unicode_set (input), 0xAC01); if (mode == 2) hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_RETAIN_GIDS); if (restrict_range) g_assert_true (hb_subset_input_set_axis_range (input, face, dummy, 0, 1, 0.5f)); else g_assert_true (hb_subset_input_pin_axis_location (input, face, dummy, 0.5f)); hb_face_t *subset = hb_subset_test_create_subset (face, input); assert_has_varc (subset, true); g_assert_cmpuint (hb_ot_var_get_axis_count (subset), ==, hb_ot_var_get_axis_count (face) - !restrict_range); hb_ot_var_axis_info_t axis; g_assert_cmpint (hb_ot_var_find_axis_info (subset, dummy, &axis), ==, restrict_range); if (restrict_range) { g_assert_cmpfloat (axis.min_value, ==, 0); g_assert_cmpfloat (axis.default_value, ==, 0.5f); g_assert_cmpfloat (axis.max_value, ==, 1); } g_assert_true (hb_ot_var_find_axis_info (subset, HB_TAG ('w','g','h','t'), &axis)); g_assert_cmpuint (axis.axis_index, ==, restrict_range ? 2 : 1); for (unsigned sample = 0; sample < 8; sample++) { hb_variation_t variations[] = { {dummy, restrict_range && (sample & 1) ? 1.f : 0.5f}, {HB_TAG ('w','g','h','t'), sample & 2 ? 840.3f : 356.5f}, {HB_TAG ('o','p','s','z'), sample & 1 ? 1.f : 0.f}, {HB_TAG ('C','O','N','D'), sample & 4 ? 1.f : 0.f}, }; char *source_path = draw_unicode_at (face, 0xAC01, variations, G_N_ELEMENTS (variations)); char *subset_path = draw_unicode_at (subset, 0xAC01, variations, G_N_ELEMENTS (variations)); g_assert_cmpstr (source_path, !=, ""); assert_paths_close (subset_path, source_path); g_free (subset_path); g_free (source_path); } hb_face_destroy (subset); } hb_face_destroy (face); } } static void test_subset_varc_instance_without_varc_glyphs (void) { hb_face_t *face = hb_test_open_font_file ("fonts/varc-ac00-ac01.ttf"); hb_subset_input_t *input = hb_subset_input_create_or_fail (); hb_set_add (hb_subset_input_glyph_set (input), 0); g_assert_true (hb_subset_input_pin_axis_to_default ( input, face, HB_TAG ('w','g','h','t'))); hb_face_t *subset = hb_subset_test_create_subset (face, input); assert_has_varc (subset, false); g_assert_cmpuint (hb_ot_var_get_axis_count (subset), ==, hb_ot_var_get_axis_count (face) - 1); hb_face_destroy (subset); hb_face_destroy (face); } static void test_subset_varc_can_be_explicitly_dropped_when_instancing (void) { hb_face_t *face = hb_test_open_font_file ("fonts/varc-ac00-ac01.ttf"); hb_set_t *unicodes = hb_set_create (); hb_set_add (unicodes, 0xAC00); hb_subset_input_t *input = hb_subset_test_create_input (unicodes); hb_set_destroy (unicodes); hb_set_add (hb_subset_input_set (input, HB_SUBSET_SETS_DROP_TABLE_TAG), HB_TAG ('V','A','R','C')); g_assert_true (hb_subset_input_pin_axis_location (input, face, HB_TAG ('w','g','h','t'), 400)); hb_face_t *subset = hb_subset_test_create_subset (face, input); assert_has_varc (subset, false); hb_face_destroy (subset); hb_face_destroy (face); } static hb_subset_input_t * create_varc_no_subset_input (hb_bool_t retain_gids) { hb_subset_input_t *input = hb_subset_input_create_or_fail (); hb_set_add (hb_subset_input_unicode_set (input), 0xAC00); hb_set_add (hb_subset_input_set (input, HB_SUBSET_SETS_NO_SUBSET_TABLE_TAG), HB_TAG ('V','A','R','C')); if (retain_gids) hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_RETAIN_GIDS); return input; } static void test_subset_varc_passthrough_requires_retained_gids (void) { hb_face_t *face = hb_test_open_font_file ("fonts/varc-ac00-ac01.ttf"); hb_subset_input_t *input = create_varc_no_subset_input (false); hb_face_t *subset = hb_subset_or_fail (face, input); g_assert_null (subset); hb_subset_input_destroy (input); input = create_varc_no_subset_input (true); subset = hb_subset_test_create_subset (face, input); assert_has_varc (subset, true); hb_face_destroy (subset); input = create_varc_no_subset_input (true); /* Even an unrelated pin cannot renumber axes in a passthrough table. */ g_assert_true (hb_subset_input_pin_axis_to_default ( input, face, HB_TAG ('0','0','0','5'))); g_assert_null (hb_subset_or_fail (face, input)); hb_subset_input_destroy (input); hb_face_destroy (face); } static void test_subset_varc_overlapping_records (void) { /* Three glyphs whose VARC records share bytes. Walking every record a * glyph resolves to must not cost more than the glyphRecords INDEX. */ static const char maxp_data[] = {0, 0, 0x50, 0, 0, 3}; static const char coverages[][10] = { /* Format 2, glyphs 0..2 -> records 0..2: caught by the closure. */ {0, 2, 0, 1, 0, 0, 0, 2, 0, 0}, /* Format 1, glyph 0 three times: caught by the table subsetter. */ {0, 1, 0, 3, 0, 0, 0, 0, 0, 0}, }; char varc_data[] = { 0, 1, 0, 0, /* version */ 0, 0, 0, 24, /* coverage */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* varStore, conditionList, axisIndicesList */ 0, 0, 0, 34, /* glyphRecords */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* coverage, filled in below */ 0, 0, 0, 3, 1, /* INDEX: count 3, offSize 1 */ 1, 31, 1, 31, /* records 0 and 2 are the same 30 bytes */ 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, 0, 0, 2, }; for (unsigned i = 0; i < G_N_ELEMENTS (coverages); i++) { memcpy (varc_data + 24, coverages[i], sizeof (coverages[i])); hb_face_t *face = hb_face_builder_create (); HB_FACE_ADD_TABLE (face, "maxp", maxp_data); HB_FACE_ADD_TABLE (face, "VARC", varc_data); hb_subset_input_t *input = hb_subset_input_create_or_fail (); hb_set_add_range (hb_subset_input_glyph_set (input), 0, 2); g_assert_null (hb_subset_or_fail (face, input)); hb_subset_input_destroy (input); hb_face_destroy (face); } } int main (int argc, char **argv) { hb_test_init (&argc, &argv); hb_test_add (test_subset_varc_closure_and_remap); hb_test_add (test_subset_varc_draw_equivalence); hb_test_add (test_subset_varc_condition_closure); hb_test_add (test_subset_varc_mismatched_coverage_and_records); hb_test_add (test_subset_varc_no_variation_index); hb_test_add (test_subset_varc_retain_gids); hb_test_add (test_subset_varc_fails_when_instancing); hb_test_add (test_subset_varc_instance_unrelated_axis); hb_test_add (test_subset_varc_original_axis_ranges); hb_test_add (test_subset_varc_instance_without_varc_glyphs); hb_test_add (test_subset_varc_can_be_explicitly_dropped_when_instancing); hb_test_add (test_subset_varc_passthrough_requires_retained_gids); hb_test_add (test_subset_varc_overlapping_records); return hb_test_run (); }