organicmaps/harfbuzz
13
Fork 0
mirror of https://github.com/harfbuzz/harfbuzz.git synced 2025-04-13 08:42:59 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 7

[test/api] Use g_assert_true instead of g_assert

Browse source 
The latter terminates the program. The former marks the test
as failing.
This commit is contained in:
Behdad Esfahbod 2025-04-06 03:49:15 -06:00
parent f73039422e
commit 155e1e633b
37 changed files with 957 additions and 957 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
test/api/hb-subset-test.h
View file

@ -73,7 +73,7 @@ hb_subset_test_create_subset (hb_face_t *source,
hb_subset_input_t *input)
{
hb_face_t *subset = hb_subset_or_fail (source, input);
g_assert (subset);
g_assert_true (subset);
hb_subset_input_destroy (input);
return subset;

4
test/api/test-aat-layout.c
View file

@ -108,11 +108,11 @@ test_aat_has (void)
{
hb_face_t *morx = hb_test_open_font_file ("fonts/aat-morx.ttf");
hb_face_t *trak;
g_assert (hb_aat_layout_has_substitution (morx));
g_assert_true (hb_aat_layout_has_substitution (morx));
hb_face_destroy (morx);
trak = hb_test_open_font_file ("fonts/aat-trak.ttf");
g_assert (hb_aat_layout_has_tracking (trak));
g_assert_true (hb_aat_layout_has_tracking (trak));
hb_face_destroy (trak);
}

18
test/api/test-base-minmax.c
View file

@ -36,19 +36,19 @@ test_ot_layout_font_extents (void)
hb_font_extents_t extents;
g_assert (hb_ot_layout_get_font_extents2 (font, HB_DIRECTION_LTR,
HB_SCRIPT_LATIN, HB_LANGUAGE_INVALID,
&extents));
g_assert_true (hb_ot_layout_get_font_extents2 (font, HB_DIRECTION_LTR,
HB_SCRIPT_LATIN, HB_LANGUAGE_INVALID,
&extents));
g_assert_cmpint (extents.ascender, ==, 2000);
g_assert (hb_ot_layout_get_font_extents2 (font, HB_DIRECTION_LTR,
HB_SCRIPT_LATIN, hb_language_from_string ("xx", -1),
&extents));
g_assert_true (hb_ot_layout_get_font_extents2 (font, HB_DIRECTION_LTR,
HB_SCRIPT_LATIN, hb_language_from_string ("xx", -1),
&extents));
g_assert_cmpint (extents.ascender, ==, 2000);
g_assert (!hb_ot_layout_get_font_extents2 (font, HB_DIRECTION_LTR,
HB_SCRIPT_ARABIC, HB_LANGUAGE_INVALID,
&extents));
g_assert_true (!hb_ot_layout_get_font_extents2 (font, HB_DIRECTION_LTR,
HB_SCRIPT_ARABIC, HB_LANGUAGE_INVALID,
&extents));
g_assert_cmpint (extents.ascender, ==, 3000);
hb_font_destroy (font);

24
test/api/test-baseline.c
View file

@ -35,22 +35,22 @@ test_ot_layout_base (void)
hb_font_t *font = hb_font_create (face);
hb_position_t position;
g_assert (hb_ot_layout_get_baseline (font, HB_OT_LAYOUT_BASELINE_TAG_IDEO_FACE_BOTTOM_OR_LEFT, HB_DIRECTION_TTB,
HB_TAG ('h','a','n','i'),
HB_TAG ('E','N','G',' '),
&position));
g_assert_true (hb_ot_layout_get_baseline (font, HB_OT_LAYOUT_BASELINE_TAG_IDEO_FACE_BOTTOM_OR_LEFT, HB_DIRECTION_TTB,
HB_TAG ('h','a','n','i'),
HB_TAG ('E','N','G',' '),
&position));
g_assert_cmpint (46, ==, position);
g_assert (hb_ot_layout_get_baseline2 (font, HB_OT_LAYOUT_BASELINE_TAG_IDEO_FACE_BOTTOM_OR_LEFT, HB_DIRECTION_TTB,
HB_SCRIPT_HAN,
hb_language_from_string ("en", -1),
&position));
g_assert_true (hb_ot_layout_get_baseline2 (font, HB_OT_LAYOUT_BASELINE_TAG_IDEO_FACE_BOTTOM_OR_LEFT, HB_DIRECTION_TTB,
HB_SCRIPT_HAN,
hb_language_from_string ("en", -1),
&position));
g_assert_cmpint (46, ==, position);
g_assert (!hb_ot_layout_get_baseline (font, HB_OT_LAYOUT_BASELINE_TAG_IDEO_EMBOX_TOP_OR_RIGHT, HB_DIRECTION_TTB,
HB_TAG ('h','a','n','i'),
HB_TAG ('E','N','G',' '),
&position));
g_assert_true (!hb_ot_layout_get_baseline (font, HB_OT_LAYOUT_BASELINE_TAG_IDEO_EMBOX_TOP_OR_RIGHT, HB_DIRECTION_TTB,
HB_TAG ('h','a','n','i'),
HB_TAG ('E','N','G',' '),
&position));
hb_font_destroy (font);
hb_face_destroy (face);

70
test/api/test-blob.c
View file

@ -50,31 +50,31 @@ test_blob_empty (void)
const char *data;
char *data_writable;
g_assert (hb_blob_is_immutable (hb_blob_get_empty ()));
g_assert (hb_blob_get_empty () != NULL);
g_assert (hb_blob_get_empty () == hb_blob_create (NULL, 0, HB_MEMORY_MODE_READONLY, NULL, NULL));
g_assert (hb_blob_get_empty () == hb_blob_create ("asdf", 0, HB_MEMORY_MODE_READONLY, NULL, NULL));
g_assert (hb_blob_get_empty () == hb_blob_create (NULL, -1, HB_MEMORY_MODE_READONLY, NULL, NULL));
g_assert (hb_blob_get_empty () == hb_blob_create ("asdfg", -1, HB_MEMORY_MODE_READONLY, NULL, NULL));
g_assert_true (hb_blob_is_immutable (hb_blob_get_empty ()));
g_assert_true (hb_blob_get_empty () != NULL);
g_assert_true (hb_blob_get_empty () == hb_blob_create (NULL, 0, HB_MEMORY_MODE_READONLY, NULL, NULL));
g_assert_true (hb_blob_get_empty () == hb_blob_create ("asdf", 0, HB_MEMORY_MODE_READONLY, NULL, NULL));
g_assert_true (hb_blob_get_empty () == hb_blob_create (NULL, -1, HB_MEMORY_MODE_READONLY, NULL, NULL));
g_assert_true (hb_blob_get_empty () == hb_blob_create ("asdfg", -1, HB_MEMORY_MODE_READONLY, NULL, NULL));
blob = hb_blob_get_empty ();
g_assert (blob == hb_blob_get_empty ());
g_assert_true (blob == hb_blob_get_empty ());
len = hb_blob_get_length (blob);
g_assert_cmpint (len, ==, 0);
data = hb_blob_get_data (blob, NULL);
g_assert (data == NULL);
g_assert_true (data == NULL);
data = hb_blob_get_data (blob, &len);
g_assert (data == NULL);
g_assert_true (data == NULL);
g_assert_cmpint (len, ==, 0);
data_writable = hb_blob_get_data_writable (blob, NULL);
g_assert (data_writable == NULL);
g_assert_true (data_writable == NULL);
data_writable = hb_blob_get_data_writable (blob, &len);
g_assert (data_writable == NULL);
g_assert_true (data_writable == NULL);
g_assert_cmpint (len, ==, 0);
}
@ -126,7 +126,7 @@ get_pagesize (void)
pagesize = (uintptr_t) getpagesize ();
#endif
g_assert (pagesize != (uintptr_t) -1);
g_assert_true (pagesize != (uintptr_t) -1);
return pagesize;
}
@ -175,7 +175,7 @@ fixture_init (fixture_t *fixture, gconstpointer user_data)
uintptr_t pagesize = get_pagesize ();
data = mmap (NULL, pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
g_assert (data != (char *) -1);
g_assert_true (data != (char *) -1);
memcpy ((char *) data, test_data, sizeof (test_data));
mprotect ((char *) data, pagesize, PROT_READ);
len = sizeof (test_data);
@ -212,7 +212,7 @@ test_blob (fixture_t *fixture, gconstpointer user_data)
char *data_writable;
unsigned int i;
g_assert (b);
g_assert_true (b);
len = hb_blob_get_length (b);
g_assert_cmpint (len, ==, fixture->len);
@ -220,45 +220,45 @@ test_blob (fixture_t *fixture, gconstpointer user_data)
data = hb_blob_get_data (b, &len);
g_assert_cmpint (len, ==, fixture->len);
if (mm == HB_MEMORY_MODE_DUPLICATE) {
g_assert (data != fixture->data);
g_assert_true (data != fixture->data);
g_assert_cmpint (fixture->freed, ==, 1);
mm = HB_MEMORY_MODE_WRITABLE;
} else {
g_assert (data == fixture->data);
g_assert_true (data == fixture->data);
g_assert_cmpint (fixture->freed, ==, 0);
}
data_writable = hb_blob_get_data_writable (b, &len);
g_assert_cmpint (len, ==, fixture->len);
g_assert (data_writable);
g_assert (0 == memcmp (data_writable, fixture->data, fixture->len));
g_assert_true (data_writable);
g_assert_true (0 == memcmp (data_writable, fixture->data, fixture->len));
if (mm == HB_MEMORY_MODE_READONLY) {
g_assert (data_writable != data);
g_assert_true (data_writable != data);
g_assert_cmpint (fixture->freed, ==, 1);
} else {
g_assert (data_writable == data);
g_assert_true (data_writable == data);
}
data = hb_blob_get_data (b, &len);
g_assert_cmpint (len, ==, fixture->len);
g_assert (data == data_writable);
g_assert_true (data == data_writable);
memset (data_writable, 0, fixture->len);
/* Now, make it immutable and watch get_data_writable() fail */
g_assert (!hb_blob_is_immutable (b));
g_assert_true (!hb_blob_is_immutable (b));
hb_blob_make_immutable (b);
g_assert (hb_blob_is_immutable (b));
g_assert_true (hb_blob_is_immutable (b));
data_writable = hb_blob_get_data_writable (b, &len);
g_assert (!data_writable);
g_assert_true (!data_writable);
g_assert_cmpint (len, ==, 0);
data = hb_blob_get_data (b, &len);
g_assert_cmpint (len, ==, fixture->len);
for (i = 0; i < len; i++)
g_assert ('\0' == data[i]);
g_assert_true ('\0' == data[i]);
}
static void
@ -283,43 +283,43 @@ test_blob_subblob (fixture_t *fixture, gconstpointer user_data)
/* A sub-blob is always created READONLY. */
g_assert (b);
g_assert_true (b);
len = hb_blob_get_length (b);
g_assert_cmpint (len, ==, fixture->len - 2);
data = hb_blob_get_data (b, &len);
g_assert_cmpint (len, ==, fixture->len - 2);
g_assert (data == fixture->data + 1);
g_assert_true (data == fixture->data + 1);
data_writable = hb_blob_get_data_writable (b, &len);
g_assert_cmpint (len, ==, fixture->len - 2);
g_assert (data_writable);
g_assert_true (data_writable);
if (mm == HB_MEMORY_MODE_READONLY)
g_assert (0 == memcmp (data_writable, fixture->data + 1, fixture->len - 2));
g_assert (data_writable != data);
g_assert_true (0 == memcmp (data_writable, fixture->data + 1, fixture->len - 2));
g_assert_true (data_writable != data);
g_assert_cmpint (fixture->freed, ==, 1);
data = hb_blob_get_data (b, &len);
g_assert_cmpint (len, ==, fixture->len - 2);
g_assert (data == data_writable);
g_assert_true (data == data_writable);
memset (data_writable, 0, fixture->len - 2);
/* Now, make it immutable and watch get_data_writable() fail */
g_assert (!hb_blob_is_immutable (b));
g_assert_true (!hb_blob_is_immutable (b));
hb_blob_make_immutable (b);
g_assert (hb_blob_is_immutable (b));
g_assert_true (hb_blob_is_immutable (b));
data_writable = hb_blob_get_data_writable (b, &len);
g_assert (!data_writable);
g_assert_true (!data_writable);
g_assert_cmpint (len, ==, 0);
data = hb_blob_get_data (b, &len);
g_assert_cmpint (len, ==, fixture->len - 2);
for (i = 0; i < len; i++)
g_assert ('\0' == data[i]);
g_assert_true ('\0' == data[i]);
}

110
test/api/test-buffer.c
View file

@ -106,74 +106,74 @@ test_buffer_properties (fixture_t *fixture, gconstpointer user_data HB_UNUSED)
/* test default properties */
g_assert (hb_buffer_get_unicode_funcs (b) == hb_unicode_funcs_get_default ());
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
g_assert (hb_buffer_get_language (b) == NULL);
g_assert_true (hb_buffer_get_unicode_funcs (b) == hb_unicode_funcs_get_default ());
g_assert_true (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
g_assert_true (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
g_assert_true (hb_buffer_get_language (b) == NULL);
/* test property changes are retained */
ufuncs = hb_unicode_funcs_create (NULL);
hb_buffer_set_unicode_funcs (b, ufuncs);
hb_unicode_funcs_destroy (ufuncs);
g_assert (hb_buffer_get_unicode_funcs (b) == ufuncs);
g_assert_true (hb_buffer_get_unicode_funcs (b) == ufuncs);
hb_buffer_set_direction (b, HB_DIRECTION_RTL);
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_RTL);
g_assert_true (hb_buffer_get_direction (b) == HB_DIRECTION_RTL);
hb_buffer_set_script (b, HB_SCRIPT_ARABIC);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_ARABIC);
g_assert_true (hb_buffer_get_script (b) == HB_SCRIPT_ARABIC);
hb_buffer_set_language (b, hb_language_from_string ("fa", -1));
g_assert (hb_buffer_get_language (b) == hb_language_from_string ("Fa", -1));
g_assert_true (hb_buffer_get_language (b) == hb_language_from_string ("Fa", -1));
hb_buffer_set_flags (b, HB_BUFFER_FLAG_BOT);
g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_BOT);
g_assert_true (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_BOT);
hb_buffer_set_replacement_codepoint (b, (unsigned int) -1);
g_assert (hb_buffer_get_replacement_codepoint (b) == (unsigned int) -1);
g_assert_true (hb_buffer_get_replacement_codepoint (b) == (unsigned int) -1);
/* test clear_contents clears all these properties: */
hb_buffer_clear_contents (b);
g_assert (hb_buffer_get_unicode_funcs (b) == ufuncs);
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
g_assert (hb_buffer_get_language (b) == NULL);
g_assert_true (hb_buffer_get_unicode_funcs (b) == ufuncs);
g_assert_true (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
g_assert_true (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
g_assert_true (hb_buffer_get_language (b) == NULL);
/* but not these: */
g_assert (hb_buffer_get_flags (b) != HB_BUFFER_FLAG_DEFAULT);
g_assert (hb_buffer_get_replacement_codepoint (b) != HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT);
g_assert_true (hb_buffer_get_flags (b) != HB_BUFFER_FLAG_DEFAULT);
g_assert_true (hb_buffer_get_replacement_codepoint (b) != HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT);
/* test reset clears all properties */
hb_buffer_set_direction (b, HB_DIRECTION_RTL);
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_RTL);
g_assert_true (hb_buffer_get_direction (b) == HB_DIRECTION_RTL);
hb_buffer_set_script (b, HB_SCRIPT_ARABIC);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_ARABIC);
g_assert_true (hb_buffer_get_script (b) == HB_SCRIPT_ARABIC);
hb_buffer_set_language (b, hb_language_from_string ("fa", -1));
g_assert (hb_buffer_get_language (b) == hb_language_from_string ("Fa", -1));
g_assert_true (hb_buffer_get_language (b) == hb_language_from_string ("Fa", -1));
hb_buffer_set_flags (b, HB_BUFFER_FLAG_BOT);
g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_BOT);
g_assert_true (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_BOT);
hb_buffer_set_replacement_codepoint (b, (unsigned int) -1);
g_assert (hb_buffer_get_replacement_codepoint (b) == (unsigned int) -1);
g_assert_true (hb_buffer_get_replacement_codepoint (b) == (unsigned int) -1);
hb_buffer_reset (b);
g_assert (hb_buffer_get_unicode_funcs (b) == hb_unicode_funcs_get_default ());
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
g_assert (hb_buffer_get_language (b) == NULL);
g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_DEFAULT);
g_assert (hb_buffer_get_replacement_codepoint (b) == HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT);
g_assert_true (hb_buffer_get_unicode_funcs (b) == hb_unicode_funcs_get_default ());
g_assert_true (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
g_assert_true (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
g_assert_true (hb_buffer_get_language (b) == NULL);
g_assert_true (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_DEFAULT);
g_assert_true (hb_buffer_get_replacement_codepoint (b) == HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT);
}
static void
@ -269,7 +269,7 @@ test_buffer_contents (fixture_t *fixture, gconstpointer user_data)
/* test setting length */
/* enlarge */
g_assert (hb_buffer_set_length (b, 10));
g_assert_true (hb_buffer_set_length (b, 10));
glyphs = hb_buffer_get_glyph_infos (b, NULL);
g_assert_cmpint (hb_buffer_get_length (b), ==, 10);
for (i = 0; i < 5; i++)
@ -277,14 +277,14 @@ test_buffer_contents (fixture_t *fixture, gconstpointer user_data)
for (i = 5; i < 10; i++)
g_assert_cmphex (glyphs[i].codepoint, ==, 0);
/* shrink */
g_assert (hb_buffer_set_length (b, 3));
g_assert_true (hb_buffer_set_length (b, 3));
glyphs = hb_buffer_get_glyph_infos (b, NULL);
g_assert_cmpint (hb_buffer_get_length (b), ==, 3);
for (i = 0; i < 3; i++)
g_assert_cmphex (glyphs[i].codepoint, ==, utf32[1+i]);
g_assert (hb_buffer_allocation_successful (b));
g_assert_true (hb_buffer_allocation_successful (b));
/* test reset clears content */
@ -325,40 +325,40 @@ test_buffer_allocation (fixture_t *fixture, gconstpointer user_data HB_UNUSED)
g_assert_cmpint (hb_buffer_get_length (b), ==, 0);
g_assert (hb_buffer_pre_allocate (b, 100));
g_assert_true (hb_buffer_pre_allocate (b, 100));
g_assert_cmpint (hb_buffer_get_length (b), ==, 0);
g_assert (hb_buffer_allocation_successful (b));
g_assert_true (hb_buffer_allocation_successful (b));
/* lets try a huge allocation, make sure it fails */
g_assert (!hb_buffer_pre_allocate (b, (unsigned int) -1));
g_assert_true (!hb_buffer_pre_allocate (b, (unsigned int) -1));
g_assert_cmpint (hb_buffer_get_length (b), ==, 0);
g_assert (!hb_buffer_allocation_successful (b));
g_assert_true (!hb_buffer_allocation_successful (b));
/* small one again */
g_assert (hb_buffer_pre_allocate (b, 50));
g_assert_true (hb_buffer_pre_allocate (b, 50));
g_assert_cmpint (hb_buffer_get_length (b), ==, 0);
g_assert (!hb_buffer_allocation_successful (b));
g_assert_true (!hb_buffer_allocation_successful (b));
hb_buffer_reset (b);
g_assert (hb_buffer_allocation_successful (b));
g_assert_true (hb_buffer_allocation_successful (b));
/* all allocation and size */
g_assert (!hb_buffer_pre_allocate (b, ((unsigned int) -1) / 20 + 1));
g_assert (!hb_buffer_allocation_successful (b));
g_assert_true (!hb_buffer_pre_allocate (b, ((unsigned int) -1) / 20 + 1));
g_assert_true (!hb_buffer_allocation_successful (b));
hb_buffer_reset (b);
g_assert (hb_buffer_allocation_successful (b));
g_assert_true (hb_buffer_allocation_successful (b));
/* technically, this one can actually pass on 64bit machines, but
* I'm doubtful that any malloc allows 4GB allocations at a time.
* But let's only enable it on a 32-bit machine. */
if (sizeof (long) == 4) {
g_assert (!hb_buffer_pre_allocate (b, ((unsigned int) -1) / 20 - 1));
g_assert (!hb_buffer_allocation_successful (b));
g_assert_true (!hb_buffer_pre_allocate (b, ((unsigned int) -1) / 20 - 1));
g_assert_true (!hb_buffer_allocation_successful (b));
}
hb_buffer_reset (b);
g_assert (hb_buffer_allocation_successful (b));
g_assert_true (hb_buffer_allocation_successful (b));
}
@ -698,9 +698,9 @@ test_buffer_utf8_validity (void)
if (glyphs[j].codepoint == (hb_codepoint_t) -1)
break;
g_assert (test->valid ? j == len : j < len);
g_assert_true (test->valid ? j == len : j < len);
if (!test->valid)
g_assert (glyphs[j].cluster == test->offset);
g_assert_true (glyphs[j].cluster == test->offset);
}
hb_buffer_destroy (b);
@ -816,8 +816,8 @@ static void
test_empty (hb_buffer_t *b)
{
g_assert_cmpint (hb_buffer_get_length (b), ==, 0);
g_assert (!hb_buffer_get_glyph_infos (b, NULL));
g_assert (!hb_buffer_get_glyph_positions (b, NULL));
g_assert_true (!hb_buffer_get_glyph_infos (b, NULL));
g_assert_true (!hb_buffer_get_glyph_positions (b, NULL));
}
static void
@ -825,10 +825,10 @@ test_buffer_empty (void)
{
hb_buffer_t *b = hb_buffer_get_empty ();
g_assert (hb_buffer_get_empty ());
g_assert (hb_buffer_get_empty () == b);
g_assert_true (hb_buffer_get_empty ());
g_assert_true (hb_buffer_get_empty () == b);
g_assert (!hb_buffer_allocation_successful (b));
g_assert_true (!hb_buffer_allocation_successful (b));
test_empty (b);
@ -839,21 +839,21 @@ test_buffer_empty (void)
hb_buffer_reverse (b);
hb_buffer_reverse_clusters (b);
g_assert (!hb_buffer_set_length (b, 10));
g_assert_true (!hb_buffer_set_length (b, 10));
test_empty (b);
g_assert (hb_buffer_set_length (b, 0));
g_assert_true (hb_buffer_set_length (b, 0));
test_empty (b);
g_assert (!hb_buffer_allocation_successful (b));
g_assert_true (!hb_buffer_allocation_successful (b));
hb_buffer_reset (b);
test_empty (b);
g_assert (!hb_buffer_allocation_successful (b));
g_assert_true (!hb_buffer_allocation_successful (b));
}
typedef struct {
@ -917,7 +917,7 @@ test_buffer_serialize_deserialize (void)
}
}
else
g_assert (!ret);
g_assert_true (!ret);
hb_buffer_destroy (b);

2
test/api/test-c.c
View file

@ -78,7 +78,7 @@ static void
test_list_shapers (void)
{
const char *first = *hb_shape_list_shapers ();
g_assert (first);
g_assert_true (first);
}
int

38
test/api/test-collect-unicodes.c
View file

@ -37,13 +37,13 @@ test_collect_unicodes_format4 (void)
hb_face_collect_unicodes (face, codepoints);
cp = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (codepoints, &cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_cmpuint (0x61, ==, cp);
g_assert (hb_set_next (codepoints, &cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_cmpuint (0x62, ==, cp);
g_assert (hb_set_next (codepoints, &cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_cmpuint (0x63, ==, cp);
g_assert (!hb_set_next (codepoints, &cp));
g_assert_true (!hb_set_next (codepoints, &cp));
hb_set_destroy (codepoints);
hb_face_destroy (face);
@ -59,11 +59,11 @@ test_collect_unicodes_format12_notdef (void)
hb_face_collect_unicodes (face, codepoints);
cp = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (codepoints, &cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_cmpuint (0x20, ==, cp);
g_assert (hb_set_next (codepoints, &cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_cmpuint (0x21, ==, cp);
g_assert (hb_set_next (codepoints, &cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_cmpuint (0x22, ==, cp);
hb_set_destroy (codepoints);
@ -80,13 +80,13 @@ test_collect_unicodes_format12 (void)
hb_face_collect_unicodes (face, codepoints);
cp = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (codepoints, &cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_cmpuint (0x61, ==, cp);
g_assert (hb_set_next (codepoints, &cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_cmpuint (0x62, ==, cp);
g_assert (hb_set_next (codepoints, &cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_cmpuint (0x63, ==, cp);
g_assert (!hb_set_next (codepoints, &cp));
g_assert_true (!hb_set_next (codepoints, &cp));
hb_set_destroy (codepoints);
hb_face_destroy (face);
@ -104,21 +104,21 @@ test_collect_unicodes (void)
hb_face_collect_unicodes (face, codepoints);
hb_face_collect_nominal_glyph_mapping (face, mapping, codepoints2);
g_assert (hb_set_is_equal (codepoints, codepoints2));
g_assert_true (hb_set_is_equal (codepoints, codepoints2));
g_assert_cmpuint (hb_set_get_population (codepoints), ==, 3);
g_assert_cmpuint (hb_map_get_population (mapping), ==, 3);
cp = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (codepoints, &cp));
g_assert (hb_map_has (mapping, cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_true (hb_map_has (mapping, cp));
g_assert_cmpuint (0x61, ==, cp);
g_assert (hb_set_next (codepoints, &cp));
g_assert (hb_map_has (mapping, cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_true (hb_map_has (mapping, cp));
g_assert_cmpuint (0x62, ==, cp);
g_assert (hb_set_next (codepoints, &cp));
g_assert (hb_map_has (mapping, cp));
g_assert_true (hb_set_next (codepoints, &cp));
g_assert_true (hb_map_has (mapping, cp));
g_assert_cmpuint (0x63, ==, cp);
g_assert (!hb_set_next (codepoints, &cp));
g_assert_true (!hb_set_next (codepoints, &cp));
hb_set_destroy (codepoints);
hb_set_destroy (codepoints2);

192
test/api/test-common.c
View file

@ -53,36 +53,36 @@ test_types_direction (void)
g_assert_cmpint ((signed) HB_DIRECTION_INVALID, ==, 0);
g_assert_cmpint (HB_DIRECTION_LTR, !=, 0);
g_assert (HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_LTR));
g_assert (HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_RTL));
g_assert (!HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_TTB));
g_assert (!HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_BTT));
g_assert (!HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_INVALID));
g_assert_true (HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_LTR));
g_assert_true (HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_RTL));
g_assert_true (!HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_TTB));
g_assert_true (!HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_BTT));
g_assert_true (!HB_DIRECTION_IS_HORIZONTAL (HB_DIRECTION_INVALID));
g_assert (!HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_LTR));
g_assert (!HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_RTL));
g_assert (HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_TTB));
g_assert (HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_BTT));
g_assert (!HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_INVALID));
g_assert_true (!HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_LTR));
g_assert_true (!HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_RTL));
g_assert_true (HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_TTB));
g_assert_true (HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_BTT));
g_assert_true (!HB_DIRECTION_IS_VERTICAL (HB_DIRECTION_INVALID));
g_assert (HB_DIRECTION_IS_FORWARD (HB_DIRECTION_LTR));
g_assert (HB_DIRECTION_IS_FORWARD (HB_DIRECTION_TTB));
g_assert (!HB_DIRECTION_IS_FORWARD (HB_DIRECTION_RTL));
g_assert (!HB_DIRECTION_IS_FORWARD (HB_DIRECTION_BTT));
g_assert (!HB_DIRECTION_IS_FORWARD (HB_DIRECTION_INVALID));
g_assert_true (HB_DIRECTION_IS_FORWARD (HB_DIRECTION_LTR));
g_assert_true (HB_DIRECTION_IS_FORWARD (HB_DIRECTION_TTB));
g_assert_true (!HB_DIRECTION_IS_FORWARD (HB_DIRECTION_RTL));
g_assert_true (!HB_DIRECTION_IS_FORWARD (HB_DIRECTION_BTT));
g_assert_true (!HB_DIRECTION_IS_FORWARD (HB_DIRECTION_INVALID));
g_assert (!HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_LTR));
g_assert (!HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_TTB));
g_assert (HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_RTL));
g_assert (HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_BTT));
g_assert (!HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_INVALID));
g_assert_true (!HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_LTR));
g_assert_true (!HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_TTB));
g_assert_true (HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_RTL));
g_assert_true (HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_BTT));
g_assert_true (!HB_DIRECTION_IS_BACKWARD (HB_DIRECTION_INVALID));
g_assert (HB_DIRECTION_IS_VALID (HB_DIRECTION_LTR));
g_assert (HB_DIRECTION_IS_VALID (HB_DIRECTION_TTB));
g_assert (HB_DIRECTION_IS_VALID (HB_DIRECTION_RTL));
g_assert (HB_DIRECTION_IS_VALID (HB_DIRECTION_BTT));
g_assert (!HB_DIRECTION_IS_VALID (HB_DIRECTION_INVALID));
g_assert (!HB_DIRECTION_IS_VALID ((hb_direction_t) 0x12345678));
g_assert_true (HB_DIRECTION_IS_VALID (HB_DIRECTION_LTR));
g_assert_true (HB_DIRECTION_IS_VALID (HB_DIRECTION_TTB));
g_assert_true (HB_DIRECTION_IS_VALID (HB_DIRECTION_RTL));
g_assert_true (HB_DIRECTION_IS_VALID (HB_DIRECTION_BTT));
g_assert_true (!HB_DIRECTION_IS_VALID (HB_DIRECTION_INVALID));
g_assert_true (!HB_DIRECTION_IS_VALID ((hb_direction_t) 0x12345678));
g_assert_cmpint (HB_DIRECTION_REVERSE (HB_DIRECTION_LTR), ==, HB_DIRECTION_RTL);
g_assert_cmpint (HB_DIRECTION_REVERSE (HB_DIRECTION_RTL), ==, HB_DIRECTION_LTR);
@ -100,11 +100,11 @@ test_types_direction (void)
g_assert_cmpint (HB_DIRECTION_RTL, ==, hb_direction_from_string ("right-to-left", -1));
g_assert_cmpint (HB_DIRECTION_TTB, ==, hb_direction_from_string ("ttb", -1));
g_assert (0 == strcmp ("ltr", hb_direction_to_string (HB_DIRECTION_LTR)));
g_assert (0 == strcmp ("rtl", hb_direction_to_string (HB_DIRECTION_RTL)));
g_assert (0 == strcmp ("ttb", hb_direction_to_string (HB_DIRECTION_TTB)));
g_assert (0 == strcmp ("btt", hb_direction_to_string (HB_DIRECTION_BTT)));
g_assert (0 == strcmp ("invalid", hb_direction_to_string (HB_DIRECTION_INVALID)));
g_assert_true (0 == strcmp ("ltr", hb_direction_to_string (HB_DIRECTION_LTR)));
g_assert_true (0 == strcmp ("rtl", hb_direction_to_string (HB_DIRECTION_RTL)));
g_assert_true (0 == strcmp ("ttb", hb_direction_to_string (HB_DIRECTION_TTB)));
g_assert_true (0 == strcmp ("btt", hb_direction_to_string (HB_DIRECTION_BTT)));
g_assert_true (0 == strcmp ("invalid", hb_direction_to_string (HB_DIRECTION_INVALID)));
}
static void
@ -184,30 +184,30 @@ test_types_language (void)
hb_language_t fa_ir = hb_language_from_string ("fa-ir", -1);
hb_language_t en = hb_language_from_string ("en", -1);
g_assert (HB_LANGUAGE_INVALID == NULL);
g_assert_true (HB_LANGUAGE_INVALID == NULL);
g_assert (fa != NULL);
g_assert (fa_IR != NULL);
g_assert (fa_IR == fa_ir);
g_assert_true (fa != NULL);
g_assert_true (fa_IR != NULL);
g_assert_true (fa_IR == fa_ir);
g_assert (en != NULL);
g_assert (en != fa);
g_assert_true (en != NULL);
g_assert_true (en != fa);
/* Test recall */
g_assert (en == hb_language_from_string ("en", -1));
g_assert (en == hb_language_from_string ("eN", -1));
g_assert (en == hb_language_from_string ("Enx", 2));
g_assert_true (en == hb_language_from_string ("en", -1));
g_assert_true (en == hb_language_from_string ("eN", -1));
g_assert_true (en == hb_language_from_string ("Enx", 2));
g_assert (HB_LANGUAGE_INVALID == hb_language_from_string (NULL, -1));
g_assert (HB_LANGUAGE_INVALID == hb_language_from_string ("", -1));
g_assert (HB_LANGUAGE_INVALID == hb_language_from_string ("en", 0));
g_assert (HB_LANGUAGE_INVALID != hb_language_from_string ("en", 1));
g_assert (NULL == hb_language_to_string (HB_LANGUAGE_INVALID));
g_assert_true (HB_LANGUAGE_INVALID == hb_language_from_string (NULL, -1));
g_assert_true (HB_LANGUAGE_INVALID == hb_language_from_string ("", -1));
g_assert_true (HB_LANGUAGE_INVALID == hb_language_from_string ("en", 0));
g_assert_true (HB_LANGUAGE_INVALID != hb_language_from_string ("en", 1));
g_assert_true (NULL == hb_language_to_string (HB_LANGUAGE_INVALID));
/* Not sure how to test this better. Setting env vars
* here doesn't sound like the right approach, and I'm
* not sure that it even works. */
g_assert (HB_LANGUAGE_INVALID != hb_language_get_default ());
g_assert_true (HB_LANGUAGE_INVALID != hb_language_get_default ());
}
static void
@ -216,105 +216,105 @@ test_types_feature (void)
hb_feature_t feature;
char buf[100];
g_assert (hb_feature_from_string ("abcd", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd", buf));
g_assert_true (0 == strcmp ("abcd", buf));
g_assert (hb_feature_from_string ("abcd=1", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd=1", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd", buf));
g_assert_true (0 == strcmp ("abcd", buf));
g_assert (hb_feature_from_string ("+abcd", -1, &feature));
g_assert_true (hb_feature_from_string ("+abcd", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd", buf));
g_assert_true (0 == strcmp ("abcd", buf));
g_assert (hb_feature_from_string ("abcd=0", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd=0", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("-abcd", buf));
g_assert_true (0 == strcmp ("-abcd", buf));
g_assert (hb_feature_from_string ("-abcd", -1, &feature));
g_assert_true (hb_feature_from_string ("-abcd", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("-abcd", buf));
g_assert_true (0 == strcmp ("-abcd", buf));
g_assert (hb_feature_from_string ("abcd=2", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd=2", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd=2", buf));
g_assert_true (0 == strcmp ("abcd=2", buf));
g_assert (hb_feature_from_string ("+abcd=2", -1, &feature));
g_assert_true (hb_feature_from_string ("+abcd=2", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd=2", buf));
g_assert_true (0 == strcmp ("abcd=2", buf));
g_assert (hb_feature_from_string ("-abcd=2", -1, &feature));
g_assert_true (hb_feature_from_string ("-abcd=2", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd=2", buf));
g_assert_true (0 == strcmp ("abcd=2", buf));
g_assert (hb_feature_from_string ("\"abcd\" on", -1, &feature));
g_assert_true (hb_feature_from_string ("\"abcd\" on", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd", buf));
g_assert_true (0 == strcmp ("abcd", buf));
g_assert (hb_feature_from_string ("\"abcd\" off", -1, &feature));
g_assert_true (hb_feature_from_string ("\"abcd\" off", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("-abcd", buf));
g_assert_true (0 == strcmp ("-abcd", buf));
g_assert (hb_feature_from_string ("\"abcd\" 1", -1, &feature));
g_assert_true (hb_feature_from_string ("\"abcd\" 1", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd", buf));
g_assert_true (0 == strcmp ("abcd", buf));
g_assert (hb_feature_from_string ("\"abcd\" 0", -1, &feature));
g_assert_true (hb_feature_from_string ("\"abcd\" 0", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("-abcd", buf));
g_assert_true (0 == strcmp ("-abcd", buf));
g_assert (hb_feature_from_string ("\"abcd\" 2", -1, &feature));
g_assert_true (hb_feature_from_string ("\"abcd\" 2", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd=2", buf));
g_assert_true (0 == strcmp ("abcd=2", buf));
g_assert (hb_feature_from_string ("abcd[0]", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[0]", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd[]", buf));
g_assert_true (0 == strcmp ("abcd[]", buf));
g_assert (hb_feature_from_string ("abcd[1]", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[1]", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd[1]", buf));
g_assert_true (0 == strcmp ("abcd[1]", buf));
g_assert (hb_feature_from_string ("abcd[1]=1", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[1]=1", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd[1]", buf));
g_assert_true (0 == strcmp ("abcd[1]", buf));
g_assert (hb_feature_from_string ("abcd[1]=2", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[1]=2", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd[1]=2", buf));
g_assert_true (0 == strcmp ("abcd[1]=2", buf));
g_assert (hb_feature_from_string ("abcd[1]=0", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[1]=0", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("-abcd[1]", buf));
g_assert_true (0 == strcmp ("-abcd[1]", buf));
g_assert (hb_feature_from_string ("abcd[]", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[]", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd", buf));
g_assert_true (0 == strcmp ("abcd", buf));
g_assert (hb_feature_from_string ("abcd[:]", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[:]", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd", buf));
g_assert_true (0 == strcmp ("abcd", buf));
g_assert (hb_feature_from_string ("abcd[1:]", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[1:]", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd[1:]", buf));
g_assert_true (0 == strcmp ("abcd[1:]", buf));
g_assert (hb_feature_from_string ("abcd[:1]", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[:1]", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd[]", buf));
g_assert_true (0 == strcmp ("abcd[]", buf));
g_assert (hb_feature_from_string ("abcd[1:3]", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[1:3]", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd[1:3]", buf));
g_assert_true (0 == strcmp ("abcd[1:3]", buf));
g_assert (hb_feature_from_string ("abcd[1:2]=1", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[1:2]=1", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd[1]", buf));
g_assert_true (0 == strcmp ("abcd[1]", buf));
g_assert (hb_feature_from_string ("abcd[1:4]=2", -1, &feature));
g_assert_true (hb_feature_from_string ("abcd[1:4]=2", -1, &feature));
hb_feature_to_string (&feature, buf, 100);
g_assert (0 == strcmp ("abcd[1:4]=2", buf));
g_assert_true (0 == strcmp ("abcd[1:4]=2", buf));
}
int

4
test/api/test-cplusplus.cc
View file

@ -100,8 +100,8 @@ test_smart_ptrs (void)
assert (hash2 (pb4) == hash2 (pb2));
assert (hash (b) == hash3 (pb5));
g_assert (pb != pb.get_empty ());
g_assert (pb != pb2);
g_assert_true (pb != pb.get_empty ());
g_assert_true (pb != pb2);
}
int

10
test/api/test-draw.c
View file

@ -1065,9 +1065,9 @@ static void
test_hb_draw_immutable (void)
{
hb_draw_funcs_t *draw_funcs = hb_draw_funcs_create ();
g_assert (!hb_draw_funcs_is_immutable (draw_funcs));
g_assert_true (!hb_draw_funcs_is_immutable (draw_funcs));
hb_draw_funcs_make_immutable (draw_funcs);
g_assert (hb_draw_funcs_is_immutable (draw_funcs));
g_assert_true (hb_draw_funcs_is_immutable (draw_funcs));
hb_draw_funcs_destroy (draw_funcs);
}
@ -1084,7 +1084,7 @@ test_hb_draw_funcs (const void* user_data)
hb_face_t *face = hb_test_open_font_file ("fonts/glyphs.ttf");
hb_font_t *font = hb_font_create (face);
hb_bool_t ret = hb_font_set_funcs_using (font, font_funcs_name);
g_assert (ret);
g_assert_true (ret);
hb_face_destroy (face);
{
draw_data.consumed = 0;
@ -1098,7 +1098,7 @@ test_hb_draw_funcs (const void* user_data)
hb_face_t *face = hb_test_open_font_file ("fonts/cff1_flex.otf");
hb_font_t *font = hb_font_create (face);
hb_bool_t ret = hb_font_set_funcs_using (font, font_funcs_name);
g_assert (ret);
g_assert_true (ret);
hb_face_destroy (face);
draw_data.consumed = 0;
@ -1141,7 +1141,7 @@ test_hb_draw_compare_ot_funcs (const void *user_data)
draw_data.str[draw_data.consumed] = '\0';
hb_bool_t ret = hb_font_set_funcs_using (font, font_funcs_name);
g_assert (ret);
g_assert_true (ret);
hb_font_draw_glyph (font, 1, funcs, &draw_data2);
draw_data2.str[draw_data2.consumed] = '\0';

2
test/api/test-face.c
View file

@ -88,7 +88,7 @@ main (int argc, char **argv)
master_face = hb_test_open_font_file_with_index (font_file, face_index);
master_head = hb_face_reference_table (master_face, HEAD_TAG);
g_assert (hb_blob_get_length (master_head) > 0);
g_assert_true (hb_blob_get_length (master_head) > 0);
font_file = hb_test_resolve_path (font_file);

112
test/api/test-font.c
View file

@ -38,15 +38,15 @@ test_face_empty (void)
hb_face_t *created_from_empty;
hb_face_t *created_from_null;
g_assert (hb_face_get_empty ());
g_assert_true (hb_face_get_empty ());
created_from_empty = hb_face_create (hb_blob_get_empty (), 0);
g_assert (hb_face_get_empty () != created_from_empty);
g_assert_true (hb_face_get_empty () != created_from_empty);
created_from_null = hb_face_create (NULL, 0);
g_assert (hb_face_get_empty () != created_from_null);
g_assert_true (hb_face_get_empty () != created_from_null);
g_assert (hb_face_reference_table (hb_face_get_empty (), HB_TAG ('h','e','a','d')) == hb_blob_get_empty ());
g_assert_true (hb_face_reference_table (hb_face_get_empty (), HB_TAG ('h','e','a','d')) == hb_blob_get_empty ());
g_assert_cmpint (hb_face_get_upem (hb_face_get_empty ()), ==, 1000);
@ -64,7 +64,7 @@ test_face_create (void)
face = hb_face_create (blob, 0);
hb_blob_destroy (blob);
g_assert (hb_face_reference_table (face, HB_TAG ('h','e','a','d')) == hb_blob_get_empty ());
g_assert_true (hb_face_reference_table (face, HB_TAG ('h','e','a','d')) == hb_blob_get_empty ());
g_assert_cmpint (hb_face_get_upem (face), ==, 1000);
@ -77,7 +77,7 @@ free_up (void *user_data)
{
int *freed = (int *) user_data;
g_assert (!*freed);
g_assert_true (!*freed);
(*freed)++;
}
@ -109,22 +109,22 @@ test_face_createfortables (void)
int freed = 0;
face = hb_face_create_for_tables (get_table, &freed, free_up);
g_assert (!freed);
g_assert_true (!freed);
g_assert (hb_face_reference_table (face, HB_TAG ('h','e','a','d')) == hb_blob_get_empty ());
g_assert_true (hb_face_reference_table (face, HB_TAG ('h','e','a','d')) == hb_blob_get_empty ());
blob = hb_face_reference_table (face, HB_TAG ('a','b','c','d'));
g_assert (blob != hb_blob_get_empty ());
g_assert_true (blob != hb_blob_get_empty ());
data = hb_blob_get_data (blob, &len);
g_assert_cmpint (len, ==, sizeof (test_data));
g_assert (0 == memcmp (data, test_data, sizeof (test_data)));
g_assert_true (0 == memcmp (data, test_data, sizeof (test_data)));
hb_blob_destroy (blob);
g_assert_cmpint (hb_face_get_upem (face), ==, 1000);
hb_face_destroy (face);
g_assert (freed);
g_assert_true (freed);
}
static unsigned int
@ -176,17 +176,17 @@ test_face_referenceblob (void)
blob = hb_face_reference_blob (face);
hb_face_destroy (face);
g_assert (blob != hb_blob_get_empty ());
g_assert_true (blob != hb_blob_get_empty ());
face = hb_face_create (blob, 0);
hb_blob_destroy (blob);
g_assert (face != hb_face_get_empty ());
g_assert_true (face != hb_face_get_empty ());
g_assert_cmpuint (hb_face_get_table_tags (face, 0, NULL, NULL), ==, sizeof (test_tags) / sizeof (test_tags[0]));
for (unsigned i = 0; i < sizeof (test_tags) / sizeof (test_tags[0]); i++)
{
hb_blob_t* table = hb_face_reference_table (face, test_tags[i]);
g_assert (table != hb_blob_get_empty ());
g_assert_true (table != hb_blob_get_empty ());
hb_blob_destroy (table);
}
@ -202,7 +202,7 @@ _test_font_nil_funcs (hb_font_t *font)
unsigned int upem = hb_face_get_upem (hb_font_get_face (font));
x = y = 13;
g_assert (!hb_font_get_glyph_contour_point (font, 17, 2, &x, &y));
g_assert_true (!hb_font_get_glyph_contour_point (font, 17, 2, &x, &y));
g_assert_cmpint (x, ==, 0);
g_assert_cmpint (y, ==, 0);
@ -218,7 +218,7 @@ _test_font_nil_funcs (hb_font_t *font)
g_assert_cmpint (extents.height, ==, 0);
glyph = 3;
g_assert (!hb_font_get_glyph (font, 17, 2, &glyph));
g_assert_true (!hb_font_get_glyph (font, 17, 2, &glyph));
g_assert_cmpint (glyph, ==, 0);
}
@ -234,10 +234,10 @@ _test_fontfuncs_nil (hb_font_funcs_t *ffuncs)
blob = hb_blob_create (test_data, sizeof (test_data), HB_MEMORY_MODE_READONLY, NULL, NULL);
face = hb_face_create (blob, 0);
hb_blob_destroy (blob);
g_assert (!hb_face_is_immutable (face));
g_assert_true (!hb_face_is_immutable (face));
font = hb_font_create (face);
g_assert (font);
g_assert (hb_face_is_immutable (face));
g_assert_true (font);
g_assert_true (hb_face_is_immutable (face));
hb_face_destroy (face);
@ -247,7 +247,7 @@ _test_fontfuncs_nil (hb_font_funcs_t *ffuncs)
_test_font_nil_funcs (font);
subfont = hb_font_create_sub_font (font);
g_assert (subfont);
g_assert_true (subfont);
g_assert_cmpint (freed, ==, 0);
hb_font_destroy (font);
@ -262,8 +262,8 @@ _test_fontfuncs_nil (hb_font_funcs_t *ffuncs)
static void
test_fontfuncs_empty (void)
{
g_assert (hb_font_funcs_get_empty ());
g_assert (hb_font_funcs_is_immutable (hb_font_funcs_get_empty ()));
g_assert_true (hb_font_funcs_get_empty ());
g_assert_true (hb_font_funcs_is_immutable (hb_font_funcs_get_empty ()));
_test_fontfuncs_nil (hb_font_funcs_get_empty ());
}
@ -274,7 +274,7 @@ test_fontfuncs_nil (void)
ffuncs = hb_font_funcs_create ();
g_assert (!hb_font_funcs_is_immutable (ffuncs));
g_assert_true (!hb_font_funcs_is_immutable (ffuncs));
_test_fontfuncs_nil (hb_font_funcs_get_empty ());
hb_font_funcs_destroy (ffuncs);
@ -358,13 +358,13 @@ test_fontfuncs_subclassing (void)
hb_font_funcs_destroy (ffuncs1);
x = y = 1;
g_assert (hb_font_get_glyph_contour_point_for_origin (font1, 1, 2, HB_DIRECTION_LTR, &x, &y));
g_assert_true (hb_font_get_glyph_contour_point_for_origin (font1, 1, 2, HB_DIRECTION_LTR, &x, &y));
g_assert_cmpint (x, ==, 2);
g_assert_cmpint (y, ==, 3);
g_assert (hb_font_get_glyph_contour_point_for_origin (font1, 2, 5, HB_DIRECTION_LTR, &x, &y));
g_assert_true (hb_font_get_glyph_contour_point_for_origin (font1, 2, 5, HB_DIRECTION_LTR, &x, &y));
g_assert_cmpint (x, ==, 4);
g_assert_cmpint (y, ==, 5);
g_assert (!hb_font_get_glyph_contour_point_for_origin (font1, 3, 7, HB_DIRECTION_RTL, &x, &y));
g_assert_true (!hb_font_get_glyph_contour_point_for_origin (font1, 3, 7, HB_DIRECTION_RTL, &x, &y));
g_assert_cmpint (x, ==, 0);
g_assert_cmpint (y, ==, 0);
x = hb_font_get_glyph_h_advance (font1, 1);
@ -377,13 +377,13 @@ test_fontfuncs_subclassing (void)
*/
font2 = hb_font_create_sub_font (font1);
font3 = hb_font_create_sub_font (font2);
g_assert (!hb_font_is_immutable (font1));
g_assert (!hb_font_is_immutable (font2));
g_assert (!hb_font_is_immutable (font3));
g_assert_true (!hb_font_is_immutable (font1));
g_assert_true (!hb_font_is_immutable (font2));
g_assert_true (!hb_font_is_immutable (font3));
hb_font_make_immutable (font3);
g_assert (hb_font_is_immutable (font1));
g_assert (hb_font_is_immutable (font2));
g_assert (hb_font_is_immutable (font3));
g_assert_true (hb_font_is_immutable (font1));
g_assert_true (hb_font_is_immutable (font2));
g_assert_true (hb_font_is_immutable (font3));
hb_font_destroy (font2);
hb_font_destroy (font3);
@ -397,13 +397,13 @@ test_fontfuncs_subclassing (void)
hb_font_funcs_destroy (ffuncs2);
x = y = 1;
g_assert (hb_font_get_glyph_contour_point_for_origin (font2, 1, 2, HB_DIRECTION_LTR, &x, &y));
g_assert_true (hb_font_get_glyph_contour_point_for_origin (font2, 1, 2, HB_DIRECTION_LTR, &x, &y));
g_assert_cmpint (x, ==, 6);
g_assert_cmpint (y, ==, 7);
g_assert (hb_font_get_glyph_contour_point_for_origin (font2, 2, 5, HB_DIRECTION_RTL, &x, &y));
g_assert_true (hb_font_get_glyph_contour_point_for_origin (font2, 2, 5, HB_DIRECTION_RTL, &x, &y));
g_assert_cmpint (x, ==, 4);
g_assert_cmpint (y, ==, 5);
g_assert (!hb_font_get_glyph_contour_point_for_origin (font2, 3, 7, HB_DIRECTION_LTR, &x, &y));
g_assert_true (!hb_font_get_glyph_contour_point_for_origin (font2, 3, 7, HB_DIRECTION_LTR, &x, &y));
g_assert_cmpint (x, ==, 0);
g_assert_cmpint (y, ==, 0);
x = hb_font_get_glyph_h_advance (font2, 1);
@ -416,13 +416,13 @@ test_fontfuncs_subclassing (void)
hb_font_set_scale (font3, 20, 30);
x = y = 1;
g_assert (hb_font_get_glyph_contour_point_for_origin (font3, 1, 2, HB_DIRECTION_RTL, &x, &y));
g_assert_true (hb_font_get_glyph_contour_point_for_origin (font3, 1, 2, HB_DIRECTION_RTL, &x, &y));
g_assert_cmpint (x, ==, 6*2);
g_assert_cmpint (y, ==, 7*3);
g_assert (hb_font_get_glyph_contour_point_for_origin (font3, 2, 5, HB_DIRECTION_LTR, &x, &y));
g_assert_true (hb_font_get_glyph_contour_point_for_origin (font3, 2, 5, HB_DIRECTION_LTR, &x, &y));
g_assert_cmpint (x, ==, 4*2);
g_assert_cmpint (y, ==, 5*3);
g_assert (!hb_font_get_glyph_contour_point_for_origin (font3, 3, 7, HB_DIRECTION_LTR, &x, &y));
g_assert_true (!hb_font_get_glyph_contour_point_for_origin (font3, 3, 7, HB_DIRECTION_LTR, &x, &y));
g_assert_cmpint (x, ==, 0*2);
g_assert_cmpint (y, ==, 0*3);
x = hb_font_get_glyph_h_advance (font3, 1);
@ -508,21 +508,21 @@ test_font_empty (void)
hb_font_t *created_from_null;
hb_font_t *created_sub_from_null;
g_assert (hb_font_get_empty ());
g_assert_true (hb_font_get_empty ());
created_from_empty = hb_font_create (hb_face_get_empty ());
g_assert (hb_font_get_empty () != created_from_empty);
g_assert_true (hb_font_get_empty () != created_from_empty);
created_from_null = hb_font_create (NULL);
g_assert (hb_font_get_empty () != created_from_null);
g_assert_true (hb_font_get_empty () != created_from_null);
created_sub_from_null = hb_font_create_sub_font (NULL);
g_assert (hb_font_get_empty () != created_sub_from_null);
g_assert_true (hb_font_get_empty () != created_sub_from_null);
g_assert (hb_font_is_immutable (hb_font_get_empty ()));
g_assert_true (hb_font_is_immutable (hb_font_get_empty ()));
g_assert (hb_font_get_face (hb_font_get_empty ()) == hb_face_get_empty ());
g_assert (hb_font_get_parent (hb_font_get_empty ()) == NULL);
g_assert_true (hb_font_get_face (hb_font_get_empty ()) == hb_face_get_empty ());
g_assert_true (hb_font_get_parent (hb_font_get_empty ()) == NULL);
hb_font_destroy (created_sub_from_null);
hb_font_destroy (created_from_null);
@ -547,19 +547,19 @@ test_font_properties (void)
hb_face_destroy (face);
g_assert (hb_font_get_face (font) == face);
g_assert (hb_font_get_parent (font) == hb_font_get_empty ());
g_assert_true (hb_font_get_face (font) == face);
g_assert_true (hb_font_get_parent (font) == hb_font_get_empty ());
subfont = hb_font_create_sub_font (font);
g_assert (hb_font_get_parent (subfont) == font);
g_assert_true (hb_font_get_parent (subfont) == font);
hb_font_set_parent(subfont, NULL);
g_assert (hb_font_get_parent (subfont) == hb_font_get_empty());
g_assert_true (hb_font_get_parent (subfont) == hb_font_get_empty());
hb_font_set_parent(subfont, font);
g_assert (hb_font_get_parent (subfont) == font);
g_assert_true (hb_font_get_parent (subfont) == font);
hb_font_set_parent(subfont, NULL);
hb_font_make_immutable (subfont);
g_assert (hb_font_get_parent (subfont) == hb_font_get_empty());
g_assert_true (hb_font_get_parent (subfont) == hb_font_get_empty());
hb_font_set_parent(subfont, font);
g_assert (hb_font_get_parent (subfont) == hb_font_get_empty());
g_assert_true (hb_font_get_parent (subfont) == hb_font_get_empty());
hb_font_destroy (subfont);
@ -615,9 +615,9 @@ test_font_properties (void)
/* Check immutable */
g_assert (!hb_font_is_immutable (font));
g_assert_true (!hb_font_is_immutable (font));
hb_font_make_immutable (font);
g_assert (hb_font_is_immutable (font));
g_assert_true (hb_font_is_immutable (font));
hb_font_set_scale (font, 10, 12);
x_scale = y_scale = 13;
@ -636,8 +636,8 @@ test_font_properties (void)
subfont = hb_font_create_sub_font (font);
hb_font_destroy (font);
g_assert (hb_font_get_parent (subfont) == font);
g_assert (hb_font_get_face (subfont) == face);
g_assert_true (hb_font_get_parent (subfont) == font);
g_assert_true (hb_font_get_face (subfont) == face);
/* scale */
x_scale = y_scale = 13;

4
test/api/test-instance-cff2.c
View file

@ -54,8 +54,8 @@ test_instance_cff2 (void)
hb_set_destroy (codepoints);
hb_subset_test_check (expected, face_abc_subset, HB_TAG ('C','F','F', '2'));
g_assert (hb_face_reference_table (face_abc_subset, HB_TAG ('f', 'v', 'a', 'r'))
== hb_blob_get_empty ());
g_assert_true (hb_face_reference_table (face_abc_subset, HB_TAG ('f', 'v', 'a', 'r'))
== hb_blob_get_empty ());
hb_face_destroy (face_abc_subset);
hb_face_destroy (face_abc);

24
test/api/test-map.c
View file

@ -32,31 +32,31 @@ test_map_basic (void)
{
hb_map_t *empty = hb_map_get_empty ();
hb_map_t *m;
g_assert (hb_map_is_empty (empty));
g_assert (!hb_map_allocation_successful (empty));
g_assert_true (hb_map_is_empty (empty));
g_assert_true (!hb_map_allocation_successful (empty));
hb_map_destroy (empty);
m = hb_map_create ();
g_assert (hb_map_allocation_successful (m));
g_assert (hb_map_is_empty (m));
g_assert_true (hb_map_allocation_successful (m));
g_assert_true (hb_map_is_empty (m));
hb_map_set (m, 213, 223);
hb_map_set (m, 643, 675);
g_assert_cmpint (hb_map_get_population (m), ==, 2);
g_assert_cmpint (hb_map_get (m, 213), ==, 223);
g_assert (!hb_map_has (m, 123));
g_assert (hb_map_has (m, 213));
g_assert_true (!hb_map_has (m, 123));
g_assert_true (hb_map_has (m, 213));
hb_map_del (m, 213);
g_assert (!hb_map_has (m, 213));
g_assert_true (!hb_map_has (m, 213));
g_assert_cmpint (hb_map_get (m, 643), ==, 675);
hb_map_set (m, 237, 673);
g_assert (hb_map_has (m, 237));
g_assert_true (hb_map_has (m, 237));
hb_map_clear (m);
g_assert (!hb_map_has (m, 237));
g_assert (!hb_map_has (m, 643));
g_assert_true (!hb_map_has (m, 237));
g_assert_true (!hb_map_has (m, 643));
g_assert_cmpint (hb_map_get_population (m), ==, 0);
hb_map_destroy (m);
@ -96,8 +96,8 @@ test_map_refcount (void)
hb_map_destroy (m);
/* We copied its reference so it is still usable after one destroy */
g_assert (hb_map_has (m, 213));
g_assert (hb_map_has (m2, 213));
g_assert_true (hb_map_has (m, 213));
g_assert_true (hb_map_has (m2, 213));
hb_map_destroy (m2);

2
test/api/test-multithread.c
View file

@ -95,7 +95,7 @@ test_body (gconstpointer data)
{
const char *backend = (const char *) data;
bool ret = hb_font_set_funcs_using (font, backend);
g_assert (ret);
g_assert_true (ret);
int i;
pthread_t *threads = calloc (num_threads, sizeof (pthread_t));

92
test/api/test-object.c
View file

@ -195,7 +195,7 @@ static void free_up0 (void *p)
data_t *data = (data_t *) p;
g_assert_cmphex (data->value, ==, MAGIC0);
g_assert (!data->freed);
g_assert_true (!data->freed);
data->freed = TRUE;
}
@ -204,7 +204,7 @@ static void free_up1 (void *p)
data_t *data = (data_t *) p;
g_assert_cmphex (data->value, ==, MAGIC1);
g_assert (!data->freed);
g_assert_true (!data->freed);
data->freed = TRUE;
}
@ -219,7 +219,7 @@ static void free_deadlock_test (void *p)
{
deadlock_test_t *t = (deadlock_test_t *) p;
g_assert (NULL == t->klass->get_user_data (t->object, &t->key));
g_assert_true (NULL == t->klass->get_user_data (t->object, &t->key));
}
@ -242,73 +242,73 @@ test_object (void)
g_test_message ("->create()");
obj = o->create ();
g_assert (obj);
g_assert_true (obj);
g_assert (obj == o->reference (obj));
g_assert_true (obj == o->reference (obj));
o->destroy (obj);
if (o->is_immutable)
g_assert (!o->is_immutable (obj));
g_assert_true (!o->is_immutable (obj));
g_assert (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert (o->get_user_data (obj, &key[0]) == &data[0]);
g_assert_true (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert_true (o->get_user_data (obj, &key[0]) == &data[0]);
if (o->is_immutable) {
o->make_immutable (obj);
g_assert (o->is_immutable (obj));
g_assert_true (o->is_immutable (obj));
}
/* Should still work even if object is made immutable */
g_assert (o->set_user_data (obj, &key[1], &data[1], free_up1, TRUE));
g_assert (o->get_user_data (obj, &key[1]) == &data[1]);
g_assert_true (o->set_user_data (obj, &key[1], &data[1], free_up1, TRUE));
g_assert_true (o->get_user_data (obj, &key[1]) == &data[1]);
g_assert (!o->set_user_data (obj, NULL, &data[0], free_up0, TRUE));
g_assert (o->get_user_data (obj, &key[0]) == &data[0]);
g_assert (o->set_user_data (obj, &key[0], &data[1], NULL, TRUE));
g_assert (data[0].freed);
g_assert (o->get_user_data (obj, &key[0]) == &data[1]);
g_assert (!data[1].freed);
g_assert_true (!o->set_user_data (obj, NULL, &data[0], free_up0, TRUE));
g_assert_true (o->get_user_data (obj, &key[0]) == &data[0]);
g_assert_true (o->set_user_data (obj, &key[0], &data[1], NULL, TRUE));
g_assert_true (data[0].freed);
g_assert_true (o->get_user_data (obj, &key[0]) == &data[1]);
g_assert_true (!data[1].freed);
data[0].freed = FALSE;
g_assert (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert (!data[0].freed);
g_assert (o->set_user_data (obj, &key[0], NULL, NULL, TRUE));
g_assert (data[0].freed);
g_assert_true (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert_true (!data[0].freed);
g_assert_true (o->set_user_data (obj, &key[0], NULL, NULL, TRUE));
g_assert_true (data[0].freed);
data[0].freed = FALSE;
global_data = 0;
g_assert (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert (!o->set_user_data (obj, &key[0], &data[0], free_up0, FALSE));
g_assert_true (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert_true (!o->set_user_data (obj, &key[0], &data[0], free_up0, FALSE));
g_assert_cmpuint (global_data, ==, 0);
g_assert (o->set_user_data (obj, &key[0], NULL, global_free_up, TRUE));
g_assert_true (o->set_user_data (obj, &key[0], NULL, global_free_up, TRUE));
g_assert_cmpuint (global_data, ==, 0);
g_assert (o->set_user_data (obj, &key[0], NULL, NULL, TRUE));
g_assert_true (o->set_user_data (obj, &key[0], NULL, NULL, TRUE));
g_assert_cmpuint (global_data, ==, 1);
global_data = 0;
for (j = 2; j < 1000; j++)
g_assert (o->set_user_data (obj, &key[j], &data[j], global_free_up, TRUE));
g_assert_true (o->set_user_data (obj, &key[j], &data[j], global_free_up, TRUE));
for (j = 2; j < 1000; j++)
g_assert (o->get_user_data (obj, &key[j]) == &data[j]);
g_assert_true (o->get_user_data (obj, &key[j]) == &data[j]);
for (j = 100; j < 1000; j++)
g_assert (o->set_user_data (obj, &key[j], NULL, NULL, TRUE));
g_assert_true (o->set_user_data (obj, &key[j], NULL, NULL, TRUE));
for (j = 2; j < 100; j++)
g_assert (o->get_user_data (obj, &key[j]) == &data[j]);
g_assert_true (o->get_user_data (obj, &key[j]) == &data[j]);
for (j = 100; j < 1000; j++)
g_assert (!o->get_user_data (obj, &key[j]));
g_assert_true (!o->get_user_data (obj, &key[j]));
g_assert_cmpuint (global_data, ==, 900);
/* Test set_user_data where the destroy() func calls user_data functions.
* Make sure it doesn't deadlock or corrupt memory. */
deadlock_test.klass = o;
deadlock_test.object = obj;
g_assert (o->set_user_data (obj, &deadlock_test.key, &deadlock_test, free_deadlock_test, TRUE));
g_assert (o->set_user_data (obj, &deadlock_test.key, NULL, NULL, TRUE));
g_assert_true (o->set_user_data (obj, &deadlock_test.key, &deadlock_test, free_deadlock_test, TRUE));
g_assert_true (o->set_user_data (obj, &deadlock_test.key, NULL, NULL, TRUE));
g_assert (!data[1].freed);
g_assert_true (!data[1].freed);
o->destroy (obj);
g_assert (data[0].freed);
g_assert (data[1].freed);
g_assert_true (data[0].freed);
g_assert_true (data[1].freed);
g_assert_cmpuint (global_data, ==, 1000-2);
}
@ -317,16 +317,16 @@ test_object (void)
g_test_message ("->get_empty()");
obj = o->get_empty ();
g_assert (obj);
g_assert_true (obj);
g_assert (obj == o->reference (obj));
g_assert_true (obj == o->reference (obj));
o->destroy (obj);
if (o->is_immutable)
g_assert (o->is_immutable (obj));
g_assert_true (o->is_immutable (obj));
g_assert (!o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert (!o->get_user_data (obj, &key[0]));
g_assert_true (!o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert_true (!o->get_user_data (obj, &key[0]));
o->destroy (obj);
o->destroy (obj);
@ -334,7 +334,7 @@ test_object (void)
o->destroy (obj);
o->destroy (obj);
g_assert (!data[0].freed);
g_assert_true (!data[0].freed);
}
{
@ -347,18 +347,18 @@ test_object (void)
if (obj == o->get_empty ())
continue; /* Tested already */
g_assert (obj == o->reference (obj));
g_assert_true (obj == o->reference (obj));
o->destroy (obj);
if (o->is_immutable)
g_assert (!o->is_immutable (obj));
g_assert_true (!o->is_immutable (obj));
g_assert (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert (o->get_user_data (obj, &key[0]));
g_assert_true (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
g_assert_true (o->get_user_data (obj, &key[0]));
o->destroy (obj);
g_assert (data[0].freed);
g_assert_true (data[0].freed);
}
}
}

124
test/api/test-ot-collect-glyphs.c
View file

@ -52,12 +52,12 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
g_assert_cmpuint (0, ==, hb_set_get_population (before));
g_assert_cmpuint (684, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (54, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (372, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (574, ==, g);
END();
@ -67,14 +67,14 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
g_assert_cmpuint (143, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (2, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (319, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (519, ==, g);
END();
@ -84,14 +84,14 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
g_assert_cmpuint (10, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (92, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (9, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (6, ==, g);
END();
@ -101,14 +101,14 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
g_assert_cmpuint (14, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (1823, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (22, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (1897, ==, g);
END();
@ -118,19 +118,19 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
g_assert_cmpuint (10, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (92, ==, g);
g_assert_cmpuint (2, ==, hb_set_get_population (after));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (after, &g));
g_assert_true (hb_set_next (after, &g));
g_assert_cmpuint (1826, ==, g);
g_assert (hb_set_next (after, &g));
g_assert_true (hb_set_next (after, &g));
g_assert_cmpuint (1837, ==, g);
g_assert_cmpuint (9, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (6, ==, g);
END();
@ -138,19 +138,19 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
BEGIN(HB_OT_TAG_GSUB, 13);
g_assert_cmpuint (771, ==, hb_set_get_population (before));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (before, &g));
g_assert_true (hb_set_next (before, &g));
g_assert_cmpuint (2, ==, g);
g_assert_cmpuint (28, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (1823, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (48, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (325, ==, g);
END();
@ -160,7 +160,7 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
g_assert_cmpuint (179, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (28, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
@ -173,7 +173,7 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
g_assert_cmpuint (48, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (1823, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
@ -186,7 +186,7 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
g_assert_cmpuint (1426, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (2, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
@ -202,7 +202,7 @@ test_ot_layout_lookup_collect_glyphs_source_sans (void)
g_assert_cmpuint (1, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (4, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
@ -233,22 +233,22 @@ test_ot_layout_lookup_collect_glyphs_noto_nastaliq (void)
g_assert_cmpuint (3, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (228, ==, g);
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (416, ==, g);
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (441, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (3, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (267, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (268, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (279, ==, g);
END();
@ -258,22 +258,22 @@ test_ot_layout_lookup_collect_glyphs_noto_nastaliq (void)
g_assert_cmpuint (3, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (228, ==, g);
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (416, ==, g);
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (441, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (3, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (267, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (268, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (279, ==, g);
END();
@ -281,22 +281,22 @@ test_ot_layout_lookup_collect_glyphs_noto_nastaliq (void)
BEGIN(HB_OT_TAG_GSUB, 16);
g_assert_cmpuint (16, ==, hb_set_get_population (before));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (before, &g));
g_assert_true (hb_set_next (before, &g));
g_assert_cmpuint (74, ==, g);
g_assert_cmpuint (27, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (276, ==, g);
g_assert_cmpuint (14, ==, hb_set_get_population (after));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (after, &g));
g_assert_true (hb_set_next (after, &g));
g_assert_cmpuint (252, ==, g);
g_assert_cmpuint (43, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (74, ==, g);
END();
@ -306,14 +306,14 @@ test_ot_layout_lookup_collect_glyphs_noto_nastaliq (void)
g_assert_cmpuint (246, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (252, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (258, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (74, ==, g);
END();
@ -324,7 +324,7 @@ test_ot_layout_lookup_collect_glyphs_noto_nastaliq (void)
g_assert_cmpuint (616, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (228, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
@ -337,7 +337,7 @@ test_ot_layout_lookup_collect_glyphs_noto_nastaliq (void)
g_assert_cmpuint (46, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (1004, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
@ -350,7 +350,7 @@ test_ot_layout_lookup_collect_glyphs_noto_nastaliq (void)
g_assert_cmpuint (242, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (257, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
@ -381,26 +381,26 @@ test_ot_layout_lookup_collect_glyphs_qahiri (void)
g_assert_cmpuint (4, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (52, ==, g);
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (60, ==, g);
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (62, ==, g);
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (159, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (4, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (53, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (61, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (63, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (160, ==, g);
END();
@ -408,26 +408,26 @@ test_ot_layout_lookup_collect_glyphs_qahiri (void)
BEGIN(HB_OT_TAG_GSUB, 11);
g_assert_cmpuint (1, ==, hb_set_get_population (before));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (before, &g));
g_assert_true (hb_set_next (before, &g));
g_assert_cmpuint (39, ==, g);
g_assert_cmpuint (2, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (154, ==, g);
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (159, ==, g);
g_assert_cmpuint (1, ==, hb_set_get_population (after));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (after, &g));
g_assert_true (hb_set_next (after, &g));
g_assert_cmpuint (179, ==, g);
g_assert_cmpuint (2, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (155, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (162, ==, g);
END();
@ -437,20 +437,20 @@ test_ot_layout_lookup_collect_glyphs_qahiri (void)
g_assert_cmpuint (4, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (53, ==, g);
g_assert_cmpuint (0, ==, hb_set_get_population (after));
g_assert_cmpuint (4, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (52, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (60, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (62, ==, g);
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (159, ==, g);
END();
@ -460,17 +460,17 @@ test_ot_layout_lookup_collect_glyphs_qahiri (void)
g_assert_cmpuint (42, ==, hb_set_get_population (input));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (input, &g));
g_assert_true (hb_set_next (input, &g));
g_assert_cmpuint (47, ==, g);
g_assert_cmpuint (46, ==, hb_set_get_population (after));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (after, &g));
g_assert_true (hb_set_next (after, &g));
g_assert_cmpuint (61, ==, g);
g_assert_cmpuint (42, ==, hb_set_get_population (output));
g = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (output, &g));
g_assert_true (hb_set_next (output, &g));
g_assert_cmpuint (463, ==, g);
END();

102
test/api/test-ot-color.c
View file

@ -348,58 +348,58 @@ test_hb_ot_color_glyph_get_layers (void)
static void
test_hb_ot_color_has_data (void)
{
g_assert (hb_ot_color_has_layers (empty) == FALSE);
g_assert (hb_ot_color_has_layers (cpal_v0) == TRUE);
g_assert (hb_ot_color_has_layers (cpal_v1) == TRUE);
g_assert (hb_ot_color_has_layers (cpal) == TRUE);
g_assert (hb_ot_color_has_layers (cbdt) == FALSE);
g_assert (hb_ot_color_has_layers (sbix) == FALSE);
g_assert (hb_ot_color_has_layers (svg) == FALSE);
g_assert (hb_ot_color_has_layers (colrv1) == FALSE);
g_assert_true (hb_ot_color_has_layers (empty) == FALSE);
g_assert_true (hb_ot_color_has_layers (cpal_v0) == TRUE);
g_assert_true (hb_ot_color_has_layers (cpal_v1) == TRUE);
g_assert_true (hb_ot_color_has_layers (cpal) == TRUE);
g_assert_true (hb_ot_color_has_layers (cbdt) == FALSE);
g_assert_true (hb_ot_color_has_layers (sbix) == FALSE);
g_assert_true (hb_ot_color_has_layers (svg) == FALSE);
g_assert_true (hb_ot_color_has_layers (colrv1) == FALSE);
g_assert (hb_ot_color_has_palettes (empty) == FALSE);
g_assert (hb_ot_color_has_palettes (cpal_v0) == TRUE);
g_assert (hb_ot_color_has_palettes (cpal_v1) == TRUE);
g_assert (hb_ot_color_has_palettes (cpal) == TRUE);
g_assert (hb_ot_color_has_palettes (cbdt) == FALSE);
g_assert (hb_ot_color_has_palettes (sbix) == FALSE);
g_assert (hb_ot_color_has_palettes (svg) == FALSE);
g_assert (hb_ot_color_has_palettes (colrv1) == TRUE);
g_assert_true (hb_ot_color_has_palettes (empty) == FALSE);
g_assert_true (hb_ot_color_has_palettes (cpal_v0) == TRUE);
g_assert_true (hb_ot_color_has_palettes (cpal_v1) == TRUE);
g_assert_true (hb_ot_color_has_palettes (cpal) == TRUE);
g_assert_true (hb_ot_color_has_palettes (cbdt) == FALSE);
g_assert_true (hb_ot_color_has_palettes (sbix) == FALSE);
g_assert_true (hb_ot_color_has_palettes (svg) == FALSE);
g_assert_true (hb_ot_color_has_palettes (colrv1) == TRUE);
g_assert (hb_ot_color_has_svg (empty) == FALSE);
g_assert (hb_ot_color_has_svg (cpal_v0) == FALSE);
g_assert (hb_ot_color_has_svg (cpal_v1) == FALSE);
g_assert (hb_ot_color_has_svg (cpal) == FALSE);
g_assert (hb_ot_color_has_svg (cbdt) == FALSE);
g_assert (hb_ot_color_has_svg (sbix) == FALSE);
g_assert (hb_ot_color_has_svg (svg) == TRUE);
g_assert (hb_ot_color_has_svg (colrv1) == FALSE);
g_assert_true (hb_ot_color_has_svg (empty) == FALSE);
g_assert_true (hb_ot_color_has_svg (cpal_v0) == FALSE);
g_assert_true (hb_ot_color_has_svg (cpal_v1) == FALSE);
g_assert_true (hb_ot_color_has_svg (cpal) == FALSE);
g_assert_true (hb_ot_color_has_svg (cbdt) == FALSE);
g_assert_true (hb_ot_color_has_svg (sbix) == FALSE);
g_assert_true (hb_ot_color_has_svg (svg) == TRUE);
g_assert_true (hb_ot_color_has_svg (colrv1) == FALSE);
g_assert (hb_ot_color_has_png (empty) == FALSE);
g_assert (hb_ot_color_has_png (cpal_v0) == FALSE);
g_assert (hb_ot_color_has_png (cpal_v1) == FALSE);
g_assert (hb_ot_color_has_png (cpal) == FALSE);
g_assert (hb_ot_color_has_png (cbdt) == TRUE);
g_assert (hb_ot_color_has_png (sbix) == TRUE);
g_assert (hb_ot_color_has_png (svg) == FALSE);
g_assert (hb_ot_color_has_png (colrv1) == FALSE);
g_assert_true (hb_ot_color_has_png (empty) == FALSE);
g_assert_true (hb_ot_color_has_png (cpal_v0) == FALSE);
g_assert_true (hb_ot_color_has_png (cpal_v1) == FALSE);
g_assert_true (hb_ot_color_has_png (cpal) == FALSE);
g_assert_true (hb_ot_color_has_png (cbdt) == TRUE);
g_assert_true (hb_ot_color_has_png (sbix) == TRUE);
g_assert_true (hb_ot_color_has_png (svg) == FALSE);
g_assert_true (hb_ot_color_has_png (colrv1) == FALSE);
g_assert (hb_ot_color_has_paint (empty) == FALSE);
g_assert (hb_ot_color_has_paint (cpal_v0) == FALSE);
g_assert (hb_ot_color_has_paint (cpal_v1) == FALSE);
g_assert (hb_ot_color_has_paint (cpal) == FALSE);
g_assert (hb_ot_color_has_paint (cbdt) == FALSE);
g_assert (hb_ot_color_has_paint (sbix) == FALSE);
g_assert (hb_ot_color_has_paint (svg) == FALSE);
g_assert (hb_ot_color_has_paint (colrv1) == TRUE);
g_assert_true (hb_ot_color_has_paint (empty) == FALSE);
g_assert_true (hb_ot_color_has_paint (cpal_v0) == FALSE);
g_assert_true (hb_ot_color_has_paint (cpal_v1) == FALSE);
g_assert_true (hb_ot_color_has_paint (cpal) == FALSE);
g_assert_true (hb_ot_color_has_paint (cbdt) == FALSE);
g_assert_true (hb_ot_color_has_paint (sbix) == FALSE);
g_assert_true (hb_ot_color_has_paint (svg) == FALSE);
g_assert_true (hb_ot_color_has_paint (colrv1) == TRUE);
}
static void
test_hb_ot_color_glyph_has_paint (void)
{
g_assert (hb_ot_color_has_paint (colrv1));
g_assert (hb_ot_color_glyph_has_paint (colrv1, 10));
g_assert (!hb_ot_color_glyph_has_paint (colrv1, 20));
g_assert_true (hb_ot_color_has_paint (colrv1));
g_assert_true (hb_ot_color_glyph_has_paint (colrv1, 10));
g_assert_true (!hb_ot_color_glyph_has_paint (colrv1, 20));
}
static void
@ -410,17 +410,17 @@ test_hb_ot_color_svg (void)
const char *data;
blob = hb_ot_color_glyph_reference_svg (svg, 0);
g_assert (hb_blob_get_length (blob) == 0);
g_assert_true (hb_blob_get_length (blob) == 0);
blob = hb_ot_color_glyph_reference_svg (svg, 1);
data = hb_blob_get_data (blob, &length);
g_assert_cmpuint (length, ==, 146);
g_assert (strncmp (data, "<?xml", 4) == 0);
g_assert (strncmp (data + 140, "</svg>", 5) == 0);
g_assert_true (strncmp (data, "<?xml", 4) == 0);
g_assert_true (strncmp (data + 140, "</svg>", 5) == 0);
hb_blob_destroy (blob);
blob = hb_ot_color_glyph_reference_svg (empty, 0);
g_assert (hb_blob_get_length (blob) == 0);
g_assert_true (hb_blob_get_length (blob) == 0);
}
@ -442,12 +442,12 @@ test_hb_ot_color_png (void)
g_assert_cmpint (extents.y_bearing, ==, 0);
g_assert_cmpint (extents.width, ==, 0);
g_assert_cmpint (extents.height, ==, 0);
g_assert (hb_blob_get_length (blob) == 0);
g_assert_true (hb_blob_get_length (blob) == 0);
blob = hb_ot_color_glyph_reference_png (sbix_font, 1);
data = hb_blob_get_data (blob, &length);
g_assert_cmpuint (length, ==, 224);
g_assert (strncmp (data + 1, "PNG", 3) == 0);
g_assert_true (strncmp (data + 1, "PNG", 3) == 0);
hb_font_get_glyph_extents (sbix_font, 1, &extents);
g_assert_cmpint (extents.x_bearing, ==, 0);
g_assert_cmpint (extents.y_bearing, ==, 800);
@ -459,12 +459,12 @@ test_hb_ot_color_png (void)
/* cbdt */
cbdt_font = hb_font_create (cbdt);
blob = hb_ot_color_glyph_reference_png (cbdt_font, 0);
g_assert (hb_blob_get_length (blob) == 0);
g_assert_true (hb_blob_get_length (blob) == 0);
blob = hb_ot_color_glyph_reference_png (cbdt_font, 1);
data = hb_blob_get_data (blob, &length);
g_assert_cmpuint (length, ==, 88);
g_assert (strncmp (data + 1, "PNG", 3) == 0);
g_assert_true (strncmp (data + 1, "PNG", 3) == 0);
hb_font_get_glyph_extents (cbdt_font, 1, &extents);
g_assert_cmpint (extents.x_bearing, ==, 0);
g_assert_cmpint (extents.y_bearing, ==, 1024);

50
test/api/test-ot-extents-cff.c
View file

@ -33,14 +33,14 @@ static void
test_extents_cff1 (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/SourceSansPro-Regular.abc.otf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_glyph_extents_t extents;
hb_bool_t result = hb_font_get_glyph_extents (font, 1, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 52);
g_assert_cmpint (extents.y_bearing, ==, 498);
@ -50,13 +50,13 @@ test_extents_cff1 (void)
hb_font_destroy (font);
hb_face_t *face_j = hb_test_open_font_file ("fonts/SourceHanSans-Regular.41,3041,4C2E.otf");
g_assert (face_j);
g_assert_true (face_j);
hb_font_t *font_j = hb_font_create (face_j);
hb_face_destroy (face_j);
g_assert (font_j);
g_assert_true (font_j);
hb_bool_t result_j = hb_font_get_glyph_extents (font_j, 3, &extents);
g_assert (result_j);
g_assert_true (result_j);
g_assert_cmpint (extents.x_bearing, ==, 34);
g_assert_cmpint (extents.y_bearing, ==, 840);
@ -70,14 +70,14 @@ static void
test_extents_cff1_flex (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/cff1_flex.otf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_glyph_extents_t extents;
hb_bool_t result = hb_font_get_glyph_extents (font, 1, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, -20);
g_assert_cmpint (extents.y_bearing, ==, 520);
@ -91,14 +91,14 @@ static void
test_extents_cff1_seac (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/cff1_seac.otf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_glyph_extents_t extents;
hb_bool_t result = hb_font_get_glyph_extents (font, 3, &extents); /* Agrave */
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 3);
g_assert_cmpint (extents.y_bearing, ==, 861);
@ -106,7 +106,7 @@ test_extents_cff1_seac (void)
g_assert_cmpint (extents.height, ==, -861);
result = hb_font_get_glyph_extents (font, 4, &extents); /* Udieresis */
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 87);
g_assert_cmpint (extents.y_bearing, ==, 827);
@ -120,14 +120,14 @@ static void
test_extents_cff2 (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/AdobeVFPrototype.abc.otf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_glyph_extents_t extents;
hb_bool_t result = hb_font_get_glyph_extents (font, 1, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 46);
g_assert_cmpint (extents.y_bearing, ==, 487);
@ -137,7 +137,7 @@ test_extents_cff2 (void)
float coords[2] = { 600.0f, 50.0f };
hb_font_set_var_coords_design (font, coords, 2);
result = hb_font_get_glyph_extents (font, 1, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 38);
g_assert_cmpint (extents.y_bearing, ==, 493);
@ -151,16 +151,16 @@ static void
test_extents_cff2_vsindex (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/AdobeVFPrototype_vsindex.otf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_glyph_extents_t extents;
float coords[2] = { 800.0f, 50.0f };
hb_font_set_var_coords_design (font, coords, 2);
hb_bool_t result = hb_font_get_glyph_extents (font, 1, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 12);
g_assert_cmpint (extents.y_bearing, ==, 655);
@ -168,7 +168,7 @@ test_extents_cff2_vsindex (void)
g_assert_cmpint (extents.height, ==, -655);
result = hb_font_get_glyph_extents (font, 2, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 8);
g_assert_cmpint (extents.y_bearing, ==, 669);
@ -182,15 +182,15 @@ static void
test_extents_cff2_vsindex_named_instance (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/AdobeVFPrototype_vsindex.otf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_font_set_var_named_instance (font, 6); // 6 (BlackMediumContrast): 900, 50
hb_glyph_extents_t extents;
hb_bool_t result = hb_font_get_glyph_extents (font, 1, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 13);
g_assert_cmpint (extents.y_bearing, ==, 652);
@ -198,7 +198,7 @@ test_extents_cff2_vsindex_named_instance (void)
g_assert_cmpint (extents.height, ==, -652);
result = hb_font_get_glyph_extents (font, 2, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 6);
g_assert_cmpint (extents.y_bearing, ==, 675);

2
test/api/test-ot-face.c
View file

@ -209,7 +209,7 @@ static void
test_ot_var_axis_on_zero_named_instance (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/Zycon.ttf");
g_assert (hb_ot_var_get_axis_count (face));
g_assert_true (hb_ot_var_get_axis_count (face));
hb_face_destroy (face);
}

4
test/api/test-ot-glyphname.c
View file

@ -33,9 +33,9 @@ test_one_glyph (hb_font_t *font, hb_codepoint_t gid, const char *name)
char buf[64];
hb_codepoint_t glyph;
g_assert(hb_font_get_glyph_name (font, gid, buf, sizeof (buf)));
g_assert_true(hb_font_get_glyph_name (font, gid, buf, sizeof (buf)));
g_assert_cmpstr(buf, ==, name);
g_assert(hb_font_get_glyph_from_name (font, name, -1, &glyph));
g_assert_true(hb_font_get_glyph_from_name (font, name, -1, &glyph));
g_assert_cmpint(glyph, ==, gid);
}

12
test/api/test-ot-layout.c
View file

@ -74,18 +74,18 @@ test_ot_layout_table_find_script (void)
hb_face_t *face = hb_test_open_font_file ("fonts/NotoNastaliqUrdu-Regular.ttf");
unsigned int index;
g_assert (hb_ot_layout_table_find_script (face, HB_OT_TAG_GSUB, HB_TAG ('a','r','a','b'), &index));
g_assert_true (hb_ot_layout_table_find_script (face, HB_OT_TAG_GSUB, HB_TAG ('a','r','a','b'), &index));
g_assert_cmpuint (0, ==, index);
g_assert (hb_ot_layout_table_find_script (face, HB_OT_TAG_GSUB, HB_TAG ('d','f','l','t'), &index));
g_assert_true (hb_ot_layout_table_find_script (face, HB_OT_TAG_GSUB, HB_TAG ('d','f','l','t'), &index));
g_assert_cmpuint (1, ==, index);
g_assert (hb_ot_layout_table_find_script (face, HB_OT_TAG_GSUB, HB_TAG ('l','a','t','n'), &index));
g_assert_true (hb_ot_layout_table_find_script (face, HB_OT_TAG_GSUB, HB_TAG ('l','a','t','n'), &index));
g_assert_cmpuint (2, ==, index);
g_assert (hb_ot_layout_table_find_script (face, HB_OT_TAG_GPOS, HB_TAG ('a','r','a','b'), &index));
g_assert_true (hb_ot_layout_table_find_script (face, HB_OT_TAG_GPOS, HB_TAG ('a','r','a','b'), &index));
g_assert_cmpuint (0, ==, index);
g_assert (!hb_ot_layout_table_find_script (face, HB_OT_TAG_GPOS, HB_TAG ('d','f','l','t'), &index));
g_assert_true (!hb_ot_layout_table_find_script (face, HB_OT_TAG_GPOS, HB_TAG ('d','f','l','t'), &index));
g_assert_cmpuint (0xFFFF, ==, index);
g_assert (!hb_ot_layout_table_find_script (face, HB_OT_TAG_GPOS, HB_TAG ('l','a','t','n'), &index));
g_assert_true (!hb_ot_layout_table_find_script (face, HB_OT_TAG_GPOS, HB_TAG ('l','a','t','n'), &index));
g_assert_cmpuint (0xFFFF, ==, index);
hb_face_destroy (face);

164
test/api/test-ot-math.c
View file

@ -38,22 +38,22 @@ test_has_data (void)
hb_font_t *font;
face = hb_test_open_font_file ("fonts/MathTestFontNone.otf");
g_assert (!hb_ot_math_has_data (face)); // MATH table not available
g_assert_true (!hb_ot_math_has_data (face)); // MATH table not available
hb_face_destroy (face);
face = hb_test_open_font_file ("fonts/MathTestFontEmpty.otf");
g_assert (hb_ot_math_has_data (face)); // MATH table available
g_assert_true (hb_ot_math_has_data (face)); // MATH table available
hb_face_destroy (face);
face = hb_face_get_empty ();
font = hb_font_create (face);
g_assert (!hb_ot_math_has_data (face)); // MATH table not available
g_assert_true (!hb_ot_math_has_data (face)); // MATH table not available
hb_font_destroy (font);
hb_face_destroy (face);
font = hb_font_get_empty ();
face = hb_font_get_face (font);
g_assert (!hb_ot_math_has_data (face)); // MATH table not available
g_assert_true (!hb_ot_math_has_data (face)); // MATH table not available
hb_font_destroy (font);
hb_face_destroy (face);
}
@ -155,21 +155,21 @@ test_get_glyph_italics_correction (void)
face = hb_test_open_font_file ("fonts/MathTestFontEmpty.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_italics_correction (font, glyph), ==, 0); // MathGlyphInfo not available
hb_font_destroy (font);
hb_face_destroy (face);
face = hb_test_open_font_file ("fonts/MathTestFontPartial1.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_italics_correction (font, glyph), ==, 0); // MathGlyphInfo empty
hb_font_destroy (font);
hb_face_destroy (face);
face = hb_test_open_font_file ("fonts/MathTestFontPartial2.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_italics_correction (font, glyph), ==, 0); // MathItalicsCorrectionInfo empty
hb_font_destroy (font);
hb_face_destroy (face);
@ -177,13 +177,13 @@ test_get_glyph_italics_correction (void)
face = hb_test_open_font_file ("fonts/MathTestFontFull.otf");
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_italics_correction (font, glyph), ==, 0); // Glyph without italic correction.
g_assert (hb_font_get_glyph_from_name (font, "A", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "A", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_italics_correction (font, glyph), ==, 394);
g_assert (hb_font_get_glyph_from_name (font, "B", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "B", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_italics_correction (font, glyph), ==, 300);
g_assert (hb_font_get_glyph_from_name (font, "C", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "C", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_italics_correction (font, glyph), ==, 904);
hb_font_destroy (font);
hb_face_destroy (face);
@ -199,7 +199,7 @@ test_get_glyph_top_accent_attachment (void)
face = hb_test_open_font_file ("fonts/MathTestFontEmpty.otf");
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_top_accent_attachment (font, glyph), ==, 1000); // MathGlyphInfo not available
hb_font_destroy (font);
hb_face_destroy (face);
@ -207,7 +207,7 @@ test_get_glyph_top_accent_attachment (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial1.otf");
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_top_accent_attachment (font, glyph), ==, 1000); // MathGlyphInfo empty
hb_font_destroy (font);
hb_face_destroy (face);
@ -215,7 +215,7 @@ test_get_glyph_top_accent_attachment (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial2.otf");
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_top_accent_attachment (font, glyph), ==, 1000); // MathTopAccentAttachment empty
hb_font_destroy (font);
hb_face_destroy (face);
@ -223,13 +223,13 @@ test_get_glyph_top_accent_attachment (void)
face = hb_test_open_font_file ("fonts/MathTestFontFull.otf");
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_top_accent_attachment (font, glyph), ==, 1000); // Glyph without top accent attachment.
g_assert (hb_font_get_glyph_from_name (font, "D", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "D", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_top_accent_attachment (font, glyph), ==, 748);
g_assert (hb_font_get_glyph_from_name (font, "E", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "E", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_top_accent_attachment (font, glyph), ==, 692);
g_assert (hb_font_get_glyph_from_name (font, "F", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "F", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_top_accent_attachment (font, glyph), ==, 636);
hb_font_destroy (font);
hb_face_destroy (face);
@ -244,24 +244,24 @@ test_is_glyph_extended_shape (void)
face = hb_test_open_font_file ("fonts/MathTestFontEmpty.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert (!hb_ot_math_is_glyph_extended_shape (face, glyph)); // MathGlyphInfo not available
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (!hb_ot_math_is_glyph_extended_shape (face, glyph)); // MathGlyphInfo not available
hb_font_destroy (font);
hb_face_destroy (face);
face = hb_test_open_font_file ("fonts/MathTestFontPartial1.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert (!hb_ot_math_is_glyph_extended_shape (face, glyph)); // MathGlyphInfo empty
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (!hb_ot_math_is_glyph_extended_shape (face, glyph)); // MathGlyphInfo empty
hb_font_destroy (font);
hb_face_destroy (face);
face = hb_test_open_font_file ("fonts/MathTestFontFull.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "G", -1, &glyph));
g_assert (!hb_ot_math_is_glyph_extended_shape (face, glyph));
g_assert (hb_font_get_glyph_from_name (font, "H", -1, &glyph));
g_assert (hb_ot_math_is_glyph_extended_shape (face, glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "G", -1, &glyph));
g_assert_true (!hb_ot_math_is_glyph_extended_shape (face, glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "H", -1, &glyph));
g_assert_true (hb_ot_math_is_glyph_extended_shape (face, glyph));
hb_font_destroy (font);
hb_face_destroy (face);
}
@ -275,7 +275,7 @@ test_get_glyph_kerning (void)
face = hb_test_open_font_file ("fonts/MathTestFontEmpty.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_TOP_RIGHT, 0), ==, 0); // MathGlyphInfo not available
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_TOP_LEFT, 0), ==, 0); // MathGlyphInfo not available
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_BOTTOM_RIGHT, 0), ==, 0); // MathGlyphInfo not available
@ -285,7 +285,7 @@ test_get_glyph_kerning (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial2.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_TOP_RIGHT, 0), ==, 0); // MathKernInfo empty
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_TOP_LEFT, 0), ==, 0); // MathKernInfo empty
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_BOTTOM_RIGHT, 0), ==, 0); // MathKernInfo empty
@ -295,7 +295,7 @@ test_get_glyph_kerning (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial3.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_TOP_RIGHT, 0), ==, 0); // MathKernInfoRecords empty
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_TOP_LEFT, 0), ==, 0); // MathKernInfoRecords empty
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_BOTTOM_RIGHT, 0), ==, 0); // MathKernInfoRecords empty
@ -306,7 +306,7 @@ test_get_glyph_kerning (void)
face = hb_test_open_font_file ("fonts/MathTestFontFull.otf");
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "I", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "I", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_TOP_RIGHT, 7), ==, 62); // lower than min height
g_assert_cmpint (hb_ot_math_get_glyph_kerning (font, glyph, HB_OT_MATH_KERN_TOP_RIGHT, 14), ==, 104); // equal to min height
@ -339,7 +339,7 @@ test_get_glyph_kernings (void)
face = hb_test_open_font_file ("fonts/MathTestFontEmpty.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_TOP_RIGHT, 0, NULL, NULL), ==, 0); // MathGlyphInfo not available
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_TOP_LEFT, 0, NULL, NULL), ==, 0); // MathGlyphInfo not available
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_BOTTOM_RIGHT, 0, NULL, NULL), ==, 0); // MathGlyphInfo not available
@ -349,7 +349,7 @@ test_get_glyph_kernings (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial2.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_TOP_RIGHT, 0, NULL, NULL), ==, 0); // MathKernInfo empty
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_TOP_LEFT, 0, NULL, NULL), ==, 0); // MathKernInfo empty
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_BOTTOM_RIGHT, 0, NULL, NULL), ==, 0); // MathKernInfo empty
@ -359,7 +359,7 @@ test_get_glyph_kernings (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial3.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_TOP_RIGHT, 0, NULL, NULL), ==, 0); // MathKernInfoRecords empty
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_TOP_LEFT, 0, NULL, NULL), ==, 0); // MathKernInfoRecords empty
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_BOTTOM_RIGHT, 0, NULL, NULL), ==, 0); // MathKernInfoRecords empty
@ -370,7 +370,7 @@ test_get_glyph_kernings (void)
face = hb_test_open_font_file ("fonts/MathTestFontFull.otf");
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "I", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "I", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_TOP_RIGHT, 0, NULL, NULL), ==, 10);
g_assert_cmpint (hb_ot_math_get_glyph_kernings (font, glyph, HB_OT_MATH_KERN_TOP_LEFT, 0, NULL, NULL), ==, 3);
@ -438,7 +438,7 @@ test_get_glyph_assembly_italics_correction (void)
face = hb_test_open_font_file ("fonts/MathTestFontEmpty.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, TRUE), ==, 0); // MathVariants not available
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, FALSE), ==, 0); // MathVariants not available
hb_font_destroy (font);
@ -446,7 +446,7 @@ test_get_glyph_assembly_italics_correction (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial1.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, TRUE), ==, 0); // VertGlyphCoverage and HorizGlyphCoverage absent
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, FALSE), ==, 0); // VertGlyphCoverage and HorizGlyphCoverage absent
hb_font_destroy (font);
@ -454,7 +454,7 @@ test_get_glyph_assembly_italics_correction (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial2.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, TRUE), ==, 0); // VertGlyphCoverage and HorizGlyphCoverage empty
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, FALSE), ==, 0); // VertGlyphCoverage and HorizGlyphCoverage empty
hb_font_destroy (font);
@ -462,7 +462,7 @@ test_get_glyph_assembly_italics_correction (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial3.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, TRUE), ==, 0); // HorizGlyphConstruction and VertGlyphConstruction empty
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, FALSE), ==, 0); // HorizGlyphConstruction and VertGlyphConstruction empty
hb_font_destroy (font);
@ -470,7 +470,7 @@ test_get_glyph_assembly_italics_correction (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial4.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, TRUE), ==, 0);
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, FALSE), ==, 0);
hb_font_destroy (font);
@ -479,10 +479,10 @@ test_get_glyph_assembly_italics_correction (void)
face = hb_test_open_font_file ("fonts/MathTestFontFull.otf");
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "arrowleft", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowleft", -1, &glyph));
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, TRUE), ==, 248);
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, FALSE), ==, 0);
g_assert (hb_font_get_glyph_from_name (font, "arrowup", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowup", -1, &glyph));
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, TRUE), ==, 0);
g_assert_cmpint (get_glyph_assembly_italics_correction (font, glyph, FALSE), ==, 662);
hb_font_destroy (font);
@ -524,7 +524,7 @@ test_get_glyph_variants (void)
face = hb_test_open_font_file ("fonts/MathTestFontEmpty.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -532,7 +532,7 @@ test_get_glyph_variants (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial1.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -540,7 +540,7 @@ test_get_glyph_variants (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial2.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -548,7 +548,7 @@ test_get_glyph_variants (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial3.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -556,7 +556,7 @@ test_get_glyph_variants (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial4.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_variants (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -566,7 +566,7 @@ test_get_glyph_variants (void)
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "arrowleft", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowleft", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_variants (font,
glyph,
HB_DIRECTION_BTT,
@ -580,7 +580,7 @@ test_get_glyph_variants (void)
NULL,
NULL), ==, 3);
g_assert (hb_font_get_glyph_from_name (font, "arrowup", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowup", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_variants (font,
glyph,
HB_DIRECTION_BTT,
@ -594,7 +594,7 @@ test_get_glyph_variants (void)
NULL,
NULL), ==, 0);
g_assert (hb_font_get_glyph_from_name (font, "arrowleft", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowleft", -1, &glyph));
do {
count = variantsSize;
hb_ot_math_get_glyph_variants (font,
@ -606,17 +606,17 @@ test_get_glyph_variants (void)
offset += count;
} while (count == variantsSize);
g_assert_cmpint (offset, ==, 3);
g_assert (hb_font_get_glyph_from_name (font, "uni2190_size2", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "uni2190_size2", -1, &glyph));
g_assert_cmpint (variants[0].glyph, ==, glyph);
g_assert_cmpint (variants[0].advance, ==, 4302);
g_assert (hb_font_get_glyph_from_name (font, "uni2190_size3", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "uni2190_size3", -1, &glyph));
g_assert_cmpint (variants[1].glyph, ==, glyph);
g_assert_cmpint (variants[1].advance, ==, 4802);
g_assert (hb_font_get_glyph_from_name (font, "uni2190_size4", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "uni2190_size4", -1, &glyph));
g_assert_cmpint (variants[2].glyph, ==, glyph);
g_assert_cmpint (variants[2].advance, ==, 5802);
g_assert (hb_font_get_glyph_from_name (font, "arrowup", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowup", -1, &glyph));
offset = 0;
do {
count = variantsSize;
@ -629,16 +629,16 @@ test_get_glyph_variants (void)
offset += count;
} while (count == variantsSize);
g_assert_cmpint (offset, ==, 4);
g_assert (hb_font_get_glyph_from_name (font, "uni2191_size2", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "uni2191_size2", -1, &glyph));
g_assert_cmpint (variants[0].glyph, ==, glyph);
g_assert_cmpint (variants[0].advance, ==, 2251);
g_assert (hb_font_get_glyph_from_name (font, "uni2191_size3", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "uni2191_size3", -1, &glyph));
g_assert_cmpint (variants[1].glyph, ==, glyph);
g_assert_cmpint (variants[1].advance, ==, 2501);
g_assert (hb_font_get_glyph_from_name (font, "uni2191_size4", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "uni2191_size4", -1, &glyph));
g_assert_cmpint (variants[2].glyph, ==, glyph);
g_assert_cmpint (variants[2].advance, ==, 3001);
g_assert (hb_font_get_glyph_from_name (font, "uni2191_size5", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "uni2191_size5", -1, &glyph));
g_assert_cmpint (variants[3].glyph, ==, glyph);
g_assert_cmpint (variants[3].advance, ==, 3751);
@ -659,7 +659,7 @@ test_get_glyph_assembly (void)
face = hb_test_open_font_file ("fonts/MathTestFontEmpty.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -667,7 +667,7 @@ test_get_glyph_assembly (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial1.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -675,7 +675,7 @@ test_get_glyph_assembly (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial2.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -683,7 +683,7 @@ test_get_glyph_assembly (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial3.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -691,7 +691,7 @@ test_get_glyph_assembly (void)
face = hb_test_open_font_file ("fonts/MathTestFontPartial4.otf");
font = hb_font_create (face);
g_assert (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "space", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_RTL, 0, NULL, NULL, NULL), ==, 0);
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font, glyph, HB_DIRECTION_BTT, 0, NULL, NULL, NULL), ==, 0);
hb_font_destroy (font);
@ -701,7 +701,7 @@ test_get_glyph_assembly (void)
font = hb_font_create (face);
hb_font_set_scale (font, 2000, 1000);
g_assert (hb_font_get_glyph_from_name (font, "arrowright", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowright", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font,
glyph,
HB_DIRECTION_BTT,
@ -717,7 +717,7 @@ test_get_glyph_assembly (void)
NULL,
NULL), ==, 3);
g_assert (hb_font_get_glyph_from_name (font, "arrowdown", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowdown", -1, &glyph));
g_assert_cmpint (hb_ot_math_get_glyph_assembly (font,
glyph,
HB_DIRECTION_BTT,
@ -733,7 +733,7 @@ test_get_glyph_assembly (void)
NULL,
NULL), ==, 0);
g_assert (hb_font_get_glyph_from_name (font, "arrowright", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowright", -1, &glyph));
do {
count = partsSize;
hb_ot_math_get_glyph_assembly (font,
@ -746,26 +746,26 @@ test_get_glyph_assembly (void)
offset += count;
} while (count == partsSize);
g_assert_cmpint (offset, ==, 3);
g_assert (hb_font_get_glyph_from_name (font, "left", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "left", -1, &glyph));
g_assert_cmpint (parts[0].glyph, ==, glyph);
g_assert_cmpint (parts[0].start_connector_length, ==, 800);
g_assert_cmpint (parts[0].end_connector_length, ==, 384);
g_assert_cmpint (parts[0].full_advance, ==, 2000);
g_assert (!(parts[0].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
g_assert (hb_font_get_glyph_from_name (font, "horizontal", -1, &glyph));
g_assert_true (!(parts[0].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
g_assert_true (hb_font_get_glyph_from_name (font, "horizontal", -1, &glyph));
g_assert_cmpint (parts[1].glyph, ==, glyph);
g_assert_cmpint (parts[1].start_connector_length, ==, 524);
g_assert_cmpint (parts[1].end_connector_length, ==, 800);
g_assert_cmpint (parts[1].full_advance, ==, 2000);
g_assert (parts[1].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER);
g_assert (hb_font_get_glyph_from_name (font, "right", -1, &glyph));
g_assert_true (parts[1].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER);
g_assert_true (hb_font_get_glyph_from_name (font, "right", -1, &glyph));
g_assert_cmpint (parts[2].glyph, ==, glyph);
g_assert_cmpint (parts[2].start_connector_length, ==, 316);
g_assert_cmpint (parts[2].end_connector_length, ==, 454);
g_assert_cmpint (parts[2].full_advance, ==, 2000);
g_assert (!(parts[2].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
g_assert_true (!(parts[2].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
g_assert (hb_font_get_glyph_from_name (font, "arrowdown", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "arrowdown", -1, &glyph));
offset = 0;
do {
count = partsSize;
@ -779,36 +779,36 @@ test_get_glyph_assembly (void)
offset += count;
} while (count == partsSize);
g_assert_cmpint (offset, ==, 5);
g_assert (hb_font_get_glyph_from_name (font, "bottom", -1, &glyph));
g_assert_true (hb_font_get_glyph_from_name (font, "bottom", -1, &glyph));
g_assert_cmpint (parts[0].glyph, ==, glyph);
g_assert_cmpint (parts[0].start_connector_length, ==, 365);
g_assert_cmpint (parts[0].end_connector_length, ==, 158);
g_assert_cmpint (parts[0].full_advance, ==, 1000);
g_assert (!(parts[0].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
g_assert (hb_font_get_glyph_from_name (font, "vertical", -1, &glyph));
g_assert_true (!(parts[0].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
g_assert_true (hb_font_get_glyph_from_name (font, "vertical", -1, &glyph));
g_assert_cmpint (parts[1].glyph, ==, glyph);
g_assert_cmpint (parts[1].start_connector_length, ==, 227);
g_assert_cmpint (parts[1].end_connector_length, ==, 365);
g_assert_cmpint (parts[1].full_advance, ==, 1000);
g_assert (parts[1].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER);
g_assert (hb_font_get_glyph_from_name (font, "center", -1, &glyph));
g_assert_true (parts[1].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER);
g_assert_true (hb_font_get_glyph_from_name (font, "center", -1, &glyph));
g_assert_cmpint (parts[2].glyph, ==, glyph);
g_assert_cmpint (parts[2].start_connector_length, ==, 54);
g_assert_cmpint (parts[2].end_connector_length, ==, 158);
g_assert_cmpint (parts[2].full_advance, ==, 1000);
g_assert (!(parts[2].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
g_assert (hb_font_get_glyph_from_name (font, "vertical", -1, &glyph));
g_assert_true (!(parts[2].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
g_assert_true (hb_font_get_glyph_from_name (font, "vertical", -1, &glyph));
g_assert_cmpint (parts[3].glyph, ==, glyph);
g_assert_cmpint (parts[3].start_connector_length, ==, 400);
g_assert_cmpint (parts[3].end_connector_length, ==, 296);
g_assert_cmpint (parts[3].full_advance, ==, 1000);
g_assert (parts[1].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER);
g_assert (hb_font_get_glyph_from_name (font, "top", -1, &glyph));
g_assert_true (parts[1].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER);
g_assert_true (hb_font_get_glyph_from_name (font, "top", -1, &glyph));
g_assert_cmpint (parts[4].glyph, ==, glyph);
g_assert_cmpint (parts[4].start_connector_length, ==, 123);
g_assert_cmpint (parts[4].end_connector_length, ==, 192);
g_assert_cmpint (parts[4].full_advance, ==, 1000);
g_assert (!(parts[4].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
g_assert_true (!(parts[4].flags & HB_OT_MATH_GLYPH_PART_FLAG_EXTENDER));
hb_font_destroy (font);
hb_face_destroy (face);

40
test/api/test-ot-metrics-tt-var.c
View file

@ -33,14 +33,14 @@ static void
test_extents_tt_var (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/SourceSansVariable-Roman-nohvar-41,C1.ttf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_glyph_extents_t extents;
hb_bool_t result = hb_font_get_glyph_extents (font, 2, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 10);
g_assert_cmpint (extents.y_bearing, ==, 846);
@ -50,7 +50,7 @@ test_extents_tt_var (void)
float coords[1] = { 500.0f };
hb_font_set_var_coords_design (font, coords, 1);
result = hb_font_get_glyph_extents (font, 2, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 0);
g_assert_cmpint (extents.y_bearing, ==, 874);
@ -64,10 +64,10 @@ static void
test_advance_tt_var_nohvar (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/SourceSansVariable-Roman-nohvar-41,C1.ttf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_position_t x, y;
hb_font_get_glyph_advance_for_direction(font, 2, HB_DIRECTION_LTR, &x, &y);
@ -99,10 +99,10 @@ static void
test_advance_tt_var_hvarvvar (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/SourceSerifVariable-Roman-VVAR.abc.ttf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_position_t x, y;
hb_font_get_glyph_advance_for_direction(font, 1, HB_DIRECTION_LTR, &x, &y);
@ -134,14 +134,14 @@ static void
test_advance_tt_var_anchor (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/SourceSansVariable-Roman.anchor.ttf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_glyph_extents_t extents;
hb_bool_t result = hb_font_get_glyph_extents (font, 2, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 56);
g_assert_cmpint (extents.y_bearing, ==, 672);
@ -151,7 +151,7 @@ test_advance_tt_var_anchor (void)
float coords[1] = { 500.0f };
hb_font_set_var_coords_design (font, coords, 1);
result = hb_font_get_glyph_extents (font, 2, &extents);
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 50);
g_assert_cmpint (extents.y_bearing, ==, 667);
@ -165,10 +165,10 @@ static void
test_extents_tt_var_comp (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/SourceSansVariable-Roman.modcomp.ttf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
hb_glyph_extents_t extents;
float coords[1] = { 800.0f };
@ -176,7 +176,7 @@ test_extents_tt_var_comp (void)
hb_bool_t result;
result = hb_font_get_glyph_extents (font, 2, &extents); /* Ccedilla, cedilla y-scaled by 0.8, with unscaled component offset */
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 19);
g_assert_cmpint (extents.y_bearing, ==, 663);
@ -184,7 +184,7 @@ test_extents_tt_var_comp (void)
g_assert_cmpint (extents.height, ==, -895);
result = hb_font_get_glyph_extents (font, 3, &extents); /* Cacute, acute y-scaled by 0.8, with unscaled component offset (default) */
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 19);
g_assert_cmpint (extents.y_bearing, ==, 909);
@ -192,7 +192,7 @@ test_extents_tt_var_comp (void)
g_assert_cmpint (extents.height, ==, -921);
result = hb_font_get_glyph_extents (font, 4, &extents); /* Ccaron, caron y-scaled by 0.8, with scaled component offset */
g_assert (result);
g_assert_true (result);
g_assert_cmpint (extents.x_bearing, ==, 19);
g_assert_cmpint (extents.y_bearing, ==, 866);
@ -206,10 +206,10 @@ static void
test_advance_tt_var_comp_v (void)
{
hb_face_t *face = hb_test_open_font_file ("fonts/SourceSansVariable-Roman.modcomp.ttf");
g_assert (face);
g_assert_true (face);
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
g_assert (font);
g_assert_true (font);
float coords[1] = { 800.0f };
hb_font_set_var_coords_design (font, coords, 1);
@ -239,7 +239,7 @@ test_advance_tt_var_gvar_infer (void)
hb_font_set_var_coords_normalized (font, coords, 6);
hb_glyph_extents_t extents = {0};
g_assert (hb_font_get_glyph_extents (font, 4, &extents));
g_assert_true (hb_font_get_glyph_extents (font, 4, &extents));
hb_font_destroy (font);
}

6
test/api/test-ot-metrics.c
View file

@ -36,7 +36,7 @@ test_ot_metrics_get_no_var (void)
hb_face_t *face = hb_test_open_font_file ("fonts/cpal-v0.ttf");
hb_font_t *font = hb_font_create (face);
hb_position_t value;
g_assert (hb_ot_metrics_get_position (font, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER, &value));
g_assert_true (hb_ot_metrics_get_position (font, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER, &value));
g_assert_cmpint (value, ==, 1000);
g_assert_cmpint (hb_ot_metrics_get_x_variation (font, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER), ==, 0);
g_assert_cmpint (hb_ot_metrics_get_y_variation (font, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER), ==, 0);
@ -52,14 +52,14 @@ test_ot_metrics_get_var (void)
hb_face_t *face = hb_test_open_font_file ("fonts/TestCFF2VF.otf");
hb_font_t *font = hb_font_create (face);
hb_position_t value;
g_assert (hb_ot_metrics_get_position (font, HB_OT_METRICS_TAG_X_HEIGHT, &value));
g_assert_true (hb_ot_metrics_get_position (font, HB_OT_METRICS_TAG_X_HEIGHT, &value));
g_assert_cmpint (value, ==, 486);
g_assert_cmpint (hb_ot_metrics_get_x_variation (font, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER), ==, 0);
g_assert_cmpint (hb_ot_metrics_get_y_variation (font, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER), ==, 0);
g_assert_cmpint (hb_ot_metrics_get_x_variation (font, HB_OT_METRICS_TAG_X_HEIGHT), ==, 0);
float coords[] = {100.f};
hb_font_set_var_coords_design (font, coords, 1);
g_assert (hb_ot_metrics_get_position (font, HB_OT_METRICS_TAG_X_HEIGHT, &value));
g_assert_true (hb_ot_metrics_get_position (font, HB_OT_METRICS_TAG_X_HEIGHT, &value));
g_assert_cmpint (value, ==, 478);
g_assert_cmpint (hb_ot_metrics_get_x_variation (font, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER), ==, 0);
g_assert_cmpint (hb_ot_metrics_get_y_variation (font, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER), ==, 0);

8
test/api/test-ot-tag.c
View file

@ -223,7 +223,7 @@ test_language_two_way (const char *tag_s, const char *lang_s)
g_assert_cmphex (tag, ==, tag2);
else
g_assert_cmphex (tag, ==, HB_TAG_CHAR4 ("dflt"));
g_assert (lang == hb_ot_tag_to_language (tag));
g_assert_true (lang == hb_ot_tag_to_language (tag));
}
static void
@ -254,7 +254,7 @@ test_tag_to_language (const char *tag_s, const char *lang_s)
g_test_message ("Testing tag %s -> language %s", tag_s, lang_s);
g_assert (lang == hb_ot_tag_to_language (tag));
g_assert_true (lang == hb_ot_tag_to_language (tag));
}
static void
@ -511,8 +511,8 @@ test_tags (hb_script_t script,
hb_tag_t *script_tags = malloc (script_count * sizeof (hb_tag_t));
hb_tag_t *language_tags = malloc (language_count * sizeof (hb_tag_t));
hb_language_t lang;
g_assert (script_tags);
g_assert (language_tags);
g_assert_true (script_tags);
g_assert_true (language_tags);
lang = hb_language_from_string (lang_s, -1);
va_start (expected_tags, expected_language_count);

446
test/api/test-set.c
View file

@ -36,14 +36,14 @@ test_empty (hb_set_t *s)
g_assert_cmpint (hb_set_get_population (s), ==, 0);
g_assert_cmpint (hb_set_get_min (s), ==, HB_SET_VALUE_INVALID);
g_assert_cmpint (hb_set_get_max (s), ==, HB_SET_VALUE_INVALID);
g_assert (!hb_set_has (s, 13));
g_assert_true (!hb_set_has (s, 13));
next = 53043;
g_assert (!hb_set_next (s, &next));
g_assert_true (!hb_set_next (s, &next));
g_assert_cmpint (next, ==, HB_SET_VALUE_INVALID);
next = 07734;
g_assert (!hb_set_previous (s, &next));
g_assert_true (!hb_set_previous (s, &next));
g_assert_cmpint (next, ==, HB_SET_VALUE_INVALID);
g_assert (hb_set_is_empty (s));
g_assert_true (hb_set_is_empty (s));
}
static void
@ -54,10 +54,10 @@ test_not_empty (hb_set_t *s)
g_assert_cmpint (hb_set_get_min (s), !=, HB_SET_VALUE_INVALID);
g_assert_cmpint (hb_set_get_max (s), !=, HB_SET_VALUE_INVALID);
next = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_cmpint (next, !=, HB_SET_VALUE_INVALID);
next = HB_SET_VALUE_INVALID;
g_assert (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_cmpint (next, !=, HB_SET_VALUE_INVALID);
}
@ -79,47 +79,47 @@ test_set_basic (void)
hb_set_add_range (s, 10, 29);
test_not_empty (s);
g_assert (hb_set_has (s, 13));
g_assert_true (hb_set_has (s, 13));
g_assert_cmpint (hb_set_get_population (s), ==, 20);
g_assert_cmpint (hb_set_get_min (s), ==, 10);
g_assert_cmpint (hb_set_get_max (s), ==, 29);
test_not_empty (s);
g_assert (hb_set_has (s, 13));
g_assert_true (hb_set_has (s, 13));
g_assert_cmpint (hb_set_get_population (s), ==, 20);
g_assert_cmpint (hb_set_get_min (s), ==, 10);
g_assert_cmpint (hb_set_get_max (s), ==, 29);
hb_set_del_range (s, 10, 18);
test_not_empty (s);
g_assert (!hb_set_has (s, 13));
g_assert_true (!hb_set_has (s, 13));
hb_set_add_range (s, 200, 800);
test_not_empty (s);
g_assert (!hb_set_has (s, 100));
g_assert (!hb_set_has (s, 199));
g_assert (hb_set_has (s, 200));
g_assert (hb_set_has (s, 201));
g_assert (hb_set_has (s, 243));
g_assert (hb_set_has (s, 254));
g_assert (hb_set_has (s, 255));
g_assert (hb_set_has (s, 256));
g_assert (hb_set_has (s, 257));
g_assert (hb_set_has (s, 511));
g_assert (hb_set_has (s, 512));
g_assert (hb_set_has (s, 600));
g_assert (hb_set_has (s, 767));
g_assert (hb_set_has (s, 768));
g_assert (hb_set_has (s, 769));
g_assert (hb_set_has (s, 782));
g_assert (hb_set_has (s, 798));
g_assert (hb_set_has (s, 799));
g_assert (hb_set_has (s, 800));
g_assert (!hb_set_has (s, 801));
g_assert (!hb_set_has (s, 802));
g_assert_true (!hb_set_has (s, 100));
g_assert_true (!hb_set_has (s, 199));
g_assert_true (hb_set_has (s, 200));
g_assert_true (hb_set_has (s, 201));
g_assert_true (hb_set_has (s, 243));
g_assert_true (hb_set_has (s, 254));
g_assert_true (hb_set_has (s, 255));
g_assert_true (hb_set_has (s, 256));
g_assert_true (hb_set_has (s, 257));
g_assert_true (hb_set_has (s, 511));
g_assert_true (hb_set_has (s, 512));
g_assert_true (hb_set_has (s, 600));
g_assert_true (hb_set_has (s, 767));
g_assert_true (hb_set_has (s, 768));
g_assert_true (hb_set_has (s, 769));
g_assert_true (hb_set_has (s, 782));
g_assert_true (hb_set_has (s, 798));
g_assert_true (hb_set_has (s, 799));
g_assert_true (hb_set_has (s, 800));
g_assert_true (!hb_set_has (s, 801));
g_assert_true (!hb_set_has (s, 802));
hb_set_del (s, 800);
g_assert (!hb_set_has (s, 800));
g_assert_true (!hb_set_has (s, 800));
g_assert_cmpint (hb_set_get_max (s), ==, 799);
@ -152,7 +152,7 @@ static void test_set_intersect_empty (void)
hb_set_add (b, 24064);
hb_set_intersect (a, b);
g_assert (hb_set_is_empty (a));
g_assert_true (hb_set_is_empty (a));
hb_set_destroy (a);
hb_set_destroy (b);
@ -165,7 +165,7 @@ static void test_set_intersect_empty (void)
hb_set_add (b, 0);
hb_set_intersect (a, b);
g_assert (hb_set_is_empty (a));
g_assert_true (hb_set_is_empty (a));
hb_set_destroy (a);
hb_set_destroy (b);
@ -183,7 +183,7 @@ static void test_set_intersect_page_reduction (void)
hb_set_add (b, 24405);
hb_set_intersect(a, b);
g_assert (hb_set_is_equal (a, b));
g_assert_true (hb_set_is_equal (a, b));
hb_set_destroy (a);
hb_set_destroy (b);
@ -208,7 +208,7 @@ static void test_set_union (void)
hb_set_add (u, 24405);
hb_set_union(b, a);
g_assert (hb_set_is_equal (u, b));
g_assert_true (hb_set_is_equal (u, b));
hb_set_destroy (a);
hb_set_destroy (b);
@ -223,24 +223,24 @@ test_set_subsets (void)
hb_set_add (l, 0x0FFFF);
hb_set_add (s, 0x1FFFF);
g_assert (!hb_set_is_subset (s, l));
g_assert_true (!hb_set_is_subset (s, l));
hb_set_clear (s);
hb_set_add (s, 0x0FFF0);
g_assert (!hb_set_is_subset (s, l));
g_assert_true (!hb_set_is_subset (s, l));
hb_set_clear (s);
hb_set_add (s, 0x0AFFF);
g_assert (!hb_set_is_subset (s, l));
g_assert_true (!hb_set_is_subset (s, l));
hb_set_clear (s);
g_assert (hb_set_is_subset (s, l));
g_assert_true (hb_set_is_subset (s, l));
hb_set_clear (l);
g_assert (hb_set_is_subset (s, l));
g_assert_true (hb_set_is_subset (s, l));
hb_set_add (s, 0x1FFFF);
g_assert (!hb_set_is_subset (s, l));
g_assert_true (!hb_set_is_subset (s, l));
hb_set_clear (s);
hb_set_add (s, 0xFF);
@ -251,17 +251,17 @@ test_set_subsets (void)
hb_set_add (l, 0x1FFFF);
hb_set_add (l, 0x2FFFF);
g_assert (hb_set_is_subset (s, l));
g_assert_true (hb_set_is_subset (s, l));
hb_set_del (l, 0xFF);
g_assert (!hb_set_is_subset (s, l));
g_assert_true (!hb_set_is_subset (s, l));
hb_set_add (l, 0xFF);
hb_set_del (l, 0x2FFFF);
g_assert (!hb_set_is_subset (s, l));
g_assert_true (!hb_set_is_subset (s, l));
hb_set_add (l, 0x2FFFF);
hb_set_del (l, 0x1FFFF);
g_assert (!hb_set_is_subset (s, l));
g_assert_true (!hb_set_is_subset (s, l));
hb_set_destroy (s);
hb_set_destroy (l);
@ -280,13 +280,13 @@ test_set_algebra (void)
hb_set_add (o2, 0x660E);
test_empty (s);
g_assert (!hb_set_is_equal (s, o));
g_assert (hb_set_is_subset (s, o));
g_assert (!hb_set_is_subset (o, s));
g_assert_true (!hb_set_is_equal (s, o));
g_assert_true (hb_set_is_subset (s, o));
g_assert_true (!hb_set_is_subset (o, s));
hb_set_set (s, o);
g_assert (hb_set_is_equal (s, o));
g_assert (hb_set_is_subset (s, o));
g_assert (hb_set_is_subset (o, s));
g_assert_true (hb_set_is_equal (s, o));
g_assert_true (hb_set_is_subset (s, o));
g_assert_true (hb_set_is_subset (o, s));
test_not_empty (s);
g_assert_cmpint (hb_set_get_population (s), ==, 2);
@ -296,50 +296,50 @@ test_set_algebra (void)
g_assert_cmpint (hb_set_get_population (s), ==, 1);
hb_set_union (s, o);
g_assert_cmpint (hb_set_get_population (s), ==, 3);
g_assert (hb_set_has (s, 10));
g_assert (hb_set_has (s, 13));
g_assert_true (hb_set_has (s, 10));
g_assert_true (hb_set_has (s, 13));
hb_set_clear (s);
test_empty (s);
g_assert_cmpint (hb_set_get_population (s), ==, 0);
hb_set_union (s, o2);
g_assert_cmpint (hb_set_get_population (s), ==, 1);
g_assert (hb_set_has (s, 0x660E));
g_assert_true (hb_set_has (s, 0x660E));
hb_set_clear (s);
test_empty (s);
hb_set_add_range (s, 10, 17);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
hb_set_intersect (s, o);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
test_not_empty (s);
g_assert_cmpint (hb_set_get_population (s), ==, 1);
g_assert (!hb_set_has (s, 10));
g_assert (hb_set_has (s, 13));
g_assert_true (!hb_set_has (s, 10));
g_assert_true (hb_set_has (s, 13));
hb_set_clear (s);
test_empty (s);
hb_set_add_range (s, 10, 17);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
hb_set_subtract (s, o);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
test_not_empty (s);
g_assert_cmpint (hb_set_get_population (s), ==, 7);
g_assert (hb_set_has (s, 12));
g_assert (!hb_set_has (s, 13));
g_assert (!hb_set_has (s, 19));
g_assert_true (hb_set_has (s, 12));
g_assert_true (!hb_set_has (s, 13));
g_assert_true (!hb_set_has (s, 19));
hb_set_clear (s);
test_empty (s);
hb_set_add_range (s, 10, 17);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
hb_set_symmetric_difference (s, o);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
test_not_empty (s);
g_assert_cmpint (hb_set_get_population (s), ==, 8);
g_assert (hb_set_has (s, 12));
g_assert (!hb_set_has (s, 13));
g_assert (hb_set_has (s, 19));
g_assert_true (hb_set_has (s, 12));
g_assert_true (!hb_set_has (s, 13));
g_assert_true (hb_set_has (s, 19));
/* https://github.com/harfbuzz/harfbuzz/issues/579 */
hb_set_clear (s);
@ -351,25 +351,25 @@ test_set_algebra (void)
test_empty (o);
hb_set_add (o, 889);
hb_set_add (o, 1024);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
hb_set_intersect (o, s);
test_not_empty (o);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
g_assert_cmpint (hb_set_get_population (o), ==, 2);
g_assert (hb_set_has (o, 889));
g_assert (hb_set_has (o, 1024));
g_assert_true (hb_set_has (o, 889));
g_assert_true (hb_set_has (o, 1024));
hb_set_clear (o);
test_empty (o);
hb_set_add_range (o, 887, 889);
hb_set_add (o, 1121);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
hb_set_intersect (o, s);
test_not_empty (o);
g_assert (!hb_set_is_equal (s, o));
g_assert_true (!hb_set_is_equal (s, o));
g_assert_cmpint (hb_set_get_population (o), ==, 3);
g_assert (hb_set_has (o, 887));
g_assert (hb_set_has (o, 888));
g_assert (hb_set_has (o, 889));
g_assert_true (hb_set_has (o, 887));
g_assert_true (hb_set_has (o, 888));
g_assert_true (hb_set_has (o, 889));
hb_set_clear (s);
test_empty (s);
@ -387,13 +387,13 @@ test_set_algebra (void)
g_assert_cmpint (hb_set_get_population (o), ==, 1);
hb_set_intersect (o, s);
g_assert_cmpint (hb_set_get_population (o), ==, 1);
g_assert (hb_set_has (o, 889));
g_assert_true (hb_set_has (o, 889));
hb_set_add (o, 511);
g_assert_cmpint (hb_set_get_population (o), ==, 2);
hb_set_intersect (o, s);
g_assert_cmpint (hb_set_get_population (o), ==, 1);
g_assert (hb_set_has (o, 889));
g_assert_true (hb_set_has (o, 889));
hb_set_destroy (s);
hb_set_destroy (o);
@ -416,84 +416,84 @@ test_set_iter (void)
test_not_empty (s);
next = HB_SET_VALUE_INVALID;
g_assert (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_cmpint (next, ==, 6);
g_assert (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_cmpint (next, ==, 10);
g_assert (hb_set_next (s, &next));
g_assert (hb_set_next (s, &next));
g_assert (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_cmpint (next, ==, 13);
g_assert (hb_set_next (s, &next));
g_assert (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_cmpint (next, ==, 15);
g_assert (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_cmpint (next, ==, 1100);
g_assert (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_cmpint (next, ==, 1200);
g_assert (hb_set_next (s, &next));
g_assert_true (hb_set_next (s, &next));
g_assert_cmpint (next, ==, 20005);
g_assert (!hb_set_next (s, &next));
g_assert_true (!hb_set_next (s, &next));
g_assert_cmpint (next, ==, HB_SET_VALUE_INVALID);
next = HB_SET_VALUE_INVALID;
g_assert (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_cmpint (next, ==, 20005);
g_assert (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_cmpint (next, ==, 1200);
g_assert (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_cmpint (next, ==, 1100);
g_assert (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_cmpint (next, ==, 15);
g_assert (hb_set_previous (s, &next));
g_assert (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_cmpint (next, ==, 13);
g_assert (hb_set_previous (s, &next));
g_assert (hb_set_previous (s, &next));
g_assert (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_cmpint (next, ==, 10);
g_assert (hb_set_previous (s, &next));
g_assert_true (hb_set_previous (s, &next));
g_assert_cmpint (next, ==, 6);
g_assert (!hb_set_previous (s, &next));
g_assert_true (!hb_set_previous (s, &next));
g_assert_cmpint (next, ==, HB_SET_VALUE_INVALID);
first = last = HB_SET_VALUE_INVALID;
g_assert (hb_set_next_range (s, &first, &last));
g_assert_true (hb_set_next_range (s, &first, &last));
g_assert_cmpint (first, ==, 6);
g_assert_cmpint (last, ==, 6);
g_assert (hb_set_next_range (s, &first, &last));
g_assert_true (hb_set_next_range (s, &first, &last));
g_assert_cmpint (first, ==, 10);
g_assert_cmpint (last, ==, 15);
g_assert (hb_set_next_range (s, &first, &last));
g_assert_true (hb_set_next_range (s, &first, &last));
g_assert_cmpint (first, ==, 1100);
g_assert_cmpint (last, ==, 1100);
g_assert (hb_set_next_range (s, &first, &last));
g_assert_true (hb_set_next_range (s, &first, &last));
g_assert_cmpint (first, ==, 1200);
g_assert_cmpint (last, ==, 1200);
g_assert (hb_set_next_range (s, &first, &last));
g_assert_true (hb_set_next_range (s, &first, &last));
g_assert_cmpint (first, ==, 20005);
g_assert_cmpint (last, ==, 20005);
g_assert (!hb_set_next_range (s, &first, &last));
g_assert_true (!hb_set_next_range (s, &first, &last));
g_assert_cmpint (first, ==, HB_SET_VALUE_INVALID);
g_assert_cmpint (last, ==, HB_SET_VALUE_INVALID);
first = last = HB_SET_VALUE_INVALID;
g_assert (hb_set_previous_range (s, &first, &last));
g_assert_true (hb_set_previous_range (s, &first, &last));
g_assert_cmpint (first, ==, 20005);
g_assert_cmpint (last, ==, 20005);
g_assert (hb_set_previous_range (s, &first, &last));
g_assert_true (hb_set_previous_range (s, &first, &last));
g_assert_cmpint (first, ==, 1200);
g_assert_cmpint (last, ==, 1200);
g_assert (hb_set_previous_range (s, &first, &last));
g_assert_true (hb_set_previous_range (s, &first, &last));
g_assert_cmpint (first, ==, 1100);
g_assert_cmpint (last, ==, 1100);
g_assert (hb_set_previous_range (s, &first, &last));
g_assert_true (hb_set_previous_range (s, &first, &last));
g_assert_cmpint (first, ==, 10);
g_assert_cmpint (last, ==, 15);
g_assert (hb_set_previous_range (s, &first, &last));
g_assert_true (hb_set_previous_range (s, &first, &last));
g_assert_cmpint (first, ==, 6);
g_assert_cmpint (last, ==, 6);
g_assert (!hb_set_previous_range (s, &first, &last));
g_assert_true (!hb_set_previous_range (s, &first, &last));
g_assert_cmpint (first, ==, HB_SET_VALUE_INVALID);
g_assert_cmpint (last, ==, HB_SET_VALUE_INVALID);
@ -505,10 +505,10 @@ test_set_empty (void)
{
hb_set_t *b = hb_set_get_empty ();
g_assert (hb_set_get_empty ());
g_assert (hb_set_get_empty () == b);
g_assert_true (hb_set_get_empty ());
g_assert_true (hb_set_get_empty () == b);
g_assert (!hb_set_allocation_successful (b));
g_assert_true (!hb_set_allocation_successful (b));
test_empty (b);
@ -516,13 +516,13 @@ test_set_empty (void)
test_empty (b);
g_assert (!hb_set_allocation_successful (b));
g_assert_true (!hb_set_allocation_successful (b));
hb_set_clear (b);
test_empty (b);
g_assert (!hb_set_allocation_successful (b));
g_assert_true (!hb_set_allocation_successful (b));
hb_set_destroy (b);
}
@ -565,10 +565,10 @@ test_set_delrange (void)
{
unsigned b = ranges[i].b;
unsigned e = ranges[i].e;
g_assert (hb_set_has (s, (b-2)&~1));
g_assert_true (hb_set_has (s, (b-2)&~1));
while (b <= e)
g_assert (!hb_set_has (s, b++));
g_assert (hb_set_has (s, (e+2)&~1));
g_assert_true (!hb_set_has (s, b++));
g_assert_true (hb_set_has (s, (e+2)&~1));
}
hb_set_destroy (s);
@ -586,29 +586,29 @@ test_set_inverted_basics (void)
hb_set_invert (s);
g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements);
g_assert (hb_set_has (s, 0));
g_assert (hb_set_has (s, 13));
g_assert (hb_set_has (s, max_set_elements - 1));
g_assert (!hb_set_is_empty (s));
g_assert_true (hb_set_has (s, 0));
g_assert_true (hb_set_has (s, 13));
g_assert_true (hb_set_has (s, max_set_elements - 1));
g_assert_true (!hb_set_is_empty (s));
g_assert_cmpint (hb_set_get_min (s), ==, 0);
g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 1);
hb_set_del (s, 13);
g_assert (!hb_set_has (s, 13));
g_assert_true (!hb_set_has (s, 13));
g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements - 1);
g_assert_cmpint (hb_set_get_min (s), ==, 0);
g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 1);
hb_set_add (s, 13);
g_assert (hb_set_has (s, 13));
g_assert_true (hb_set_has (s, 13));
g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements);
hb_set_del (s, 0);
hb_set_del (s, max_set_elements - 1);
g_assert (!hb_set_has (s, 0));
g_assert (hb_set_has (s, 13));
g_assert (!hb_set_has (s, max_set_elements - 1));
g_assert (!hb_set_is_empty (s));
g_assert_true (!hb_set_has (s, 0));
g_assert_true (hb_set_has (s, 13));
g_assert_true (!hb_set_has (s, max_set_elements - 1));
g_assert_true (!hb_set_is_empty (s));
g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements - 2);
g_assert_cmpint (hb_set_get_min (s), ==, 1);
g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 2);
@ -628,39 +628,39 @@ test_set_inverted_ranges (void)
hb_set_del_range (s, 41, 4000);
hb_set_add_range (s, 78, 601);
g_assert (hb_set_has (s, 40));
g_assert (!hb_set_has (s, 41));
g_assert (!hb_set_has (s, 64));
g_assert (!hb_set_has (s, 77));
g_assert (hb_set_has (s, 78));
g_assert (hb_set_has (s, 300));
g_assert (hb_set_has (s, 601));
g_assert (!hb_set_has (s, 602));
g_assert (!hb_set_has (s, 3000));
g_assert (!hb_set_has (s, 4000));
g_assert (hb_set_has (s, 4001));
g_assert_true (hb_set_has (s, 40));
g_assert_true (!hb_set_has (s, 41));
g_assert_true (!hb_set_has (s, 64));
g_assert_true (!hb_set_has (s, 77));
g_assert_true (hb_set_has (s, 78));
g_assert_true (hb_set_has (s, 300));
g_assert_true (hb_set_has (s, 601));
g_assert_true (!hb_set_has (s, 602));
g_assert_true (!hb_set_has (s, 3000));
g_assert_true (!hb_set_has (s, 4000));
g_assert_true (hb_set_has (s, 4001));
g_assert (!hb_set_is_empty (s));
g_assert_true (!hb_set_is_empty (s));
g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements - 3436);
g_assert_cmpint (hb_set_get_min (s), ==, 0);
g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 1);
hb_set_del_range (s, 0, 37);
g_assert (!hb_set_has (s, 0));
g_assert (!hb_set_has (s, 37));
g_assert (hb_set_has (s, 38));
g_assert (!hb_set_is_empty (s));
g_assert_true (!hb_set_has (s, 0));
g_assert_true (!hb_set_has (s, 37));
g_assert_true (hb_set_has (s, 38));
g_assert_true (!hb_set_is_empty (s));
g_assert_cmpint (hb_set_get_population (s), ==,
max_set_elements - 3436 - 38);
g_assert_cmpint (hb_set_get_min (s), ==, 38);
g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 1);
hb_set_del_range (s, max_set_elements - 13, max_set_elements - 1);
g_assert (!hb_set_has (s, max_set_elements - 1));
g_assert (!hb_set_has (s, max_set_elements - 13));
g_assert (hb_set_has (s, max_set_elements - 14));
g_assert_true (!hb_set_has (s, max_set_elements - 1));
g_assert_true (!hb_set_has (s, max_set_elements - 13));
g_assert_true (hb_set_has (s, max_set_elements - 14));
g_assert (!hb_set_is_empty (s));
g_assert_true (!hb_set_is_empty (s));
g_assert_cmpint (hb_set_get_population (s), ==,
max_set_elements - 3436 - 38 - 13);
g_assert_cmpint (hb_set_get_min (s), ==, 38);
@ -683,90 +683,90 @@ test_set_inverted_iteration_next (void)
hb_codepoint_t cp = HB_SET_VALUE_INVALID;
hb_codepoint_t start = 0;
hb_codepoint_t end = 0;
g_assert (hb_set_next (s, &cp));
g_assert_true (hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, 0);
g_assert (hb_set_next (s, &cp));
g_assert_true (hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, 1);
g_assert (hb_set_next_range (s, &start, &end));
g_assert_true (hb_set_next_range (s, &start, &end));
g_assert_cmpint (start, ==, 1);
g_assert_cmpint (end, ==, 40);
start = 40;
end = 40;
g_assert (hb_set_next_range (s, &start, &end));
g_assert_true (hb_set_next_range (s, &start, &end));
g_assert_cmpint (start, ==, 78);
g_assert_cmpint (end, ==, 601);
start = 40;
end = 57;
g_assert (hb_set_next_range (s, &start, &end));
g_assert_true (hb_set_next_range (s, &start, &end));
g_assert_cmpint (start, ==, 78);
g_assert_cmpint (end, ==, 601);
cp = 39;
g_assert (hb_set_next (s, &cp));
g_assert_true (hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, 40);
g_assert (hb_set_next (s, &cp));
g_assert_true (hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, 78);
cp = 56;
g_assert (hb_set_next (s, &cp));
g_assert_true (hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, 78);
cp = 78;
g_assert (hb_set_next (s, &cp));
g_assert_true (hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, 79);
cp = 601;
g_assert (hb_set_next (s, &cp));
g_assert_true (hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, 4001);
cp = HB_SET_VALUE_INVALID;
hb_set_del (s, 0);
g_assert (hb_set_next (s, &cp));
g_assert_true (hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, 1);
start = 0;
end = 0;
g_assert (hb_set_next_range (s, &start, &end));
g_assert_true (hb_set_next_range (s, &start, &end));
g_assert_cmpint (start, ==, 1);
g_assert_cmpint (end, ==, 40);
cp = max_set_elements - 1;
g_assert (!hb_set_next (s, &cp));
g_assert_true (!hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, HB_SET_VALUE_INVALID);
start = 4000;
end = 4000;
g_assert (hb_set_next_range (s, &start, &end));
g_assert_true (hb_set_next_range (s, &start, &end));
g_assert_cmpint (start, ==, 4001);
g_assert_cmpint (end, ==, max_set_elements - 1);
start = max_set_elements - 1;
end = max_set_elements - 1;
g_assert (!hb_set_next_range (s, &start, &end));
g_assert_true (!hb_set_next_range (s, &start, &end));
g_assert_cmpint (start, ==, HB_SET_VALUE_INVALID);
g_assert_cmpint (end, ==, HB_SET_VALUE_INVALID);
cp = max_set_elements - 3;
hb_set_del (s, max_set_elements - 1);
g_assert (hb_set_next (s, &cp));
g_assert_true (hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, max_set_elements - 2);
g_assert (!hb_set_next (s, &cp));
g_assert_true (!hb_set_next (s, &cp));
g_assert_cmpint (cp, ==, HB_SET_VALUE_INVALID);
start = max_set_elements - 2;
end = max_set_elements - 2;
g_assert (!hb_set_next_range (s, &start, &end));
g_assert_true (!hb_set_next_range (s, &start, &end));
g_assert_cmpint (start, ==, HB_SET_VALUE_INVALID);
g_assert_cmpint (end, ==, HB_SET_VALUE_INVALID);
start = max_set_elements - 3;
end = max_set_elements - 3;
g_assert (hb_set_next_range (s, &start, &end));
g_assert_true (hb_set_next_range (s, &start, &end));
g_assert_cmpint (start, ==, max_set_elements - 2);
g_assert_cmpint (end, ==, max_set_elements - 2);
@ -787,94 +787,94 @@ test_set_inverted_iteration_prev (void)
hb_codepoint_t cp = HB_SET_VALUE_INVALID;
hb_codepoint_t start = max_set_elements - 1;
hb_codepoint_t end = max_set_elements - 1;
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, max_set_elements - 1);
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, max_set_elements - 2);
g_assert (hb_set_previous_range (s, &start, &end));
g_assert_true (hb_set_previous_range (s, &start, &end));
g_assert_cmpint (start, ==, 4001);
g_assert_cmpint (end, ==, max_set_elements - 2);
start = 4001;
end = 4001;
g_assert (hb_set_previous_range (s, &start, &end));
g_assert_true (hb_set_previous_range (s, &start, &end));
g_assert_cmpint (start, ==, 78);
g_assert_cmpint (end, ==, 601);
start = 2500;
end = 3000;
g_assert (hb_set_previous_range (s, &start, &end));
g_assert_true (hb_set_previous_range (s, &start, &end));
g_assert_cmpint (start, ==, 78);
g_assert_cmpint (end, ==, 601);
cp = 4002;
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, 4001);
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, 601);
cp = 3500;
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, 601);
cp = 601;
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, 600);
cp = 78;
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, 40);
cp = HB_SET_VALUE_INVALID;
hb_set_del (s, max_set_elements - 1);
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, max_set_elements - 2);
start = max_set_elements - 1;
end = max_set_elements - 1;
g_assert (hb_set_previous_range (s, &start, &end));
g_assert_true (hb_set_previous_range (s, &start, &end));
g_assert_cmpint (start, ==, 4001);
g_assert_cmpint (end, ==, max_set_elements - 2);
cp = 0;
g_assert (!hb_set_previous (s, &cp));
g_assert_true (!hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, HB_SET_VALUE_INVALID);
cp = 40;
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, 39);
start = 40;
end = 40;
g_assert (hb_set_previous_range (s, &start, &end));
g_assert_true (hb_set_previous_range (s, &start, &end));
g_assert_cmpint (start, ==, 0);
g_assert_cmpint (end, ==, 39);
start = 0;
end = 0;
g_assert (!hb_set_previous_range (s, &start, &end));
g_assert_true (!hb_set_previous_range (s, &start, &end));
g_assert_cmpint (start, ==, HB_SET_VALUE_INVALID);
g_assert_cmpint (end, ==, HB_SET_VALUE_INVALID);
cp = 2;
hb_set_del (s, 0);
g_assert (hb_set_previous (s, &cp));
g_assert_true (hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, 1);
g_assert (!hb_set_previous (s, &cp));
g_assert_true (!hb_set_previous (s, &cp));
g_assert_cmpint (cp, ==, HB_SET_VALUE_INVALID);
start = 1;
end = 1;
g_assert (!hb_set_previous_range (s, &start, &end));
g_assert_true (!hb_set_previous_range (s, &start, &end));
g_assert_cmpint (start, ==, HB_SET_VALUE_INVALID);
g_assert_cmpint (end, ==, HB_SET_VALUE_INVALID);
start = 2;
end = 2;
g_assert (hb_set_previous_range (s, &start, &end));
g_assert_true (hb_set_previous_range (s, &start, &end));
g_assert_cmpint (start, ==, 1);
g_assert_cmpint (end, ==, 1);
@ -890,50 +890,50 @@ test_set_inverted_equality (void)
hb_set_invert (a);
hb_set_invert (b);
g_assert (hb_set_is_equal (a, b));
g_assert (hb_set_is_equal (b, a));
g_assert_true (hb_set_is_equal (a, b));
g_assert_true (hb_set_is_equal (b, a));
hb_set_add (a, 10);
g_assert (hb_set_is_equal (a, b));
g_assert (hb_set_is_equal (b, a));
g_assert_true (hb_set_is_equal (a, b));
g_assert_true (hb_set_is_equal (b, a));
hb_set_del (a, 42);
g_assert (!hb_set_is_equal (a, b));
g_assert (!hb_set_is_equal (b, a));
g_assert_true (!hb_set_is_equal (a, b));
g_assert_true (!hb_set_is_equal (b, a));
hb_set_del (b, 42);
g_assert (hb_set_is_equal (a, b));
g_assert (hb_set_is_equal (b, a));
g_assert_true (hb_set_is_equal (a, b));
g_assert_true (hb_set_is_equal (b, a));
hb_set_del_range (a, 43, 50);
hb_set_del_range (a, 51, 76);
hb_set_del_range (b, 43, 76);
g_assert (hb_set_is_equal (a, b));
g_assert (hb_set_is_equal (b, a));
g_assert_true (hb_set_is_equal (a, b));
g_assert_true (hb_set_is_equal (b, a));
hb_set_del (a, 0);
g_assert (!hb_set_is_equal (a, b));
g_assert (!hb_set_is_equal (b, a));
g_assert_true (!hb_set_is_equal (a, b));
g_assert_true (!hb_set_is_equal (b, a));
hb_set_del (b, 0);
g_assert (hb_set_is_equal (a, b));
g_assert (hb_set_is_equal (b, a));
g_assert_true (hb_set_is_equal (a, b));
g_assert_true (hb_set_is_equal (b, a));
hb_set_del (a, max_set_elements - 1);
g_assert (!hb_set_is_equal (a, b));
g_assert (!hb_set_is_equal (b, a));
g_assert_true (!hb_set_is_equal (a, b));
g_assert_true (!hb_set_is_equal (b, a));
hb_set_del (b, max_set_elements - 1);
g_assert (hb_set_is_equal (a, b));
g_assert (hb_set_is_equal (b, a));
g_assert_true (hb_set_is_equal (a, b));
g_assert_true (hb_set_is_equal (b, a));
hb_set_invert (a);
g_assert (!hb_set_is_equal (a, b));
g_assert (!hb_set_is_equal (b, a));
g_assert_true (!hb_set_is_equal (a, b));
g_assert_true (!hb_set_is_equal (b, a));
hb_set_invert (b);
g_assert (hb_set_is_equal (a, b));
g_assert (hb_set_is_equal (b, a));
g_assert_true (hb_set_is_equal (a, b));
g_assert_true (hb_set_is_equal (b, a));
hb_set_destroy (a);
hb_set_destroy (b);
@ -1065,7 +1065,7 @@ test_set_inverted_operations (void)
}
}
g_assert (all_succeeded);
g_assert_true (all_succeeded);
}
static void
@ -1075,13 +1075,13 @@ test_hb_set_add_sorted_array (void)
hb_codepoint_t array[7] = {1, 2, 3, 1000, 2000, 2001, 2002};
hb_set_add_sorted_array (set, array, 7);
g_assert_cmpint (hb_set_get_population (set), ==, 7);
g_assert (hb_set_has (set, 1));
g_assert (hb_set_has (set, 2));
g_assert (hb_set_has (set, 3));
g_assert (hb_set_has (set, 1000));
g_assert (hb_set_has (set, 2000));
g_assert (hb_set_has (set, 2001));
g_assert (hb_set_has (set, 2002));
g_assert_true (hb_set_has (set, 1));
g_assert_true (hb_set_has (set, 2));
g_assert_true (hb_set_has (set, 3));
g_assert_true (hb_set_has (set, 1000));
g_assert_true (hb_set_has (set, 2000));
g_assert_true (hb_set_has (set, 2001));
g_assert_true (hb_set_has (set, 2002));
hb_set_destroy (set);
}
@ -1093,7 +1093,7 @@ test_set_next_many (void)
hb_set_add (set, i);
for (unsigned i=6000; i<6100; i++)
hb_set_add (set, i);
g_assert (hb_set_get_population (set) == 700);
g_assert_true (hb_set_get_population (set) == 700);
hb_codepoint_t array[700];
unsigned int n = hb_set_next_many (set, HB_SET_VALUE_INVALID, array, 700);
@ -1102,7 +1102,7 @@ test_set_next_many (void)
for (unsigned i=0; i<600; i++)
g_assert_cmpint (array[i], ==, i);
for (unsigned i=0; i<100; i++)
g_assert (array[600 + i] == 6000u + i);
g_assert_true (array[600 + i] == 6000u + i);
// Try skipping initial values.
for (unsigned i = 0; i < 700; i++)
@ -1125,7 +1125,7 @@ test_set_next_many_restricted (void)
hb_set_add (set, i);
for (int i=6000; i<6100; i++)
hb_set_add (set, i);
g_assert (hb_set_get_population (set) == 700);
g_assert_true (hb_set_get_population (set) == 700);
hb_codepoint_t array[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
hb_set_next_many (set, HB_SET_VALUE_INVALID, array, 9);

2
test/api/test-shape.c
View file

@ -190,7 +190,7 @@ test_shape_list (void)
;
g_assert_cmpint (i, >, 1);
g_assert (!strcmp (shapers[i - 1], "fallback"));
g_assert_true (!strcmp (shapers[i - 1], "fallback"));
}
int

8
test/api/test-subset-drop-tables.c
View file

@ -43,14 +43,14 @@ test_subset_drop_tables (void)
hb_set_destroy (codepoints);
hb_face_t* subset = hb_subset_or_fail (face, input);
g_assert (subset);
g_assert_true (subset);
hb_blob_t *hdmx = hb_face_reference_table (subset, HB_TAG ('h', 'd', 'm', 'x'));
hb_blob_t *hmtx = hb_face_reference_table (subset, HB_TAG ('h', 'm', 't', 'x'));
hb_blob_t *cmap = hb_face_reference_table (subset, HB_TAG ('c', 'm', 'a', 'p'));
g_assert (!hb_blob_get_length (hdmx));
g_assert (!hb_blob_get_length (hmtx));
g_assert ( hb_blob_get_length (cmap));
g_assert_true (!hb_blob_get_length (hdmx));
g_assert_true (!hb_blob_get_length (hmtx));
g_assert_true ( hb_blob_get_length (cmap));
hb_blob_destroy (hdmx);
hb_blob_destroy (hmtx);
hb_blob_destroy (cmap);

2
test/api/test-subset-glyf.c
View file

@ -302,7 +302,7 @@ test_subset_glyf_strip_hints_invalid (void)
hb_set_destroy (codepoints);
face_subset = hb_subset_or_fail (face, input);
g_assert (!face_subset);
g_assert_true (!face_subset);
hb_subset_input_destroy (input);
hb_face_destroy (face);

2
test/api/test-subset-hdmx.c
View file

@ -83,7 +83,7 @@ test_subset_hdmx_invalid (void)
hb_set_add (codepoints, 'c');
subset = hb_subset_or_fail (face, input);
g_assert (!subset);
g_assert_true (!subset);
hb_subset_input_destroy (input);
hb_face_destroy (subset);

2
test/api/test-subset-hmtx.c
View file

@ -163,7 +163,7 @@ test_subset_invalid_hmtx (void)
hb_set_add (codepoints, 'c');
subset = hb_subset_or_fail (face, input);
g_assert (!subset);
g_assert_true (!subset);
hb_subset_input_destroy (input);
hb_face_destroy (subset);

54
test/api/test-subset.c
View file

@ -43,7 +43,7 @@ test_subset_32_tables (void)
hb_set_add (codepoints, 'c');
subset = hb_subset_or_fail (face, input);
g_assert (!subset);
g_assert_true (!subset);
hb_subset_input_destroy (input);
hb_face_destroy (subset);
@ -64,7 +64,7 @@ test_subset_no_inf_loop (void)
hb_set_add (codepoints, 'c');
subset = hb_subset_or_fail (face, input);
g_assert (!subset);
g_assert_true (!subset);
hb_subset_input_destroy (input);
hb_face_destroy (subset);
@ -85,7 +85,7 @@ test_subset_crash (void)
hb_set_add (codepoints, 'c');
subset = hb_subset_or_fail (face, input);
g_assert (!subset);
g_assert_true (!subset);
hb_subset_input_destroy (input);
hb_face_destroy (subset);
@ -97,14 +97,14 @@ test_subset_set_flags (void)
{
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
g_assert (hb_subset_input_get_flags (input) == HB_SUBSET_FLAGS_DEFAULT);
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 (hb_subset_input_get_flags (input) ==
g_assert_true (hb_subset_input_get_flags (input) ==
(hb_subset_flags_t) (
HB_SUBSET_FLAGS_NAME_LEGACY |
HB_SUBSET_FLAGS_NOTDEF_OUTLINE |
@ -115,7 +115,7 @@ test_subset_set_flags (void)
HB_SUBSET_FLAGS_NOTDEF_OUTLINE |
HB_SUBSET_FLAGS_NO_PRUNE_UNICODE_RANGES);
g_assert (hb_subset_input_get_flags (input) ==
g_assert_true (hb_subset_input_get_flags (input) ==
(hb_subset_flags_t) (
HB_SUBSET_FLAGS_NAME_LEGACY |
HB_SUBSET_FLAGS_NOTDEF_OUTLINE |
@ -139,15 +139,15 @@ test_subset_sets (void)
hb_set_add (hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG), 87);
hb_set_add (set, 83);
g_assert (hb_set_is_equal (hb_subset_input_glyph_set (input), set));
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 (hb_set_is_equal (hb_subset_input_unicode_set (input), set));
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 (hb_set_is_equal (hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG), set));
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);
@ -167,18 +167,18 @@ test_subset_plan (void)
hb_set_destroy (codepoints);
hb_subset_plan_t* plan = hb_subset_plan_create_or_fail (face_abc, input);
g_assert (plan);
g_assert_true (plan);
const hb_map_t* mapping = hb_subset_plan_old_to_new_glyph_mapping (plan);
g_assert (hb_map_get (mapping, 1) == 1);
g_assert (hb_map_get (mapping, 3) == 2);
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 (hb_map_get (mapping, 1) == 1);
g_assert (hb_map_get (mapping, 2) == 3);
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 (hb_map_get (mapping, 0x63) == 3);
g_assert_true (hb_map_get (mapping, 0x63) == 3);
hb_face_t* face_abc_subset = hb_subset_plan_execute_or_fail (plan);
@ -272,19 +272,19 @@ test_subset_cff2_get_charstring_data (void)
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 (length == 2);
g_assert (data[0] == 0x20);
g_assert (data[1] == 0x0A);
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 (length == 2);
g_assert (data[0] == 0x20);
g_assert (data[1] == 0x0A);
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 (length == 0);
g_assert_true (length == 0);
hb_blob_destroy (cff2);
hb_blob_destroy (maxp);
@ -337,7 +337,7 @@ test_subset_cff2_get_charstring_data_no_cff (void)
hb_face_t* face = hb_face_create (face_blob, 0);
hb_blob_t* cs0 = hb_subset_cff2_get_charstring_data (face, 0);
g_assert (hb_blob_get_length (cs0) == 0);
g_assert_true (hb_blob_get_length (cs0) == 0);
hb_face_destroy (builder);
hb_blob_destroy (face_blob);
@ -357,7 +357,7 @@ test_subset_cff2_get_charstring_data_invalid_cff2 (void)
hb_face_t* face = hb_face_create (face_blob, 0);
hb_blob_t* cs0 = hb_subset_cff2_get_charstring_data (face, 0);
g_assert (hb_blob_get_length (cs0) == 0);
g_assert_true (hb_blob_get_length (cs0) == 0);
hb_blob_destroy (cff2);
hb_face_destroy (builder);
@ -394,9 +394,9 @@ test_subset_cff2_get_charstring_data_lifetime (void)
unsigned int length;
const uint8_t* data = (const uint8_t*) hb_blob_get_data (cs0, &length);
g_assert (length == 2);
g_assert (data[0] == 0x20);
g_assert (data[1] == 0x0A);
g_assert_true (length == 2);
g_assert_true (data[0] == 0x20);
g_assert_true (data[1] == 0x0A);
hb_blob_destroy (cs0);
}

138
test/api/test-unicode.c
View file

@ -55,8 +55,8 @@ static void free_up (void *p)
{
data_t *data = (data_t *) p;
g_assert (data->value == MAGIC0 || data->value == MAGIC1);
g_assert (!data->freed);
g_assert_true (data->value == MAGIC0 || data->value == MAGIC1);
g_assert_true (!data->freed);
data->freed = TRUE;
}
@ -67,9 +67,9 @@ simple_get_script (hb_unicode_funcs_t *ufuncs,
{
data_t *data = (data_t *) user_data;
g_assert (hb_unicode_funcs_get_parent (ufuncs) != NULL);
g_assert_true (hb_unicode_funcs_get_parent (ufuncs) != NULL);
g_assert_cmphex (data->value, ==, MAGIC0);
g_assert (!data->freed);
g_assert_true (!data->freed);
if ('a' <= codepoint && codepoint <= 'z')
return HB_SCRIPT_LATIN;
@ -84,9 +84,9 @@ a_is_for_arabic_get_script (hb_unicode_funcs_t *ufuncs,
{
data_t *data = (data_t *) user_data;
g_assert (hb_unicode_funcs_get_parent (ufuncs) != NULL);
g_assert_true (hb_unicode_funcs_get_parent (ufuncs) != NULL);
g_assert_cmphex (data->value, ==, MAGIC1);
g_assert (!data->freed);
g_assert_true (!data->freed);
if (codepoint == 'a') {
return HB_SCRIPT_ARABIC;
@ -609,8 +609,8 @@ test_unicode_properties (gconstpointer user_data, hb_bool_t lenient)
unsigned int i, j;
gboolean failed = TRUE;
g_assert (hb_unicode_funcs_is_immutable (uf));
g_assert (hb_unicode_funcs_get_parent (uf));
g_assert_true (hb_unicode_funcs_is_immutable (uf));
g_assert_true (hb_unicode_funcs_get_parent (uf));
for (i = 0; i < G_N_ELEMENTS (properties); i++) {
const property_t *p = &properties[i];
@ -686,7 +686,7 @@ test_unicode_properties_nil (void)
{
hb_unicode_funcs_t *uf = hb_unicode_funcs_create (NULL);
g_assert (!hb_unicode_funcs_is_immutable (uf));
g_assert_true (!hb_unicode_funcs_is_immutable (uf));
_test_unicode_properties_nil (uf);
hb_unicode_funcs_destroy (uf);
@ -697,8 +697,8 @@ test_unicode_properties_empty (void)
{
hb_unicode_funcs_t *uf = hb_unicode_funcs_get_empty ();
g_assert (uf);
g_assert (hb_unicode_funcs_is_immutable (uf));
g_assert_true (uf);
g_assert_true (hb_unicode_funcs_is_immutable (uf));
_test_unicode_properties_nil (uf);
}
@ -711,13 +711,13 @@ test_unicode_chainup (void)
/* Chain-up to nil */
uf = hb_unicode_funcs_create (NULL);
g_assert (!hb_unicode_funcs_is_immutable (uf));
g_assert_true (!hb_unicode_funcs_is_immutable (uf));
uf2 = hb_unicode_funcs_create (uf);
g_assert (hb_unicode_funcs_is_immutable (uf));
g_assert_true (hb_unicode_funcs_is_immutable (uf));
hb_unicode_funcs_destroy (uf);
g_assert (!hb_unicode_funcs_is_immutable (uf2));
g_assert_true (!hb_unicode_funcs_is_immutable (uf2));
_test_unicode_properties_nil (uf2);
hb_unicode_funcs_destroy (uf2);
@ -725,13 +725,13 @@ test_unicode_chainup (void)
/* Chain-up to default */
uf = hb_unicode_funcs_create (hb_unicode_funcs_get_default ());
g_assert (!hb_unicode_funcs_is_immutable (uf));
g_assert_true (!hb_unicode_funcs_is_immutable (uf));
uf2 = hb_unicode_funcs_create (uf);
g_assert (hb_unicode_funcs_is_immutable (uf));
g_assert_true (hb_unicode_funcs_is_immutable (uf));
hb_unicode_funcs_destroy (uf);
g_assert (!hb_unicode_funcs_is_immutable (uf2));
g_assert_true (!hb_unicode_funcs_is_immutable (uf2));
hb_unicode_funcs_make_immutable (uf2);
test_unicode_properties_strict (uf2);
@ -755,7 +755,7 @@ test_unicode_setters (void)
g_test_message ("Testing property %s", p->name);
uf = hb_unicode_funcs_create (NULL);
g_assert (!hb_unicode_funcs_is_immutable (uf));
g_assert_true (!hb_unicode_funcs_is_immutable (uf));
p->func_setter (uf, (get_func_t) simple_get_script, &data[0], free_up);
@ -763,18 +763,18 @@ test_unicode_setters (void)
g_assert_cmphex (p->getter (uf, '0'), ==, HB_SCRIPT_UNKNOWN);
p->func_setter (uf, (get_func_t) NULL, NULL, NULL);
g_assert (data[0].freed && !data[1].freed);
g_assert_true (data[0].freed && !data[1].freed);
g_assert (!hb_unicode_funcs_is_immutable (uf));
g_assert_true (!hb_unicode_funcs_is_immutable (uf));
hb_unicode_funcs_make_immutable (uf);
g_assert (hb_unicode_funcs_is_immutable (uf));
g_assert_true (hb_unicode_funcs_is_immutable (uf));
/* Since uf is immutable now, the following setter should do nothing. */
p->func_setter (uf, (get_func_t) a_is_for_arabic_get_script, &data[1], free_up);
g_assert (data[0].freed && data[1].freed);
g_assert_true (data[0].freed && data[1].freed);
hb_unicode_funcs_destroy (uf);
g_assert (data[0].freed && data[1].freed);
g_assert_true (data[0].freed && data[1].freed);
}
}
@ -812,9 +812,9 @@ test_unicode_subclassing_nil (data_fixture_t *f, gconstpointer user_data HB_UNUS
g_assert_cmphex (hb_unicode_script (aa, 'a'), ==, HB_SCRIPT_ARABIC);
g_assert_cmphex (hb_unicode_script (aa, 'b'), ==, HB_SCRIPT_UNKNOWN);
g_assert (!f->data[0].freed && !f->data[1].freed);
g_assert_true (!f->data[0].freed && !f->data[1].freed);
hb_unicode_funcs_destroy (aa);
g_assert (!f->data[0].freed && f->data[1].freed);
g_assert_true (!f->data[0].freed && f->data[1].freed);
}
static void
@ -831,9 +831,9 @@ test_unicode_subclassing_default (data_fixture_t *f, gconstpointer user_data HB_
g_assert_cmphex (hb_unicode_script (aa, 'a'), ==, HB_SCRIPT_ARABIC);
g_assert_cmphex (hb_unicode_script (aa, 'b'), ==, HB_SCRIPT_LATIN);
g_assert (!f->data[0].freed && !f->data[1].freed);
g_assert_true (!f->data[0].freed && !f->data[1].freed);
hb_unicode_funcs_destroy (aa);
g_assert (!f->data[0].freed && f->data[1].freed);
g_assert_true (!f->data[0].freed && f->data[1].freed);
}
static void
@ -851,7 +851,7 @@ test_unicode_subclassing_deep (data_fixture_t *f, gconstpointer user_data HB_UNU
hb_unicode_funcs_destroy (uf);
/* make sure the 'uf' didn't get freed, since 'aa' holds a ref */
g_assert (!f->data[0].freed);
g_assert_true (!f->data[0].freed);
hb_unicode_funcs_set_script_func (aa, a_is_for_arabic_get_script,
&f->data[1], free_up);
@ -860,9 +860,9 @@ test_unicode_subclassing_deep (data_fixture_t *f, gconstpointer user_data HB_UNU
g_assert_cmphex (hb_unicode_script (aa, 'b'), ==, HB_SCRIPT_LATIN);
g_assert_cmphex (hb_unicode_script (aa, '0'), ==, HB_SCRIPT_UNKNOWN);
g_assert (!f->data[0].freed && !f->data[1].freed);
g_assert_true (!f->data[0].freed && !f->data[1].freed);
hb_unicode_funcs_destroy (aa);
g_assert (f->data[0].freed && f->data[1].freed);
g_assert_true (f->data[0].freed && f->data[1].freed);
}
@ -931,67 +931,67 @@ test_unicode_normalization (gconstpointer user_data)
/* Test compose() */
/* Not composable */
g_assert (!hb_unicode_compose (uf, 0x0041, 0x0042, &ab) && ab == 0);
g_assert (!hb_unicode_compose (uf, 0x0041, 0, &ab) && ab == 0);
g_assert (!hb_unicode_compose (uf, 0x0066, 0x0069, &ab) && ab == 0);
g_assert_true (!hb_unicode_compose (uf, 0x0041, 0x0042, &ab) && ab == 0);
g_assert_true (!hb_unicode_compose (uf, 0x0041, 0, &ab) && ab == 0);
g_assert_true (!hb_unicode_compose (uf, 0x0066, 0x0069, &ab) && ab == 0);
/* Singletons should not compose */
g_assert (!hb_unicode_compose (uf, 0x212B, 0, &ab) && ab == 0);
g_assert (!hb_unicode_compose (uf, 0x00C5, 0, &ab) && ab == 0);
g_assert (!hb_unicode_compose (uf, 0x2126, 0, &ab) && ab == 0);
g_assert (!hb_unicode_compose (uf, 0x03A9, 0, &ab) && ab == 0);
g_assert_true (!hb_unicode_compose (uf, 0x212B, 0, &ab) && ab == 0);
g_assert_true (!hb_unicode_compose (uf, 0x00C5, 0, &ab) && ab == 0);
g_assert_true (!hb_unicode_compose (uf, 0x2126, 0, &ab) && ab == 0);
g_assert_true (!hb_unicode_compose (uf, 0x03A9, 0, &ab) && ab == 0);
/* Non-starter pairs should not compose */
g_assert (!hb_unicode_compose (uf, 0x0308, 0x0301, &ab) && ab == 0); /* !0x0344 */
g_assert (!hb_unicode_compose (uf, 0x0F71, 0x0F72, &ab) && ab == 0); /* !0x0F73 */
g_assert_true (!hb_unicode_compose (uf, 0x0308, 0x0301, &ab) && ab == 0); /* !0x0344 */
g_assert_true (!hb_unicode_compose (uf, 0x0F71, 0x0F72, &ab) && ab == 0); /* !0x0F73 */
/* Pairs */
g_assert (hb_unicode_compose (uf, 0x0041, 0x030A, &ab) && ab == 0x00C5);
g_assert (hb_unicode_compose (uf, 0x006F, 0x0302, &ab) && ab == 0x00F4);
g_assert (hb_unicode_compose (uf, 0x1E63, 0x0307, &ab) && ab == 0x1E69);
g_assert (hb_unicode_compose (uf, 0x0073, 0x0323, &ab) && ab == 0x1E63);
g_assert (hb_unicode_compose (uf, 0x0064, 0x0307, &ab) && ab == 0x1E0B);
g_assert (hb_unicode_compose (uf, 0x0064, 0x0323, &ab) && ab == 0x1E0D);
g_assert_true (hb_unicode_compose (uf, 0x0041, 0x030A, &ab) && ab == 0x00C5);
g_assert_true (hb_unicode_compose (uf, 0x006F, 0x0302, &ab) && ab == 0x00F4);
g_assert_true (hb_unicode_compose (uf, 0x1E63, 0x0307, &ab) && ab == 0x1E69);
g_assert_true (hb_unicode_compose (uf, 0x0073, 0x0323, &ab) && ab == 0x1E63);
g_assert_true (hb_unicode_compose (uf, 0x0064, 0x0307, &ab) && ab == 0x1E0B);
g_assert_true (hb_unicode_compose (uf, 0x0064, 0x0323, &ab) && ab == 0x1E0D);
/* Hangul */
g_assert (hb_unicode_compose (uf, 0xD4CC, 0x11B6, &ab) && ab == 0xD4DB);
g_assert (hb_unicode_compose (uf, 0x1111, 0x1171, &ab) && ab == 0xD4CC);
g_assert (hb_unicode_compose (uf, 0xCE20, 0x11B8, &ab) && ab == 0xCE31);
g_assert (hb_unicode_compose (uf, 0x110E, 0x1173, &ab) && ab == 0xCE20);
g_assert_true (hb_unicode_compose (uf, 0xD4CC, 0x11B6, &ab) && ab == 0xD4DB);
g_assert_true (hb_unicode_compose (uf, 0x1111, 0x1171, &ab) && ab == 0xD4CC);
g_assert_true (hb_unicode_compose (uf, 0xCE20, 0x11B8, &ab) && ab == 0xCE31);
g_assert_true (hb_unicode_compose (uf, 0x110E, 0x1173, &ab) && ab == 0xCE20);
g_assert (!hb_unicode_compose (uf, 0xAC00, 0x11A7, &ab));
g_assert (hb_unicode_compose (uf, 0xAC00, 0x11A8, &ab) && ab == 0xAC01);
g_assert (!hb_unicode_compose (uf, 0xAC01, 0x11A8, &ab));
g_assert_true (!hb_unicode_compose (uf, 0xAC00, 0x11A7, &ab));
g_assert_true (hb_unicode_compose (uf, 0xAC00, 0x11A8, &ab) && ab == 0xAC01);
g_assert_true (!hb_unicode_compose (uf, 0xAC01, 0x11A8, &ab));
/* Test decompose() */
/* Not decomposable */
g_assert (!hb_unicode_decompose (uf, 0x0041, &a, &b) && a == 0x0041 && b == 0);
g_assert (!hb_unicode_decompose (uf, 0xFB01, &a, &b) && a == 0xFB01 && b == 0);
g_assert (!hb_unicode_decompose (uf, 0x1F1EF, &a, &b) && a == 0x1F1EF && b == 0);
g_assert_true (!hb_unicode_decompose (uf, 0x0041, &a, &b) && a == 0x0041 && b == 0);
g_assert_true (!hb_unicode_decompose (uf, 0xFB01, &a, &b) && a == 0xFB01 && b == 0);
g_assert_true (!hb_unicode_decompose (uf, 0x1F1EF, &a, &b) && a == 0x1F1EF && b == 0);
/* Singletons */
g_assert (hb_unicode_decompose (uf, 0x212B, &a, &b) && a == 0x00C5 && b == 0);
g_assert (hb_unicode_decompose (uf, 0x2126, &a, &b) && a == 0x03A9 && b == 0);
g_assert_true (hb_unicode_decompose (uf, 0x212B, &a, &b) && a == 0x00C5 && b == 0);
g_assert_true (hb_unicode_decompose (uf, 0x2126, &a, &b) && a == 0x03A9 && b == 0);
/* Non-starter pairs decompose, but not compose */
g_assert (hb_unicode_decompose (uf, 0x0344, &a, &b) && a == 0x0308 && b == 0x0301);
g_assert (hb_unicode_decompose (uf, 0x0F73, &a, &b) && a == 0x0F71 && b == 0x0F72);
g_assert_true (hb_unicode_decompose (uf, 0x0344, &a, &b) && a == 0x0308 && b == 0x0301);
g_assert_true (hb_unicode_decompose (uf, 0x0F73, &a, &b) && a == 0x0F71 && b == 0x0F72);
/* Pairs */
g_assert (hb_unicode_decompose (uf, 0x00C5, &a, &b) && a == 0x0041 && b == 0x030A);
g_assert (hb_unicode_decompose (uf, 0x00F4, &a, &b) && a == 0x006F && b == 0x0302);
g_assert (hb_unicode_decompose (uf, 0x1E69, &a, &b) && a == 0x1E63 && b == 0x0307);
g_assert (hb_unicode_decompose (uf, 0x1E63, &a, &b) && a == 0x0073 && b == 0x0323);
g_assert (hb_unicode_decompose (uf, 0x1E0B, &a, &b) && a == 0x0064 && b == 0x0307);
g_assert (hb_unicode_decompose (uf, 0x1E0D, &a, &b) && a == 0x0064 && b == 0x0323);
g_assert_true (hb_unicode_decompose (uf, 0x00C5, &a, &b) && a == 0x0041 && b == 0x030A);
g_assert_true (hb_unicode_decompose (uf, 0x00F4, &a, &b) && a == 0x006F && b == 0x0302);
g_assert_true (hb_unicode_decompose (uf, 0x1E69, &a, &b) && a == 0x1E63 && b == 0x0307);
g_assert_true (hb_unicode_decompose (uf, 0x1E63, &a, &b) && a == 0x0073 && b == 0x0323);
g_assert_true (hb_unicode_decompose (uf, 0x1E0B, &a, &b) && a == 0x0064 && b == 0x0307);
g_assert_true (hb_unicode_decompose (uf, 0x1E0D, &a, &b) && a == 0x0064 && b == 0x0323);
/* Hangul */
g_assert (hb_unicode_decompose (uf, 0xD4DB, &a, &b) && a == 0xD4CC && b == 0x11B6);
g_assert (hb_unicode_decompose (uf, 0xD4CC, &a, &b) && a == 0x1111 && b == 0x1171);
g_assert (hb_unicode_decompose (uf, 0xCE31, &a, &b) && a == 0xCE20 && b == 0x11B8);
g_assert (hb_unicode_decompose (uf, 0xCE20, &a, &b) && a == 0x110E && b == 0x1173);
g_assert_true (hb_unicode_decompose (uf, 0xD4DB, &a, &b) && a == 0xD4CC && b == 0x11B6);
g_assert_true (hb_unicode_decompose (uf, 0xD4CC, &a, &b) && a == 0x1111 && b == 0x1171);
g_assert_true (hb_unicode_decompose (uf, 0xCE31, &a, &b) && a == 0xCE20 && b == 0x11B8);
g_assert_true (hb_unicode_decompose (uf, 0xCE20, &a, &b) && a == 0x110E && b == 0x1173);
}

4
test/api/test-var-coords.c
View file

@ -78,11 +78,11 @@ test_get_var_get_axis_infos (void)
unsigned c = 1;
g_assert_cmpint (hb_ot_var_get_axis_infos (face, 0, &c, &info), ==, 2);
g_assert (info.tag == HB_TAG ('w','g','h','t'));
g_assert_true (info.tag == HB_TAG ('w','g','h','t'));
g_assert_cmpint (c, ==, 1);
hb_ot_var_get_axis_infos (face, 1, &c, &info);
g_assert (info.tag == HB_TAG ('w','d','t','h'));
g_assert_true (info.tag == HB_TAG ('w','d','t','h'));
g_assert_cmpint (c, ==, 1);
hb_ot_var_get_axis_infos (face, 2, &c, &info);

34
test/api/test-version.c
View file

@ -42,32 +42,32 @@ test_version (void)
g_assert_cmpint (micro, ==, HB_VERSION_MICRO);
s = g_strdup_printf ("%u.%u.%u", major, minor, micro);
g_assert (0 == strcmp (HB_VERSION_STRING, s));
g_assert_true (0 == strcmp (HB_VERSION_STRING, s));
g_free (s);
g_assert (0 == strcmp (HB_VERSION_STRING, hb_version_string ()));
g_assert_true (0 == strcmp (HB_VERSION_STRING, hb_version_string ()));
g_assert (HB_VERSION_ATLEAST (major, minor, micro));
g_assert_true (HB_VERSION_ATLEAST (major, minor, micro));
if (major)
g_assert (HB_VERSION_ATLEAST (major-1, minor, micro));
g_assert_true (HB_VERSION_ATLEAST (major-1, minor, micro));
if (minor)
g_assert (HB_VERSION_ATLEAST (major, minor-1, micro));
g_assert_true (HB_VERSION_ATLEAST (major, minor-1, micro));
if (micro)
g_assert (HB_VERSION_ATLEAST (major, minor, micro-1));
g_assert (!HB_VERSION_ATLEAST (major+1, minor, micro));
g_assert (!HB_VERSION_ATLEAST (major, minor+1, micro));
g_assert (!HB_VERSION_ATLEAST (major, minor, micro+1));
g_assert (!HB_VERSION_ATLEAST (major, minor, micro+1));
g_assert_true (HB_VERSION_ATLEAST (major, minor, micro-1));
g_assert_true (!HB_VERSION_ATLEAST (major+1, minor, micro));
g_assert_true (!HB_VERSION_ATLEAST (major, minor+1, micro));
g_assert_true (!HB_VERSION_ATLEAST (major, minor, micro+1));
g_assert_true (!HB_VERSION_ATLEAST (major, minor, micro+1));
g_assert (hb_version_atleast (major, minor, micro));
g_assert_true (hb_version_atleast (major, minor, micro));
if (major)
g_assert (hb_version_atleast (major-1, minor, micro));
g_assert_true (hb_version_atleast (major-1, minor, micro));
if (minor)
g_assert (hb_version_atleast (major, minor-1, micro));
g_assert_true (hb_version_atleast (major, minor-1, micro));
if (micro)
g_assert (hb_version_atleast (major, minor, micro-1));
g_assert (!hb_version_atleast (major+1, minor, micro));
g_assert (!hb_version_atleast (major, minor+1, micro));
g_assert (!hb_version_atleast (major, minor, micro+1));
g_assert_true (hb_version_atleast (major, minor, micro-1));
g_assert_true (!hb_version_atleast (major+1, minor, micro));
g_assert_true (!hb_version_atleast (major, minor+1, micro));
g_assert_true (!hb_version_atleast (major, minor, micro+1));
}
int