[tests] Finish test-set.c

All passing now.

test/api/test-set.c

@@ -29,243 +29,169 @@
 /* Unit tests for hb-set.h */
 
 
-#if 0
 static void
-test_buffer_properties (fixture_t *fixture, gconstpointer user_data)
+test_empty (hb_set_t *s)
 {
-  hb_buffer_t *b = fixture->buffer;
+  hb_codepoint_t next = (hb_codepoint_t) -1;
-  hb_unicode_funcs_t *ufuncs;
+  g_assert_cmpint (hb_set_get_population (s), ==, 0);
-
+  g_assert_cmpint (hb_set_get_min (s), ==, (hb_codepoint_t) -1);
-  /* test default properties */
+  g_assert_cmpint (hb_set_get_max (s), ==, (hb_codepoint_t) -1);
-
+  g_assert (!hb_set_has (s, 13));
-  g_assert (hb_buffer_get_unicode_funcs (b) == hb_unicode_funcs_get_default ());
+  g_assert (!hb_set_next (s, &next));
-  g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
+  g_assert_cmpint (next, ==, (hb_codepoint_t) -1);
-  g_assert (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
-  g_assert (hb_buffer_get_language (b) == NULL);
-  g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAGS_DEFAULT);
-
-
-  /* test property changes are retained */
-  ufuncs = hb_unicode_funcs_create (NULL);
-  hb_buffer_set_unicode_funcs (b, ufuncs);
-  hb_unicode_funcs_destroy (ufuncs);
-  g_assert (hb_buffer_get_unicode_funcs (b) == ufuncs);
-
-  hb_buffer_set_direction (b, HB_DIRECTION_RTL);
-  g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_RTL);
-
-  hb_buffer_set_script (b, HB_SCRIPT_ARABIC);
-  g_assert (hb_buffer_get_script (b) == HB_SCRIPT_ARABIC);
-
-  hb_buffer_set_language (b, hb_language_from_string ("fa", -1));
-  g_assert (hb_buffer_get_language (b) == hb_language_from_string ("Fa", -1));
-
-  hb_buffer_set_flags (b, HB_BUFFER_FLAG_BOT);
-  g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_BOT);
-
-
-
-  /* test clear clears all properties but unicode_funcs */
-
-  hb_buffer_clear (b);
-
-  g_assert (hb_buffer_get_unicode_funcs (b) == ufuncs);
-  g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
-  g_assert (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
-  g_assert (hb_buffer_get_language (b) == NULL);
-  g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAGS_DEFAULT);
-
-
-  /* test reset clears all properties */
-
-  hb_buffer_set_direction (b, HB_DIRECTION_RTL);
-  g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_RTL);
-
-  hb_buffer_set_script (b, HB_SCRIPT_ARABIC);
-  g_assert (hb_buffer_get_script (b) == HB_SCRIPT_ARABIC);
-
-  hb_buffer_set_language (b, hb_language_from_string ("fa", -1));
-  g_assert (hb_buffer_get_language (b) == hb_language_from_string ("Fa", -1));
-
-  hb_buffer_set_flags (b, HB_BUFFER_FLAG_BOT);
-  g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_BOT);
-
-  hb_buffer_reset (b);
-
-  g_assert (hb_buffer_get_unicode_funcs (b) == hb_unicode_funcs_get_default ());
-  g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
-  g_assert (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
-  g_assert (hb_buffer_get_language (b) == NULL);
-  g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAGS_DEFAULT);
 }
 
 static void
-test_buffer_contents (fixture_t *fixture, gconstpointer user_data)
+test_not_empty (hb_set_t *s)
 {
-  hb_buffer_t *b = fixture->buffer;
+  hb_codepoint_t next = (hb_codepoint_t) -1;
-  unsigned int i, len, len2;
+  g_assert_cmpint (hb_set_get_population (s), !=, 0);
-  buffer_type_t buffer_type = GPOINTER_TO_INT (user_data);
+  g_assert_cmpint (hb_set_get_min (s), !=, (hb_codepoint_t) -1);
-  hb_glyph_info_t *glyphs;
+  g_assert_cmpint (hb_set_get_max (s), !=, (hb_codepoint_t) -1);
-
+  g_assert (hb_set_next (s, &next));
-  if (buffer_type == BUFFER_EMPTY) {
+  g_assert_cmpint (next, !=, (hb_codepoint_t) -1);
-    g_assert_cmpint (hb_buffer_get_population (b), ==, 0);
-    return;
-  }
-
-  len = hb_buffer_get_population (b);
-  hb_buffer_get_glyph_infos (b, NULL); /* test NULL */
-  glyphs = hb_buffer_get_glyph_infos (b, &len2);
-  g_assert_cmpint (len, ==, len2);
-  g_assert_cmpint (len, ==, 5);
-
-  for (i = 0; i < len; i++) {
-    g_assert_cmphex (glyphs[i].mask,      ==, 1);
-    g_assert_cmphex (glyphs[i].var1.u32,  ==, 0);
-    g_assert_cmphex (glyphs[i].var2.u32,  ==, 0);
-  }
-
-  for (i = 0; i < len; i++) {
-    unsigned int cluster;
-    cluster = 1+i;
-    if (i >= 2) {
-      if (buffer_type == BUFFER_UTF16)
-	cluster++;
-      else if (buffer_type == BUFFER_UTF8)
-        cluster += 3;
-    }
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[1+i]);
-    g_assert_cmphex (glyphs[i].cluster,   ==, cluster);
-  }
-
-  /* reverse, test, and reverse back */
-
-  hb_buffer_reverse (b);
-  for (i = 0; i < len; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[len-i]);
-
-  hb_buffer_reverse (b);
-  for (i = 0; i < len; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[1+i]);
-
-  /* reverse_clusters works same as reverse for now since each codepoint is
-   * in its own cluster */
-
-  hb_buffer_reverse_clusters (b);
-  for (i = 0; i < len; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[len-i]);
-
-  hb_buffer_reverse_clusters (b);
-  for (i = 0; i < len; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[1+i]);
-
-  /* now form a cluster and test again */
-  glyphs[2].cluster = glyphs[1].cluster;
-
-  /* reverse, test, and reverse back */
-
-  hb_buffer_reverse (b);
-  for (i = 0; i < len; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[len-i]);
-
-  hb_buffer_reverse (b);
-  for (i = 0; i < len; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[1+i]);
-
-  /* reverse_clusters twice still should return the original string,
-   * but when applied once, the 1-2 cluster should be retained. */
-
-  hb_buffer_reverse_clusters (b);
-  for (i = 0; i < len; i++) {
-    unsigned int j = len-1-i;
-    if (j == 1)
-      j = 2;
-    else if (j == 2)
-      j = 1;
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[1+j]);
-  }
-
-  hb_buffer_reverse_clusters (b);
-  for (i = 0; i < len; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[1+i]);
-
-
-  /* test setting length */
-
-  /* enlarge */
-  g_assert (hb_buffer_set_length (b, 10));
-  glyphs = hb_buffer_get_glyph_infos (b, NULL);
-  g_assert_cmpint (hb_buffer_get_population (b), ==, 10);
-  for (i = 0; i < 5; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[1+i]);
-  for (i = 5; i < 10; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, 0);
-  /* shrink */
-  g_assert (hb_buffer_set_length (b, 3));
-  glyphs = hb_buffer_get_glyph_infos (b, NULL);
-  g_assert_cmpint (hb_buffer_get_population (b), ==, 3);
-  for (i = 0; i < 3; i++)
-    g_assert_cmphex (glyphs[i].codepoint, ==, utf32[1+i]);
-
-
-  g_assert (hb_buffer_allocation_successful (b));
-
-
-  /* test reset clears content */
-
-  hb_buffer_reset (b);
-  g_assert_cmpint (hb_buffer_get_population (b), ==, 0);
 }
 
 static void
-test_buffer_allocation (fixture_t *fixture, gconstpointer user_data)
+test_set_basic (void)
 {
-  hb_buffer_t *b = fixture->buffer;
+  hb_set_t *s = hb_set_create ();
 
-  g_assert_cmpint (hb_buffer_get_population (b), ==, 0);
+  test_empty (s);
+  hb_set_add (s, 13);
+  test_not_empty (s);
 
-  g_assert (hb_buffer_pre_allocate (b, 100));
+  hb_set_clear (s);
-  g_assert_cmpint (hb_buffer_get_population (b), ==, 0);
+  test_empty (s);
-  g_assert (hb_buffer_allocation_successful (b));
 
-  /* lets try a huge allocation, make sure it fails */
+  hb_set_add_range (s, 10, 29);
-  g_assert (!hb_buffer_pre_allocate (b, (unsigned int) -1));
+  test_not_empty (s);
-  g_assert_cmpint (hb_buffer_get_population (b), ==, 0);
+  g_assert (hb_set_has (s, 13));
-  g_assert (!hb_buffer_allocation_successful (b));
+  g_assert_cmpint (hb_set_get_population (s), ==, 20);
+  g_assert_cmpint (hb_set_get_min (s), ==, 10);
+  g_assert_cmpint (hb_set_get_max (s), ==, 29);
 
-  /* small one again */
+  hb_set_invert (s);
-  g_assert (hb_buffer_pre_allocate (b, 50));
+  test_not_empty (s);
-  g_assert_cmpint (hb_buffer_get_population (b), ==, 0);
+  g_assert (!hb_set_has (s, 13));
-  g_assert (!hb_buffer_allocation_successful (b));
+  g_assert_cmpint (hb_set_get_min (s), ==, 0);
 
-  hb_buffer_reset (b);
+  hb_set_invert (s);
-  g_assert (hb_buffer_allocation_successful (b));
+  test_not_empty (s);
+  g_assert (hb_set_has (s, 13));
+  g_assert_cmpint (hb_set_get_population (s), ==, 20);
+  g_assert_cmpint (hb_set_get_min (s), ==, 10);
+  g_assert_cmpint (hb_set_get_max (s), ==, 29);
 
-  /* all allocation and size  */
+  hb_set_del_range (s, 10, 18);
-  g_assert (!hb_buffer_pre_allocate (b, ((unsigned int) -1) / 20 + 1));
+  test_not_empty (s);
-  g_assert (!hb_buffer_allocation_successful (b));
+  g_assert (!hb_set_has (s, 13));
-
-  hb_buffer_reset (b);
-  g_assert (hb_buffer_allocation_successful (b));
-
-  /* technically, this one can actually pass on 64bit machines, but
-   * I'm doubtful that any malloc allows 4GB allocations at a time.
-   * But let's only enable it on a 32-bit machine. */
-  if (sizeof (long) == 4) {
-    g_assert (!hb_buffer_pre_allocate (b, ((unsigned int) -1) / 20 - 1));
-    g_assert (!hb_buffer_allocation_successful (b));
 }
 
-  hb_buffer_reset (b);
-  g_assert (hb_buffer_allocation_successful (b));
-}
-#endif
-
 static void
-test_empty (hb_set_t *b)
+test_set_algebra (void)
 {
-  g_assert_cmpint (hb_set_get_population (b), ==, 0);
+  hb_set_t *s = hb_set_create ();
-  g_assert_cmpint (hb_set_get_min (b), ==, (hb_codepoint_t) -1);
+  hb_set_t *o = hb_set_create ();
-  g_assert_cmpint (hb_set_get_max (b), ==, (hb_codepoint_t) -1);
+
+  hb_set_add (o, 13);
+  hb_set_add (o, 19);
+
+  test_empty (s);
+  g_assert (!hb_set_is_equal (s, o));
+  hb_set_set (s, o);
+  g_assert (hb_set_is_equal (s, o));
+  test_not_empty (s);
+  g_assert_cmpint (hb_set_get_population (s), ==, 2);
+
+  hb_set_clear (s);
+  test_empty (s);
+  hb_set_add (s, 10);
+  g_assert_cmpint (hb_set_get_population (s), ==, 1);
+  hb_set_union (s, o);
+  g_assert_cmpint (hb_set_get_population (s), ==, 3);
+  g_assert (hb_set_has (s, 10));
+  g_assert (hb_set_has (s, 13));
+
+  hb_set_clear (s);
+  test_empty (s);
+  hb_set_add_range (s, 10, 17);
+  g_assert (!hb_set_is_equal (s, o));
+  hb_set_intersect (s, o);
+  g_assert (!hb_set_is_equal (s, o));
+  test_not_empty (s);
+  g_assert_cmpint (hb_set_get_population (s), ==, 1);
+  g_assert (!hb_set_has (s, 10));
+  g_assert (hb_set_has (s, 13));
+
+  hb_set_clear (s);
+  test_empty (s);
+  hb_set_add_range (s, 10, 17);
+  g_assert (!hb_set_is_equal (s, o));
+  hb_set_subtract (s, o);
+  g_assert (!hb_set_is_equal (s, o));
+  test_not_empty (s);
+  g_assert_cmpint (hb_set_get_population (s), ==, 7);
+  g_assert (hb_set_has (s, 12));
+  g_assert (!hb_set_has (s, 13));
+  g_assert (!hb_set_has (s, 19));
+
+  hb_set_clear (s);
+  test_empty (s);
+  hb_set_add_range (s, 10, 17);
+  g_assert (!hb_set_is_equal (s, o));
+  hb_set_symmetric_difference (s, o);
+  g_assert (!hb_set_is_equal (s, o));
+  test_not_empty (s);
+  g_assert_cmpint (hb_set_get_population (s), ==, 8);
+  g_assert (hb_set_has (s, 12));
+  g_assert (!hb_set_has (s, 13));
+  g_assert (hb_set_has (s, 19));
+}
+
+static void
+test_set_iter (void)
+{
+  hb_codepoint_t next, first, last;
+  hb_set_t *s = hb_set_create ();
+
+  hb_set_add (s, 13);
+  hb_set_add_range (s, 6, 6);
+  hb_set_add_range (s, 10, 15);
+  hb_set_add (s, 20005);
+
+  test_not_empty (s);
+
+  next = (hb_codepoint_t) -1;
+  g_assert (hb_set_next (s, &next));
+  g_assert_cmpint (next, ==, 6);
+  g_assert (hb_set_next (s, &next));
+  g_assert_cmpint (next, ==, 10);
+  g_assert (hb_set_next (s, &next));
+  g_assert (hb_set_next (s, &next));
+  g_assert (hb_set_next (s, &next));
+  g_assert_cmpint (next, ==, 13);
+  g_assert (hb_set_next (s, &next));
+  g_assert (hb_set_next (s, &next));
+  g_assert_cmpint (next, ==, 15);
+  g_assert (hb_set_next (s, &next));
+  g_assert_cmpint (next, ==, 20005);
+  g_assert (!hb_set_next (s, &next));
+  g_assert_cmpint (next, ==, 20005);
+
+  first = last = (hb_codepoint_t) -1;
+  g_assert (hb_set_next_range (s, &first, &last));
+  g_assert_cmpint (first, ==, 6);
+  g_assert_cmpint (last,  ==, 6);
+  g_assert (hb_set_next_range (s, &first, &last));
+  g_assert_cmpint (first, ==, 10);
+  g_assert_cmpint (last,  ==, 15);
+  g_assert (hb_set_next_range (s, &first, &last));
+  g_assert_cmpint (first, ==, 20005);
+  g_assert_cmpint (last,  ==, 20005);
+  g_assert (!hb_set_next_range (s, &first, &last));
+  g_assert_cmpint (first, ==, 20005);
+  g_assert_cmpint (last,  ==, 20005);
 }
 
 static void
@@ -302,10 +228,9 @@ main (int argc, char **argv)
 {
   hb_test_init (&argc, &argv);
 
-#if 0
+  hb_test_add (test_set_basic);
   hb_test_add (test_set_algebra);
   hb_test_add (test_set_iter);
-#endif
   hb_test_add (test_set_empty);
 
   return hb_test_run();