1 /*
2 * Copyright © 2013 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-set.h */
30
31
32 static void
test_empty(hb_set_t * s)33 test_empty (hb_set_t *s)
34 {
35 hb_codepoint_t next = HB_SET_VALUE_INVALID;
36 g_assert_cmpint (hb_set_get_population (s), ==, 0);
37 g_assert_cmpint (hb_set_get_min (s), ==, HB_SET_VALUE_INVALID);
38 g_assert_cmpint (hb_set_get_max (s), ==, HB_SET_VALUE_INVALID);
39 g_assert (!hb_set_has (s, 13));
40 g_assert (!hb_set_next (s, &next));
41 g_assert_cmpint (next, ==, HB_SET_VALUE_INVALID);
42 g_assert (hb_set_is_empty (s));
43 }
44
45 static void
test_not_empty(hb_set_t * s)46 test_not_empty (hb_set_t *s)
47 {
48 hb_codepoint_t next = HB_SET_VALUE_INVALID;
49 g_assert_cmpint (hb_set_get_population (s), !=, 0);
50 g_assert_cmpint (hb_set_get_min (s), !=, HB_SET_VALUE_INVALID);
51 g_assert_cmpint (hb_set_get_max (s), !=, HB_SET_VALUE_INVALID);
52 g_assert (hb_set_next (s, &next));
53 g_assert_cmpint (next, !=, HB_SET_VALUE_INVALID);
54 }
55
56 static void
test_set_basic(void)57 test_set_basic (void)
58 {
59 hb_set_t *s = hb_set_create ();
60
61 test_empty (s);
62 hb_set_add (s, 13);
63 test_not_empty (s);
64
65 hb_set_clear (s);
66 test_empty (s);
67
68 hb_set_add (s, 33000);
69 test_not_empty (s);
70 hb_set_clear (s);
71
72 hb_set_add_range (s, 10, 29);
73 test_not_empty (s);
74 g_assert (hb_set_has (s, 13));
75 g_assert_cmpint (hb_set_get_population (s), ==, 20);
76 g_assert_cmpint (hb_set_get_min (s), ==, 10);
77 g_assert_cmpint (hb_set_get_max (s), ==, 29);
78
79 test_not_empty (s);
80 g_assert (hb_set_has (s, 13));
81 g_assert_cmpint (hb_set_get_population (s), ==, 20);
82 g_assert_cmpint (hb_set_get_min (s), ==, 10);
83 g_assert_cmpint (hb_set_get_max (s), ==, 29);
84
85 hb_set_del_range (s, 10, 18);
86 test_not_empty (s);
87 g_assert (!hb_set_has (s, 13));
88
89 hb_set_add_range (s, 200, 800);
90 test_not_empty (s);
91 g_assert (!hb_set_has (s, 100));
92 g_assert (!hb_set_has (s, 199));
93 g_assert (hb_set_has (s, 200));
94 g_assert (hb_set_has (s, 201));
95 g_assert (hb_set_has (s, 243));
96 g_assert (hb_set_has (s, 254));
97 g_assert (hb_set_has (s, 255));
98 g_assert (hb_set_has (s, 256));
99 g_assert (hb_set_has (s, 257));
100 g_assert (hb_set_has (s, 511));
101 g_assert (hb_set_has (s, 512));
102 g_assert (hb_set_has (s, 600));
103 g_assert (hb_set_has (s, 767));
104 g_assert (hb_set_has (s, 768));
105 g_assert (hb_set_has (s, 769));
106 g_assert (hb_set_has (s, 782));
107 g_assert (hb_set_has (s, 798));
108 g_assert (hb_set_has (s, 799));
109 g_assert (hb_set_has (s, 800));
110 g_assert (!hb_set_has (s, 801));
111 g_assert (!hb_set_has (s, 802));
112
113 hb_set_destroy (s);
114 }
115
116 static inline void
print_set(hb_set_t * s)117 print_set (hb_set_t *s)
118 {
119 hb_codepoint_t next;
120 printf ("{");
121 for (next = HB_SET_VALUE_INVALID; hb_set_next (s, &next); )
122 printf ("%d, ", next);
123 printf ("}\n");
124 }
125
126 static void
test_set_algebra(void)127 test_set_algebra (void)
128 {
129 hb_set_t *s = hb_set_create ();
130 hb_set_t *o = hb_set_create ();
131
132 hb_set_add (o, 13);
133 hb_set_add (o, 19);
134
135 test_empty (s);
136 g_assert (!hb_set_is_equal (s, o));
137 hb_set_set (s, o);
138 g_assert (hb_set_is_equal (s, o));
139 test_not_empty (s);
140 g_assert_cmpint (hb_set_get_population (s), ==, 2);
141
142 hb_set_clear (s);
143 test_empty (s);
144 hb_set_add (s, 10);
145 g_assert_cmpint (hb_set_get_population (s), ==, 1);
146 hb_set_union (s, o);
147 g_assert_cmpint (hb_set_get_population (s), ==, 3);
148 g_assert (hb_set_has (s, 10));
149 g_assert (hb_set_has (s, 13));
150
151 hb_set_clear (s);
152 test_empty (s);
153 hb_set_add_range (s, 10, 17);
154 g_assert (!hb_set_is_equal (s, o));
155 hb_set_intersect (s, o);
156 g_assert (!hb_set_is_equal (s, o));
157 test_not_empty (s);
158 g_assert_cmpint (hb_set_get_population (s), ==, 1);
159 g_assert (!hb_set_has (s, 10));
160 g_assert (hb_set_has (s, 13));
161
162 hb_set_clear (s);
163 test_empty (s);
164 hb_set_add_range (s, 10, 17);
165 g_assert (!hb_set_is_equal (s, o));
166 hb_set_subtract (s, o);
167 g_assert (!hb_set_is_equal (s, o));
168 test_not_empty (s);
169 g_assert_cmpint (hb_set_get_population (s), ==, 7);
170 g_assert (hb_set_has (s, 12));
171 g_assert (!hb_set_has (s, 13));
172 g_assert (!hb_set_has (s, 19));
173
174 hb_set_clear (s);
175 test_empty (s);
176 hb_set_add_range (s, 10, 17);
177 g_assert (!hb_set_is_equal (s, o));
178 hb_set_symmetric_difference (s, o);
179 g_assert (!hb_set_is_equal (s, o));
180 test_not_empty (s);
181 g_assert_cmpint (hb_set_get_population (s), ==, 8);
182 g_assert (hb_set_has (s, 12));
183 g_assert (!hb_set_has (s, 13));
184 g_assert (hb_set_has (s, 19));
185
186 /* https://github.com/harfbuzz/harfbuzz/issues/579 */
187 hb_set_clear (s);
188 test_empty (s);
189 hb_set_add_range (s, 886, 895);
190 hb_set_add (s, 1024);
191 hb_set_add (s, 1152);
192 hb_set_clear (o);
193 test_empty (o);
194 hb_set_add (o, 889);
195 hb_set_add (o, 1024);
196 g_assert (!hb_set_is_equal (s, o));
197 hb_set_intersect (o, s);
198 test_not_empty (o);
199 g_assert (!hb_set_is_equal (s, o));
200 g_assert_cmpint (hb_set_get_population (o), ==, 2);
201 g_assert (hb_set_has (o, 889));
202 g_assert (hb_set_has (o, 1024));
203 hb_set_clear (o);
204 test_empty (o);
205 hb_set_add_range (o, 887, 889);
206 hb_set_add (o, 1121);
207 g_assert (!hb_set_is_equal (s, o));
208 hb_set_intersect (o, s);
209 test_not_empty (o);
210 g_assert (!hb_set_is_equal (s, o));
211 g_assert_cmpint (hb_set_get_population (o), ==, 3);
212 g_assert (hb_set_has (o, 887));
213 g_assert (hb_set_has (o, 888));
214 g_assert (hb_set_has (o, 889));
215
216 hb_set_clear (s);
217 test_empty (s);
218 hb_set_add_range (s, 886, 895);
219 hb_set_add (s, 1014);
220 hb_set_add (s, 1017);
221 hb_set_add (s, 1024);
222 hb_set_add (s, 1113);
223 hb_set_add (s, 1121);
224 g_assert_cmpint (hb_set_get_population (s), ==, 15);
225
226 hb_set_clear (o);
227 test_empty (o);
228 hb_set_add (o, 889);
229 g_assert_cmpint (hb_set_get_population (o), ==, 1);
230 hb_set_intersect (o, s);
231 g_assert_cmpint (hb_set_get_population (o), ==, 1);
232 g_assert (hb_set_has (o, 889));
233
234 hb_set_destroy (s);
235 hb_set_destroy (o);
236 }
237
238 static void
test_set_iter(void)239 test_set_iter (void)
240 {
241 hb_codepoint_t next, first, last;
242 hb_set_t *s = hb_set_create ();
243
244 hb_set_add (s, 13);
245 hb_set_add_range (s, 6, 6);
246 hb_set_add_range (s, 10, 15);
247 hb_set_add (s, 1100);
248 hb_set_add (s, 1200);
249 hb_set_add (s, 20005);
250
251 test_not_empty (s);
252
253 next = HB_SET_VALUE_INVALID;
254 g_assert (hb_set_next (s, &next));
255 g_assert_cmpint (next, ==, 6);
256 g_assert (hb_set_next (s, &next));
257 g_assert_cmpint (next, ==, 10);
258 g_assert (hb_set_next (s, &next));
259 g_assert (hb_set_next (s, &next));
260 g_assert (hb_set_next (s, &next));
261 g_assert_cmpint (next, ==, 13);
262 g_assert (hb_set_next (s, &next));
263 g_assert (hb_set_next (s, &next));
264 g_assert_cmpint (next, ==, 15);
265 g_assert (hb_set_next (s, &next));
266 g_assert_cmpint (next, ==, 1100);
267 g_assert (hb_set_next (s, &next));
268 g_assert_cmpint (next, ==, 1200);
269 g_assert (hb_set_next (s, &next));
270 g_assert_cmpint (next, ==, 20005);
271 g_assert (!hb_set_next (s, &next));
272 g_assert_cmpint (next, ==, HB_SET_VALUE_INVALID);
273
274 first = last = HB_SET_VALUE_INVALID;
275 g_assert (hb_set_next_range (s, &first, &last));
276 g_assert_cmpint (first, ==, 6);
277 g_assert_cmpint (last, ==, 6);
278 g_assert (hb_set_next_range (s, &first, &last));
279 g_assert_cmpint (first, ==, 10);
280 g_assert_cmpint (last, ==, 15);
281 g_assert (hb_set_next_range (s, &first, &last));
282 g_assert_cmpint (first, ==, 1100);
283 g_assert_cmpint (last, ==, 1100);
284 g_assert (hb_set_next_range (s, &first, &last));
285 g_assert_cmpint (first, ==, 1200);
286 g_assert_cmpint (last, ==, 1200);
287 g_assert (hb_set_next_range (s, &first, &last));
288 g_assert_cmpint (first, ==, 20005);
289 g_assert_cmpint (last, ==, 20005);
290 g_assert (!hb_set_next_range (s, &first, &last));
291 g_assert_cmpint (first, ==, HB_SET_VALUE_INVALID);
292 g_assert_cmpint (last, ==, HB_SET_VALUE_INVALID);
293
294 hb_set_destroy (s);
295 }
296
297 static void
test_set_empty(void)298 test_set_empty (void)
299 {
300 hb_set_t *b = hb_set_get_empty ();
301
302 g_assert (hb_set_get_empty ());
303 g_assert (hb_set_get_empty () == b);
304
305 g_assert (!hb_set_allocation_successful (b));
306
307 test_empty (b);
308
309 hb_set_add (b, 13);
310
311 test_empty (b);
312
313 hb_set_invert (b);
314
315 test_empty (b);
316
317 g_assert (!hb_set_allocation_successful (b));
318
319 hb_set_clear (b);
320
321 test_empty (b);
322
323 g_assert (!hb_set_allocation_successful (b));
324
325 hb_set_destroy (b);
326 }
327
328 int
main(int argc,char ** argv)329 main (int argc, char **argv)
330 {
331 hb_test_init (&argc, &argv);
332
333 hb_test_add (test_set_basic);
334 hb_test_add (test_set_algebra);
335 hb_test_add (test_set_iter);
336 hb_test_add (test_set_empty);
337
338 return hb_test_run();
339 }
340