Some more documentation fixes

[~andy/gtk] / gtk / tests / bitmask.c

diff --git a/gtk/tests/bitmask.c b/gtk/tests/bitmask.c
index 3aa9d34c46c5770a9435acf1416badc575d95ebe..33e4b42653d942bf61c37df6a26a7c87fc09e08c 100644 (file)
--- a/gtk/tests/bitmask.c
+++ b/gtk/tests/bitmask.c
@@ -46,9 +46,9 @@ gtk_bitmask_new_parse (const char *string)
   for (i = 0; i < length; i++)
     {
       if (string[i] == '0')
-        _gtk_bitmask_set (mask, length - i - 1, FALSE);
+        mask = _gtk_bitmask_set (mask, length - i - 1, FALSE);
       else if (string[i] == '1')
-        _gtk_bitmask_set (mask, length - i - 1, TRUE);
+        mask = _gtk_bitmask_set (mask, length - i - 1, TRUE);
       else
         g_assert_not_reached ();
     }
@@ -74,6 +74,9 @@ gtk_bitmask_new_parse (const char *string)
 static const char *tests[] = {
                                                                                                                                    "0",
                                                                                                                                    "1",
+                                                                                                     "1000000000000000000000000000000",
+                                                                                                    "10000000000000000000000000000000",
+                                                                     "100000000000000000000000000000000000000000000000000000000000000",
                                                                     "1000000000000000000000000000000000000000000000000000000000000000",
                                                                    "10000000000000000000000000000000000000000000000000000000000000000",
   "1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010",
@@ -140,12 +143,12 @@ test_set (void)
       for (j = 0; j < N_TRIES; j++)
         {
           indexes[j] = g_test_rand_int_range (0, MAX_INDEX);
-          _gtk_bitmask_set (copy, indexes[j], g_test_rand_bit ());
+          copy = _gtk_bitmask_set (copy, indexes[j], g_test_rand_bit ());
         }
 
       for (j = 0; j < N_TRIES; j++)
         {
-          _gtk_bitmask_set (copy, indexes[j], _gtk_bitmask_get (mask, indexes[j]));
+          copy = _gtk_bitmask_set (copy, indexes[j], _gtk_bitmask_get (mask, indexes[j]));
         }
 
       assert_cmpmasks (copy, mask);
@@ -171,15 +174,15 @@ test_union (void)
           guint id = g_test_rand_int_range (0, MAX_INDEX);
 
           if (g_test_rand_bit ())
-            _gtk_bitmask_set (left, id, TRUE);
+            left = _gtk_bitmask_set (left, id, TRUE);
           else
-            _gtk_bitmask_set (right, id, TRUE);
+            right = _gtk_bitmask_set (right, id, TRUE);
 
-          _gtk_bitmask_set (expected, id, TRUE);
+          expected = _gtk_bitmask_set (expected, id, TRUE);
         }
 
-      _gtk_bitmask_union (left, right);
-      _gtk_bitmask_union (right, left);
+      left = _gtk_bitmask_union (left, right);
+      right = _gtk_bitmask_union (right, left);
 
       assert_cmpmasks (left, expected);
       assert_cmpmasks (right, expected);
@@ -209,13 +212,13 @@ test_intersect (void)
 
           if (g_test_rand_bit ())
             {
-              _gtk_bitmask_set (left, id, set);
-              _gtk_bitmask_set (expected, id, set ? _gtk_bitmask_get (right, id) : 0);
+              left = _gtk_bitmask_set (left, id, set);
+              expected = _gtk_bitmask_set (expected, id, set ? _gtk_bitmask_get (right, id) : 0);
             }
           else
             {
-              _gtk_bitmask_set (right, id, set);
-              _gtk_bitmask_set (expected, id, set ? _gtk_bitmask_get (left, id) : 0);
+              right = _gtk_bitmask_set (right, id, set);
+              expected = _gtk_bitmask_set (expected, id, set ? _gtk_bitmask_get (left, id) : 0);
             }
         }
 
@@ -223,8 +226,8 @@ test_intersect (void)
       g_assert_cmpint (intersects, ==, _gtk_bitmask_intersects (right, left));
       g_assert_cmpint (intersects, !=, _gtk_bitmask_is_empty (expected));
 
-      _gtk_bitmask_intersect (left, right);
-      _gtk_bitmask_intersect (right, left);
+      left = _gtk_bitmask_intersect (left, right);
+      right = _gtk_bitmask_intersect (right, left);
 
       assert_cmpmasks (left, expected);
       assert_cmpmasks (right, expected);
@@ -234,6 +237,49 @@ test_intersect (void)
     }
 }
 
+static void
+test_intersect_hardcoded (void)
+{
+  GtkBitmask *left, *right, *intersection, *expected;
+  const char *left_str, *right_str;
+  guint left_len, right_len;
+  guint i, l, r;
+
+  for (l = 0; l < G_N_ELEMENTS (tests); l++)
+    {
+      for (r = 0; r < G_N_ELEMENTS (tests); r++)
+        {
+          left = masks[l];
+          right = masks[r];
+          left_str = tests[l];
+          right_str = tests[r];
+          left_len = strlen (tests[l]);
+          right_len = strlen (tests[r]);
+
+          expected = _gtk_bitmask_new ();
+          if (left_len > right_len)
+            left_str += left_len - right_len;
+          if (right_len > left_len)
+            right_str += right_len - left_len;
+          i = MIN (right_len, left_len);
+          while (i--)
+            {
+              expected = _gtk_bitmask_set (expected, i, left_str[0] == '1' && right_str[0] == '1');
+              right_str++;
+              left_str++;
+            }
+
+          intersection = _gtk_bitmask_intersect (_gtk_bitmask_copy (left), right);
+
+          assert_cmpmasks (intersection, expected);
+          g_assert_cmpint (_gtk_bitmask_is_empty (expected), ==, !_gtk_bitmask_intersects (left, right));
+
+          _gtk_bitmask_free (intersection);
+          _gtk_bitmask_free (expected);
+        }
+    }
+}
+
 #define SWAP(_a, _b) G_STMT_START{ \
   guint _tmp = _a; \
   _a = _b; \
@@ -265,19 +311,19 @@ test_invert_range (void)
       end = MIN (left_end, right_end);
 
       if (left_start != left_end)
-        _gtk_bitmask_invert_range (left, left_start, left_end);
+        left = _gtk_bitmask_invert_range (left, left_start, left_end);
       if (right_start != right_end)
-        _gtk_bitmask_invert_range (right, right_start, right_end);
+        right = _gtk_bitmask_invert_range (right, right_start, right_end);
       if (start < end)
-        _gtk_bitmask_invert_range (expected, start, end);
+        expected = _gtk_bitmask_invert_range (expected, start, end);
 
       intersection = _gtk_bitmask_copy (left);
-      _gtk_bitmask_intersect (intersection, right);
+      intersection = _gtk_bitmask_intersect (intersection, right);
 
       assert_cmpmasks (intersection, expected);
 
       if (start < end)
-        _gtk_bitmask_invert_range (expected, start, end);
+        expected = _gtk_bitmask_invert_range (expected, start, end);
 
       g_assert_cmpint (_gtk_bitmask_is_empty (expected), ==, TRUE);
 
@@ -328,6 +374,7 @@ main (int argc, char *argv[])
   g_test_add_func ("/bitmask/set", test_set);
   g_test_add_func ("/bitmask/union", test_union);
   g_test_add_func ("/bitmask/intersect", test_intersect);
+  g_test_add_func ("/bitmask/intersect_hardcoded", test_intersect_hardcoded);
   g_test_add_func ("/bitmask/invert_range", test_invert_range);
 
   result = g_test_run ();