test/api/test-set.c

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