[pcsx_rearmed.git] / deps / libretro-common / test / queues / test_generic_queue.c

/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (test_generic_queue.c).
 * ---------------------------------------------------------------------------------------
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include <check.h>
#include <stdarg.h>
#include <stdlib.h>

#include <queues/generic_queue.h>

#define SUITE_NAME "Generic Queue"

static char *_value_1 = "value1";
static char *_value_2 = "value2";
static char *_value_3 = "value3";

START_TEST (test_generic_queue_create)
{
   generic_queue_t *queue = generic_queue_new();
   ck_assert_ptr_nonnull(queue);
   generic_queue_free(queue, NULL);
}
END_TEST

START_TEST (test_generic_queue_free)
{
   generic_queue_t *queue = generic_queue_new();
   generic_queue_free(queue, NULL);
   generic_queue_free(NULL, NULL);
}
END_TEST

START_TEST (test_generic_queue_push_pop)
{
   generic_queue_t *queue;
   char *value;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);
   ck_assert_int_eq(generic_queue_length(queue), 1);
   value = (char *) generic_queue_pop(queue);
   ck_assert_ptr_eq(value, _value_1);
   ck_assert_int_eq(generic_queue_length(queue), 0);

   generic_queue_push(queue, _value_2);
   ck_assert_int_eq(generic_queue_length(queue), 1);
   generic_queue_push(queue, _value_3);
   ck_assert_int_eq(generic_queue_length(queue), 2);
   value = (char *) generic_queue_pop(queue);
   ck_assert_ptr_eq(value, _value_3);
   ck_assert_int_eq(generic_queue_length(queue), 1);
   value = (char *) generic_queue_pop(queue);
   ck_assert_ptr_eq(value, _value_2);
   ck_assert_int_eq(generic_queue_length(queue), 0);

   generic_queue_free(queue, NULL);
}
END_TEST

START_TEST (test_generic_queue_peek)
{
   generic_queue_t *queue;

   queue = generic_queue_new();
   ck_assert_ptr_null(generic_queue_peek(queue));
   ck_assert_ptr_null(generic_queue_peek_first(queue));

   generic_queue_push(queue, _value_1);
   ck_assert_ptr_eq(_value_1, generic_queue_peek(queue));
   ck_assert_ptr_eq(_value_1, generic_queue_peek_first(queue));

   generic_queue_push(queue, _value_2);
   ck_assert_ptr_eq(_value_2, generic_queue_peek(queue));
   ck_assert_ptr_eq(_value_1, generic_queue_peek_first(queue));

   generic_queue_push(queue, _value_3);
   ck_assert_ptr_eq(_value_3, generic_queue_peek(queue));
   ck_assert_ptr_eq(_value_1, generic_queue_peek_first(queue));

   generic_queue_free(queue, NULL);
}
END_TEST

START_TEST (test_generic_queue_shift_unshift)
{
   generic_queue_t *queue;
   char *value;

   queue = generic_queue_new();
   generic_queue_shift(queue, _value_1);
   ck_assert_int_eq(generic_queue_length(queue), 1);
   value = (char *) generic_queue_unshift(queue);
   ck_assert_ptr_eq(value, _value_1);
   ck_assert_int_eq(generic_queue_length(queue), 0);

   generic_queue_shift(queue, _value_2);
   ck_assert_int_eq(generic_queue_length(queue), 1);
   generic_queue_shift(queue, _value_3);
   ck_assert_int_eq(generic_queue_length(queue), 2);
   value = (char *) generic_queue_unshift(queue);
   ck_assert_ptr_eq(value, _value_3);
   ck_assert_int_eq(generic_queue_length(queue), 1);
   value = (char *) generic_queue_unshift(queue);
   ck_assert_ptr_eq(value, _value_2);
   ck_assert_int_eq(generic_queue_length(queue), 0);

   generic_queue_free(queue, NULL);
}
END_TEST

START_TEST (test_generic_queue_empty)
{
   generic_queue_t *queue;

   queue = generic_queue_new();
   ck_assert_ptr_null(generic_queue_pop(queue));
   ck_assert_ptr_null(generic_queue_unshift(queue));
   generic_queue_free(queue, NULL);
}
END_TEST

void _free_value(void *value)
{
   return;
}

START_TEST (test_generic_queue_iterator)
{
   generic_queue_t *queue;
   generic_queue_iterator_t *iterator;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);
   generic_queue_push(queue, _value_2);
   generic_queue_push(queue, _value_3);

   iterator = generic_queue_iterator(queue, true);
   ck_assert_ptr_nonnull(iterator);
   ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_1);
   iterator = generic_queue_iterator_next(iterator);
   ck_assert_ptr_nonnull(iterator);
   ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_2);
   iterator = generic_queue_iterator_next(iterator);
   ck_assert_ptr_nonnull(iterator);
   ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_3);
   iterator = generic_queue_iterator_next(iterator);
   ck_assert_ptr_null(iterator);

   iterator = generic_queue_iterator(queue, false);
   ck_assert_ptr_nonnull(iterator);
   ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_3);
   iterator = generic_queue_iterator_next(iterator);
   ck_assert_ptr_nonnull(iterator);
   ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_2);
   iterator = generic_queue_iterator_next(iterator);
   ck_assert_ptr_nonnull(iterator);
   ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_1);
   iterator = generic_queue_iterator_next(iterator);
   ck_assert_ptr_null(iterator);

   generic_queue_free(queue, &_free_value);
}
END_TEST

START_TEST (test_generic_queue_shift_free)
{
   generic_queue_t *queue;

   queue = generic_queue_new();

   generic_queue_shift(queue, _value_1);
   generic_queue_shift(queue, _value_2);
   generic_queue_shift(queue, _value_3);

   generic_queue_free(queue, &_free_value);
}
END_TEST

START_TEST (test_generic_queue_remove_one)
{
   generic_queue_t *queue;
   generic_queue_iterator_t *iterator;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);

   iterator = generic_queue_iterator(queue, true);
   iterator = generic_queue_iterator_remove(iterator);
   ck_assert_ptr_null(iterator);
   ck_assert_int_eq(generic_queue_length(queue), 0);

   generic_queue_free(queue, NULL);
}
END_TEST

static void _verify_queue_values(generic_queue_t *queue, int count, ...)
{
   va_list values_list;
   void **values;
   int i;
   generic_queue_iterator_t *iterator;

   values = (void **)malloc(count * sizeof(void *));

   ck_assert_int_eq(count, generic_queue_length(queue));

   va_start(values_list, count);
   for (i = 0; i < count; i++)
      values[i] = va_arg(values_list, void *);
   va_end(values_list);

   iterator = generic_queue_iterator(queue, true);
   for (i = 0; i < count; i++)
   {
      ck_assert_ptr_nonnull(iterator);
      ck_assert_ptr_eq(values[i], generic_queue_iterator_value(iterator));
      iterator = generic_queue_iterator_next(iterator);
   }
   ck_assert_ptr_null(iterator);

   iterator = generic_queue_iterator(queue, false);
   for (i = count - 1; i >= 0; i--)
   {
      ck_assert_ptr_nonnull(iterator);
      ck_assert_ptr_eq(values[i], generic_queue_iterator_value(iterator));
      iterator = generic_queue_iterator_next(iterator);
   }
   ck_assert_ptr_null(iterator);

   free(values);
}

START_TEST (test_generic_queue_iterator_remove_first)
{
   generic_queue_t *queue;
   generic_queue_iterator_t *iterator;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);
   generic_queue_push(queue, _value_2);
   generic_queue_push(queue, _value_3);

   iterator = generic_queue_iterator(queue, true);
   iterator = generic_queue_iterator_remove(iterator);
   generic_queue_iterator_free(iterator);

   _verify_queue_values(queue, 2, _value_2, _value_3);

   generic_queue_free(queue, &_free_value);
}
END_TEST

START_TEST (test_generic_queue_iterator_remove_middle)
{
   generic_queue_t *queue;
   generic_queue_iterator_t *iterator;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);
   generic_queue_push(queue, _value_2);
   generic_queue_push(queue, _value_3);

   iterator = generic_queue_iterator(queue, true);
   iterator = generic_queue_iterator_next(iterator);
   iterator = generic_queue_iterator_remove(iterator);
   generic_queue_iterator_free(iterator);

   _verify_queue_values(queue, 2, _value_1, _value_3);

   generic_queue_free(queue, &_free_value);
}
END_TEST

START_TEST (test_generic_queue_iterator_remove_last)
{
   generic_queue_t *queue;
   generic_queue_iterator_t *iterator;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);
   generic_queue_push(queue, _value_2);
   generic_queue_push(queue, _value_3);

   iterator = generic_queue_iterator(queue, false);
   iterator = generic_queue_iterator_remove(iterator);
   generic_queue_iterator_free(iterator);

   _verify_queue_values(queue, 2, _value_1, _value_2);

   generic_queue_free(queue, &_free_value);
}
END_TEST

START_TEST (test_generic_queue_remove_first)
{
   generic_queue_t *queue;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);
   generic_queue_push(queue, _value_2);
   generic_queue_push(queue, _value_3);

   ck_assert_ptr_eq(generic_queue_remove(queue, _value_1), _value_1);

   _verify_queue_values(queue, 2, _value_2, _value_3);

   generic_queue_free(queue, &_free_value);
}

START_TEST (test_generic_queue_remove_middle)
{
   generic_queue_t *queue;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);
   generic_queue_push(queue, _value_2);
   generic_queue_push(queue, _value_3);

   ck_assert_ptr_eq(generic_queue_remove(queue, _value_2), _value_2);

   _verify_queue_values(queue, 2, _value_1, _value_3);

   generic_queue_free(queue, &_free_value);
}

START_TEST (test_generic_queue_remove_last)
{
   generic_queue_t *queue;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);
   generic_queue_push(queue, _value_2);
   generic_queue_push(queue, _value_3);

   ck_assert_ptr_eq(generic_queue_remove(queue, _value_3), _value_3);

   _verify_queue_values(queue, 2, _value_1, _value_2);

   generic_queue_free(queue, &_free_value);
}

START_TEST (test_generic_queue_iterator_free)
{
   generic_queue_t *queue;
   generic_queue_iterator_t *iterator;

   queue = generic_queue_new();
   generic_queue_push(queue, _value_1);
   iterator = generic_queue_iterator(queue, true);

   generic_queue_iterator_free(iterator);
   generic_queue_iterator_free(NULL);

   generic_queue_free(queue, _free_value);
}
END_TEST

Suite *create_suite(void)
{
   Suite *s = suite_create(SUITE_NAME);

   TCase *tc_core = tcase_create("Core");
   tcase_add_test(tc_core, test_generic_queue_create);
   tcase_add_test(tc_core, test_generic_queue_free);
   tcase_add_test(tc_core, test_generic_queue_push_pop);
   tcase_add_test(tc_core, test_generic_queue_peek);
   tcase_add_test(tc_core, test_generic_queue_shift_unshift);
   tcase_add_test(tc_core, test_generic_queue_empty);
   tcase_add_test(tc_core, test_generic_queue_iterator);
   tcase_add_test(tc_core, test_generic_queue_shift_free);
   tcase_add_test(tc_core, test_generic_queue_remove_one);
   tcase_add_test(tc_core, test_generic_queue_iterator_remove_first);
   tcase_add_test(tc_core, test_generic_queue_iterator_remove_middle);
   tcase_add_test(tc_core, test_generic_queue_iterator_remove_last);
   tcase_add_test(tc_core, test_generic_queue_remove_first);
   tcase_add_test(tc_core, test_generic_queue_remove_middle);
   tcase_add_test(tc_core, test_generic_queue_remove_last);
   tcase_add_test(tc_core, test_generic_queue_iterator_free);
   suite_add_tcase(s, tc_core);

   return s;
}

int main(void)
{
	int num_fail;
	Suite *s = create_suite();
	SRunner *sr = srunner_create(s);
	srunner_run_all(sr, CK_NORMAL);
	num_fail = srunner_ntests_failed(sr);
	srunner_free(sr);
	return (num_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
Commit	Line	Data
3719602c PC	1	/* Copyright (C) 2010-2020 The RetroArch team
	2	*
	3	* ---------------------------------------------------------------------------------------
	4	* The following license statement only applies to this file (test_generic_queue.c).
	5	* ---------------------------------------------------------------------------------------
	6	*
	7	* Permission is hereby granted, free of charge,
	8	* to any person obtaining a copy of this software and associated documentation files (the "Software"),
	9	* to deal in the Software without restriction, including without limitation the rights to
	10	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
	11	* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
	16	* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	18	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	19	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	21	*/
	22	#include <check.h>
	23	#include <stdarg.h>
	24	#include <stdlib.h>
	25
	26	#include <queues/generic_queue.h>
	27
	28	#define SUITE_NAME "Generic Queue"
	29
	30	static char *_value_1 = "value1";
	31	static char *_value_2 = "value2";
	32	static char *_value_3 = "value3";
	33
	34	START_TEST (test_generic_queue_create)
	35	{
	36	generic_queue_t *queue = generic_queue_new();
	37	ck_assert_ptr_nonnull(queue);
	38	generic_queue_free(queue, NULL);
	39	}
	40	END_TEST
	41
	42	START_TEST (test_generic_queue_free)
	43	{
	44	generic_queue_t *queue = generic_queue_new();
	45	generic_queue_free(queue, NULL);
	46	generic_queue_free(NULL, NULL);
	47	}
	48	END_TEST
	49
	50	START_TEST (test_generic_queue_push_pop)
	51	{
	52	generic_queue_t *queue;
	53	char *value;
	54
	55	queue = generic_queue_new();
	56	generic_queue_push(queue, _value_1);
	57	ck_assert_int_eq(generic_queue_length(queue), 1);
	58	value = (char *) generic_queue_pop(queue);
	59	ck_assert_ptr_eq(value, _value_1);
	60	ck_assert_int_eq(generic_queue_length(queue), 0);
	61
	62	generic_queue_push(queue, _value_2);
	63	ck_assert_int_eq(generic_queue_length(queue), 1);
	64	generic_queue_push(queue, _value_3);
65	ck_assert_int_eq(generic_queue_length(queue), 2);
66	value = (char *) generic_queue_pop(queue);
67	ck_assert_ptr_eq(value, _value_3);
68	ck_assert_int_eq(generic_queue_length(queue), 1);
69	value = (char *) generic_queue_pop(queue);
70	ck_assert_ptr_eq(value, _value_2);
71	ck_assert_int_eq(generic_queue_length(queue), 0);
72
73	generic_queue_free(queue, NULL);
74	}
75	END_TEST
76
77	START_TEST (test_generic_queue_peek)
78	{
79	generic_queue_t *queue;
80
81	queue = generic_queue_new();
82	ck_assert_ptr_null(generic_queue_peek(queue));
83	ck_assert_ptr_null(generic_queue_peek_first(queue));
84
85	generic_queue_push(queue, _value_1);
86	ck_assert_ptr_eq(_value_1, generic_queue_peek(queue));
87	ck_assert_ptr_eq(_value_1, generic_queue_peek_first(queue));
88
89	generic_queue_push(queue, _value_2);
90	ck_assert_ptr_eq(_value_2, generic_queue_peek(queue));
91	ck_assert_ptr_eq(_value_1, generic_queue_peek_first(queue));
92
93	generic_queue_push(queue, _value_3);
94	ck_assert_ptr_eq(_value_3, generic_queue_peek(queue));
95	ck_assert_ptr_eq(_value_1, generic_queue_peek_first(queue));
96
97	generic_queue_free(queue, NULL);
98	}
99	END_TEST
100
101	START_TEST (test_generic_queue_shift_unshift)
102	{
103	generic_queue_t *queue;
104	char *value;
105
106	queue = generic_queue_new();
107	generic_queue_shift(queue, _value_1);
108	ck_assert_int_eq(generic_queue_length(queue), 1);
109	value = (char *) generic_queue_unshift(queue);
110	ck_assert_ptr_eq(value, _value_1);
111	ck_assert_int_eq(generic_queue_length(queue), 0);
112
113	generic_queue_shift(queue, _value_2);
114	ck_assert_int_eq(generic_queue_length(queue), 1);
115	generic_queue_shift(queue, _value_3);
116	ck_assert_int_eq(generic_queue_length(queue), 2);
117	value = (char *) generic_queue_unshift(queue);
118	ck_assert_ptr_eq(value, _value_3);
119	ck_assert_int_eq(generic_queue_length(queue), 1);
120	value = (char *) generic_queue_unshift(queue);
121	ck_assert_ptr_eq(value, _value_2);
122	ck_assert_int_eq(generic_queue_length(queue), 0);
123
124	generic_queue_free(queue, NULL);
125	}
126	END_TEST
127
128	START_TEST (test_generic_queue_empty)
129	{
130	generic_queue_t *queue;
131
132	queue = generic_queue_new();
133	ck_assert_ptr_null(generic_queue_pop(queue));
134	ck_assert_ptr_null(generic_queue_unshift(queue));
135	generic_queue_free(queue, NULL);
136	}
137	END_TEST
138
139	void _free_value(void *value)
140	{
141	return;
142	}
143
144	START_TEST (test_generic_queue_iterator)
145	{
146	generic_queue_t *queue;
147	generic_queue_iterator_t *iterator;
148
149	queue = generic_queue_new();
150	generic_queue_push(queue, _value_1);
151	generic_queue_push(queue, _value_2);
152	generic_queue_push(queue, _value_3);
153
154	iterator = generic_queue_iterator(queue, true);
155	ck_assert_ptr_nonnull(iterator);
156	ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_1);
157	iterator = generic_queue_iterator_next(iterator);
158	ck_assert_ptr_nonnull(iterator);
159	ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_2);
160	iterator = generic_queue_iterator_next(iterator);
161	ck_assert_ptr_nonnull(iterator);
162	ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_3);
163	iterator = generic_queue_iterator_next(iterator);
164	ck_assert_ptr_null(iterator);
165
166	iterator = generic_queue_iterator(queue, false);
167	ck_assert_ptr_nonnull(iterator);
168	ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_3);
169	iterator = generic_queue_iterator_next(iterator);
170	ck_assert_ptr_nonnull(iterator);
171	ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_2);
172	iterator = generic_queue_iterator_next(iterator);
173	ck_assert_ptr_nonnull(iterator);
174	ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_1);
175	iterator = generic_queue_iterator_next(iterator);
176	ck_assert_ptr_null(iterator);
177
178	generic_queue_free(queue, &_free_value);
179	}
180	END_TEST
181
182	START_TEST (test_generic_queue_shift_free)
183	{
184	generic_queue_t *queue;
185
186	queue = generic_queue_new();
187
188	generic_queue_shift(queue, _value_1);
189	generic_queue_shift(queue, _value_2);
190	generic_queue_shift(queue, _value_3);
191
192	generic_queue_free(queue, &_free_value);
193	}
194	END_TEST
195
196	START_TEST (test_generic_queue_remove_one)
197	{
198	generic_queue_t *queue;
199	generic_queue_iterator_t *iterator;
200
201	queue = generic_queue_new();
202	generic_queue_push(queue, _value_1);
203
204	iterator = generic_queue_iterator(queue, true);
205	iterator = generic_queue_iterator_remove(iterator);
206	ck_assert_ptr_null(iterator);
207	ck_assert_int_eq(generic_queue_length(queue), 0);
208
209	generic_queue_free(queue, NULL);
210	}
211	END_TEST
212
213	static void _verify_queue_values(generic_queue_t *queue, int count, ...)
214	{
215	va_list values_list;
216	void **values;
217	int i;
218	generic_queue_iterator_t *iterator;
219
220	values = (void *)malloc(count sizeof(void *));
221
222	ck_assert_int_eq(count, generic_queue_length(queue));
223
224	va_start(values_list, count);
225	for (i = 0; i < count; i++)
226	values[i] = va_arg(values_list, void *);
227	va_end(values_list);
228
229	iterator = generic_queue_iterator(queue, true);
230	for (i = 0; i < count; i++)
231	{
232	ck_assert_ptr_nonnull(iterator);
233	ck_assert_ptr_eq(values[i], generic_queue_iterator_value(iterator));
234	iterator = generic_queue_iterator_next(iterator);
235	}
236	ck_assert_ptr_null(iterator);
237
238	iterator = generic_queue_iterator(queue, false);
239	for (i = count - 1; i >= 0; i--)
240	{
241	ck_assert_ptr_nonnull(iterator);
242	ck_assert_ptr_eq(values[i], generic_queue_iterator_value(iterator));
243	iterator = generic_queue_iterator_next(iterator);
244	}
245	ck_assert_ptr_null(iterator);
246
247	free(values);
248	}
249
250	START_TEST (test_generic_queue_iterator_remove_first)
251	{
252	generic_queue_t *queue;
253	generic_queue_iterator_t *iterator;
254
255	queue = generic_queue_new();
256	generic_queue_push(queue, _value_1);
257	generic_queue_push(queue, _value_2);
258	generic_queue_push(queue, _value_3);
259
260	iterator = generic_queue_iterator(queue, true);
261	iterator = generic_queue_iterator_remove(iterator);
262	generic_queue_iterator_free(iterator);
263
264	_verify_queue_values(queue, 2, _value_2, _value_3);
265
266	generic_queue_free(queue, &_free_value);
267	}
268	END_TEST
269
270	START_TEST (test_generic_queue_iterator_remove_middle)
271	{
272	generic_queue_t *queue;
273	generic_queue_iterator_t *iterator;
274
275	queue = generic_queue_new();
276	generic_queue_push(queue, _value_1);
277	generic_queue_push(queue, _value_2);
278	generic_queue_push(queue, _value_3);
279
280	iterator = generic_queue_iterator(queue, true);
281	iterator = generic_queue_iterator_next(iterator);
282	iterator = generic_queue_iterator_remove(iterator);
283	generic_queue_iterator_free(iterator);
284
285	_verify_queue_values(queue, 2, _value_1, _value_3);
286
287	generic_queue_free(queue, &_free_value);
288	}
289	END_TEST
290
291	START_TEST (test_generic_queue_iterator_remove_last)
292	{
293	generic_queue_t *queue;
294	generic_queue_iterator_t *iterator;
295
296	queue = generic_queue_new();
297	generic_queue_push(queue, _value_1);
298	generic_queue_push(queue, _value_2);
299	generic_queue_push(queue, _value_3);
300
301	iterator = generic_queue_iterator(queue, false);
302	iterator = generic_queue_iterator_remove(iterator);
303	generic_queue_iterator_free(iterator);
304
305	_verify_queue_values(queue, 2, _value_1, _value_2);
306
307	generic_queue_free(queue, &_free_value);
308	}
309	END_TEST
310
311	START_TEST (test_generic_queue_remove_first)
312	{
313	generic_queue_t *queue;
314
315	queue = generic_queue_new();
316	generic_queue_push(queue, _value_1);
317	generic_queue_push(queue, _value_2);
318	generic_queue_push(queue, _value_3);
319
320	ck_assert_ptr_eq(generic_queue_remove(queue, _value_1), _value_1);
321
322	_verify_queue_values(queue, 2, _value_2, _value_3);
323
324	generic_queue_free(queue, &_free_value);
325	}
326
327	START_TEST (test_generic_queue_remove_middle)
328	{
329	generic_queue_t *queue;
330
331	queue = generic_queue_new();
332	generic_queue_push(queue, _value_1);
333	generic_queue_push(queue, _value_2);
334	generic_queue_push(queue, _value_3);
335
336	ck_assert_ptr_eq(generic_queue_remove(queue, _value_2), _value_2);
337
338	_verify_queue_values(queue, 2, _value_1, _value_3);
339
340	generic_queue_free(queue, &_free_value);
341	}
342
343	START_TEST (test_generic_queue_remove_last)
344	{
345	generic_queue_t *queue;
346
347	queue = generic_queue_new();
348	generic_queue_push(queue, _value_1);
349	generic_queue_push(queue, _value_2);
350	generic_queue_push(queue, _value_3);
351
352	ck_assert_ptr_eq(generic_queue_remove(queue, _value_3), _value_3);
353
354	_verify_queue_values(queue, 2, _value_1, _value_2);
355
356	generic_queue_free(queue, &_free_value);
357	}
358
359	START_TEST (test_generic_queue_iterator_free)
360	{
361	generic_queue_t *queue;
362	generic_queue_iterator_t *iterator;
363
364	queue = generic_queue_new();
365	generic_queue_push(queue, _value_1);
366	iterator = generic_queue_iterator(queue, true);
367
368	generic_queue_iterator_free(iterator);
369	generic_queue_iterator_free(NULL);
370
371	generic_queue_free(queue, _free_value);
372	}
373	END_TEST
374
375	Suite *create_suite(void)
376	{
377	Suite *s = suite_create(SUITE_NAME);
378
379	TCase *tc_core = tcase_create("Core");
380	tcase_add_test(tc_core, test_generic_queue_create);
381	tcase_add_test(tc_core, test_generic_queue_free);
382	tcase_add_test(tc_core, test_generic_queue_push_pop);
383	tcase_add_test(tc_core, test_generic_queue_peek);
384	tcase_add_test(tc_core, test_generic_queue_shift_unshift);
385	tcase_add_test(tc_core, test_generic_queue_empty);
386	tcase_add_test(tc_core, test_generic_queue_iterator);
387	tcase_add_test(tc_core, test_generic_queue_shift_free);
388	tcase_add_test(tc_core, test_generic_queue_remove_one);
389	tcase_add_test(tc_core, test_generic_queue_iterator_remove_first);
390	tcase_add_test(tc_core, test_generic_queue_iterator_remove_middle);
391	tcase_add_test(tc_core, test_generic_queue_iterator_remove_last);
392	tcase_add_test(tc_core, test_generic_queue_remove_first);
393	tcase_add_test(tc_core, test_generic_queue_remove_middle);
394	tcase_add_test(tc_core, test_generic_queue_remove_last);
395	tcase_add_test(tc_core, test_generic_queue_iterator_free);
396	suite_add_tcase(s, tc_core);
397
398	return s;
399	}
400
401	int main(void)
402	{
403	int num_fail;
404	Suite *s = create_suite();
405	SRunner *sr = srunner_create(s);
406	srunner_run_all(sr, CK_NORMAL);
407	num_fail = srunner_ntests_failed(sr);
408	srunner_free(sr);
409	return (num_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
410	}