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 = 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
  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
  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   hb_set_invert (s);
  80   test_not_empty (s);
  81   g_assert (!hb_set_has (s, 13));
  82   g_assert_cmpint (hb_set_get_min (s), ==, 0);
  83
  84   hb_set_invert (s);
  85   test_not_empty (s);
  86   g_assert (hb_set_has (s, 13));
  87   g_assert_cmpint (hb_set_get_population (s), ==, 20);
  88   g_assert_cmpint (hb_set_get_min (s), ==, 10);
  89   g_assert_cmpint (hb_set_get_max (s), ==, 29);
  90
  91   hb_set_del_range (s, 10, 18);
  92   test_not_empty (s);
  93   g_assert (!hb_set_has (s, 13));
  94
  95   hb_set_destroy (s);
  96 }
  97
  98 static void
  99 test_set_algebra (void)
 100 {
 101   hb_set_t *s = hb_set_create ();
 102   hb_set_t *o = hb_set_create ();
 103
 104   hb_set_add (o, 13);
 105   hb_set_add (o, 19);
 106
 107   test_empty (s);
 108   g_assert (!hb_set_is_equal (s, o));
 109   hb_set_set (s, o);
 110   g_assert (hb_set_is_equal (s, o));
 111   test_not_empty (s);
 112   g_assert_cmpint (hb_set_get_population (s), ==, 2);
 113
 114   hb_set_clear (s);
 115   test_empty (s);
 116   hb_set_add (s, 10);
 117   g_assert_cmpint (hb_set_get_population (s), ==, 1);
 118   hb_set_union (s, o);
 119   g_assert_cmpint (hb_set_get_population (s), ==, 3);
 120   g_assert (hb_set_has (s, 10));
 121   g_assert (hb_set_has (s, 13));
 122
 123   hb_set_clear (s);
 124   test_empty (s);
 125   hb_set_add_range (s, 10, 17);
 126   g_assert (!hb_set_is_equal (s, o));
 127   hb_set_intersect (s, o);
 128   g_assert (!hb_set_is_equal (s, o));
 129   test_not_empty (s);
 130   g_assert_cmpint (hb_set_get_population (s), ==, 1);
 131   g_assert (!hb_set_has (s, 10));
 132   g_assert (hb_set_has (s, 13));
 133
 134   hb_set_clear (s);
 135   test_empty (s);
 136   hb_set_add_range (s, 10, 17);
 137   g_assert (!hb_set_is_equal (s, o));
 138   hb_set_subtract (s, o);
 139   g_assert (!hb_set_is_equal (s, o));
 140   test_not_empty (s);
 141   g_assert_cmpint (hb_set_get_population (s), ==, 7);
 142   g_assert (hb_set_has (s, 12));
 143   g_assert (!hb_set_has (s, 13));
 144   g_assert (!hb_set_has (s, 19));
 145
 146   hb_set_clear (s);
 147   test_empty (s);
 148   hb_set_add_range (s, 10, 17);
 149   g_assert (!hb_set_is_equal (s, o));
 150   hb_set_symmetric_difference (s, o);
 151   g_assert (!hb_set_is_equal (s, o));
 152   test_not_empty (s);
 153   g_assert_cmpint (hb_set_get_population (s), ==, 8);
 154   g_assert (hb_set_has (s, 12));
 155   g_assert (!hb_set_has (s, 13));
 156   g_assert (hb_set_has (s, 19));
 157
 158   hb_set_destroy (s);
 159 }
 160
 161 static void
 162 test_set_iter (void)
 163 {
 164   hb_codepoint_t next, first, last;
 165   hb_set_t *s = hb_set_create ();
 166
 167   hb_set_add (s, 13);
 168   hb_set_add_range (s, 6, 6);
 169   hb_set_add_range (s, 10, 15);
 170   hb_set_add (s, 20005);
 171
 172   test_not_empty (s);
 173
 174   next = HB_SET_VALUE_INVALID;
 175   g_assert (hb_set_next (s, &next));
 176   g_assert_cmpint (next, ==, 6);
 177   g_assert (hb_set_next (s, &next));
 178   g_assert_cmpint (next, ==, 10);
 179   g_assert (hb_set_next (s, &next));
 180   g_assert (hb_set_next (s, &next));
 181   g_assert (hb_set_next (s, &next));
 182   g_assert_cmpint (next, ==, 13);
 183   g_assert (hb_set_next (s, &next));
 184   g_assert (hb_set_next (s, &next));
 185   g_assert_cmpint (next, ==, 15);
 186   g_assert (hb_set_next (s, &next));
 187   g_assert_cmpint (next, ==, 20005);
 188   g_assert (!hb_set_next (s, &next));
 189   g_assert_cmpint (next, ==, HB_SET_VALUE_INVALID);
 190
 191   first = last = HB_SET_VALUE_INVALID;
 192   g_assert (hb_set_next_range (s, &first, &last));
 193   g_assert_cmpint (first, ==, 6);
 194   g_assert_cmpint (last,  ==, 6);
 195   g_assert (hb_set_next_range (s, &first, &last));
 196   g_assert_cmpint (first, ==, 10);
 197   g_assert_cmpint (last,  ==, 15);
 198   g_assert (hb_set_next_range (s, &first, &last));
 199   g_assert_cmpint (first, ==, 20005);
 200   g_assert_cmpint (last,  ==, 20005);
 201   g_assert (!hb_set_next_range (s, &first, &last));
 202   g_assert_cmpint (first, ==, HB_SET_VALUE_INVALID);
 203   g_assert_cmpint (last,  ==, HB_SET_VALUE_INVALID);
 204
 205   hb_set_destroy (s);
 206 }
 207
 208 static void
 209 test_set_empty (void)
 210 {
 211   hb_set_t *b = hb_set_get_empty ();
 212
 213   g_assert (hb_set_get_empty ());
 214   g_assert (hb_set_get_empty () == b);
 215
 216   g_assert (!hb_set_allocation_successful (b));
 217
 218   test_empty (b);
 219
 220   hb_set_add (b, 13);
 221
 222   test_empty (b);
 223
 224   hb_set_invert (b);
 225
 226   test_empty (b);
 227
 228   g_assert (!hb_set_allocation_successful (b));
 229
 230   hb_set_clear (b);
 231
 232   test_empty (b);
 233
 234   g_assert (!hb_set_allocation_successful (b));
 235
 236   hb_set_destroy (b);
 237 }
 238
 239 int
 240 main (int argc, char **argv)
 241 {
 242   hb_test_init (&argc, &argv);
 243
 244   hb_test_add (test_set_basic);
 245   hb_test_add (test_set_algebra);
 246   hb_test_add (test_set_iter);
 247   hb_test_add (test_set_empty);
 248
 249   return hb_test_run();
 250 }