luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-26 07:26:15 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'cleanup-warnings-split-4' into 'main'

Browse Source 
Cleanup warnings split 4

See merge request GNOME/glib!2493
This commit is contained in:
Philip Withnall 2022-02-22 08:40:04 +00:00
commit 60bbf27c45
10 changed files with 151 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
glib/tests/dataset.c
View File

@ -179,13 +179,13 @@ test_dataset_id (void)
g_assert (ret == NULL); g_assert (ret == NULL);
} }
static GData *list; static GData *global_list;
static void static void
free_one (gpointer data) free_one (gpointer data)
{ {
/* recurse */ /* recurse */
g_datalist_clear (&list); g_datalist_clear (&global_list);
} }
static void static void
@ -194,11 +194,11 @@ test_datalist_clear (void)
/* Need to use a subprocess because it will deadlock if it fails */ /* Need to use a subprocess because it will deadlock if it fails */
if (g_test_subprocess ()) if (g_test_subprocess ())
{ {
g_datalist_init (&list); g_datalist_init (&global_list);
g_datalist_set_data_full (&list, "one", GINT_TO_POINTER (1), free_one); g_datalist_set_data_full (&global_list, "one", GINT_TO_POINTER (1), free_one);
g_datalist_set_data_full (&list, "two", GINT_TO_POINTER (2), NULL); g_datalist_set_data_full (&global_list, "two", GINT_TO_POINTER (2), NULL);
g_datalist_clear (&list); g_datalist_clear (&global_list);
g_assert (list == NULL); g_assert (global_list == NULL);
return; return;
} }

38
glib/tests/hash.c
View File

@ -34,9 +34,7 @@
#include <glib.h> #include <glib.h>
static int global_array[10000];
int array[10000];
static void static void
fill_hash_table_and_array (GHashTable *hash_table) fill_hash_table_and_array (GHashTable *hash_table)
@ -45,8 +43,8 @@ fill_hash_table_and_array (GHashTable *hash_table)
for (i = 0; i < 10000; i++) for (i = 0; i < 10000; i++)
{ {
array[i] = i; global_array[i] = i;
g_hash_table_insert (hash_table, &array[i], &array[i]); g_hash_table_insert (hash_table, &global_array[i], &global_array[i]);
} }
} }
@ -641,7 +639,7 @@ test_hash_misc (void)
verify_result_array (result_array); verify_result_array (result_array);
for (i = 0; i < 10000; i++) for (i = 0; i < 10000; i++)
g_hash_table_remove (hash_table, &array[i]); g_hash_table_remove (hash_table, &global_array[i]);
fill_hash_table_and_array (hash_table); fill_hash_table_and_array (hash_table);
@ -971,14 +969,14 @@ set_ref_hash_test (void)
key_unref (key2); key_unref (key2);
} }
GHashTable *h; static GHashTable *global_hashtable;
typedef struct { typedef struct {
gchar *string; gchar *string;
gboolean freed; gboolean freed;
} FakeFreeData; } FakeFreeData;
GPtrArray *fake_free_data; static GPtrArray *fake_free_data;
static void static void
fake_free (gpointer dead) fake_free (gpointer dead)
@ -1003,7 +1001,7 @@ fake_free (gpointer dead)
static void static void
value_destroy_insert (gpointer value) value_destroy_insert (gpointer value)
{ {
g_hash_table_remove_all (h); g_hash_table_remove_all (global_hashtable);
} }
static void static void
@ -1016,44 +1014,44 @@ test_destroy_modify (void)
fake_free_data = g_ptr_array_new (); fake_free_data = g_ptr_array_new ();
h = g_hash_table_new_full (g_str_hash, g_str_equal, fake_free, value_destroy_insert); global_hashtable = g_hash_table_new_full (g_str_hash, g_str_equal, fake_free, value_destroy_insert);
ffd = g_new0 (FakeFreeData, 1); ffd = g_new0 (FakeFreeData, 1);
ffd->string = g_strdup ("a"); ffd->string = g_strdup ("a");
g_ptr_array_add (fake_free_data, ffd); g_ptr_array_add (fake_free_data, ffd);
g_hash_table_insert (h, ffd->string, "b"); g_hash_table_insert (global_hashtable, ffd->string, "b");
ffd = g_new0 (FakeFreeData, 1); ffd = g_new0 (FakeFreeData, 1);
ffd->string = g_strdup ("c"); ffd->string = g_strdup ("c");
g_ptr_array_add (fake_free_data, ffd); g_ptr_array_add (fake_free_data, ffd);
g_hash_table_insert (h, ffd->string, "d"); g_hash_table_insert (global_hashtable, ffd->string, "d");
ffd = g_new0 (FakeFreeData, 1); ffd = g_new0 (FakeFreeData, 1);
ffd->string = g_strdup ("e"); ffd->string = g_strdup ("e");
g_ptr_array_add (fake_free_data, ffd); g_ptr_array_add (fake_free_data, ffd);
g_hash_table_insert (h, ffd->string, "f"); g_hash_table_insert (global_hashtable, ffd->string, "f");
ffd = g_new0 (FakeFreeData, 1); ffd = g_new0 (FakeFreeData, 1);
ffd->string = g_strdup ("g"); ffd->string = g_strdup ("g");
g_ptr_array_add (fake_free_data, ffd); g_ptr_array_add (fake_free_data, ffd);
g_hash_table_insert (h, ffd->string, "h"); g_hash_table_insert (global_hashtable, ffd->string, "h");
ffd = g_new0 (FakeFreeData, 1); ffd = g_new0 (FakeFreeData, 1);
ffd->string = g_strdup ("h"); ffd->string = g_strdup ("h");
g_ptr_array_add (fake_free_data, ffd); g_ptr_array_add (fake_free_data, ffd);
g_hash_table_insert (h, ffd->string, "k"); g_hash_table_insert (global_hashtable, ffd->string, "k");
ffd = g_new0 (FakeFreeData, 1); ffd = g_new0 (FakeFreeData, 1);
ffd->string = g_strdup ("a"); ffd->string = g_strdup ("a");
g_ptr_array_add (fake_free_data, ffd); g_ptr_array_add (fake_free_data, ffd);
g_hash_table_insert (h, ffd->string, "c"); g_hash_table_insert (global_hashtable, ffd->string, "c");
g_hash_table_remove (h, "c"); g_hash_table_remove (global_hashtable, "c");
/* that removed everything... */ /* that removed everything... */
for (i = 0; i < fake_free_data->len; i++) for (i = 0; i < fake_free_data->len; i++)
{ {
FakeFreeData *ffd = g_ptr_array_index (fake_free_data, i); ffd = g_ptr_array_index (fake_free_data, i);
g_assert (ffd->freed); g_assert (ffd->freed);
g_free (ffd->string); g_free (ffd->string);
@ -1063,9 +1061,9 @@ test_destroy_modify (void)
g_ptr_array_unref (fake_free_data); g_ptr_array_unref (fake_free_data);
/* ... so this is a no-op */ /* ... so this is a no-op */
g_hash_table_remove (h, "e"); g_hash_table_remove (global_hashtable, "e");
g_hash_table_unref (h); g_hash_table_unref (global_hashtable);
} }
static gboolean static gboolean

4
glib/tests/logging.c
View File

@ -525,9 +525,9 @@ test_structured_logging_roundtrip1 (void)
if (expected_messages != NULL) if (expected_messages != NULL)
{ {
char *str; char *str;
ExpectedMessage *expected = expected_messages->data; ExpectedMessage *msg = expected_messages->data;
str = g_log_writer_format_fields (0, expected->fields, expected->n_fields, FALSE); str = g_log_writer_format_fields (0, msg->fields, msg->n_fields, FALSE);
g_test_fail_printf ("Unexpected message: %s", str); g_test_fail_printf ("Unexpected message: %s", str);
g_free (str); g_free (str);
} }

90
glib/tests/mainloop.c
View File

@ -48,7 +48,7 @@ dispatch (GSource *source, GSourceFunc cb, gpointer date)
return FALSE; return FALSE;
} }
static GSourceFuncs funcs = { static GSourceFuncs global_funcs = {
prepare, prepare,
check, check,
dispatch, dispatch,
@ -63,14 +63,14 @@ test_maincontext_basic (void)
GMainContext *ctx; GMainContext *ctx;
GSource *source; GSource *source;
guint id; guint id;
gpointer data = &funcs; gpointer data = &global_funcs;
ctx = g_main_context_new (); ctx = g_main_context_new ();
g_assert_false (g_main_context_pending (ctx)); g_assert_false (g_main_context_pending (ctx));
g_assert_false (g_main_context_iteration (ctx, FALSE)); g_assert_false (g_main_context_iteration (ctx, FALSE));
source = g_source_new (&funcs, sizeof (GSource)); source = g_source_new (&global_funcs, sizeof (GSource));
g_assert_cmpint (g_source_get_priority (source), ==, G_PRIORITY_DEFAULT); g_assert_cmpint (g_source_get_priority (source), ==, G_PRIORITY_DEFAULT);
g_assert_false (g_source_is_destroyed (source)); g_assert_false (g_source_is_destroyed (source));
@ -87,7 +87,7 @@ test_maincontext_basic (void)
g_assert_cmpstr (g_source_get_name (source), ==, "still d"); g_assert_cmpstr (g_source_get_name (source), ==, "still d");
g_assert_null (g_main_context_find_source_by_user_data (ctx, NULL)); g_assert_null (g_main_context_find_source_by_user_data (ctx, NULL));
g_assert_null (g_main_context_find_source_by_funcs_user_data (ctx, &funcs, NULL)); g_assert_null (g_main_context_find_source_by_funcs_user_data (ctx, &global_funcs, NULL));
id = g_source_attach (source, ctx); id = g_source_attach (source, ctx);
g_assert_cmpint (g_source_get_id (source), ==, id); g_assert_cmpint (g_source_get_id (source), ==, id);
@ -113,18 +113,18 @@ test_maincontext_basic (void)
g_source_unref (source); g_source_unref (source);
ctx = g_main_context_default (); ctx = g_main_context_default ();
source = g_source_new (&funcs, sizeof (GSource)); source = g_source_new (&global_funcs, sizeof (GSource));
g_source_set_funcs (source, &funcs); g_source_set_funcs (source, &global_funcs);
g_source_set_callback (source, cb, data, NULL); g_source_set_callback (source, cb, data, NULL);
id = g_source_attach (source, ctx); id = g_source_attach (source, ctx);
g_source_unref (source); g_source_unref (source);
g_source_set_name_by_id (id, "e"); g_source_set_name_by_id (id, "e");
g_assert_cmpstr (g_source_get_name (source), ==, "e"); g_assert_cmpstr (g_source_get_name (source), ==, "e");
g_assert_true (g_source_get_context (source) == ctx); g_assert_true (g_source_get_context (source) == ctx);
g_assert_true (g_source_remove_by_funcs_user_data (&funcs, data)); g_assert_true (g_source_remove_by_funcs_user_data (&global_funcs, data));
source = g_source_new (&funcs, sizeof (GSource)); source = g_source_new (&global_funcs, sizeof (GSource));
g_source_set_funcs (source, &funcs); g_source_set_funcs (source, &global_funcs);
g_source_set_callback (source, cb, data, NULL); g_source_set_callback (source, cb, data, NULL);
id = g_source_attach (source, ctx); id = g_source_attach (source, ctx);
g_assert_cmpint (id, >, 0); g_assert_cmpint (id, >, 0);
@ -208,9 +208,9 @@ test_ownerless_polling (gconstpointer test_data)
g_main_context_unref (ctx); g_main_context_unref (ctx);
} }
static gint a; static gint global_a;
static gint b; static gint global_b;
static gint c; static gint global_c;
static gboolean static gboolean
count_calls (gpointer data) count_calls (gpointer data)
@ -235,23 +235,23 @@ test_timeouts (void)
return; return;
} }
a = b = c = 0; global_a = global_b = global_c = 0;
ctx = g_main_context_new (); ctx = g_main_context_new ();
loop = g_main_loop_new (ctx, FALSE); loop = g_main_loop_new (ctx, FALSE);
source = g_timeout_source_new (100); source = g_timeout_source_new (100);
g_source_set_callback (source, count_calls, &a, NULL); g_source_set_callback (source, count_calls, &global_a, NULL);
g_source_attach (source, ctx); g_source_attach (source, ctx);
g_source_unref (source); g_source_unref (source);
source = g_timeout_source_new (250); source = g_timeout_source_new (250);
g_source_set_callback (source, count_calls, &b, NULL); g_source_set_callback (source, count_calls, &global_b, NULL);
g_source_attach (source, ctx); g_source_attach (source, ctx);
g_source_unref (source); g_source_unref (source);
source = g_timeout_source_new (330); source = g_timeout_source_new (330);
g_source_set_callback (source, count_calls, &c, NULL); g_source_set_callback (source, count_calls, &global_c, NULL);
g_source_attach (source, ctx); g_source_attach (source, ctx);
g_source_unref (source); g_source_unref (source);
@ -265,13 +265,13 @@ test_timeouts (void)
/* We may be delayed for an arbitrary amount of time - for example, /* We may be delayed for an arbitrary amount of time - for example,
* it's possible for all timeouts to fire exactly once. * it's possible for all timeouts to fire exactly once.
*/ */
g_assert_cmpint (a, >, 0); g_assert_cmpint (global_a, >, 0);
g_assert_cmpint (a, >=, b); g_assert_cmpint (global_a, >=, global_b);
g_assert_cmpint (b, >=, c); g_assert_cmpint (global_b, >=, global_c);
g_assert_cmpint (a, <=, 10); g_assert_cmpint (global_a, <=, 10);
g_assert_cmpint (b, <=, 4); g_assert_cmpint (global_b, <=, 4);
g_assert_cmpint (c, <=, 3); g_assert_cmpint (global_c, <=, 3);
g_main_loop_unref (loop); g_main_loop_unref (loop);
g_main_context_unref (ctx); g_main_context_unref (ctx);
@ -284,36 +284,36 @@ test_priorities (void)
GSource *sourcea; GSource *sourcea;
GSource *sourceb; GSource *sourceb;
a = b = c = 0; global_a = global_b = global_c = 0;
ctx = g_main_context_new (); ctx = g_main_context_new ();
sourcea = g_idle_source_new (); sourcea = g_idle_source_new ();
g_source_set_callback (sourcea, count_calls, &a, NULL); g_source_set_callback (sourcea, count_calls, &global_a, NULL);
g_source_set_priority (sourcea, 1); g_source_set_priority (sourcea, 1);
g_source_attach (sourcea, ctx); g_source_attach (sourcea, ctx);
g_source_unref (sourcea); g_source_unref (sourcea);
sourceb = g_idle_source_new (); sourceb = g_idle_source_new ();
g_source_set_callback (sourceb, count_calls, &b, NULL); g_source_set_callback (sourceb, count_calls, &global_b, NULL);
g_source_set_priority (sourceb, 0); g_source_set_priority (sourceb, 0);
g_source_attach (sourceb, ctx); g_source_attach (sourceb, ctx);
g_source_unref (sourceb); g_source_unref (sourceb);
g_assert_true (g_main_context_pending (ctx)); g_assert_true (g_main_context_pending (ctx));
g_assert_true (g_main_context_iteration (ctx, FALSE)); g_assert_true (g_main_context_iteration (ctx, FALSE));
g_assert_cmpint (a, ==, 0); g_assert_cmpint (global_a, ==, 0);
g_assert_cmpint (b, ==, 1); g_assert_cmpint (global_b, ==, 1);
g_assert_true (g_main_context_iteration (ctx, FALSE)); g_assert_true (g_main_context_iteration (ctx, FALSE));
g_assert_cmpint (a, ==, 0); g_assert_cmpint (global_a, ==, 0);
g_assert_cmpint (b, ==, 2); g_assert_cmpint (global_b, ==, 2);
g_source_destroy (sourceb); g_source_destroy (sourceb);
g_assert_true (g_main_context_iteration (ctx, FALSE)); g_assert_true (g_main_context_iteration (ctx, FALSE));
g_assert_cmpint (a, ==, 1); g_assert_cmpint (global_a, ==, 1);
g_assert_cmpint (b, ==, 2); g_assert_cmpint (global_b, ==, 2);
g_assert_true (g_main_context_pending (ctx)); g_assert_true (g_main_context_pending (ctx));
g_source_destroy (sourcea); g_source_destroy (sourcea);
@ -499,7 +499,7 @@ run_inner_loop (gpointer user_data)
GMainLoop *inner; GMainLoop *inner;
GSource *timeout; GSource *timeout;
a++; global_a++;
inner = g_main_loop_new (ctx, FALSE); inner = g_main_loop_new (ctx, FALSE);
timeout = counter_source_new (100); timeout = counter_source_new (100);
@ -523,7 +523,7 @@ test_child_sources (void)
ctx = g_main_context_new (); ctx = g_main_context_new ();
loop = g_main_loop_new (ctx, FALSE); loop = g_main_loop_new (ctx, FALSE);
a = b = c = 0; global_a = global_b = global_c = 0;
parent = counter_source_new (2000); parent = counter_source_new (2000);
g_source_set_callback (parent, run_inner_loop, ctx, NULL); g_source_set_callback (parent, run_inner_loop, ctx, NULL);
@ -531,11 +531,11 @@ test_child_sources (void)
g_source_attach (parent, ctx); g_source_attach (parent, ctx);
child_b = counter_source_new (250); child_b = counter_source_new (250);
g_source_set_callback (child_b, count_calls, &b, NULL); g_source_set_callback (child_b, count_calls, &global_b, NULL);
g_source_add_child_source (parent, child_b); g_source_add_child_source (parent, child_b);
child_c = counter_source_new (330); child_c = counter_source_new (330);
g_source_set_callback (child_c, count_calls, &c, NULL); g_source_set_callback (child_c, count_calls, &global_c, NULL);
g_source_set_priority (child_c, G_PRIORITY_HIGH); g_source_set_priority (child_c, G_PRIORITY_HIGH);
g_source_add_child_source (parent, child_c); g_source_add_child_source (parent, child_c);
@ -578,9 +578,9 @@ test_child_sources (void)
* 1110 - inner loop ends, a returns, outer loop exits * 1110 - inner loop ends, a returns, outer loop exits
*/ */
g_assert_cmpint (a, ==, 6); g_assert_cmpint (global_a, ==, 6);
g_assert_cmpint (b, ==, 3); g_assert_cmpint (global_b, ==, 3);
g_assert_cmpint (c, ==, 3); g_assert_cmpint (global_c, ==, 3);
g_source_destroy (parent); g_source_destroy (parent);
g_source_unref (parent); g_source_unref (parent);
@ -601,17 +601,17 @@ test_recursive_child_sources (void)
ctx = g_main_context_new (); ctx = g_main_context_new ();
loop = g_main_loop_new (ctx, FALSE); loop = g_main_loop_new (ctx, FALSE);
a = b = c = 0; global_a = global_b = global_c = 0;
parent = counter_source_new (500); parent = counter_source_new (500);
g_source_set_callback (parent, count_calls, &a, NULL); g_source_set_callback (parent, count_calls, &global_a, NULL);
child_b = counter_source_new (220); child_b = counter_source_new (220);
g_source_set_callback (child_b, count_calls, &b, NULL); g_source_set_callback (child_b, count_calls, &global_b, NULL);
g_source_add_child_source (parent, child_b); g_source_add_child_source (parent, child_b);
child_c = counter_source_new (430); child_c = counter_source_new (430);
g_source_set_callback (child_c, count_calls, &c, NULL); g_source_set_callback (child_c, count_calls, &global_c, NULL);
g_source_add_child_source (child_b, child_c); g_source_add_child_source (child_b, child_c);
g_source_attach (parent, ctx); g_source_attach (parent, ctx);
@ -635,9 +635,9 @@ test_recursive_child_sources (void)
* 1940 b (b -> 2160, a -> 2440) * 1940 b (b -> 2160, a -> 2440)
*/ */
g_assert_cmpint (a, ==, 9); g_assert_cmpint (global_a, ==, 9);
g_assert_cmpint (b, ==, 9); g_assert_cmpint (global_b, ==, 9);
g_assert_cmpint (c, ==, 4); g_assert_cmpint (global_c, ==, 4);
g_source_destroy (parent); g_source_destroy (parent);
g_source_unref (parent); g_source_unref (parent);

117
glib/tests/node.c
View File

@ -31,9 +31,6 @@
#include "glib.h" #include "glib.h"
#define C2P(c) ((gpointer) ((long) (c)))
#define P2C(p) ((gchar) ((long) (p)))
typedef struct { typedef struct {
GString *s; GString *s;
gint count; gint count;
@ -45,7 +42,7 @@ node_build_string (GNode *node,
{ {
CallbackData *d = data; CallbackData *d = data;
g_string_append_c (d->s, P2C (node->data)); g_string_append_c (d->s, GPOINTER_TO_INT (node->data));
d->count--; d->count--;
@ -171,22 +168,22 @@ traversal_test (void)
gsize i; gsize i;
CallbackData data; CallbackData data;
root = g_node_new (C2P ('A')); root = g_node_new (GINT_TO_POINTER ('A'));
node_B = g_node_new (C2P ('B')); node_B = g_node_new (GINT_TO_POINTER ('B'));
g_node_append (root, node_B); g_node_append (root, node_B);
g_node_append_data (node_B, C2P ('E')); g_node_append_data (node_B, GINT_TO_POINTER ('E'));
g_node_prepend_data (node_B, C2P ('C')); g_node_prepend_data (node_B, GINT_TO_POINTER ('C'));
node_D = g_node_new (C2P ('D')); node_D = g_node_new (GINT_TO_POINTER ('D'));
g_node_insert (node_B, 1, node_D); g_node_insert (node_B, 1, node_D);
node_F = g_node_new (C2P ('F')); node_F = g_node_new (GINT_TO_POINTER ('F'));
g_node_append (root, node_F); g_node_append (root, node_F);
node_G = g_node_new (C2P ('G')); node_G = g_node_new (GINT_TO_POINTER ('G'));
g_node_append (node_F, node_G); g_node_append (node_F, node_G);
node_J = g_node_new (C2P ('J')); node_J = g_node_new (GINT_TO_POINTER ('J'));
g_node_prepend (node_G, node_J); g_node_prepend (node_G, node_J);
g_node_insert (node_G, 42, g_node_new (C2P ('K'))); g_node_insert (node_G, 42, g_node_new (GINT_TO_POINTER ('K')));
g_node_insert_data (node_G, 0, C2P ('H')); g_node_insert_data (node_G, 0, GINT_TO_POINTER ('H'));
g_node_insert (node_G, 1, g_node_new (C2P ('I'))); g_node_insert (node_G, 1, g_node_new (GINT_TO_POINTER ('I')));
/* we have built: A /* we have built: A
* / \ * / \
@ -227,8 +224,8 @@ traversal_test (void)
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &data); g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &data);
g_assert_cmpstr (data.s->str, ==, "ABFEDCGKJIH"); g_assert_cmpstr (data.s->str, ==, "ABFEDCGKJIH");
g_node_append (node_D, g_node_new (C2P ('L'))); g_node_append (node_D, g_node_new (GINT_TO_POINTER ('L')));
g_node_insert (node_D, -1, g_node_new (C2P ('M'))); g_node_insert (node_D, -1, g_node_new (GINT_TO_POINTER ('M')));
g_string_set_size (data.s, 0); g_string_set_size (data.s, 0);
data.count = -1; data.count = -1;
@ -252,31 +249,31 @@ construct_test (void)
GNode *node_H; GNode *node_H;
guint i; guint i;
root = g_node_new (C2P ('A')); root = g_node_new (GINT_TO_POINTER ('A'));
g_assert_cmpint (g_node_depth (root), ==, 1); g_assert_cmpint (g_node_depth (root), ==, 1);
g_assert_cmpint (g_node_max_height (root), ==, 1); g_assert_cmpint (g_node_max_height (root), ==, 1);
node_B = g_node_new (C2P ('B')); node_B = g_node_new (GINT_TO_POINTER ('B'));
g_node_append (root, node_B); g_node_append (root, node_B);
g_assert (root->children == node_B); g_assert (root->children == node_B);
g_node_append_data (node_B, C2P ('E')); g_node_append_data (node_B, GINT_TO_POINTER ('E'));
g_node_prepend_data (node_B, C2P ('C')); g_node_prepend_data (node_B, GINT_TO_POINTER ('C'));
node_D = g_node_new (C2P ('D')); node_D = g_node_new (GINT_TO_POINTER ('D'));
g_node_insert (node_B, 1, node_D); g_node_insert (node_B, 1, node_D);
node_F = g_node_new (C2P ('F')); node_F = g_node_new (GINT_TO_POINTER ('F'));
g_node_append (root, node_F); g_node_append (root, node_F);
g_assert (root->children->next == node_F); g_assert (root->children->next == node_F);
node_G = g_node_new (C2P ('G')); node_G = g_node_new (GINT_TO_POINTER ('G'));
g_node_append (node_F, node_G); g_node_append (node_F, node_G);
node_J = g_node_new (C2P ('J')); node_J = g_node_new (GINT_TO_POINTER ('J'));
g_node_insert_after (node_G, NULL, node_J); g_node_insert_after (node_G, NULL, node_J);
g_node_insert (node_G, 42, g_node_new (C2P ('K'))); g_node_insert (node_G, 42, g_node_new (GINT_TO_POINTER ('K')));
node_H = g_node_new (C2P ('H')); node_H = g_node_new (GINT_TO_POINTER ('H'));
g_node_insert_after (node_G, NULL, node_H); g_node_insert_after (node_G, NULL, node_H);
g_node_insert (node_G, 1, g_node_new (C2P ('I'))); g_node_insert (node_G, 1, g_node_new (GINT_TO_POINTER ('I')));
/* we have built: A /* we have built: A
* / \ * / \
@ -294,16 +291,16 @@ construct_test (void)
g_assert_cmpint (g_node_n_nodes (root, G_TRAVERSE_ALL), ==, 11); g_assert_cmpint (g_node_n_nodes (root, G_TRAVERSE_ALL), ==, 11);
g_assert_cmpint (g_node_max_height (node_F), ==, 3); g_assert_cmpint (g_node_max_height (node_F), ==, 3);
g_assert_cmpint (g_node_n_children (node_G), ==, 4); g_assert_cmpint (g_node_n_children (node_G), ==, 4);
g_assert (g_node_find_child (root, G_TRAVERSE_ALL, C2P ('F')) == node_F); g_assert (g_node_find_child (root, G_TRAVERSE_ALL, GINT_TO_POINTER ('F')) == node_F);
g_assert (g_node_find_child (node_G, G_TRAVERSE_LEAFS, C2P ('H')) == node_H); g_assert (g_node_find_child (node_G, G_TRAVERSE_LEAFS, GINT_TO_POINTER ('H')) == node_H);
g_assert (g_node_find_child (root, G_TRAVERSE_ALL, C2P ('H')) == NULL); g_assert (g_node_find_child (root, G_TRAVERSE_ALL, GINT_TO_POINTER ('H')) == NULL);
g_assert (g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, C2P ('I')) == NULL); g_assert (g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, GINT_TO_POINTER ('I')) == NULL);
g_assert (g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, C2P ('J')) == node_J); g_assert (g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, GINT_TO_POINTER ('J')) == node_J);
for (i = 0; i < g_node_n_children (node_B); i++) for (i = 0; i < g_node_n_children (node_B); i++)
{ {
node = g_node_nth_child (node_B, i); node = g_node_nth_child (node_B, i);
g_assert_cmpint (P2C (node->data), ==, ('C' + i)); g_assert_cmpint (GPOINTER_TO_INT (node->data), ==, ('C' + i));
} }
for (i = 0; i < g_node_n_children (node_G); i++) for (i = 0; i < g_node_n_children (node_G); i++)
@ -345,14 +342,14 @@ misc_test (void)
GNode *node_E; GNode *node_E;
CallbackData data; CallbackData data;
root = g_node_new (C2P ('A')); root = g_node_new (GINT_TO_POINTER ('A'));
node_B = g_node_new (C2P ('B')); node_B = g_node_new (GINT_TO_POINTER ('B'));
g_node_append (root, node_B); g_node_append (root, node_B);
node_D = g_node_new (C2P ('D')); node_D = g_node_new (GINT_TO_POINTER ('D'));
g_node_append (root, node_D); g_node_append (root, node_D);
node_C = g_node_new (C2P ('C')); node_C = g_node_new (GINT_TO_POINTER ('C'));
g_node_insert_after (root, node_B, node_C); g_node_insert_after (root, node_B, node_C);
node_E = g_node_new (C2P ('E')); node_E = g_node_new (GINT_TO_POINTER ('E'));
g_node_append (node_C, node_E); g_node_append (node_C, node_E);
g_assert (g_node_get_root (node_E) == root); g_assert (g_node_get_root (node_E) == root);
@ -362,10 +359,10 @@ misc_test (void)
g_assert (g_node_first_sibling (node_D) == node_B); g_assert (g_node_first_sibling (node_D) == node_B);
g_assert (g_node_first_sibling (node_E) == node_E); g_assert (g_node_first_sibling (node_E) == node_E);
g_assert (g_node_first_sibling (root) == root); g_assert (g_node_first_sibling (root) == root);
g_assert_cmpint (g_node_child_index (root, C2P ('B')), ==, 0); g_assert_cmpint (g_node_child_index (root, GINT_TO_POINTER ('B')), ==, 0);
g_assert_cmpint (g_node_child_index (root, C2P ('C')), ==, 1); g_assert_cmpint (g_node_child_index (root, GINT_TO_POINTER ('C')), ==, 1);
g_assert_cmpint (g_node_child_index (root, C2P ('D')), ==, 2); g_assert_cmpint (g_node_child_index (root, GINT_TO_POINTER ('D')), ==, 2);
g_assert_cmpint (g_node_child_index (root, C2P ('E')), ==, -1); g_assert_cmpint (g_node_child_index (root, GINT_TO_POINTER ('E')), ==, -1);
data.s = g_string_new (""); data.s = g_string_new ("");
data.count = -1; data.count = -1;
@ -418,21 +415,21 @@ unlink_test (void)
* *
*/ */
root = g_node_new (C2P ('a')); root = g_node_new (GINT_TO_POINTER ('a'));
node = bnode = g_node_append_data (root, C2P ('b')); node = bnode = g_node_append_data (root, GINT_TO_POINTER ('b'));
g_node_append_data (node, C2P ('e')); g_node_append_data (node, GINT_TO_POINTER ('e'));
g_node_append_data (node, C2P ('f')); g_node_append_data (node, GINT_TO_POINTER ('f'));
g_node_append_data (node, C2P ('g')); g_node_append_data (node, GINT_TO_POINTER ('g'));
node = cnode = g_node_append_data (root, C2P ('c')); node = cnode = g_node_append_data (root, GINT_TO_POINTER ('c'));
g_node_append_data (node, C2P ('h')); g_node_append_data (node, GINT_TO_POINTER ('h'));
g_node_append_data (node, C2P ('i')); g_node_append_data (node, GINT_TO_POINTER ('i'));
g_node_append_data (node, C2P ('j')); g_node_append_data (node, GINT_TO_POINTER ('j'));
node = g_node_append_data (root, C2P ('d')); node = g_node_append_data (root, GINT_TO_POINTER ('d'));
g_node_append_data (node, C2P ('k')); g_node_append_data (node, GINT_TO_POINTER ('k'));
g_node_append_data (node, C2P ('l')); g_node_append_data (node, GINT_TO_POINTER ('l'));
g_node_append_data (node, C2P ('m')); g_node_append_data (node, GINT_TO_POINTER ('m'));
g_node_unlink (cnode); g_node_unlink (cnode);
@ -473,10 +470,10 @@ copy_test (void)
GNode *copy; GNode *copy;
gchar *expected; gchar *expected;
root = g_node_new (C2P ('a')); root = g_node_new (GINT_TO_POINTER ('a'));
g_node_append_data (root, C2P ('b')); g_node_append_data (root, GINT_TO_POINTER ('b'));
g_node_append_data (root, C2P ('c')); g_node_append_data (root, GINT_TO_POINTER ('c'));
g_node_append_data (root, C2P ('d')); g_node_append_data (root, GINT_TO_POINTER ('d'));
expected = "abcd"; expected = "abcd";
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, check_order, &expected); g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, check_order, &expected);

9
glib/tests/option-context.c
View File

@ -28,15 +28,14 @@
#include <locale.h> #include <locale.h>
#include <math.h> #include <math.h>
static GOptionEntry global_main_entries[] = {
static GOptionEntry main_entries[] = {
{ "main-switch", 0, 0, { "main-switch", 0, 0,
G_OPTION_ARG_NONE, NULL, G_OPTION_ARG_NONE, NULL,
"A switch that is in the main group", NULL }, "A switch that is in the main group", NULL },
G_OPTION_ENTRY_NULL G_OPTION_ENTRY_NULL
}; };
static GOptionEntry group_entries[] = { static GOptionEntry global_group_entries[] = {
{ "test-switch", 0, 0, { "test-switch", 0, 0,
G_OPTION_ARG_NONE, NULL, G_OPTION_ARG_NONE, NULL,
"A switch that is in the test group", NULL }, "A switch that is in the test group", NULL },
@ -54,14 +53,14 @@ make_options (int test_number)
options = g_option_context_new (NULL); options = g_option_context_new (NULL);
if (have_main_entries) if (have_main_entries)
g_option_context_add_main_entries (options, main_entries, NULL); g_option_context_add_main_entries (options, global_main_entries, NULL);
if (have_test_entries) if (have_test_entries)
{ {
group = g_option_group_new ("test", "Test Options", group = g_option_group_new ("test", "Test Options",
"Show all test options", "Show all test options",
NULL, NULL); NULL, NULL);
g_option_context_add_group (options, group); g_option_context_add_group (options, group);
g_option_group_add_entries (group, group_entries); g_option_group_add_entries (group, global_group_entries);
} }
return options; return options;

11
glib/tests/sequence.c
View File

@ -544,8 +544,6 @@ run_random_tests (gconstpointer d)
break; break;
case GET_ITER_AT_POS: case GET_ITER_AT_POS:
{ {
int i;
g_assert (g_queue_get_length (seq->queue) == (guint) g_sequence_get_length (seq->sequence)); g_assert (g_queue_get_length (seq->queue) == (guint) g_sequence_get_length (seq->sequence));
for (i = 0; i < 10; ++i) for (i = 0; i < 10; ++i)
@ -660,7 +658,6 @@ run_random_tests (gconstpointer d)
break; break;
case INSERT_SORTED: case INSERT_SORTED:
{ {
int i;
dump_info (seq); dump_info (seq);
g_sequence_sort (seq->sequence, compare_items, NULL); g_sequence_sort (seq->sequence, compare_items, NULL);
@ -683,7 +680,6 @@ run_random_tests (gconstpointer d)
break; break;
case INSERT_SORTED_ITER: case INSERT_SORTED_ITER:
{ {
int i;
dump_info (seq); dump_info (seq);
g_sequence_sort (seq->sequence, compare_items, NULL); g_sequence_sort (seq->sequence, compare_items, NULL);
@ -710,8 +706,6 @@ run_random_tests (gconstpointer d)
break; break;
case SORT_CHANGED: case SORT_CHANGED:
{ {
int i;
g_sequence_sort (seq->sequence, compare_items, NULL); g_sequence_sort (seq->sequence, compare_items, NULL);
g_queue_sort (seq->queue, compare_iters, NULL); g_queue_sort (seq->queue, compare_iters, NULL);
@ -737,8 +731,6 @@ run_random_tests (gconstpointer d)
break; break;
case SORT_CHANGED_ITER: case SORT_CHANGED_ITER:
{ {
int i;
g_sequence_sort (seq->sequence, compare_items, NULL); g_sequence_sort (seq->sequence, compare_items, NULL);
g_queue_sort (seq->queue, compare_iters, NULL); g_queue_sort (seq->queue, compare_iters, NULL);
@ -765,8 +757,6 @@ run_random_tests (gconstpointer d)
break; break;
case REMOVE: case REMOVE:
{ {
int i;
for (i = 0; i < N_TIMES; ++i) for (i = 0; i < N_TIMES; ++i)
{ {
GList *link; GList *link;
@ -958,7 +948,6 @@ run_random_tests (gconstpointer d)
if (!g_sequence_iter_is_end (iter)) if (!g_sequence_iter_is_end (iter))
{ {
Item *item; Item *item;
int i;
check_integrity (seq); check_integrity (seq);

24
glib/tests/spawn-multithreaded.c
View File

@ -40,11 +40,11 @@ static char *echo_prog_path;
#include <windows.h> #include <windows.h>
#endif #endif
GMainLoop *main_loop; static GMainLoop *global_main_loop;
guint alive; static guint alive;
#ifdef G_OS_WIN32 #ifdef G_OS_WIN32
char *argv0; static char *argv0;
#endif #endif
static GPid static GPid
@ -98,7 +98,7 @@ child_watch_callback (GPid pid, gint status, gpointer data)
g_spawn_close_pid (pid); g_spawn_close_pid (pid);
if (--alive == 0) if (--alive == 0)
g_main_loop_quit (main_loop); g_main_loop_quit (global_main_loop);
return TRUE; return TRUE;
} }
@ -142,7 +142,7 @@ test_spawn_childs (void)
{ {
GPid pid; GPid pid;
main_loop = g_main_loop_new (NULL, FALSE); global_main_loop = g_main_loop_new (NULL, FALSE);
#ifdef G_OS_WIN32 #ifdef G_OS_WIN32
system ("ipconfig /all"); system ("ipconfig /all");
@ -151,7 +151,7 @@ test_spawn_childs (void)
#endif #endif
alive = 2; alive = 2;
g_timeout_add_seconds (30, quit_loop, main_loop); g_timeout_add_seconds (30, quit_loop, global_main_loop);
pid = get_a_child (10); pid = get_a_child (10);
g_child_watch_add (pid, (GChildWatchFunc) child_watch_callback, g_child_watch_add (pid, (GChildWatchFunc) child_watch_callback,
@ -160,8 +160,8 @@ test_spawn_childs (void)
g_child_watch_add (pid, (GChildWatchFunc) child_watch_callback, g_child_watch_add (pid, (GChildWatchFunc) child_watch_callback,
GINT_TO_POINTER (7)); GINT_TO_POINTER (7));
g_main_loop_run (main_loop); g_main_loop_run (global_main_loop);
g_main_loop_unref (main_loop); g_main_loop_unref (global_main_loop);
g_assert_cmpint (alive, ==, 0); g_assert_cmpint (alive, ==, 0);
} }
@ -169,7 +169,7 @@ test_spawn_childs (void)
static void static void
test_spawn_childs_threads (void) test_spawn_childs_threads (void)
{ {
main_loop = g_main_loop_new (NULL, FALSE); global_main_loop = g_main_loop_new (NULL, FALSE);
#ifdef G_OS_WIN32 #ifdef G_OS_WIN32
system ("ipconfig /all"); system ("ipconfig /all");
@ -178,13 +178,13 @@ test_spawn_childs_threads (void)
#endif #endif
alive = 2; alive = 2;
g_timeout_add_seconds (30, quit_loop, main_loop); g_timeout_add_seconds (30, quit_loop, global_main_loop);
g_thread_new (NULL, start_thread, GINT_TO_POINTER (3)); g_thread_new (NULL, start_thread, GINT_TO_POINTER (3));
g_thread_new (NULL, start_thread, GINT_TO_POINTER (7)); g_thread_new (NULL, start_thread, GINT_TO_POINTER (7));
g_main_loop_run (main_loop); g_main_loop_run (global_main_loop);
g_main_loop_unref (main_loop); g_main_loop_unref (global_main_loop);
g_assert_cmpint (alive, ==, 0); g_assert_cmpint (alive, ==, 0);
} }

7
glib/tests/strfuncs.c
View File

@ -2440,15 +2440,14 @@ test_ascii_string_to_number_usual (void)
case UNSIGNED: case UNSIGNED:
{ {
guint64 value64 = 0;
result = g_ascii_string_to_unsigned (data->str, result = g_ascii_string_to_unsigned (data->str,
data->base, data->base,
data->min, data->min,
data->max, data->max,
&value64, &valueu64,
&error); &error);
value = value64; value = valueu64;
g_assert_cmpint (value, ==, value64); g_assert_cmpint (value, ==, valueu64);
break; break;
} }

6
glib/tests/utf8-validate.c
View File

@ -32,7 +32,7 @@ typedef struct {
gboolean valid; gboolean valid;
} Test; } Test;
Test test[] = { static Test global_test[] = {
/* some tests to check max_len handling */ /* some tests to check max_len handling */
/* length 1 */ /* length 1 */
{ "abcde", -1, 5, TRUE }, { "abcde", -1, 5, TRUE },
@ -364,10 +364,10 @@ main (int argc, char *argv[])
g_test_init (&argc, &argv, NULL); g_test_init (&argc, &argv, NULL);
for (i = 0; test[i].text; i++) for (i = 0; global_test[i].text; i++)
{ {
path = g_strdup_printf ("/utf8/validate/%d", i); path = g_strdup_printf ("/utf8/validate/%d", i);
g_test_add_data_func (path, &test[i], do_test); g_test_add_data_func (path, &global_test[i], do_test);
g_free (path); g_free (path);
} }