/* testcollection.c generated by valac 0.20.1.52-2186, the Vala compiler
 * generated from testcollection.vala, do not modify */

/* testcollection.vala
 *
 * Copyright (C) 2008  Jürg Billeter
 * Copyright (C) 2009  Didier Villevalois, Julien Peeters
 * Copyright (C) 2011-2012  Maciej Piechotka
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * Author:
 * 	Jürg Billeter <j@bitron.ch>
 * 	Didier 'Ptitjes' Villevalois <ptitjes@free.fr>
 * 	Julien Peeters <contact@julienpeeters.fr>
 *      Maciej Piechotka <uzytkownik2@gmail.com>
 */

#include <glib.h>
#include <glib-object.h>
#include <gee.h>
#include <stdlib.h>
#include <string.h>


#define GEE_TYPE_TEST_CASE (gee_test_case_get_type ())
#define GEE_TEST_CASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TEST_CASE, GeeTestCase))
#define GEE_TEST_CASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_TEST_CASE, GeeTestCaseClass))
#define GEE_IS_TEST_CASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TEST_CASE))
#define GEE_IS_TEST_CASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_TEST_CASE))
#define GEE_TEST_CASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_TEST_CASE, GeeTestCaseClass))

typedef struct _GeeTestCase GeeTestCase;
typedef struct _GeeTestCaseClass GeeTestCaseClass;
typedef struct _GeeTestCasePrivate GeeTestCasePrivate;

#define TYPE_COLLECTION_TESTS (collection_tests_get_type ())
#define COLLECTION_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_COLLECTION_TESTS, CollectionTests))
#define COLLECTION_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_COLLECTION_TESTS, CollectionTestsClass))
#define IS_COLLECTION_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_COLLECTION_TESTS))
#define IS_COLLECTION_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_COLLECTION_TESTS))
#define COLLECTION_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_COLLECTION_TESTS, CollectionTestsClass))

typedef struct _CollectionTests CollectionTests;
typedef struct _CollectionTestsClass CollectionTestsClass;
typedef struct _CollectionTestsPrivate CollectionTestsPrivate;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
typedef struct _Block1Data Block1Data;
typedef struct _Block2Data Block2Data;
typedef struct _Block3Data Block3Data;
typedef struct _Block4Data Block4Data;
#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

struct _GeeTestCase {
	GObject parent_instance;
	GeeTestCasePrivate * priv;
};

struct _GeeTestCaseClass {
	GObjectClass parent_class;
	void (*set_up) (GeeTestCase* self);
	void (*tear_down) (GeeTestCase* self);
};

struct _CollectionTests {
	GeeTestCase parent_instance;
	CollectionTestsPrivate * priv;
	GeeCollection* test_collection;
};

struct _CollectionTestsClass {
	GeeTestCaseClass parent_class;
};

typedef void (*GeeTestCaseTestMethod) (void* user_data);
struct _Block1Data {
	int _ref_count_;
	CollectionTests * self;
	gint count;
};

struct _Block2Data {
	int _ref_count_;
	CollectionTests * self;
	gboolean one;
	gboolean two;
	gboolean three;
	gint i;
};

struct _Block3Data {
	int _ref_count_;
	CollectionTests * self;
	gboolean one;
	gboolean two;
	gboolean three;
};

struct _Block4Data {
	int _ref_count_;
	CollectionTests * self;
	gboolean one;
	gboolean two;
	gboolean three;
};


static gpointer collection_tests_parent_class = NULL;

GType gee_test_case_get_type (void) G_GNUC_CONST;
GType collection_tests_get_type (void) G_GNUC_CONST;
enum  {
	COLLECTION_TESTS_DUMMY_PROPERTY
};
CollectionTests* collection_tests_construct (GType object_type, const gchar* name);
GeeTestCase* gee_test_case_construct (GType object_type, const gchar* name);
void gee_test_case_add_test (GeeTestCase* self, const gchar* name, GeeTestCaseTestMethod test, void* test_target, GDestroyNotify test_target_destroy_notify);
void collection_tests_test_type_correctness (CollectionTests* self);
static void _collection_tests_test_type_correctness_gee_test_case_test_method (gpointer self);
void collection_tests_test_iterator_returns_all_elements_once (CollectionTests* self);
static void _collection_tests_test_iterator_returns_all_elements_once_gee_test_case_test_method (gpointer self);
void collection_tests_test_mutable_iterator (CollectionTests* self);
static void _collection_tests_test_mutable_iterator_gee_test_case_test_method (gpointer self);
void collection_tests_test_contains_size_and_is_empty (CollectionTests* self);
static void _collection_tests_test_contains_size_and_is_empty_gee_test_case_test_method (gpointer self);
void collection_tests_test_add_remove (CollectionTests* self);
static void _collection_tests_test_add_remove_gee_test_case_test_method (gpointer self);
void collection_tests_test_clear (CollectionTests* self);
static void _collection_tests_test_clear_gee_test_case_test_method (gpointer self);
void collection_tests_test_add_all (CollectionTests* self);
static void _collection_tests_test_add_all_gee_test_case_test_method (gpointer self);
void collection_tests_test_contains_all (CollectionTests* self);
static void _collection_tests_test_contains_all_gee_test_case_test_method (gpointer self);
void collection_tests_test_remove_all (CollectionTests* self);
static void _collection_tests_test_remove_all_gee_test_case_test_method (gpointer self);
void collection_tests_test_retain_all (CollectionTests* self);
static void _collection_tests_test_retain_all_gee_test_case_test_method (gpointer self);
void collection_tests_test_to_array (CollectionTests* self);
static void _collection_tests_test_to_array_gee_test_case_test_method (gpointer self);
void collection_tests_test_gobject_properties (CollectionTests* self);
static void _collection_tests_test_gobject_properties_gee_test_case_test_method (gpointer self);
void collection_tests_test_fold (CollectionTests* self);
static void _collection_tests_test_fold_gee_test_case_test_method (gpointer self);
void collection_tests_test_foreach (CollectionTests* self);
static void _collection_tests_test_foreach_gee_test_case_test_method (gpointer self);
void collection_tests_test_map (CollectionTests* self);
static void _collection_tests_test_map_gee_test_case_test_method (gpointer self);
void collection_tests_test_scan (CollectionTests* self);
static void _collection_tests_test_scan_gee_test_case_test_method (gpointer self);
void collection_tests_test_filter (CollectionTests* self);
static void _collection_tests_test_filter_gee_test_case_test_method (gpointer self);
void collection_tests_test_chop (CollectionTests* self);
static void _collection_tests_test_chop_gee_test_case_test_method (gpointer self);
gchar** test_data_get_data (int* result_length1);
guint* test_data_get_drawn_numbers (int* result_length1);
static gint __lambda3_ (CollectionTests* self, gchar* x, gint y);
static gpointer ___lambda3__gee_fold_func (gpointer g, gpointer a, gpointer self);
static gint __lambda4_ (CollectionTests* self, gchar* x, gint y);
static gpointer ___lambda4__gee_fold_func (gpointer g, gpointer a, gpointer self);
static gint __lambda5_ (CollectionTests* self, gchar* x, gint y);
static gpointer ___lambda5__gee_fold_func (gpointer g, gpointer a, gpointer self);
static Block1Data* block1_data_ref (Block1Data* _data1_);
static void block1_data_unref (void * _userdata_);
static gboolean __lambda6_ (Block1Data* _data1_, gchar* x);
static gboolean ___lambda6__gee_forall_func (gpointer g, gpointer self);
static gboolean __lambda7_ (Block1Data* _data1_, gchar* x);
static gboolean ___lambda7__gee_forall_func (gpointer g, gpointer self);
static gboolean __lambda8_ (Block1Data* _data1_, gchar* x);
static gboolean ___lambda8__gee_forall_func (gpointer g, gpointer self);
static gboolean __lambda9_ (Block1Data* _data1_, gchar* x);
static gboolean ___lambda9__gee_forall_func (gpointer g, gpointer self);
static Block2Data* block2_data_ref (Block2Data* _data2_);
static void block2_data_unref (void * _userdata_);
static gint __lambda10_ (Block2Data* _data2_, gchar* str);
static gpointer ___lambda10__gee_map_func (gpointer g, gpointer self);
static gint __lambda11_ (Block2Data* _data2_, gchar* str);
static gpointer ___lambda11__gee_map_func (gpointer g, gpointer self);
static Block3Data* block3_data_ref (Block3Data* _data3_);
static void block3_data_unref (void * _userdata_);
static gint __lambda12_ (Block3Data* _data3_, gchar* str, gint cur);
static gpointer ___lambda12__gee_fold_func (gpointer g, gpointer a, gpointer self);
static gint __lambda13_ (Block3Data* _data3_, gchar* str, gint cur);
static gpointer ___lambda13__gee_fold_func (gpointer g, gpointer a, gpointer self);
static Block4Data* block4_data_ref (Block4Data* _data4_);
static void block4_data_unref (void * _userdata_);
static gboolean __lambda14_ (Block4Data* _data4_, const gchar* str);
static gboolean ___lambda14__gee_predicate (gconstpointer g, gpointer self);
static gboolean __lambda15_ (Block4Data* _data4_, const gchar* str);
static gboolean ___lambda15__gee_predicate (gconstpointer g, gpointer self);
static void collection_tests_finalize (GObject* obj);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);


static void _collection_tests_test_type_correctness_gee_test_case_test_method (gpointer self) {
	collection_tests_test_type_correctness (self);
}


static void _collection_tests_test_iterator_returns_all_elements_once_gee_test_case_test_method (gpointer self) {
	collection_tests_test_iterator_returns_all_elements_once (self);
}


static void _collection_tests_test_mutable_iterator_gee_test_case_test_method (gpointer self) {
	collection_tests_test_mutable_iterator (self);
}


static void _collection_tests_test_contains_size_and_is_empty_gee_test_case_test_method (gpointer self) {
	collection_tests_test_contains_size_and_is_empty (self);
}


static void _collection_tests_test_add_remove_gee_test_case_test_method (gpointer self) {
	collection_tests_test_add_remove (self);
}


static void _collection_tests_test_clear_gee_test_case_test_method (gpointer self) {
	collection_tests_test_clear (self);
}


static void _collection_tests_test_add_all_gee_test_case_test_method (gpointer self) {
	collection_tests_test_add_all (self);
}


static void _collection_tests_test_contains_all_gee_test_case_test_method (gpointer self) {
	collection_tests_test_contains_all (self);
}


static void _collection_tests_test_remove_all_gee_test_case_test_method (gpointer self) {
	collection_tests_test_remove_all (self);
}


static void _collection_tests_test_retain_all_gee_test_case_test_method (gpointer self) {
	collection_tests_test_retain_all (self);
}


static void _collection_tests_test_to_array_gee_test_case_test_method (gpointer self) {
	collection_tests_test_to_array (self);
}


static void _collection_tests_test_gobject_properties_gee_test_case_test_method (gpointer self) {
	collection_tests_test_gobject_properties (self);
}


static void _collection_tests_test_fold_gee_test_case_test_method (gpointer self) {
	collection_tests_test_fold (self);
}


static void _collection_tests_test_foreach_gee_test_case_test_method (gpointer self) {
	collection_tests_test_foreach (self);
}


static void _collection_tests_test_map_gee_test_case_test_method (gpointer self) {
	collection_tests_test_map (self);
}


static void _collection_tests_test_scan_gee_test_case_test_method (gpointer self) {
	collection_tests_test_scan (self);
}


static void _collection_tests_test_filter_gee_test_case_test_method (gpointer self) {
	collection_tests_test_filter (self);
}


static void _collection_tests_test_chop_gee_test_case_test_method (gpointer self) {
	collection_tests_test_chop (self);
}


CollectionTests* collection_tests_construct (GType object_type, const gchar* name) {
	CollectionTests * self = NULL;
	const gchar* _tmp0_ = NULL;
	g_return_val_if_fail (name != NULL, NULL);
	_tmp0_ = name;
	self = (CollectionTests*) gee_test_case_construct (object_type, _tmp0_);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] type correctness", _collection_tests_test_type_correctness_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] iterator returns all elements once", _collection_tests_test_iterator_returns_all_elements_once_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] mutable iterator", _collection_tests_test_mutable_iterator_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] contains, size and is_empty", _collection_tests_test_contains_size_and_is_empty_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] add and remove", _collection_tests_test_add_remove_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] clear", _collection_tests_test_clear_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] add_all", _collection_tests_test_add_all_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] contains_all", _collection_tests_test_contains_all_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] remove_all", _collection_tests_test_remove_all_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] retain_all", _collection_tests_test_retain_all_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] to_array", _collection_tests_test_to_array_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] GObject properties", _collection_tests_test_gobject_properties_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] fold", _collection_tests_test_fold_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] foreach", _collection_tests_test_foreach_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] map", _collection_tests_test_map_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] scan", _collection_tests_test_scan_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] filter", _collection_tests_test_filter_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	gee_test_case_add_test ((GeeTestCase*) self, "[Collection] chop", _collection_tests_test_chop_gee_test_case_test_method, g_object_ref (self), g_object_unref);
	return self;
}


void collection_tests_test_type_correctness (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	GeeCollection* _tmp1_ = NULL;
	GType _tmp2_ = 0UL;
	GType _tmp3_ = 0UL;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp1_ = self->test_collection;
	_tmp2_ = gee_traversable_get_element_type ((GeeTraversable*) _tmp1_);
	_tmp3_ = _tmp2_;
	_vala_assert (_tmp3_ == G_TYPE_STRING, "test_collection.element_type == typeof (string)");
}


void collection_tests_test_iterator_returns_all_elements_once (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	gboolean has_next = FALSE;
	GeeIterator* iterator = NULL;
	GeeCollection* _tmp1_ = NULL;
	GeeIterator* _tmp2_ = NULL;
	GeeIterator* _tmp3_ = NULL;
	gboolean _tmp4_ = FALSE;
	GeeIterator* _tmp5_ = NULL;
	gboolean _tmp6_ = FALSE;
	gchar** data = NULL;
	gint _tmp7_ = 0;
	gchar** _tmp8_ = NULL;
	gint data_length1 = 0;
	gint _data_size_ = 0;
	gchar** _tmp9_ = NULL;
	gint _tmp9__length1 = 0;
	guint* found_times = NULL;
	gchar** _tmp13_ = NULL;
	gint _tmp13__length1 = 0;
	guint* _tmp14_ = NULL;
	gint found_times_length1 = 0;
	gint _found_times_size_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp1_ = self->test_collection;
	_tmp2_ = gee_iterable_iterator ((GeeIterable*) _tmp1_);
	iterator = _tmp2_;
	_tmp3_ = iterator;
	_tmp4_ = gee_iterator_has_next (_tmp3_);
	_vala_assert (!_tmp4_, "! iterator.has_next ()");
	_tmp5_ = iterator;
	_tmp6_ = gee_iterator_next (_tmp5_);
	_vala_assert (!_tmp6_, "! iterator.next ()");
	_tmp8_ = test_data_get_data (&_tmp7_);
	data = _tmp8_;
	data_length1 = _tmp7_;
	_data_size_ = data_length1;
	_tmp9_ = data;
	_tmp9__length1 = data_length1;
	{
		gchar** el_collection = NULL;
		gint el_collection_length1 = 0;
		gint _el_collection_size_ = 0;
		gint el_it = 0;
		el_collection = _tmp9_;
		el_collection_length1 = _tmp9__length1;
		for (el_it = 0; el_it < _tmp9__length1; el_it = el_it + 1) {
			const gchar* el = NULL;
			el = el_collection[el_it];
			{
				GeeCollection* _tmp10_ = NULL;
				const gchar* _tmp11_ = NULL;
				gboolean _tmp12_ = FALSE;
				_tmp10_ = self->test_collection;
				_tmp11_ = el;
				_tmp12_ = gee_collection_add (_tmp10_, _tmp11_);
				_vala_assert (_tmp12_, "test_collection.add (el)");
			}
		}
	}
	_tmp13_ = data;
	_tmp13__length1 = data_length1;
	_tmp14_ = g_new0 (guint, _tmp13__length1);
	found_times = _tmp14_;
	found_times_length1 = _tmp13__length1;
	_found_times_size_ = found_times_length1;
	{
		guint i = 0U;
		i = (guint) 0;
		{
			gboolean _tmp15_ = FALSE;
			_tmp15_ = TRUE;
			while (TRUE) {
				gboolean _tmp16_ = FALSE;
				guint _tmp18_ = 0U;
				GeeCollection* _tmp27_ = NULL;
				GeeIterator* _tmp28_ = NULL;
				gboolean valid = FALSE;
				GeeIterator* _tmp29_ = NULL;
				gboolean _tmp30_ = FALSE;
				gboolean _tmp31_ = FALSE;
				gboolean _tmp32_ = FALSE;
				GeeIterator* _tmp64_ = NULL;
				gboolean _tmp65_ = FALSE;
				gboolean _tmp66_ = FALSE;
				GeeIterator* _tmp67_ = NULL;
				gboolean _tmp68_ = FALSE;
				gboolean _tmp69_ = FALSE;
				gboolean _tmp70_ = FALSE;
				GeeIterator* _tmp71_ = NULL;
				gboolean _tmp72_ = FALSE;
				GeeIterator* _tmp73_ = NULL;
				gboolean _tmp74_ = FALSE;
				gboolean _tmp75_ = FALSE;
				guint* _tmp76_ = NULL;
				gint _tmp76__length1 = 0;
				_tmp16_ = _tmp15_;
				if (!_tmp16_) {
					guint _tmp17_ = 0U;
					_tmp17_ = i;
					i = _tmp17_ + 1;
				}
				_tmp15_ = FALSE;
				_tmp18_ = i;
				if (!(_tmp18_ < ((guint) 2))) {
					break;
				}
				{
					guint j = 0U;
					j = (guint) 0;
					{
						gboolean _tmp19_ = FALSE;
						_tmp19_ = TRUE;
						while (TRUE) {
							gboolean _tmp20_ = FALSE;
							guint _tmp22_ = 0U;
							guint* _tmp23_ = NULL;
							gint _tmp23__length1 = 0;
							guint* _tmp24_ = NULL;
							gint _tmp24__length1 = 0;
							guint _tmp25_ = 0U;
							guint _tmp26_ = 0U;
							_tmp20_ = _tmp19_;
							if (!_tmp20_) {
								guint _tmp21_ = 0U;
								_tmp21_ = j;
								j = _tmp21_ + 1;
							}
							_tmp19_ = FALSE;
							_tmp22_ = j;
							_tmp23_ = found_times;
							_tmp23__length1 = found_times_length1;
							if (!(_tmp22_ < ((guint) _tmp23__length1))) {
								break;
							}
							_tmp24_ = found_times;
							_tmp24__length1 = found_times_length1;
							_tmp25_ = j;
							_tmp24_[_tmp25_] = (guint) 0;
							_tmp26_ = _tmp24_[_tmp25_];
						}
					}
				}
				_tmp27_ = self->test_collection;
				_tmp28_ = gee_iterable_iterator ((GeeIterable*) _tmp27_);
				_g_object_unref0 (iterator);
				iterator = _tmp28_;
				_tmp29_ = iterator;
				_tmp30_ = gee_iterator_get_valid (_tmp29_);
				_tmp31_ = _tmp30_;
				valid = _tmp31_;
				_tmp32_ = valid;
				_vala_assert (!_tmp32_, "! valid");
				while (TRUE) {
					GeeIterator* _tmp33_ = NULL;
					gboolean _tmp34_ = FALSE;
					gboolean _tmp35_ = FALSE;
					GeeIterator* _tmp36_ = NULL;
					gboolean _tmp37_ = FALSE;
					gboolean _tmp38_ = FALSE;
					gboolean _tmp39_ = FALSE;
					GeeIterator* _tmp40_ = NULL;
					gboolean _tmp41_ = FALSE;
					GeeIterator* _tmp42_ = NULL;
					gboolean _tmp43_ = FALSE;
					gboolean _tmp44_ = FALSE;
					gboolean _tmp45_ = FALSE;
					gboolean _tmp46_ = FALSE;
					gchar* element = NULL;
					GeeIterator* _tmp47_ = NULL;
					gpointer _tmp48_ = NULL;
					GeeIterator* _tmp49_ = NULL;
					gboolean _tmp50_ = FALSE;
					gboolean _tmp51_ = FALSE;
					_tmp33_ = iterator;
					_tmp34_ = gee_iterator_has_next (_tmp33_);
					has_next = _tmp34_;
					_tmp35_ = valid;
					_tmp36_ = iterator;
					_tmp37_ = gee_iterator_get_valid (_tmp36_);
					_tmp38_ = _tmp37_;
					_vala_assert (_tmp35_ == _tmp38_, "valid == iterator.valid");
					_tmp39_ = has_next;
					_tmp40_ = iterator;
					_tmp41_ = gee_iterator_next (_tmp40_);
					_vala_assert (_tmp39_ == _tmp41_, "has_next == iterator.next ()");
					_tmp42_ = iterator;
					_tmp43_ = gee_iterator_get_valid (_tmp42_);
					_tmp44_ = _tmp43_;
					valid = _tmp44_;
					_tmp45_ = valid;
					_vala_assert (_tmp45_, "valid = iterator.valid");
					_tmp46_ = has_next;
					if (!_tmp46_) {
						break;
					}
					_tmp47_ = iterator;
					_tmp48_ = gee_iterator_get (_tmp47_);
					element = (gchar*) _tmp48_;
					_tmp49_ = iterator;
					_tmp50_ = gee_iterator_get_valid (_tmp49_);
					_tmp51_ = _tmp50_;
					_vala_assert (_tmp51_, "iterator.valid");
					{
						guint element_idx = 0U;
						element_idx = (guint) 0;
						{
							gboolean _tmp52_ = FALSE;
							_tmp52_ = TRUE;
							while (TRUE) {
								gboolean _tmp53_ = FALSE;
								guint _tmp55_ = 0U;
								gchar** _tmp56_ = NULL;
								gint _tmp56__length1 = 0;
								gchar** _tmp57_ = NULL;
								gint _tmp57__length1 = 0;
								guint _tmp58_ = 0U;
								const gchar* _tmp59_ = NULL;
								const gchar* _tmp60_ = NULL;
								_tmp53_ = _tmp52_;
								if (!_tmp53_) {
									guint _tmp54_ = 0U;
									_tmp54_ = element_idx;
									element_idx = _tmp54_ + 1;
								}
								_tmp52_ = FALSE;
								_tmp55_ = element_idx;
								_tmp56_ = data;
								_tmp56__length1 = data_length1;
								_vala_assert (_tmp55_ < ((guint) _tmp56__length1), "element_idx < data.length");
								_tmp57_ = data;
								_tmp57__length1 = data_length1;
								_tmp58_ = element_idx;
								_tmp59_ = _tmp57_[_tmp58_];
								_tmp60_ = element;
								if (g_strcmp0 (_tmp59_, _tmp60_) == 0) {
									guint* _tmp61_ = NULL;
									gint _tmp61__length1 = 0;
									guint _tmp62_ = 0U;
									guint _tmp63_ = 0U;
									_tmp61_ = found_times;
									_tmp61__length1 = found_times_length1;
									_tmp62_ = element_idx;
									_tmp63_ = _tmp61_[_tmp62_];
									_tmp61_[_tmp62_] = _tmp63_ + 1;
									break;
								}
							}
						}
					}
					_g_free0 (element);
				}
				_tmp64_ = iterator;
				_tmp65_ = gee_iterator_has_next (_tmp64_);
				has_next = _tmp65_;
				_tmp66_ = has_next;
				_vala_assert (!_tmp66_, "! has_next");
				_tmp67_ = iterator;
				_tmp68_ = gee_iterator_get_valid (_tmp67_);
				_tmp69_ = _tmp68_;
				_vala_assert (_tmp69_, "iterator.valid");
				_tmp70_ = has_next;
				_tmp71_ = iterator;
				_tmp72_ = gee_iterator_next (_tmp71_);
				_vala_assert (_tmp70_ == _tmp72_, "has_next == iterator.next ()");
				_tmp73_ = iterator;
				_tmp74_ = gee_iterator_get_valid (_tmp73_);
				_tmp75_ = _tmp74_;
				_vala_assert (_tmp75_, "iterator.valid");
				_tmp76_ = found_times;
				_tmp76__length1 = found_times_length1;
				{
					guint* ft_collection = NULL;
					gint ft_collection_length1 = 0;
					gint _ft_collection_size_ = 0;
					gint ft_it = 0;
					ft_collection = _tmp76_;
					ft_collection_length1 = _tmp76__length1;
					for (ft_it = 0; ft_it < _tmp76__length1; ft_it = ft_it + 1) {
						guint ft = 0U;
						ft = ft_collection[ft_it];
						{
							guint _tmp77_ = 0U;
							_tmp77_ = ft;
							_vala_assert (_tmp77_ == ((guint) 1), "ft == 1");
						}
					}
				}
			}
		}
	}
	found_times = (g_free (found_times), NULL);
	_g_object_unref0 (iterator);
}


void collection_tests_test_mutable_iterator (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	gboolean has_next = FALSE;
	GeeIterator* iterator = NULL;
	GeeCollection* _tmp1_ = NULL;
	GeeIterator* _tmp2_ = NULL;
	gchar** data = NULL;
	gint _tmp3_ = 0;
	gchar** _tmp4_ = NULL;
	gint data_length1 = 0;
	gint _data_size_ = 0;
	guint* idx = NULL;
	gint _tmp5_ = 0;
	guint* _tmp6_ = NULL;
	gint idx_length1 = 0;
	gint _idx_size_ = 0;
	gchar** _tmp7_ = NULL;
	gint _tmp7__length1 = 0;
	GeeCollection* _tmp11_ = NULL;
	GeeIterator* _tmp12_ = NULL;
	guint* found_times = NULL;
	gchar** _tmp13_ = NULL;
	gint _tmp13__length1 = 0;
	guint* _tmp14_ = NULL;
	gint found_times_length1 = 0;
	gint _found_times_size_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp1_ = self->test_collection;
	_tmp2_ = gee_iterable_iterator ((GeeIterable*) _tmp1_);
	iterator = _tmp2_;
	_tmp4_ = test_data_get_data (&_tmp3_);
	data = _tmp4_;
	data_length1 = _tmp3_;
	_data_size_ = data_length1;
	_tmp6_ = test_data_get_drawn_numbers (&_tmp5_);
	idx = _tmp6_;
	idx_length1 = _tmp5_;
	_idx_size_ = idx_length1;
	_tmp7_ = data;
	_tmp7__length1 = data_length1;
	{
		gchar** el_collection = NULL;
		gint el_collection_length1 = 0;
		gint _el_collection_size_ = 0;
		gint el_it = 0;
		el_collection = _tmp7_;
		el_collection_length1 = _tmp7__length1;
		for (el_it = 0; el_it < _tmp7__length1; el_it = el_it + 1) {
			const gchar* el = NULL;
			el = el_collection[el_it];
			{
				GeeCollection* _tmp8_ = NULL;
				const gchar* _tmp9_ = NULL;
				gboolean _tmp10_ = FALSE;
				_tmp8_ = self->test_collection;
				_tmp9_ = el;
				_tmp10_ = gee_collection_add (_tmp8_, _tmp9_);
				_vala_assert (_tmp10_, "test_collection.add (el)");
			}
		}
	}
	_tmp11_ = self->test_collection;
	_tmp12_ = gee_iterable_iterator ((GeeIterable*) _tmp11_);
	_g_object_unref0 (iterator);
	iterator = _tmp12_;
	_tmp13_ = data;
	_tmp13__length1 = data_length1;
	_tmp14_ = g_new0 (guint, _tmp13__length1);
	found_times = _tmp14_;
	found_times_length1 = _tmp13__length1;
	_found_times_size_ = found_times_length1;
	{
		guint i = 0U;
		i = (guint) 0;
		{
			gboolean _tmp15_ = FALSE;
			_tmp15_ = TRUE;
			while (TRUE) {
				gboolean _tmp16_ = FALSE;
				guint _tmp18_ = 0U;
				guint* _tmp19_ = NULL;
				gint _tmp19__length1 = 0;
				GeeCollection* _tmp28_ = NULL;
				GeeIterator* _tmp29_ = NULL;
				GeeIterator* _tmp30_ = NULL;
				gboolean _tmp31_ = FALSE;
				gboolean _tmp32_ = FALSE;
				gboolean last_removed = FALSE;
				GeeIterator* _tmp72_ = NULL;
				gboolean _tmp73_ = FALSE;
				gboolean _tmp74_ = FALSE;
				GeeIterator* _tmp75_ = NULL;
				gboolean _tmp76_ = FALSE;
				gboolean _tmp77_ = FALSE;
				gboolean _tmp78_ = FALSE;
				gboolean _tmp79_ = FALSE;
				GeeIterator* _tmp80_ = NULL;
				gboolean _tmp81_ = FALSE;
				GeeIterator* _tmp82_ = NULL;
				gboolean _tmp83_ = FALSE;
				gboolean _tmp84_ = FALSE;
				gboolean _tmp85_ = FALSE;
				_tmp16_ = _tmp15_;
				if (!_tmp16_) {
					guint _tmp17_ = 0U;
					_tmp17_ = i;
					i = _tmp17_ + 1;
				}
				_tmp15_ = FALSE;
				_tmp18_ = i;
				_tmp19_ = idx;
				_tmp19__length1 = idx_length1;
				if (!(_tmp18_ <= ((guint) _tmp19__length1))) {
					break;
				}
				{
					guint j = 0U;
					j = (guint) 0;
					{
						gboolean _tmp20_ = FALSE;
						_tmp20_ = TRUE;
						while (TRUE) {
							gboolean _tmp21_ = FALSE;
							guint _tmp23_ = 0U;
							guint* _tmp24_ = NULL;
							gint _tmp24__length1 = 0;
							guint* _tmp25_ = NULL;
							gint _tmp25__length1 = 0;
							guint _tmp26_ = 0U;
							guint _tmp27_ = 0U;
							_tmp21_ = _tmp20_;
							if (!_tmp21_) {
								guint _tmp22_ = 0U;
								_tmp22_ = j;
								j = _tmp22_ + 1;
							}
							_tmp20_ = FALSE;
							_tmp23_ = j;
							_tmp24_ = found_times;
							_tmp24__length1 = found_times_length1;
							if (!(_tmp23_ < ((guint) _tmp24__length1))) {
								break;
							}
							_tmp25_ = found_times;
							_tmp25__length1 = found_times_length1;
							_tmp26_ = j;
							_tmp25_[_tmp26_] = (guint) 0;
							_tmp27_ = _tmp25_[_tmp26_];
						}
					}
				}
				_tmp28_ = self->test_collection;
				_tmp29_ = gee_iterable_iterator ((GeeIterable*) _tmp28_);
				_g_object_unref0 (iterator);
				iterator = _tmp29_;
				_tmp30_ = iterator;
				_tmp31_ = gee_iterator_get_valid (_tmp30_);
				_tmp32_ = _tmp31_;
				_vala_assert (!_tmp32_, "! iterator.valid");
				last_removed = FALSE;
				while (TRUE) {
					GeeIterator* _tmp33_ = NULL;
					gboolean _tmp34_ = FALSE;
					gboolean _tmp35_ = FALSE;
					GeeIterator* _tmp36_ = NULL;
					gboolean _tmp37_ = FALSE;
					gboolean _tmp38_ = FALSE;
					gchar* element = NULL;
					GeeIterator* _tmp39_ = NULL;
					gpointer _tmp40_ = NULL;
					GeeIterator* _tmp41_ = NULL;
					gboolean _tmp42_ = FALSE;
					gboolean _tmp43_ = FALSE;
					_tmp33_ = iterator;
					_tmp34_ = gee_iterator_has_next (_tmp33_);
					has_next = _tmp34_;
					_tmp35_ = has_next;
					_tmp36_ = iterator;
					_tmp37_ = gee_iterator_next (_tmp36_);
					_vala_assert (_tmp35_ == _tmp37_, "has_next == iterator.next ()");
					_tmp38_ = has_next;
					if (!_tmp38_) {
						break;
					}
					_tmp39_ = iterator;
					_tmp40_ = gee_iterator_get (_tmp39_);
					element = (gchar*) _tmp40_;
					_tmp41_ = iterator;
					_tmp42_ = gee_iterator_get_valid (_tmp41_);
					_tmp43_ = _tmp42_;
					_vala_assert (_tmp43_, "iterator.valid");
					{
						guint element_idx = 0U;
						element_idx = (guint) 0;
						{
							gboolean _tmp44_ = FALSE;
							_tmp44_ = TRUE;
							while (TRUE) {
								gboolean _tmp45_ = FALSE;
								guint _tmp47_ = 0U;
								gchar** _tmp48_ = NULL;
								gint _tmp48__length1 = 0;
								gchar** _tmp49_ = NULL;
								gint _tmp49__length1 = 0;
								guint _tmp50_ = 0U;
								const gchar* _tmp51_ = NULL;
								const gchar* _tmp52_ = NULL;
								_tmp45_ = _tmp44_;
								if (!_tmp45_) {
									guint _tmp46_ = 0U;
									_tmp46_ = element_idx;
									element_idx = _tmp46_ + 1;
								}
								_tmp44_ = FALSE;
								_tmp47_ = element_idx;
								_tmp48_ = data;
								_tmp48__length1 = data_length1;
								_vala_assert (_tmp47_ < ((guint) _tmp48__length1), "element_idx < data.length");
								_tmp49_ = data;
								_tmp49__length1 = data_length1;
								_tmp50_ = element_idx;
								_tmp51_ = _tmp49_[_tmp50_];
								_tmp52_ = element;
								if (g_strcmp0 (_tmp51_, _tmp52_) == 0) {
									gboolean _tmp53_ = FALSE;
									guint _tmp54_ = 0U;
									guint* _tmp55_ = NULL;
									gint _tmp55__length1 = 0;
									gboolean _tmp64_ = FALSE;
									guint* _tmp69_ = NULL;
									gint _tmp69__length1 = 0;
									guint _tmp70_ = 0U;
									guint _tmp71_ = 0U;
									_tmp54_ = i;
									_tmp55_ = idx;
									_tmp55__length1 = idx_length1;
									if (_tmp54_ != ((guint) _tmp55__length1)) {
										gchar** _tmp56_ = NULL;
										gint _tmp56__length1 = 0;
										guint _tmp57_ = 0U;
										const gchar* _tmp58_ = NULL;
										gchar** _tmp59_ = NULL;
										gint _tmp59__length1 = 0;
										guint* _tmp60_ = NULL;
										gint _tmp60__length1 = 0;
										guint _tmp61_ = 0U;
										guint _tmp62_ = 0U;
										const gchar* _tmp63_ = NULL;
										_tmp56_ = data;
										_tmp56__length1 = data_length1;
										_tmp57_ = element_idx;
										_tmp58_ = _tmp56_[_tmp57_];
										_tmp59_ = data;
										_tmp59__length1 = data_length1;
										_tmp60_ = idx;
										_tmp60__length1 = idx_length1;
										_tmp61_ = i;
										_tmp62_ = _tmp60_[_tmp61_];
										_tmp63_ = _tmp59_[_tmp62_];
										_tmp53_ = g_strcmp0 (_tmp58_, _tmp63_) == 0;
									} else {
										_tmp53_ = FALSE;
									}
									_tmp64_ = _tmp53_;
									if (_tmp64_) {
										GeeIterator* _tmp65_ = NULL;
										GeeIterator* _tmp66_ = NULL;
										gboolean _tmp67_ = FALSE;
										gboolean _tmp68_ = FALSE;
										_tmp65_ = iterator;
										gee_iterator_remove (_tmp65_);
										_tmp66_ = iterator;
										_tmp67_ = gee_iterator_get_valid (_tmp66_);
										_tmp68_ = _tmp67_;
										_vala_assert (!_tmp68_, "! iterator.valid");
										last_removed = TRUE;
									} else {
										last_removed = FALSE;
									}
									_tmp69_ = found_times;
									_tmp69__length1 = found_times_length1;
									_tmp70_ = element_idx;
									_tmp71_ = _tmp69_[_tmp70_];
									_tmp69_[_tmp70_] = _tmp71_ + 1;
									break;
								}
							}
						}
					}
					_g_free0 (element);
				}
				_tmp72_ = iterator;
				_tmp73_ = gee_iterator_has_next (_tmp72_);
				has_next = _tmp73_;
				_tmp74_ = has_next;
				_vala_assert (!_tmp74_, "! has_next");
				_tmp75_ = iterator;
				_tmp76_ = gee_iterator_get_valid (_tmp75_);
				_tmp77_ = _tmp76_;
				_tmp78_ = last_removed;
				_vala_assert (_tmp77_ == (!_tmp78_), "iterator.valid == !last_removed");
				_tmp79_ = has_next;
				_tmp80_ = iterator;
				_tmp81_ = gee_iterator_next (_tmp80_);
				_vala_assert (_tmp79_ == _tmp81_, "has_next == iterator.next ()");
				_tmp82_ = iterator;
				_tmp83_ = gee_iterator_get_valid (_tmp82_);
				_tmp84_ = _tmp83_;
				_tmp85_ = last_removed;
				_vala_assert (_tmp84_ == (!_tmp85_), "iterator.valid == !last_removed");
				{
					guint j = 0U;
					j = (guint) 0;
					{
						gboolean _tmp86_ = FALSE;
						_tmp86_ = TRUE;
						while (TRUE) {
							gboolean _tmp87_ = FALSE;
							guint _tmp89_ = 0U;
							guint* _tmp90_ = NULL;
							gint _tmp90__length1 = 0;
							gboolean removed = FALSE;
							gint _tmp100_ = 0;
							gboolean _tmp101_ = FALSE;
							guint* _tmp102_ = NULL;
							gint _tmp102__length1 = 0;
							guint _tmp103_ = 0U;
							guint _tmp104_ = 0U;
							gint _tmp105_ = 0;
							_tmp87_ = _tmp86_;
							if (!_tmp87_) {
								guint _tmp88_ = 0U;
								_tmp88_ = j;
								j = _tmp88_ + 1;
							}
							_tmp86_ = FALSE;
							_tmp89_ = j;
							_tmp90_ = found_times;
							_tmp90__length1 = found_times_length1;
							if (!(_tmp89_ < ((guint) _tmp90__length1))) {
								break;
							}
							removed = FALSE;
							{
								gint k = 0;
								k = 0;
								{
									gboolean _tmp91_ = FALSE;
									_tmp91_ = TRUE;
									while (TRUE) {
										gboolean _tmp92_ = FALSE;
										gint _tmp94_ = 0;
										guint _tmp95_ = 0U;
										guint* _tmp96_ = NULL;
										gint _tmp96__length1 = 0;
										gint _tmp97_ = 0;
										guint _tmp98_ = 0U;
										guint _tmp99_ = 0U;
										_tmp92_ = _tmp91_;
										if (!_tmp92_) {
											gint _tmp93_ = 0;
											_tmp93_ = k;
											k = _tmp93_ + 1;
										}
										_tmp91_ = FALSE;
										_tmp94_ = k;
										_tmp95_ = i;
										if (!(((guint) _tmp94_) < _tmp95_)) {
											break;
										}
										_tmp96_ = idx;
										_tmp96__length1 = idx_length1;
										_tmp97_ = k;
										_tmp98_ = _tmp96_[_tmp97_];
										_tmp99_ = j;
										if (_tmp98_ == _tmp99_) {
											removed = TRUE;
											break;
										}
									}
								}
							}
							_tmp101_ = removed;
							if (_tmp101_) {
								_tmp100_ = 0;
							} else {
								_tmp100_ = 1;
							}
							_tmp102_ = found_times;
							_tmp102__length1 = found_times_length1;
							_tmp103_ = j;
							_tmp104_ = _tmp102_[_tmp103_];
							_tmp105_ = _tmp100_;
							_vala_assert (_tmp104_ == ((guint) _tmp105_), "found_times[j] == (removed ? 0 : 1)");
						}
					}
				}
			}
		}
	}
	found_times = (g_free (found_times), NULL);
	_g_object_unref0 (iterator);
}


void collection_tests_test_contains_size_and_is_empty (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	gchar** data = NULL;
	gint _tmp1_ = 0;
	gchar** _tmp2_ = NULL;
	gint data_length1 = 0;
	gint _data_size_ = 0;
	guint* idx = NULL;
	gint _tmp3_ = 0;
	guint* _tmp4_ = NULL;
	gint idx_length1 = 0;
	gint _idx_size_ = 0;
	gchar** _tmp5_ = NULL;
	gint _tmp5__length1 = 0;
	GeeCollection* _tmp9_ = NULL;
	gint _tmp10_ = 0;
	gint _tmp11_ = 0;
	GeeCollection* _tmp12_ = NULL;
	gboolean _tmp13_ = FALSE;
	gboolean _tmp14_ = FALSE;
	GeeCollection* _tmp15_ = NULL;
	gchar** _tmp16_ = NULL;
	gint _tmp16__length1 = 0;
	const gchar* _tmp17_ = NULL;
	gboolean _tmp18_ = FALSE;
	GeeCollection* _tmp19_ = NULL;
	gchar** _tmp20_ = NULL;
	gint _tmp20__length1 = 0;
	const gchar* _tmp21_ = NULL;
	gboolean _tmp22_ = FALSE;
	GeeCollection* _tmp33_ = NULL;
	gint _tmp34_ = 0;
	gint _tmp35_ = 0;
	GeeCollection* _tmp36_ = NULL;
	gboolean _tmp37_ = FALSE;
	gboolean _tmp38_ = FALSE;
	GeeCollection* _tmp39_ = NULL;
	gboolean _tmp40_ = FALSE;
	gchar** _tmp41_ = NULL;
	gint _tmp41__length1 = 0;
	GeeCollection* _tmp45_ = NULL;
	gint _tmp46_ = 0;
	gint _tmp47_ = 0;
	GeeCollection* _tmp48_ = NULL;
	gboolean _tmp49_ = FALSE;
	gboolean _tmp50_ = FALSE;
	GeeCollection* _tmp158_ = NULL;
	gchar** _tmp159_ = NULL;
	gint _tmp159__length1 = 0;
	GeeCollection* _tmp163_ = NULL;
	gint _tmp164_ = 0;
	gint _tmp165_ = 0;
	GeeCollection* _tmp166_ = NULL;
	gboolean _tmp167_ = FALSE;
	gboolean _tmp168_ = FALSE;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp2_ = test_data_get_data (&_tmp1_);
	data = _tmp2_;
	data_length1 = _tmp1_;
	_data_size_ = data_length1;
	_tmp4_ = test_data_get_drawn_numbers (&_tmp3_);
	idx = _tmp4_;
	idx_length1 = _tmp3_;
	_idx_size_ = idx_length1;
	_tmp5_ = data;
	_tmp5__length1 = data_length1;
	{
		gchar** s_collection = NULL;
		gint s_collection_length1 = 0;
		gint _s_collection_size_ = 0;
		gint s_it = 0;
		s_collection = _tmp5_;
		s_collection_length1 = _tmp5__length1;
		for (s_it = 0; s_it < _tmp5__length1; s_it = s_it + 1) {
			const gchar* s = NULL;
			s = s_collection[s_it];
			{
				GeeCollection* _tmp6_ = NULL;
				const gchar* _tmp7_ = NULL;
				gboolean _tmp8_ = FALSE;
				_tmp6_ = self->test_collection;
				_tmp7_ = s;
				_tmp8_ = gee_collection_contains (_tmp6_, _tmp7_);
				_vala_assert (!_tmp8_, "! test_collection.contains (s)");
			}
		}
	}
	_tmp9_ = self->test_collection;
	_tmp10_ = gee_collection_get_size (_tmp9_);
	_tmp11_ = _tmp10_;
	_vala_assert (_tmp11_ == 0, "test_collection.size == 0");
	_tmp12_ = self->test_collection;
	_tmp13_ = gee_collection_get_is_empty (_tmp12_);
	_tmp14_ = _tmp13_;
	_vala_assert (_tmp14_, "test_collection.is_empty");
	_tmp15_ = self->test_collection;
	_tmp16_ = data;
	_tmp16__length1 = data_length1;
	_tmp17_ = _tmp16_[0];
	_tmp18_ = gee_collection_add (_tmp15_, _tmp17_);
	_vala_assert (_tmp18_, "test_collection.add (data[0])");
	_tmp19_ = self->test_collection;
	_tmp20_ = data;
	_tmp20__length1 = data_length1;
	_tmp21_ = _tmp20_[0];
	_tmp22_ = gee_collection_contains (_tmp19_, _tmp21_);
	_vala_assert (_tmp22_, "test_collection.contains (data[0])");
	{
		guint i = 0U;
		i = (guint) 1;
		{
			gboolean _tmp23_ = FALSE;
			_tmp23_ = TRUE;
			while (TRUE) {
				gboolean _tmp24_ = FALSE;
				guint _tmp26_ = 0U;
				gchar** _tmp27_ = NULL;
				gint _tmp27__length1 = 0;
				GeeCollection* _tmp28_ = NULL;
				gchar** _tmp29_ = NULL;
				gint _tmp29__length1 = 0;
				guint _tmp30_ = 0U;
				const gchar* _tmp31_ = NULL;
				gboolean _tmp32_ = FALSE;
				_tmp24_ = _tmp23_;
				if (!_tmp24_) {
					guint _tmp25_ = 0U;
					_tmp25_ = i;
					i = _tmp25_ + 1;
				}
				_tmp23_ = FALSE;
				_tmp26_ = i;
				_tmp27_ = data;
				_tmp27__length1 = data_length1;
				if (!(_tmp26_ < ((guint) _tmp27__length1))) {
					break;
				}
				_tmp28_ = self->test_collection;
				_tmp29_ = data;
				_tmp29__length1 = data_length1;
				_tmp30_ = i;
				_tmp31_ = _tmp29_[_tmp30_];
				_tmp32_ = gee_collection_contains (_tmp28_, _tmp31_);
				_vala_assert (!_tmp32_, "! test_collection.contains (data[i])");
			}
		}
	}
	_tmp33_ = self->test_collection;
	_tmp34_ = gee_collection_get_size (_tmp33_);
	_tmp35_ = _tmp34_;
	_vala_assert (_tmp35_ == 1, "test_collection.size == 1");
	_tmp36_ = self->test_collection;
	_tmp37_ = gee_collection_get_is_empty (_tmp36_);
	_tmp38_ = _tmp37_;
	_vala_assert (!_tmp38_, "! test_collection.is_empty");
	_tmp39_ = self->test_collection;
	_tmp40_ = gee_collection_remove (_tmp39_, "one");
	_vala_assert (_tmp40_, "test_collection.remove (\"one\")");
	_tmp41_ = data;
	_tmp41__length1 = data_length1;
	{
		gchar** s_collection = NULL;
		gint s_collection_length1 = 0;
		gint _s_collection_size_ = 0;
		gint s_it = 0;
		s_collection = _tmp41_;
		s_collection_length1 = _tmp41__length1;
		for (s_it = 0; s_it < _tmp41__length1; s_it = s_it + 1) {
			const gchar* s = NULL;
			s = s_collection[s_it];
			{
				GeeCollection* _tmp42_ = NULL;
				const gchar* _tmp43_ = NULL;
				gboolean _tmp44_ = FALSE;
				_tmp42_ = self->test_collection;
				_tmp43_ = s;
				_tmp44_ = gee_collection_contains (_tmp42_, _tmp43_);
				_vala_assert (!_tmp44_, "! test_collection.contains (s)");
			}
		}
	}
	_tmp45_ = self->test_collection;
	_tmp46_ = gee_collection_get_size (_tmp45_);
	_tmp47_ = _tmp46_;
	_vala_assert (_tmp47_ == 0, "test_collection.size == 0");
	_tmp48_ = self->test_collection;
	_tmp49_ = gee_collection_get_is_empty (_tmp48_);
	_tmp50_ = _tmp49_;
	_vala_assert (_tmp50_, "test_collection.is_empty");
	{
		guint i = 0U;
		i = (guint) 0;
		{
			gboolean _tmp51_ = FALSE;
			_tmp51_ = TRUE;
			while (TRUE) {
				gboolean _tmp52_ = FALSE;
				guint _tmp54_ = 0U;
				gchar** _tmp55_ = NULL;
				gint _tmp55__length1 = 0;
				GeeCollection* _tmp56_ = NULL;
				gchar** _tmp57_ = NULL;
				gint _tmp57__length1 = 0;
				guint _tmp58_ = 0U;
				const gchar* _tmp59_ = NULL;
				gboolean _tmp60_ = FALSE;
				GeeCollection* _tmp82_ = NULL;
				gint _tmp83_ = 0;
				gint _tmp84_ = 0;
				guint _tmp85_ = 0U;
				GeeCollection* _tmp86_ = NULL;
				gboolean _tmp87_ = FALSE;
				gboolean _tmp88_ = FALSE;
				_tmp52_ = _tmp51_;
				if (!_tmp52_) {
					guint _tmp53_ = 0U;
					_tmp53_ = i;
					i = _tmp53_ + 1;
				}
				_tmp51_ = FALSE;
				_tmp54_ = i;
				_tmp55_ = data;
				_tmp55__length1 = data_length1;
				if (!(_tmp54_ < ((guint) _tmp55__length1))) {
					break;
				}
				_tmp56_ = self->test_collection;
				_tmp57_ = data;
				_tmp57__length1 = data_length1;
				_tmp58_ = i;
				_tmp59_ = _tmp57_[_tmp58_];
				_tmp60_ = gee_collection_add (_tmp56_, _tmp59_);
				_vala_assert (_tmp60_, "test_collection.add (data[i])");
				{
					guint j = 0U;
					j = (guint) 0;
					{
						gboolean _tmp61_ = FALSE;
						_tmp61_ = TRUE;
						while (TRUE) {
							gboolean _tmp62_ = FALSE;
							guint _tmp64_ = 0U;
							guint _tmp65_ = 0U;
							GeeCollection* _tmp66_ = NULL;
							gchar** _tmp67_ = NULL;
							gint _tmp67__length1 = 0;
							guint _tmp68_ = 0U;
							const gchar* _tmp69_ = NULL;
							gboolean _tmp70_ = FALSE;
							_tmp62_ = _tmp61_;
							if (!_tmp62_) {
								guint _tmp63_ = 0U;
								_tmp63_ = j;
								j = _tmp63_ + 1;
							}
							_tmp61_ = FALSE;
							_tmp64_ = j;
							_tmp65_ = i;
							if (!(_tmp64_ <= _tmp65_)) {
								break;
							}
							_tmp66_ = self->test_collection;
							_tmp67_ = data;
							_tmp67__length1 = data_length1;
							_tmp68_ = j;
							_tmp69_ = _tmp67_[_tmp68_];
							_tmp70_ = gee_collection_contains (_tmp66_, _tmp69_);
							_vala_assert (_tmp70_, "test_collection.contains (data[j])");
						}
					}
				}
				{
					guint j = 0U;
					guint _tmp71_ = 0U;
					_tmp71_ = i;
					j = _tmp71_ + 1;
					{
						gboolean _tmp72_ = FALSE;
						_tmp72_ = TRUE;
						while (TRUE) {
							gboolean _tmp73_ = FALSE;
							guint _tmp75_ = 0U;
							gchar** _tmp76_ = NULL;
							gint _tmp76__length1 = 0;
							GeeCollection* _tmp77_ = NULL;
							gchar** _tmp78_ = NULL;
							gint _tmp78__length1 = 0;
							guint _tmp79_ = 0U;
							const gchar* _tmp80_ = NULL;
							gboolean _tmp81_ = FALSE;
							_tmp73_ = _tmp72_;
							if (!_tmp73_) {
								guint _tmp74_ = 0U;
								_tmp74_ = j;
								j = _tmp74_ + 1;
							}
							_tmp72_ = FALSE;
							_tmp75_ = j;
							_tmp76_ = data;
							_tmp76__length1 = data_length1;
							if (!(_tmp75_ < ((guint) _tmp76__length1))) {
								break;
							}
							_tmp77_ = self->test_collection;
							_tmp78_ = data;
							_tmp78__length1 = data_length1;
							_tmp79_ = j;
							_tmp80_ = _tmp78_[_tmp79_];
							_tmp81_ = gee_collection_contains (_tmp77_, _tmp80_);
							_vala_assert (!_tmp81_, "! test_collection.contains (data[j])");
						}
					}
				}
				_tmp82_ = self->test_collection;
				_tmp83_ = gee_collection_get_size (_tmp82_);
				_tmp84_ = _tmp83_;
				_tmp85_ = i;
				_vala_assert (((guint) _tmp84_) == (_tmp85_ + 1), "test_collection.size == i + 1");
				_tmp86_ = self->test_collection;
				_tmp87_ = gee_collection_get_is_empty (_tmp86_);
				_tmp88_ = _tmp87_;
				_vala_assert (!_tmp88_, "! test_collection.is_empty");
			}
		}
	}
	{
		guint i = 0U;
		i = (guint) 0;
		{
			gboolean _tmp89_ = FALSE;
			_tmp89_ = TRUE;
			while (TRUE) {
				gboolean _tmp90_ = FALSE;
				guint _tmp92_ = 0U;
				guint* _tmp93_ = NULL;
				gint _tmp93__length1 = 0;
				GeeCollection* _tmp94_ = NULL;
				gchar** _tmp95_ = NULL;
				gint _tmp95__length1 = 0;
				guint* _tmp96_ = NULL;
				gint _tmp96__length1 = 0;
				guint _tmp97_ = 0U;
				guint _tmp98_ = 0U;
				const gchar* _tmp99_ = NULL;
				gboolean _tmp100_ = FALSE;
				GeeCollection* _tmp121_ = NULL;
				gint _tmp122_ = 0;
				gint _tmp123_ = 0;
				gchar** _tmp124_ = NULL;
				gint _tmp124__length1 = 0;
				guint _tmp125_ = 0U;
				GeeCollection* _tmp126_ = NULL;
				gchar** _tmp127_ = NULL;
				gint _tmp127__length1 = 0;
				guint* _tmp128_ = NULL;
				gint _tmp128__length1 = 0;
				guint _tmp129_ = 0U;
				guint _tmp130_ = 0U;
				const gchar* _tmp131_ = NULL;
				gboolean _tmp132_ = FALSE;
				GeeCollection* _tmp153_ = NULL;
				gint _tmp154_ = 0;
				gint _tmp155_ = 0;
				gchar** _tmp156_ = NULL;
				gint _tmp156__length1 = 0;
				guint _tmp157_ = 0U;
				_tmp90_ = _tmp89_;
				if (!_tmp90_) {
					guint _tmp91_ = 0U;
					_tmp91_ = i;
					i = _tmp91_ + 1;
				}
				_tmp89_ = FALSE;
				_tmp92_ = i;
				_tmp93_ = idx;
				_tmp93__length1 = idx_length1;
				if (!(_tmp92_ < ((guint) _tmp93__length1))) {
					break;
				}
				_tmp94_ = self->test_collection;
				_tmp95_ = data;
				_tmp95__length1 = data_length1;
				_tmp96_ = idx;
				_tmp96__length1 = idx_length1;
				_tmp97_ = i;
				_tmp98_ = _tmp96_[_tmp97_];
				_tmp99_ = _tmp95_[_tmp98_];
				_tmp100_ = gee_collection_remove (_tmp94_, _tmp99_);
				_vala_assert (_tmp100_, "test_collection.remove (data[idx[i]])");
				{
					guint j = 0U;
					j = (guint) 0;
					{
						gboolean _tmp101_ = FALSE;
						_tmp101_ = TRUE;
						while (TRUE) {
							gboolean _tmp102_ = FALSE;
							guint _tmp104_ = 0U;
							gchar** _tmp105_ = NULL;
							gint _tmp105__length1 = 0;
							gboolean removed = FALSE;
							GeeCollection* _tmp115_ = NULL;
							gchar** _tmp116_ = NULL;
							gint _tmp116__length1 = 0;
							guint _tmp117_ = 0U;
							const gchar* _tmp118_ = NULL;
							gboolean _tmp119_ = FALSE;
							gboolean _tmp120_ = FALSE;
							_tmp102_ = _tmp101_;
							if (!_tmp102_) {
								guint _tmp103_ = 0U;
								_tmp103_ = j;
								j = _tmp103_ + 1;
							}
							_tmp101_ = FALSE;
							_tmp104_ = j;
							_tmp105_ = data;
							_tmp105__length1 = data_length1;
							if (!(_tmp104_ < ((guint) _tmp105__length1))) {
								break;
							}
							removed = FALSE;
							{
								guint k = 0U;
								k = (guint) 0;
								{
									gboolean _tmp106_ = FALSE;
									_tmp106_ = TRUE;
									while (TRUE) {
										gboolean _tmp107_ = FALSE;
										guint _tmp109_ = 0U;
										guint _tmp110_ = 0U;
										guint* _tmp111_ = NULL;
										gint _tmp111__length1 = 0;
										guint _tmp112_ = 0U;
										guint _tmp113_ = 0U;
										guint _tmp114_ = 0U;
										_tmp107_ = _tmp106_;
										if (!_tmp107_) {
											guint _tmp108_ = 0U;
											_tmp108_ = k;
											k = _tmp108_ + 1;
										}
										_tmp106_ = FALSE;
										_tmp109_ = k;
										_tmp110_ = i;
										if (!(_tmp109_ <= _tmp110_)) {
											break;
										}
										_tmp111_ = idx;
										_tmp111__length1 = idx_length1;
										_tmp112_ = k;
										_tmp113_ = _tmp111_[_tmp112_];
										_tmp114_ = j;
										if (_tmp113_ == _tmp114_) {
											removed = TRUE;
											break;
										}
									}
								}
							}
							_tmp115_ = self->test_collection;
							_tmp116_ = data;
							_tmp116__length1 = data_length1;
							_tmp117_ = j;
							_tmp118_ = _tmp116_[_tmp117_];
							_tmp119_ = gee_collection_contains (_tmp115_, _tmp118_);
							_tmp120_ = removed;
							_vala_assert (_tmp119_ == (!_tmp120_), "test_collection.contains (data[j]) == !removed");
						}
					}
				}
				_tmp121_ = self->test_collection;
				_tmp122_ = gee_collection_get_size (_tmp121_);
				_tmp123_ = _tmp122_;
				_tmp124_ = data;
				_tmp124__length1 = data_length1;
				_tmp125_ = i;
				_vala_assert (((guint) _tmp123_) == (_tmp124__length1 - (_tmp125_ + 1)), "test_collection.size == data.length - (i + 1)");
				_tmp126_ = self->test_collection;
				_tmp127_ = data;
				_tmp127__length1 = data_length1;
				_tmp128_ = idx;
				_tmp128__length1 = idx_length1;
				_tmp129_ = i;
				_tmp130_ = _tmp128_[_tmp129_];
				_tmp131_ = _tmp127_[_tmp130_];
				_tmp132_ = gee_collection_remove (_tmp126_, _tmp131_);
				_vala_assert (!_tmp132_, "! test_collection.remove (data[idx[i]])");
				{
					guint j = 0U;
					j = (guint) 0;
					{
						gboolean _tmp133_ = FALSE;
						_tmp133_ = TRUE;
						while (TRUE) {
							gboolean _tmp134_ = FALSE;
							guint _tmp136_ = 0U;
							gchar** _tmp137_ = NULL;
							gint _tmp137__length1 = 0;
							gboolean removed = FALSE;
							GeeCollection* _tmp147_ = NULL;
							gchar** _tmp148_ = NULL;
							gint _tmp148__length1 = 0;
							guint _tmp149_ = 0U;
							const gchar* _tmp150_ = NULL;
							gboolean _tmp151_ = FALSE;
							gboolean _tmp152_ = FALSE;
							_tmp134_ = _tmp133_;
							if (!_tmp134_) {
								guint _tmp135_ = 0U;
								_tmp135_ = j;
								j = _tmp135_ + 1;
							}
							_tmp133_ = FALSE;
							_tmp136_ = j;
							_tmp137_ = data;
							_tmp137__length1 = data_length1;
							if (!(_tmp136_ < ((guint) _tmp137__length1))) {
								break;
							}
							removed = FALSE;
							{
								guint k = 0U;
								k = (guint) 0;
								{
									gboolean _tmp138_ = FALSE;
									_tmp138_ = TRUE;
									while (TRUE) {
										gboolean _tmp139_ = FALSE;
										guint _tmp141_ = 0U;
										guint _tmp142_ = 0U;
										guint* _tmp143_ = NULL;
										gint _tmp143__length1 = 0;
										guint _tmp144_ = 0U;
										guint _tmp145_ = 0U;
										guint _tmp146_ = 0U;
										_tmp139_ = _tmp138_;
										if (!_tmp139_) {
											guint _tmp140_ = 0U;
											_tmp140_ = k;
											k = _tmp140_ + 1;
										}
										_tmp138_ = FALSE;
										_tmp141_ = k;
										_tmp142_ = i;
										if (!(_tmp141_ <= _tmp142_)) {
											break;
										}
										_tmp143_ = idx;
										_tmp143__length1 = idx_length1;
										_tmp144_ = k;
										_tmp145_ = _tmp143_[_tmp144_];
										_tmp146_ = j;
										if (_tmp145_ == _tmp146_) {
											removed = TRUE;
											break;
										}
									}
								}
							}
							_tmp147_ = self->test_collection;
							_tmp148_ = data;
							_tmp148__length1 = data_length1;
							_tmp149_ = j;
							_tmp150_ = _tmp148_[_tmp149_];
							_tmp151_ = gee_collection_contains (_tmp147_, _tmp150_);
							_tmp152_ = removed;
							_vala_assert (_tmp151_ == (!_tmp152_), "test_collection.contains (data[j]) == !removed");
						}
					}
				}
				_tmp153_ = self->test_collection;
				_tmp154_ = gee_collection_get_size (_tmp153_);
				_tmp155_ = _tmp154_;
				_tmp156_ = data;
				_tmp156__length1 = data_length1;
				_tmp157_ = i;
				_vala_assert (((guint) _tmp155_) == (_tmp156__length1 - (_tmp157_ + 1)), "test_collection.size == data.length - (i + 1)");
			}
		}
	}
	_tmp158_ = self->test_collection;
	gee_collection_clear (_tmp158_);
	_tmp159_ = data;
	_tmp159__length1 = data_length1;
	{
		gchar** el_collection = NULL;
		gint el_collection_length1 = 0;
		gint _el_collection_size_ = 0;
		gint el_it = 0;
		el_collection = _tmp159_;
		el_collection_length1 = _tmp159__length1;
		for (el_it = 0; el_it < _tmp159__length1; el_it = el_it + 1) {
			const gchar* el = NULL;
			el = el_collection[el_it];
			{
				GeeCollection* _tmp160_ = NULL;
				const gchar* _tmp161_ = NULL;
				gboolean _tmp162_ = FALSE;
				_tmp160_ = self->test_collection;
				_tmp161_ = el;
				_tmp162_ = gee_collection_contains (_tmp160_, _tmp161_);
				_vala_assert (!_tmp162_, "! test_collection.contains (el)");
			}
		}
	}
	_tmp163_ = self->test_collection;
	_tmp164_ = gee_collection_get_size (_tmp163_);
	_tmp165_ = _tmp164_;
	_vala_assert (_tmp165_ == 0, "test_collection.size == 0");
	_tmp166_ = self->test_collection;
	_tmp167_ = gee_collection_get_is_empty (_tmp166_);
	_tmp168_ = _tmp167_;
	_vala_assert (_tmp168_, "test_collection.is_empty");
}


void collection_tests_test_add_remove (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	gchar** to_add = NULL;
	gint _tmp1_ = 0;
	gchar** _tmp2_ = NULL;
	gint to_add_length1 = 0;
	gint _to_add_size_ = 0;
	gint expected_size = 0;
	gchar** _tmp3_ = NULL;
	gint _tmp3__length1 = 0;
	GeeCollection* _tmp18_ = NULL;
	gint _tmp19_ = 0;
	gint _tmp20_ = 0;
	gchar** _tmp21_ = NULL;
	gint _tmp21__length1 = 0;
	gchar** _tmp22_ = NULL;
	gint _tmp22__length1 = 0;
	gchar** _tmp27_ = NULL;
	gint _tmp27__length1 = 0;
	GeeCollection* _tmp42_ = NULL;
	gint _tmp43_ = 0;
	gint _tmp44_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp2_ = test_data_get_data (&_tmp1_);
	to_add = _tmp2_;
	to_add_length1 = _tmp1_;
	_to_add_size_ = to_add_length1;
	expected_size = 0;
	_tmp3_ = to_add;
	_tmp3__length1 = to_add_length1;
	{
		gchar** a_collection = NULL;
		gint a_collection_length1 = 0;
		gint _a_collection_size_ = 0;
		gint a_it = 0;
		a_collection = _tmp3_;
		a_collection_length1 = _tmp3__length1;
		for (a_it = 0; a_it < _tmp3__length1; a_it = a_it + 1) {
			gchar* _tmp4_ = NULL;
			gchar* a = NULL;
			_tmp4_ = g_strdup (a_collection[a_it]);
			a = _tmp4_;
			{
				GeeCollection* _tmp5_ = NULL;
				const gchar* _tmp6_ = NULL;
				gboolean _tmp7_ = FALSE;
				GeeCollection* _tmp8_ = NULL;
				gint _tmp9_ = 0;
				gint _tmp10_ = 0;
				gint _tmp11_ = 0;
				GeeCollection* _tmp12_ = NULL;
				const gchar* _tmp13_ = NULL;
				gboolean _tmp14_ = FALSE;
				GeeCollection* _tmp15_ = NULL;
				const gchar* _tmp16_ = NULL;
				gboolean _tmp17_ = FALSE;
				_tmp5_ = self->test_collection;
				_tmp6_ = a;
				_tmp7_ = gee_collection_contains (_tmp5_, _tmp6_);
				_vala_assert (!_tmp7_, "!test_collection.contains (a)");
				_tmp8_ = self->test_collection;
				_tmp9_ = gee_collection_get_size (_tmp8_);
				_tmp10_ = _tmp9_;
				_tmp11_ = expected_size;
				expected_size = _tmp11_ + 1;
				_vala_assert (_tmp10_ == _tmp11_, "test_collection.size == expected_size++");
				_tmp12_ = self->test_collection;
				_tmp13_ = a;
				_tmp14_ = gee_collection_add (_tmp12_, _tmp13_);
				_vala_assert (_tmp14_, "test_collection.add (a)");
				_tmp15_ = self->test_collection;
				_tmp16_ = a;
				_tmp17_ = gee_collection_contains (_tmp15_, _tmp16_);
				_vala_assert (_tmp17_, "test_collection.contains (a)");
				_g_free0 (a);
			}
		}
	}
	_tmp18_ = self->test_collection;
	_tmp19_ = gee_collection_get_size (_tmp18_);
	_tmp20_ = _tmp19_;
	_tmp21_ = to_add;
	_tmp21__length1 = to_add_length1;
	_vala_assert (_tmp20_ == _tmp21__length1, "test_collection.size == to_add.length");
	_tmp22_ = to_add;
	_tmp22__length1 = to_add_length1;
	{
		gchar** a_collection = NULL;
		gint a_collection_length1 = 0;
		gint _a_collection_size_ = 0;
		gint a_it = 0;
		a_collection = _tmp22_;
		a_collection_length1 = _tmp22__length1;
		for (a_it = 0; a_it < _tmp22__length1; a_it = a_it + 1) {
			gchar* _tmp23_ = NULL;
			gchar* a = NULL;
			_tmp23_ = g_strdup (a_collection[a_it]);
			a = _tmp23_;
			{
				GeeCollection* _tmp24_ = NULL;
				const gchar* _tmp25_ = NULL;
				gboolean _tmp26_ = FALSE;
				_tmp24_ = self->test_collection;
				_tmp25_ = a;
				_tmp26_ = gee_collection_contains (_tmp24_, _tmp25_);
				_vala_assert (_tmp26_, "test_collection.contains (a)");
				_g_free0 (a);
			}
		}
	}
	_tmp27_ = to_add;
	_tmp27__length1 = to_add_length1;
	{
		gchar** a_collection = NULL;
		gint a_collection_length1 = 0;
		gint _a_collection_size_ = 0;
		gint a_it = 0;
		a_collection = _tmp27_;
		a_collection_length1 = _tmp27__length1;
		for (a_it = 0; a_it < _tmp27__length1; a_it = a_it + 1) {
			gchar* _tmp28_ = NULL;
			gchar* a = NULL;
			_tmp28_ = g_strdup (a_collection[a_it]);
			a = _tmp28_;
			{
				GeeCollection* _tmp29_ = NULL;
				const gchar* _tmp30_ = NULL;
				gboolean _tmp31_ = FALSE;
				GeeCollection* _tmp32_ = NULL;
				gint _tmp33_ = 0;
				gint _tmp34_ = 0;
				gint _tmp35_ = 0;
				GeeCollection* _tmp36_ = NULL;
				const gchar* _tmp37_ = NULL;
				gboolean _tmp38_ = FALSE;
				GeeCollection* _tmp39_ = NULL;
				const gchar* _tmp40_ = NULL;
				gboolean _tmp41_ = FALSE;
				_tmp29_ = self->test_collection;
				_tmp30_ = a;
				_tmp31_ = gee_collection_contains (_tmp29_, _tmp30_);
				_vala_assert (_tmp31_, "test_collection.contains (a)");
				_tmp32_ = self->test_collection;
				_tmp33_ = gee_collection_get_size (_tmp32_);
				_tmp34_ = _tmp33_;
				_tmp35_ = expected_size;
				expected_size = _tmp35_ - 1;
				_vala_assert (_tmp34_ == _tmp35_, "test_collection.size == expected_size--");
				_tmp36_ = self->test_collection;
				_tmp37_ = a;
				_tmp38_ = gee_collection_remove (_tmp36_, _tmp37_);
				_vala_assert (_tmp38_, "test_collection.remove (a)");
				_tmp39_ = self->test_collection;
				_tmp40_ = a;
				_tmp41_ = gee_collection_contains (_tmp39_, _tmp40_);
				_vala_assert (!_tmp41_, "!test_collection.contains (a)");
				_g_free0 (a);
			}
		}
	}
	_tmp42_ = self->test_collection;
	_tmp43_ = gee_collection_get_size (_tmp42_);
	_tmp44_ = _tmp43_;
	_vala_assert (_tmp44_ == 0, "test_collection.size == 0");
}


void collection_tests_test_clear (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	gchar** to_add = NULL;
	gint _tmp1_ = 0;
	gchar** _tmp2_ = NULL;
	gint to_add_length1 = 0;
	gint _to_add_size_ = 0;
	gint expected_size = 0;
	gchar** _tmp3_ = NULL;
	gint _tmp3__length1 = 0;
	GeeCollection* _tmp18_ = NULL;
	gint _tmp19_ = 0;
	gint _tmp20_ = 0;
	gchar** _tmp21_ = NULL;
	gint _tmp21__length1 = 0;
	GeeCollection* _tmp22_ = NULL;
	GeeCollection* _tmp23_ = NULL;
	gint _tmp24_ = 0;
	gint _tmp25_ = 0;
	GeeIterator* iter = NULL;
	GeeCollection* _tmp26_ = NULL;
	GeeIterator* _tmp27_ = NULL;
	gboolean _tmp28_ = FALSE;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp2_ = test_data_get_data (&_tmp1_);
	to_add = _tmp2_;
	to_add_length1 = _tmp1_;
	_to_add_size_ = to_add_length1;
	expected_size = 0;
	_tmp3_ = to_add;
	_tmp3__length1 = to_add_length1;
	{
		gchar** a_collection = NULL;
		gint a_collection_length1 = 0;
		gint _a_collection_size_ = 0;
		gint a_it = 0;
		a_collection = _tmp3_;
		a_collection_length1 = _tmp3__length1;
		for (a_it = 0; a_it < _tmp3__length1; a_it = a_it + 1) {
			gchar* _tmp4_ = NULL;
			gchar* a = NULL;
			_tmp4_ = g_strdup (a_collection[a_it]);
			a = _tmp4_;
			{
				GeeCollection* _tmp5_ = NULL;
				const gchar* _tmp6_ = NULL;
				gboolean _tmp7_ = FALSE;
				GeeCollection* _tmp8_ = NULL;
				gint _tmp9_ = 0;
				gint _tmp10_ = 0;
				gint _tmp11_ = 0;
				GeeCollection* _tmp12_ = NULL;
				const gchar* _tmp13_ = NULL;
				gboolean _tmp14_ = FALSE;
				GeeCollection* _tmp15_ = NULL;
				const gchar* _tmp16_ = NULL;
				gboolean _tmp17_ = FALSE;
				_tmp5_ = self->test_collection;
				_tmp6_ = a;
				_tmp7_ = gee_collection_contains (_tmp5_, _tmp6_);
				_vala_assert (!_tmp7_, "!test_collection.contains (a)");
				_tmp8_ = self->test_collection;
				_tmp9_ = gee_collection_get_size (_tmp8_);
				_tmp10_ = _tmp9_;
				_tmp11_ = expected_size;
				expected_size = _tmp11_ + 1;
				_vala_assert (_tmp10_ == _tmp11_, "test_collection.size == expected_size++");
				_tmp12_ = self->test_collection;
				_tmp13_ = a;
				_tmp14_ = gee_collection_add (_tmp12_, _tmp13_);
				_vala_assert (_tmp14_, "test_collection.add (a)");
				_tmp15_ = self->test_collection;
				_tmp16_ = a;
				_tmp17_ = gee_collection_contains (_tmp15_, _tmp16_);
				_vala_assert (_tmp17_, "test_collection.contains (a)");
				_g_free0 (a);
			}
		}
	}
	_tmp18_ = self->test_collection;
	_tmp19_ = gee_collection_get_size (_tmp18_);
	_tmp20_ = _tmp19_;
	_tmp21_ = to_add;
	_tmp21__length1 = to_add_length1;
	_vala_assert (_tmp20_ == _tmp21__length1, "test_collection.size == to_add.length");
	_tmp22_ = self->test_collection;
	gee_collection_clear (_tmp22_);
	_tmp23_ = self->test_collection;
	_tmp24_ = gee_collection_get_size (_tmp23_);
	_tmp25_ = _tmp24_;
	_vala_assert (_tmp25_ == 0, "test_collection.size == 0");
	_tmp26_ = self->test_collection;
	_tmp27_ = gee_iterable_iterator ((GeeIterable*) _tmp26_);
	iter = _tmp27_;
	_vala_assert (iter != NULL, "iter != null");
	_tmp28_ = gee_iterator_has_next (iter);
	_vala_assert (!_tmp28_, "!iter.has_next ()");
	_g_object_unref0 (iter);
}


void collection_tests_test_add_all (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	GeeArrayList* dummy = NULL;
	GeeArrayList* _tmp1_ = NULL;
	GeeCollection* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	gboolean _tmp6_ = FALSE;
	gboolean _tmp7_ = FALSE;
	gboolean _tmp8_ = FALSE;
	GeeCollection* _tmp9_ = NULL;
	gboolean _tmp10_ = FALSE;
	GeeCollection* _tmp11_ = NULL;
	gboolean _tmp12_ = FALSE;
	GeeCollection* _tmp13_ = NULL;
	gint _tmp14_ = 0;
	gint _tmp15_ = 0;
	GeeCollection* _tmp16_ = NULL;
	gboolean _tmp17_ = FALSE;
	GeeCollection* _tmp18_ = NULL;
	gboolean _tmp19_ = FALSE;
	gboolean _tmp20_ = FALSE;
	gboolean _tmp21_ = FALSE;
	GeeCollection* _tmp22_ = NULL;
	gboolean _tmp23_ = FALSE;
	GeeCollection* _tmp24_ = NULL;
	gint _tmp25_ = 0;
	gint _tmp26_ = 0;
	GeeCollection* _tmp27_ = NULL;
	gboolean _tmp28_ = FALSE;
	GeeCollection* _tmp29_ = NULL;
	gboolean _tmp30_ = FALSE;
	GeeCollection* _tmp31_ = NULL;
	gboolean _tmp32_ = FALSE;
	gint _tmp33_ = 0;
	gint _tmp34_ = 0;
	gboolean _tmp35_ = FALSE;
	gboolean _tmp36_ = FALSE;
	gboolean _tmp37_ = FALSE;
	GeeCollection* _tmp38_ = NULL;
	gboolean _tmp39_ = FALSE;
	gboolean _tmp40_ = FALSE;
	gboolean _tmp41_ = FALSE;
	GeeCollection* _tmp42_ = NULL;
	gboolean _tmp43_ = FALSE;
	GeeCollection* _tmp44_ = NULL;
	gboolean _tmp45_ = FALSE;
	GeeCollection* _tmp46_ = NULL;
	gint _tmp47_ = 0;
	gint _tmp48_ = 0;
	GeeCollection* _tmp49_ = NULL;
	gboolean _tmp50_ = FALSE;
	GeeCollection* _tmp51_ = NULL;
	gboolean _tmp52_ = FALSE;
	GeeCollection* _tmp53_ = NULL;
	gboolean _tmp54_ = FALSE;
	GeeCollection* _tmp55_ = NULL;
	gboolean _tmp56_ = FALSE;
	gint _tmp57_ = 0;
	gint _tmp58_ = 0;
	gboolean _tmp59_ = FALSE;
	gboolean _tmp60_ = FALSE;
	gboolean _tmp61_ = FALSE;
	GeeCollection* _tmp62_ = NULL;
	gboolean _tmp63_ = FALSE;
	gboolean _tmp64_ = FALSE;
	gboolean _tmp65_ = FALSE;
	GeeCollection* _tmp66_ = NULL;
	gboolean _tmp67_ = FALSE;
	GeeCollection* _tmp68_ = NULL;
	gboolean _tmp69_ = FALSE;
	GeeCollection* _tmp70_ = NULL;
	gint _tmp71_ = 0;
	gint _tmp72_ = 0;
	GeeCollection* _tmp73_ = NULL;
	gboolean _tmp74_ = FALSE;
	GeeCollection* _tmp75_ = NULL;
	gboolean _tmp76_ = FALSE;
	GeeCollection* _tmp77_ = NULL;
	gboolean _tmp78_ = FALSE;
	gint _tmp79_ = 0;
	gint _tmp80_ = 0;
	gboolean _tmp81_ = FALSE;
	gboolean _tmp82_ = FALSE;
	gboolean _tmp83_ = FALSE;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp1_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);
	dummy = _tmp1_;
	_tmp2_ = self->test_collection;
	_tmp3_ = gee_collection_add_all (_tmp2_, (GeeCollection*) dummy);
	_vala_assert (!_tmp3_, "! test_collection.add_all (dummy)");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_get_is_empty (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_assert (_tmp6_, "test_collection.is_empty");
	_tmp7_ = gee_collection_get_is_empty ((GeeCollection*) dummy);
	_tmp8_ = _tmp7_;
	_vala_assert (_tmp8_, "dummy.is_empty");
	_tmp9_ = self->test_collection;
	_tmp10_ = gee_collection_add (_tmp9_, "hello");
	_vala_assert (_tmp10_, "test_collection.add (\"hello\")");
	_tmp11_ = self->test_collection;
	_tmp12_ = gee_collection_add_all (_tmp11_, (GeeCollection*) dummy);
	_vala_assert (!_tmp12_, "! test_collection.add_all (dummy)");
	_tmp13_ = self->test_collection;
	_tmp14_ = gee_collection_get_size (_tmp13_);
	_tmp15_ = _tmp14_;
	_vala_assert (_tmp15_ == 1, "test_collection.size == 1");
	_tmp16_ = self->test_collection;
	_tmp17_ = gee_collection_contains (_tmp16_, "hello");
	_vala_assert (_tmp17_, "test_collection.contains (\"hello\")");
	_tmp18_ = self->test_collection;
	gee_collection_clear (_tmp18_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_tmp19_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp19_, "dummy.add (\"hello1\")");
	_tmp20_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp20_, "dummy.add (\"hello2\")");
	_tmp21_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp21_, "dummy.add (\"hello3\")");
	_tmp22_ = self->test_collection;
	_tmp23_ = gee_collection_add_all (_tmp22_, (GeeCollection*) dummy);
	_vala_assert (_tmp23_, "test_collection.add_all (dummy)");
	_tmp24_ = self->test_collection;
	_tmp25_ = gee_collection_get_size (_tmp24_);
	_tmp26_ = _tmp25_;
	_vala_assert (_tmp26_ == 3, "test_collection.size == 3");
	_tmp27_ = self->test_collection;
	_tmp28_ = gee_collection_contains (_tmp27_, "hello1");
	_vala_assert (_tmp28_, "test_collection.contains (\"hello1\")");
	_tmp29_ = self->test_collection;
	_tmp30_ = gee_collection_contains (_tmp29_, "hello2");
	_vala_assert (_tmp30_, "test_collection.contains (\"hello2\")");
	_tmp31_ = self->test_collection;
	_tmp32_ = gee_collection_contains (_tmp31_, "hello3");
	_vala_assert (_tmp32_, "test_collection.contains (\"hello3\")");
	_tmp33_ = gee_abstract_collection_get_size ((GeeCollection*) dummy);
	_tmp34_ = _tmp33_;
	_vala_assert (_tmp34_ == 3, "dummy.size == 3");
	_tmp35_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp35_, "dummy.contains (\"hello1\")");
	_tmp36_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp36_, "dummy.contains (\"hello2\")");
	_tmp37_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp37_, "dummy.contains (\"hello3\")");
	_tmp38_ = self->test_collection;
	gee_collection_clear (_tmp38_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_tmp39_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp39_, "dummy.add (\"hello1\")");
	_tmp40_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp40_, "dummy.add (\"hello2\")");
	_tmp41_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp41_, "dummy.add (\"hello3\")");
	_tmp42_ = self->test_collection;
	_tmp43_ = gee_collection_add (_tmp42_, "hello");
	_vala_assert (_tmp43_, "test_collection.add (\"hello\")");
	_tmp44_ = self->test_collection;
	_tmp45_ = gee_collection_add_all (_tmp44_, (GeeCollection*) dummy);
	_vala_assert (_tmp45_, "test_collection.add_all (dummy)");
	_tmp46_ = self->test_collection;
	_tmp47_ = gee_collection_get_size (_tmp46_);
	_tmp48_ = _tmp47_;
	_vala_assert (_tmp48_ == 4, "test_collection.size == 4");
	_tmp49_ = self->test_collection;
	_tmp50_ = gee_collection_contains (_tmp49_, "hello");
	_vala_assert (_tmp50_, "test_collection.contains (\"hello\")");
	_tmp51_ = self->test_collection;
	_tmp52_ = gee_collection_contains (_tmp51_, "hello1");
	_vala_assert (_tmp52_, "test_collection.contains (\"hello1\")");
	_tmp53_ = self->test_collection;
	_tmp54_ = gee_collection_contains (_tmp53_, "hello2");
	_vala_assert (_tmp54_, "test_collection.contains (\"hello2\")");
	_tmp55_ = self->test_collection;
	_tmp56_ = gee_collection_contains (_tmp55_, "hello3");
	_vala_assert (_tmp56_, "test_collection.contains (\"hello3\")");
	_tmp57_ = gee_abstract_collection_get_size ((GeeCollection*) dummy);
	_tmp58_ = _tmp57_;
	_vala_assert (_tmp58_ == 3, "dummy.size == 3");
	_tmp59_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp59_, "dummy.contains (\"hello1\")");
	_tmp60_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp60_, "dummy.contains (\"hello2\")");
	_tmp61_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp61_, "dummy.contains (\"hello3\")");
	_tmp62_ = self->test_collection;
	gee_collection_clear (_tmp62_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_tmp63_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp63_, "dummy.add (\"hello1\")");
	_tmp64_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp64_, "dummy.add (\"hello2\")");
	_tmp65_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp65_, "dummy.add (\"hello3\")");
	_tmp66_ = self->test_collection;
	_tmp67_ = gee_collection_add (_tmp66_, "hello1");
	_vala_assert (_tmp67_, "test_collection.add (\"hello1\")");
	_tmp68_ = self->test_collection;
	_tmp69_ = gee_collection_add_all (_tmp68_, (GeeCollection*) dummy);
	_vala_assert (_tmp69_, "test_collection.add_all (dummy)");
	_tmp70_ = self->test_collection;
	_tmp71_ = gee_collection_get_size (_tmp70_);
	_tmp72_ = _tmp71_;
	_vala_assert (_tmp72_ >= 3, "test_collection.size >= 3");
	_tmp73_ = self->test_collection;
	_tmp74_ = gee_collection_contains (_tmp73_, "hello1");
	_vala_assert (_tmp74_, "test_collection.contains (\"hello1\")");
	_tmp75_ = self->test_collection;
	_tmp76_ = gee_collection_contains (_tmp75_, "hello2");
	_vala_assert (_tmp76_, "test_collection.contains (\"hello2\")");
	_tmp77_ = self->test_collection;
	_tmp78_ = gee_collection_contains (_tmp77_, "hello3");
	_vala_assert (_tmp78_, "test_collection.contains (\"hello3\")");
	_tmp79_ = gee_abstract_collection_get_size ((GeeCollection*) dummy);
	_tmp80_ = _tmp79_;
	_vala_assert (_tmp80_ == 3, "dummy.size == 3");
	_tmp81_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp81_, "dummy.contains (\"hello1\")");
	_tmp82_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp82_, "dummy.contains (\"hello2\")");
	_tmp83_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp83_, "dummy.contains (\"hello3\")");
	_g_object_unref0 (dummy);
}


void collection_tests_test_contains_all (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	GeeArrayList* dummy = NULL;
	GeeArrayList* _tmp1_ = NULL;
	gboolean _tmp2_ = FALSE;
	gboolean _tmp3_ = FALSE;
	gboolean _tmp4_ = FALSE;
	GeeCollection* _tmp5_ = NULL;
	gboolean _tmp6_ = FALSE;
	gboolean _tmp7_ = FALSE;
	GeeCollection* _tmp8_ = NULL;
	gboolean _tmp9_ = FALSE;
	GeeCollection* _tmp10_ = NULL;
	gboolean _tmp11_ = FALSE;
	GeeCollection* _tmp12_ = NULL;
	gboolean _tmp13_ = FALSE;
	GeeCollection* _tmp14_ = NULL;
	gboolean _tmp15_ = FALSE;
	GeeCollection* _tmp16_ = NULL;
	gboolean _tmp17_ = FALSE;
	GeeCollection* _tmp18_ = NULL;
	gboolean _tmp19_ = FALSE;
	GeeCollection* _tmp20_ = NULL;
	gboolean _tmp21_ = FALSE;
	GeeCollection* _tmp22_ = NULL;
	gboolean _tmp23_ = FALSE;
	GeeCollection* _tmp24_ = NULL;
	gboolean _tmp25_ = FALSE;
	GeeCollection* _tmp26_ = NULL;
	gboolean _tmp27_ = FALSE;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp1_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);
	dummy = _tmp1_;
	_tmp2_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp2_, "dummy.add (\"hello1\")");
	_tmp3_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp3_, "dummy.add (\"hello2\")");
	_tmp4_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp4_, "dummy.add (\"hello3\")");
	_tmp5_ = self->test_collection;
	_tmp6_ = gee_collection_get_is_empty (_tmp5_);
	_tmp7_ = _tmp6_;
	_vala_assert (_tmp7_, "test_collection.is_empty");
	_tmp8_ = self->test_collection;
	_tmp9_ = gee_collection_contains_all (_tmp8_, (GeeCollection*) dummy);
	_vala_assert (!_tmp9_, "! test_collection.contains_all (dummy)");
	_tmp10_ = self->test_collection;
	_tmp11_ = gee_collection_add (_tmp10_, "hello4");
	_vala_assert (_tmp11_, "test_collection.add (\"hello4\")");
	_tmp12_ = self->test_collection;
	_tmp13_ = gee_collection_add (_tmp12_, "hello5");
	_vala_assert (_tmp13_, "test_collection.add (\"hello5\")");
	_tmp14_ = self->test_collection;
	_tmp15_ = gee_collection_contains_all (_tmp14_, (GeeCollection*) dummy);
	_vala_assert (!_tmp15_, "! test_collection.contains_all (dummy)");
	_tmp16_ = self->test_collection;
	_tmp17_ = gee_collection_add (_tmp16_, "hello1");
	_vala_assert (_tmp17_, "test_collection.add (\"hello1\")");
	_tmp18_ = self->test_collection;
	_tmp19_ = gee_collection_add (_tmp18_, "hello2");
	_vala_assert (_tmp19_, "test_collection.add (\"hello2\")");
	_tmp20_ = self->test_collection;
	_tmp21_ = gee_collection_contains_all (_tmp20_, (GeeCollection*) dummy);
	_vala_assert (!_tmp21_, "! test_collection.contains_all (dummy)");
	_tmp22_ = self->test_collection;
	_tmp23_ = gee_collection_add (_tmp22_, "hello3");
	_vala_assert (_tmp23_, "test_collection.add (\"hello3\")");
	_tmp24_ = self->test_collection;
	_tmp25_ = gee_collection_contains_all (_tmp24_, (GeeCollection*) dummy);
	_vala_assert (_tmp25_, "test_collection.contains_all (dummy)");
	_tmp26_ = self->test_collection;
	_tmp27_ = gee_collection_contains_all ((GeeCollection*) dummy, _tmp26_);
	_vala_assert (!_tmp27_, "! dummy.contains_all (test_collection)");
	_g_object_unref0 (dummy);
}


void collection_tests_test_remove_all (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	GeeArrayList* dummy = NULL;
	GeeArrayList* _tmp1_ = NULL;
	GeeCollection* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	gboolean _tmp6_ = FALSE;
	gboolean _tmp7_ = FALSE;
	gboolean _tmp8_ = FALSE;
	gboolean _tmp9_ = FALSE;
	gboolean _tmp10_ = FALSE;
	gboolean _tmp11_ = FALSE;
	GeeCollection* _tmp12_ = NULL;
	gboolean _tmp13_ = FALSE;
	GeeCollection* _tmp14_ = NULL;
	gboolean _tmp15_ = FALSE;
	gboolean _tmp16_ = FALSE;
	GeeCollection* _tmp17_ = NULL;
	gboolean _tmp18_ = FALSE;
	gboolean _tmp19_ = FALSE;
	gboolean _tmp20_ = FALSE;
	GeeCollection* _tmp21_ = NULL;
	gboolean _tmp22_ = FALSE;
	GeeCollection* _tmp23_ = NULL;
	gboolean _tmp24_ = FALSE;
	GeeCollection* _tmp25_ = NULL;
	gboolean _tmp26_ = FALSE;
	GeeCollection* _tmp27_ = NULL;
	gint _tmp28_ = 0;
	gint _tmp29_ = 0;
	gint _tmp30_ = 0;
	gint _tmp31_ = 0;
	GeeCollection* _tmp32_ = NULL;
	gboolean _tmp33_ = FALSE;
	gboolean _tmp34_ = FALSE;
	gboolean _tmp35_ = FALSE;
	GeeCollection* _tmp36_ = NULL;
	gboolean _tmp37_ = FALSE;
	GeeCollection* _tmp38_ = NULL;
	gboolean _tmp39_ = FALSE;
	GeeCollection* _tmp40_ = NULL;
	gboolean _tmp41_ = FALSE;
	GeeCollection* _tmp42_ = NULL;
	gboolean _tmp43_ = FALSE;
	GeeCollection* _tmp44_ = NULL;
	gboolean _tmp45_ = FALSE;
	gboolean _tmp46_ = FALSE;
	gint _tmp47_ = 0;
	gint _tmp48_ = 0;
	GeeCollection* _tmp49_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp1_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);
	dummy = _tmp1_;
	_tmp2_ = self->test_collection;
	_tmp3_ = gee_collection_remove_all (_tmp2_, (GeeCollection*) dummy);
	_vala_assert (!_tmp3_, "! test_collection.remove_all (dummy)");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_get_is_empty (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_assert (_tmp6_, "test_collection.is_empty");
	_tmp7_ = gee_collection_get_is_empty ((GeeCollection*) dummy);
	_tmp8_ = _tmp7_;
	_vala_assert (_tmp8_, "dummy.is_empty");
	_tmp9_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp9_, "dummy.add (\"hello1\")");
	_tmp10_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp10_, "dummy.add (\"hello2\")");
	_tmp11_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp11_, "dummy.add (\"hello3\")");
	_tmp12_ = self->test_collection;
	_tmp13_ = gee_collection_remove_all (_tmp12_, (GeeCollection*) dummy);
	_vala_assert (!_tmp13_, "! test_collection.remove_all (dummy)");
	_tmp14_ = self->test_collection;
	_tmp15_ = gee_collection_get_is_empty (_tmp14_);
	_tmp16_ = _tmp15_;
	_vala_assert (_tmp16_, "test_collection.is_empty");
	_tmp17_ = self->test_collection;
	gee_collection_clear (_tmp17_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_tmp18_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp18_, "dummy.add (\"hello1\")");
	_tmp19_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp19_, "dummy.add (\"hello2\")");
	_tmp20_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp20_, "dummy.add (\"hello3\")");
	_tmp21_ = self->test_collection;
	_tmp22_ = gee_collection_add (_tmp21_, "hello4");
	_vala_assert (_tmp22_, "test_collection.add (\"hello4\")");
	_tmp23_ = self->test_collection;
	_tmp24_ = gee_collection_add (_tmp23_, "hello5");
	_vala_assert (_tmp24_, "test_collection.add (\"hello5\")");
	_tmp25_ = self->test_collection;
	_tmp26_ = gee_collection_remove_all (_tmp25_, (GeeCollection*) dummy);
	_vala_assert (!_tmp26_, "! test_collection.remove_all (dummy)");
	_tmp27_ = self->test_collection;
	_tmp28_ = gee_collection_get_size (_tmp27_);
	_tmp29_ = _tmp28_;
	_vala_assert (_tmp29_ == 2, "test_collection.size == 2");
	_tmp30_ = gee_abstract_collection_get_size ((GeeCollection*) dummy);
	_tmp31_ = _tmp30_;
	_vala_assert (_tmp31_ == 3, "dummy.size == 3");
	_tmp32_ = self->test_collection;
	gee_collection_clear (_tmp32_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_tmp33_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp33_, "dummy.add (\"hello1\")");
	_tmp34_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp34_, "dummy.add (\"hello2\")");
	_tmp35_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp35_, "dummy.add (\"hello3\")");
	_tmp36_ = self->test_collection;
	_tmp37_ = gee_collection_add (_tmp36_, "hello1");
	_vala_assert (_tmp37_, "test_collection.add (\"hello1\")");
	_tmp38_ = self->test_collection;
	_tmp39_ = gee_collection_add (_tmp38_, "hello2");
	_vala_assert (_tmp39_, "test_collection.add (\"hello2\")");
	_tmp40_ = self->test_collection;
	_tmp41_ = gee_collection_add (_tmp40_, "hello3");
	_vala_assert (_tmp41_, "test_collection.add (\"hello3\")");
	_tmp42_ = self->test_collection;
	_tmp43_ = gee_collection_remove_all (_tmp42_, (GeeCollection*) dummy);
	_vala_assert (_tmp43_, "test_collection.remove_all (dummy)");
	_tmp44_ = self->test_collection;
	_tmp45_ = gee_collection_get_is_empty (_tmp44_);
	_tmp46_ = _tmp45_;
	_vala_assert (_tmp46_, "test_collection.is_empty");
	_tmp47_ = gee_abstract_collection_get_size ((GeeCollection*) dummy);
	_tmp48_ = _tmp47_;
	_vala_assert (_tmp48_ == 3, "dummy.size == 3");
	_tmp49_ = self->test_collection;
	gee_collection_clear (_tmp49_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_g_object_unref0 (dummy);
}


void collection_tests_test_retain_all (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	GeeArrayList* dummy = NULL;
	GeeArrayList* _tmp1_ = NULL;
	GeeCollection* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	gboolean _tmp6_ = FALSE;
	gboolean _tmp7_ = FALSE;
	gboolean _tmp8_ = FALSE;
	GeeCollection* _tmp9_ = NULL;
	gboolean _tmp10_ = FALSE;
	GeeCollection* _tmp11_ = NULL;
	gboolean _tmp12_ = FALSE;
	GeeCollection* _tmp13_ = NULL;
	gboolean _tmp14_ = FALSE;
	GeeCollection* _tmp15_ = NULL;
	gboolean _tmp16_ = FALSE;
	gboolean _tmp17_ = FALSE;
	gboolean _tmp18_ = FALSE;
	gboolean _tmp19_ = FALSE;
	GeeCollection* _tmp20_ = NULL;
	gboolean _tmp21_ = FALSE;
	gboolean _tmp22_ = FALSE;
	gboolean _tmp23_ = FALSE;
	GeeCollection* _tmp24_ = NULL;
	gboolean _tmp25_ = FALSE;
	GeeCollection* _tmp26_ = NULL;
	gboolean _tmp27_ = FALSE;
	gboolean _tmp28_ = FALSE;
	gint _tmp29_ = 0;
	gint _tmp30_ = 0;
	gboolean _tmp31_ = FALSE;
	gboolean _tmp32_ = FALSE;
	gboolean _tmp33_ = FALSE;
	GeeCollection* _tmp34_ = NULL;
	gboolean _tmp35_ = FALSE;
	gboolean _tmp36_ = FALSE;
	gboolean _tmp37_ = FALSE;
	GeeCollection* _tmp38_ = NULL;
	gboolean _tmp39_ = FALSE;
	GeeCollection* _tmp40_ = NULL;
	gboolean _tmp41_ = FALSE;
	GeeCollection* _tmp42_ = NULL;
	gboolean _tmp43_ = FALSE;
	GeeCollection* _tmp44_ = NULL;
	gboolean _tmp45_ = FALSE;
	gboolean _tmp46_ = FALSE;
	gint _tmp47_ = 0;
	gint _tmp48_ = 0;
	gboolean _tmp49_ = FALSE;
	gboolean _tmp50_ = FALSE;
	gboolean _tmp51_ = FALSE;
	GeeCollection* _tmp52_ = NULL;
	gboolean _tmp53_ = FALSE;
	gboolean _tmp54_ = FALSE;
	gboolean _tmp55_ = FALSE;
	GeeCollection* _tmp56_ = NULL;
	gboolean _tmp57_ = FALSE;
	GeeCollection* _tmp58_ = NULL;
	gboolean _tmp59_ = FALSE;
	GeeCollection* _tmp60_ = NULL;
	gboolean _tmp61_ = FALSE;
	GeeCollection* _tmp62_ = NULL;
	gboolean _tmp63_ = FALSE;
	GeeCollection* _tmp64_ = NULL;
	gint _tmp65_ = 0;
	gint _tmp66_ = 0;
	GeeCollection* _tmp67_ = NULL;
	gboolean _tmp68_ = FALSE;
	GeeCollection* _tmp69_ = NULL;
	gboolean _tmp70_ = FALSE;
	GeeCollection* _tmp71_ = NULL;
	gboolean _tmp72_ = FALSE;
	gint _tmp73_ = 0;
	gint _tmp74_ = 0;
	gboolean _tmp75_ = FALSE;
	gboolean _tmp76_ = FALSE;
	gboolean _tmp77_ = FALSE;
	GeeCollection* _tmp78_ = NULL;
	gboolean _tmp79_ = FALSE;
	gboolean _tmp80_ = FALSE;
	gboolean _tmp81_ = FALSE;
	GeeCollection* _tmp82_ = NULL;
	gboolean _tmp83_ = FALSE;
	GeeCollection* _tmp84_ = NULL;
	gboolean _tmp85_ = FALSE;
	GeeCollection* _tmp86_ = NULL;
	gboolean _tmp87_ = FALSE;
	GeeCollection* _tmp88_ = NULL;
	gboolean _tmp89_ = FALSE;
	GeeCollection* _tmp90_ = NULL;
	gint _tmp91_ = 0;
	gint _tmp92_ = 0;
	GeeCollection* _tmp93_ = NULL;
	gboolean _tmp94_ = FALSE;
	GeeCollection* _tmp95_ = NULL;
	gboolean _tmp96_ = FALSE;
	gint _tmp97_ = 0;
	gint _tmp98_ = 0;
	gboolean _tmp99_ = FALSE;
	gboolean _tmp100_ = FALSE;
	gboolean _tmp101_ = FALSE;
	GeeCollection* _tmp102_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp1_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);
	dummy = _tmp1_;
	_tmp2_ = self->test_collection;
	_tmp3_ = gee_collection_retain_all (_tmp2_, (GeeCollection*) dummy);
	_vala_assert (!_tmp3_, "! test_collection.retain_all (dummy)");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_get_is_empty (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_assert (_tmp6_, "test_collection.is_empty");
	_tmp7_ = gee_collection_get_is_empty ((GeeCollection*) dummy);
	_tmp8_ = _tmp7_;
	_vala_assert (_tmp8_, "dummy.is_empty");
	_tmp9_ = self->test_collection;
	_tmp10_ = gee_collection_add (_tmp9_, "hello1");
	_vala_assert (_tmp10_, "test_collection.add (\"hello1\")");
	_tmp11_ = self->test_collection;
	_tmp12_ = gee_collection_add (_tmp11_, "hello2");
	_vala_assert (_tmp12_, "test_collection.add (\"hello2\")");
	_tmp13_ = self->test_collection;
	_tmp14_ = gee_collection_retain_all (_tmp13_, (GeeCollection*) dummy);
	_vala_assert (_tmp14_, "test_collection.retain_all (dummy)");
	_tmp15_ = self->test_collection;
	_tmp16_ = gee_collection_get_is_empty (_tmp15_);
	_tmp17_ = _tmp16_;
	_vala_assert (_tmp17_, "test_collection.is_empty");
	_tmp18_ = gee_collection_get_is_empty ((GeeCollection*) dummy);
	_tmp19_ = _tmp18_;
	_vala_assert (_tmp19_, "dummy.is_empty");
	_tmp20_ = self->test_collection;
	gee_collection_clear (_tmp20_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_tmp21_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp21_, "dummy.add (\"hello1\")");
	_tmp22_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp22_, "dummy.add (\"hello2\")");
	_tmp23_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp23_, "dummy.add (\"hello3\")");
	_tmp24_ = self->test_collection;
	_tmp25_ = gee_collection_retain_all (_tmp24_, (GeeCollection*) dummy);
	_vala_assert (!_tmp25_, "! test_collection.retain_all (dummy)");
	_tmp26_ = self->test_collection;
	_tmp27_ = gee_collection_get_is_empty (_tmp26_);
	_tmp28_ = _tmp27_;
	_vala_assert (_tmp28_, "test_collection.is_empty");
	_tmp29_ = gee_abstract_collection_get_size ((GeeCollection*) dummy);
	_tmp30_ = _tmp29_;
	_vala_assert (_tmp30_ == 3, "dummy.size == 3");
	_tmp31_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp31_, "dummy.contains (\"hello1\")");
	_tmp32_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp32_, "dummy.contains (\"hello2\")");
	_tmp33_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp33_, "dummy.contains (\"hello3\")");
	_tmp34_ = self->test_collection;
	gee_collection_clear (_tmp34_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_tmp35_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp35_, "dummy.add (\"hello1\")");
	_tmp36_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp36_, "dummy.add (\"hello2\")");
	_tmp37_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp37_, "dummy.add (\"hello3\")");
	_tmp38_ = self->test_collection;
	_tmp39_ = gee_collection_add (_tmp38_, "hello4");
	_vala_assert (_tmp39_, "test_collection.add (\"hello4\")");
	_tmp40_ = self->test_collection;
	_tmp41_ = gee_collection_add (_tmp40_, "hello5");
	_vala_assert (_tmp41_, "test_collection.add (\"hello5\")");
	_tmp42_ = self->test_collection;
	_tmp43_ = gee_collection_retain_all (_tmp42_, (GeeCollection*) dummy);
	_vala_assert (_tmp43_, "test_collection.retain_all (dummy)");
	_tmp44_ = self->test_collection;
	_tmp45_ = gee_collection_get_is_empty (_tmp44_);
	_tmp46_ = _tmp45_;
	_vala_assert (_tmp46_, "test_collection.is_empty");
	_tmp47_ = gee_abstract_collection_get_size ((GeeCollection*) dummy);
	_tmp48_ = _tmp47_;
	_vala_assert (_tmp48_ == 3, "dummy.size == 3");
	_tmp49_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp49_, "dummy.contains (\"hello1\")");
	_tmp50_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp50_, "dummy.contains (\"hello2\")");
	_tmp51_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp51_, "dummy.contains (\"hello3\")");
	_tmp52_ = self->test_collection;
	gee_collection_clear (_tmp52_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_tmp53_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp53_, "dummy.add (\"hello1\")");
	_tmp54_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp54_, "dummy.add (\"hello2\")");
	_tmp55_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp55_, "dummy.add (\"hello3\")");
	_tmp56_ = self->test_collection;
	_tmp57_ = gee_collection_add (_tmp56_, "hello1");
	_vala_assert (_tmp57_, "test_collection.add (\"hello1\")");
	_tmp58_ = self->test_collection;
	_tmp59_ = gee_collection_add (_tmp58_, "hello2");
	_vala_assert (_tmp59_, "test_collection.add (\"hello2\")");
	_tmp60_ = self->test_collection;
	_tmp61_ = gee_collection_add (_tmp60_, "hello3");
	_vala_assert (_tmp61_, "test_collection.add (\"hello3\")");
	_tmp62_ = self->test_collection;
	_tmp63_ = gee_collection_retain_all (_tmp62_, (GeeCollection*) dummy);
	_vala_assert (!_tmp63_, "! test_collection.retain_all (dummy)");
	_tmp64_ = self->test_collection;
	_tmp65_ = gee_collection_get_size (_tmp64_);
	_tmp66_ = _tmp65_;
	_vala_assert (_tmp66_ == 3, "test_collection.size == 3");
	_tmp67_ = self->test_collection;
	_tmp68_ = gee_collection_contains (_tmp67_, "hello1");
	_vala_assert (_tmp68_, "test_collection.contains (\"hello1\")");
	_tmp69_ = self->test_collection;
	_tmp70_ = gee_collection_contains (_tmp69_, "hello2");
	_vala_assert (_tmp70_, "test_collection.contains (\"hello2\")");
	_tmp71_ = self->test_collection;
	_tmp72_ = gee_collection_contains (_tmp71_, "hello3");
	_vala_assert (_tmp72_, "test_collection.contains (\"hello3\")");
	_tmp73_ = gee_abstract_collection_get_size ((GeeCollection*) dummy);
	_tmp74_ = _tmp73_;
	_vala_assert (_tmp74_ == 3, "dummy.size == 3");
	_tmp75_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp75_, "dummy.contains (\"hello1\")");
	_tmp76_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp76_, "dummy.contains (\"hello2\")");
	_tmp77_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp77_, "dummy.contains (\"hello3\")");
	_tmp78_ = self->test_collection;
	gee_collection_clear (_tmp78_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_tmp79_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp79_, "dummy.add (\"hello1\")");
	_tmp80_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp80_, "dummy.add (\"hello2\")");
	_tmp81_ = gee_abstract_collection_add ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp81_, "dummy.add (\"hello3\")");
	_tmp82_ = self->test_collection;
	_tmp83_ = gee_collection_add (_tmp82_, "hello2");
	_vala_assert (_tmp83_, "test_collection.add (\"hello2\")");
	_tmp84_ = self->test_collection;
	_tmp85_ = gee_collection_add (_tmp84_, "hello3");
	_vala_assert (_tmp85_, "test_collection.add (\"hello3\")");
	_tmp86_ = self->test_collection;
	_tmp87_ = gee_collection_add (_tmp86_, "hello4");
	_vala_assert (_tmp87_, "test_collection.add (\"hello4\")");
	_tmp88_ = self->test_collection;
	_tmp89_ = gee_collection_retain_all (_tmp88_, (GeeCollection*) dummy);
	_vala_assert (_tmp89_, "test_collection.retain_all (dummy)");
	_tmp90_ = self->test_collection;
	_tmp91_ = gee_collection_get_size (_tmp90_);
	_tmp92_ = _tmp91_;
	_vala_assert (_tmp92_ == 2, "test_collection.size == 2");
	_tmp93_ = self->test_collection;
	_tmp94_ = gee_collection_contains (_tmp93_, "hello2");
	_vala_assert (_tmp94_, "test_collection.contains (\"hello2\")");
	_tmp95_ = self->test_collection;
	_tmp96_ = gee_collection_contains (_tmp95_, "hello3");
	_vala_assert (_tmp96_, "test_collection.contains (\"hello3\")");
	_tmp97_ = gee_abstract_collection_get_size ((GeeCollection*) dummy);
	_tmp98_ = _tmp97_;
	_vala_assert (_tmp98_ == 3, "dummy.size == 3");
	_tmp99_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello1");
	_vala_assert (_tmp99_, "dummy.contains (\"hello1\")");
	_tmp100_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello2");
	_vala_assert (_tmp100_, "dummy.contains (\"hello2\")");
	_tmp101_ = gee_abstract_collection_contains ((GeeAbstractCollection*) dummy, "hello3");
	_vala_assert (_tmp101_, "dummy.contains (\"hello3\")");
	_tmp102_ = self->test_collection;
	gee_collection_clear (_tmp102_);
	gee_abstract_collection_clear ((GeeAbstractCollection*) dummy);
	_g_object_unref0 (dummy);
}


void collection_tests_test_to_array (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	GeeCollection* _tmp1_ = NULL;
	gboolean _tmp2_ = FALSE;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	GeeCollection* _tmp6_ = NULL;
	gboolean _tmp7_ = FALSE;
	GeeCollection* _tmp8_ = NULL;
	gboolean _tmp9_ = FALSE;
	gchar** array = NULL;
	GeeCollection* _tmp10_ = NULL;
	gint _tmp11_ = 0;
	gpointer* _tmp12_ = NULL;
	gint array_length1 = 0;
	gint _array_size_ = 0;
	gint index = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	_tmp1_ = self->test_collection;
	_tmp2_ = gee_collection_get_is_empty (_tmp1_);
	_tmp3_ = _tmp2_;
	_vala_assert (_tmp3_, "test_collection.is_empty");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_add (_tmp4_, "hello1");
	_vala_assert (_tmp5_, "test_collection.add (\"hello1\")");
	_tmp6_ = self->test_collection;
	_tmp7_ = gee_collection_add (_tmp6_, "hello2");
	_vala_assert (_tmp7_, "test_collection.add (\"hello2\")");
	_tmp8_ = self->test_collection;
	_tmp9_ = gee_collection_add (_tmp8_, "hello3");
	_vala_assert (_tmp9_, "test_collection.add (\"hello3\")");
	_tmp10_ = self->test_collection;
	_tmp12_ = gee_collection_to_array (_tmp10_, &_tmp11_);
	array = (gchar**) _tmp12_;
	array_length1 = (_tmp11_ * sizeof (gchar*)) / sizeof (gchar*);
	_array_size_ = array_length1;
	index = 0;
	{
		GeeIterator* _element_it = NULL;
		GeeCollection* _tmp13_ = NULL;
		GeeIterator* _tmp14_ = NULL;
		_tmp13_ = self->test_collection;
		_tmp14_ = gee_iterable_iterator ((GeeIterable*) _tmp13_);
		_element_it = _tmp14_;
		while (TRUE) {
			GeeIterator* _tmp15_ = NULL;
			gboolean _tmp16_ = FALSE;
			gchar* element = NULL;
			GeeIterator* _tmp17_ = NULL;
			gpointer _tmp18_ = NULL;
			const gchar* _tmp19_ = NULL;
			gchar** _tmp20_ = NULL;
			gint _tmp20__length1 = 0;
			gint _tmp21_ = 0;
			const gchar* _tmp22_ = NULL;
			_tmp15_ = _element_it;
			_tmp16_ = gee_iterator_next (_tmp15_);
			if (!_tmp16_) {
				break;
			}
			_tmp17_ = _element_it;
			_tmp18_ = gee_iterator_get (_tmp17_);
			element = (gchar*) _tmp18_;
			_tmp19_ = element;
			_tmp20_ = array;
			_tmp20__length1 = array_length1;
			_tmp21_ = index;
			index = _tmp21_ + 1;
			_tmp22_ = _tmp20_[_tmp21_];
			_vala_assert (g_strcmp0 (_tmp19_, _tmp22_) == 0, "element == array[index++]");
			_g_free0 (element);
		}
		_g_object_unref0 (_element_it);
	}
	array = (_vala_array_free (array, array_length1, (GDestroyNotify) g_free), NULL);
}


void collection_tests_test_gobject_properties (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	GValue value = {0};
	GValue _tmp1_ = {0};
	GValue _tmp2_ = {0};
	GeeCollection* _tmp3_ = NULL;
	gint _tmp4_ = 0;
	GeeCollection* _tmp5_ = NULL;
	gint _tmp6_ = 0;
	gint _tmp7_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_vala_assert (_tmp0_ != NULL, "test_collection != null");
	g_value_init (&_tmp1_, G_TYPE_INT);
	G_IS_VALUE (&value) ? (g_value_unset (&value), NULL) : NULL;
	value = _tmp1_;
	_tmp2_ = value;
	_tmp3_ = self->test_collection;
	g_object_get_property ((GObject*) _tmp3_, "size", &value);
	_tmp4_ = g_value_get_int (&value);
	_tmp5_ = self->test_collection;
	_tmp6_ = gee_collection_get_size (_tmp5_);
	_tmp7_ = _tmp6_;
	_vala_assert (_tmp4_ == _tmp7_, "value.get_int () == test_collection.size");
	g_value_unset (&value);
	G_IS_VALUE (&value) ? (g_value_unset (&value), NULL) : NULL;
}


static gint __lambda3_ (CollectionTests* self, gchar* x, gint y) {
	gint result = 0;
	gint _tmp0_ = 0;
	g_return_val_if_fail (x != NULL, 0);
	_tmp0_ = y;
	result = _tmp0_ + 1;
	_g_free0 (x);
	return result;
}


static gpointer ___lambda3__gee_fold_func (gpointer g, gpointer a, gpointer self) {
	gpointer result;
	result = __lambda3_ (self, g, a);
	return result;
}


static gint __lambda4_ (CollectionTests* self, gchar* x, gint y) {
	gint result = 0;
	gint _tmp0_ = 0;
	g_return_val_if_fail (x != NULL, 0);
	_tmp0_ = y;
	result = _tmp0_ + 1;
	_g_free0 (x);
	return result;
}


static gpointer ___lambda4__gee_fold_func (gpointer g, gpointer a, gpointer self) {
	gpointer result;
	result = __lambda4_ (self, g, a);
	return result;
}


static gint __lambda5_ (CollectionTests* self, gchar* x, gint y) {
	gint result = 0;
	gint _tmp0_ = 0;
	g_return_val_if_fail (x != NULL, 0);
	_tmp0_ = y;
	result = _tmp0_ + 1;
	_g_free0 (x);
	return result;
}


static gpointer ___lambda5__gee_fold_func (gpointer g, gpointer a, gpointer self) {
	gpointer result;
	result = __lambda5_ (self, g, a);
	return result;
}


void collection_tests_test_fold (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	gboolean _tmp1_ = FALSE;
	GeeCollection* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	gint count = 0;
	GeeCollection* _tmp6_ = NULL;
	gpointer _tmp7_ = NULL;
	gint _tmp8_ = 0;
	GeeCollection* _tmp9_ = NULL;
	GeeIterator* _tmp10_ = NULL;
	GeeIterator* _tmp11_ = NULL;
	gpointer _tmp12_ = NULL;
	gint _tmp13_ = 0;
	GeeIterator* iter = NULL;
	GeeCollection* _tmp14_ = NULL;
	GeeIterator* _tmp15_ = NULL;
	gboolean _tmp16_ = FALSE;
	gpointer _tmp17_ = NULL;
	gint _tmp18_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_tmp1_ = gee_collection_add (_tmp0_, "one");
	_vala_assert (_tmp1_, "test_collection.add (\"one\")");
	_tmp2_ = self->test_collection;
	_tmp3_ = gee_collection_add (_tmp2_, "two");
	_vala_assert (_tmp3_, "test_collection.add (\"two\")");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_add (_tmp4_, "three");
	_vala_assert (_tmp5_, "test_collection.add (\"three\")");
	_tmp6_ = self->test_collection;
	_tmp7_ = gee_traversable_fold ((GeeTraversable*) _tmp6_, G_TYPE_INT, NULL, NULL, ___lambda3__gee_fold_func, self, (gpointer) ((gintptr) 0));
	count = (gint) ((gintptr) _tmp7_);
	_tmp8_ = count;
	_vala_assert (_tmp8_ == 3, "count == 3");
	_tmp9_ = self->test_collection;
	_tmp10_ = gee_iterable_iterator ((GeeIterable*) _tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = gee_traversable_fold ((GeeTraversable*) _tmp11_, G_TYPE_INT, NULL, NULL, ___lambda4__gee_fold_func, self, (gpointer) ((gintptr) 0));
	count = (gint) ((gintptr) _tmp12_);
	_g_object_unref0 (_tmp11_);
	_tmp13_ = count;
	_vala_assert (_tmp13_ == 3, "count == 3");
	_tmp14_ = self->test_collection;
	_tmp15_ = gee_iterable_iterator ((GeeIterable*) _tmp14_);
	iter = _tmp15_;
	_tmp16_ = gee_iterator_next (iter);
	_vala_assert (_tmp16_, "iter.next ()");
	_tmp17_ = gee_traversable_fold ((GeeTraversable*) iter, G_TYPE_INT, NULL, NULL, ___lambda5__gee_fold_func, self, (gpointer) ((gintptr) 0));
	count = (gint) ((gintptr) _tmp17_);
	_tmp18_ = count;
	_vala_assert (_tmp18_ == 3, "count == 3");
	_g_object_unref0 (iter);
}


static Block1Data* block1_data_ref (Block1Data* _data1_) {
	g_atomic_int_inc (&_data1_->_ref_count_);
	return _data1_;
}


static void block1_data_unref (void * _userdata_) {
	Block1Data* _data1_;
	_data1_ = (Block1Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
		CollectionTests * self;
		self = _data1_->self;
		_g_object_unref0 (self);
		g_slice_free (Block1Data, _data1_);
	}
}


static gboolean __lambda6_ (Block1Data* _data1_, gchar* x) {
	CollectionTests * self;
	gboolean result = FALSE;
	gint _tmp0_ = 0;
	self = _data1_->self;
	g_return_val_if_fail (x != NULL, FALSE);
	_tmp0_ = _data1_->count;
	_data1_->count = _tmp0_ + 1;
	result = TRUE;
	_g_free0 (x);
	return result;
}


static gboolean ___lambda6__gee_forall_func (gpointer g, gpointer self) {
	gboolean result;
	result = __lambda6_ (self, g);
	return result;
}


static gboolean __lambda7_ (Block1Data* _data1_, gchar* x) {
	CollectionTests * self;
	gboolean result = FALSE;
	gint _tmp0_ = 0;
	self = _data1_->self;
	g_return_val_if_fail (x != NULL, FALSE);
	_tmp0_ = _data1_->count;
	_data1_->count = _tmp0_ + 1;
	result = TRUE;
	_g_free0 (x);
	return result;
}


static gboolean ___lambda7__gee_forall_func (gpointer g, gpointer self) {
	gboolean result;
	result = __lambda7_ (self, g);
	return result;
}


static gboolean __lambda8_ (Block1Data* _data1_, gchar* x) {
	CollectionTests * self;
	gboolean result = FALSE;
	gint _tmp0_ = 0;
	self = _data1_->self;
	g_return_val_if_fail (x != NULL, FALSE);
	_tmp0_ = _data1_->count;
	_data1_->count = _tmp0_ + 1;
	result = TRUE;
	_g_free0 (x);
	return result;
}


static gboolean ___lambda8__gee_forall_func (gpointer g, gpointer self) {
	gboolean result;
	result = __lambda8_ (self, g);
	return result;
}


static gboolean __lambda9_ (Block1Data* _data1_, gchar* x) {
	CollectionTests * self;
	gboolean result = FALSE;
	gint _tmp0_ = 0;
	self = _data1_->self;
	g_return_val_if_fail (x != NULL, FALSE);
	_tmp0_ = _data1_->count;
	_data1_->count = _tmp0_ + 1;
	result = FALSE;
	_g_free0 (x);
	return result;
}


static gboolean ___lambda9__gee_forall_func (gpointer g, gpointer self) {
	gboolean result;
	result = __lambda9_ (self, g);
	return result;
}


void collection_tests_test_foreach (CollectionTests* self) {
	Block1Data* _data1_;
	GeeCollection* _tmp0_ = NULL;
	gboolean _tmp1_ = FALSE;
	GeeCollection* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	gboolean res = FALSE;
	GeeCollection* _tmp6_ = NULL;
	gboolean _tmp7_ = FALSE;
	gboolean _tmp8_ = FALSE;
	GeeCollection* _tmp9_ = NULL;
	GeeIterator* _tmp10_ = NULL;
	GeeIterator* _tmp11_ = NULL;
	gboolean _tmp12_ = FALSE;
	gboolean _tmp13_ = FALSE;
	GeeIterator* iter = NULL;
	GeeCollection* _tmp14_ = NULL;
	GeeIterator* _tmp15_ = NULL;
	gboolean _tmp16_ = FALSE;
	gboolean _tmp17_ = FALSE;
	gboolean _tmp18_ = FALSE;
	GeeCollection* _tmp19_ = NULL;
	gboolean _tmp20_ = FALSE;
	gboolean _tmp21_ = FALSE;
	g_return_if_fail (self != NULL);
	_data1_ = g_slice_new0 (Block1Data);
	_data1_->_ref_count_ = 1;
	_data1_->self = g_object_ref (self);
	_tmp0_ = self->test_collection;
	_tmp1_ = gee_collection_add (_tmp0_, "one");
	_vala_assert (_tmp1_, "test_collection.add (\"one\")");
	_tmp2_ = self->test_collection;
	_tmp3_ = gee_collection_add (_tmp2_, "two");
	_vala_assert (_tmp3_, "test_collection.add (\"two\")");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_add (_tmp4_, "three");
	_vala_assert (_tmp5_, "test_collection.add (\"three\")");
	_data1_->count = 0;
	_tmp6_ = self->test_collection;
	_tmp7_ = gee_traversable_foreach ((GeeTraversable*) _tmp6_, ___lambda6__gee_forall_func, _data1_);
	res = _tmp7_;
	_vala_assert (_data1_->count == 3, "count == 3");
	_tmp8_ = res;
	_vala_assert (_tmp8_ == TRUE, "res == true");
	_tmp9_ = self->test_collection;
	_tmp10_ = gee_iterable_iterator ((GeeIterable*) _tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = gee_traversable_foreach ((GeeTraversable*) _tmp11_, ___lambda7__gee_forall_func, _data1_);
	res = _tmp12_;
	_g_object_unref0 (_tmp11_);
	_vala_assert (_data1_->count == 6, "count == 6");
	_tmp13_ = res;
	_vala_assert (_tmp13_ == TRUE, "res == true");
	_tmp14_ = self->test_collection;
	_tmp15_ = gee_iterable_iterator ((GeeIterable*) _tmp14_);
	iter = _tmp15_;
	_tmp16_ = gee_iterator_next (iter);
	_vala_assert (_tmp16_, "iter.next ()");
	_tmp17_ = gee_traversable_foreach ((GeeTraversable*) iter, ___lambda8__gee_forall_func, _data1_);
	res = _tmp17_;
	_vala_assert (_data1_->count == 9, "count == 9");
	_tmp18_ = res;
	_vala_assert (_tmp18_ == TRUE, "res == true");
	_tmp19_ = self->test_collection;
	_tmp20_ = gee_traversable_foreach ((GeeTraversable*) _tmp19_, ___lambda9__gee_forall_func, _data1_);
	res = _tmp20_;
	_vala_assert (_data1_->count == 10, "count == 10");
	_tmp21_ = res;
	_vala_assert (_tmp21_ == FALSE, "res == false");
	_g_object_unref0 (iter);
	block1_data_unref (_data1_);
	_data1_ = NULL;
}


static Block2Data* block2_data_ref (Block2Data* _data2_) {
	g_atomic_int_inc (&_data2_->_ref_count_);
	return _data2_;
}


static void block2_data_unref (void * _userdata_) {
	Block2Data* _data2_;
	_data2_ = (Block2Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
		CollectionTests * self;
		self = _data2_->self;
		_g_object_unref0 (self);
		g_slice_free (Block2Data, _data2_);
	}
}


static gint __lambda10_ (Block2Data* _data2_, gchar* str) {
	CollectionTests * self;
	gint result = 0;
	const gchar* _tmp0_ = NULL;
	gint _tmp6_ = 0;
	self = _data2_->self;
	g_return_val_if_fail (str != NULL, 0);
	_tmp0_ = str;
	if (g_strcmp0 (_tmp0_, "one") == 0) {
		gboolean _tmp1_ = FALSE;
		_tmp1_ = _data2_->one;
		_vala_assert (!_tmp1_, "!one");
		_data2_->one = TRUE;
	} else {
		const gchar* _tmp2_ = NULL;
		_tmp2_ = str;
		if (g_strcmp0 (_tmp2_, "two") == 0) {
			gboolean _tmp3_ = FALSE;
			_tmp3_ = _data2_->two;
			_vala_assert (!_tmp3_, "!two");
			_data2_->two = TRUE;
		} else {
			const gchar* _tmp4_ = NULL;
			_tmp4_ = str;
			if (g_strcmp0 (_tmp4_, "three") == 0) {
				gboolean _tmp5_ = FALSE;
				_tmp5_ = _data2_->three;
				_vala_assert (!_tmp5_, "!three");
				_data2_->three = TRUE;
			} else {
				g_assert_not_reached ();
			}
		}
	}
	_tmp6_ = _data2_->i;
	_data2_->i = _tmp6_ + 1;
	result = _tmp6_;
	_g_free0 (str);
	return result;
}


static gpointer ___lambda10__gee_map_func (gpointer g, gpointer self) {
	gpointer result;
	result = __lambda10_ (self, g);
	return result;
}


static gint __lambda11_ (Block2Data* _data2_, gchar* str) {
	CollectionTests * self;
	gint result = 0;
	const gchar* _tmp0_ = NULL;
	gint _tmp6_ = 0;
	self = _data2_->self;
	g_return_val_if_fail (str != NULL, 0);
	_tmp0_ = str;
	if (g_strcmp0 (_tmp0_, "one") == 0) {
		gboolean _tmp1_ = FALSE;
		_tmp1_ = _data2_->one;
		_vala_assert (!_tmp1_, "!one");
		_data2_->one = TRUE;
	} else {
		const gchar* _tmp2_ = NULL;
		_tmp2_ = str;
		if (g_strcmp0 (_tmp2_, "two") == 0) {
			gboolean _tmp3_ = FALSE;
			_tmp3_ = _data2_->two;
			_vala_assert (!_tmp3_, "!two");
			_data2_->two = TRUE;
		} else {
			const gchar* _tmp4_ = NULL;
			_tmp4_ = str;
			if (g_strcmp0 (_tmp4_, "three") == 0) {
				gboolean _tmp5_ = FALSE;
				_tmp5_ = _data2_->three;
				_vala_assert (!_tmp5_, "!three");
				_data2_->three = TRUE;
			} else {
				g_assert_not_reached ();
			}
		}
	}
	_tmp6_ = _data2_->i;
	_data2_->i = _tmp6_ + 1;
	result = _tmp6_;
	_g_free0 (str);
	return result;
}


static gpointer ___lambda11__gee_map_func (gpointer g, gpointer self) {
	gpointer result;
	result = __lambda11_ (self, g);
	return result;
}


void collection_tests_test_map (CollectionTests* self) {
	Block2Data* _data2_;
	GeeCollection* _tmp0_ = NULL;
	gboolean _tmp1_ = FALSE;
	GeeCollection* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	GeeIterator* iter = NULL;
	GeeCollection* _tmp6_ = NULL;
	GeeIterator* _tmp7_ = NULL;
	GeeIterator* _tmp8_ = NULL;
	GeeIterator* _tmp9_ = NULL;
	GeeIterator* _tmp10_ = NULL;
	gint j = 0;
	gint _tmp24_ = 0;
	gint _tmp25_ = 0;
	gint _tmp26_ = 0;
	GeeCollection* _tmp27_ = NULL;
	gint _tmp28_ = 0;
	gint _tmp29_ = 0;
	gboolean _tmp30_ = FALSE;
	gboolean _tmp31_ = FALSE;
	gboolean _tmp32_ = FALSE;
	gboolean _tmp33_ = FALSE;
	gboolean _tmp34_ = FALSE;
	gint _tmp35_ = 0;
	GeeCollection* _tmp36_ = NULL;
	GeeIterator* _tmp37_ = NULL;
	gint _tmp51_ = 0;
	gint _tmp52_ = 0;
	gint _tmp53_ = 0;
	GeeCollection* _tmp54_ = NULL;
	gint _tmp55_ = 0;
	gint _tmp56_ = 0;
	gboolean _tmp57_ = FALSE;
	gboolean _tmp58_ = FALSE;
	gboolean _tmp59_ = FALSE;
	g_return_if_fail (self != NULL);
	_data2_ = g_slice_new0 (Block2Data);
	_data2_->_ref_count_ = 1;
	_data2_->self = g_object_ref (self);
	_tmp0_ = self->test_collection;
	_tmp1_ = gee_collection_add (_tmp0_, "one");
	_vala_assert (_tmp1_, "test_collection.add (\"one\")");
	_tmp2_ = self->test_collection;
	_tmp3_ = gee_collection_add (_tmp2_, "two");
	_vala_assert (_tmp3_, "test_collection.add (\"two\")");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_add (_tmp4_, "three");
	_vala_assert (_tmp5_, "test_collection.add (\"three\")");
	_data2_->one = FALSE;
	_data2_->two = FALSE;
	_data2_->three = FALSE;
	_data2_->i = 0;
	_tmp6_ = self->test_collection;
	_tmp7_ = gee_iterable_iterator ((GeeIterable*) _tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = gee_traversable_map ((GeeTraversable*) _tmp8_, G_TYPE_INT, NULL, NULL, ___lambda10__gee_map_func, _data2_);
	_tmp10_ = _tmp9_;
	_g_object_unref0 (_tmp8_);
	iter = _tmp10_;
	j = 0;
	while (TRUE) {
		GeeIterator* _tmp11_ = NULL;
		gboolean _tmp12_ = FALSE;
		gint _tmp13_ = 0;
		gint _tmp14_ = 0;
		gint _tmp15_ = 0;
		GeeIterator* _tmp16_ = NULL;
		gpointer _tmp17_ = NULL;
		gint _tmp18_ = 0;
		GeeIterator* _tmp19_ = NULL;
		gpointer _tmp20_ = NULL;
		gint _tmp21_ = 0;
		gint _tmp22_ = 0;
		gint _tmp23_ = 0;
		_tmp11_ = iter;
		_tmp12_ = gee_iterator_next (_tmp11_);
		if (!_tmp12_) {
			break;
		}
		_tmp13_ = _data2_->i;
		_tmp14_ = j;
		_vala_assert (_tmp13_ == _tmp14_, "i == j");
		_tmp15_ = j;
		_tmp16_ = iter;
		_tmp17_ = gee_iterator_get (_tmp16_);
		_vala_assert (_tmp15_ == ((gint) ((gintptr) _tmp17_)), "j == iter.get ()");
		_tmp18_ = j;
		_tmp19_ = iter;
		_tmp20_ = gee_iterator_get (_tmp19_);
		_vala_assert (_tmp18_ == ((gint) ((gintptr) _tmp20_)), "j == iter.get ()");
		_tmp21_ = j;
		j = _tmp21_ + 1;
		_tmp22_ = _data2_->i;
		_tmp23_ = j;
		_vala_assert (_tmp22_ == _tmp23_, "i == j");
	}
	_tmp24_ = _data2_->i;
	_tmp25_ = j;
	_vala_assert (_tmp24_ == _tmp25_, "i == j");
	_tmp26_ = _data2_->i;
	_tmp27_ = self->test_collection;
	_tmp28_ = gee_collection_get_size (_tmp27_);
	_tmp29_ = _tmp28_;
	_vala_assert (_tmp26_ == _tmp29_, "i == test_collection.size");
	_tmp30_ = _data2_->one;
	_vala_assert (_tmp30_, "one");
	_tmp31_ = _data2_->two;
	_vala_assert (_tmp31_, "two");
	_tmp32_ = _data2_->three;
	_vala_assert (_tmp32_, "three");
	_data2_->three = FALSE;
	_tmp33_ = _data2_->three;
	_data2_->two = _tmp33_;
	_tmp34_ = _data2_->two;
	_data2_->one = _tmp34_;
	j = 0;
	_tmp35_ = j;
	_data2_->i = _tmp35_;
	_tmp36_ = self->test_collection;
	_tmp37_ = gee_traversable_map ((GeeTraversable*) _tmp36_, G_TYPE_INT, NULL, NULL, ___lambda11__gee_map_func, _data2_);
	_g_object_unref0 (iter);
	iter = _tmp37_;
	while (TRUE) {
		GeeIterator* _tmp38_ = NULL;
		gboolean _tmp39_ = FALSE;
		gint _tmp40_ = 0;
		gint _tmp41_ = 0;
		gint _tmp42_ = 0;
		GeeIterator* _tmp43_ = NULL;
		gpointer _tmp44_ = NULL;
		gint _tmp45_ = 0;
		GeeIterator* _tmp46_ = NULL;
		gpointer _tmp47_ = NULL;
		gint _tmp48_ = 0;
		gint _tmp49_ = 0;
		gint _tmp50_ = 0;
		_tmp38_ = iter;
		_tmp39_ = gee_iterator_next (_tmp38_);
		if (!_tmp39_) {
			break;
		}
		_tmp40_ = _data2_->i;
		_tmp41_ = j;
		_vala_assert (_tmp40_ == _tmp41_, "i == j");
		_tmp42_ = j;
		_tmp43_ = iter;
		_tmp44_ = gee_iterator_get (_tmp43_);
		_vala_assert (_tmp42_ == ((gint) ((gintptr) _tmp44_)), "j == iter.get ()");
		_tmp45_ = j;
		_tmp46_ = iter;
		_tmp47_ = gee_iterator_get (_tmp46_);
		_vala_assert (_tmp45_ == ((gint) ((gintptr) _tmp47_)), "j == iter.get ()");
		_tmp48_ = j;
		j = _tmp48_ + 1;
		_tmp49_ = _data2_->i;
		_tmp50_ = j;
		_vala_assert (_tmp49_ == _tmp50_, "i == j");
	}
	_tmp51_ = _data2_->i;
	_tmp52_ = j;
	_vala_assert (_tmp51_ == _tmp52_, "i == j");
	_tmp53_ = _data2_->i;
	_tmp54_ = self->test_collection;
	_tmp55_ = gee_collection_get_size (_tmp54_);
	_tmp56_ = _tmp55_;
	_vala_assert (_tmp53_ == _tmp56_, "i == test_collection.size");
	_tmp57_ = _data2_->one;
	_vala_assert (_tmp57_, "one");
	_tmp58_ = _data2_->two;
	_vala_assert (_tmp58_, "two");
	_tmp59_ = _data2_->three;
	_vala_assert (_tmp59_, "three");
	_g_object_unref0 (iter);
	block2_data_unref (_data2_);
	_data2_ = NULL;
}


static Block3Data* block3_data_ref (Block3Data* _data3_) {
	g_atomic_int_inc (&_data3_->_ref_count_);
	return _data3_;
}


static void block3_data_unref (void * _userdata_) {
	Block3Data* _data3_;
	_data3_ = (Block3Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
		CollectionTests * self;
		self = _data3_->self;
		_g_object_unref0 (self);
		g_slice_free (Block3Data, _data3_);
	}
}


static gint __lambda12_ (Block3Data* _data3_, gchar* str, gint cur) {
	CollectionTests * self;
	gint result = 0;
	const gchar* _tmp0_ = NULL;
	gint _tmp6_ = 0;
	self = _data3_->self;
	g_return_val_if_fail (str != NULL, 0);
	_tmp0_ = str;
	if (g_strcmp0 (_tmp0_, "one") == 0) {
		gboolean _tmp1_ = FALSE;
		_tmp1_ = _data3_->one;
		_vala_assert (!_tmp1_, "!one");
		_data3_->one = TRUE;
	} else {
		const gchar* _tmp2_ = NULL;
		_tmp2_ = str;
		if (g_strcmp0 (_tmp2_, "two") == 0) {
			gboolean _tmp3_ = FALSE;
			_tmp3_ = _data3_->two;
			_vala_assert (!_tmp3_, "!two");
			_data3_->two = TRUE;
		} else {
			const gchar* _tmp4_ = NULL;
			_tmp4_ = str;
			if (g_strcmp0 (_tmp4_, "three") == 0) {
				gboolean _tmp5_ = FALSE;
				_tmp5_ = _data3_->three;
				_vala_assert (!_tmp5_, "!three");
				_data3_->three = TRUE;
			} else {
				g_assert_not_reached ();
			}
		}
	}
	_tmp6_ = cur;
	result = _tmp6_ + 1;
	_g_free0 (str);
	return result;
}


static gpointer ___lambda12__gee_fold_func (gpointer g, gpointer a, gpointer self) {
	gpointer result;
	result = __lambda12_ (self, g, a);
	return result;
}


static gint __lambda13_ (Block3Data* _data3_, gchar* str, gint cur) {
	CollectionTests * self;
	gint result = 0;
	const gchar* _tmp0_ = NULL;
	gint _tmp6_ = 0;
	self = _data3_->self;
	g_return_val_if_fail (str != NULL, 0);
	_tmp0_ = str;
	if (g_strcmp0 (_tmp0_, "one") == 0) {
		gboolean _tmp1_ = FALSE;
		_tmp1_ = _data3_->one;
		_vala_assert (!_tmp1_, "!one");
		_data3_->one = TRUE;
	} else {
		const gchar* _tmp2_ = NULL;
		_tmp2_ = str;
		if (g_strcmp0 (_tmp2_, "two") == 0) {
			gboolean _tmp3_ = FALSE;
			_tmp3_ = _data3_->two;
			_vala_assert (!_tmp3_, "!two");
			_data3_->two = TRUE;
		} else {
			const gchar* _tmp4_ = NULL;
			_tmp4_ = str;
			if (g_strcmp0 (_tmp4_, "three") == 0) {
				gboolean _tmp5_ = FALSE;
				_tmp5_ = _data3_->three;
				_vala_assert (!_tmp5_, "!three");
				_data3_->three = TRUE;
			} else {
				g_assert_not_reached ();
			}
		}
	}
	_tmp6_ = cur;
	result = _tmp6_ + 1;
	_g_free0 (str);
	return result;
}


static gpointer ___lambda13__gee_fold_func (gpointer g, gpointer a, gpointer self) {
	gpointer result;
	result = __lambda13_ (self, g, a);
	return result;
}


void collection_tests_test_scan (CollectionTests* self) {
	Block3Data* _data3_;
	GeeCollection* _tmp0_ = NULL;
	gboolean _tmp1_ = FALSE;
	GeeCollection* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	GeeIterator* iter = NULL;
	GeeCollection* _tmp6_ = NULL;
	GeeIterator* _tmp7_ = NULL;
	GeeIterator* _tmp8_ = NULL;
	GeeIterator* _tmp9_ = NULL;
	GeeIterator* _tmp10_ = NULL;
	gint j = 0;
	gint _tmp22_ = 0;
	GeeCollection* _tmp23_ = NULL;
	gint _tmp24_ = 0;
	gint _tmp25_ = 0;
	gboolean _tmp26_ = FALSE;
	gboolean _tmp27_ = FALSE;
	gboolean _tmp28_ = FALSE;
	gboolean _tmp29_ = FALSE;
	gboolean _tmp30_ = FALSE;
	GeeCollection* _tmp31_ = NULL;
	GeeIterator* _tmp32_ = NULL;
	gint _tmp44_ = 0;
	GeeCollection* _tmp45_ = NULL;
	gint _tmp46_ = 0;
	gint _tmp47_ = 0;
	gboolean _tmp48_ = FALSE;
	gboolean _tmp49_ = FALSE;
	gboolean _tmp50_ = FALSE;
	g_return_if_fail (self != NULL);
	_data3_ = g_slice_new0 (Block3Data);
	_data3_->_ref_count_ = 1;
	_data3_->self = g_object_ref (self);
	_tmp0_ = self->test_collection;
	_tmp1_ = gee_collection_add (_tmp0_, "one");
	_vala_assert (_tmp1_, "test_collection.add (\"one\")");
	_tmp2_ = self->test_collection;
	_tmp3_ = gee_collection_add (_tmp2_, "two");
	_vala_assert (_tmp3_, "test_collection.add (\"two\")");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_add (_tmp4_, "three");
	_vala_assert (_tmp5_, "test_collection.add (\"three\")");
	_data3_->one = FALSE;
	_data3_->two = FALSE;
	_data3_->three = FALSE;
	_tmp6_ = self->test_collection;
	_tmp7_ = gee_iterable_iterator ((GeeIterable*) _tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = gee_traversable_scan ((GeeTraversable*) _tmp8_, G_TYPE_INT, NULL, NULL, ___lambda12__gee_fold_func, _data3_, (gpointer) ((gintptr) 0));
	_tmp10_ = _tmp9_;
	_g_object_unref0 (_tmp8_);
	iter = _tmp10_;
	j = 0;
	{
		gboolean _tmp11_ = FALSE;
		_tmp11_ = TRUE;
		while (TRUE) {
			gboolean _tmp12_ = FALSE;
			gint _tmp15_ = 0;
			GeeIterator* _tmp16_ = NULL;
			gpointer _tmp17_ = NULL;
			gint _tmp18_ = 0;
			GeeIterator* _tmp19_ = NULL;
			gpointer _tmp20_ = NULL;
			gint _tmp21_ = 0;
			_tmp12_ = _tmp11_;
			if (!_tmp12_) {
				GeeIterator* _tmp13_ = NULL;
				gboolean _tmp14_ = FALSE;
				_tmp13_ = iter;
				_tmp14_ = gee_iterator_next (_tmp13_);
				if (!_tmp14_) {
					break;
				}
			}
			_tmp11_ = FALSE;
			_tmp15_ = j;
			_tmp16_ = iter;
			_tmp17_ = gee_iterator_get (_tmp16_);
			_vala_assert (_tmp15_ == ((gint) ((gintptr) _tmp17_)), "j == iter.get ()");
			_tmp18_ = j;
			_tmp19_ = iter;
			_tmp20_ = gee_iterator_get (_tmp19_);
			_vala_assert (_tmp18_ == ((gint) ((gintptr) _tmp20_)), "j == iter.get ()");
			_tmp21_ = j;
			j = _tmp21_ + 1;
		}
	}
	_tmp22_ = j;
	_tmp23_ = self->test_collection;
	_tmp24_ = gee_collection_get_size (_tmp23_);
	_tmp25_ = _tmp24_;
	_vala_assert (_tmp22_ == (_tmp25_ + 1), "j == test_collection.size + 1");
	_tmp26_ = _data3_->one;
	_vala_assert (_tmp26_, "one");
	_tmp27_ = _data3_->two;
	_vala_assert (_tmp27_, "two");
	_tmp28_ = _data3_->three;
	_vala_assert (_tmp28_, "three");
	_data3_->three = FALSE;
	_tmp29_ = _data3_->three;
	_data3_->two = _tmp29_;
	_tmp30_ = _data3_->two;
	_data3_->one = _tmp30_;
	j = 0;
	_tmp31_ = self->test_collection;
	_tmp32_ = gee_traversable_scan ((GeeTraversable*) _tmp31_, G_TYPE_INT, NULL, NULL, ___lambda13__gee_fold_func, _data3_, (gpointer) ((gintptr) 0));
	_g_object_unref0 (iter);
	iter = _tmp32_;
	{
		gboolean _tmp33_ = FALSE;
		_tmp33_ = TRUE;
		while (TRUE) {
			gboolean _tmp34_ = FALSE;
			gint _tmp37_ = 0;
			GeeIterator* _tmp38_ = NULL;
			gpointer _tmp39_ = NULL;
			gint _tmp40_ = 0;
			GeeIterator* _tmp41_ = NULL;
			gpointer _tmp42_ = NULL;
			gint _tmp43_ = 0;
			_tmp34_ = _tmp33_;
			if (!_tmp34_) {
				GeeIterator* _tmp35_ = NULL;
				gboolean _tmp36_ = FALSE;
				_tmp35_ = iter;
				_tmp36_ = gee_iterator_next (_tmp35_);
				if (!_tmp36_) {
					break;
				}
			}
			_tmp33_ = FALSE;
			_tmp37_ = j;
			_tmp38_ = iter;
			_tmp39_ = gee_iterator_get (_tmp38_);
			_vala_assert (_tmp37_ == ((gint) ((gintptr) _tmp39_)), "j == iter.get ()");
			_tmp40_ = j;
			_tmp41_ = iter;
			_tmp42_ = gee_iterator_get (_tmp41_);
			_vala_assert (_tmp40_ == ((gint) ((gintptr) _tmp42_)), "j == iter.get ()");
			_tmp43_ = j;
			j = _tmp43_ + 1;
		}
	}
	_tmp44_ = j;
	_tmp45_ = self->test_collection;
	_tmp46_ = gee_collection_get_size (_tmp45_);
	_tmp47_ = _tmp46_;
	_vala_assert (_tmp44_ == (_tmp47_ + 1), "j == test_collection.size + 1");
	_tmp48_ = _data3_->one;
	_vala_assert (_tmp48_, "one");
	_tmp49_ = _data3_->two;
	_vala_assert (_tmp49_, "two");
	_tmp50_ = _data3_->three;
	_vala_assert (_tmp50_, "three");
	_g_object_unref0 (iter);
	block3_data_unref (_data3_);
	_data3_ = NULL;
}


static Block4Data* block4_data_ref (Block4Data* _data4_) {
	g_atomic_int_inc (&_data4_->_ref_count_);
	return _data4_;
}


static void block4_data_unref (void * _userdata_) {
	Block4Data* _data4_;
	_data4_ = (Block4Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
		CollectionTests * self;
		self = _data4_->self;
		_g_object_unref0 (self);
		g_slice_free (Block4Data, _data4_);
	}
}


static gboolean __lambda14_ (Block4Data* _data4_, const gchar* str) {
	CollectionTests * self;
	gboolean result = FALSE;
	const gchar* _tmp0_ = NULL;
	const gchar* _tmp6_ = NULL;
	self = _data4_->self;
	g_return_val_if_fail (str != NULL, FALSE);
	_tmp0_ = str;
	if (g_strcmp0 (_tmp0_, "one") == 0) {
		gboolean _tmp1_ = FALSE;
		_tmp1_ = _data4_->one;
		_vala_assert (!_tmp1_, "!one");
		_data4_->one = TRUE;
	} else {
		const gchar* _tmp2_ = NULL;
		_tmp2_ = str;
		if (g_strcmp0 (_tmp2_, "two") == 0) {
			gboolean _tmp3_ = FALSE;
			_tmp3_ = _data4_->two;
			_vala_assert (!_tmp3_, "!two");
			_data4_->two = TRUE;
		} else {
			const gchar* _tmp4_ = NULL;
			_tmp4_ = str;
			if (g_strcmp0 (_tmp4_, "three") == 0) {
				gboolean _tmp5_ = FALSE;
				_tmp5_ = _data4_->three;
				_vala_assert (!_tmp5_, "!three");
				_data4_->three = TRUE;
			} else {
				g_assert_not_reached ();
			}
		}
	}
	_tmp6_ = str;
	result = g_strcmp0 (_tmp6_, "two") != 0;
	return result;
}


static gboolean ___lambda14__gee_predicate (gconstpointer g, gpointer self) {
	gboolean result;
	result = __lambda14_ (self, g);
	return result;
}


static gboolean __lambda15_ (Block4Data* _data4_, const gchar* str) {
	CollectionTests * self;
	gboolean result = FALSE;
	const gchar* _tmp0_ = NULL;
	const gchar* _tmp6_ = NULL;
	self = _data4_->self;
	g_return_val_if_fail (str != NULL, FALSE);
	_tmp0_ = str;
	if (g_strcmp0 (_tmp0_, "one") == 0) {
		gboolean _tmp1_ = FALSE;
		_tmp1_ = _data4_->one;
		_vala_assert (!_tmp1_, "!one");
		_data4_->one = TRUE;
	} else {
		const gchar* _tmp2_ = NULL;
		_tmp2_ = str;
		if (g_strcmp0 (_tmp2_, "two") == 0) {
			gboolean _tmp3_ = FALSE;
			_tmp3_ = _data4_->two;
			_vala_assert (!_tmp3_, "!two");
			_data4_->two = TRUE;
		} else {
			const gchar* _tmp4_ = NULL;
			_tmp4_ = str;
			if (g_strcmp0 (_tmp4_, "three") == 0) {
				gboolean _tmp5_ = FALSE;
				_tmp5_ = _data4_->three;
				_vala_assert (!_tmp5_, "!three");
				_data4_->three = TRUE;
			} else {
				g_assert_not_reached ();
			}
		}
	}
	_tmp6_ = str;
	result = g_strcmp0 (_tmp6_, "two") != 0;
	return result;
}


static gboolean ___lambda15__gee_predicate (gconstpointer g, gpointer self) {
	gboolean result;
	result = __lambda15_ (self, g);
	return result;
}


void collection_tests_test_filter (CollectionTests* self) {
	Block4Data* _data4_;
	GeeCollection* _tmp0_ = NULL;
	gboolean _tmp1_ = FALSE;
	GeeCollection* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	GeeIterator* iter = NULL;
	GeeCollection* _tmp6_ = NULL;
	GeeIterator* _tmp7_ = NULL;
	GeeIterator* _tmp8_ = NULL;
	GeeIterator* _tmp9_ = NULL;
	GeeIterator* _tmp10_ = NULL;
	GeeIterator* _tmp11_ = NULL;
	gboolean _tmp12_ = FALSE;
	gboolean _tmp13_ = FALSE;
	gint j = 0;
	gint _tmp20_ = 0;
	gboolean _tmp21_ = FALSE;
	gboolean _tmp22_ = FALSE;
	gboolean _tmp23_ = FALSE;
	gboolean _tmp24_ = FALSE;
	gboolean _tmp25_ = FALSE;
	GeeCollection* _tmp26_ = NULL;
	GeeIterator* _tmp27_ = NULL;
	GeeIterator* _tmp28_ = NULL;
	gboolean _tmp29_ = FALSE;
	gboolean _tmp30_ = FALSE;
	gint _tmp37_ = 0;
	gboolean _tmp38_ = FALSE;
	gboolean _tmp39_ = FALSE;
	gboolean _tmp40_ = FALSE;
	g_return_if_fail (self != NULL);
	_data4_ = g_slice_new0 (Block4Data);
	_data4_->_ref_count_ = 1;
	_data4_->self = g_object_ref (self);
	_tmp0_ = self->test_collection;
	_tmp1_ = gee_collection_add (_tmp0_, "one");
	_vala_assert (_tmp1_, "test_collection.add (\"one\")");
	_tmp2_ = self->test_collection;
	_tmp3_ = gee_collection_add (_tmp2_, "two");
	_vala_assert (_tmp3_, "test_collection.add (\"two\")");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_add (_tmp4_, "three");
	_vala_assert (_tmp5_, "test_collection.add (\"three\")");
	_data4_->one = FALSE;
	_data4_->two = FALSE;
	_data4_->three = FALSE;
	_tmp6_ = self->test_collection;
	_tmp7_ = gee_iterable_iterator ((GeeIterable*) _tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = gee_traversable_filter ((GeeTraversable*) _tmp8_, ___lambda14__gee_predicate, block4_data_ref (_data4_), block4_data_unref);
	_tmp10_ = _tmp9_;
	_g_object_unref0 (_tmp8_);
	iter = _tmp10_;
	_tmp11_ = iter;
	_tmp12_ = gee_iterator_get_valid (_tmp11_);
	_tmp13_ = _tmp12_;
	_vala_assert (!_tmp13_, "!iter.valid");
	j = 0;
	while (TRUE) {
		GeeIterator* _tmp14_ = NULL;
		gboolean _tmp15_ = FALSE;
		GeeIterator* _tmp16_ = NULL;
		gpointer _tmp17_ = NULL;
		gchar* _tmp18_ = NULL;
		gint _tmp19_ = 0;
		_tmp14_ = iter;
		_tmp15_ = gee_iterator_next (_tmp14_);
		if (!_tmp15_) {
			break;
		}
		_tmp16_ = iter;
		_tmp17_ = gee_iterator_get (_tmp16_);
		_tmp18_ = (gchar*) _tmp17_;
		_vala_assert (g_strcmp0 (_tmp18_, "two") != 0, "iter.get () != \"two\"");
		_g_free0 (_tmp18_);
		_tmp19_ = j;
		j = _tmp19_ + 1;
	}
	_tmp20_ = j;
	_vala_assert (_tmp20_ == 2, "j == 2");
	_tmp21_ = _data4_->one;
	_vala_assert (_tmp21_, "one");
	_tmp22_ = _data4_->two;
	_vala_assert (_tmp22_, "two");
	_tmp23_ = _data4_->three;
	_vala_assert (_tmp23_, "three");
	_data4_->three = FALSE;
	_tmp24_ = _data4_->three;
	_data4_->two = _tmp24_;
	_tmp25_ = _data4_->two;
	_data4_->one = _tmp25_;
	j = 0;
	_tmp26_ = self->test_collection;
	_tmp27_ = gee_traversable_filter ((GeeTraversable*) _tmp26_, ___lambda15__gee_predicate, block4_data_ref (_data4_), block4_data_unref);
	_g_object_unref0 (iter);
	iter = _tmp27_;
	_tmp28_ = iter;
	_tmp29_ = gee_iterator_get_valid (_tmp28_);
	_tmp30_ = _tmp29_;
	_vala_assert (!_tmp30_, "!iter.valid");
	while (TRUE) {
		GeeIterator* _tmp31_ = NULL;
		gboolean _tmp32_ = FALSE;
		GeeIterator* _tmp33_ = NULL;
		gpointer _tmp34_ = NULL;
		gchar* _tmp35_ = NULL;
		gint _tmp36_ = 0;
		_tmp31_ = iter;
		_tmp32_ = gee_iterator_next (_tmp31_);
		if (!_tmp32_) {
			break;
		}
		_tmp33_ = iter;
		_tmp34_ = gee_iterator_get (_tmp33_);
		_tmp35_ = (gchar*) _tmp34_;
		_vala_assert (g_strcmp0 (_tmp35_, "two") != 0, "iter.get () != \"two\"");
		_g_free0 (_tmp35_);
		_tmp36_ = j;
		j = _tmp36_ + 1;
	}
	_tmp37_ = j;
	_vala_assert (_tmp37_ == 2, "j == 2");
	_tmp38_ = _data4_->one;
	_vala_assert (_tmp38_, "one");
	_tmp39_ = _data4_->two;
	_vala_assert (_tmp39_, "two");
	_tmp40_ = _data4_->three;
	_vala_assert (_tmp40_, "three");
	_g_object_unref0 (iter);
	block4_data_unref (_data4_);
	_data4_ = NULL;
}


void collection_tests_test_chop (CollectionTests* self) {
	GeeCollection* _tmp0_ = NULL;
	gboolean _tmp1_ = FALSE;
	GeeCollection* _tmp2_ = NULL;
	gboolean _tmp3_ = FALSE;
	GeeCollection* _tmp4_ = NULL;
	gboolean _tmp5_ = FALSE;
	GeeIterator* iter = NULL;
	GeeCollection* _tmp6_ = NULL;
	GeeIterator* _tmp7_ = NULL;
	GeeIterator* _tmp8_ = NULL;
	GeeIterator* _tmp9_ = NULL;
	GeeIterator* _tmp10_ = NULL;
	GeeIterator* _tmp11_ = NULL;
	gboolean _tmp12_ = FALSE;
	gboolean _tmp13_ = FALSE;
	GeeIterator* iter2 = NULL;
	GeeCollection* _tmp14_ = NULL;
	GeeIterator* _tmp15_ = NULL;
	GeeIterator* _tmp16_ = NULL;
	gboolean _tmp17_ = FALSE;
	GeeIterator* _tmp18_ = NULL;
	gboolean _tmp19_ = FALSE;
	GeeIterator* _tmp20_ = NULL;
	gboolean _tmp21_ = FALSE;
	GeeIterator* _tmp22_ = NULL;
	gpointer _tmp23_ = NULL;
	gchar* _tmp24_ = NULL;
	GeeIterator* _tmp25_ = NULL;
	gpointer _tmp26_ = NULL;
	gchar* _tmp27_ = NULL;
	GeeIterator* _tmp28_ = NULL;
	gboolean _tmp29_ = FALSE;
	GeeIterator* _tmp30_ = NULL;
	gboolean _tmp31_ = FALSE;
	GeeCollection* _tmp32_ = NULL;
	GeeIterator* _tmp33_ = NULL;
	GeeIterator* _tmp34_ = NULL;
	gboolean _tmp35_ = FALSE;
	gboolean _tmp36_ = FALSE;
	GeeCollection* _tmp37_ = NULL;
	GeeIterator* _tmp38_ = NULL;
	GeeIterator* _tmp39_ = NULL;
	gboolean _tmp40_ = FALSE;
	GeeIterator* _tmp41_ = NULL;
	gboolean _tmp42_ = FALSE;
	GeeIterator* _tmp43_ = NULL;
	gboolean _tmp44_ = FALSE;
	GeeIterator* _tmp45_ = NULL;
	gpointer _tmp46_ = NULL;
	gchar* _tmp47_ = NULL;
	GeeIterator* _tmp48_ = NULL;
	gpointer _tmp49_ = NULL;
	gchar* _tmp50_ = NULL;
	GeeIterator* _tmp51_ = NULL;
	gboolean _tmp52_ = FALSE;
	GeeIterator* _tmp53_ = NULL;
	gboolean _tmp54_ = FALSE;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_collection;
	_tmp1_ = gee_collection_add (_tmp0_, "one");
	_vala_assert (_tmp1_, "test_collection.add (\"one\")");
	_tmp2_ = self->test_collection;
	_tmp3_ = gee_collection_add (_tmp2_, "two");
	_vala_assert (_tmp3_, "test_collection.add (\"two\")");
	_tmp4_ = self->test_collection;
	_tmp5_ = gee_collection_add (_tmp4_, "three");
	_vala_assert (_tmp5_, "test_collection.add (\"three\")");
	_tmp6_ = self->test_collection;
	_tmp7_ = gee_iterable_iterator ((GeeIterable*) _tmp6_);
	_tmp8_ = _tmp7_;
	_tmp9_ = gee_traversable_chop ((GeeTraversable*) _tmp8_, 1, 1);
	_tmp10_ = _tmp9_;
	_g_object_unref0 (_tmp8_);
	iter = _tmp10_;
	_tmp11_ = iter;
	_tmp12_ = gee_iterator_get_valid (_tmp11_);
	_tmp13_ = _tmp12_;
	_vala_assert (!_tmp13_, "!iter.valid");
	_tmp14_ = self->test_collection;
	_tmp15_ = gee_iterable_iterator ((GeeIterable*) _tmp14_);
	iter2 = _tmp15_;
	_tmp16_ = iter2;
	_tmp17_ = gee_iterator_next (_tmp16_);
	_vala_assert (_tmp17_, "iter2.next ()");
	_tmp18_ = iter2;
	_tmp19_ = gee_iterator_next (_tmp18_);
	_vala_assert (_tmp19_, "iter2.next ()");
	_tmp20_ = iter;
	_tmp21_ = gee_iterator_next (_tmp20_);
	_vala_assert (_tmp21_, "iter.next ()");
	_tmp22_ = iter2;
	_tmp23_ = gee_iterator_get (_tmp22_);
	_tmp24_ = (gchar*) _tmp23_;
	_tmp25_ = iter;
	_tmp26_ = gee_iterator_get (_tmp25_);
	_tmp27_ = (gchar*) _tmp26_;
	_vala_assert (g_strcmp0 (_tmp24_, _tmp27_) == 0, "iter2.get () == iter.get ()");
	_g_free0 (_tmp27_);
	_g_free0 (_tmp24_);
	_tmp28_ = iter;
	_tmp29_ = gee_iterator_next (_tmp28_);
	_vala_assert (!_tmp29_, "!iter.next ()");
	_tmp30_ = iter2;
	_tmp31_ = gee_iterator_next (_tmp30_);
	_vala_assert (_tmp31_, "iter2.next ()");
	_tmp32_ = self->test_collection;
	_tmp33_ = gee_traversable_chop ((GeeTraversable*) _tmp32_, 1, 1);
	_g_object_unref0 (iter);
	iter = _tmp33_;
	_tmp34_ = iter;
	_tmp35_ = gee_iterator_get_valid (_tmp34_);
	_tmp36_ = _tmp35_;
	_vala_assert (!_tmp36_, "!iter.valid");
	_tmp37_ = self->test_collection;
	_tmp38_ = gee_iterable_iterator ((GeeIterable*) _tmp37_);
	_g_object_unref0 (iter2);
	iter2 = _tmp38_;
	_tmp39_ = iter2;
	_tmp40_ = gee_iterator_next (_tmp39_);
	_vala_assert (_tmp40_, "iter2.next ()");
	_tmp41_ = iter2;
	_tmp42_ = gee_iterator_next (_tmp41_);
	_vala_assert (_tmp42_, "iter2.next ()");
	_tmp43_ = iter;
	_tmp44_ = gee_iterator_next (_tmp43_);
	_vala_assert (_tmp44_, "iter.next ()");
	_tmp45_ = iter2;
	_tmp46_ = gee_iterator_get (_tmp45_);
	_tmp47_ = (gchar*) _tmp46_;
	_tmp48_ = iter;
	_tmp49_ = gee_iterator_get (_tmp48_);
	_tmp50_ = (gchar*) _tmp49_;
	_vala_assert (g_strcmp0 (_tmp47_, _tmp50_) == 0, "iter2.get () == iter.get ()");
	_g_free0 (_tmp50_);
	_g_free0 (_tmp47_);
	_tmp51_ = iter;
	_tmp52_ = gee_iterator_next (_tmp51_);
	_vala_assert (!_tmp52_, "!iter.next ()");
	_tmp53_ = iter2;
	_tmp54_ = gee_iterator_next (_tmp53_);
	_vala_assert (_tmp54_, "iter2.next ()");
	_g_object_unref0 (iter2);
	_g_object_unref0 (iter);
}


static void collection_tests_class_init (CollectionTestsClass * klass) {
	collection_tests_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = collection_tests_finalize;
}


static void collection_tests_instance_init (CollectionTests * self) {
}


static void collection_tests_finalize (GObject* obj) {
	CollectionTests * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_COLLECTION_TESTS, CollectionTests);
	_g_object_unref0 (self->test_collection);
	G_OBJECT_CLASS (collection_tests_parent_class)->finalize (obj);
}


GType collection_tests_get_type (void) {
	static volatile gsize collection_tests_type_id__volatile = 0;
	if (g_once_init_enter (&collection_tests_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (CollectionTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) collection_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (CollectionTests), 0, (GInstanceInitFunc) collection_tests_instance_init, NULL };
		GType collection_tests_type_id;
		collection_tests_type_id = g_type_register_static (GEE_TYPE_TEST_CASE, "CollectionTests", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
		g_once_init_leave (&collection_tests_type_id__volatile, collection_tests_type_id);
	}
	return collection_tests_type_id__volatile;
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	if ((array != NULL) && (destroy_func != NULL)) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}



