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_destroy (s);
 122 }
 123
 124
 125 // static inline void
 126 // print_set (hb_set_t *s)
 127 // {
 128 //   hb_codepoint_t next;
 129 //   printf ("{");
 130 //   for (next = HB_SET_VALUE_INVALID; hb_set_next (s, &next); )
 131 //     printf ("%d, ", next);
 132 //   printf ("}\n");
 133 // }
 134
 135 static void
 136 test_set_algebra (void)
 137 {
 138   hb_set_t *s = hb_set_create ();
 139   hb_set_t *o = hb_set_create ();
 140   hb_set_t *o2 = hb_set_create ();
 141
 142   hb_set_add (o, 13);
 143   hb_set_add (o, 19);
 144
 145   hb_set_add (o2, 0x660E);
 146
 147   test_empty (s);
 148   g_assert (!hb_set_is_equal (s, o));
 149   g_assert (hb_set_is_subset (s, o));
 150   g_assert (!hb_set_is_subset (o, s));
 151   hb_set_set (s, o);
 152   g_assert (hb_set_is_equal (s, o));
 153   g_assert (hb_set_is_subset (s, o));
 154   g_assert (hb_set_is_subset (o, s));
 155   test_not_empty (s);
 156   g_assert_cmpint (hb_set_get_population (s), ==, 2);
 157
 158   hb_set_clear (s);
 159   test_empty (s);
 160   hb_set_add (s, 10);
 161   g_assert_cmpint (hb_set_get_population (s), ==, 1);
 162   hb_set_union (s, o);
 163   g_assert_cmpint (hb_set_get_population (s), ==, 3);
 164   g_assert (hb_set_has (s, 10));
 165   g_assert (hb_set_has (s, 13));
 166
 167   hb_set_clear (s);
 168   test_empty (s);
 169   g_assert_cmpint (hb_set_get_population (s), ==, 0);
 170   hb_set_union (s, o2);
 171   g_assert_cmpint (hb_set_get_population (s), ==, 1);
 172   g_assert (hb_set_has (s, 0x660E));
 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_intersect (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), ==, 1);
 182   g_assert (!hb_set_has (s, 10));
 183   g_assert (hb_set_has (s, 13));
 184
 185   hb_set_clear (s);
 186   test_empty (s);
 187   hb_set_add_range (s, 10, 17);
 188   g_assert (!hb_set_is_equal (s, o));
 189   hb_set_subtract (s, o);
 190   g_assert (!hb_set_is_equal (s, o));
 191   test_not_empty (s);
 192   g_assert_cmpint (hb_set_get_population (s), ==, 7);
 193   g_assert (hb_set_has (s, 12));
 194   g_assert (!hb_set_has (s, 13));
 195   g_assert (!hb_set_has (s, 19));
 196
 197   hb_set_clear (s);
 198   test_empty (s);
 199   hb_set_add_range (s, 10, 17);
 200   g_assert (!hb_set_is_equal (s, o));
 201   hb_set_symmetric_difference (s, o);
 202   g_assert (!hb_set_is_equal (s, o));
 203   test_not_empty (s);
 204   g_assert_cmpint (hb_set_get_population (s), ==, 8);
 205   g_assert (hb_set_has (s, 12));
 206   g_assert (!hb_set_has (s, 13));
 207   g_assert (hb_set_has (s, 19));
 208
 209   /* https://github.com/harfbuzz/harfbuzz/issues/579 */
 210   hb_set_clear (s);
 211   test_empty (s);
 212   hb_set_add_range (s, 886, 895);
 213   hb_set_add (s, 1024);
 214   hb_set_add (s, 1152);
 215   hb_set_clear (o);
 216   test_empty (o);
 217   hb_set_add (o, 889);
 218   hb_set_add (o, 1024);
 219   g_assert (!hb_set_is_equal (s, o));
 220   hb_set_intersect (o, s);
 221   test_not_empty (o);
 222   g_assert (!hb_set_is_equal (s, o));
 223   g_assert_cmpint (hb_set_get_population (o), ==, 2);
 224   g_assert (hb_set_has (o, 889));
 225   g_assert (hb_set_has (o, 1024));
 226   hb_set_clear (o);
 227   test_empty (o);
 228   hb_set_add_range (o, 887, 889);
 229   hb_set_add (o, 1121);
 230   g_assert (!hb_set_is_equal (s, o));
 231   hb_set_intersect (o, s);
 232   test_not_empty (o);
 233   g_assert (!hb_set_is_equal (s, o));
 234   g_assert_cmpint (hb_set_get_population (o), ==, 3);
 235   g_assert (hb_set_has (o, 887));
 236   g_assert (hb_set_has (o, 888));
 237   g_assert (hb_set_has (o, 889));
 238
 239   hb_set_clear (s);
 240   test_empty (s);
 241   hb_set_add_range (s, 886, 895);
 242   hb_set_add (s, 1014);
 243   hb_set_add (s, 1017);
 244   hb_set_add (s, 1024);
 245   hb_set_add (s, 1113);
 246   hb_set_add (s, 1121);
 247   g_assert_cmpint (hb_set_get_population (s), ==, 15);
 248
 249   hb_set_clear (o);
 250   test_empty (o);
 251   hb_set_add (o, 889);
 252   g_assert_cmpint (hb_set_get_population (o), ==, 1);
 253   hb_set_intersect (o, s);
 254   g_assert_cmpint (hb_set_get_population (o), ==, 1);
 255   g_assert (hb_set_has (o, 889));
 256
 257   hb_set_add (o, 511);
 258   g_assert_cmpint (hb_set_get_population (o), ==, 2);
 259   hb_set_intersect (o, s);
 260   g_assert_cmpint (hb_set_get_population (o), ==, 1);
 261   g_assert (hb_set_has (o, 889));
 262
 263   hb_set_destroy (s);
 264   hb_set_destroy (o);
 265 }
 266
 267 static void
 268 test_set_iter (void)
 269 {
 270   hb_codepoint_t next, first, last;
 271   hb_set_t *s = hb_set_create ();
 272
 273   hb_set_add (s, 13);
 274   hb_set_add_range (s, 6, 6);
 275   hb_set_add_range (s, 10, 15);
 276   hb_set_add (s, 1100);
 277   hb_set_add (s, 1200);
 278   hb_set_add (s, 20005);
 279
 280   test_not_empty (s);
 281
 282   next = HB_SET_VALUE_INVALID;
 283   g_assert (hb_set_next (s, &next));
 284   g_assert_cmpint (next, ==, 6);
 285   g_assert (hb_set_next (s, &next));
 286   g_assert_cmpint (next, ==, 10);
 287   g_assert (hb_set_next (s, &next));
 288   g_assert (hb_set_next (s, &next));
 289   g_assert (hb_set_next (s, &next));
 290   g_assert_cmpint (next, ==, 13);
 291   g_assert (hb_set_next (s, &next));
 292   g_assert (hb_set_next (s, &next));
 293   g_assert_cmpint (next, ==, 15);
 294   g_assert (hb_set_next (s, &next));
 295   g_assert_cmpint (next, ==, 1100);
 296   g_assert (hb_set_next (s, &next));
 297   g_assert_cmpint (next, ==, 1200);
 298   g_assert (hb_set_next (s, &next));
 299   g_assert_cmpint (next, ==, 20005);
 300   g_assert (!hb_set_next (s, &next));
 301   g_assert_cmpint (next, ==, HB_SET_VALUE_INVALID);
 302
 303   next = HB_SET_VALUE_INVALID;
 304   g_assert (hb_set_previous (s, &next));
 305   g_assert_cmpint (next, ==, 20005);
 306   g_assert (hb_set_previous (s, &next));
 307   g_assert_cmpint (next, ==, 1200);
 308   g_assert (hb_set_previous (s, &next));
 309   g_assert_cmpint (next, ==, 1100);
 310   g_assert (hb_set_previous (s, &next));
 311   g_assert_cmpint (next, ==, 15);
 312   g_assert (hb_set_previous (s, &next));
 313   g_assert (hb_set_previous (s, &next));
 314   g_assert_cmpint (next, ==, 13);
 315   g_assert (hb_set_previous (s, &next));
 316   g_assert (hb_set_previous (s, &next));
 317   g_assert (hb_set_previous (s, &next));
 318   g_assert_cmpint (next, ==, 10);
 319   g_assert (hb_set_previous (s, &next));
 320   g_assert_cmpint (next, ==, 6);
 321   g_assert (!hb_set_previous (s, &next));
 322   g_assert_cmpint (next, ==, HB_SET_VALUE_INVALID);
 323
 324   first = last = HB_SET_VALUE_INVALID;
 325   g_assert (hb_set_next_range (s, &first, &last));
 326   g_assert_cmpint (first, ==, 6);
 327   g_assert_cmpint (last,  ==, 6);
 328   g_assert (hb_set_next_range (s, &first, &last));
 329   g_assert_cmpint (first, ==, 10);
 330   g_assert_cmpint (last,  ==, 15);
 331   g_assert (hb_set_next_range (s, &first, &last));
 332   g_assert_cmpint (first, ==, 1100);
 333   g_assert_cmpint (last,  ==, 1100);
 334   g_assert (hb_set_next_range (s, &first, &last));
 335   g_assert_cmpint (first, ==, 1200);
 336   g_assert_cmpint (last,  ==, 1200);
 337   g_assert (hb_set_next_range (s, &first, &last));
 338   g_assert_cmpint (first, ==, 20005);
 339   g_assert_cmpint (last,  ==, 20005);
 340   g_assert (!hb_set_next_range (s, &first, &last));
 341   g_assert_cmpint (first, ==, HB_SET_VALUE_INVALID);
 342   g_assert_cmpint (last,  ==, HB_SET_VALUE_INVALID);
 343
 344   first = last = HB_SET_VALUE_INVALID;
 345   g_assert (hb_set_previous_range (s, &first, &last));
 346   g_assert_cmpint (first, ==, 20005);
 347   g_assert_cmpint (last,  ==, 20005);
 348   g_assert (hb_set_previous_range (s, &first, &last));
 349   g_assert_cmpint (first, ==, 1200);
 350   g_assert_cmpint (last,  ==, 1200);
 351   g_assert (hb_set_previous_range (s, &first, &last));
 352   g_assert_cmpint (first, ==, 1100);
 353   g_assert_cmpint (last,  ==, 1100);
 354   g_assert (hb_set_previous_range (s, &first, &last));
 355   g_assert_cmpint (first, ==, 10);
 356   g_assert_cmpint (last,  ==, 15);
 357   g_assert (hb_set_previous_range (s, &first, &last));
 358   g_assert_cmpint (first, ==, 6);
 359   g_assert_cmpint (last,  ==, 6);
 360   g_assert (!hb_set_previous_range (s, &first, &last));
 361   g_assert_cmpint (first, ==, HB_SET_VALUE_INVALID);
 362   g_assert_cmpint (last,  ==, HB_SET_VALUE_INVALID);
 363
 364   hb_set_destroy (s);
 365 }
 366
 367 static void
 368 test_set_empty (void)
 369 {
 370   hb_set_t *b = hb_set_get_empty ();
 371
 372   g_assert (hb_set_get_empty ());
 373   g_assert (hb_set_get_empty () == b);
 374
 375   g_assert (!hb_set_allocation_successful (b));
 376
 377   test_empty (b);
 378
 379   hb_set_add (b, 13);
 380
 381   test_empty (b);
 382
 383   hb_set_invert (b);
 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 }