/* testreadonlymap.c generated by valac 0.19.0.4-d6d4, the Vala compiler
 * generated from testreadonlymap.vala, do not modify */

/* testreadonlymap.vala
 *
 * Copyright (C) 2008  Jürg Billeter
 * Copyright (C) 2009  Didier Villevalois
 *
 * 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:
 * 	Didier 'Ptitjes' Villevalois <ptitjes@free.fr>
 */

#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_READ_ONLY_MAP_TESTS (read_only_map_tests_get_type ())
#define READ_ONLY_MAP_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_READ_ONLY_MAP_TESTS, ReadOnlyMapTests))
#define READ_ONLY_MAP_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_READ_ONLY_MAP_TESTS, ReadOnlyMapTestsClass))
#define IS_READ_ONLY_MAP_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_READ_ONLY_MAP_TESTS))
#define IS_READ_ONLY_MAP_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_READ_ONLY_MAP_TESTS))
#define READ_ONLY_MAP_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_READ_ONLY_MAP_TESTS, ReadOnlyMapTestsClass))

typedef struct _ReadOnlyMapTests ReadOnlyMapTests;
typedef struct _ReadOnlyMapTestsClass ReadOnlyMapTestsClass;
typedef struct _ReadOnlyMapTestsPrivate ReadOnlyMapTestsPrivate;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#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 _ReadOnlyMapTests {
	GeeTestCase parent_instance;
	ReadOnlyMapTestsPrivate * priv;
	GeeMap* test_map;
	GeeMap* ro_map;
};

struct _ReadOnlyMapTestsClass {
	GeeTestCaseClass parent_class;
};

typedef void (*GeeTestCaseTestMethod) (void* user_data);

static gpointer read_only_map_tests_parent_class = NULL;

GType gee_test_case_get_type (void) G_GNUC_CONST;
GType read_only_map_tests_get_type (void) G_GNUC_CONST;
enum  {
	READ_ONLY_MAP_TESTS_DUMMY_PROPERTY
};
ReadOnlyMapTests* read_only_map_tests_new (void);
ReadOnlyMapTests* read_only_map_tests_construct (GType object_type);
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);
void read_only_map_tests_test_unique_read_only_view_instance (ReadOnlyMapTests* self);
static void _read_only_map_tests_test_unique_read_only_view_instance_gee_test_case_test_method (gpointer self);
void read_only_map_tests_test_immutable_iterator (ReadOnlyMapTests* self);
static void _read_only_map_tests_test_immutable_iterator_gee_test_case_test_method (gpointer self);
void read_only_map_tests_test_immutable (ReadOnlyMapTests* self);
static void _read_only_map_tests_test_immutable_gee_test_case_test_method (gpointer self);
void read_only_map_tests_test_accurate_view (ReadOnlyMapTests* self);
static void _read_only_map_tests_test_accurate_view_gee_test_case_test_method (gpointer self);
static void read_only_map_tests_real_set_up (GeeTestCase* base);
static void read_only_map_tests_real_tear_down (GeeTestCase* base);
static void read_only_map_tests_finalize (GObject* obj);


static void _read_only_map_tests_test_unique_read_only_view_instance_gee_test_case_test_method (gpointer self) {
	read_only_map_tests_test_unique_read_only_view_instance (self);
}


static void _read_only_map_tests_test_immutable_iterator_gee_test_case_test_method (gpointer self) {
	read_only_map_tests_test_immutable_iterator (self);
}


static void _read_only_map_tests_test_immutable_gee_test_case_test_method (gpointer self) {
	read_only_map_tests_test_immutable (self);
}


static void _read_only_map_tests_test_accurate_view_gee_test_case_test_method (gpointer self) {
	read_only_map_tests_test_accurate_view (self);
}


ReadOnlyMapTests* read_only_map_tests_construct (GType object_type) {
	ReadOnlyMapTests * self = NULL;
	self = (ReadOnlyMapTests*) gee_test_case_construct (object_type, "ReadOnlyMap");
	gee_test_case_add_test ((GeeTestCase*) self, "[ReadOnlyMap] unique read-only view instance", _read_only_map_tests_test_unique_read_only_view_instance_gee_test_case_test_method, self);
	gee_test_case_add_test ((GeeTestCase*) self, "[ReadOnlyMap] immutable iterator", _read_only_map_tests_test_immutable_iterator_gee_test_case_test_method, self);
	gee_test_case_add_test ((GeeTestCase*) self, "[ReadOnlyMap] immutable", _read_only_map_tests_test_immutable_gee_test_case_test_method, self);
	gee_test_case_add_test ((GeeTestCase*) self, "[ReadOnlyMap] accurate view", _read_only_map_tests_test_accurate_view_gee_test_case_test_method, self);
	return self;
}


ReadOnlyMapTests* read_only_map_tests_new (void) {
	return read_only_map_tests_construct (TYPE_READ_ONLY_MAP_TESTS);
}


static void read_only_map_tests_real_set_up (GeeTestCase* base) {
	ReadOnlyMapTests * self;
	GeeTreeMap* _tmp0_;
	GeeMap* _tmp1_;
	GeeMap* _tmp2_;
	GeeMap* _tmp3_;
	self = (ReadOnlyMapTests*) base;
	_tmp0_ = gee_tree_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL);
	_g_object_unref0 (self->test_map);
	self->test_map = (GeeMap*) _tmp0_;
	_tmp1_ = self->test_map;
	_tmp2_ = gee_map_get_read_only_view (_tmp1_);
	_tmp3_ = _tmp2_;
	_g_object_unref0 (self->ro_map);
	self->ro_map = _tmp3_;
}


static void read_only_map_tests_real_tear_down (GeeTestCase* base) {
	ReadOnlyMapTests * self;
	self = (ReadOnlyMapTests*) base;
	_g_object_unref0 (self->test_map);
	self->test_map = NULL;
	_g_object_unref0 (self->ro_map);
	self->ro_map = NULL;
}


void read_only_map_tests_test_unique_read_only_view_instance (ReadOnlyMapTests* self) {
	GeeMap* _tmp0_;
	GeeMap* _tmp1_;
	GeeMap* _tmp2_;
	GeeMap* another_ro_map;
	GeeMap* _tmp3_;
	GeeMap* _tmp4_;
	GeeMap* _tmp5_;
	GObject* _tmp6_;
	GeeMap* _tmp7_;
	gconstpointer _tmp8_ = NULL;
	GeeMap* _tmp9_;
	GeeMap* _tmp10_;
	GeeMap* _tmp11_;
	GeeMap* _tmp12_;
	gconstpointer _tmp13_ = NULL;
	GeeMap* _tmp14_;
	GeeMap* _tmp15_;
	GeeMap* _tmp16_;
	GeeMap* _tmp17_;
	GeeMap* _tmp18_;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_map;
	_tmp1_ = gee_map_get_read_only_view (_tmp0_);
	_tmp2_ = _tmp1_;
	another_ro_map = _tmp2_;
	_tmp3_ = self->ro_map;
	_tmp4_ = another_ro_map;
	_vala_assert (_tmp3_ == _tmp4_, "ro_map == another_ro_map");
	_tmp5_ = self->ro_map;
	_tmp6_ = g_object_new (G_TYPE_OBJECT, NULL);
	g_object_set_data_full ((GObject*) _tmp5_, "marker", _tmp6_, g_object_unref);
	_tmp7_ = another_ro_map;
	_tmp8_ = g_object_get_data ((GObject*) _tmp7_, "marker");
	_vala_assert (((GObject*) _tmp8_) != NULL, "another_ro_map.get_data<Object> (\"marker\") != null");
	_g_object_unref0 (another_ro_map);
	another_ro_map = NULL;
	_g_object_unref0 (self->ro_map);
	self->ro_map = NULL;
	_tmp9_ = self->test_map;
	_tmp10_ = gee_map_get_read_only_view (_tmp9_);
	_tmp11_ = _tmp10_;
	_g_object_unref0 (another_ro_map);
	another_ro_map = _tmp11_;
	_tmp12_ = another_ro_map;
	_tmp13_ = g_object_get_data ((GObject*) _tmp12_, "marker");
	_vala_assert (((GObject*) _tmp13_) == NULL, "another_ro_map.get_data<Object> (\"marker\") == null");
	_tmp14_ = another_ro_map;
	_tmp15_ = another_ro_map;
	_tmp16_ = gee_map_get_read_only_view (_tmp15_);
	_tmp17_ = _tmp16_;
	_tmp18_ = _tmp17_;
	_vala_assert (_tmp14_ == _tmp18_, "another_ro_map == another_ro_map.read_only_view");
	_g_object_unref0 (_tmp18_);
	_g_object_unref0 (another_ro_map);
}


void read_only_map_tests_test_immutable_iterator (ReadOnlyMapTests* self) {
	GeeMap* _tmp0_;
	GeeMap* _tmp1_;
	GeeMap* _tmp2_;
	gint _tmp3_;
	gint _tmp4_;
	GeeMap* _tmp5_;
	gboolean _tmp6_ = FALSE;
	GeeMap* _tmp7_;
	gboolean _tmp8_ = FALSE;
	GeeMap* _tmp9_;
	gboolean _tmp10_ = FALSE;
	GeeMap* _tmp11_;
	gboolean _tmp12_ = FALSE;
	GeeMap* _tmp13_;
	GeeSet* _tmp14_;
	GeeSet* _tmp15_;
	GeeSet* _tmp16_;
	GeeIterator* _tmp17_ = NULL;
	GeeIterator* _tmp18_;
	GeeIterator* iterator;
	GeeIterator* _tmp19_;
	gboolean _tmp20_ = FALSE;
	GeeIterator* _tmp21_;
	gboolean _tmp22_ = FALSE;
	GeeIterator* _tmp23_;
	gpointer _tmp24_ = NULL;
	gchar* _tmp25_;
	GeeIterator* _tmp26_;
	gboolean _tmp27_ = FALSE;
	GeeIterator* _tmp28_;
	gboolean _tmp29_ = FALSE;
	GeeIterator* _tmp30_;
	gpointer _tmp31_ = NULL;
	gchar* _tmp32_;
	GeeIterator* _tmp33_;
	gboolean _tmp34_ = FALSE;
	GeeIterator* _tmp35_;
	gboolean _tmp36_ = FALSE;
	GeeIterator* _tmp37_;
	gboolean _tmp38_ = FALSE;
	GeeIterator* _tmp39_;
	gpointer _tmp40_ = NULL;
	gchar* _tmp41_;
	gboolean _tmp42_ = FALSE;
	GeeMap* _tmp44_;
	gint _tmp45_;
	gint _tmp46_;
	GeeMap* _tmp47_;
	gboolean _tmp48_ = FALSE;
	GeeMap* _tmp49_;
	gboolean _tmp50_ = FALSE;
	GeeMap* _tmp51_;
	gboolean _tmp52_ = FALSE;
	GeeMap* _tmp53_;
	gboolean _tmp54_ = FALSE;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_map;
	gee_map_set (_tmp0_, "one", "one");
	_tmp1_ = self->test_map;
	gee_map_set (_tmp1_, "two", "two");
	_tmp2_ = self->ro_map;
	_tmp3_ = gee_map_get_size (_tmp2_);
	_tmp4_ = _tmp3_;
	_vala_assert (_tmp4_ == 2, "ro_map.size == 2");
	_tmp5_ = self->ro_map;
	_tmp6_ = gee_map_has_key (_tmp5_, "one");
	_vala_assert (_tmp6_, "ro_map.has_key (\"one\")");
	_tmp7_ = self->ro_map;
	_tmp8_ = gee_map_has (_tmp7_, "one", "one");
	_vala_assert (_tmp8_, "ro_map.has (\"one\", \"one\")");
	_tmp9_ = self->ro_map;
	_tmp10_ = gee_map_has_key (_tmp9_, "two");
	_vala_assert (_tmp10_, "ro_map.has_key (\"two\")");
	_tmp11_ = self->ro_map;
	_tmp12_ = gee_map_has (_tmp11_, "two", "two");
	_vala_assert (_tmp12_, "ro_map.has (\"two\", \"two\")");
	_tmp13_ = self->ro_map;
	_tmp14_ = gee_map_get_keys (_tmp13_);
	_tmp15_ = _tmp14_;
	_tmp16_ = _tmp15_;
	_tmp17_ = gee_iterable_iterator ((GeeIterable*) _tmp16_);
	_tmp18_ = _tmp17_;
	_g_object_unref0 (_tmp16_);
	iterator = _tmp18_;
	_tmp19_ = iterator;
	_tmp20_ = gee_iterator_has_next (_tmp19_);
	_vala_assert (_tmp20_, "iterator.has_next ()");
	_tmp21_ = iterator;
	_tmp22_ = gee_iterator_next (_tmp21_);
	_vala_assert (_tmp22_, "iterator.next ()");
	_tmp23_ = iterator;
	_tmp24_ = gee_iterator_get (_tmp23_);
	_tmp25_ = (gchar*) _tmp24_;
	_vala_assert (g_strcmp0 (_tmp25_, "one") == 0, "iterator.get () == \"one\"");
	_g_free0 (_tmp25_);
	_tmp26_ = iterator;
	_tmp27_ = gee_iterator_has_next (_tmp26_);
	_vala_assert (_tmp27_, "iterator.has_next ()");
	_tmp28_ = iterator;
	_tmp29_ = gee_iterator_next (_tmp28_);
	_vala_assert (_tmp29_, "iterator.next ()");
	_tmp30_ = iterator;
	_tmp31_ = gee_iterator_get (_tmp30_);
	_tmp32_ = (gchar*) _tmp31_;
	_vala_assert (g_strcmp0 (_tmp32_, "two") == 0, "iterator.get () == \"two\"");
	_g_free0 (_tmp32_);
	_tmp33_ = iterator;
	_tmp34_ = gee_iterator_has_next (_tmp33_);
	_vala_assert (!_tmp34_, "! iterator.has_next ()");
	_tmp35_ = iterator;
	_tmp36_ = gee_iterator_next (_tmp35_);
	_vala_assert (!_tmp36_, "! iterator.next ()");
	_tmp37_ = iterator;
	_tmp38_ = gee_iterator_first (_tmp37_);
	_vala_assert (_tmp38_, "iterator.first ()");
	_tmp39_ = iterator;
	_tmp40_ = gee_iterator_get (_tmp39_);
	_tmp41_ = (gchar*) _tmp40_;
	_vala_assert (g_strcmp0 (_tmp41_, "one") == 0, "iterator.get () == \"one\"");
	_g_free0 (_tmp41_);
	_tmp42_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
	if (_tmp42_) {
		GeeIterator* _tmp43_;
		_tmp43_ = iterator;
		gee_iterator_remove (_tmp43_);
		exit (0);
	}
	g_test_trap_assert_failed ();
	_tmp44_ = self->ro_map;
	_tmp45_ = gee_map_get_size (_tmp44_);
	_tmp46_ = _tmp45_;
	_vala_assert (_tmp46_ == 2, "ro_map.size == 2");
	_tmp47_ = self->ro_map;
	_tmp48_ = gee_map_has_key (_tmp47_, "one");
	_vala_assert (_tmp48_, "ro_map.has_key (\"one\")");
	_tmp49_ = self->ro_map;
	_tmp50_ = gee_map_has (_tmp49_, "one", "one");
	_vala_assert (_tmp50_, "ro_map.has (\"one\", \"one\")");
	_tmp51_ = self->ro_map;
	_tmp52_ = gee_map_has_key (_tmp51_, "two");
	_vala_assert (_tmp52_, "ro_map.has_key (\"two\")");
	_tmp53_ = self->ro_map;
	_tmp54_ = gee_map_has (_tmp53_, "two", "two");
	_vala_assert (_tmp54_, "ro_map.has (\"two\", \"two\")");
	_g_object_unref0 (iterator);
}


void read_only_map_tests_test_immutable (ReadOnlyMapTests* self) {
	GeeMap* _tmp0_;
	GeeMap* _tmp1_;
	gint _tmp2_;
	gint _tmp3_;
	GeeMap* _tmp4_;
	gboolean _tmp5_ = FALSE;
	GeeMap* _tmp6_;
	gboolean _tmp7_ = FALSE;
	GeeHashMap* _tmp8_;
	GeeMap* dummy;
	GeeMap* _tmp9_;
	GeeMap* _tmp10_;
	gboolean _tmp11_ = FALSE;
	GeeMap* _tmp13_;
	gint _tmp14_;
	gint _tmp15_;
	GeeMap* _tmp16_;
	gboolean _tmp17_ = FALSE;
	GeeMap* _tmp18_;
	gboolean _tmp19_ = FALSE;
	gboolean _tmp20_ = FALSE;
	GeeMap* _tmp22_;
	gint _tmp23_;
	gint _tmp24_;
	GeeMap* _tmp25_;
	gboolean _tmp26_ = FALSE;
	GeeMap* _tmp27_;
	gboolean _tmp28_ = FALSE;
	gboolean _tmp29_ = FALSE;
	GeeMap* _tmp32_;
	gint _tmp33_;
	gint _tmp34_;
	GeeMap* _tmp35_;
	gboolean _tmp36_ = FALSE;
	GeeMap* _tmp37_;
	gboolean _tmp38_ = FALSE;
	gboolean _tmp39_ = FALSE;
	GeeMap* _tmp42_;
	gint _tmp43_;
	gint _tmp44_;
	GeeMap* _tmp45_;
	gboolean _tmp46_ = FALSE;
	GeeMap* _tmp47_;
	gboolean _tmp48_ = FALSE;
	gboolean _tmp49_ = FALSE;
	GeeMap* _tmp53_;
	gint _tmp54_;
	gint _tmp55_;
	GeeMap* _tmp56_;
	gboolean _tmp57_ = FALSE;
	GeeMap* _tmp58_;
	gboolean _tmp59_ = FALSE;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->test_map;
	gee_map_set (_tmp0_, "one", "one");
	_tmp1_ = self->ro_map;
	_tmp2_ = gee_map_get_size (_tmp1_);
	_tmp3_ = _tmp2_;
	_vala_assert (_tmp3_ == 1, "ro_map.size == 1");
	_tmp4_ = self->ro_map;
	_tmp5_ = gee_map_has_key (_tmp4_, "one");
	_vala_assert (_tmp5_, "ro_map.has_key (\"one\")");
	_tmp6_ = self->ro_map;
	_tmp7_ = gee_map_has (_tmp6_, "one", "one");
	_vala_assert (_tmp7_, "ro_map.has (\"one\", \"one\")");
	_tmp8_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);
	dummy = (GeeMap*) _tmp8_;
	_tmp9_ = dummy;
	gee_map_set (_tmp9_, "one", "one");
	_tmp10_ = dummy;
	gee_map_set (_tmp10_, "two", "two");
	_tmp11_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
	if (_tmp11_) {
		GeeMap* _tmp12_;
		_tmp12_ = self->ro_map;
		gee_map_set (_tmp12_, "two", "two");
		exit (0);
	}
	g_test_trap_assert_failed ();
	_tmp13_ = self->ro_map;
	_tmp14_ = gee_map_get_size (_tmp13_);
	_tmp15_ = _tmp14_;
	_vala_assert (_tmp15_ == 1, "ro_map.size == 1");
	_tmp16_ = self->ro_map;
	_tmp17_ = gee_map_has_key (_tmp16_, "one");
	_vala_assert (_tmp17_, "ro_map.has_key (\"one\")");
	_tmp18_ = self->ro_map;
	_tmp19_ = gee_map_has (_tmp18_, "one", "one");
	_vala_assert (_tmp19_, "ro_map.has (\"one\", \"one\")");
	_tmp20_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
	if (_tmp20_) {
		GeeMap* _tmp21_;
		_tmp21_ = self->ro_map;
		gee_map_clear (_tmp21_);
		exit (0);
	}
	g_test_trap_assert_failed ();
	_tmp22_ = self->ro_map;
	_tmp23_ = gee_map_get_size (_tmp22_);
	_tmp24_ = _tmp23_;
	_vala_assert (_tmp24_ == 1, "ro_map.size == 1");
	_tmp25_ = self->ro_map;
	_tmp26_ = gee_map_has_key (_tmp25_, "one");
	_vala_assert (_tmp26_, "ro_map.has_key (\"one\")");
	_tmp27_ = self->ro_map;
	_tmp28_ = gee_map_has (_tmp27_, "one", "one");
	_vala_assert (_tmp28_, "ro_map.has (\"one\", \"one\")");
	_tmp29_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
	if (_tmp29_) {
		GeeMap* _tmp30_;
		gboolean _tmp31_ = FALSE;
		_tmp30_ = self->ro_map;
		_tmp31_ = gee_map_unset (_tmp30_, "one", NULL);
		_vala_assert (_tmp31_, "ro_map.unset (\"one\")");
		exit (0);
	}
	g_test_trap_assert_failed ();
	_tmp32_ = self->ro_map;
	_tmp33_ = gee_map_get_size (_tmp32_);
	_tmp34_ = _tmp33_;
	_vala_assert (_tmp34_ == 1, "ro_map.size == 1");
	_tmp35_ = self->ro_map;
	_tmp36_ = gee_map_has_key (_tmp35_, "one");
	_vala_assert (_tmp36_, "ro_map.has_key (\"one\")");
	_tmp37_ = self->ro_map;
	_tmp38_ = gee_map_has (_tmp37_, "one", "one");
	_vala_assert (_tmp38_, "ro_map.has (\"one\", \"one\")");
	_tmp39_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
	if (_tmp39_) {
		GeeMap* _tmp40_;
		GeeMap* _tmp41_;
		_tmp40_ = self->ro_map;
		_tmp41_ = dummy;
		gee_map_set_all (_tmp40_, _tmp41_);
		exit (0);
	}
	g_test_trap_assert_failed ();
	_tmp42_ = self->ro_map;
	_tmp43_ = gee_map_get_size (_tmp42_);
	_tmp44_ = _tmp43_;
	_vala_assert (_tmp44_ == 1, "ro_map.size == 1");
	_tmp45_ = self->ro_map;
	_tmp46_ = gee_map_has_key (_tmp45_, "one");
	_vala_assert (_tmp46_, "ro_map.has_key (\"one\")");
	_tmp47_ = self->ro_map;
	_tmp48_ = gee_map_has (_tmp47_, "one", "one");
	_vala_assert (_tmp48_, "ro_map.has (\"one\", \"one\")");
	_tmp49_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
	if (_tmp49_) {
		GeeMap* _tmp50_;
		GeeMap* _tmp51_;
		gboolean _tmp52_ = FALSE;
		_tmp50_ = self->ro_map;
		_tmp51_ = dummy;
		_tmp52_ = gee_map_unset_all (_tmp50_, _tmp51_);
		_vala_assert (_tmp52_, "ro_map.unset_all (dummy)");
		exit (0);
	}
	g_test_trap_assert_failed ();
	_tmp53_ = self->ro_map;
	_tmp54_ = gee_map_get_size (_tmp53_);
	_tmp55_ = _tmp54_;
	_vala_assert (_tmp55_ == 1, "ro_map.size == 1");
	_tmp56_ = self->ro_map;
	_tmp57_ = gee_map_has_key (_tmp56_, "one");
	_vala_assert (_tmp57_, "ro_map.has_key (\"one\")");
	_tmp58_ = self->ro_map;
	_tmp59_ = gee_map_has (_tmp58_, "one", "one");
	_vala_assert (_tmp59_, "ro_map.has (\"one\", \"one\")");
	_g_object_unref0 (dummy);
}


void read_only_map_tests_test_accurate_view (ReadOnlyMapTests* self) {
	GeeHashMap* _tmp0_;
	GeeMap* dummy;
	GeeMap* _tmp1_;
	gint _tmp2_;
	gint _tmp3_;
	GeeMap* _tmp4_;
	gboolean _tmp5_;
	gboolean _tmp6_;
	GeeMap* _tmp7_;
	gboolean _tmp8_ = FALSE;
	GeeMap* _tmp9_;
	gboolean _tmp10_ = FALSE;
	GeeMap* _tmp11_;
	gpointer _tmp12_ = NULL;
	gchar* _tmp13_;
	GeeMap* _tmp14_;
	GeeMap* _tmp15_;
	gint _tmp16_;
	gint _tmp17_;
	GeeMap* _tmp18_;
	gboolean _tmp19_;
	gboolean _tmp20_;
	GeeMap* _tmp21_;
	gboolean _tmp22_ = FALSE;
	GeeMap* _tmp23_;
	gboolean _tmp24_ = FALSE;
	GeeMap* _tmp25_;
	gpointer _tmp26_ = NULL;
	gchar* _tmp27_;
	GeeMap* _tmp28_;
	GeeMap* _tmp29_;
	gint _tmp30_;
	gint _tmp31_;
	GeeMap* _tmp32_;
	gboolean _tmp33_;
	gboolean _tmp34_;
	GeeMap* _tmp35_;
	gboolean _tmp36_ = FALSE;
	GeeMap* _tmp37_;
	gboolean _tmp38_ = FALSE;
	GeeMap* _tmp39_;
	gpointer _tmp40_ = NULL;
	gchar* _tmp41_;
	GeeMap* _tmp42_;
	gboolean _tmp43_ = FALSE;
	GeeMap* _tmp44_;
	gboolean _tmp45_ = FALSE;
	GeeMap* _tmp46_;
	gpointer _tmp47_ = NULL;
	gchar* _tmp48_;
	GeeMap* _tmp49_;
	gboolean _tmp50_ = FALSE;
	GeeMap* _tmp51_;
	gboolean _tmp52_ = FALSE;
	GeeMap* _tmp53_;
	gint _tmp54_;
	gint _tmp55_;
	GeeMap* _tmp56_;
	gboolean _tmp57_;
	gboolean _tmp58_;
	GeeMap* _tmp59_;
	gboolean _tmp60_ = FALSE;
	GeeMap* _tmp61_;
	gboolean _tmp62_ = FALSE;
	GeeMap* _tmp63_;
	gpointer _tmp64_ = NULL;
	gchar* _tmp65_;
	GeeMap* _tmp66_;
	gboolean _tmp67_ = FALSE;
	GeeMap* _tmp68_;
	gboolean _tmp69_ = FALSE;
	GeeMap* _tmp70_;
	gpointer _tmp71_ = NULL;
	gchar* _tmp72_;
	GeeMap* _tmp73_;
	gboolean _tmp74_ = FALSE;
	GeeMap* _tmp75_;
	GeeMap* _tmp76_;
	gint _tmp77_;
	gint _tmp78_;
	GeeMap* _tmp79_;
	gboolean _tmp80_;
	gboolean _tmp81_;
	GeeMap* _tmp82_;
	gboolean _tmp83_ = FALSE;
	GeeMap* _tmp84_;
	gboolean _tmp85_ = FALSE;
	GeeMap* _tmp86_;
	gpointer _tmp87_ = NULL;
	gchar* _tmp88_;
	GeeMap* _tmp89_;
	gpointer _tmp90_ = NULL;
	gchar* _tmp91_;
	g_return_if_fail (self != NULL);
	_tmp0_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);
	dummy = (GeeMap*) _tmp0_;
	gee_map_set (dummy, "one", "one");
	gee_map_set (dummy, "two", "two");
	_tmp1_ = self->ro_map;
	_tmp2_ = gee_map_get_size (_tmp1_);
	_tmp3_ = _tmp2_;
	_vala_assert (_tmp3_ == 0, "ro_map.size == 0");
	_tmp4_ = self->ro_map;
	_tmp5_ = gee_map_get_is_empty (_tmp4_);
	_tmp6_ = _tmp5_;
	_vala_assert (_tmp6_, "ro_map.is_empty");
	_tmp7_ = self->ro_map;
	_tmp8_ = gee_map_has_key (_tmp7_, "one");
	_vala_assert (!_tmp8_, "! ro_map.has_key (\"one\")");
	_tmp9_ = self->ro_map;
	_tmp10_ = gee_map_has (_tmp9_, "one", "one");
	_vala_assert (!_tmp10_, "! ro_map.has (\"one\", \"one\")");
	_tmp11_ = self->ro_map;
	_tmp12_ = gee_map_get (_tmp11_, "one");
	_tmp13_ = (gchar*) _tmp12_;
	_vala_assert (_tmp13_ == NULL, "ro_map.get (\"one\") == null");
	_g_free0 (_tmp13_);
	_tmp14_ = self->test_map;
	gee_map_set (_tmp14_, "one", "one");
	_tmp15_ = self->ro_map;
	_tmp16_ = gee_map_get_size (_tmp15_);
	_tmp17_ = _tmp16_;
	_vala_assert (_tmp17_ == 1, "ro_map.size == 1");
	_tmp18_ = self->ro_map;
	_tmp19_ = gee_map_get_is_empty (_tmp18_);
	_tmp20_ = _tmp19_;
	_vala_assert (!_tmp20_, "! ro_map.is_empty");
	_tmp21_ = self->ro_map;
	_tmp22_ = gee_map_has_key (_tmp21_, "one");
	_vala_assert (_tmp22_, "ro_map.has_key (\"one\")");
	_tmp23_ = self->ro_map;
	_tmp24_ = gee_map_has (_tmp23_, "one", "one");
	_vala_assert (_tmp24_, "ro_map.has (\"one\", \"one\")");
	_tmp25_ = self->ro_map;
	_tmp26_ = gee_map_get (_tmp25_, "one");
	_tmp27_ = (gchar*) _tmp26_;
	_vala_assert (g_strcmp0 (_tmp27_, "one") == 0, "ro_map.get (\"one\") == \"one\"");
	_g_free0 (_tmp27_);
	_tmp28_ = self->test_map;
	gee_map_set (_tmp28_, "two", "two");
	_tmp29_ = self->ro_map;
	_tmp30_ = gee_map_get_size (_tmp29_);
	_tmp31_ = _tmp30_;
	_vala_assert (_tmp31_ == 2, "ro_map.size == 2");
	_tmp32_ = self->ro_map;
	_tmp33_ = gee_map_get_is_empty (_tmp32_);
	_tmp34_ = _tmp33_;
	_vala_assert (!_tmp34_, "! ro_map.is_empty");
	_tmp35_ = self->ro_map;
	_tmp36_ = gee_map_has_key (_tmp35_, "one");
	_vala_assert (_tmp36_, "ro_map.has_key (\"one\")");
	_tmp37_ = self->ro_map;
	_tmp38_ = gee_map_has (_tmp37_, "one", "one");
	_vala_assert (_tmp38_, "ro_map.has (\"one\", \"one\")");
	_tmp39_ = self->ro_map;
	_tmp40_ = gee_map_get (_tmp39_, "one");
	_tmp41_ = (gchar*) _tmp40_;
	_vala_assert (g_strcmp0 (_tmp41_, "one") == 0, "ro_map.get (\"one\") == \"one\"");
	_g_free0 (_tmp41_);
	_tmp42_ = self->ro_map;
	_tmp43_ = gee_map_has_key (_tmp42_, "two");
	_vala_assert (_tmp43_, "ro_map.has_key (\"two\")");
	_tmp44_ = self->ro_map;
	_tmp45_ = gee_map_has (_tmp44_, "two", "two");
	_vala_assert (_tmp45_, "ro_map.has (\"two\", \"two\")");
	_tmp46_ = self->ro_map;
	_tmp47_ = gee_map_get (_tmp46_, "two");
	_tmp48_ = (gchar*) _tmp47_;
	_vala_assert (g_strcmp0 (_tmp48_, "two") == 0, "ro_map.get (\"two\") == \"two\"");
	_g_free0 (_tmp48_);
	_tmp49_ = self->ro_map;
	_tmp50_ = gee_map_has_all (_tmp49_, dummy);
	_vala_assert (_tmp50_, "ro_map.has_all (dummy)");
	_tmp51_ = self->test_map;
	_tmp52_ = gee_map_unset (_tmp51_, "one", NULL);
	_vala_assert (_tmp52_, "test_map.unset (\"one\")");
	_tmp53_ = self->ro_map;
	_tmp54_ = gee_map_get_size (_tmp53_);
	_tmp55_ = _tmp54_;
	_vala_assert (_tmp55_ == 1, "ro_map.size == 1");
	_tmp56_ = self->ro_map;
	_tmp57_ = gee_map_get_is_empty (_tmp56_);
	_tmp58_ = _tmp57_;
	_vala_assert (!_tmp58_, "! ro_map.is_empty");
	_tmp59_ = self->ro_map;
	_tmp60_ = gee_map_has_key (_tmp59_, "one");
	_vala_assert (!_tmp60_, "! ro_map.has_key (\"one\")");
	_tmp61_ = self->ro_map;
	_tmp62_ = gee_map_has (_tmp61_, "one", "one");
	_vala_assert (!_tmp62_, "! ro_map.has (\"one\", \"one\")");
	_tmp63_ = self->ro_map;
	_tmp64_ = gee_map_get (_tmp63_, "one");
	_tmp65_ = (gchar*) _tmp64_;
	_vala_assert (_tmp65_ == NULL, "ro_map.get (\"one\") == null");
	_g_free0 (_tmp65_);
	_tmp66_ = self->ro_map;
	_tmp67_ = gee_map_has_key (_tmp66_, "two");
	_vala_assert (_tmp67_, "ro_map.has_key (\"two\")");
	_tmp68_ = self->ro_map;
	_tmp69_ = gee_map_has (_tmp68_, "two", "two");
	_vala_assert (_tmp69_, "ro_map.has (\"two\", \"two\")");
	_tmp70_ = self->ro_map;
	_tmp71_ = gee_map_get (_tmp70_, "two");
	_tmp72_ = (gchar*) _tmp71_;
	_vala_assert (g_strcmp0 (_tmp72_, "two") == 0, "ro_map.get (\"two\") == \"two\"");
	_g_free0 (_tmp72_);
	_tmp73_ = self->ro_map;
	_tmp74_ = gee_map_has_all (_tmp73_, dummy);
	_vala_assert (!_tmp74_, "! ro_map.has_all (dummy)");
	_tmp75_ = self->test_map;
	gee_map_clear (_tmp75_);
	_tmp76_ = self->ro_map;
	_tmp77_ = gee_map_get_size (_tmp76_);
	_tmp78_ = _tmp77_;
	_vala_assert (_tmp78_ == 0, "ro_map.size == 0");
	_tmp79_ = self->ro_map;
	_tmp80_ = gee_map_get_is_empty (_tmp79_);
	_tmp81_ = _tmp80_;
	_vala_assert (_tmp81_, "ro_map.is_empty");
	_tmp82_ = self->ro_map;
	_tmp83_ = gee_map_has (_tmp82_, "one", "one");
	_vala_assert (!_tmp83_, "! ro_map.has (\"one\", \"one\")");
	_tmp84_ = self->ro_map;
	_tmp85_ = gee_map_has (_tmp84_, "two", "two");
	_vala_assert (!_tmp85_, "! ro_map.has (\"two\", \"two\")");
	_tmp86_ = self->ro_map;
	_tmp87_ = gee_map_get (_tmp86_, "one");
	_tmp88_ = (gchar*) _tmp87_;
	_vala_assert (_tmp88_ == NULL, "ro_map.get (\"one\") == null");
	_g_free0 (_tmp88_);
	_tmp89_ = self->ro_map;
	_tmp90_ = gee_map_get (_tmp89_, "two");
	_tmp91_ = (gchar*) _tmp90_;
	_vala_assert (_tmp91_ == NULL, "ro_map.get (\"two\") == null");
	_g_free0 (_tmp91_);
	_g_object_unref0 (dummy);
}


static void read_only_map_tests_class_init (ReadOnlyMapTestsClass * klass) {
	read_only_map_tests_parent_class = g_type_class_peek_parent (klass);
	GEE_TEST_CASE_CLASS (klass)->set_up = read_only_map_tests_real_set_up;
	GEE_TEST_CASE_CLASS (klass)->tear_down = read_only_map_tests_real_tear_down;
	G_OBJECT_CLASS (klass)->finalize = read_only_map_tests_finalize;
}


static void read_only_map_tests_instance_init (ReadOnlyMapTests * self) {
}


static void read_only_map_tests_finalize (GObject* obj) {
	ReadOnlyMapTests * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_READ_ONLY_MAP_TESTS, ReadOnlyMapTests);
	_g_object_unref0 (self->test_map);
	_g_object_unref0 (self->ro_map);
	G_OBJECT_CLASS (read_only_map_tests_parent_class)->finalize (obj);
}


GType read_only_map_tests_get_type (void) {
	static volatile gsize read_only_map_tests_type_id__volatile = 0;
	if (g_once_init_enter (&read_only_map_tests_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ReadOnlyMapTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) read_only_map_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ReadOnlyMapTests), 0, (GInstanceInitFunc) read_only_map_tests_instance_init, NULL };
		GType read_only_map_tests_type_id;
		read_only_map_tests_type_id = g_type_register_static (GEE_TYPE_TEST_CASE, "ReadOnlyMapTests", &g_define_type_info, 0);
		g_once_init_leave (&read_only_map_tests_type_id__volatile, read_only_map_tests_type_id);
	}
	return read_only_map_tests_type_id__volatile;
}