forked from AuroraMiddleware/gtk
tests: Add tests for GtkBitmask
This commit is contained in:
Benjamin Otte
parent
45b9193290
commit
eddd36d1d9
@ -134,6 +134,11 @@ rbtree_CFLAGS = -DGTK_COMPILATION -UG_ENABLE_DEBUG
|
||||
rbtree_SOURCES = rbtree.c ../gtkrbtree.h ../gtkrbtree.c
|
||||
rbtree_LDADD = $(GTK_DEP_LIBS)
|
||||
|
||||
TEST_PROGS += bitmask
|
||||
bitmask_CFLAGS = -DGTK_COMPILATION -UG_ENABLE_DEBUG
|
||||
bitmask_SOURCES = bitmask.c ../gtkbitmaskprivate.h ../gtkbitmask.c
|
||||
bitmask_LDADD = $(GTK_DEP_LIBS)
|
||||
|
||||
TEST_PROGS += regression-tests
|
||||
regression_tests_SOURCES = regression-tests.c
|
||||
regression_tests_LDADD = $(progs_ldadd)
|
||||
|
||||
340
gtk/tests/bitmask.c
Normal file
340
gtk/tests/bitmask.c
Normal file
@ -0,0 +1,340 @@
|
||||
/* GtkRBTree tests.
|
||||
*
|
||||
* Copyright (C) 2011, Red Hat, Inc.
|
||||
* Authors: Benjamin Otte <otte@gnome.org>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#include <locale.h>
|
||||
|
||||
#include "../gtkbitmaskprivate.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
/* how often we run the random tests */
|
||||
#define N_RUNS 20
|
||||
|
||||
/* how many tries we do in our random tests */
|
||||
#define N_TRIES 100
|
||||
|
||||
/* the maximum index we use for bitmask values */
|
||||
#define MAX_INDEX 1000
|
||||
|
||||
/* UTILITIES */
|
||||
|
||||
static GtkBitmask *
|
||||
gtk_bitmask_new_parse (const char *string)
|
||||
{
|
||||
guint i, length;
|
||||
GtkBitmask *mask;
|
||||
|
||||
length = strlen (string);
|
||||
mask = _gtk_bitmask_new ();
|
||||
|
||||
for (i = 0; i < length; i++)
|
||||
{
|
||||
if (string[i] == '0')
|
||||
_gtk_bitmask_set (mask, length - i - 1, FALSE);
|
||||
else if (string[i] == '1')
|
||||
_gtk_bitmask_set (mask, length - i - 1, TRUE);
|
||||
else
|
||||
g_assert_not_reached ();
|
||||
}
|
||||
|
||||
return mask;
|
||||
}
|
||||
|
||||
#define assert_cmpmasks(mask,other) G_STMT_START { \
|
||||
if (G_UNLIKELY (!_gtk_bitmask_equals (mask, other))) \
|
||||
{ \
|
||||
char *mask_string = _gtk_bitmask_to_string (mask); \
|
||||
char *other_string = _gtk_bitmask_to_string (other); \
|
||||
char *msg = g_strdup_printf ("%s (%s) != %s (%s)", \
|
||||
G_STRINGIFY (mask), mask_string, \
|
||||
G_STRINGIFY (other), other_string); \
|
||||
g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); \
|
||||
g_free (msg); \
|
||||
g_free (mask_string); \
|
||||
g_free (other_string); \
|
||||
} \
|
||||
}G_STMT_END
|
||||
|
||||
static const char *tests[] = {
|
||||
"0",
|
||||
"1",
|
||||
"1000000000000000000000000000000000000000000000000000000000000000",
|
||||
"10000000000000000000000000000000000000000000000000000000000000000",
|
||||
"1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010",
|
||||
"1000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000",
|
||||
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
|
||||
};
|
||||
|
||||
static GtkBitmask *masks[G_N_ELEMENTS (tests)];
|
||||
|
||||
/* TEST */
|
||||
|
||||
static void
|
||||
test_to_string (void)
|
||||
{
|
||||
guint i;
|
||||
char *to_string;
|
||||
|
||||
for (i = 0; i < G_N_ELEMENTS (tests); i++)
|
||||
{
|
||||
to_string = _gtk_bitmask_to_string (masks[i]);
|
||||
g_assert_cmpstr (to_string, ==, tests[i]);
|
||||
g_free (to_string);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_is_empty (void)
|
||||
{
|
||||
guint i;
|
||||
|
||||
for (i = 0; i < G_N_ELEMENTS (tests); i++)
|
||||
{
|
||||
g_assert_cmpint (_gtk_bitmask_is_empty (masks[i]), ==, i == 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_equals (void)
|
||||
{
|
||||
guint i, j;
|
||||
|
||||
for (i = 0; i < G_N_ELEMENTS (tests); i++)
|
||||
{
|
||||
for (j = 0; j < G_N_ELEMENTS (tests); j++)
|
||||
{
|
||||
g_assert_cmpint (_gtk_bitmask_equals (masks[i], masks[j]), ==, i == j);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_set (void)
|
||||
{
|
||||
guint i, j;
|
||||
guint indexes[N_TRIES];
|
||||
GtkBitmask *copy;
|
||||
const GtkBitmask *mask;
|
||||
|
||||
for (i = 0; i < N_RUNS; i++)
|
||||
{
|
||||
mask = masks[g_test_rand_int_range (0, G_N_ELEMENTS (tests))];
|
||||
copy = _gtk_bitmask_copy (mask);
|
||||
|
||||
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 ());
|
||||
}
|
||||
|
||||
for (j = 0; j < N_TRIES; j++)
|
||||
{
|
||||
_gtk_bitmask_set (copy, indexes[j], _gtk_bitmask_get (mask, indexes[j]));
|
||||
}
|
||||
|
||||
assert_cmpmasks (copy, mask);
|
||||
_gtk_bitmask_free (copy);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_union (void)
|
||||
{
|
||||
GtkBitmask *left, *right, *expected;
|
||||
guint run, try, n_tries;
|
||||
|
||||
for (run = 0; run < N_RUNS; run++)
|
||||
{
|
||||
left = _gtk_bitmask_new ();
|
||||
right = _gtk_bitmask_new ();
|
||||
expected = _gtk_bitmask_new ();
|
||||
|
||||
n_tries = g_test_perf () ? N_TRIES : g_test_rand_int_range (0, N_TRIES);
|
||||
for (try = 0; try < n_tries; try++)
|
||||
{
|
||||
guint id = g_test_rand_int_range (0, MAX_INDEX);
|
||||
|
||||
if (g_test_rand_bit ())
|
||||
_gtk_bitmask_set (left, id, TRUE);
|
||||
else
|
||||
_gtk_bitmask_set (right, id, TRUE);
|
||||
|
||||
_gtk_bitmask_set (expected, id, TRUE);
|
||||
}
|
||||
|
||||
_gtk_bitmask_union (left, right);
|
||||
_gtk_bitmask_union (right, left);
|
||||
|
||||
assert_cmpmasks (left, expected);
|
||||
assert_cmpmasks (right, expected);
|
||||
_gtk_bitmask_free (left);
|
||||
_gtk_bitmask_free (right);
|
||||
_gtk_bitmask_free (expected);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
test_intersect (void)
|
||||
{
|
||||
GtkBitmask *left, *right, *expected;
|
||||
guint run, try;
|
||||
gboolean intersects;
|
||||
|
||||
for (run = 0; run < N_RUNS; run++)
|
||||
{
|
||||
left = _gtk_bitmask_new ();
|
||||
right = _gtk_bitmask_new ();
|
||||
expected = _gtk_bitmask_new ();
|
||||
|
||||
for (try = 0; try < N_TRIES; try++)
|
||||
{
|
||||
guint id = g_test_rand_int_range (0, MAX_INDEX);
|
||||
gboolean set = g_test_rand_bit ();
|
||||
|
||||
if (g_test_rand_bit ())
|
||||
{
|
||||
_gtk_bitmask_set (left, id, set);
|
||||
_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);
|
||||
}
|
||||
}
|
||||
|
||||
intersects = _gtk_bitmask_intersects (left, right);
|
||||
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);
|
||||
|
||||
assert_cmpmasks (left, expected);
|
||||
assert_cmpmasks (right, expected);
|
||||
_gtk_bitmask_free (left);
|
||||
_gtk_bitmask_free (right);
|
||||
_gtk_bitmask_free (expected);
|
||||
}
|
||||
}
|
||||
|
||||
#define SWAP(_a, _b) G_STMT_START{ \
|
||||
guint _tmp = _a; \
|
||||
_a = _b; \
|
||||
_b = _tmp; \
|
||||
}G_STMT_END
|
||||
|
||||
static void
|
||||
test_invert_range (void)
|
||||
{
|
||||
GtkBitmask *left, *right, *intersection, *expected;
|
||||
guint run;
|
||||
guint left_start, left_end, right_start, right_end, start, end;
|
||||
|
||||
for (run = 0; run < N_RUNS; run++)
|
||||
{
|
||||
left = _gtk_bitmask_new ();
|
||||
right = _gtk_bitmask_new ();
|
||||
expected = _gtk_bitmask_new ();
|
||||
|
||||
left_start = g_test_rand_int_range (0, MAX_INDEX);
|
||||
left_end = g_test_rand_int_range (0, MAX_INDEX);
|
||||
if (left_start > left_end)
|
||||
SWAP (left_start, left_end);
|
||||
right_start = g_test_rand_int_range (0, MAX_INDEX);
|
||||
right_end = g_test_rand_int_range (0, MAX_INDEX);
|
||||
if (right_start > right_end)
|
||||
SWAP (right_start, right_end);
|
||||
start = MAX (left_start, right_start);
|
||||
end = MIN (left_end, right_end);
|
||||
|
||||
if (left_start != left_end)
|
||||
_gtk_bitmask_invert_range (left, left_start, left_end);
|
||||
if (right_start != right_end)
|
||||
_gtk_bitmask_invert_range (right, right_start, right_end);
|
||||
if (start < end)
|
||||
_gtk_bitmask_invert_range (expected, start, end);
|
||||
|
||||
intersection = _gtk_bitmask_copy (left);
|
||||
_gtk_bitmask_intersect (intersection, right);
|
||||
|
||||
assert_cmpmasks (intersection, expected);
|
||||
|
||||
if (start < end)
|
||||
_gtk_bitmask_invert_range (expected, start, end);
|
||||
|
||||
g_assert_cmpint (_gtk_bitmask_is_empty (expected), ==, TRUE);
|
||||
|
||||
_gtk_bitmask_free (left);
|
||||
_gtk_bitmask_free (right);
|
||||
_gtk_bitmask_free (intersection);
|
||||
_gtk_bitmask_free (expected);
|
||||
}
|
||||
}
|
||||
|
||||
/* SETUP & RUNNING */
|
||||
|
||||
static void
|
||||
create_masks (void)
|
||||
{
|
||||
guint i;
|
||||
|
||||
for (i = 0; i < G_N_ELEMENTS (tests); i++)
|
||||
masks[i] = gtk_bitmask_new_parse (tests[i]);
|
||||
}
|
||||
|
||||
static void
|
||||
free_masks (void)
|
||||
{
|
||||
guint i;
|
||||
|
||||
for (i = 0; i < G_N_ELEMENTS (tests); i++)
|
||||
{
|
||||
_gtk_bitmask_free (masks[i]);
|
||||
masks[i] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char *argv[])
|
||||
{
|
||||
int result;
|
||||
|
||||
g_test_init (&argc, &argv, NULL);
|
||||
setlocale (LC_ALL, "C");
|
||||
g_test_bug_base ("http://bugzilla.gnome.org/show_bug.cgi?id=%s");
|
||||
|
||||
create_masks ();
|
||||
|
||||
g_test_add_func ("/bitmask/to_string", test_to_string);
|
||||
g_test_add_func ("/bitmask/is_empty", test_is_empty);
|
||||
g_test_add_func ("/bitmask/equals", test_equals);
|
||||
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/invert_range", test_invert_range);
|
||||
|
||||
result = g_test_run ();
|
||||
|
||||
free_masks ();
|
||||
|
||||
return result;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user