| /* |
| * 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[1000] = {{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); |
| |
| 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 (); |
| } |