Home | History | Annotate | Download | only in api
      1 /*
      2  * Copyright  2011  Google, Inc.
      3  *
      4  *  This is part of HarfBuzz, a text shaping library.
      5  *
      6  * Permission is hereby granted, without written agreement and without
      7  * license or royalty fees, to use, copy, modify, and distribute this
      8  * software and its documentation for any purpose, provided that the
      9  * above copyright notice and the following two paragraphs appear in
     10  * all copies of this software.
     11  *
     12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
     13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
     14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
     15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
     16  * DAMAGE.
     17  *
     18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
     19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
     20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
     21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
     22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
     23  *
     24  * Google Author(s): Behdad Esfahbod
     25  */
     26 
     27 #include "hb-test.h"
     28 
     29 /* Unit tests for hb-object-private.h */
     30 
     31 
     32 static void *
     33 create_blob (void)
     34 {
     35   static char data[] = "test data";
     36   return hb_blob_create (data, sizeof (data), HB_MEMORY_MODE_READONLY, NULL, NULL);
     37 }
     38 static void *
     39 create_blob_from_inert (void)
     40 {
     41   return hb_blob_create (NULL, 0, HB_MEMORY_MODE_DUPLICATE, NULL, NULL);
     42 }
     43 
     44 static void *
     45 create_buffer (void)
     46 {
     47   return hb_buffer_create ();
     48 }
     49 static void *
     50 create_buffer_from_inert (void)
     51 {
     52   return NULL;
     53 }
     54 
     55 static void *
     56 create_set (void)
     57 {
     58   return hb_set_create ();
     59 }
     60 static void *
     61 create_set_from_inert (void)
     62 {
     63   return NULL;
     64 }
     65 
     66 static void *
     67 create_face (void)
     68 {
     69   hb_blob_t *blob = (hb_blob_t *) create_blob ();
     70   hb_face_t *face = hb_face_create (blob, 0);
     71   hb_blob_destroy (blob);
     72   return face;
     73 }
     74 static void *
     75 create_face_from_inert (void)
     76 {
     77   return hb_face_create (hb_blob_get_empty (), 0);
     78 }
     79 
     80 static void *
     81 create_font (void)
     82 {
     83   hb_face_t *face = (hb_face_t *) create_face ();
     84   hb_font_t *font = hb_font_create (face);
     85   hb_face_destroy (face);
     86   return font;
     87 }
     88 static void *
     89 create_font_from_inert (void)
     90 {
     91   return hb_font_create (hb_face_get_empty ());
     92 }
     93 
     94 static void *
     95 create_font_funcs (void)
     96 {
     97   return hb_font_funcs_create ();
     98 }
     99 static void *
    100 create_font_funcs_from_inert (void)
    101 {
    102   return NULL;
    103 }
    104 
    105 static void *
    106 create_unicode_funcs (void)
    107 {
    108   return hb_unicode_funcs_create (NULL);
    109 }
    110 static void *
    111 create_unicode_funcs_from_inert (void)
    112 {
    113   return hb_unicode_funcs_create (hb_unicode_funcs_get_empty ());
    114 }
    115 
    116 
    117 
    118 typedef void     *(*create_func_t)         (void);
    119 typedef void     *(*reference_func_t)      (void *obj);
    120 typedef void      (*destroy_func_t)        (void *obj);
    121 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);
    122 typedef void *    (*get_user_data_func_t)  (void *obj, hb_user_data_key_t *key);
    123 typedef void      (*make_immutable_func_t) (void *obj);
    124 typedef hb_bool_t (*is_immutable_func_t)   (void *obj);
    125 
    126 typedef struct {
    127   create_func_t          create;
    128   create_func_t          create_from_inert;
    129   create_func_t          get_empty;
    130   reference_func_t       reference;
    131   destroy_func_t         destroy;
    132   set_user_data_func_t   set_user_data;
    133   get_user_data_func_t   get_user_data;
    134   make_immutable_func_t  make_immutable;
    135   is_immutable_func_t    is_immutable;
    136   const char            *name;
    137 } object_t;
    138 
    139 #define OBJECT_WITHOUT_IMMUTABILITY(name) \
    140   { \
    141     (create_func_t)         create_##name, \
    142     (create_func_t)         create_##name##_from_inert, \
    143     (create_func_t)         hb_##name##_get_empty, \
    144     (reference_func_t)      hb_##name##_reference, \
    145     (destroy_func_t)        hb_##name##_destroy, \
    146     (set_user_data_func_t)  hb_##name##_set_user_data, \
    147     (get_user_data_func_t)  hb_##name##_get_user_data, \
    148     (make_immutable_func_t) NULL, \
    149     (is_immutable_func_t)   NULL, \
    150     #name, \
    151   }
    152 #define OBJECT_WITH_IMMUTABILITY(name) \
    153   { \
    154     (create_func_t)         create_##name, \
    155     (create_func_t)         create_##name##_from_inert, \
    156     (create_func_t)         hb_##name##_get_empty, \
    157     (reference_func_t)      hb_##name##_reference, \
    158     (destroy_func_t)        hb_##name##_destroy, \
    159     (set_user_data_func_t)  hb_##name##_set_user_data, \
    160     (get_user_data_func_t)  hb_##name##_get_user_data, \
    161     (make_immutable_func_t) hb_##name##_make_immutable, \
    162     (is_immutable_func_t)   hb_##name##_is_immutable, \
    163     #name, \
    164   }
    165 static const object_t objects[] =
    166 {
    167   OBJECT_WITHOUT_IMMUTABILITY (buffer),
    168   OBJECT_WITHOUT_IMMUTABILITY (set),
    169   OBJECT_WITH_IMMUTABILITY (blob),
    170   OBJECT_WITH_IMMUTABILITY (face),
    171   OBJECT_WITH_IMMUTABILITY (font),
    172   OBJECT_WITH_IMMUTABILITY (font_funcs),
    173   OBJECT_WITH_IMMUTABILITY (unicode_funcs)
    174 };
    175 #undef OBJECT
    176 
    177 
    178 #define MAGIC0 0x12345678
    179 #define MAGIC1 0x76543210
    180 
    181 typedef struct {
    182   int value;
    183   gboolean freed;
    184 } data_t;
    185 
    186 static int global_data;
    187 
    188 static void global_free_up (void *p G_GNUC_UNUSED)
    189 {
    190   global_data++;
    191 }
    192 
    193 static void free_up0 (void *p)
    194 {
    195   data_t *data = (data_t *) p;
    196 
    197   g_assert_cmphex (data->value, ==, MAGIC0);
    198   g_assert (!data->freed);
    199   data->freed = TRUE;
    200 }
    201 
    202 static void free_up1 (void *p)
    203 {
    204   data_t *data = (data_t *) p;
    205 
    206   g_assert_cmphex (data->value, ==, MAGIC1);
    207   g_assert (!data->freed);
    208   data->freed = TRUE;
    209 }
    210 
    211 
    212 typedef struct {
    213   const object_t *klass;
    214   void *object;
    215   hb_user_data_key_t key;
    216 } deadlock_test_t;
    217 
    218 static void free_deadlock_test (void *p)
    219 {
    220   deadlock_test_t *t = (deadlock_test_t *) p;
    221 
    222   g_assert (NULL == t->klass->get_user_data (t->object, &t->key));
    223 }
    224 
    225 
    226 static void
    227 test_object (void)
    228 {
    229   unsigned int i;
    230 
    231   for (i = 0; i < G_N_ELEMENTS (objects); i++) {
    232     const object_t *o = &objects[i];
    233     void *obj;
    234     hb_user_data_key_t key[1001];
    235 
    236     {
    237       unsigned int j;
    238       data_t data[1000] = {{MAGIC0, FALSE}, {MAGIC1, FALSE}};
    239       deadlock_test_t deadlock_test;
    240 
    241       g_test_message ("Testing object %s", o->name);
    242 
    243       g_test_message ("->create()");
    244       obj = o->create ();
    245       g_assert (obj);
    246 
    247       g_assert (obj == o->reference (obj));
    248       o->destroy (obj);
    249 
    250       if (o->is_immutable)
    251 	g_assert (!o->is_immutable (obj));
    252 
    253       g_assert (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
    254       g_assert (o->get_user_data (obj, &key[0]) == &data[0]);
    255 
    256       if (o->is_immutable) {
    257 	o->make_immutable (obj);
    258 	g_assert (o->is_immutable (obj));
    259       }
    260 
    261       /* Should still work even if object is made immutable */
    262       g_assert (o->set_user_data (obj, &key[1], &data[1], free_up1, TRUE));
    263       g_assert (o->get_user_data (obj, &key[1]) == &data[1]);
    264 
    265       g_assert (!o->set_user_data (obj, NULL, &data[0], free_up0, TRUE));
    266       g_assert (o->get_user_data (obj, &key[0]) == &data[0]);
    267       g_assert (o->set_user_data (obj, &key[0], &data[1], NULL, TRUE));
    268       g_assert (data[0].freed);
    269       g_assert (o->get_user_data (obj, &key[0]) == &data[1]);
    270       g_assert (!data[1].freed);
    271 
    272       data[0].freed = FALSE;
    273       g_assert (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
    274       g_assert (!data[0].freed);
    275       g_assert (o->set_user_data (obj, &key[0], NULL, NULL, TRUE));
    276       g_assert (data[0].freed);
    277 
    278       data[0].freed = FALSE;
    279       global_data = 0;
    280       g_assert (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
    281       g_assert (!o->set_user_data (obj, &key[0], &data[0], free_up0, FALSE));
    282       g_assert_cmpuint (global_data, ==, 0);
    283       g_assert (o->set_user_data (obj, &key[0], NULL, global_free_up, TRUE));
    284       g_assert_cmpuint (global_data, ==, 0);
    285       g_assert (o->set_user_data (obj, &key[0], NULL, NULL, TRUE));
    286       g_assert_cmpuint (global_data, ==, 1);
    287 
    288       global_data = 0;
    289       for (j = 2; j < 1000; j++)
    290 	g_assert (o->set_user_data (obj, &key[j], &data[j], global_free_up, TRUE));
    291       for (j = 2; j < 1000; j++)
    292 	g_assert (o->get_user_data (obj, &key[j]) == &data[j]);
    293       for (j = 100; j < 1000; j++)
    294 	g_assert (o->set_user_data (obj, &key[j], NULL, NULL, TRUE));
    295       for (j = 2; j < 100; j++)
    296 	g_assert (o->get_user_data (obj, &key[j]) == &data[j]);
    297       for (j = 100; j < 1000; j++)
    298 	g_assert (!o->get_user_data (obj, &key[j]));
    299       g_assert_cmpuint (global_data, ==, 900);
    300 
    301       /* Test set_user_data where the destroy() func calls user_data functions.
    302        * Make sure it doesn't deadlock or corrupt memory. */
    303       deadlock_test.klass = o;
    304       deadlock_test.object = obj;
    305       g_assert (o->set_user_data (obj, &deadlock_test.key, &deadlock_test, free_deadlock_test, TRUE));
    306       g_assert (o->set_user_data (obj, &deadlock_test.key, NULL, NULL, TRUE));
    307 
    308       g_assert (!data[1].freed);
    309       o->destroy (obj);
    310       g_assert (data[0].freed);
    311       g_assert (data[1].freed);
    312       g_assert_cmpuint (global_data, ==, 1000-2);
    313     }
    314 
    315     {
    316       data_t data[2] = {{MAGIC0, FALSE}, {MAGIC1, FALSE}};
    317 
    318       g_test_message ("->get_empty()");
    319       obj = o->get_empty ();
    320       g_assert (obj);
    321 
    322       g_assert (obj == o->reference (obj));
    323       o->destroy (obj);
    324 
    325       if (o->is_immutable)
    326 	g_assert (o->is_immutable (obj));
    327 
    328       g_assert (!o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
    329       g_assert (!o->get_user_data (obj, &key[0]));
    330 
    331       o->destroy (obj);
    332       o->destroy (obj);
    333       o->destroy (obj);
    334       o->destroy (obj);
    335       o->destroy (obj);
    336 
    337       g_assert (!data[0].freed);
    338     }
    339 
    340     {
    341       data_t data[2] = {{MAGIC0, FALSE}, {MAGIC1, FALSE}};
    342 
    343       g_test_message ("->create_from_inert()");
    344       obj = o->create_from_inert ();
    345       if (!obj)
    346 	continue;
    347       if (obj == o->get_empty ())
    348         continue; /* Tested already */
    349 
    350       g_assert (obj == o->reference (obj));
    351       o->destroy (obj);
    352 
    353       if (o->is_immutable)
    354 	g_assert (!o->is_immutable (obj));
    355 
    356       g_assert (o->set_user_data (obj, &key[0], &data[0], free_up0, TRUE));
    357       g_assert (o->get_user_data (obj, &key[0]));
    358 
    359       o->destroy (obj);
    360 
    361       g_assert (data[0].freed);
    362     }
    363   }
    364 }
    365 
    366 
    367 int
    368 main (int argc, char **argv)
    369 {
    370   hb_test_init (&argc, &argv);
    371 
    372   hb_test_add (test_object);
    373 
    374   return hb_test_run ();
    375 }
    376