Branch data Line data Source code
1 : : #include <glib.h>
2 : :
3 : : #define SIZE 50
4 : : #define NUMBER_MIN 0000
5 : : #define NUMBER_MAX 9999
6 : :
7 : :
8 : : static guint32 array[SIZE];
9 : :
10 : :
11 : : static gint
12 : 1654 : sort (gconstpointer p1, gconstpointer p2)
13 : : {
14 : : gint32 a, b;
15 : :
16 : 1654 : a = GPOINTER_TO_INT (p1);
17 : 1654 : b = GPOINTER_TO_INT (p2);
18 : :
19 [ + + - + ]: 1654 : return (a > b ? +1 : a == b ? 0 : -1);
20 : : }
21 : :
22 : : /*
23 : : * gslist sort tests
24 : : */
25 : : static void
26 : 1 : test_slist_sort (void)
27 : : {
28 : 1 : GSList *slist = NULL;
29 : : gint i;
30 : :
31 [ + + ]: 51 : for (i = 0; i < SIZE; i++)
32 : 50 : slist = g_slist_append (slist, GINT_TO_POINTER (array[i]));
33 : :
34 : 1 : slist = g_slist_sort (slist, sort);
35 [ + + ]: 50 : for (i = 0; i < SIZE - 1; i++)
36 : : {
37 : : gpointer p1, p2;
38 : :
39 : 49 : p1 = g_slist_nth_data (slist, i);
40 : 49 : p2 = g_slist_nth_data (slist, i+1);
41 : :
42 : 49 : g_assert (GPOINTER_TO_INT (p1) <= GPOINTER_TO_INT (p2));
43 : : }
44 : :
45 : 1 : g_slist_free (slist);
46 : 1 : }
47 : :
48 : : static void
49 : 1 : test_slist_sort_with_data (void)
50 : : {
51 : 1 : GSList *slist = NULL;
52 : : gint i;
53 : :
54 [ + + ]: 51 : for (i = 0; i < SIZE; i++)
55 : 50 : slist = g_slist_append (slist, GINT_TO_POINTER (array[i]));
56 : :
57 : 1 : slist = g_slist_sort_with_data (slist, (GCompareDataFunc)sort, NULL);
58 [ + + ]: 50 : for (i = 0; i < SIZE - 1; i++)
59 : : {
60 : : gpointer p1, p2;
61 : :
62 : 49 : p1 = g_slist_nth_data (slist, i);
63 : 49 : p2 = g_slist_nth_data (slist, i+1);
64 : :
65 : 49 : g_assert (GPOINTER_TO_INT (p1) <= GPOINTER_TO_INT (p2));
66 : : }
67 : :
68 : 1 : g_slist_free (slist);
69 : 1 : }
70 : :
71 : : /* Test that the sort is stable. */
72 : : static void
73 : 1 : test_slist_sort_stable (void)
74 : : {
75 : 1 : GSList *list = NULL; /* (element-type utf8) */
76 : 1 : GSList *copy = NULL; /* (element-type utf8) */
77 : : gsize i;
78 : :
79 : : /* Build a test list, already ordered. */
80 [ + + ]: 51 : for (i = 0; i < SIZE; i++)
81 : 50 : list = g_slist_append (list, g_strdup_printf ("%" G_GSIZE_FORMAT, i / 5));
82 : :
83 : : /* Take a copy and sort it. */
84 : 1 : copy = g_slist_copy (list);
85 : 1 : copy = g_slist_sort (copy, (GCompareFunc) g_strcmp0);
86 : :
87 : : /* Compare the two lists, checking pointers are equal to ensure the elements
88 : : * have been kept stable. */
89 [ + + ]: 51 : for (i = 0; i < SIZE; i++)
90 : : {
91 : : gpointer p1, p2;
92 : :
93 : 50 : p1 = g_slist_nth_data (list, i);
94 : 50 : p2 = g_slist_nth_data (list, i);
95 : :
96 : 50 : g_assert (p1 == p2);
97 : : }
98 : :
99 : 1 : g_slist_free (copy);
100 : 1 : g_slist_free_full (list, g_free);
101 : 1 : }
102 : :
103 : : static void
104 : 1 : test_slist_insert_sorted (void)
105 : : {
106 : 1 : GSList *slist = NULL;
107 : : gint i;
108 : :
109 [ + + ]: 51 : for (i = 0; i < SIZE; i++)
110 : 50 : slist = g_slist_insert_sorted (slist, GINT_TO_POINTER (array[i]), sort);
111 : :
112 [ + + ]: 50 : for (i = 0; i < SIZE - 1; i++)
113 : : {
114 : : gpointer p1, p2;
115 : :
116 : 49 : p1 = g_slist_nth_data (slist, i);
117 : 49 : p2 = g_slist_nth_data (slist, i+1);
118 : :
119 : 49 : g_assert (GPOINTER_TO_INT (p1) <= GPOINTER_TO_INT (p2));
120 : : }
121 : :
122 : 1 : g_slist_free (slist);
123 : 1 : }
124 : :
125 : : static void
126 : 1 : test_slist_insert_sorted_with_data (void)
127 : : {
128 : 1 : GSList *slist = NULL;
129 : : gint i;
130 : :
131 [ + + ]: 51 : for (i = 0; i < SIZE; i++)
132 : 50 : slist = g_slist_insert_sorted_with_data (slist,
133 : 50 : GINT_TO_POINTER (array[i]),
134 : : (GCompareDataFunc)sort,
135 : : NULL);
136 : :
137 [ + + ]: 50 : for (i = 0; i < SIZE - 1; i++)
138 : : {
139 : : gpointer p1, p2;
140 : :
141 : 49 : p1 = g_slist_nth_data (slist, i);
142 : 49 : p2 = g_slist_nth_data (slist, i+1);
143 : :
144 : 49 : g_assert (GPOINTER_TO_INT (p1) <= GPOINTER_TO_INT (p2));
145 : : }
146 : :
147 : 1 : g_slist_free (slist);
148 : 1 : }
149 : :
150 : : static void
151 : 1 : test_slist_reverse (void)
152 : : {
153 : 1 : GSList *slist = NULL;
154 : : GSList *st;
155 : 1 : gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
156 : : gint i;
157 : :
158 [ + + ]: 11 : for (i = 0; i < 10; i++)
159 : 10 : slist = g_slist_append (slist, &nums[i]);
160 : :
161 : 1 : slist = g_slist_reverse (slist);
162 : :
163 [ + + ]: 11 : for (i = 0; i < 10; i++)
164 : : {
165 : 10 : st = g_slist_nth (slist, i);
166 : 10 : g_assert (*((gint*) st->data) == (9 - i));
167 : : }
168 : :
169 : 1 : g_slist_free (slist);
170 : 1 : }
171 : :
172 : : static void
173 : 1 : test_slist_nth (void)
174 : : {
175 : 1 : GSList *slist = NULL;
176 : : GSList *st;
177 : 1 : gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
178 : : gint i;
179 : :
180 [ + + ]: 11 : for (i = 0; i < 10; i++)
181 : 10 : slist = g_slist_append (slist, &nums[i]);
182 : :
183 [ + + ]: 11 : for (i = 0; i < 10; i++)
184 : : {
185 : 10 : st = g_slist_nth (slist, i);
186 : 10 : g_assert (*((gint*) st->data) == i);
187 : : }
188 : :
189 : 1 : g_slist_free (slist);
190 : 1 : }
191 : :
192 : : static void
193 : 1 : test_slist_remove (void)
194 : : {
195 : 1 : GSList *slist = NULL;
196 : : GSList *st;
197 : 1 : gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
198 : : gint i;
199 : :
200 [ + + ]: 11 : for (i = 0; i < 10; i++)
201 : : {
202 : 10 : slist = g_slist_append (slist, &nums[i]);
203 : 10 : slist = g_slist_append (slist, &nums[i]);
204 : : }
205 : :
206 : 1 : g_assert_cmpint (g_slist_length (slist), ==, 20);
207 : :
208 [ + + ]: 11 : for (i = 0; i < 10; i++)
209 : : {
210 : 10 : slist = g_slist_remove (slist, &nums[i]);
211 : : }
212 : :
213 : 1 : g_assert_cmpint (g_slist_length (slist), ==, 10);
214 : :
215 [ + + ]: 11 : for (i = 0; i < 10; i++)
216 : : {
217 : 10 : st = g_slist_nth (slist, i);
218 : 10 : g_assert (*((gint*) st->data) == i);
219 : : }
220 : :
221 : 1 : g_slist_free (slist);
222 : 1 : }
223 : :
224 : : static void
225 : 1 : test_slist_remove_all (void)
226 : : {
227 : 1 : GSList *slist = NULL;
228 : 1 : gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
229 : : gint i;
230 : :
231 [ + + ]: 11 : for (i = 0; i < 10; i++)
232 : : {
233 : 10 : slist = g_slist_append (slist, &nums[i]);
234 : 10 : slist = g_slist_append (slist, &nums[i]);
235 : : }
236 : :
237 : 1 : g_assert_cmpint (g_slist_length (slist), ==, 20);
238 : :
239 [ + + ]: 6 : for (i = 0; i < 5; i++)
240 : : {
241 : 5 : slist = g_slist_remove_all (slist, &nums[2 * i + 1]);
242 : 5 : slist = g_slist_remove_all (slist, &nums[8 - 2 * i]);
243 : : }
244 : :
245 : 1 : g_assert_cmpint (g_slist_length (slist), ==, 0);
246 : 1 : g_assert (slist == NULL);
247 : 1 : }
248 : :
249 : : static void
250 : 1 : test_slist_insert (void)
251 : : {
252 : 1 : gpointer a = "a";
253 : 1 : gpointer b = "b";
254 : 1 : gpointer c = "c";
255 : 1 : GSList *slist = NULL;
256 : : GSList *st;
257 : 1 : gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
258 : : gint i;
259 : :
260 : 1 : slist = g_slist_insert_before (NULL, NULL, &nums[1]);
261 : 1 : slist = g_slist_insert (slist, &nums[3], 1);
262 : 1 : slist = g_slist_insert (slist, &nums[4], -1);
263 : 1 : slist = g_slist_insert (slist, &nums[0], 0);
264 : 1 : slist = g_slist_insert (slist, &nums[5], 100);
265 : 1 : slist = g_slist_insert_before (slist, NULL, &nums[6]);
266 : 1 : slist = g_slist_insert_before (slist, slist->next->next, &nums[2]);
267 : :
268 : 1 : slist = g_slist_insert (slist, &nums[9], 7);
269 : 1 : slist = g_slist_insert (slist, &nums[8], 7);
270 : 1 : slist = g_slist_insert (slist, &nums[7], 7);
271 : :
272 [ + + ]: 11 : for (i = 0; i < 10; i++)
273 : : {
274 : 10 : st = g_slist_nth (slist, i);
275 : 10 : g_assert (*((gint*) st->data) == i);
276 : : }
277 : :
278 : 1 : g_slist_free (slist);
279 : :
280 : 1 : slist = g_slist_insert (NULL, a, 1);
281 : 1 : g_assert (slist->data == a);
282 : 1 : g_assert (slist->next == NULL);
283 : 1 : g_slist_free (slist);
284 : :
285 : 1 : slist = g_slist_append (NULL, a);
286 : 1 : slist = g_slist_append (slist, b);
287 : 1 : slist = g_slist_insert (slist, c, 5);
288 : :
289 : 1 : g_assert (slist->next->next->data == c);
290 : 1 : g_assert (slist->next->next->next == NULL);
291 : 1 : g_slist_free (slist);
292 : :
293 : 1 : slist = g_slist_append (NULL, a);
294 : 1 : slist = g_slist_insert_before (slist, slist, b);
295 : 1 : g_assert (slist->data == b);
296 : 1 : g_assert (slist->next->data == a);
297 : 1 : g_assert (slist->next->next == NULL);
298 : 1 : g_slist_free (slist);
299 : 1 : }
300 : :
301 : : static gint
302 : 65 : find_num (gconstpointer l, gconstpointer data)
303 : : {
304 : 65 : return *(gint*)l - GPOINTER_TO_INT(data);
305 : : }
306 : :
307 : : static void
308 : 1 : test_slist_position (void)
309 : : {
310 : 1 : GSList *slist = NULL;
311 : : GSList *st;
312 : 1 : gint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
313 : : gint i;
314 : :
315 [ + + ]: 11 : for (i = 0; i < 10; i++)
316 : : {
317 : 10 : slist = g_slist_append (slist, &nums[i]);
318 : : }
319 : :
320 : 1 : g_assert_cmpint (g_slist_index (slist, NULL), ==, -1);
321 : 1 : g_assert_cmpint (g_slist_position (slist, NULL), ==, -1);
322 : :
323 [ + + ]: 11 : for (i = 0; i < 10; i++)
324 : : {
325 : 10 : g_assert_cmpint (g_slist_index (slist, &nums[i]), ==, i);
326 : 10 : st = g_slist_find_custom (slist, GINT_TO_POINTER(i), find_num);
327 : 10 : g_assert (st != NULL);
328 : 10 : g_assert_cmpint (g_slist_position (slist, st), ==, i);
329 : : }
330 : :
331 : 1 : st = g_slist_find_custom (slist, GINT_TO_POINTER (1000), find_num);
332 : 1 : g_assert (st == NULL);
333 : :
334 : 1 : g_slist_free (slist);
335 : 1 : }
336 : :
337 : : static void
338 : 1 : test_slist_concat (void)
339 : : {
340 : 1 : gpointer a = "a";
341 : 1 : gpointer b = "b";
342 : : GSList *s1, *s2, *s;
343 : :
344 : 1 : s1 = g_slist_append (NULL, a);
345 : 1 : s2 = g_slist_append (NULL, b);
346 : 1 : s = g_slist_concat (s1, s2);
347 : 1 : g_assert (s->data == a);
348 : 1 : g_assert (s->next->data == b);
349 : 1 : g_assert (s->next->next == NULL);
350 : 1 : g_slist_free (s);
351 : :
352 : 1 : s1 = g_slist_append (NULL, a);
353 : :
354 : 1 : s = g_slist_concat (NULL, s1);
355 : 1 : g_assert_cmpint (g_slist_length (s), ==, 1);
356 : 1 : s = g_slist_concat (s1, NULL);
357 : 1 : g_assert_cmpint (g_slist_length (s), ==, 1);
358 : :
359 : 1 : g_slist_free (s);
360 : :
361 : 1 : s = g_slist_concat (NULL, NULL);
362 : 1 : g_assert (s == NULL);
363 : 1 : }
364 : :
365 : : static void
366 : 1 : test_slist_copy (void)
367 : : {
368 : 1 : GSList *slist = NULL, *copy;
369 : : GSList *s1, *s2;
370 : 1 : guint nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
371 : : gsize i;
372 : :
373 : : /* Copy and test a many-element list. */
374 [ + + ]: 11 : for (i = 0; i < 10; i++)
375 : 10 : slist = g_slist_append (slist, &nums[i]);
376 : :
377 : 1 : copy = g_slist_copy (slist);
378 : :
379 : 1 : g_assert_cmpuint (g_slist_length (copy), ==, g_slist_length (slist));
380 : :
381 [ + + + - ]: 11 : for (s1 = copy, s2 = slist; s1 != NULL && s2 != NULL; s1 = s1->next, s2 = s2->next)
382 : 10 : g_assert (s1->data == s2->data);
383 : :
384 : 1 : g_slist_free (copy);
385 : 1 : g_slist_free (slist);
386 : :
387 : : /* Copy a NULL list. */
388 : 1 : copy = g_slist_copy (NULL);
389 : 1 : g_assert_null (copy);
390 : 1 : }
391 : :
392 : : static gpointer
393 : 3 : copy_and_count_string (gconstpointer src,
394 : : gpointer data)
395 : : {
396 : 3 : const gchar *str = src;
397 : 3 : gsize *count = data;
398 : :
399 : 3 : *count = *count + 1;
400 : 3 : return g_strdup (str);
401 : : }
402 : :
403 : : static void
404 : 1 : test_slist_copy_deep (void)
405 : : {
406 : 1 : GSList *slist = NULL, *copy;
407 : : GSList *s1, *s2;
408 : : gsize count;
409 : :
410 : : /* Deep-copy a simple list. */
411 : 1 : slist = g_slist_append (slist, "a");
412 : 1 : slist = g_slist_append (slist, "b");
413 : 1 : slist = g_slist_append (slist, "c");
414 : :
415 : 1 : count = 0;
416 : 1 : copy = g_slist_copy_deep (slist, copy_and_count_string, &count);
417 : :
418 : 1 : g_assert_cmpuint (count, ==, g_slist_length (slist));
419 : 1 : g_assert_cmpuint (g_slist_length (copy), ==, count);
420 [ + + + - ]: 4 : for (s1 = slist, s2 = copy; s1 != NULL && s2 != NULL; s1 = s1->next, s2 = s2->next)
421 : : {
422 : 3 : g_assert_cmpstr (s1->data, ==, s2->data);
423 : 3 : g_assert (s1->data != s2->data);
424 : : }
425 : :
426 : 1 : g_slist_free_full (copy, g_free);
427 : 1 : g_slist_free (slist);
428 : :
429 : : /* Try with an empty list. */
430 : 1 : count = 0;
431 : 1 : copy = g_slist_copy_deep (NULL, copy_and_count_string, &count);
432 : 1 : g_assert_cmpuint (count, ==, 0);
433 : 1 : g_assert_null (copy);
434 : 1 : }
435 : :
436 : : int
437 : 1 : main (int argc, char *argv[])
438 : : {
439 : : gint i;
440 : :
441 : 1 : g_test_init (&argc, &argv, NULL);
442 : :
443 : : /* Create an array of random numbers. */
444 [ + + ]: 51 : for (i = 0; i < SIZE; i++)
445 : 50 : array[i] = g_test_rand_int_range (NUMBER_MIN, NUMBER_MAX);
446 : :
447 : 1 : g_test_add_func ("/slist/sort", test_slist_sort);
448 : 1 : g_test_add_func ("/slist/sort-with-data", test_slist_sort_with_data);
449 : 1 : g_test_add_func ("/slist/sort/stable", test_slist_sort_stable);
450 : 1 : g_test_add_func ("/slist/insert-sorted", test_slist_insert_sorted);
451 : 1 : g_test_add_func ("/slist/insert-sorted-with-data", test_slist_insert_sorted_with_data);
452 : 1 : g_test_add_func ("/slist/reverse", test_slist_reverse);
453 : 1 : g_test_add_func ("/slist/nth", test_slist_nth);
454 : 1 : g_test_add_func ("/slist/remove", test_slist_remove);
455 : 1 : g_test_add_func ("/slist/remove-all", test_slist_remove_all);
456 : 1 : g_test_add_func ("/slist/insert", test_slist_insert);
457 : 1 : g_test_add_func ("/slist/position", test_slist_position);
458 : 1 : g_test_add_func ("/slist/concat", test_slist_concat);
459 : 1 : g_test_add_func ("/slist/copy", test_slist_copy);
460 : 1 : g_test_add_func ("/slist/copy/deep", test_slist_copy_deep);
461 : :
462 : 1 : return g_test_run ();
463 : : }
|