mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-21 06:51:01 +01:00
Release the face lock around solid, gradient, and custom palette callbacks. Keep lazy FreeType color-stop reads locked and give each getter call its own iterator, so callbacks can query the same font without deadlocking or disturbing another stop query. Snapshot the selected palette once per COLRv1 traversal, shared by the bounds and paint passes. Nested paints can select a different palette on the face; they must not change the outer paint's colors. Return failure if the palette copy cannot be allocated. Stops remain lazy and no cache policy or limits change. Add a bounded callback regression with the existing COLRv1 fixture. It queries font extents, performs nested paints with another palette, and checks repeated and paged stop reads against the OT backend. The original code times out; unlocking without copying the palette fails the color comparison. The full Meson suite passes: 274 tests, no failures. Reported by Anthropic's OSS Scanner as ANT-2026-YPLDSFHA. Assisted-by: OpenAI Codex
1201 lines
35 KiB
C
1201 lines
35 KiB
C
/*
|
|
* Copyright © 2022 Matthias Clasen
|
|
*
|
|
* 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-features.h>
|
|
#include <hb-ot.h>
|
|
|
|
#ifdef HB_HAS_FREETYPE
|
|
#include <hb-ft.h>
|
|
|
|
#if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) >= 21300
|
|
#include FT_COLOR_H
|
|
#endif
|
|
#endif
|
|
|
|
static inline hb_bool_t
|
|
have_ft_colrv1 (void)
|
|
{
|
|
#if defined(HB_HAS_FREETYPE) && (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) >= 21300
|
|
return TRUE;
|
|
#else
|
|
return FALSE;
|
|
#endif
|
|
}
|
|
|
|
/* Unit tests for hb-paint.h */
|
|
|
|
/* ---- */
|
|
|
|
typedef struct {
|
|
int level;
|
|
GString *string;
|
|
} paint_data_t;
|
|
|
|
static float
|
|
clean_float (float v)
|
|
{
|
|
/* Keep text fixtures stable across backends that may produce -0.f. */
|
|
return v == 0.f ? 0.f : v;
|
|
}
|
|
|
|
static void print (paint_data_t *data, const char *format, ...) G_GNUC_PRINTF (2, 3);
|
|
|
|
static void
|
|
print (paint_data_t *data,
|
|
const char *format,
|
|
...)
|
|
{
|
|
va_list args;
|
|
|
|
g_string_append_printf (data->string, "%*s", 2 * data->level, "");
|
|
|
|
va_start (args, format);
|
|
g_string_append_vprintf (data->string, format, args);
|
|
va_end (args);
|
|
|
|
g_string_append (data->string, "\n");
|
|
}
|
|
|
|
static void
|
|
push_transform (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
float xx, float yx,
|
|
float xy, float yy,
|
|
float dx, float dy,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
xx = clean_float (xx);
|
|
yx = clean_float (yx);
|
|
xy = clean_float (xy);
|
|
yy = clean_float (yy);
|
|
dx = clean_float (dx);
|
|
dy = clean_float (dy);
|
|
|
|
print (data, "start transform %.3g %.3g %.3g %.3g %.3g %.3g", xx, yx, xy, yy, dx, dy);
|
|
data->level++;
|
|
}
|
|
|
|
static void
|
|
pop_transform (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
data->level--;
|
|
print (data, "end transform");
|
|
}
|
|
|
|
static void
|
|
fill_glyph (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_codepoint_t glyph,
|
|
hb_font_t *font HB_UNUSED,
|
|
hb_bool_t use_foreground HB_UNUSED,
|
|
hb_color_t color,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
print (data, "fill glyph %u solid %d %d %d %d", glyph,
|
|
hb_color_get_red (color),
|
|
hb_color_get_green (color),
|
|
hb_color_get_blue (color),
|
|
hb_color_get_alpha (color));
|
|
}
|
|
|
|
static hb_bool_t
|
|
paint_color_glyph (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_codepoint_t glyph,
|
|
hb_font_t *font HB_UNUSED,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
print (data, "paint color glyph %u; acting as failed", glyph);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
push_clip_glyph (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_codepoint_t glyph,
|
|
hb_font_t *font HB_UNUSED,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
print (data, "start clip glyph %u", glyph);
|
|
data->level++;
|
|
}
|
|
|
|
static void
|
|
push_clip_rectangle (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
float xmin, float ymin, float xmax, float ymax,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
print (data, "start clip rectangle %.3g %.3g %.3g %.3g", xmin, ymin, xmax, ymax);
|
|
data->level++;
|
|
}
|
|
|
|
static void
|
|
pop_clip (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
data->level--;
|
|
print (data, "end clip");
|
|
}
|
|
|
|
static void
|
|
paint_color (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_bool_t use_foreground HB_UNUSED,
|
|
hb_color_t color,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
print (data, "solid %d %d %d %d",
|
|
hb_color_get_red (color),
|
|
hb_color_get_green (color),
|
|
hb_color_get_blue (color),
|
|
hb_color_get_alpha (color));
|
|
}
|
|
|
|
static hb_bool_t
|
|
paint_image (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_blob_t *blob HB_UNUSED,
|
|
unsigned int width,
|
|
unsigned int height,
|
|
hb_tag_t format,
|
|
float slant,
|
|
hb_glyph_extents_t *extents,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
char buf[5] = { 0, };
|
|
|
|
hb_tag_to_string (format, buf);
|
|
print (data, "image type %s size %u %u slant %.3g extents %d %d %d %d\n",
|
|
buf, width, height, slant,
|
|
extents->x_bearing, extents->y_bearing, extents->width, extents->height);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
print_color_stops (paint_data_t *data,
|
|
hb_paint_extend_t extend,
|
|
hb_color_stop_t *stops,
|
|
unsigned int len)
|
|
{
|
|
print (data, "colors %d", extend);
|
|
data->level += 1;
|
|
for (unsigned int i = 0; i < len; i++)
|
|
print (data, "%.3g %d %d %d %d",
|
|
stops[i].offset,
|
|
hb_color_get_red (stops[i].color),
|
|
hb_color_get_green (stops[i].color),
|
|
hb_color_get_blue (stops[i].color),
|
|
hb_color_get_alpha (stops[i].color));
|
|
data->level -= 1;
|
|
}
|
|
|
|
static void
|
|
print_color_line (paint_data_t *data,
|
|
hb_color_line_t *color_line)
|
|
{
|
|
hb_color_stop_t *stops;
|
|
unsigned int len;
|
|
|
|
len = hb_color_line_get_color_stops (color_line, 0, NULL, NULL);
|
|
stops = malloc (len * sizeof (hb_color_stop_t));
|
|
hb_color_line_get_color_stops (color_line, 0, &len, stops);
|
|
|
|
print_color_stops (data, hb_color_line_get_extend (color_line), stops, len);
|
|
free (stops);
|
|
}
|
|
|
|
static void
|
|
paint_linear_gradient (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_color_line_t *color_line,
|
|
float x0, float y0,
|
|
float x1, float y1,
|
|
float x2, float y2,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
float xx0, yy0, xx1, yy1;
|
|
float xxx0, yyy0, xxx1, yyy1;
|
|
float min, max;
|
|
hb_color_stop_t *stops;
|
|
unsigned int len;
|
|
|
|
hb_paint_reduce_linear_anchors (x0, y0, x1, y1, x2, y2,
|
|
&xx0, &yy0, &xx1, &yy1);
|
|
len = hb_color_line_get_color_stops (color_line, 0, NULL, NULL);
|
|
stops = malloc (len * sizeof (hb_color_stop_t));
|
|
hb_color_line_get_color_stops (color_line, 0, &len, stops);
|
|
hb_paint_normalize_color_line (stops, len, &min, &max);
|
|
|
|
xxx0 = xx0 + min * (xx1 - xx0);
|
|
yyy0 = yy0 + min * (yy1 - yy0);
|
|
xxx1 = xx0 + max * (xx1 - xx0);
|
|
yyy1 = yy0 + max * (yy1 - yy0);
|
|
|
|
print (data, "linear gradient");
|
|
data->level += 1;
|
|
print (data, "p0 %.3g %.3g", xxx0, yyy0);
|
|
print (data, "p1 %.3g %.3g", xxx1, yyy1);
|
|
|
|
print_color_stops (data, hb_color_line_get_extend (color_line), stops, len);
|
|
data->level -= 1;
|
|
free (stops);
|
|
}
|
|
|
|
static void
|
|
paint_radial_gradient (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_color_line_t *color_line,
|
|
float x0, float y0, float r0,
|
|
float x1, float y1, float r1,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
print (data, "radial gradient");
|
|
data->level += 1;
|
|
print (data, "p0 %.3g %.3g radius %.3g", x0, y0, r0);
|
|
print (data, "p1 %.3g %.3g radius %.3g", x1, y1, r1);
|
|
|
|
print_color_line (data, color_line);
|
|
data->level -= 1;
|
|
}
|
|
|
|
static void
|
|
paint_sweep_gradient (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_color_line_t *color_line,
|
|
float cx, float cy,
|
|
float start_angle,
|
|
float end_angle,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
|
|
print (data, "sweep gradient");
|
|
data->level++;
|
|
print (data, "center %.3g %.3g", cx, cy);
|
|
print (data, "angles %.3g %.3g", start_angle, end_angle);
|
|
|
|
print_color_line (data, color_line);
|
|
data->level -= 1;
|
|
}
|
|
|
|
static void
|
|
push_group (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
print (data, "push group");
|
|
data->level++;
|
|
}
|
|
|
|
static void
|
|
pop_group (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_paint_composite_mode_t mode,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_data_t *data = paint_data;
|
|
data->level--;
|
|
print (data, "pop group mode %d", mode);
|
|
}
|
|
|
|
static hb_paint_funcs_t *
|
|
get_test_paint_funcs (void)
|
|
{
|
|
static hb_paint_funcs_t *funcs = NULL;
|
|
|
|
if (!funcs)
|
|
{
|
|
funcs = hb_paint_funcs_create ();
|
|
|
|
hb_paint_funcs_set_push_transform_func (funcs, push_transform, NULL, NULL);
|
|
hb_paint_funcs_set_pop_transform_func (funcs, pop_transform, NULL, NULL);
|
|
hb_paint_funcs_set_fill_glyph_func (funcs, fill_glyph, NULL, NULL);
|
|
hb_paint_funcs_set_color_glyph_func (funcs, paint_color_glyph, NULL, NULL);
|
|
hb_paint_funcs_set_push_clip_glyph_func (funcs, push_clip_glyph, NULL, NULL);
|
|
hb_paint_funcs_set_push_clip_rectangle_func (funcs, push_clip_rectangle, NULL, NULL);
|
|
hb_paint_funcs_set_pop_clip_func (funcs, pop_clip, NULL, NULL);
|
|
hb_paint_funcs_set_push_group_func (funcs, push_group, NULL, NULL);
|
|
hb_paint_funcs_set_pop_group_func (funcs, pop_group, NULL, NULL);
|
|
hb_paint_funcs_set_color_func (funcs, paint_color, NULL, NULL);
|
|
hb_paint_funcs_set_image_func (funcs, paint_image, NULL, NULL);
|
|
hb_paint_funcs_set_linear_gradient_func (funcs, paint_linear_gradient, NULL, NULL);
|
|
hb_paint_funcs_set_radial_gradient_func (funcs, paint_radial_gradient, NULL, NULL);
|
|
hb_paint_funcs_set_sweep_gradient_func (funcs, paint_sweep_gradient, NULL, NULL);
|
|
|
|
hb_paint_funcs_make_immutable (funcs);
|
|
}
|
|
|
|
return funcs;
|
|
}
|
|
|
|
typedef struct {
|
|
const char *font_file;
|
|
float slant;
|
|
hb_codepoint_t glyph;
|
|
unsigned int palette;
|
|
const char *output;
|
|
} paint_test_t;
|
|
|
|
#define NOTO_HAND "fonts/noto_handwriting-cff2_colr_1.otf"
|
|
#define TEST_GLYPHS "fonts/test_glyphs-glyf_colr_1.ttf"
|
|
#define TEST_GLYPHS_VF "fonts/test_glyphs-glyf_colr_1_variable.ttf"
|
|
#define BAD_COLRV1 "fonts/bad_colrv1.ttf"
|
|
#define ROCHER_ABC "fonts/RocherColorGX.abc.ttf"
|
|
|
|
/* To verify the rendering visually, use
|
|
*
|
|
* hb-view --font-slant SLANT --font-palette PALETTE FONT --glyphs gidGID
|
|
*
|
|
* where GID is the glyph value of the test.
|
|
*/
|
|
static paint_test_t paint_tests[] = {
|
|
/* COLRv1 */
|
|
{ NOTO_HAND, 0., 10, 0, "hand-10" },
|
|
{ NOTO_HAND, 0.2f,10, 0, "hand-10.2" },
|
|
|
|
{ TEST_GLYPHS, 0, 6, 0, "test-6" }, // linear gradient
|
|
{ TEST_GLYPHS, 0, 10, 0, "test-10" }, // sweep gradient
|
|
{ TEST_GLYPHS, 0, 92, 0, "test-92" }, // radial gradient
|
|
{ TEST_GLYPHS, 0, 106, 0, "test-106" },
|
|
{ TEST_GLYPHS, 0, 116, 0, "test-116" }, // compositing
|
|
{ TEST_GLYPHS, 0, 123, 0, "test-123" },
|
|
{ TEST_GLYPHS, 0, 154, 0, "test-154" },
|
|
{ TEST_GLYPHS, 0, 165, 0, "test-165" }, // linear gradient
|
|
{ TEST_GLYPHS, 0, 175, 0, "test-175" }, // layers
|
|
|
|
{ TEST_GLYPHS_VF, 0, 6, 0, "testvf-6" },
|
|
{ TEST_GLYPHS_VF, 0, 10, 0, "testvf-10" },
|
|
{ TEST_GLYPHS_VF, 0, 92, 0, "testvf-92" },
|
|
{ TEST_GLYPHS_VF, 0, 106, 0, "testvf-106" },
|
|
{ TEST_GLYPHS_VF, 0, 116, 0, "testvf-116" },
|
|
{ TEST_GLYPHS_VF, 0, 123, 0, "testvf-123" },
|
|
{ TEST_GLYPHS_VF, 0, 154, 0, "testvf-154" },
|
|
{ TEST_GLYPHS_VF, 0, 165, 0, "testvf-165" },
|
|
{ TEST_GLYPHS_VF, 0, 175, 0, "testvf-175" },
|
|
|
|
{ BAD_COLRV1, 0, 154, 0, "bad-154" }, // recursion
|
|
|
|
/* COLRv0 */
|
|
{ ROCHER_ABC, 0.3f, 1, 0, "rocher-1" },
|
|
{ ROCHER_ABC, 0.3f, 2, 2, "rocher-2" },
|
|
{ ROCHER_ABC, 0, 3, 200, "rocher-3" },
|
|
};
|
|
|
|
static void
|
|
test_hb_paint (gconstpointer d,
|
|
hb_bool_t use_ft HB_UNUSED)
|
|
{
|
|
const paint_test_t *test = d;
|
|
hb_face_t *face;
|
|
hb_font_t *font;
|
|
hb_paint_funcs_t *funcs;
|
|
paint_data_t data;
|
|
char *file;
|
|
char *buffer;
|
|
gsize len;
|
|
GError *error = NULL;
|
|
|
|
face = hb_test_open_font_file (test->font_file);
|
|
font = hb_font_create (face);
|
|
|
|
hb_font_set_synthetic_slant (font, test->slant);
|
|
|
|
#ifdef HB_HAS_FREETYPE
|
|
if (use_ft)
|
|
hb_ft_font_set_funcs (font);
|
|
#endif
|
|
|
|
funcs = get_test_paint_funcs ();
|
|
|
|
data.string = g_string_new ("");
|
|
data.level = 0;
|
|
|
|
hb_font_paint_glyph (font, test->glyph, funcs, &data, 0, HB_COLOR (0, 0, 0, 255));
|
|
|
|
/* Run
|
|
*
|
|
* GENERATE_DATA=1 G_TEST_SRCDIR=./test/api ./build/test/api/test-paint
|
|
*
|
|
* to regenerate the expected output for all tests.
|
|
*/
|
|
file = g_test_build_filename (G_TEST_DIST, "results-paint", test->output, NULL);
|
|
if (getenv ("GENERATE_DATA"))
|
|
{
|
|
if (!g_file_set_contents (file, data.string->str, data.string->len, NULL))
|
|
g_error ("Failed to write %s.", file);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!g_file_get_contents (file, &buffer, &len, &error))
|
|
{
|
|
g_test_message ("File %s not found.", file);
|
|
g_test_fail ();
|
|
return;
|
|
}
|
|
|
|
char **lines = g_strsplit (data.string->str, "\n", 0);
|
|
char **expected;
|
|
if (strstr (buffer, "\r\n"))
|
|
expected = g_strsplit (buffer, "\r\n", 0);
|
|
else
|
|
expected = g_strsplit (buffer, "\n", 0);
|
|
|
|
if (g_strv_length (lines) != g_strv_length (expected))
|
|
{
|
|
g_test_message ("Unexpected number of lines in output (%d instead of %d):\n%s", g_strv_length (lines), g_strv_length (expected), data.string->str);
|
|
g_test_fail ();
|
|
}
|
|
else
|
|
{
|
|
unsigned int length = g_strv_length (lines);
|
|
for (unsigned int i = 0; i < length; i++)
|
|
{
|
|
if (strcmp (lines[i], expected[i]) != 0)
|
|
{
|
|
int pos;
|
|
for (pos = 0; lines[i][pos]; pos++)
|
|
if (lines[i][pos] != expected[i][pos])
|
|
break;
|
|
|
|
g_test_message ("Unexpected output at %d:%d (%c instead of %c):\n%s", i, pos, lines[i][pos], expected[i][pos], data.string->str);
|
|
g_test_fail ();
|
|
}
|
|
}
|
|
}
|
|
|
|
g_strfreev (lines);
|
|
g_strfreev (expected);
|
|
|
|
g_free (buffer);
|
|
g_free (file);
|
|
|
|
g_string_free (data.string, TRUE);
|
|
|
|
hb_font_destroy (font);
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
static void
|
|
test_compare_to_ot (const char *file, hb_codepoint_t glyph)
|
|
{
|
|
hb_face_t *face;
|
|
hb_font_t *font;
|
|
hb_paint_funcs_t *funcs;
|
|
GString *ot_str;
|
|
paint_data_t data;
|
|
|
|
face = hb_test_open_font_file (file);
|
|
font = hb_font_create (face);
|
|
|
|
funcs = get_test_paint_funcs ();
|
|
|
|
data.string = g_string_new ("");
|
|
data.level = 0;
|
|
|
|
hb_font_paint_glyph (font, glyph, funcs, &data, 0, HB_COLOR (0, 0, 0, 255));
|
|
|
|
g_assert_true (data.level == 0);
|
|
|
|
ot_str = data.string;
|
|
|
|
#ifdef HB_HAS_FREETYPE
|
|
hb_ft_font_set_funcs (font);
|
|
#endif
|
|
|
|
data.string = g_string_new ("");
|
|
data.level = 0;
|
|
|
|
hb_font_paint_glyph (font, glyph, funcs, &data, 0, HB_COLOR (0, 0, 0, 255));
|
|
|
|
g_assert_true (data.level == 0);
|
|
|
|
g_assert_cmpstr (ot_str->str, ==, data.string->str);
|
|
|
|
g_string_free (data.string, TRUE);
|
|
hb_font_destroy (font);
|
|
hb_face_destroy (face);
|
|
|
|
g_string_free (ot_str, TRUE);
|
|
}
|
|
|
|
static void
|
|
test_hb_paint_ot (gconstpointer data)
|
|
{
|
|
test_hb_paint (data, 0);
|
|
}
|
|
|
|
static void
|
|
test_hb_paint_ft (gconstpointer data)
|
|
{
|
|
if (have_ft_colrv1 ())
|
|
test_hb_paint (data, 1);
|
|
else
|
|
g_test_skip ("FreeType COLRv1 support not present");
|
|
}
|
|
|
|
static void
|
|
test_compare_to_ot_novf (gconstpointer d)
|
|
{
|
|
test_compare_to_ot (TEST_GLYPHS, GPOINTER_TO_UINT (d));
|
|
}
|
|
|
|
static void
|
|
test_compare_to_ot_vf (gconstpointer d)
|
|
{
|
|
test_compare_to_ot (TEST_GLYPHS_VF, GPOINTER_TO_UINT (d));
|
|
}
|
|
|
|
static void
|
|
scrutinize_linear_gradient (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_color_line_t *color_line,
|
|
float x0 HB_UNUSED, float y0 HB_UNUSED,
|
|
float x1 HB_UNUSED, float y1 HB_UNUSED,
|
|
float x2 HB_UNUSED, float y2 HB_UNUSED,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
hb_bool_t *result = paint_data;
|
|
hb_color_stop_t *stops;
|
|
unsigned int len;
|
|
hb_color_stop_t *stops2;
|
|
unsigned int len2;
|
|
|
|
*result = FALSE;
|
|
|
|
len = hb_color_line_get_color_stops (color_line, 0, NULL, NULL);
|
|
if (len == 0)
|
|
return;
|
|
|
|
stops = malloc (len * sizeof (hb_color_stop_t));
|
|
stops2 = malloc (len * sizeof (hb_color_stop_t));
|
|
|
|
hb_color_line_get_color_stops (color_line, 0, &len, stops);
|
|
hb_color_line_get_color_stops (color_line, 0, &len, stops2);
|
|
|
|
// check that we can get stops twice
|
|
if (memcmp (stops, stops2, len * sizeof (hb_color_stop_t)) != 0)
|
|
{
|
|
free (stops);
|
|
free (stops2);
|
|
return;
|
|
}
|
|
|
|
// check that we can get a single stop in the middle
|
|
len2 = 1;
|
|
hb_color_line_get_color_stops (color_line, len - 1, &len2, stops2);
|
|
if (memcmp (&stops[len - 1], stops2, sizeof (hb_color_stop_t)) != 0)
|
|
{
|
|
free (stops);
|
|
free (stops2);
|
|
return;
|
|
}
|
|
|
|
free (stops);
|
|
free (stops2);
|
|
|
|
*result = TRUE;
|
|
}
|
|
|
|
static void
|
|
test_color_stops (hb_bool_t use_ft HB_UNUSED)
|
|
{
|
|
hb_face_t *face;
|
|
hb_font_t *font;
|
|
hb_paint_funcs_t *funcs;
|
|
hb_bool_t result = FALSE;
|
|
|
|
face = hb_test_open_font_file (NOTO_HAND);
|
|
font = hb_font_create (face);
|
|
|
|
#ifdef HB_HAS_FREETYPE
|
|
if (use_ft)
|
|
hb_ft_font_set_funcs (font);
|
|
#endif
|
|
|
|
funcs = hb_paint_funcs_create ();
|
|
hb_paint_funcs_set_linear_gradient_func (funcs, scrutinize_linear_gradient, NULL, NULL);
|
|
|
|
hb_font_paint_glyph (font, 10, funcs, &result, 0, HB_COLOR (0, 0, 0, 255));
|
|
|
|
g_assert_true (result);
|
|
|
|
hb_paint_funcs_destroy (funcs);
|
|
hb_font_destroy (font);
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
static void
|
|
test_color_stops_ot (void)
|
|
{
|
|
test_color_stops (0);
|
|
}
|
|
|
|
static void
|
|
test_color_stops_ft (void)
|
|
{
|
|
if (have_ft_colrv1 ())
|
|
test_color_stops (1);
|
|
else
|
|
g_test_skip ("FreeType COLRv1 support not present");
|
|
}
|
|
|
|
|
|
typedef struct
|
|
{
|
|
hb_font_t *font;
|
|
hb_paint_funcs_t *empty_funcs;
|
|
GString *colors;
|
|
unsigned int gradients[3];
|
|
unsigned int palette_calls;
|
|
hb_bool_t reenter;
|
|
} reentrant_paint_t;
|
|
|
|
static void
|
|
reentrant_query_font (reentrant_paint_t *data)
|
|
{
|
|
if (data->reenter)
|
|
{
|
|
hb_glyph_extents_t extents;
|
|
hb_font_get_glyph_extents (data->font, 8, &extents);
|
|
}
|
|
}
|
|
|
|
static hb_bool_t
|
|
reentrant_palette (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
unsigned int color_index HB_UNUSED,
|
|
hb_color_t *color HB_UNUSED,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
reentrant_paint_t *data = paint_data;
|
|
reentrant_query_font (data);
|
|
if (data->reenter)
|
|
/* A nested paint selects a different FreeType palette. */
|
|
hb_font_paint_glyph (data->font, 8, data->empty_funcs, NULL, 1,
|
|
HB_COLOR (0, 0, 0, 255));
|
|
data->palette_calls++;
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
reentrant_color (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
hb_bool_t is_foreground,
|
|
hb_color_t color,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
reentrant_paint_t *data = paint_data;
|
|
reentrant_query_font (data);
|
|
g_string_append_printf (data->colors, "c %u %u;", is_foreground, color);
|
|
}
|
|
|
|
static void
|
|
reentrant_gradient (reentrant_paint_t *data, hb_color_line_t *line, unsigned int kind)
|
|
{
|
|
unsigned int total = hb_color_line_get_color_stops (line, 0, NULL, NULL);
|
|
hb_color_stop_t *stops = g_new0 (hb_color_stop_t, total);
|
|
hb_color_stop_t *again = g_new0 (hb_color_stop_t, total);
|
|
unsigned int count = total;
|
|
|
|
reentrant_query_font (data);
|
|
hb_color_line_get_color_stops (line, 0, &count, stops);
|
|
g_assert_cmpuint (count, ==, total);
|
|
reentrant_query_font (data);
|
|
count = total;
|
|
hb_color_line_get_color_stops (line, 0, &count, again);
|
|
g_assert_cmpuint (count, ==, total);
|
|
|
|
for (unsigned int i = 0; i < total; i++)
|
|
{
|
|
g_assert_cmpfloat (stops[i].offset, ==, again[i].offset);
|
|
g_assert_cmpuint (stops[i].color, ==, again[i].color);
|
|
g_assert_cmpuint (stops[i].is_foreground, ==, again[i].is_foreground);
|
|
count = 1;
|
|
hb_color_line_get_color_stops (line, i, &count, again);
|
|
g_assert_cmpuint (count, ==, 1);
|
|
g_assert_cmpuint (stops[i].color, ==, again[0].color);
|
|
g_string_append_printf (data->colors, "g%u %u %u;", kind,
|
|
stops[i].is_foreground, stops[i].color);
|
|
}
|
|
data->gradients[kind]++;
|
|
g_free (again);
|
|
g_free (stops);
|
|
}
|
|
|
|
static void
|
|
reentrant_linear (hb_paint_funcs_t *funcs HB_UNUSED, void *paint_data,
|
|
hb_color_line_t *line,
|
|
float x0 HB_UNUSED, float y0 HB_UNUSED,
|
|
float x1 HB_UNUSED, float y1 HB_UNUSED,
|
|
float x2 HB_UNUSED, float y2 HB_UNUSED,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
reentrant_gradient (paint_data, line, 0);
|
|
}
|
|
|
|
static void
|
|
reentrant_radial (hb_paint_funcs_t *funcs HB_UNUSED, void *paint_data,
|
|
hb_color_line_t *line,
|
|
float x0 HB_UNUSED, float y0 HB_UNUSED, float r0 HB_UNUSED,
|
|
float x1 HB_UNUSED, float y1 HB_UNUSED, float r1 HB_UNUSED,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
reentrant_gradient (paint_data, line, 1);
|
|
}
|
|
|
|
static void
|
|
reentrant_sweep (hb_paint_funcs_t *funcs HB_UNUSED, void *paint_data,
|
|
hb_color_line_t *line,
|
|
float x0 HB_UNUSED, float y0 HB_UNUSED,
|
|
float start HB_UNUSED, float end HB_UNUSED,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
reentrant_gradient (paint_data, line, 2);
|
|
}
|
|
|
|
static void
|
|
test_ft_reentrant_paint (void)
|
|
{
|
|
if (!have_ft_colrv1 ())
|
|
{
|
|
g_test_skip ("FreeType COLRv1 support not present");
|
|
return;
|
|
}
|
|
#if GLIB_CHECK_VERSION(2,38,0)
|
|
if (!g_test_subprocess ())
|
|
{
|
|
g_test_trap_subprocess (NULL, 5 * G_USEC_PER_SEC, 0);
|
|
g_test_trap_assert_passed ();
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
static const hb_codepoint_t glyphs[] = {8, 12, 94, 116, 177};
|
|
hb_face_t *face = hb_test_open_font_file (TEST_GLYPHS);
|
|
hb_font_t *font = hb_font_create (face);
|
|
hb_paint_funcs_t *funcs = hb_paint_funcs_create ();
|
|
hb_paint_funcs_t *empty_funcs = hb_paint_funcs_create ();
|
|
reentrant_paint_t data = {font, empty_funcs, g_string_new (""), {0, 0, 0}, 0, FALSE};
|
|
|
|
hb_paint_funcs_set_color_func (funcs, reentrant_color, NULL, NULL);
|
|
hb_paint_funcs_set_custom_palette_color_func (funcs, reentrant_palette, NULL, NULL);
|
|
hb_paint_funcs_set_linear_gradient_func (funcs, reentrant_linear, NULL, NULL);
|
|
hb_paint_funcs_set_radial_gradient_func (funcs, reentrant_radial, NULL, NULL);
|
|
hb_paint_funcs_set_sweep_gradient_func (funcs, reentrant_sweep, NULL, NULL);
|
|
|
|
/* Get reference colors before enabling font reentry and nested paints. */
|
|
for (unsigned int i = 0; i < G_N_ELEMENTS (glyphs); i++)
|
|
hb_font_paint_glyph (font, glyphs[i], funcs, &data, 0, HB_COLOR (0, 0, 0, 255));
|
|
char *expected = g_strdup (data.colors->str);
|
|
g_string_truncate (data.colors, 0);
|
|
data.reenter = TRUE;
|
|
data.palette_calls = 0;
|
|
#ifdef HB_HAS_FREETYPE
|
|
hb_ft_font_set_funcs (font);
|
|
#endif
|
|
|
|
for (unsigned int i = 0; i < G_N_ELEMENTS (glyphs); i++)
|
|
hb_font_paint_glyph (font, glyphs[i], funcs, &data, 0, HB_COLOR (0, 0, 0, 255));
|
|
|
|
g_assert_cmpstr (data.colors->str, ==, expected);
|
|
g_assert_cmpuint (data.palette_calls, >, 0);
|
|
for (unsigned int i = 0; i < 3; i++)
|
|
g_assert_cmpuint (data.gradients[i], >, 0);
|
|
|
|
g_free (expected);
|
|
g_string_free (data.colors, TRUE);
|
|
hb_paint_funcs_destroy (empty_funcs);
|
|
hb_paint_funcs_destroy (funcs);
|
|
hb_font_destroy (font);
|
|
hb_face_destroy (face);
|
|
}
|
|
|
|
|
|
/* ── Arbitrary-path clip API (push_clip_path_start/_end) ─────────── */
|
|
|
|
static void
|
|
test_push_clip_path_nil_returns_null (void)
|
|
{
|
|
/* Unset callbacks fall through to nil stubs; start must return
|
|
* NULL + clear draw_data so callers know the backend can't do
|
|
* arbitrary-path clipping. */
|
|
hb_paint_funcs_t *funcs = hb_paint_funcs_create ();
|
|
void *draw_data = (void *) 0xdeadbeef;
|
|
hb_draw_funcs_t *df = hb_paint_push_clip_path_start (funcs, NULL, &draw_data);
|
|
g_assert_null (df);
|
|
g_assert_null (draw_data);
|
|
|
|
/* end is a no-op on the nil stub. */
|
|
hb_paint_push_clip_path_end (funcs, NULL);
|
|
|
|
/* Also: NULL draw_data must be accepted; the entry point routes
|
|
* it through an internal scratch. */
|
|
df = hb_paint_push_clip_path_start (funcs, NULL, NULL);
|
|
g_assert_null (df);
|
|
|
|
hb_paint_funcs_destroy (funcs);
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
int move_to_calls;
|
|
int line_to_calls;
|
|
int close_path_calls;
|
|
float last_x, last_y;
|
|
hb_bool_t start_called;
|
|
hb_bool_t end_called;
|
|
int pop_clip_calls;
|
|
hb_draw_funcs_t *start_draw_funcs_out;
|
|
} clip_path_rec_t;
|
|
|
|
static void
|
|
clip_path_sink_move_to (hb_draw_funcs_t *funcs HB_UNUSED,
|
|
void *draw_data,
|
|
hb_draw_state_t *st HB_UNUSED,
|
|
float x, float y,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
clip_path_rec_t *r = (clip_path_rec_t *) draw_data;
|
|
r->move_to_calls++;
|
|
r->last_x = x; r->last_y = y;
|
|
}
|
|
|
|
static void
|
|
clip_path_sink_line_to (hb_draw_funcs_t *funcs HB_UNUSED,
|
|
void *draw_data,
|
|
hb_draw_state_t *st HB_UNUSED,
|
|
float x, float y,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
clip_path_rec_t *r = (clip_path_rec_t *) draw_data;
|
|
r->line_to_calls++;
|
|
r->last_x = x; r->last_y = y;
|
|
}
|
|
|
|
static void
|
|
clip_path_sink_close_path (hb_draw_funcs_t *funcs HB_UNUSED,
|
|
void *draw_data,
|
|
hb_draw_state_t *st HB_UNUSED,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
clip_path_rec_t *r = (clip_path_rec_t *) draw_data;
|
|
r->close_path_calls++;
|
|
}
|
|
|
|
static hb_draw_funcs_t *
|
|
clip_path_start_cb (hb_paint_funcs_t *pfuncs HB_UNUSED,
|
|
void *paint_data,
|
|
void **draw_data,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
clip_path_rec_t *r = (clip_path_rec_t *) paint_data;
|
|
r->start_called = TRUE;
|
|
*draw_data = r;
|
|
return r->start_draw_funcs_out;
|
|
}
|
|
|
|
static void
|
|
clip_path_end_cb (hb_paint_funcs_t *pfuncs HB_UNUSED,
|
|
void *paint_data,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
clip_path_rec_t *r = (clip_path_rec_t *) paint_data;
|
|
r->end_called = TRUE;
|
|
}
|
|
|
|
static void
|
|
clip_path_pop_clip_cb (hb_paint_funcs_t *pfuncs HB_UNUSED,
|
|
void *paint_data,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
clip_path_rec_t *r = (clip_path_rec_t *) paint_data;
|
|
r->pop_clip_calls++;
|
|
}
|
|
|
|
/* Round-trip: registered start/end fire in order, the returned
|
|
* draw-funcs + draw-data propagate to the caller, and every
|
|
* hb_draw_*() call on those funcs reaches the accumulator. */
|
|
static void
|
|
test_push_clip_path_round_trip (void)
|
|
{
|
|
hb_draw_funcs_t *sink = hb_draw_funcs_create ();
|
|
hb_draw_funcs_set_move_to_func (sink, clip_path_sink_move_to, NULL, NULL);
|
|
hb_draw_funcs_set_line_to_func (sink, clip_path_sink_line_to, NULL, NULL);
|
|
hb_draw_funcs_set_close_path_func (sink, clip_path_sink_close_path, NULL, NULL);
|
|
hb_draw_funcs_make_immutable (sink);
|
|
|
|
clip_path_rec_t r = {0};
|
|
r.start_draw_funcs_out = sink;
|
|
|
|
hb_paint_funcs_t *pfuncs = hb_paint_funcs_create ();
|
|
hb_paint_funcs_set_push_clip_path_start_func (pfuncs, clip_path_start_cb, NULL, NULL);
|
|
hb_paint_funcs_set_push_clip_path_end_func (pfuncs, clip_path_end_cb, NULL, NULL);
|
|
hb_paint_funcs_set_pop_clip_func (pfuncs, clip_path_pop_clip_cb, NULL, NULL);
|
|
hb_paint_funcs_make_immutable (pfuncs);
|
|
|
|
void *draw_data = NULL;
|
|
hb_draw_funcs_t *df = hb_paint_push_clip_path_start (pfuncs, &r, &draw_data);
|
|
|
|
g_assert_true (r.start_called);
|
|
g_assert_nonnull (df);
|
|
g_assert_true (df == sink);
|
|
g_assert_true (draw_data == &r);
|
|
|
|
hb_draw_state_t st = HB_DRAW_STATE_DEFAULT;
|
|
hb_draw_move_to (df, draw_data, &st, 1.f, 2.f);
|
|
hb_draw_line_to (df, draw_data, &st, 3.f, 4.f);
|
|
hb_draw_line_to (df, draw_data, &st, 5.f, 6.f);
|
|
hb_draw_close_path (df, draw_data, &st);
|
|
|
|
g_assert_cmpint (r.move_to_calls, ==, 1);
|
|
/* hb_draw_close_path synthesizes a line_to back to the contour
|
|
* start, so our two explicit line_tos show up as three. */
|
|
g_assert_cmpint (r.line_to_calls, ==, 3);
|
|
g_assert_cmpint (r.close_path_calls, ==, 1);
|
|
/* The synthetic closing line_to took the pen back to the
|
|
* move_to point (1, 2). */
|
|
g_assert_cmpfloat (r.last_x, ==, 1.f);
|
|
g_assert_cmpfloat (r.last_y, ==, 2.f);
|
|
|
|
hb_paint_push_clip_path_end (pfuncs, &r);
|
|
g_assert_true (r.end_called);
|
|
|
|
hb_paint_pop_clip (pfuncs, &r);
|
|
g_assert_cmpint (r.pop_clip_calls, ==, 1);
|
|
|
|
hb_paint_funcs_destroy (pfuncs);
|
|
hb_draw_funcs_destroy (sink);
|
|
}
|
|
|
|
/* Test the default implementation of fill_glyph does the
|
|
* push_clip_glyph + color + pop_clip sequence. */
|
|
static void
|
|
test_fill_glyph_nil_decomposes (void)
|
|
{
|
|
hb_paint_funcs_t *funcs = hb_paint_funcs_create ();
|
|
hb_paint_funcs_set_push_clip_glyph_func (funcs, push_clip_glyph, NULL, NULL);
|
|
hb_paint_funcs_set_color_func (funcs, paint_color, NULL, NULL);
|
|
hb_paint_funcs_set_pop_clip_func (funcs, pop_clip, NULL, NULL);
|
|
hb_paint_funcs_make_immutable (funcs);
|
|
|
|
paint_data_t data;
|
|
data.string = g_string_new ("");
|
|
data.level = 0;
|
|
|
|
hb_paint_fill_glyph (funcs, &data, 42, hb_font_get_empty (),
|
|
FALSE, HB_COLOR (1, 2, 3, 4));
|
|
|
|
g_assert_true (data.level == 0);
|
|
g_assert_cmpstr (data.string->str, ==,
|
|
"start clip glyph 42\n"
|
|
" solid 3 2 1 4\n"
|
|
"end clip\n");
|
|
|
|
g_string_free (data.string, TRUE);
|
|
hb_paint_funcs_destroy (funcs);
|
|
}
|
|
|
|
static void *color_glyph_user_data_seen;
|
|
|
|
static hb_bool_t
|
|
color_glyph_record_user_data (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data HB_UNUSED,
|
|
hb_codepoint_t glyph HB_UNUSED,
|
|
hb_font_t *font HB_UNUSED,
|
|
void *user_data)
|
|
{
|
|
color_glyph_user_data_seen = user_data;
|
|
return TRUE;
|
|
}
|
|
|
|
/* Each callback must be handed the user_data it was registered with,
|
|
* not another callback's. */
|
|
static void
|
|
test_color_glyph_user_data (void)
|
|
{
|
|
char color_glyph_ctx = 0;
|
|
char push_clip_glyph_ctx = 0;
|
|
|
|
hb_paint_funcs_t *funcs = hb_paint_funcs_create ();
|
|
hb_paint_funcs_set_color_glyph_func (funcs, color_glyph_record_user_data,
|
|
&color_glyph_ctx, NULL);
|
|
hb_paint_funcs_set_push_clip_glyph_func (funcs, push_clip_glyph,
|
|
&push_clip_glyph_ctx, NULL);
|
|
hb_paint_funcs_make_immutable (funcs);
|
|
|
|
color_glyph_user_data_seen = NULL;
|
|
hb_paint_color_glyph (funcs, NULL, 42, hb_font_get_empty ());
|
|
|
|
g_assert_true (color_glyph_user_data_seen == &color_glyph_ctx);
|
|
|
|
hb_paint_funcs_destroy (funcs);
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
int64_t policy;
|
|
int64_t live;
|
|
} paint_budget_data_t;
|
|
|
|
static hb_bool_t
|
|
paint_set_budget (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
int64_t budget,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
paint_budget_data_t *data = (paint_budget_data_t *) paint_data;
|
|
data->policy = budget;
|
|
data->live = budget == HB_BUDGET_DEFAULT ? 4321 : budget;
|
|
return TRUE;
|
|
}
|
|
|
|
static int64_t
|
|
paint_get_budget (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
return ((paint_budget_data_t *) paint_data)->policy;
|
|
}
|
|
|
|
static int64_t *
|
|
paint_get_budget_remaining (hb_paint_funcs_t *funcs HB_UNUSED,
|
|
void *paint_data,
|
|
void *user_data HB_UNUSED)
|
|
{
|
|
return &((paint_budget_data_t *) paint_data)->live;
|
|
}
|
|
|
|
static void
|
|
test_hb_paint_budget (void)
|
|
{
|
|
paint_budget_data_t data = {HB_BUDGET_DEFAULT, 4321};
|
|
hb_paint_funcs_t *funcs = hb_paint_funcs_create ();
|
|
|
|
g_assert_false (hb_paint_set_budget (funcs, &data, 100));
|
|
g_assert_cmpint (hb_paint_get_budget (funcs, &data), ==, HB_BUDGET_DEFAULT);
|
|
g_assert_cmpint (hb_paint_get_budget_remaining (funcs, &data), ==, HB_BUDGET_UNLIMITED);
|
|
|
|
hb_paint_funcs_set_set_budget_func (funcs, paint_set_budget, NULL, NULL);
|
|
hb_paint_funcs_set_get_budget_func (funcs, paint_get_budget, NULL, NULL);
|
|
hb_paint_funcs_set_get_budget_remaining_func (funcs, paint_get_budget_remaining, NULL, NULL);
|
|
|
|
g_assert_true (hb_paint_set_budget (funcs, &data, -7));
|
|
g_assert_cmpint (hb_paint_get_budget (funcs, &data), ==, 0);
|
|
g_assert_cmpint (hb_paint_get_budget_remaining (funcs, &data), ==, 0);
|
|
|
|
g_assert_true (hb_paint_set_budget (funcs, &data, HB_BUDGET_DEFAULT));
|
|
g_assert_cmpint (hb_paint_get_budget (funcs, &data), ==, HB_BUDGET_DEFAULT);
|
|
g_assert_cmpint (hb_paint_get_budget_remaining (funcs, &data), ==, 4321);
|
|
|
|
g_assert_true (hb_paint_set_budget (funcs, &data, 9876));
|
|
g_assert_cmpint (hb_paint_get_budget (funcs, &data), ==, 9876);
|
|
g_assert_cmpint (hb_paint_get_budget_remaining (funcs, &data), ==, 9876);
|
|
|
|
g_assert_true (hb_paint_set_budget (funcs, &data, HB_BUDGET_UNLIMITED));
|
|
g_assert_cmpint (hb_paint_get_budget (funcs, &data), ==, HB_BUDGET_UNLIMITED);
|
|
g_assert_cmpint (hb_paint_get_budget_remaining (funcs, &data), ==, HB_BUDGET_UNLIMITED);
|
|
|
|
hb_paint_funcs_destroy (funcs);
|
|
}
|
|
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
int status = 0;
|
|
|
|
hb_test_init (&argc, &argv);
|
|
|
|
/* Register font-free API tests first so the missing-font bail
|
|
* below doesn't prevent them from running. */
|
|
hb_test_add (test_push_clip_path_nil_returns_null);
|
|
hb_test_add (test_push_clip_path_round_trip);
|
|
hb_test_add (test_fill_glyph_nil_decomposes);
|
|
hb_test_add (test_color_glyph_user_data);
|
|
hb_test_add (test_hb_paint_budget);
|
|
|
|
for (unsigned int i = 0; i < G_N_ELEMENTS (paint_tests); i++)
|
|
{
|
|
hb_test_add_data_flavor (&paint_tests[i], paint_tests[i].output, test_hb_paint_ot);
|
|
hb_test_add_data_flavor (&paint_tests[i], paint_tests[i].output, test_hb_paint_ft);
|
|
}
|
|
|
|
hb_face_t *face = hb_test_open_font_file (TEST_GLYPHS);
|
|
unsigned glyph_count = hb_face_get_glyph_count (face);
|
|
const char **font_funcs = hb_font_list_funcs ();
|
|
for (const char **font_func = font_funcs; *font_func; font_func++)
|
|
{
|
|
if (strcmp (*font_func, "ot") == 0)
|
|
continue;
|
|
if (!have_ft_colrv1 () && strcmp (*font_func, "ft") == 0)
|
|
continue;
|
|
for (unsigned int i = 1; i < glyph_count; i++)
|
|
{
|
|
char buf[32];
|
|
snprintf (buf, 32, "test-%s-%u", *font_func, i);
|
|
hb_test_add_data_flavor (GUINT_TO_POINTER (i), buf, test_compare_to_ot_novf);
|
|
hb_test_add_data_flavor (GUINT_TO_POINTER (i), buf, test_compare_to_ot_vf);
|
|
}
|
|
}
|
|
hb_face_destroy (face);
|
|
|
|
hb_test_add (test_color_stops_ot);
|
|
hb_test_add (test_color_stops_ft);
|
|
hb_test_add (test_ft_reentrant_paint);
|
|
|
|
status = hb_test_run();
|
|
|
|
return status;
|
|
}
|