1 /* testqueue.c generated by valac 0.46.6, the Vala compiler
2  * generated from testqueue.vala, do not modify */
3 
4 /* testqueue.vala
5  *
6  * Copyright (C) 2009  Didier Villevalois
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12 
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17 
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
21  *
22  * Author:
23  * 	Didier 'Ptitjes' Villevalois <ptitjes@free.fr>
24  */
25 
26 #include <glib-object.h>
27 #include <gee.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <glib.h>
31 
32 #define GEE_TYPE_TEST_CASE (gee_test_case_get_type ())
33 #define GEE_TEST_CASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TEST_CASE, GeeTestCase))
34 #define GEE_TEST_CASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_TEST_CASE, GeeTestCaseClass))
35 #define GEE_IS_TEST_CASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TEST_CASE))
36 #define GEE_IS_TEST_CASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_TEST_CASE))
37 #define GEE_TEST_CASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_TEST_CASE, GeeTestCaseClass))
38 
39 typedef struct _GeeTestCase GeeTestCase;
40 typedef struct _GeeTestCaseClass GeeTestCaseClass;
41 typedef struct _GeeTestCasePrivate GeeTestCasePrivate;
42 
43 #define TYPE_COLLECTION_TESTS (collection_tests_get_type ())
44 #define COLLECTION_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_COLLECTION_TESTS, CollectionTests))
45 #define COLLECTION_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_COLLECTION_TESTS, CollectionTestsClass))
46 #define IS_COLLECTION_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_COLLECTION_TESTS))
47 #define IS_COLLECTION_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_COLLECTION_TESTS))
48 #define COLLECTION_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_COLLECTION_TESTS, CollectionTestsClass))
49 
50 typedef struct _CollectionTests CollectionTests;
51 typedef struct _CollectionTestsClass CollectionTestsClass;
52 typedef struct _CollectionTestsPrivate CollectionTestsPrivate;
53 
54 #define TYPE_QUEUE_TESTS (queue_tests_get_type ())
55 #define QUEUE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_QUEUE_TESTS, QueueTests))
56 #define QUEUE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_QUEUE_TESTS, QueueTestsClass))
57 #define IS_QUEUE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_QUEUE_TESTS))
58 #define IS_QUEUE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_QUEUE_TESTS))
59 #define QUEUE_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_QUEUE_TESTS, QueueTestsClass))
60 
61 typedef struct _QueueTests QueueTests;
62 typedef struct _QueueTestsClass QueueTestsClass;
63 typedef struct _QueueTestsPrivate QueueTestsPrivate;
64 enum  {
65 	QUEUE_TESTS_0_PROPERTY,
66 	QUEUE_TESTS_NUM_PROPERTIES
67 };
68 static GParamSpec* queue_tests_properties[QUEUE_TESTS_NUM_PROPERTIES];
69 typedef void (*GeeTestCaseTestMethod) (gpointer user_data);
70 #define _g_free0(var) (var = (g_free (var), NULL))
71 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
72 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
73 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
74 #define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
75 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
76 
77 struct _GeeTestCase {
78 	GObject parent_instance;
79 	GeeTestCasePrivate * priv;
80 };
81 
82 struct _GeeTestCaseClass {
83 	GObjectClass parent_class;
84 	void (*set_up) (GeeTestCase* self);
85 	void (*tear_down) (GeeTestCase* self);
86 };
87 
88 struct _CollectionTests {
89 	GeeTestCase parent_instance;
90 	CollectionTestsPrivate * priv;
91 	GeeCollection* test_collection;
92 };
93 
94 struct _CollectionTestsClass {
95 	GeeTestCaseClass parent_class;
96 };
97 
98 struct _QueueTests {
99 	CollectionTests parent_instance;
100 	QueueTestsPrivate * priv;
101 };
102 
103 struct _QueueTestsClass {
104 	CollectionTestsClass parent_class;
105 };
106 
107 static gpointer queue_tests_parent_class = NULL;
108 
109 GType gee_test_case_get_type (void) G_GNUC_CONST;
110 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GeeTestCase, g_object_unref)
111 GType collection_tests_get_type (void) G_GNUC_CONST;
112 G_DEFINE_AUTOPTR_CLEANUP_FUNC (CollectionTests, g_object_unref)
113 GType queue_tests_get_type (void) G_GNUC_CONST;
114 G_DEFINE_AUTOPTR_CLEANUP_FUNC (QueueTests, g_object_unref)
115 QueueTests* queue_tests_construct (GType object_type,
116                                    const gchar* name);
117 CollectionTests* collection_tests_construct (GType object_type,
118                                              const gchar* name);
119 void gee_test_case_add_test (GeeTestCase* self,
120                              const gchar* name,
121                              GeeTestCaseTestMethod test,
122                              gpointer test_target,
123                              GDestroyNotify test_target_destroy_notify);
124 void queue_tests_test_capacity_bound (QueueTests* self);
125 static void _queue_tests_test_capacity_bound_gee_test_case_test_method (gpointer self);
126 void queue_tests_test_one_element_operation (QueueTests* self);
127 static void _queue_tests_test_one_element_operation_gee_test_case_test_method (gpointer self);
128 void queue_tests_test_gobject_properties (QueueTests* self);
129 static void _queue_tests_test_gobject_properties_gee_test_case_test_method (gpointer self);
130 
131 static void
_queue_tests_test_capacity_bound_gee_test_case_test_method(gpointer self)132 _queue_tests_test_capacity_bound_gee_test_case_test_method (gpointer self)
133 {
134 	queue_tests_test_capacity_bound ((QueueTests*) self);
135 }
136 
137 static void
_queue_tests_test_one_element_operation_gee_test_case_test_method(gpointer self)138 _queue_tests_test_one_element_operation_gee_test_case_test_method (gpointer self)
139 {
140 	queue_tests_test_one_element_operation ((QueueTests*) self);
141 }
142 
143 static void
_queue_tests_test_gobject_properties_gee_test_case_test_method(gpointer self)144 _queue_tests_test_gobject_properties_gee_test_case_test_method (gpointer self)
145 {
146 	queue_tests_test_gobject_properties ((QueueTests*) self);
147 }
148 
149 QueueTests*
queue_tests_construct(GType object_type,const gchar * name)150 queue_tests_construct (GType object_type,
151                        const gchar* name)
152 {
153 	QueueTests * self = NULL;
154 	g_return_val_if_fail (name != NULL, NULL);
155 	self = (QueueTests*) collection_tests_construct (object_type, name);
156 	gee_test_case_add_test ((GeeTestCase*) self, "[Queue] capacity bound", _queue_tests_test_capacity_bound_gee_test_case_test_method, g_object_ref (self), g_object_unref);
157 	gee_test_case_add_test ((GeeTestCase*) self, "[Queue] one element operation", _queue_tests_test_one_element_operation_gee_test_case_test_method, g_object_ref (self), g_object_unref);
158 	gee_test_case_add_test ((GeeTestCase*) self, "[Queue] GObject properties", _queue_tests_test_gobject_properties_gee_test_case_test_method, g_object_ref (self), g_object_unref);
159 	return self;
160 }
161 
162 static gpointer
_g_object_ref0(gpointer self)163 _g_object_ref0 (gpointer self)
164 {
165 	return self ? g_object_ref (self) : NULL;
166 }
167 
168 void
queue_tests_test_capacity_bound(QueueTests * self)169 queue_tests_test_capacity_bound (QueueTests* self)
170 {
171 	GeeQueue* test_queue = NULL;
172 	GeeCollection* _tmp0_;
173 	GeeQueue* _tmp1_;
174 	GeeQueue* _tmp2_;
175 	GeeQueue* _tmp3_;
176 	gint _tmp4_;
177 	gint _tmp5_;
178 	g_return_if_fail (self != NULL);
179 	_tmp0_ = ((CollectionTests*) self)->test_collection;
180 	_tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_QUEUE) ? ((GeeQueue*) _tmp0_) : NULL);
181 	test_queue = _tmp1_;
182 	_tmp2_ = test_queue;
183 	_vala_assert (_tmp2_ != NULL, "test_queue != null");
184 	_tmp3_ = test_queue;
185 	_tmp4_ = gee_queue_get_capacity (_tmp3_);
186 	_tmp5_ = _tmp4_;
187 	if (_tmp5_ == GEE_QUEUE_UNBOUNDED_CAPACITY) {
188 		GeeQueue* _tmp6_;
189 		gint _tmp7_;
190 		gint _tmp8_;
191 		GeeQueue* _tmp9_;
192 		gboolean _tmp10_;
193 		gboolean _tmp11_;
194 		_tmp6_ = test_queue;
195 		_tmp7_ = gee_queue_get_remaining_capacity (_tmp6_);
196 		_tmp8_ = _tmp7_;
197 		_vala_assert (_tmp8_ == GEE_QUEUE_UNBOUNDED_CAPACITY, "test_queue.remaining_capacity == Gee.Queue.UNBOUNDED_CAPACITY");
198 		_tmp9_ = test_queue;
199 		_tmp10_ = gee_queue_get_is_full (_tmp9_);
200 		_tmp11_ = _tmp10_;
201 		_vala_assert (!_tmp11_, "! test_queue.is_full");
202 	} else {
203 		GeeQueue* _tmp12_;
204 		gboolean _tmp13_;
205 		gboolean _tmp14_;
206 		gint capacity = 0;
207 		GeeQueue* _tmp15_;
208 		gint _tmp16_;
209 		gint _tmp17_;
210 		GeeQueue* _tmp27_;
211 		gboolean _tmp28_;
212 		gboolean _tmp29_;
213 		GeeQueue* _tmp41_;
214 		gboolean _tmp42_;
215 		gboolean _tmp43_;
216 		_tmp12_ = test_queue;
217 		_tmp13_ = gee_collection_get_is_empty ((GeeCollection*) _tmp12_);
218 		_tmp14_ = _tmp13_;
219 		_vala_assert (_tmp14_, "test_queue.is_empty");
220 		_tmp15_ = test_queue;
221 		_tmp16_ = gee_queue_get_capacity (_tmp15_);
222 		_tmp17_ = _tmp16_;
223 		capacity = _tmp17_;
224 		{
225 			gint i = 0;
226 			i = 1;
227 			{
228 				gboolean _tmp18_ = FALSE;
229 				_tmp18_ = TRUE;
230 				while (TRUE) {
231 					GeeQueue* _tmp20_;
232 					gboolean _tmp21_;
233 					gboolean _tmp22_;
234 					GeeQueue* _tmp23_;
235 					GeeQueue* _tmp24_;
236 					gint _tmp25_;
237 					gint _tmp26_;
238 					if (!_tmp18_) {
239 						gint _tmp19_;
240 						_tmp19_ = i;
241 						i = _tmp19_ + 1;
242 					}
243 					_tmp18_ = FALSE;
244 					if (!(i <= capacity)) {
245 						break;
246 					}
247 					_tmp20_ = test_queue;
248 					_tmp21_ = gee_queue_get_is_full (_tmp20_);
249 					_tmp22_ = _tmp21_;
250 					_vala_assert (!_tmp22_, "! test_queue.is_full");
251 					_tmp23_ = test_queue;
252 					_vala_assert (gee_queue_offer (_tmp23_, "one"), "test_queue.offer (\"one\")");
253 					_tmp24_ = test_queue;
254 					_tmp25_ = gee_queue_get_remaining_capacity (_tmp24_);
255 					_tmp26_ = _tmp25_;
256 					_vala_assert (_tmp26_ == (capacity - i), "test_queue.remaining_capacity == capacity - i");
257 				}
258 			}
259 		}
260 		_tmp27_ = test_queue;
261 		_tmp28_ = gee_queue_get_is_full (_tmp27_);
262 		_tmp29_ = _tmp28_;
263 		_vala_assert (_tmp29_, "test_queue.is_full");
264 		{
265 			gint i = 0;
266 			i = 1;
267 			{
268 				gboolean _tmp30_ = FALSE;
269 				_tmp30_ = TRUE;
270 				while (TRUE) {
271 					GeeQueue* _tmp32_;
272 					gpointer _tmp33_;
273 					gchar* _tmp34_;
274 					GeeQueue* _tmp35_;
275 					gboolean _tmp36_;
276 					gboolean _tmp37_;
277 					GeeQueue* _tmp38_;
278 					gint _tmp39_;
279 					gint _tmp40_;
280 					if (!_tmp30_) {
281 						gint _tmp31_;
282 						_tmp31_ = i;
283 						i = _tmp31_ + 1;
284 					}
285 					_tmp30_ = FALSE;
286 					if (!(i <= capacity)) {
287 						break;
288 					}
289 					_tmp32_ = test_queue;
290 					_tmp33_ = gee_queue_poll (_tmp32_);
291 					_tmp34_ = (gchar*) _tmp33_;
292 					_vala_assert (g_strcmp0 (_tmp34_, "one") == 0, "test_queue.poll () == \"one\"");
293 					_g_free0 (_tmp34_);
294 					_tmp35_ = test_queue;
295 					_tmp36_ = gee_queue_get_is_full (_tmp35_);
296 					_tmp37_ = _tmp36_;
297 					_vala_assert (!_tmp37_, "! test_queue.is_full");
298 					_tmp38_ = test_queue;
299 					_tmp39_ = gee_queue_get_remaining_capacity (_tmp38_);
300 					_tmp40_ = _tmp39_;
301 					_vala_assert (_tmp40_ == i, "test_queue.remaining_capacity == i");
302 				}
303 			}
304 		}
305 		_tmp41_ = test_queue;
306 		_tmp42_ = gee_collection_get_is_empty ((GeeCollection*) _tmp41_);
307 		_tmp43_ = _tmp42_;
308 		_vala_assert (_tmp43_, "test_queue.is_empty");
309 	}
310 	_g_object_unref0 (test_queue);
311 }
312 
313 void
queue_tests_test_one_element_operation(QueueTests * self)314 queue_tests_test_one_element_operation (QueueTests* self)
315 {
316 	GeeQueue* test_queue = NULL;
317 	GeeCollection* _tmp0_;
318 	GeeQueue* _tmp1_;
319 	GeeArrayList* recipient = NULL;
320 	GeeArrayList* _tmp2_;
321 	gpointer _tmp3_;
322 	gchar* _tmp4_;
323 	gint _tmp5_;
324 	gint _tmp6_;
325 	gboolean _tmp7_;
326 	gboolean _tmp8_;
327 	gpointer _tmp9_;
328 	gchar* _tmp10_;
329 	gint _tmp11_;
330 	gint _tmp12_;
331 	gboolean _tmp13_;
332 	gboolean _tmp14_;
333 	gpointer _tmp15_;
334 	gchar* _tmp16_;
335 	gpointer _tmp17_;
336 	gchar* _tmp18_;
337 	gint _tmp19_;
338 	gint _tmp20_;
339 	gboolean _tmp21_;
340 	gboolean _tmp22_;
341 	gint _tmp23_;
342 	gint _tmp24_;
343 	gpointer _tmp25_;
344 	gchar* _tmp26_;
345 	gint _tmp27_;
346 	gint _tmp28_;
347 	gboolean _tmp29_;
348 	gboolean _tmp30_;
349 	gint _tmp31_;
350 	gint _tmp32_;
351 	gint _tmp33_;
352 	gint _tmp34_;
353 	gboolean _tmp35_;
354 	gboolean _tmp36_;
355 	gint _tmp37_;
356 	gint _tmp38_;
357 	gpointer _tmp39_;
358 	gchar* _tmp40_;
359 	g_return_if_fail (self != NULL);
360 	_tmp0_ = ((CollectionTests*) self)->test_collection;
361 	_tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_QUEUE) ? ((GeeQueue*) _tmp0_) : NULL);
362 	test_queue = _tmp1_;
363 	_tmp2_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, NULL, NULL, NULL);
364 	recipient = _tmp2_;
365 	_vala_assert (test_queue != NULL, "test_queue != null");
366 	_vala_assert (gee_queue_offer (test_queue, "one"), "test_queue.offer (\"one\")");
367 	_tmp3_ = gee_queue_peek (test_queue);
368 	_tmp4_ = (gchar*) _tmp3_;
369 	_vala_assert (g_strcmp0 (_tmp4_, "one") == 0, "test_queue.peek () == \"one\"");
370 	_g_free0 (_tmp4_);
371 	_tmp5_ = gee_collection_get_size ((GeeCollection*) test_queue);
372 	_tmp6_ = _tmp5_;
373 	_vala_assert (_tmp6_ == 1, "test_queue.size == 1");
374 	_tmp7_ = gee_collection_get_is_empty ((GeeCollection*) test_queue);
375 	_tmp8_ = _tmp7_;
376 	_vala_assert (!_tmp8_, "! test_queue.is_empty");
377 	_tmp9_ = gee_queue_poll (test_queue);
378 	_tmp10_ = (gchar*) _tmp9_;
379 	_vala_assert (g_strcmp0 (_tmp10_, "one") == 0, "test_queue.poll () == \"one\"");
380 	_g_free0 (_tmp10_);
381 	_tmp11_ = gee_collection_get_size ((GeeCollection*) test_queue);
382 	_tmp12_ = _tmp11_;
383 	_vala_assert (_tmp12_ == 0, "test_queue.size == 0");
384 	_tmp13_ = gee_collection_get_is_empty ((GeeCollection*) test_queue);
385 	_tmp14_ = _tmp13_;
386 	_vala_assert (_tmp14_, "test_queue.is_empty");
387 	_tmp15_ = gee_queue_peek (test_queue);
388 	_tmp16_ = (gchar*) _tmp15_;
389 	_vala_assert (_tmp16_ == NULL, "test_queue.peek () == null");
390 	_g_free0 (_tmp16_);
391 	_tmp17_ = gee_queue_poll (test_queue);
392 	_tmp18_ = (gchar*) _tmp17_;
393 	_vala_assert (_tmp18_ == NULL, "test_queue.poll () == null");
394 	_g_free0 (_tmp18_);
395 	gee_abstract_collection_clear ((GeeAbstractCollection*) recipient);
396 	_vala_assert (gee_queue_offer (test_queue, "one"), "test_queue.offer (\"one\")");
397 	_vala_assert (gee_queue_drain (test_queue, (GeeCollection*) recipient, 1) == 1, "test_queue.drain (recipient, 1) == 1");
398 	_tmp19_ = gee_collection_get_size ((GeeCollection*) test_queue);
399 	_tmp20_ = _tmp19_;
400 	_vala_assert (_tmp20_ == 0, "test_queue.size == 0");
401 	_tmp21_ = gee_collection_get_is_empty ((GeeCollection*) test_queue);
402 	_tmp22_ = _tmp21_;
403 	_vala_assert (_tmp22_, "test_queue.is_empty");
404 	_tmp23_ = gee_abstract_collection_get_size ((GeeAbstractCollection*) recipient);
405 	_tmp24_ = _tmp23_;
406 	_vala_assert (_tmp24_ == 1, "recipient.size == 1");
407 	_tmp25_ = gee_abstract_list_get ((GeeAbstractList*) recipient, 0);
408 	_tmp26_ = (gchar*) _tmp25_;
409 	_vala_assert (g_strcmp0 (_tmp26_, "one") == 0, "recipient.get (0) == \"one\"");
410 	_g_free0 (_tmp26_);
411 	gee_abstract_collection_clear ((GeeAbstractCollection*) recipient);
412 	_vala_assert (gee_queue_drain (test_queue, (GeeCollection*) recipient, 1) == 0, "test_queue.drain (recipient, 1) == 0");
413 	_tmp27_ = gee_collection_get_size ((GeeCollection*) test_queue);
414 	_tmp28_ = _tmp27_;
415 	_vala_assert (_tmp28_ == 0, "test_queue.size == 0");
416 	_tmp29_ = gee_collection_get_is_empty ((GeeCollection*) test_queue);
417 	_tmp30_ = _tmp29_;
418 	_vala_assert (_tmp30_, "test_queue.is_empty");
419 	_tmp31_ = gee_abstract_collection_get_size ((GeeAbstractCollection*) recipient);
420 	_tmp32_ = _tmp31_;
421 	_vala_assert (_tmp32_ == 0, "recipient.size == 0");
422 	gee_abstract_collection_clear ((GeeAbstractCollection*) recipient);
423 	_vala_assert (gee_queue_offer (test_queue, "one"), "test_queue.offer (\"one\")");
424 	_vala_assert (gee_queue_drain (test_queue, (GeeCollection*) recipient, -1) == 1, "test_queue.drain (recipient) == 1");
425 	_tmp33_ = gee_collection_get_size ((GeeCollection*) test_queue);
426 	_tmp34_ = _tmp33_;
427 	_vala_assert (_tmp34_ == 0, "test_queue.size == 0");
428 	_tmp35_ = gee_collection_get_is_empty ((GeeCollection*) test_queue);
429 	_tmp36_ = _tmp35_;
430 	_vala_assert (_tmp36_, "test_queue.is_empty");
431 	_tmp37_ = gee_abstract_collection_get_size ((GeeAbstractCollection*) recipient);
432 	_tmp38_ = _tmp37_;
433 	_vala_assert (_tmp38_ == 1, "recipient.size == 1");
434 	_tmp39_ = gee_abstract_list_get ((GeeAbstractList*) recipient, 0);
435 	_tmp40_ = (gchar*) _tmp39_;
436 	_vala_assert (g_strcmp0 (_tmp40_, "one") == 0, "recipient.get (0) == \"one\"");
437 	_g_free0 (_tmp40_);
438 	_g_object_unref0 (recipient);
439 	_g_object_unref0 (test_queue);
440 }
441 
442 void
queue_tests_test_gobject_properties(QueueTests * self)443 queue_tests_test_gobject_properties (QueueTests* self)
444 {
445 	GeeQueue* test_queue = NULL;
446 	GeeCollection* _tmp0_;
447 	GeeQueue* _tmp1_;
448 	GValue value = {0};
449 	GValue _tmp2_ = {0};
450 	gint _tmp3_;
451 	gint _tmp4_;
452 	GValue _tmp5_ = {0};
453 	gint _tmp6_;
454 	gint _tmp7_;
455 	GValue _tmp8_ = {0};
456 	gboolean _tmp9_;
457 	gboolean _tmp10_;
458 	g_return_if_fail (self != NULL);
459 	_tmp0_ = ((CollectionTests*) self)->test_collection;
460 	_tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_QUEUE) ? ((GeeQueue*) _tmp0_) : NULL);
461 	test_queue = _tmp1_;
462 	_vala_assert (test_queue != NULL, "test_queue != null");
463 	g_value_init (&_tmp2_, G_TYPE_INT);
464 	G_IS_VALUE (&value) ? (g_value_unset (&value), NULL) : NULL;
465 	value = _tmp2_;
466 	g_object_get_property ((GObject*) test_queue, "capacity", &value);
467 	_tmp3_ = gee_queue_get_capacity (test_queue);
468 	_tmp4_ = _tmp3_;
469 	_vala_assert (g_value_get_int (&value) == _tmp4_, "value.get_int () == test_queue.capacity");
470 	g_value_unset (&value);
471 	g_value_init (&_tmp5_, G_TYPE_INT);
472 	G_IS_VALUE (&value) ? (g_value_unset (&value), NULL) : NULL;
473 	value = _tmp5_;
474 	g_object_get_property ((GObject*) test_queue, "remaining-capacity", &value);
475 	_tmp6_ = gee_queue_get_remaining_capacity (test_queue);
476 	_tmp7_ = _tmp6_;
477 	_vala_assert (g_value_get_int (&value) == _tmp7_, "value.get_int () == test_queue.remaining_capacity");
478 	g_value_unset (&value);
479 	g_value_init (&_tmp8_, G_TYPE_BOOLEAN);
480 	G_IS_VALUE (&value) ? (g_value_unset (&value), NULL) : NULL;
481 	value = _tmp8_;
482 	g_object_get_property ((GObject*) test_queue, "is-full", &value);
483 	_tmp9_ = gee_queue_get_is_full (test_queue);
484 	_tmp10_ = _tmp9_;
485 	_vala_assert (g_value_get_boolean (&value) == _tmp10_, "value.get_boolean () == test_queue.is_full");
486 	g_value_unset (&value);
487 	G_IS_VALUE (&value) ? (g_value_unset (&value), NULL) : NULL;
488 	_g_object_unref0 (test_queue);
489 }
490 
491 static void
queue_tests_class_init(QueueTestsClass * klass,gpointer klass_data)492 queue_tests_class_init (QueueTestsClass * klass,
493                         gpointer klass_data)
494 {
495 	queue_tests_parent_class = g_type_class_peek_parent (klass);
496 }
497 
498 static void
queue_tests_instance_init(QueueTests * self,gpointer klass)499 queue_tests_instance_init (QueueTests * self,
500                            gpointer klass)
501 {
502 }
503 
504 GType
queue_tests_get_type(void)505 queue_tests_get_type (void)
506 {
507 	static volatile gsize queue_tests_type_id__volatile = 0;
508 	if (g_once_init_enter (&queue_tests_type_id__volatile)) {
509 		static const GTypeInfo g_define_type_info = { sizeof (QueueTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) queue_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (QueueTests), 0, (GInstanceInitFunc) queue_tests_instance_init, NULL };
510 		GType queue_tests_type_id;
511 		queue_tests_type_id = g_type_register_static (TYPE_COLLECTION_TESTS, "QueueTests", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
512 		g_once_init_leave (&queue_tests_type_id__volatile, queue_tests_type_id);
513 	}
514 	return queue_tests_type_id__volatile;
515 }
516 
517