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 *
create_blob(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 *
create_blob_from_inert(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 *
create_buffer(void)45 create_buffer (void)
46 {
47 return hb_buffer_create ();
48 }
49 static void *
create_buffer_from_inert(void)50 create_buffer_from_inert (void)
51 {
52 return NULL;
53 }
54
55 static void *
create_set(void)56 create_set (void)
57 {
58 return hb_set_create ();
59 }
60 static void *
create_set_from_inert(void)61 create_set_from_inert (void)
62 {
63 return NULL;
64 }
65
66 static void *
create_face(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 *
create_face_from_inert(void)75 create_face_from_inert (void)
76 {
77 return hb_face_create (hb_blob_get_empty (), 0);
78 }
79
80 static void *
create_font(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 *
create_font_from_inert(void)89 create_font_from_inert (void)
90 {
91 return hb_font_create (hb_face_get_empty ());
92 }
93
94 static void *
create_font_funcs(void)95 create_font_funcs (void)
96 {
97 return hb_font_funcs_create ();
98 }
99 static void *
create_font_funcs_from_inert(void)100 create_font_funcs_from_inert (void)
101 {
102 return NULL;
103 }
104
105 static void *
create_unicode_funcs(void)106 create_unicode_funcs (void)
107 {
108 return hb_unicode_funcs_create (NULL);
109 }
110 static void *
create_unicode_funcs_from_inert(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
global_free_up(void * p G_GNUC_UNUSED)188 static void global_free_up (void *p G_GNUC_UNUSED)
189 {
190 global_data++;
191 }
192
free_up0(void * p)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
free_up1(void * p)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
free_deadlock_test(void * p)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
test_object(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[2] = {{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
main(int argc,char ** argv)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