mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-19 05:51:05 +01:00
* [subset] Charge Coverage and ClassDef glyph walks to a work budget Coverage::subset() expands a format 2 Coverage glyph by glyph, up to numGlyphs, every time an offset to it is subset, and nothing bounded that work. A 10-byte range Coverage referenced by 30,000 two-byte offsets in a subtable listed 8 times costs 1.6e10 iterator steps, while the sanitizer only bounds work by table bytes; a 60 KB font keeps hb-subset busy ~50 s. GDEF's MarkGlyphSets reaches the same walk with no feature or lookup needing to survive planning. Give hb_subset_context_t a per-table work budget (HB_BUDGET_SUBSET_TABLE, in the hb_budget_spend() idiom of hb-limits.hh) with a check_ops() helper that fails the serializer once exhausted, and charge Coverage::subset() its capped population before the walk. Charging inside Coverage::subset() covers every caller (ReverseChainSingleSubst, (Chain)ContextFormat3, GDEF MarkGlyphSets, ...) without touching them. The same unbounded per-reference pattern in ClassDefFormat1_3 / ClassDefFormat2_4::subset() (the range or glyphset walk and the glyph_filter count) is charged the same way. A hostile table that exceeds the budget now fails the subset cleanly (hb_subset_or_fail returns NULL) in a fraction of a second instead of succeeding slowly; valid-font output is byte-identical and the heaviest local table spends a small fraction of the budget. test_subset_shared_coverage_budget builds the reverse-chaining GSUB in memory and asserts 256 shared references subset while 2048 fail. Discovered by Anthropic's OSS Scanner, as vulnerability ANT-2026-LLIWV9UK. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * [subset] Charge layout glyph walks to the existing subset budget Drop the separate HB_BUDGET_SUBSET_TABLE budget and the second hb_subset_context_t field it needed; check_ops() now charges budget_remaining (HB_BUDGET_SUBSET_GLYF, 1 << 28), the per-table budget glyf instancing already uses. Both are per-table and shared across buffer-size retries, and no table spends both. The larger budget still bounds the attack (fails after 2^28 glyph steps, ~3 s), so test_subset_shared_coverage_budget now expects the failure at 8192 shared offsets instead of 2048. Subsetting all glyphs with --layout-features='*' of Gulzar, NotoSansKR-VF and GoogleSansFlex-VF keeps GSUB/GPOS/GDEF with output byte-identical to before; the heaviest table (Gulzar GPOS) spends ~98K units, under 0.04% of the budget. Full meson test: 278 OK. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
1847 lines
65 KiB
C
1847 lines
65 KiB
C
/*
|
|
* Copyright © 2018 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.
|
|
*
|
|
* Google Author(s): Garret Rieger
|
|
*/
|
|
|
|
#include "hb-test.h"
|
|
#include "hb-subset-test.h"
|
|
|
|
#include <math.h>
|
|
|
|
/* Unit tests for hb-subset-glyf.h */
|
|
|
|
static void
|
|
test_subset_32_tables (void)
|
|
{
|
|
hb_face_t *face = hb_test_open_font_file ("../fuzzing/fonts/oom-6ef8c96d3710262511bcc730dce9c00e722cb653");
|
|
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_t *codepoints = hb_subset_input_unicode_set (input);
|
|
hb_face_t *subset;
|
|
|
|
hb_set_add (codepoints, 'a');
|
|
hb_set_add (codepoints, 'b');
|
|
hb_set_add (codepoints, 'c');
|
|
|
|
subset = hb_subset_or_fail (face, input);
|
|
g_assert_true (!subset);
|
|
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (subset);
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
static void
|
|
test_subset_no_inf_loop (void)
|
|
{
|
|
hb_face_t *face = hb_test_open_font_file ("../fuzzing/fonts/clusterfuzz-testcase-minimized-hb-subset-fuzzer-5521982557782016");
|
|
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_t *codepoints = hb_subset_input_unicode_set (input);
|
|
hb_face_t *subset;
|
|
|
|
hb_set_add (codepoints, 'a');
|
|
hb_set_add (codepoints, 'b');
|
|
hb_set_add (codepoints, 'c');
|
|
|
|
subset = hb_subset_or_fail (face, input);
|
|
g_assert_true (!subset);
|
|
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (subset);
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
static void
|
|
test_subset_crash (void)
|
|
{
|
|
hb_face_t *face = hb_test_open_font_file ("../fuzzing/fonts/crash-4b60576767ee4d9fe1cc10959d89baf73d4e8249");
|
|
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_t *codepoints = hb_subset_input_unicode_set (input);
|
|
hb_face_t *subset;
|
|
|
|
hb_set_add (codepoints, 'a');
|
|
hb_set_add (codepoints, 'b');
|
|
hb_set_add (codepoints, 'c');
|
|
|
|
subset = hb_subset_or_fail (face, input);
|
|
g_assert_true (!subset);
|
|
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (subset);
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
static char *
|
|
_put16 (char *p, unsigned v)
|
|
{
|
|
*p++ = (char) (v >> 8);
|
|
*p++ = (char) (v & 0xFF);
|
|
return p;
|
|
}
|
|
|
|
/* A GSUB with one reverse-chaining lookup whose backtrack_count backtrack
|
|
* offsets all point at one Coverage holding the single range 0..range_last,
|
|
* in a face declaring 65535 glyphs. Each offset costs two bytes but makes
|
|
* the subsetter walk the whole range. */
|
|
static hb_face_t *
|
|
_create_shared_coverage_face (unsigned backtrack_count, unsigned range_last)
|
|
{
|
|
static const char cmap_data[] = {
|
|
0, 0, 0, 1, 0, 3, 0, 1, 0, 0, 0, 12,
|
|
0, 6, 0, 12, 0, 0, 0, 'a', 0, 1, 0, 1, /* format 6: 'a' -> glyph 1 */
|
|
};
|
|
static const char maxp_data[] = { 0, 0, 0x50, 0, (char) 0xFF, (char) 0xFF };
|
|
|
|
unsigned subtable_length = 12 + 2 * backtrack_count + 6 + 10;
|
|
unsigned gsub_length = 10 + 20 + 14 + 4 + 8 + subtable_length;
|
|
char *gsub = g_malloc (gsub_length);
|
|
char *p = gsub;
|
|
|
|
p = _put16 (p, 1); p = _put16 (p, 0);
|
|
p = _put16 (p, 10); p = _put16 (p, 30); p = _put16 (p, 44);
|
|
/* ScriptList: DFLT, default LangSys using feature 0. */
|
|
p = _put16 (p, 1); memcpy (p, "DFLT", 4); p += 4; p = _put16 (p, 8);
|
|
p = _put16 (p, 4); p = _put16 (p, 0);
|
|
p = _put16 (p, 0); p = _put16 (p, 0xFFFF); p = _put16 (p, 1); p = _put16 (p, 0);
|
|
/* FeatureList: calt, using lookup 0. */
|
|
p = _put16 (p, 1); memcpy (p, "calt", 4); p += 4; p = _put16 (p, 8);
|
|
p = _put16 (p, 0); p = _put16 (p, 1); p = _put16 (p, 0);
|
|
/* LookupList: one type 8 lookup with one subtable. */
|
|
p = _put16 (p, 1); p = _put16 (p, 4);
|
|
p = _put16 (p, 8); p = _put16 (p, 0); p = _put16 (p, 1); p = _put16 (p, 8);
|
|
/* ReverseChainSingleSubstFormat1 substituting glyph 1 by itself. */
|
|
p = _put16 (p, 1); p = _put16 (p, 12 + 2 * backtrack_count);
|
|
p = _put16 (p, backtrack_count);
|
|
for (unsigned i = 0; i < backtrack_count; i++)
|
|
p = _put16 (p, 12 + 2 * backtrack_count + 6);
|
|
p = _put16 (p, 0);
|
|
p = _put16 (p, 1); p = _put16 (p, 1);
|
|
p = _put16 (p, 1); p = _put16 (p, 1); p = _put16 (p, 1);
|
|
p = _put16 (p, 2); p = _put16 (p, 1); p = _put16 (p, 0); p = _put16 (p, range_last); p = _put16 (p, 0);
|
|
g_assert_cmpuint (p - gsub, ==, gsub_length);
|
|
|
|
hb_face_t *builder = hb_face_builder_create ();
|
|
hb_blob_t *blob = hb_blob_create (gsub, gsub_length, HB_MEMORY_MODE_WRITABLE, gsub, g_free);
|
|
hb_face_builder_add_table (builder, HB_TAG ('G','S','U','B'), blob);
|
|
hb_blob_destroy (blob);
|
|
HB_FACE_ADD_TABLE (builder, "cmap", cmap_data);
|
|
HB_FACE_ADD_TABLE (builder, "maxp", maxp_data);
|
|
|
|
blob = hb_face_reference_blob (builder);
|
|
hb_face_t *face = hb_face_create (blob, 0);
|
|
hb_blob_destroy (blob);
|
|
hb_face_destroy (builder);
|
|
return face;
|
|
}
|
|
|
|
static void
|
|
test_subset_shared_coverage_budget (void)
|
|
{
|
|
/* Walking 65535 glyphs per offset must run out of the per-table work
|
|
* budget (HB_BUDGET_SUBSET_GLYF) at 8192 offsets, but not at 256. */
|
|
static const struct { unsigned backtrack_count, range_last; hb_bool_t expected; } cases[] = {
|
|
{ 8192, 1, TRUE },
|
|
{ 256, 65534, TRUE },
|
|
{ 8192, 65534, FALSE },
|
|
};
|
|
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (cases); i++)
|
|
{
|
|
hb_face_t *face = _create_shared_coverage_face (cases[i].backtrack_count, cases[i].range_last);
|
|
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_add (hb_subset_input_unicode_set (input), 'a');
|
|
|
|
hb_face_t *subset = hb_subset_or_fail (face, input);
|
|
g_assert_true (!subset == !cases[i].expected);
|
|
if (subset)
|
|
{
|
|
hb_blob_t *gsub = hb_face_reference_table (subset, HB_TAG ('G','S','U','B'));
|
|
g_assert_cmpuint (hb_blob_get_length (gsub), >, 0);
|
|
hb_blob_destroy (gsub);
|
|
}
|
|
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (subset);
|
|
hb_face_destroy (face);
|
|
}
|
|
}
|
|
|
|
#ifndef HB_NO_VAR
|
|
static void
|
|
assert_lookup_variations_shape (hb_face_t *face,
|
|
const int *coords,
|
|
unsigned coord_count,
|
|
const hb_codepoint_t *expected)
|
|
{
|
|
hb_font_t *font = hb_font_create (face);
|
|
hb_font_set_var_coords_normalized (font, coords, coord_count);
|
|
|
|
hb_buffer_t *buffer = hb_buffer_create ();
|
|
hb_buffer_add_utf8 (buffer, "ABCDEF", -1, 0, -1);
|
|
hb_buffer_guess_segment_properties (buffer);
|
|
hb_shape (font, buffer, NULL, 0);
|
|
|
|
unsigned length;
|
|
const hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &length);
|
|
g_assert_cmpuint (length, ==, 6);
|
|
for (unsigned i = 0; i < length; i++)
|
|
g_assert_cmpuint (info[i].codepoint, ==, expected[i]);
|
|
|
|
hb_buffer_destroy (buffer);
|
|
hb_font_destroy (font);
|
|
}
|
|
|
|
static void
|
|
test_subset_lookup_variations (void)
|
|
{
|
|
hb_face_t *face = hb_test_open_font_file (
|
|
"../shape/data/in-house/fonts/4e9f0bc6a8f25b5fd3547bbc17423ce8cedb915f.ttf");
|
|
const hb_codepoint_t expected_all[] = {2, 4, 6, 8, 9, 10};
|
|
const hb_codepoint_t expected_test_08_dumy_08[] = {2, 3, 6, 8, 9, 10};
|
|
const hb_codepoint_t expected_test_03_dumy_0[] = {2, 4, 5, 7, 8, 11};
|
|
const hb_codepoint_t expected_test_03_dumy_08[] = {2, 3, 6, 7, 8, 11};
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
|
|
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
|
|
hb_set_t *features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
|
|
hb_set_clear (features);
|
|
hb_set_add (features, HB_TAG ('l', 'i', 'g', 'a'));
|
|
|
|
hb_face_t *subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
int coords[] = {13107}; /* 0.8 */
|
|
assert_lookup_variations_shape (subset, coords, 1, expected_all);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
|
|
input = hb_subset_input_create_or_fail ();
|
|
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
|
|
features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
|
|
hb_set_clear (features);
|
|
hb_set_add (features, HB_TAG ('l', 'i', 'g', 'a'));
|
|
g_assert_true (hb_subset_input_pin_axis_location (
|
|
input, face, HB_TAG ('T', 'E', 'S', 'T'), 0.8f));
|
|
g_assert_true (hb_subset_input_pin_axis_location (
|
|
input, face, HB_TAG ('D', 'U', 'M', 'Y'), 0.f));
|
|
|
|
subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
assert_lookup_variations_shape (subset, NULL, 0, expected_all);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
|
|
input = hb_subset_input_create_or_fail ();
|
|
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
|
|
features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
|
|
hb_set_clear (features);
|
|
hb_set_add (features, HB_TAG ('l', 'i', 'g', 'a'));
|
|
g_assert_true (hb_subset_input_pin_axis_location (
|
|
input, face, HB_TAG ('T', 'E', 'S', 'T'), 0.8f));
|
|
|
|
subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
coords[0] = 0;
|
|
assert_lookup_variations_shape (subset, coords, 1, expected_all);
|
|
coords[0] = 13107; /* DUMY=0.8 */
|
|
assert_lookup_variations_shape (
|
|
subset, coords, 1, expected_test_08_dumy_08);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
|
|
input = hb_subset_input_create_or_fail ();
|
|
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
|
|
features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
|
|
hb_set_clear (features);
|
|
hb_set_add (features, HB_TAG ('l', 'i', 'g', 'a'));
|
|
hb_set_add (features, HB_TAG ('r', 'l', 'i', 'g'));
|
|
g_assert_true (hb_subset_input_pin_axis_location (
|
|
input, face, HB_TAG ('T', 'E', 'S', 'T'), 0.3f));
|
|
|
|
subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
coords[0] = 0;
|
|
assert_lookup_variations_shape (
|
|
subset, coords, 1, expected_test_03_dumy_0);
|
|
coords[0] = 13107; /* DUMY=0.8 */
|
|
assert_lookup_variations_shape (
|
|
subset, coords, 1, expected_test_03_dumy_08);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
static void
|
|
assert_condition_instance_matches (hb_face_t *face, hb_face_t *subset,
|
|
const int *coords,
|
|
const int *subset_coords,
|
|
unsigned subset_coord_count)
|
|
{
|
|
hb_font_t *fonts[] = {hb_font_create (face), hb_font_create (subset)};
|
|
hb_buffer_t *buffers[] = {hb_buffer_create (), hb_buffer_create ()};
|
|
hb_font_set_var_coords_normalized (fonts[0], coords, 2);
|
|
hb_font_set_var_coords_normalized (fonts[1], subset_coords, subset_coord_count);
|
|
for (unsigned i = 0; i < 2; i++)
|
|
{
|
|
hb_buffer_add_utf8 (buffers[i], "ABCDEF", -1, 0, -1);
|
|
hb_buffer_guess_segment_properties (buffers[i]);
|
|
hb_shape (fonts[i], buffers[i], NULL, 0);
|
|
}
|
|
|
|
unsigned length, subset_length;
|
|
const hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffers[0], &length);
|
|
const hb_glyph_info_t *subset_info = hb_buffer_get_glyph_infos (buffers[1], &subset_length);
|
|
const hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffers[0], NULL);
|
|
const hb_glyph_position_t *subset_pos = hb_buffer_get_glyph_positions (buffers[1], NULL);
|
|
g_assert_cmpuint (length, ==, 6);
|
|
g_assert_cmpuint (subset_length, ==, length);
|
|
for (unsigned i = 0; i < length; i++)
|
|
{
|
|
g_assert_cmpuint (subset_info[i].codepoint, ==, info[i].codepoint);
|
|
g_assert_cmpint (subset_pos[i].x_advance, ==, pos[i].x_advance);
|
|
/* Numeric positioning deltas can round by one unit during instancing. */
|
|
g_assert_cmpint (abs (subset_pos[i].x_offset - pos[i].x_offset), <=, 1);
|
|
}
|
|
|
|
for (unsigned i = 0; i < 2; i++)
|
|
{
|
|
hb_buffer_destroy (buffers[i]);
|
|
hb_font_destroy (fonts[i]);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_subset_feature_variation_universal (void)
|
|
{
|
|
const char *filenames[] = {
|
|
"fonts/feature-variation-universal.ttf",
|
|
"fonts/feature-variation-universal-prefix.ttf"
|
|
};
|
|
const int widths[] = {-16384, 0, 9830, 13107, 16384};
|
|
for (unsigned f = 0; f < G_N_ELEMENTS (filenames); f++)
|
|
{
|
|
hb_face_t *face = hb_test_open_font_file (filenames[f]);
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_RETAIN_GIDS);
|
|
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
|
|
g_assert_true (hb_subset_input_pin_axis_location (
|
|
input, face, HB_TAG ('T', 'E', 'S', 'T'), 0.3f));
|
|
hb_face_t *subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (widths); i++)
|
|
{
|
|
int coords[] = {4915, widths[i]};
|
|
assert_condition_instance_matches (face, subset, coords, &widths[i], 1);
|
|
}
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (face);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_subset_lookup_variation_fractional_value (void)
|
|
{
|
|
hb_face_t *face = hb_test_open_font_file (
|
|
"../shape/data/in-house/fonts/4e9f0bc6a8f25b5fd3547bbc17423ce8cedb915f.ttf");
|
|
const float locations[] = {0.5f, 0.6f, 0.7f};
|
|
const int normalized[] = {8192, 9830, 11469};
|
|
const int test_coords[] = {4915, 13107};
|
|
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (locations); i++)
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_RETAIN_GIDS);
|
|
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
|
|
g_assert_true (hb_subset_input_pin_axis_location (
|
|
input, face, HB_TAG ('D', 'U', 'M', 'Y'), locations[i]));
|
|
hb_face_t *subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
for (unsigned j = 0; j < G_N_ELEMENTS (test_coords); j++)
|
|
{
|
|
int coords[] = {test_coords[j], normalized[i]};
|
|
assert_condition_instance_matches (face, subset, coords, &test_coords[j], 1);
|
|
}
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
static void
|
|
test_subset_condition_value_precision (void)
|
|
{
|
|
const char *filenames[] = {
|
|
"fonts/feature-variation-precision-GSUB-legacy.ttf",
|
|
"fonts/feature-variation-precision-GSUB-lookup.ttf",
|
|
"fonts/feature-variation-precision-GPOS-legacy.ttf",
|
|
"fonts/feature-variation-precision-GPOS-lookup.ttf",
|
|
"fonts/feature-variation-precision-GSUB-legacy-large.ttf",
|
|
"fonts/feature-variation-precision-GSUB-lookup-large.ttf",
|
|
"fonts/feature-variation-precision-GPOS-legacy-large.ttf",
|
|
"fonts/feature-variation-precision-GPOS-lookup-large.ttf",
|
|
"fonts/feature-variation-precision-GSUB-legacy-third.ttf",
|
|
"fonts/feature-variation-precision-GSUB-lookup-third.ttf",
|
|
"fonts/feature-variation-precision-GPOS-legacy-third.ttf",
|
|
"fonts/feature-variation-precision-GPOS-lookup-third.ttf",
|
|
"fonts/feature-variation-precision-GSUB-legacy-large-third.ttf",
|
|
"fonts/feature-variation-precision-GSUB-lookup-large-third.ttf",
|
|
"fonts/feature-variation-precision-GPOS-legacy-large-third.ttf",
|
|
"fonts/feature-variation-precision-GPOS-lookup-large-third.ttf",
|
|
"fonts/feature-variation-precision-GSUB-legacy-avar2.ttf",
|
|
"fonts/feature-variation-precision-GSUB-lookup-avar2.ttf",
|
|
"fonts/feature-variation-precision-GPOS-legacy-avar2.ttf",
|
|
"fonts/feature-variation-precision-GPOS-lookup-avar2.ttf"
|
|
};
|
|
const hb_tag_t tags[] = {HB_TAG ('T','E','S','T'), HB_TAG ('D','U','M','Y')};
|
|
const int locations[] = {-8192, 0, 1, 2048, 4096, 5461, 5462,
|
|
8192, 12288, 16383, 16384};
|
|
for (unsigned f = 0; f < G_N_ELEMENTS (filenames); f++)
|
|
{
|
|
g_test_message ("Font: %s", filenames[f]);
|
|
hb_face_t *face = hb_test_open_font_file (filenames[f]);
|
|
if (strstr (filenames[f], "large-third"))
|
|
{
|
|
hb_font_t *font = hb_font_create (face);
|
|
hb_buffer_t *buffer = hb_buffer_create ();
|
|
const int coords[] = {1, 16384};
|
|
hb_font_set_var_coords_normalized (font, coords, 2);
|
|
hb_buffer_add_utf8 (buffer, "AB", -1, 0, -1);
|
|
hb_buffer_guess_segment_properties (buffer);
|
|
hb_shape (font, buffer, NULL, 0);
|
|
unsigned length;
|
|
const hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &length);
|
|
const hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, NULL);
|
|
g_assert_cmpuint (length, ==, 2);
|
|
/* 32767 + 1/12288 - 32767 is positive, even though float addition
|
|
* loses the fractional residual next to the large default. */
|
|
if (strstr (filenames[f], "-GSUB-"))
|
|
g_assert_cmpuint (info[1].codepoint, ==, 4);
|
|
else
|
|
g_assert_cmpint (pos[1].x_advance, ==, 620);
|
|
hb_buffer_destroy (buffer);
|
|
hb_font_destroy (font);
|
|
}
|
|
for (unsigned pinned = 0; pinned < 2; pinned++)
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (locations); i++)
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_RETAIN_GIDS);
|
|
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
|
|
g_assert_true (hb_subset_input_pin_axis_location (
|
|
input, face, tags[pinned], locations[i] / 16384.f));
|
|
hb_face_t *subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
for (unsigned j = 0; j < G_N_ELEMENTS (locations); j++)
|
|
{
|
|
int coords[] = {0, 0};
|
|
coords[pinned] = locations[i];
|
|
coords[1 - pinned] = locations[j];
|
|
assert_condition_instance_matches (face, subset, coords, &locations[j], 1);
|
|
/* A private bias region must survive instancing the font again. */
|
|
hb_subset_input_t *static_input = hb_subset_input_create_or_fail ();
|
|
hb_subset_input_set_flags (static_input, HB_SUBSET_FLAGS_RETAIN_GIDS);
|
|
hb_set_add_range (hb_subset_input_unicode_set (static_input), 'A', 'F');
|
|
g_assert_true (hb_subset_input_pin_axis_location (
|
|
static_input, subset, tags[1 - pinned], locations[j] / 16384.f));
|
|
hb_face_t *static_subset = hb_subset_or_fail (subset, static_input);
|
|
g_assert_nonnull (static_subset);
|
|
assert_condition_instance_matches (face, static_subset, coords, NULL, 0);
|
|
hb_face_destroy (static_subset);
|
|
hb_subset_input_destroy (static_input);
|
|
}
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
hb_face_destroy (face);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_subset_feature_variation_conditions (void)
|
|
{
|
|
hb_face_t *face = hb_test_open_font_file ("fonts/feature-variation-conditions.ttf");
|
|
const float locations[] = {-0.8f, -0.6f, 0.f, 0.3f, 0.6f, 0.8f};
|
|
const int normalized[] = {-13107, -9830, 0, 4915, 9830, 13107};
|
|
const hb_tag_t tags[] = {HB_TAG ('T','E','S','T'), HB_TAG ('D','U','M','Y')};
|
|
const int original_coords[][2] = {{0, 0}, {4915, 0}, {4915, 13107},
|
|
{13107, -13107}, {4915, -9830}};
|
|
const hb_codepoint_t expected[][6] = {
|
|
{2, 3, 5, 7, 9, 11}, {2, 4, 5, 7, 9, 11}, {2, 3, 6, 7, 9, 11},
|
|
{2, 3, 5, 7, 9, 12}, {2, 3, 5, 8, 9, 11}
|
|
};
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (original_coords); i++)
|
|
assert_lookup_variations_shape (face, original_coords[i], 2, expected[i]);
|
|
|
|
for (unsigned pinned = 0; pinned < 3; pinned++)
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (locations); i++)
|
|
for (unsigned j = 0; j < (pinned == 2 ? G_N_ELEMENTS (locations) : 1); j++)
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_RETAIN_GIDS);
|
|
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
|
|
if (pinned == 2)
|
|
{
|
|
g_assert_true (hb_subset_input_pin_axis_location (input, face, tags[0], locations[i]));
|
|
g_assert_true (hb_subset_input_pin_axis_location (input, face, tags[1], locations[j]));
|
|
}
|
|
else
|
|
g_assert_true (hb_subset_input_pin_axis_location (input, face, tags[pinned], locations[i]));
|
|
|
|
hb_face_t *subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
if (pinned == 2)
|
|
{
|
|
int coords[] = {normalized[i], normalized[j]};
|
|
assert_condition_instance_matches (face, subset, coords, NULL, 0);
|
|
}
|
|
else
|
|
for (unsigned k = 0; k < G_N_ELEMENTS (locations); k++)
|
|
{
|
|
int coords[] = {0, 0};
|
|
coords[pinned] = normalized[i];
|
|
coords[1 - pinned] = normalized[k];
|
|
assert_condition_instance_matches (face, subset, coords, &normalized[k], 1);
|
|
}
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
hb_face_destroy (face);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
test_subset_set_flags (void)
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
|
|
g_assert_true (hb_subset_input_get_flags (input) == HB_SUBSET_FLAGS_DEFAULT);
|
|
|
|
hb_subset_input_set_flags (input,
|
|
HB_SUBSET_FLAGS_NAME_LEGACY |
|
|
HB_SUBSET_FLAGS_NOTDEF_OUTLINE |
|
|
HB_SUBSET_FLAGS_GLYPH_NAMES);
|
|
|
|
g_assert_true (hb_subset_input_get_flags (input) ==
|
|
(hb_subset_flags_t) (
|
|
HB_SUBSET_FLAGS_NAME_LEGACY |
|
|
HB_SUBSET_FLAGS_NOTDEF_OUTLINE |
|
|
HB_SUBSET_FLAGS_GLYPH_NAMES));
|
|
|
|
hb_subset_input_set_flags (input,
|
|
HB_SUBSET_FLAGS_NAME_LEGACY |
|
|
HB_SUBSET_FLAGS_NOTDEF_OUTLINE |
|
|
HB_SUBSET_FLAGS_NO_PRUNE_UNICODE_RANGES);
|
|
|
|
g_assert_true (hb_subset_input_get_flags (input) ==
|
|
(hb_subset_flags_t) (
|
|
HB_SUBSET_FLAGS_NAME_LEGACY |
|
|
HB_SUBSET_FLAGS_NOTDEF_OUTLINE |
|
|
HB_SUBSET_FLAGS_NO_PRUNE_UNICODE_RANGES));
|
|
|
|
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
|
|
static void
|
|
test_subset_sets (void)
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_t* set = hb_set_create ();
|
|
|
|
hb_set_add (hb_subset_input_set (input, HB_SUBSET_SETS_GLYPH_INDEX), 83);
|
|
hb_set_add (hb_subset_input_set (input, HB_SUBSET_SETS_UNICODE), 85);
|
|
|
|
hb_set_clear (hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG));
|
|
hb_set_add (hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG), 87);
|
|
|
|
hb_set_add (set, 83);
|
|
g_assert_true (hb_set_is_equal (hb_subset_input_glyph_set (input), set));
|
|
hb_set_clear (set);
|
|
|
|
hb_set_add (set, 85);
|
|
g_assert_true (hb_set_is_equal (hb_subset_input_unicode_set (input), set));
|
|
hb_set_clear (set);
|
|
|
|
hb_set_add (set, 87);
|
|
g_assert_true (hb_set_is_equal (hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG), set));
|
|
hb_set_clear (set);
|
|
|
|
hb_set_destroy (set);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
static void
|
|
test_subset_plan (void)
|
|
{
|
|
hb_face_t *face_abc = hb_test_open_font_file ("fonts/Roboto-Regular.abc.ttf");
|
|
hb_face_t *face_ac = hb_test_open_font_file ("fonts/Roboto-Regular.ac.ttf");
|
|
|
|
hb_set_t *codepoints = hb_set_create();
|
|
hb_set_add (codepoints, 97);
|
|
hb_set_add (codepoints, 99);
|
|
hb_subset_input_t* input = hb_subset_test_create_input (codepoints);
|
|
hb_set_destroy (codepoints);
|
|
|
|
hb_subset_plan_t* plan = hb_subset_plan_create_or_fail (face_abc, input);
|
|
g_assert_true (plan);
|
|
|
|
const hb_map_t* mapping = hb_subset_plan_old_to_new_glyph_mapping (plan);
|
|
g_assert_true (hb_map_get (mapping, 1) == 1);
|
|
g_assert_true (hb_map_get (mapping, 3) == 2);
|
|
|
|
mapping = hb_subset_plan_new_to_old_glyph_mapping (plan);
|
|
g_assert_true (hb_map_get (mapping, 1) == 1);
|
|
g_assert_true (hb_map_get (mapping, 2) == 3);
|
|
|
|
mapping = hb_subset_plan_unicode_to_old_glyph_mapping (plan);
|
|
g_assert_true (hb_map_get (mapping, 0x63) == 3);
|
|
|
|
hb_face_t* face_abc_subset = hb_subset_plan_execute_or_fail (plan);
|
|
|
|
hb_subset_test_check (face_ac, face_abc_subset, HB_TAG ('l','o','c', 'a'));
|
|
hb_subset_test_check (face_ac, face_abc_subset, HB_TAG ('g','l','y','f'));
|
|
|
|
hb_subset_input_destroy (input);
|
|
hb_subset_plan_destroy (plan);
|
|
hb_face_destroy (face_abc_subset);
|
|
hb_face_destroy (face_abc);
|
|
hb_face_destroy (face_ac);
|
|
}
|
|
|
|
#ifndef HB_NO_SUBSET_LAYOUT
|
|
static void
|
|
test_subset_unsupported_layout_table_retains_gids (void)
|
|
{
|
|
hb_face_t *face = hb_test_open_font_file ("fonts/aat-morx.ttf");
|
|
hb_tag_t morx = HB_TAG ('m', 'o', 'r', 'x');
|
|
|
|
const struct {
|
|
bool drop_morx;
|
|
bool passthrough;
|
|
unsigned expected_num_glyphs;
|
|
unsigned expected_gid_a;
|
|
bool expected_morx;
|
|
} tests[] = {
|
|
/* morx is retained; glyph ids must not be renumbered. */
|
|
{false, true, 3, 2, true},
|
|
/* morx is dropped; glyph ids are renumbered as usual. */
|
|
{true, true, 2, 1, false},
|
|
/* morx is kept but not passed through, so it is dropped. */
|
|
{false, false, 2, 1, false},
|
|
};
|
|
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (tests); i++)
|
|
{
|
|
hb_set_t *codepoints = hb_set_create ();
|
|
hb_set_add (codepoints, 'A');
|
|
hb_subset_input_t *input = hb_subset_test_create_input (codepoints);
|
|
hb_set_destroy (codepoints);
|
|
|
|
if (!tests[i].drop_morx)
|
|
hb_set_del (hb_subset_input_set (input, HB_SUBSET_SETS_DROP_TABLE_TAG), morx);
|
|
if (tests[i].passthrough)
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_PASSTHROUGH_UNRECOGNIZED);
|
|
|
|
hb_subset_plan_t *plan = hb_subset_plan_create_or_fail (face, input);
|
|
g_assert_nonnull (plan);
|
|
g_assert_cmpuint (hb_map_get (hb_subset_plan_old_to_new_glyph_mapping (plan), 2),
|
|
==, tests[i].expected_gid_a);
|
|
|
|
hb_face_t *subset = hb_subset_plan_execute_or_fail (plan);
|
|
g_assert_nonnull (subset);
|
|
g_assert_cmpuint (hb_face_get_glyph_count (subset), ==, tests[i].expected_num_glyphs);
|
|
|
|
hb_blob_t *morx_blob = hb_face_reference_table (subset, morx);
|
|
g_assert_true (!!hb_blob_get_length (morx_blob) == tests[i].expected_morx);
|
|
hb_blob_destroy (morx_blob);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_plan_destroy (plan);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
static void
|
|
test_subset_graphite_table_retains_gids (void)
|
|
{
|
|
hb_face_t *face = hb_test_open_font_file ("fonts/graphite2-expansion.ttf");
|
|
static const hb_tag_t graphite_tables[] = {
|
|
HB_TAG ('G', 'l', 'a', 't'),
|
|
HB_TAG ('G', 'l', 'o', 'c'),
|
|
HB_TAG ('S', 'i', 'l', 'f'),
|
|
};
|
|
|
|
for (unsigned retain = 0; retain < 2; retain++)
|
|
{
|
|
hb_set_t *glyphs = hb_set_create ();
|
|
hb_set_add (glyphs, 2);
|
|
hb_subset_input_t *input = hb_subset_test_create_input_from_glyphs (glyphs);
|
|
hb_set_destroy (glyphs);
|
|
|
|
if (retain)
|
|
{
|
|
hb_set_t *drop_tables = hb_subset_input_set (input, HB_SUBSET_SETS_DROP_TABLE_TAG);
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (graphite_tables); i++)
|
|
hb_set_del (drop_tables, graphite_tables[i]);
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_PASSTHROUGH_UNRECOGNIZED);
|
|
}
|
|
|
|
hb_subset_plan_t *plan = hb_subset_plan_create_or_fail (face, input);
|
|
g_assert_nonnull (plan);
|
|
g_assert_cmpuint (hb_map_get (hb_subset_plan_old_to_new_glyph_mapping (plan), 2),
|
|
==, retain ? 2 : 1);
|
|
|
|
hb_face_t *subset = hb_subset_plan_execute_or_fail (plan);
|
|
g_assert_nonnull (subset);
|
|
g_assert_cmpuint (hb_face_get_glyph_count (subset), ==, retain ? 3 : 2);
|
|
|
|
hb_blob_t *silf = hb_face_reference_table (subset, HB_TAG ('S', 'i', 'l', 'f'));
|
|
g_assert_true (!!hb_blob_get_length (silf) == retain);
|
|
hb_blob_destroy (silf);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_plan_destroy (plan);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
static const char synthetic_table_data[] = {0, 1, 0, 0};
|
|
|
|
static hb_face_t *
|
|
_face_with_synthetic_table (hb_face_t *source, hb_tag_t tag)
|
|
{
|
|
hb_face_t *face = hb_face_builder_create ();
|
|
|
|
hb_tag_t tags[32];
|
|
unsigned offset = 0;
|
|
while (true)
|
|
{
|
|
unsigned count = G_N_ELEMENTS (tags);
|
|
hb_face_get_table_tags (source, offset, &count, tags);
|
|
if (!count) break;
|
|
|
|
for (unsigned i = 0; i < count; i++)
|
|
{
|
|
hb_blob_t *blob = hb_face_reference_table (source, tags[i]);
|
|
hb_face_builder_add_table (face, tags[i], blob);
|
|
hb_blob_destroy (blob);
|
|
}
|
|
offset += count;
|
|
}
|
|
|
|
hb_blob_t *blob = hb_blob_create_or_fail (synthetic_table_data,
|
|
sizeof (synthetic_table_data),
|
|
HB_MEMORY_MODE_READONLY, NULL, NULL);
|
|
hb_face_builder_add_table (face, tag, blob);
|
|
hb_blob_destroy (blob);
|
|
|
|
return face;
|
|
}
|
|
|
|
static void
|
|
test_subset_unsubsettable_glyph_tables (void)
|
|
{
|
|
/* These tables must be passed through byte-for-byte. If a subsetter is added
|
|
* for one of them this test fails, since the new handler will reject or
|
|
* rewrite the synthetic data, and the tag should be removed from
|
|
* hb-subset-plan.cc's unsubsettable_glyph_tables[]. */
|
|
static const hb_tag_t tags[] = {
|
|
HB_TAG ('E', 'B', 'D', 'T'),
|
|
HB_TAG ('E', 'B', 'L', 'C'),
|
|
HB_TAG ('J', 'S', 'T', 'F'),
|
|
HB_TAG ('L', 'T', 'S', 'H'),
|
|
HB_TAG ('S', 'V', 'G', ' '),
|
|
HB_TAG ('Z', 'a', 'p', 'f'),
|
|
HB_TAG ('b', 'd', 'a', 't'),
|
|
HB_TAG ('b', 'l', 'o', 'c'),
|
|
HB_TAG ('g', 'c', 'i', 'd'),
|
|
HB_TAG ('h', 'v', 'g', 'l'),
|
|
HB_TAG ('h', 'v', 'p', 'm'),
|
|
HB_TAG ('a', 'n', 'k', 'r'),
|
|
HB_TAG ('b', 's', 'l', 'n'),
|
|
HB_TAG ('j', 'u', 's', 't'),
|
|
HB_TAG ('k', 'e', 'r', 'n'),
|
|
HB_TAG ('k', 'e', 'r', 'x'),
|
|
HB_TAG ('l', 'c', 'a', 'r'),
|
|
HB_TAG ('m', 'o', 'r', 't'),
|
|
HB_TAG ('m', 'o', 'r', 'x'),
|
|
HB_TAG ('o', 'p', 'b', 'd'),
|
|
HB_TAG ('p', 'r', 'o', 'p'),
|
|
HB_TAG ('G', 'l', 'a', 't'),
|
|
HB_TAG ('G', 'l', 'o', 'c'),
|
|
HB_TAG ('S', 'i', 'l', 'f'),
|
|
};
|
|
hb_face_t *source = hb_test_open_font_file ("fonts/Roboto-Regular.abc.ttf");
|
|
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (tags); i++)
|
|
{
|
|
hb_face_t *face = _face_with_synthetic_table (source, tags[i]);
|
|
|
|
hb_set_t *glyphs = hb_set_create ();
|
|
hb_set_add (glyphs, 3);
|
|
hb_subset_input_t *input = hb_subset_test_create_input_from_glyphs (glyphs);
|
|
hb_set_destroy (glyphs);
|
|
hb_set_del (hb_subset_input_set (input, HB_SUBSET_SETS_DROP_TABLE_TAG), tags[i]);
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_PASSTHROUGH_UNRECOGNIZED);
|
|
|
|
hb_subset_plan_t *plan = hb_subset_plan_create_or_fail (face, input);
|
|
g_assert_nonnull (plan);
|
|
g_assert_cmpuint (hb_map_get (hb_subset_plan_old_to_new_glyph_mapping (plan), 3),
|
|
==, 3);
|
|
|
|
hb_face_t *subset = hb_subset_plan_execute_or_fail (plan);
|
|
g_assert_nonnull (subset);
|
|
g_assert_cmpuint (hb_face_get_glyph_count (subset), ==, 4);
|
|
|
|
hb_blob_t *blob = hb_face_reference_table (subset, tags[i]);
|
|
unsigned length;
|
|
const char *data = hb_blob_get_data (blob, &length);
|
|
g_assert_cmpmem (data, length, synthetic_table_data, sizeof (synthetic_table_data));
|
|
hb_blob_destroy (blob);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_plan_destroy (plan);
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
hb_face_destroy (source);
|
|
}
|
|
|
|
static void
|
|
test_subset_non_glyph_layout_table_does_not_retain_gids (void)
|
|
{
|
|
/* aat-trak.ttf has both morx and trak. morx is dropped by default, leaving
|
|
* only trak, which does not refer to glyphs, so ids are renumbered. */
|
|
hb_face_t *face = hb_test_open_font_file ("fonts/aat-trak.ttf");
|
|
hb_tag_t trak = HB_TAG ('t', 'r', 'a', 'k');
|
|
|
|
hb_set_t *codepoints = hb_set_create ();
|
|
hb_set_add (codepoints, 'C');
|
|
hb_subset_input_t *input = hb_subset_test_create_input (codepoints);
|
|
hb_set_destroy (codepoints);
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_PASSTHROUGH_UNRECOGNIZED);
|
|
|
|
hb_subset_plan_t *plan = hb_subset_plan_create_or_fail (face, input);
|
|
g_assert_nonnull (plan);
|
|
g_assert_cmpuint (hb_map_get (hb_subset_plan_old_to_new_glyph_mapping (plan), 4),
|
|
==, 1);
|
|
|
|
hb_face_t *subset = hb_subset_plan_execute_or_fail (plan);
|
|
g_assert_nonnull (subset);
|
|
g_assert_cmpuint (hb_face_get_glyph_count (subset), ==, 2);
|
|
|
|
hb_blob_t *trak_blob = hb_face_reference_table (subset, trak);
|
|
g_assert_cmpuint (hb_blob_get_length (trak_blob), >, 0);
|
|
hb_blob_destroy (trak_blob);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_plan_destroy (plan);
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (face);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
test_subset_custom_glyph_mapping (void)
|
|
{
|
|
/* old gid, new gid, last retained gid, expected output glyph count */
|
|
static const unsigned tests[][4] = {
|
|
{2, 1, 3, 4},
|
|
{0, 0, 3, 4},
|
|
{0, 17, 3, 4}, /* .notdef always stays at 0. */
|
|
{1, 300, 3, 303},
|
|
{2, 0, 3, 0},
|
|
{1, 0xFFFFFFu, 1, 0}, /* The count, including .notdef, exceeds 24 bits. */
|
|
{2, 0xFFFFFEu, 3, 0}, /* No room for the unmapped glyphs. */
|
|
{2, 0x7FFFFFFFu, 3, 0},
|
|
{2, 0xFFFFFFFEu, 3, 0},
|
|
};
|
|
hb_face_t *source = hb_test_open_font_file ("fonts/Roboto-Regular.abc.ttf");
|
|
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (tests); i++)
|
|
{
|
|
hb_set_t *glyphs = hb_set_create ();
|
|
hb_set_add_range (glyphs, 0, tests[i][2]);
|
|
hb_subset_input_t *input = hb_subset_test_create_input_from_glyphs (glyphs);
|
|
hb_set_destroy (glyphs);
|
|
hb_map_set (hb_subset_input_old_to_new_glyph_mapping (input), tests[i][0], tests[i][1]);
|
|
|
|
hb_face_t *subset = hb_subset_or_fail (source, input);
|
|
if (tests[i][3])
|
|
{
|
|
g_assert_nonnull (subset);
|
|
g_assert_cmpuint (hb_face_get_glyph_count (subset), ==, tests[i][3]);
|
|
}
|
|
else
|
|
g_assert_null (subset);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
hb_face_destroy (source);
|
|
}
|
|
|
|
static hb_face_t *
|
|
_face_copy_tables (hb_face_t *source)
|
|
{
|
|
hb_face_t *face = hb_face_builder_create ();
|
|
|
|
hb_tag_t tags[32];
|
|
unsigned offset = 0;
|
|
while (true)
|
|
{
|
|
unsigned count = G_N_ELEMENTS (tags);
|
|
hb_face_get_table_tags (source, offset, &count, tags);
|
|
if (!count) break;
|
|
|
|
for (unsigned i = 0; i < count; i++)
|
|
{
|
|
hb_blob_t *blob = hb_face_reference_table (source, tags[i]);
|
|
hb_face_builder_add_table (face, tags[i], blob);
|
|
hb_blob_destroy (blob);
|
|
}
|
|
offset += count;
|
|
}
|
|
|
|
return face;
|
|
}
|
|
|
|
static hb_face_t *
|
|
_face_with_table (hb_face_t *source, hb_tag_t tag, const void *data, unsigned length)
|
|
{
|
|
hb_face_t *face = _face_copy_tables (source);
|
|
hb_blob_t *blob = hb_blob_create_or_fail ((const char *) data, length,
|
|
HB_MEMORY_MODE_READONLY, NULL, NULL);
|
|
hb_face_builder_add_table (face, tag, blob);
|
|
hb_blob_destroy (blob);
|
|
|
|
return face;
|
|
}
|
|
|
|
static hb_face_t *
|
|
_face_with_name_table_and_wws (hb_face_t *source,
|
|
const void *name_data, unsigned name_length,
|
|
bool wws)
|
|
{
|
|
hb_face_t *face = _face_copy_tables (source);
|
|
|
|
hb_blob_t *name_blob = hb_blob_create_or_fail ((const char *) name_data,
|
|
name_length,
|
|
HB_MEMORY_MODE_READONLY,
|
|
NULL, NULL);
|
|
g_assert_nonnull (name_blob);
|
|
hb_face_builder_add_table (face, HB_TAG ('n','a','m','e'), name_blob);
|
|
hb_blob_destroy (name_blob);
|
|
|
|
hb_blob_t *os2 = hb_face_reference_table (source, HB_TAG ('O','S','/','2'));
|
|
hb_blob_t *os2_copy = hb_blob_copy_writable_or_fail (os2);
|
|
hb_blob_destroy (os2);
|
|
g_assert_nonnull (os2_copy);
|
|
|
|
unsigned length;
|
|
char *data = (char *) hb_blob_get_data_writable (os2_copy, &length);
|
|
g_assert_cmpuint (length, >=, 64);
|
|
/* fsSelection is at offset 62 in OS/2 version 0 and later. */
|
|
uint16_t fs_selection = ((uint8_t) data[62] << 8) | (uint8_t) data[63];
|
|
if (wws)
|
|
fs_selection |= 1u << 8;
|
|
else
|
|
fs_selection &= ~(1u << 8);
|
|
data[62] = fs_selection >> 8;
|
|
data[63] = fs_selection;
|
|
|
|
hb_face_builder_add_table (face, HB_TAG ('O','S','/','2'), os2_copy);
|
|
hb_blob_destroy (os2_copy);
|
|
|
|
return face;
|
|
}
|
|
|
|
static hb_blob_t *
|
|
_blob_with_checksum (uint32_t checksum, unsigned length)
|
|
{
|
|
char *data = (char *) g_malloc0 (length ? length : 1);
|
|
if (length >= 4)
|
|
{
|
|
data[0] = checksum >> 24;
|
|
data[1] = checksum >> 16;
|
|
data[2] = checksum >> 8;
|
|
data[3] = checksum;
|
|
}
|
|
return hb_blob_create_or_fail (data, length, HB_MEMORY_MODE_WRITABLE,
|
|
data, g_free);
|
|
}
|
|
|
|
static void
|
|
test_subset_no_hinting_ignored_for_hint_dependent_font (void)
|
|
{
|
|
#ifndef HB_NO_NAME
|
|
/* Minimal name table with Font Family = "MingLiU". */
|
|
static const unsigned char name_table[] = {
|
|
0x00, 0x00, 0x00, 0x01, 0x00, 0x12,
|
|
0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x01, 0x00, 0x0E, 0x00, 0x00,
|
|
0x00, 0x4D, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67,
|
|
0x00, 0x4C, 0x00, 0x69, 0x00, 0x55,
|
|
};
|
|
/* "HuaTianKaiTi" followed by U+4F53. FreeType reads the non-ASCII
|
|
* character as `?`, matching the list entry "HuaTianKaiTi?". */
|
|
static const unsigned char name_table_question[] = {
|
|
0x00, 0x00, 0x00, 0x01, 0x00, 0x12,
|
|
0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x01, 0x00, 0x1A, 0x00, 0x00,
|
|
0x00, 0x48, 0x00, 0x75, 0x00, 0x61, 0x00, 0x54,
|
|
0x00, 0x69, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x4B,
|
|
0x00, 0x61, 0x00, 0x69, 0x00, 0x54, 0x00, 0x69,
|
|
0x4F, 0x53,
|
|
};
|
|
static const hb_tag_t hint_tags[] = {
|
|
HB_TAG ('c','v','t',' '),
|
|
HB_TAG ('f','p','g','m'),
|
|
HB_TAG ('p','r','e','p'),
|
|
};
|
|
|
|
hb_face_t *source = hb_test_open_font_file ("fonts/Roboto-Regular.abc.ttf");
|
|
hb_face_t *face = _face_with_table (source, HB_TAG ('n','a','m','e'),
|
|
name_table, sizeof (name_table));
|
|
hb_face_t *face_question = _face_with_table (source, HB_TAG ('n','a','m','e'),
|
|
name_table_question,
|
|
sizeof (name_table_question));
|
|
|
|
hb_set_t *codepoints = hb_set_create ();
|
|
hb_set_add (codepoints, 'a');
|
|
|
|
for (unsigned i = 0; i < 3; i++)
|
|
{
|
|
bool hint_dependent = i != 0;
|
|
hb_face_t *target = i == 0 ? source : i == 1 ? face : face_question;
|
|
|
|
hb_subset_input_t *input = hb_subset_test_create_input (codepoints);
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_NO_HINTING);
|
|
hb_face_t *subset = hb_subset_or_fail (target, input);
|
|
g_assert_nonnull (subset);
|
|
|
|
for (unsigned j = 0; j < G_N_ELEMENTS (hint_tags); j++)
|
|
{
|
|
hb_blob_t *blob = hb_face_reference_table (subset, hint_tags[j]);
|
|
g_assert_true (!!hb_blob_get_length (blob) == hint_dependent);
|
|
hb_blob_destroy (blob);
|
|
}
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
hb_set_destroy (codepoints);
|
|
hb_face_destroy (face_question);
|
|
hb_face_destroy (face);
|
|
hb_face_destroy (source);
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
test_subset_no_hinting_hint_dependent_wws_family (void)
|
|
{
|
|
#ifndef HB_NO_NAME
|
|
/* Font Family = "NotTricky", Typographic Family = "MingLiU", and
|
|
* WWS Family = "NotTricky". With the OS/2 WWS bit set FreeType
|
|
* picks the typographic family and keeps hints; with it clear it
|
|
* picks the WWS family and must not fall through to the typographic
|
|
* one. */
|
|
static const unsigned char name_table[] = {
|
|
0x00, 0x00, 0x00, 0x03, 0x00, 0x2A,
|
|
0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x01, 0x00, 0x12, 0x00, 0x00,
|
|
0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x10, 0x00, 0x0E, 0x00, 0x12,
|
|
0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x15, 0x00, 0x12, 0x00, 0x20,
|
|
0x00, 0x4E, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x54, 0x00, 0x72, 0x00, 0x69,
|
|
0x00, 0x63, 0x00, 0x6B, 0x00, 0x79, 0x00, 0x4D, 0x00, 0x69, 0x00, 0x6E,
|
|
0x00, 0x67, 0x00, 0x4C, 0x00, 0x69, 0x00, 0x55, 0x00, 0x4E, 0x00, 0x6F,
|
|
0x00, 0x74, 0x00, 0x54, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x6B,
|
|
0x00, 0x79,
|
|
};
|
|
static const hb_tag_t hint_tags[] = {
|
|
HB_TAG ('c','v','t',' '),
|
|
HB_TAG ('f','p','g','m'),
|
|
HB_TAG ('p','r','e','p'),
|
|
};
|
|
|
|
hb_face_t *source = hb_test_open_font_file ("fonts/Roboto-Regular.abc.ttf");
|
|
hb_face_t *wws = _face_with_name_table_and_wws (source, name_table,
|
|
sizeof (name_table), true);
|
|
hb_face_t *no_wws = _face_with_name_table_and_wws (source, name_table,
|
|
sizeof (name_table), false);
|
|
|
|
hb_set_t *codepoints = hb_set_create ();
|
|
hb_set_add (codepoints, 'a');
|
|
|
|
for (unsigned i = 0; i < 2; i++)
|
|
{
|
|
bool hint_dependent = i == 0;
|
|
hb_face_t *target = i == 0 ? wws : no_wws;
|
|
|
|
hb_subset_input_t *input = hb_subset_test_create_input (codepoints);
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_NO_HINTING);
|
|
hb_face_t *subset = hb_subset_or_fail (target, input);
|
|
g_assert_nonnull (subset);
|
|
|
|
for (unsigned j = 0; j < G_N_ELEMENTS (hint_tags); j++)
|
|
{
|
|
hb_blob_t *blob = hb_face_reference_table (subset, hint_tags[j]);
|
|
g_assert_true (!!hb_blob_get_length (blob) == hint_dependent);
|
|
hb_blob_destroy (blob);
|
|
}
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
hb_set_destroy (codepoints);
|
|
hb_face_destroy (no_wws);
|
|
hb_face_destroy (wws);
|
|
hb_face_destroy (source);
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
test_subset_no_hinting_ignored_for_hint_dependent_ids (void)
|
|
{
|
|
static const struct {
|
|
hb_tag_t tag;
|
|
uint32_t checksum;
|
|
unsigned length;
|
|
} ids[] = {
|
|
{HB_TAG ('c','v','t',' '), 0x05BCF058, 0x000002E4},
|
|
{HB_TAG ('f','p','g','m'), 0x28233BF1, 0x000087C4},
|
|
{HB_TAG ('p','r','e','p'), 0xA344A1EA, 0x000001E1},
|
|
};
|
|
static const hb_tag_t hint_tags[] = {
|
|
HB_TAG ('c','v','t',' '),
|
|
HB_TAG ('f','p','g','m'),
|
|
HB_TAG ('p','r','e','p'),
|
|
};
|
|
|
|
hb_face_t *source = hb_test_open_font_file ("fonts/Roboto-Regular.abc.ttf");
|
|
hb_face_t *face = _face_copy_tables (source);
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (ids); i++)
|
|
{
|
|
hb_blob_t *blob = _blob_with_checksum (ids[i].checksum, ids[i].length);
|
|
hb_face_builder_add_table (face, ids[i].tag, blob);
|
|
hb_blob_destroy (blob);
|
|
}
|
|
|
|
hb_set_t *codepoints = hb_set_create ();
|
|
hb_set_add (codepoints, 'a');
|
|
hb_subset_input_t *input = hb_subset_test_create_input (codepoints);
|
|
hb_set_destroy (codepoints);
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_NO_HINTING);
|
|
|
|
hb_face_t *subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (hint_tags); i++)
|
|
{
|
|
hb_blob_t *blob = hb_face_reference_table (subset, hint_tags[i]);
|
|
g_assert_cmpuint (hb_blob_get_length (blob), >, 0);
|
|
hb_blob_destroy (blob);
|
|
}
|
|
|
|
hb_face_destroy (subset);
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (face);
|
|
hb_face_destroy (source);
|
|
}
|
|
|
|
static hb_blob_t*
|
|
_copy_table (hb_face_t *face HB_UNUSED, hb_tag_t tag, void *user_data)
|
|
{
|
|
hb_blob_t *table = hb_face_reference_table ((hb_face_t*) user_data, tag);
|
|
hb_blob_t *copy = hb_blob_copy_writable_or_fail (table);
|
|
hb_blob_destroy (table);
|
|
return copy;
|
|
}
|
|
|
|
typedef struct {
|
|
hb_face_t *source;
|
|
hb_tag_t tag;
|
|
unsigned references;
|
|
} table_cache_test_t;
|
|
|
|
static hb_blob_t *
|
|
_reference_counted_table (hb_face_t *face, hb_tag_t tag, void *user_data)
|
|
{
|
|
table_cache_test_t *data = (table_cache_test_t *) user_data;
|
|
if (tag == data->tag)
|
|
data->references++;
|
|
return _copy_table (face, tag, data->source);
|
|
}
|
|
|
|
static unsigned
|
|
_get_counted_table_tags (const hb_face_t *face HB_UNUSED, unsigned start_offset,
|
|
unsigned *table_count, hb_tag_t *table_tags, void *user_data)
|
|
{
|
|
table_cache_test_t *data = (table_cache_test_t *) user_data;
|
|
return hb_face_get_table_tags (data->source, start_offset, table_count, table_tags);
|
|
}
|
|
|
|
static void
|
|
test_subset_sanitized_table_cache (void)
|
|
{
|
|
const struct {
|
|
const char *font;
|
|
hb_tag_t tag;
|
|
} tests[] = {
|
|
{"fonts/Roboto-Regular.abc.ttf", HB_TAG ('O','S','/','2')},
|
|
#ifndef HB_NO_COLOR
|
|
{"fonts/TwemojiMozilla.subset.ttf", HB_TAG ('C','O','L','R')},
|
|
#endif
|
|
#ifndef HB_NO_OT_LAYOUT
|
|
{"fonts/Roboto-Regular-gpos-.aw.ttf", HB_TAG ('G','P','O','S')},
|
|
#endif
|
|
};
|
|
|
|
for (unsigned i = 0; i < G_N_ELEMENTS (tests); i++)
|
|
{
|
|
table_cache_test_t data = {hb_test_open_font_file (tests[i].font), tests[i].tag, 0};
|
|
hb_face_t *face = hb_face_create_for_tables (_reference_counted_table, &data, NULL);
|
|
hb_face_set_get_table_tags_func (face, _get_counted_table_tags, &data, NULL);
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_invert (hb_subset_input_glyph_set (input));
|
|
|
|
hb_face_t *first = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (first);
|
|
unsigned references = data.references;
|
|
g_assert_cmpuint (references, >, 0);
|
|
hb_face_t *second = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (second);
|
|
g_assert_cmpuint (data.references, ==, references);
|
|
hb_blob_t *blob = hb_face_reference_table (second, data.tag);
|
|
g_assert_cmpuint (hb_blob_get_length (blob), >, 0);
|
|
hb_blob_destroy (blob);
|
|
hb_subset_test_check (first, second, data.tag);
|
|
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (face);
|
|
hb_face_destroy (data.source);
|
|
hb_face_destroy (first);
|
|
hb_face_destroy (second);
|
|
}
|
|
}
|
|
|
|
#if !defined(HB_NO_OT_LAYOUT) && !defined(HB_NO_OT_LAYOUT_BLOCKLIST)
|
|
static void
|
|
test_subset_gdef_blocklist (void)
|
|
{
|
|
/* Match a Cantarell entry in the GDEF blocklist, with glyph 1 a mark. */
|
|
static const char gdef[188] =
|
|
"\x00\x01\x00\x00\x00\x0C\x00\x00\x00\x00\x00\x00"
|
|
"\x00\x01\x00\x01\x00\x01\x00\x03";
|
|
/* Valid layout tables with one empty lookup and no scripts or features. */
|
|
static const char gsub[248] =
|
|
"\x00\x01\x00\x00\x00\x0A\x00\x0C\x00\x0E\x00\x00\x00\x00"
|
|
"\x00\x01\x00\x04\x00\x01\x00\x00\x00\x01\x00\x08"
|
|
"\x00\x01\x00\x06\x00\x00\x00\x01\x00\x00";
|
|
static const char gpos[3852] =
|
|
"\x00\x01\x00\x00\x00\x0A\x00\x0C\x00\x0E\x00\x00\x00\x00"
|
|
"\x00\x01\x00\x04\x00\x01\x00\x00\x00\x01\x00\x08"
|
|
"\x00\x01\x00\x06\x00\x00\x00\x01\x00\x00";
|
|
static const char maxp[] = "\x00\x00\x50\x00\x00\x02";
|
|
hb_face_t *source = hb_face_builder_create ();
|
|
HB_FACE_ADD_TABLE (source, "GDEF", gdef);
|
|
HB_FACE_ADD_TABLE (source, "GSUB", gsub);
|
|
HB_FACE_ADD_TABLE (source, "GPOS", gpos);
|
|
HB_FACE_ADD_TABLE (source, "maxp", maxp);
|
|
table_cache_test_t data = {source, HB_TAG ('G','D','E','F'), 0};
|
|
hb_face_t *face = hb_face_create_for_tables (_reference_counted_table, &data, NULL);
|
|
hb_face_set_get_table_tags_func (face, _get_counted_table_tags, &data, NULL);
|
|
|
|
g_assert_false (hb_ot_layout_has_glyph_classes (face));
|
|
g_assert_cmpuint (data.references, ==, 1);
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_add (hb_subset_input_glyph_set (input), 1);
|
|
for (unsigned i = 0; i < 2; i++)
|
|
{
|
|
hb_face_t *subset = hb_subset_or_fail (face, input);
|
|
g_assert_nonnull (subset);
|
|
g_assert_cmpuint (data.references, ==, 1);
|
|
g_assert_true (hb_ot_layout_has_glyph_classes (subset));
|
|
g_assert_cmpuint (hb_ot_layout_get_glyph_class (subset, 1), ==, HB_OT_LAYOUT_GLYPH_CLASS_MARK);
|
|
g_assert_false (hb_ot_layout_has_glyph_classes (face));
|
|
hb_face_destroy (subset);
|
|
}
|
|
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (face);
|
|
hb_face_destroy (source);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
test_subset_create_for_tables_face (void)
|
|
{
|
|
hb_face_t *face_abc = hb_test_open_font_file ("fonts/Roboto-Regular.abc.ttf");
|
|
hb_face_t *face_ac = hb_test_open_font_file ("fonts/Roboto-Regular.ac.ttf");
|
|
hb_face_t *face_create_for_tables = hb_face_create_for_tables (
|
|
_copy_table,
|
|
face_abc,
|
|
NULL);
|
|
|
|
hb_set_t *codepoints = hb_set_create();
|
|
hb_set_add (codepoints, 97);
|
|
hb_set_add (codepoints, 99);
|
|
|
|
hb_subset_input_t* input = hb_subset_test_create_input (codepoints);
|
|
hb_set_destroy (codepoints);
|
|
|
|
hb_face_t* face_abc_subset = hb_subset_or_fail (face_create_for_tables, input);
|
|
|
|
hb_subset_test_check (face_ac, face_abc_subset, HB_TAG ('l','o','c', 'a'));
|
|
hb_subset_test_check (face_ac, face_abc_subset, HB_TAG ('g','l','y','f'));
|
|
hb_subset_test_check (face_ac, face_abc_subset, HB_TAG ('g','a','s','p'));
|
|
|
|
hb_subset_input_destroy (input);
|
|
hb_face_destroy (face_abc_subset);
|
|
hb_face_destroy (face_create_for_tables);
|
|
hb_face_destroy (face_abc);
|
|
hb_face_destroy (face_ac);
|
|
}
|
|
|
|
#ifndef HB_NO_BEYOND_64K
|
|
static void
|
|
test_subset_create_for_tables_face_MAXP (void)
|
|
{
|
|
static const char MAXP_data[] = "\x00\x00\x50\x00\x00\x00\x03";
|
|
hb_face_t *source = hb_face_builder_create ();
|
|
HB_FACE_ADD_TABLE (source, "MAXP", MAXP_data);
|
|
hb_face_t *callback_face = hb_face_create_for_tables (_copy_table, source, NULL);
|
|
|
|
hb_set_t *glyphs = hb_set_create ();
|
|
hb_set_add (glyphs, 0);
|
|
hb_set_add (glyphs, 2);
|
|
hb_face_t *subset = hb_subset_test_create_subset (
|
|
callback_face, hb_subset_test_create_input_from_glyphs (glyphs));
|
|
hb_set_destroy (glyphs);
|
|
|
|
hb_blob_t *blob = hb_face_reference_table (subset, HB_TAG ('M','A','X','P'));
|
|
unsigned length;
|
|
const unsigned char *data =
|
|
(const unsigned char *) hb_blob_get_data (blob, &length);
|
|
g_assert_cmpuint (length, ==, 7);
|
|
g_assert_cmpuint ((data[4] << 16) | (data[5] << 8) | data[6], ==, 2);
|
|
hb_blob_destroy (blob);
|
|
|
|
hb_face_destroy (subset);
|
|
hb_face_destroy (callback_face);
|
|
hb_face_destroy (source);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
test_subset_axis_range_from_string (void)
|
|
{
|
|
float min, max, def;
|
|
|
|
/* An explicit len must bound the parse: bytes after len are not part of
|
|
* the string and must be neither read nor interpreted. */
|
|
g_assert_true (hb_subset_axis_range_from_string ("100:200:", 3, &min, &max, &def));
|
|
g_assert_cmpfloat (min, ==, 100.f);
|
|
g_assert_cmpfloat (def, ==, 100.f);
|
|
g_assert_cmpfloat (max, ==, 100.f);
|
|
|
|
g_assert_true (hb_subset_axis_range_from_string ("100:200:", 7, &min, &max, &def));
|
|
g_assert_cmpfloat (min, ==, 100.f);
|
|
g_assert_true (isnan (def));
|
|
g_assert_cmpfloat (max, ==, 200.f);
|
|
|
|
g_assert_true (hb_subset_axis_range_from_string ("100:200,wdth=75:100", 7, &min, &max, &def));
|
|
g_assert_cmpfloat (min, ==, 100.f);
|
|
g_assert_true (isnan (def));
|
|
g_assert_cmpfloat (max, ==, 200.f);
|
|
|
|
g_assert_true (hb_subset_axis_range_from_string ("100:300:200,", 11, &min, &max, &def));
|
|
g_assert_cmpfloat (min, ==, 100.f);
|
|
g_assert_cmpfloat (def, ==, 300.f);
|
|
g_assert_cmpfloat (max, ==, 200.f);
|
|
|
|
g_assert_true (hb_subset_axis_range_from_string (":300:,", 5, &min, &max, &def));
|
|
g_assert_true (isnan (min));
|
|
g_assert_cmpfloat (def, ==, 300.f);
|
|
g_assert_true (isnan (max));
|
|
|
|
g_assert_true (hb_subset_axis_range_from_string ("drop,wdth=75", 4, &min, &max, &def));
|
|
g_assert_true (isnan (min));
|
|
g_assert_true (isnan (def));
|
|
g_assert_true (isnan (max));
|
|
|
|
g_assert_true (hb_subset_axis_range_from_string ("dropped", 4, &min, &max, &def));
|
|
g_assert_true (isnan (min));
|
|
g_assert_false (hb_subset_axis_range_from_string ("dropped", -1, &min, &max, &def));
|
|
g_assert_false (hb_subset_axis_range_from_string ("drop", 3, &min, &max, &def));
|
|
g_assert_false (hb_subset_axis_range_from_string ("", 0, &min, &max, &def));
|
|
|
|
/* NUL-terminated input behaves as before. */
|
|
g_assert_true (hb_subset_axis_range_from_string ("100:200", -1, &min, &max, &def));
|
|
g_assert_cmpfloat (min, ==, 100.f);
|
|
g_assert_true (isnan (def));
|
|
g_assert_cmpfloat (max, ==, 200.f);
|
|
|
|
g_assert_true (hb_subset_axis_range_from_string ("drop", -1, &min, &max, &def));
|
|
g_assert_true (isnan (min));
|
|
g_assert_true (isnan (def));
|
|
g_assert_true (isnan (max));
|
|
|
|
g_assert_false (hb_subset_axis_range_from_string ("abc", -1, &min, &max, &def));
|
|
}
|
|
|
|
#ifdef HB_EXPERIMENTAL_API
|
|
const uint8_t CFF2[226] = {
|
|
// From https://learn.microsoft.com/en-us/typography/opentype/spec/cff2
|
|
0x02, 0x00, 0x05, 0x00, 0x07, 0xCF, 0x0C, 0x24, 0xC3, 0x11, 0x9B, 0x18, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x26, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x01,
|
|
0x00, 0x02, 0xC0, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x01, 0x01, 0x03, 0x05,
|
|
0x20, 0x0A, 0x20, 0x0A, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x05, 0xF7, 0x06, 0xDA, 0x12, 0x77,
|
|
0x9F, 0xF8, 0x6C, 0x9D, 0xAE, 0x9A, 0xF4, 0x9A, 0x95, 0x9F, 0xB3, 0x9F, 0x8B, 0x8B, 0x8B, 0x8B,
|
|
0x85, 0x9A, 0x8B, 0x8B, 0x97, 0x73, 0x8B, 0x8B, 0x8C, 0x80, 0x8B, 0x8B, 0x8B, 0x8D, 0x8B, 0x8B,
|
|
0x8C, 0x8A, 0x8B, 0x8B, 0x97, 0x17, 0x06, 0xFB, 0x8E, 0x95, 0x86, 0x9D, 0x8B, 0x8B, 0x8D, 0x17,
|
|
0x07, 0x77, 0x9F, 0xF8, 0x6D, 0x9D, 0xAD, 0x9A, 0xF3, 0x9A, 0x95, 0x9F, 0xB3, 0x9F, 0x08, 0xFB,
|
|
0x8D, 0x95, 0x09, 0x1E, 0xA0, 0x37, 0x5F, 0x0C, 0x09, 0x8B, 0x0C, 0x0B, 0xC2, 0x6E, 0x9E, 0x8C,
|
|
0x17, 0x0A, 0xDB, 0x57, 0xF7, 0x02, 0x8C, 0x17, 0x0B, 0xB3, 0x9A, 0x77, 0x9F, 0x82, 0x8A, 0x8D,
|
|
0x17, 0x0C, 0x0C, 0xDB, 0x95, 0x57, 0xF7, 0x02, 0x85, 0x8B, 0x8D, 0x17, 0x0C, 0x0D, 0xF7, 0x06,
|
|
0x13, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x1B, 0xBD, 0xBD, 0xEF, 0x8C, 0x10, 0x8B, 0x15, 0xF8,
|
|
0x88, 0x27, 0xFB, 0x5C, 0x8C, 0x10, 0x06, 0xF8, 0x88, 0x07, 0xFC, 0x88, 0xEF, 0xF7, 0x5C, 0x8C,
|
|
0x10, 0x06
|
|
};
|
|
|
|
const uint8_t CFF2_ONLY_CHARSTRINGS[12] = {
|
|
0x00, 0x00, 0x00, 0x02, 0x01, 0x01, 0x03, 0x05,
|
|
0x20, 0x0A, 0x20, 0x0A
|
|
};
|
|
|
|
static void
|
|
test_subset_cff2_get_charstring_data (void)
|
|
{
|
|
const uint8_t maxp_data[6] = {
|
|
0x00, 0x00, 0x50, 0x00,
|
|
0x00, 0x02 // numGlyphs
|
|
};
|
|
|
|
hb_blob_t* cff2 = hb_blob_create ((const char*) CFF2, 226, HB_MEMORY_MODE_READONLY, 0, 0);
|
|
hb_blob_t* maxp = hb_blob_create ((const char*) maxp_data, 6, HB_MEMORY_MODE_READONLY, 0, 0);
|
|
hb_face_t* builder = hb_face_builder_create ();
|
|
hb_face_builder_add_table (builder, HB_TAG('C', 'F', 'F', '2'), cff2);
|
|
hb_face_builder_add_table (builder, HB_TAG('m', 'a', 'x', 'p'), maxp);
|
|
hb_blob_t* face_blob = hb_face_reference_blob (builder);
|
|
hb_face_t* face = hb_face_create (face_blob, 0);
|
|
|
|
hb_blob_t* cs0 = hb_subset_cff2_get_charstring_data (face, 0);
|
|
unsigned int length;
|
|
const uint8_t* data = (const uint8_t*) hb_blob_get_data (cs0, &length);
|
|
g_assert_true (length == 2);
|
|
g_assert_true (data[0] == 0x20);
|
|
g_assert_true (data[1] == 0x0A);
|
|
|
|
hb_blob_t* cs1 = hb_subset_cff2_get_charstring_data (face, 1);
|
|
data = (const uint8_t*) hb_blob_get_data (cs1, &length);
|
|
g_assert_true (length == 2);
|
|
g_assert_true (data[0] == 0x20);
|
|
g_assert_true (data[1] == 0x0A);
|
|
|
|
hb_blob_t* cs2 = hb_subset_cff2_get_charstring_data (face, 2);
|
|
data = (const uint8_t*) hb_blob_get_data (cs2, &length);
|
|
g_assert_true (length == 0);
|
|
|
|
hb_blob_destroy (cff2);
|
|
hb_blob_destroy (maxp);
|
|
hb_face_destroy (builder);
|
|
hb_blob_destroy (face_blob);
|
|
hb_face_destroy (face);
|
|
hb_blob_destroy (cs0);
|
|
hb_blob_destroy (cs1);
|
|
hb_blob_destroy (cs2);
|
|
}
|
|
|
|
static void
|
|
test_subset_cff2_get_all_charstrings_data (void)
|
|
{
|
|
const uint8_t maxp_data[6] = {
|
|
0x00, 0x00, 0x50, 0x00,
|
|
0x00, 0x02 // numGlyphs
|
|
};
|
|
|
|
hb_blob_t* cff2 = hb_blob_create ((const char*) CFF2, 226, HB_MEMORY_MODE_READONLY, 0, 0);
|
|
hb_blob_t* maxp = hb_blob_create ((const char*) maxp_data, 6, HB_MEMORY_MODE_READONLY, 0, 0);
|
|
hb_face_t* builder = hb_face_builder_create ();
|
|
hb_face_builder_add_table (builder, HB_TAG('C', 'F', 'F', '2'), cff2);
|
|
hb_face_builder_add_table (builder, HB_TAG('m', 'a', 'x', 'p'), maxp);
|
|
hb_blob_t* face_blob = hb_face_reference_blob (builder);
|
|
hb_face_t* face = hb_face_create (face_blob, 0);
|
|
|
|
hb_blob_t* cs = hb_subset_cff2_get_charstrings_index (face);
|
|
hb_blob_destroy (cff2);
|
|
hb_blob_destroy (maxp);
|
|
hb_face_destroy (builder);
|
|
hb_blob_destroy (face_blob);
|
|
hb_face_destroy (face);
|
|
|
|
unsigned int length;
|
|
const uint8_t* data = (const uint8_t*) hb_blob_get_data (cs, &length);
|
|
g_assert_cmpint (length, ==, 12);
|
|
for (int i = 0; i < 12; i++) {
|
|
g_assert_cmpint(data[i], ==, CFF2_ONLY_CHARSTRINGS[i]);
|
|
}
|
|
|
|
hb_blob_destroy (cs);
|
|
}
|
|
|
|
static void
|
|
test_subset_cff2_get_charstring_data_no_cff (void)
|
|
{
|
|
hb_face_t* builder = hb_face_builder_create ();
|
|
hb_blob_t* face_blob = hb_face_reference_blob (builder);
|
|
hb_face_t* face = hb_face_create (face_blob, 0);
|
|
|
|
hb_blob_t* cs0 = hb_subset_cff2_get_charstring_data (face, 0);
|
|
g_assert_true (hb_blob_get_length (cs0) == 0);
|
|
|
|
hb_face_destroy (builder);
|
|
hb_blob_destroy (face_blob);
|
|
hb_face_destroy (face);
|
|
hb_blob_destroy (cs0);
|
|
}
|
|
|
|
static void
|
|
test_subset_cff2_get_charstring_data_invalid_cff2 (void)
|
|
{
|
|
// cff2 will parse as invalid since charstrings count doesn't not match num glyphs
|
|
// (because there is no maxp).
|
|
hb_blob_t* cff2 = hb_blob_create ((const char*) CFF2, 226, HB_MEMORY_MODE_READONLY, 0, 0);
|
|
hb_face_t* builder = hb_face_builder_create ();
|
|
hb_face_builder_add_table (builder, HB_TAG('C', 'F', 'F', '2'), cff2);
|
|
hb_blob_t* face_blob = hb_face_reference_blob (builder);
|
|
hb_face_t* face = hb_face_create (face_blob, 0);
|
|
|
|
hb_blob_t* cs0 = hb_subset_cff2_get_charstring_data (face, 0);
|
|
g_assert_true (hb_blob_get_length (cs0) == 0);
|
|
|
|
hb_blob_destroy (cff2);
|
|
hb_face_destroy (builder);
|
|
hb_blob_destroy (face_blob);
|
|
hb_face_destroy (face);
|
|
hb_blob_destroy (cs0);
|
|
}
|
|
|
|
static void
|
|
test_subset_cff2_get_charstring_data_lifetime (void)
|
|
{
|
|
const uint8_t maxp_data[6] = {
|
|
0x00, 0x00, 0x50, 0x00,
|
|
0x00, 0x02 // numGlyphs
|
|
};
|
|
|
|
hb_blob_t* cff2 = hb_blob_create ((const char*) CFF2, 226, HB_MEMORY_MODE_READONLY, 0, 0);
|
|
hb_blob_t* maxp = hb_blob_create ((const char*) maxp_data, 6, HB_MEMORY_MODE_READONLY, 0, 0);
|
|
hb_face_t* builder = hb_face_builder_create ();
|
|
hb_face_builder_add_table (builder, HB_TAG('C', 'F', 'F', '2'), cff2);
|
|
hb_face_builder_add_table (builder, HB_TAG('m', 'a', 'x', 'p'), maxp);
|
|
hb_blob_t* face_blob = hb_face_reference_blob (builder);
|
|
hb_face_t* face = hb_face_create (face_blob, 0);
|
|
|
|
hb_blob_t* cs0 = hb_subset_cff2_get_charstring_data (face, 0);
|
|
|
|
// Destroy the blob that cs0 is referencing via subblob to ensure lifetimes are being
|
|
// handled correctly.
|
|
hb_blob_destroy (cff2);
|
|
hb_blob_destroy (maxp);
|
|
hb_face_destroy (builder);
|
|
hb_blob_destroy (face_blob);
|
|
hb_face_destroy (face);
|
|
|
|
unsigned int length;
|
|
const uint8_t* data = (const uint8_t*) hb_blob_get_data (cs0, &length);
|
|
g_assert_true (length == 2);
|
|
g_assert_true (data[0] == 0x20);
|
|
g_assert_true (data[1] == 0x0A);
|
|
|
|
hb_blob_destroy (cs0);
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef HB_EXPERIMENTAL_API
|
|
static void
|
|
test_subset_input_to_string (void)
|
|
{
|
|
/* Test NULL input */
|
|
g_assert_null (hb_subset_input_to_string_or_fail (NULL));
|
|
|
|
/* Test default input -> empty string */
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_blob_t *blob = hb_subset_input_to_string_or_fail (input);
|
|
g_assert_nonnull (blob);
|
|
unsigned len = 0;
|
|
const char *data = hb_blob_get_data (blob, &len);
|
|
g_assert_cmpint (len, ==, 1);
|
|
g_assert_cmpstr (data, ==, "");
|
|
hb_blob_destroy (blob);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
/* Test unicodes ranges */
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_t *unicodes = hb_subset_input_unicode_set (input);
|
|
hb_set_add (unicodes, 0x41);
|
|
hb_set_add (unicodes, 0x42);
|
|
hb_set_add (unicodes, 0x43);
|
|
hb_set_add (unicodes, 0x45);
|
|
hb_set_add (unicodes, 0x61);
|
|
hb_set_add (unicodes, 0x62);
|
|
hb_set_add (unicodes, 0x63);
|
|
|
|
hb_blob_t *blob = hb_subset_input_to_string_or_fail (input);
|
|
g_assert_nonnull (blob);
|
|
unsigned len = 0;
|
|
const char *data = hb_blob_get_data (blob, &len);
|
|
g_assert_cmpstr (data, ==, "--unicodes=41-43,45,61-63");
|
|
hb_blob_destroy (blob);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
/* Test gids ranges and flags */
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_t *gids = hb_subset_input_glyph_set (input);
|
|
hb_set_add (gids, 1);
|
|
hb_set_add (gids, 2);
|
|
hb_set_add (gids, 3);
|
|
hb_set_add (gids, 5);
|
|
hb_set_add (gids, 10);
|
|
hb_set_add (gids, 11);
|
|
hb_subset_input_set_flags (input, HB_SUBSET_FLAGS_NO_HINTING | HB_SUBSET_FLAGS_RETAIN_GIDS);
|
|
|
|
hb_blob_t *blob = hb_subset_input_to_string_or_fail (input);
|
|
g_assert_nonnull (blob);
|
|
unsigned len = 0;
|
|
const char *data = hb_blob_get_data (blob, &len);
|
|
g_assert_cmpstr (data, ==, "--no-hinting --retain-gids --gids=1-3,5,10-11");
|
|
hb_blob_destroy (blob);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
/* Test keep everything */
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_subset_input_keep_everything (input);
|
|
|
|
hb_blob_t *blob = hb_subset_input_to_string_or_fail (input);
|
|
g_assert_nonnull (blob);
|
|
unsigned len = 0;
|
|
const char *data = hb_blob_get_data (blob, &len);
|
|
const char *expected = "--name-legacy --passthrough-tables --notdef-outline --glyph-names --no-prune-unicode-ranges --unicodes=* --gids=* --name-IDs=* --name-languages=* --layout-features=* --drop-tables-=*";
|
|
g_assert_cmpstr (data, ==, expected);
|
|
g_assert_cmpint (len - 1, ==, strlen (expected));
|
|
hb_blob_destroy (blob);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
/* Test inverted sets with exclusions */
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_t *unicodes = hb_subset_input_set (input, HB_SUBSET_SETS_UNICODE);
|
|
hb_set_invert (unicodes);
|
|
hb_set_del (unicodes, 0x20);
|
|
hb_set_del (unicodes, 0x41);
|
|
hb_set_del (unicodes, 0x42);
|
|
hb_set_del (unicodes, 0x43);
|
|
|
|
hb_set_t *gids = hb_subset_input_set (input, HB_SUBSET_SETS_GLYPH_INDEX);
|
|
hb_set_invert (gids);
|
|
hb_set_del (gids, 5);
|
|
hb_set_del (gids, 6);
|
|
hb_set_del (gids, 7);
|
|
|
|
hb_set_t *features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
|
|
hb_set_clear (features);
|
|
hb_set_invert (features);
|
|
hb_set_del (features, HB_TAG ('k', 'e', 'r', 'n'));
|
|
|
|
hb_blob_t *blob = hb_subset_input_to_string_or_fail (input);
|
|
g_assert_nonnull (blob);
|
|
unsigned len = 0;
|
|
const char *data = hb_blob_get_data (blob, &len);
|
|
const char *expected = "--unicodes=* --unicodes-=20,41-43 --gids=* --gids-=5-7 --layout-features=* --layout-features-=kern";
|
|
g_assert_cmpstr (data, ==, expected);
|
|
hb_blob_destroy (blob);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
/* Test empty non-default sets */
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
hb_set_clear (hb_subset_input_set (input, HB_SUBSET_SETS_NAME_ID));
|
|
hb_set_clear (hb_subset_input_set (input, HB_SUBSET_SETS_NAME_LANG_ID));
|
|
|
|
hb_blob_t *blob = hb_subset_input_to_string_or_fail (input);
|
|
g_assert_nonnull (blob);
|
|
unsigned len = 0;
|
|
const char *data = hb_blob_get_data (blob, &len);
|
|
const char *expected = "--name-IDs-=* --name-languages-=*";
|
|
g_assert_cmpstr (data, ==, expected);
|
|
hb_blob_destroy (blob);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
/* Test non-default non-inverted tag sets */
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
|
|
hb_set_t *features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
|
|
hb_set_clear (features);
|
|
hb_set_add (features, HB_TAG ('l', 'i', 'g', 'a'));
|
|
hb_set_add (features, HB_TAG ('k', 'e', 'r', 'n'));
|
|
|
|
hb_set_t *scripts = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_SCRIPT_TAG);
|
|
hb_set_clear (scripts);
|
|
hb_set_add (scripts, HB_TAG ('l', 'a', 't', 'n'));
|
|
|
|
hb_set_t *drop_tables = hb_subset_input_set (input, HB_SUBSET_SETS_DROP_TABLE_TAG);
|
|
hb_set_clear (drop_tables);
|
|
hb_set_add (drop_tables, HB_TAG ('G', 'S', 'U', 'B'));
|
|
|
|
hb_blob_t *blob = hb_subset_input_to_string_or_fail (input);
|
|
g_assert_nonnull (blob);
|
|
unsigned len = 0;
|
|
const char *data = hb_blob_get_data (blob, &len);
|
|
const char *expected = "--layout-features=kern,liga --layout-scripts=latn --drop-tables=GSUB";
|
|
g_assert_cmpstr (data, ==, expected);
|
|
hb_blob_destroy (blob);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
/* Test tag sanitization with unsafe ASCII characters */
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
|
|
hb_set_t *features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
|
|
hb_set_clear (features);
|
|
/* Tag with space, newline, and single-quote: 'a \n'' */
|
|
hb_set_add (features, HB_TAG ('a', ' ', '\n', '\''));
|
|
|
|
hb_blob_t *blob = hb_subset_input_to_string_or_fail (input);
|
|
g_assert_nonnull (blob);
|
|
unsigned len = 0;
|
|
const char *data = hb_blob_get_data (blob, &len);
|
|
const char *expected = "--layout-features=a___";
|
|
g_assert_cmpstr (data, ==, expected);
|
|
hb_blob_destroy (blob);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
|
|
/* Test trimming trailing whitespace from tags */
|
|
{
|
|
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
|
|
|
|
hb_set_t *drop_tables = hb_subset_input_set (input, HB_SUBSET_SETS_DROP_TABLE_TAG);
|
|
hb_set_clear (drop_tables);
|
|
hb_set_add (drop_tables, HB_TAG ('c', 'v', 't', ' '));
|
|
|
|
hb_set_t *features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
|
|
hb_set_clear (features);
|
|
hb_set_add (features, HB_TAG (' ', ' ', ' ', ' '));
|
|
hb_set_add (features, HB_TAG ('f', 'o', 'o', ' '));
|
|
|
|
hb_blob_t *blob = hb_subset_input_to_string_or_fail (input);
|
|
g_assert_nonnull (blob);
|
|
unsigned len = 0;
|
|
const char *data = hb_blob_get_data (blob, &len);
|
|
const char *expected = "--layout-features=,foo --drop-tables=cvt";
|
|
g_assert_cmpstr (data, ==, expected);
|
|
hb_blob_destroy (blob);
|
|
hb_subset_input_destroy (input);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
hb_test_init (&argc, &argv);
|
|
|
|
hb_test_add (test_subset_32_tables);
|
|
hb_test_add (test_subset_no_inf_loop);
|
|
hb_test_add (test_subset_crash);
|
|
hb_test_add (test_subset_shared_coverage_budget);
|
|
#ifndef HB_NO_VAR
|
|
hb_test_add (test_subset_lookup_variations);
|
|
hb_test_add (test_subset_lookup_variation_fractional_value);
|
|
hb_test_add (test_subset_condition_value_precision);
|
|
hb_test_add (test_subset_feature_variation_conditions);
|
|
hb_test_add (test_subset_feature_variation_universal);
|
|
#endif
|
|
hb_test_add (test_subset_set_flags);
|
|
hb_test_add (test_subset_sets);
|
|
hb_test_add (test_subset_plan);
|
|
#ifndef HB_NO_SUBSET_LAYOUT
|
|
hb_test_add (test_subset_unsupported_layout_table_retains_gids);
|
|
hb_test_add (test_subset_graphite_table_retains_gids);
|
|
hb_test_add (test_subset_unsubsettable_glyph_tables);
|
|
hb_test_add (test_subset_non_glyph_layout_table_does_not_retain_gids);
|
|
#endif
|
|
hb_test_add (test_subset_custom_glyph_mapping);
|
|
hb_test_add (test_subset_no_hinting_ignored_for_hint_dependent_font);
|
|
hb_test_add (test_subset_no_hinting_hint_dependent_wws_family);
|
|
hb_test_add (test_subset_no_hinting_ignored_for_hint_dependent_ids);
|
|
hb_test_add (test_subset_sanitized_table_cache);
|
|
#if !defined(HB_NO_OT_LAYOUT) && !defined(HB_NO_OT_LAYOUT_BLOCKLIST)
|
|
hb_test_add (test_subset_gdef_blocklist);
|
|
#endif
|
|
hb_test_add (test_subset_create_for_tables_face);
|
|
#ifndef HB_NO_BEYOND_64K
|
|
hb_test_add (test_subset_create_for_tables_face_MAXP);
|
|
#endif
|
|
hb_test_add (test_subset_axis_range_from_string);
|
|
|
|
#ifdef HB_EXPERIMENTAL_API
|
|
hb_test_add (test_subset_input_to_string);
|
|
hb_test_add (test_subset_cff2_get_charstring_data);
|
|
hb_test_add (test_subset_cff2_get_all_charstrings_data);
|
|
hb_test_add (test_subset_cff2_get_charstring_data_no_cff);
|
|
hb_test_add (test_subset_cff2_get_charstring_data_invalid_cff2);
|
|
hb_test_add (test_subset_cff2_get_charstring_data_lifetime);
|
|
#endif
|
|
|
|
return hb_test_run();
|
|
}
|