Files
harfbuzz/test/api/test-subset-varc.c
Behdad EsfahbodandClaude Opus 4.8 9ddb3d0f24 [VARC] Bound the glyph records walked during subsetting to the INDEX size
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>
2026-11-09 13:17:50 -06:00

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 ();
}