mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-19 14:01:10 +01:00
closure_glyphs(), depend() and varc_subset_plan_t::collect_glyphs() each decode the full glyph record of every glyph id they reach, assuming every glyph has its own record. Nothing enforces that: CFFIndex::sanitize() accepts overlapping glyphRecords offsets, and a Coverage table may map many glyph ids to the same INDEX entry, so N glyph ids can resolve to one large record and the walk does N times that record's work -- quadratic in the font size (44 s for a 245 KB font), charged to no budget. In a well-formed table the records are disjoint and each glyph is visited once, so the bytes of all records walked cannot exceed the glyphRecords INDEX. Enforce exactly that invariant where the records are fetched, in all three walks, failing through each site's existing idiom. The remaining work is linear: a component decodes only if its record holds at least one byte per 64 counted axis values. In collect_glyphs() this also replaces the saturating sum and the post-loop data_size != UINT_MAX test, which a 64-bit build bypasses because hb_unsigned_add_saturate() returns size_t and the sum truncates into the unsigned data_size (a near-4 GiB total stored as a small value); the running total is now checked after every addition. Overlapping VARC records, already malformed per the CFF INDEX spec, now fail subsetting instead of being accepted; shaping and drawing are unaffected and valid VARC fonts subset to byte-identical output. Discovered by Anthropic's OSS Scanner, as vulnerability ANT-2026-71PGEDL2. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
586 lines
20 KiB
C
586 lines
20 KiB
C
/*
|
|
* 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 <math.h>
|
|
|
|
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 ();
|
|
}
|