walkero/harfbuzz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
harfbuzz/test/api/test-object.c
Behdad Esfahbod eb0bf3ae66 Relax inert checks 
Previously, when creating an object from inert inputs (eg:
"hb_font_create(hb_face_get_empty())") we returned the inert
empty object.  This is not helpful as there are legitimate
usecases to do that.

We now never return the inert object unless allocation failed.

Tests are revised to reflect.
2015-04-09 19:16:57 -07:00

380 lines
10 KiB
C
Raw Blame History

/*
* Copyright © 2011 Google, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Google Author(s): Behdad Esfahbod
*/
#include "hb-test.h"
/* Unit tests for hb-object-private.h */
static void *
create_blob (void)
{
static char data[] = "test data";
return hb_blob_create (data, sizeof (data), HB_MEMORY_MODE_READONLY, NULL, NULL);
}
static void *
create_blob_from_inert (void)
{
return hb_blob_create (NULL, 0, HB_MEMORY_MODE_DUPLICATE, NULL, NULL);
}
static void *
create_buffer (void)
{
return hb_buffer_create ();
}
static void *
create_buffer_from_inert (void)
{
return NULL;
}
static void *
create_set (void)
{
return hb_set_create ();
}
static void *
create_set_from_inert (void)
{
return NULL;
}
static void *
create_face (void)
{
hb_blob_t *blob = (hb_blob_t *) create_blob ();
hb_face_t *face = hb_face_create (blob, 0);
hb_blob_destroy (blob);
return face;
}
static void *
create_face_from_inert (void)
{
return hb_face_create (hb_blob_get_empty (), 0);
}
static void *
create_font (void)
{
hb_face_t *face = (hb_face_t *) create_face ();
hb_font_t *font = hb_font_create (face);
hb_face_destroy (face);
return font;
}
static void *
create_font_from_inert (void)
{
return hb_font_create (hb_face_get_empty ());
}
static void *
create_font_funcs (void)
{
return hb_font_funcs_create ();
}
static void *
create_font_funcs_from_inert (void)
{
return NULL;
}
static void *
create_unicode_funcs (void)
{
return hb_unicode_funcs_create (NULL);
}
static void *
create_unicode_funcs_from_inert (void)
{
return hb_unicode_funcs_create (hb_unicode_funcs_get_empty ());
}
typedef void *(*create_func_t) (void);
typedef void *(*reference_func_t) (void *obj);
typedef void (*destroy_func_t) (void *obj);
typedef hb_bool_t (*set_user_data_func_t) (void *obj, hb_user_data_key_t *key, void *data, hb_destroy_func_t destroy, hb_bool_t replace);
typedef void * (*get_user_data_func_t) (void *obj, hb_user_data_key_t *key);
typedef void (*make_immutable_func_t) (void *obj);
typedef hb_bool_t (*is_immutable_func_t) (void *obj);
typedef struct {
create_func_t create;
create_func_t create_from_inert;
create_func_t get_empty;
reference_func_t reference;
destroy_func_t destroy;
set_user_data_func_t set_user_data;
get_user_data_func_t get_user_data;
make_immutable_func_t make_immutable;
is_immutable_func_t is_immutable;
const char *name;
} object_t;
#define OBJECT_WITHOUT_IMMUTABILITY(name) \
{ \
(create_func_t) create_##name, \
(create_func_t) create_##name##_from_inert, \
(create_func_t) hb_##name##_get_empty, \
(reference_func_t) hb_##name##_reference, \
(destroy_func_t) hb_##name##_destroy, \
(set_user_data_func_t) hb_##name##_set_user_data, \
(get_user_data_func_t) hb_##name##_get_user_data, \
(make_immutable_func_t) NULL, \
(is_immutable_func_t) NULL, \
#name, \
}
#define OBJECT_WITH_IMMUTABILITY(name) \
{ \
(create_func_t) create_##name, \
(create_func_t) create_##name##_from_inert, \
(create_func_t) hb_##name##_get_empty, \
(reference_func_t) hb_##name##_reference, \
(destroy_func_t) hb_##name##_destroy, \
(set_user_data_func_t) hb_##name##_set_user_data, \
(get_user_data_func_t) hb_##name##_get_user_data, \
(make_immutable_func_t) hb_##name##_make_immutable, \
(is_immutable_func_t) hb_##name##_is_immutable, \
#name, \
}
static const object_t objects[] =
{
OBJECT_WITHOUT_IMMUTABILITY (buffer),
OBJECT_WITHOUT_IMMUTABILITY (set),
OBJECT_WITH_IMMUTABILITY (blob),
OBJECT_WITH_IMMUTABILITY (face),
OBJECT_WITH_IMMUTABILITY (font),
OBJECT_WITH_IMMUTABILITY (font_funcs),
OBJECT_WITH_IMMUTABILITY (unicode_funcs)
};
#undef OBJECT
#define MAGIC0 0x12345678
#define MAGIC1 0x76543210
typedef struct {
int value;
gboolean freed;
} data_t;
static int global_data;
static void global_free_up (void *p G_GNUC_UNUSED)
{
global_data++;
}
static void free_up0 (void *p)
{
data_t *data = (data_t *) p;
g_assert_cmphex (data->value, ==, MAGIC0);
g_assert (!data->freed);
data->freed = TRUE;
}
static void free_up1 (void *p)
{
data_t *data = (data_t *) p;
g_assert_cmphex (data->value, ==, MAGIC1);
g_assert (!data->freed);
data->freed = TRUE;
}
typedef struct {
const object_t *klass;
void *object;
hb_user_data_key_t key;
} deadlock_test_t;
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));
}
static void
test_object (void)
{
unsigned int i;
for (i = 0; i < G_N_ELEMENTS (objects); i++) {
const object_t *o = &objects[i];
void *obj;
hb_user_data_key_t key[1001];
{
unsigned int j;
data_t data[2] = {{MAGIC0, FALSE}, {MAGIC1, FALSE}};
deadlock_test_t deadlock_test;
g_test_message ("Testing object %s", o->name);
g_test_message ("->create()");
obj = o->create ();
g_assert (obj);
g_assert (obj == o->reference (obj));
o->destroy (obj);
if (o->is_immutable)
g_assert (!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]);
if (o->is_immutable) {
o->make_immutable (obj);
g_assert (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 (!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);
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);
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_cmpuint (global_data, ==, 0);
g_assert (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_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));
for (j = 2; j < 1000; j++)
g_assert (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));
for (j = 2; j < 100; j++)
g_assert (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_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 (!data[1].freed);
o->destroy (obj);
g_assert (data[0].freed);
g_assert (data[1].freed);
g_assert_cmpuint (global_data, ==, 1000-2);
}
{
data_t data[2] = {{MAGIC0, FALSE}, {MAGIC1, FALSE}};
g_test_message ("->get_empty()");
obj = o->get_empty ();
g_assert (obj);
g_assert (obj == o->reference (obj));
o->destroy (obj);
if (o->is_immutable)
g_assert (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]));
o->destroy (obj);
o->destroy (obj);
o->destroy (obj);
o->destroy (obj);
o->destroy (obj);
g_assert (!data[0].freed);
}
{
data_t data[2] = {{MAGIC0, FALSE}, {MAGIC1, FALSE}};
g_test_message ("->create_from_inert()");
obj = o->create_from_inert ();
if (!obj)
continue;
if (obj == o->get_empty ())
continue; /* Tested already */
g_assert (obj == o->reference (obj));
o->destroy (obj);
if (o->is_immutable)
g_assert (!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]));
o->destroy (obj);
o->destroy (obj);
o->destroy (obj);
o->destroy (obj);
o->destroy (obj);
g_assert (data[0].freed);
}
}
}
int
main (int argc, char **argv)
{
hb_test_init (&argc, &argv);
hb_test_add (test_object);
return hb_test_run ();
}
Reference in New Issue View Git Blame Copy Permalink