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