tests/testlist.c

   1 /* testlist.c generated by valac 0.18.0, the Vala compiler
   2  * generated from testlist.vala, do not modify */
   3
   4 /* testlist.vala
   5  *
   6  * Copyright (C) 2008  Jürg Billeter
   7  * Copyright (C) 2009  Didier Villevalois, Julien Peeters
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  22  *
  23  * Author:
  24  *      Jürg Billeter <j@bitron.ch>
  25  *      Didier 'Ptitjes' Villevalois <ptitjes@free.fr>
  26  *      Julien Peeters <contact@julienpeeters.fr>
  27  */
  28
  29 #include <glib.h>
  30 #include <glib-object.h>
  31 #include <gee.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35
  36 #define GEE_TYPE_TEST_CASE (gee_test_case_get_type ())
  37 #define GEE_TEST_CASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TEST_CASE, GeeTestCase))
  38 #define GEE_TEST_CASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_TEST_CASE, GeeTestCaseClass))
  39 #define GEE_IS_TEST_CASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TEST_CASE))
  40 #define GEE_IS_TEST_CASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_TEST_CASE))
  41 #define GEE_TEST_CASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_TEST_CASE, GeeTestCaseClass))
  42
  43 typedef struct _GeeTestCase GeeTestCase;
  44 typedef struct _GeeTestCaseClass GeeTestCaseClass;
  45 typedef struct _GeeTestCasePrivate GeeTestCasePrivate;
  46
  47 #define TYPE_COLLECTION_TESTS (collection_tests_get_type ())
  48 #define COLLECTION_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_COLLECTION_TESTS, CollectionTests))
  49 #define COLLECTION_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_COLLECTION_TESTS, CollectionTestsClass))
  50 #define IS_COLLECTION_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_COLLECTION_TESTS))
  51 #define IS_COLLECTION_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_COLLECTION_TESTS))
  52 #define COLLECTION_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_COLLECTION_TESTS, CollectionTestsClass))
  53
  54 typedef struct _CollectionTests CollectionTests;
  55 typedef struct _CollectionTestsClass CollectionTestsClass;
  56 typedef struct _CollectionTestsPrivate CollectionTestsPrivate;
  57
  58 #define TYPE_LIST_TESTS (list_tests_get_type ())
  59 #define LIST_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_LIST_TESTS, ListTests))
  60 #define LIST_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_LIST_TESTS, ListTestsClass))
  61 #define IS_LIST_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_LIST_TESTS))
  62 #define IS_LIST_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_LIST_TESTS))
  63 #define LIST_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_LIST_TESTS, ListTestsClass))
  64
  65 typedef struct _ListTests ListTests;
  66 typedef struct _ListTestsClass ListTestsClass;
  67 typedef struct _ListTestsPrivate ListTestsPrivate;
  68 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  69 #define _g_free0(var) (var = (g_free (var), NULL))
  70 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
  71
  72 struct _GeeTestCase {
  73         GObject parent_instance;
  74         GeeTestCasePrivate * priv;
  75 };
  76
  77 struct _GeeTestCaseClass {
  78         GObjectClass parent_class;
  79         void (*set_up) (GeeTestCase* self);
  80         void (*tear_down) (GeeTestCase* self);
  81 };
  82
  83 struct _CollectionTests {
  84         GeeTestCase parent_instance;
  85         CollectionTestsPrivate * priv;
  86         GeeCollection* test_collection;
  87 };
  88
  89 struct _CollectionTestsClass {
  90         GeeTestCaseClass parent_class;
  91 };
  92
  93 struct _ListTests {
  94         CollectionTests parent_instance;
  95         ListTestsPrivate * priv;
  96 };
  97
  98 struct _ListTestsClass {
  99         CollectionTestsClass parent_class;
 100         void (*test_duplicates_are_retained) (ListTests* self);
 101 };
 102
 103 typedef void (*GeeTestCaseTestMethod) (void* user_data);
 104
 105 static gpointer list_tests_parent_class = NULL;
 106
 107 GType gee_test_case_get_type (void) G_GNUC_CONST;
 108 GType collection_tests_get_type (void) G_GNUC_CONST;
 109 GType list_tests_get_type (void) G_GNUC_CONST;
 110 enum  {
 111         LIST_TESTS_DUMMY_PROPERTY
 112 };
 113 ListTests* list_tests_construct (GType object_type, const gchar* name);
 114 CollectionTests* collection_tests_construct (GType object_type, const gchar* name);
 115 void gee_test_case_add_test (GeeTestCase* self, const gchar* name, GeeTestCaseTestMethod test, void* test_target, GDestroyNotify test_target_destroy_notify);
 116 void list_tests_test_iterator_is_ordered (ListTests* self);
 117 static void _list_tests_test_iterator_is_ordered_gee_test_case_test_method (gpointer self);
 118 void list_tests_test_list_iterator (ListTests* self);
 119 static void _list_tests_test_list_iterator_gee_test_case_test_method (gpointer self);
 120 void list_tests_test_duplicates_are_retained (ListTests* self);
 121 static void _list_tests_test_duplicates_are_retained_gee_test_case_test_method (gpointer self);
 122 void list_tests_test_get (ListTests* self);
 123 static void _list_tests_test_get_gee_test_case_test_method (gpointer self);
 124 void list_tests_test_set (ListTests* self);
 125 static void _list_tests_test_set_gee_test_case_test_method (gpointer self);
 126 void list_tests_test_insert (ListTests* self);
 127 static void _list_tests_test_insert_gee_test_case_test_method (gpointer self);
 128 void list_tests_test_remove_at (ListTests* self);
 129 static void _list_tests_test_remove_at_gee_test_case_test_method (gpointer self);
 130 void list_tests_test_index_of (ListTests* self);
 131 static void _list_tests_test_index_of_gee_test_case_test_method (gpointer self);
 132 void list_tests_test_first (ListTests* self);
 133 static void _list_tests_test_first_gee_test_case_test_method (gpointer self);
 134 void list_tests_test_last (ListTests* self);
 135 static void _list_tests_test_last_gee_test_case_test_method (gpointer self);
 136 void list_tests_test_insert_all (ListTests* self);
 137 static void _list_tests_test_insert_all_gee_test_case_test_method (gpointer self);
 138 void list_tests_test_slice (ListTests* self);
 139 static void _list_tests_test_slice_gee_test_case_test_method (gpointer self);
 140 static void list_tests_real_test_duplicates_are_retained (ListTests* self);
 141
 142
 143 static void _list_tests_test_iterator_is_ordered_gee_test_case_test_method (gpointer self) {
 144         list_tests_test_iterator_is_ordered (self);
 145 }
 146
 147
 148 static void _list_tests_test_list_iterator_gee_test_case_test_method (gpointer self) {
 149         list_tests_test_list_iterator (self);
 150 }
 151
 152
 153 static void _list_tests_test_duplicates_are_retained_gee_test_case_test_method (gpointer self) {
 154         list_tests_test_duplicates_are_retained (self);
 155 }
 156
 157
 158 static void _list_tests_test_get_gee_test_case_test_method (gpointer self) {
 159         list_tests_test_get (self);
 160 }
 161
 162
 163 static void _list_tests_test_set_gee_test_case_test_method (gpointer self) {
 164         list_tests_test_set (self);
 165 }
 166
 167
 168 static void _list_tests_test_insert_gee_test_case_test_method (gpointer self) {
 169         list_tests_test_insert (self);
 170 }
 171
 172
 173 static void _list_tests_test_remove_at_gee_test_case_test_method (gpointer self) {
 174         list_tests_test_remove_at (self);
 175 }
 176
 177
 178 static void _list_tests_test_index_of_gee_test_case_test_method (gpointer self) {
 179         list_tests_test_index_of (self);
 180 }
 181
 182
 183 static void _list_tests_test_first_gee_test_case_test_method (gpointer self) {
 184         list_tests_test_first (self);
 185 }
 186
 187
 188 static void _list_tests_test_last_gee_test_case_test_method (gpointer self) {
 189         list_tests_test_last (self);
 190 }
 191
 192
 193 static void _list_tests_test_insert_all_gee_test_case_test_method (gpointer self) {
 194         list_tests_test_insert_all (self);
 195 }
 196
 197
 198 static void _list_tests_test_slice_gee_test_case_test_method (gpointer self) {
 199         list_tests_test_slice (self);
 200 }
 201
 202
 203 ListTests* list_tests_construct (GType object_type, const gchar* name) {
 204         ListTests * self = NULL;
 205         const gchar* _tmp0_;
 206         g_return_val_if_fail (name != NULL, NULL);
 207         _tmp0_ = name;
 208         self = (ListTests*) collection_tests_construct (object_type, _tmp0_);
 209         gee_test_case_add_test ((GeeTestCase*) self, "[List] iterator is ordered", _list_tests_test_iterator_is_ordered_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 210         gee_test_case_add_test ((GeeTestCase*) self, "[List] list iterator", _list_tests_test_list_iterator_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 211         gee_test_case_add_test ((GeeTestCase*) self, "[List] duplicates are retained", _list_tests_test_duplicates_are_retained_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 212         gee_test_case_add_test ((GeeTestCase*) self, "[List] get", _list_tests_test_get_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 213         gee_test_case_add_test ((GeeTestCase*) self, "[List] set", _list_tests_test_set_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 214         gee_test_case_add_test ((GeeTestCase*) self, "[List] insert", _list_tests_test_insert_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 215         gee_test_case_add_test ((GeeTestCase*) self, "[List] remove_at", _list_tests_test_remove_at_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 216         gee_test_case_add_test ((GeeTestCase*) self, "[List] index_of", _list_tests_test_index_of_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 217         gee_test_case_add_test ((GeeTestCase*) self, "[List] first", _list_tests_test_first_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 218         gee_test_case_add_test ((GeeTestCase*) self, "[List] last", _list_tests_test_last_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 219         gee_test_case_add_test ((GeeTestCase*) self, "[List] insert_all", _list_tests_test_insert_all_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 220         gee_test_case_add_test ((GeeTestCase*) self, "[List] slice", _list_tests_test_slice_gee_test_case_test_method, g_object_ref (self), g_object_unref);
 221         return self;
 222 }
 223
 224
 225 static gpointer _g_object_ref0 (gpointer self) {
 226         return self ? g_object_ref (self) : NULL;
 227 }
 228
 229
 230 void list_tests_test_iterator_is_ordered (ListTests* self) {
 231         GeeCollection* _tmp0_;
 232         GeeList* _tmp1_;
 233         GeeList* test_list;
 234         GeeIterator* _tmp2_ = NULL;
 235         GeeIterator* iterator;
 236         GeeIterator* _tmp3_;
 237         gboolean _tmp4_ = FALSE;
 238         gboolean _tmp5_ = FALSE;
 239         gboolean _tmp6_ = FALSE;
 240         gboolean _tmp7_ = FALSE;
 241         gboolean _tmp8_ = FALSE;
 242         GeeIterator* _tmp9_ = NULL;
 243         GeeIterator* _tmp10_;
 244         gboolean _tmp11_ = FALSE;
 245         GeeIterator* _tmp12_;
 246         gpointer _tmp13_ = NULL;
 247         gchar* _tmp14_;
 248         GeeIterator* _tmp15_;
 249         gboolean _tmp16_ = FALSE;
 250         GeeIterator* _tmp17_;
 251         gpointer _tmp18_ = NULL;
 252         gchar* _tmp19_;
 253         GeeIterator* _tmp20_;
 254         gboolean _tmp21_ = FALSE;
 255         GeeIterator* _tmp22_;
 256         gpointer _tmp23_ = NULL;
 257         gchar* _tmp24_;
 258         GeeIterator* _tmp25_;
 259         gboolean _tmp26_ = FALSE;
 260         GeeIterator* _tmp27_;
 261         gpointer _tmp28_ = NULL;
 262         gchar* _tmp29_;
 263         GeeIterator* _tmp30_;
 264         gboolean _tmp31_ = FALSE;
 265         g_return_if_fail (self != NULL);
 266         _tmp0_ = ((CollectionTests*) self)->test_collection;
 267         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
 268         test_list = _tmp1_;
 269         _vala_assert (test_list != NULL, "test_list != null");
 270         _tmp2_ = gee_iterable_iterator ((GeeIterable*) test_list);
 271         iterator = _tmp2_;
 272         _tmp3_ = iterator;
 273         _tmp4_ = gee_iterator_next (_tmp3_);
 274         _vala_assert (!_tmp4_, "! iterator.next ()");
 275         _tmp5_ = gee_collection_add ((GeeCollection*) test_list, "one");
 276         _vala_assert (_tmp5_, "test_list.add (\"one\")");
 277         _tmp6_ = gee_collection_add ((GeeCollection*) test_list, "two");
 278         _vala_assert (_tmp6_, "test_list.add (\"two\")");
 279         _tmp7_ = gee_collection_add ((GeeCollection*) test_list, "three");
 280         _vala_assert (_tmp7_, "test_list.add (\"three\")");
 281         _tmp8_ = gee_collection_add ((GeeCollection*) test_list, "one");
 282         _vala_assert (_tmp8_, "test_list.add (\"one\")");
 283         _tmp9_ = gee_iterable_iterator ((GeeIterable*) test_list);
 284         _g_object_unref0 (iterator);
 285         iterator = _tmp9_;
 286         _tmp10_ = iterator;
 287         _tmp11_ = gee_iterator_next (_tmp10_);
 288         _vala_assert (_tmp11_, "iterator.next()");
 289         _tmp12_ = iterator;
 290         _tmp13_ = gee_iterator_get (_tmp12_);
 291         _tmp14_ = (gchar*) _tmp13_;
 292         _vala_assert (g_strcmp0 (_tmp14_, "one") == 0, "iterator.get () == \"one\"");
 293         _g_free0 (_tmp14_);
 294         _tmp15_ = iterator;
 295         _tmp16_ = gee_iterator_next (_tmp15_);
 296         _vala_assert (_tmp16_, "iterator.next()");
 297         _tmp17_ = iterator;
 298         _tmp18_ = gee_iterator_get (_tmp17_);
 299         _tmp19_ = (gchar*) _tmp18_;
 300         _vala_assert (g_strcmp0 (_tmp19_, "two") == 0, "iterator.get () == \"two\"");
 301         _g_free0 (_tmp19_);
 302         _tmp20_ = iterator;
 303         _tmp21_ = gee_iterator_next (_tmp20_);
 304         _vala_assert (_tmp21_, "iterator.next()");
 305         _tmp22_ = iterator;
 306         _tmp23_ = gee_iterator_get (_tmp22_);
 307         _tmp24_ = (gchar*) _tmp23_;
 308         _vala_assert (g_strcmp0 (_tmp24_, "three") == 0, "iterator.get () == \"three\"");
 309         _g_free0 (_tmp24_);
 310         _tmp25_ = iterator;
 311         _tmp26_ = gee_iterator_next (_tmp25_);
 312         _vala_assert (_tmp26_, "iterator.next()");
 313         _tmp27_ = iterator;
 314         _tmp28_ = gee_iterator_get (_tmp27_);
 315         _tmp29_ = (gchar*) _tmp28_;
 316         _vala_assert (g_strcmp0 (_tmp29_, "one") == 0, "iterator.get () == \"one\"");
 317         _g_free0 (_tmp29_);
 318         _tmp30_ = iterator;
 319         _tmp31_ = gee_iterator_next (_tmp30_);
 320         _vala_assert (!_tmp31_, "! iterator.next ()");
 321         _g_object_unref0 (iterator);
 322         _g_object_unref0 (test_list);
 323 }
 324
 325
 326 void list_tests_test_list_iterator (ListTests* self) {
 327         GeeCollection* _tmp0_;
 328         GeeList* _tmp1_;
 329         GeeList* test_list;
 330         GeeListIterator* _tmp2_ = NULL;
 331         GeeListIterator* iterator;
 332         GeeListIterator* _tmp3_;
 333         gboolean _tmp4_ = FALSE;
 334         GeeListIterator* _tmp5_;
 335         gboolean _tmp6_ = FALSE;
 336         gboolean _tmp7_ = FALSE;
 337         gboolean _tmp8_ = FALSE;
 338         gboolean _tmp9_ = FALSE;
 339         GeeListIterator* _tmp10_ = NULL;
 340         GeeListIterator* _tmp11_;
 341         gboolean _tmp12_ = FALSE;
 342         GeeListIterator* _tmp13_;
 343         gpointer _tmp14_ = NULL;
 344         gchar* _tmp15_;
 345         GeeListIterator* _tmp16_;
 346         gint _tmp17_ = 0;
 347         GeeListIterator* _tmp18_;
 348         GeeListIterator* _tmp19_;
 349         gboolean _tmp20_ = FALSE;
 350         GeeListIterator* _tmp21_;
 351         gpointer _tmp22_ = NULL;
 352         gchar* _tmp23_;
 353         GeeListIterator* _tmp24_;
 354         gint _tmp25_ = 0;
 355         GeeListIterator* _tmp26_;
 356         gint _tmp27_;
 357         gint _tmp28_;
 358         GeeListIterator* _tmp29_;
 359         gint _tmp30_ = 0;
 360         GeeListIterator* _tmp31_;
 361         gint _tmp32_;
 362         gint _tmp33_;
 363         GeeListIterator* _tmp34_;
 364         gint _tmp35_ = 0;
 365         GeeListIterator* _tmp36_;
 366         gboolean _tmp37_ = FALSE;
 367         GeeListIterator* _tmp38_;
 368         gpointer _tmp39_ = NULL;
 369         gchar* _tmp40_;
 370         GeeListIterator* _tmp41_;
 371         gint _tmp42_ = 0;
 372         GeeListIterator* _tmp43_;
 373         GeeListIterator* _tmp44_;
 374         gboolean _tmp45_ = FALSE;
 375         GeeListIterator* _tmp46_;
 376         gboolean _tmp47_ = FALSE;
 377         GeeListIterator* _tmp48_ = NULL;
 378         GeeListIterator* _tmp49_;
 379         gboolean _tmp50_ = FALSE;
 380         GeeListIterator* _tmp51_;
 381         gpointer _tmp52_ = NULL;
 382         gchar* _tmp53_;
 383         GeeListIterator* _tmp54_;
 384         gint _tmp55_ = 0;
 385         g_return_if_fail (self != NULL);
 386         _tmp0_ = ((CollectionTests*) self)->test_collection;
 387         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
 388         test_list = _tmp1_;
 389         _vala_assert (test_list != NULL, "test_list != null");
 390         _tmp2_ = gee_list_list_iterator (test_list);
 391         iterator = _tmp2_;
 392         _tmp3_ = iterator;
 393         _tmp4_ = gee_iterator_has_next ((GeeIterator*) _tmp3_);
 394         _vala_assert (!_tmp4_, "! iterator.has_next ()");
 395         _tmp5_ = iterator;
 396         _tmp6_ = gee_iterator_next ((GeeIterator*) _tmp5_);
 397         _vala_assert (!_tmp6_, "! iterator.next ()");
 398         _tmp7_ = gee_collection_add ((GeeCollection*) test_list, "one");
 399         _vala_assert (_tmp7_, "test_list.add (\"one\")");
 400         _tmp8_ = gee_collection_add ((GeeCollection*) test_list, "two");
 401         _vala_assert (_tmp8_, "test_list.add (\"two\")");
 402         _tmp9_ = gee_collection_add ((GeeCollection*) test_list, "three");
 403         _vala_assert (_tmp9_, "test_list.add (\"three\")");
 404         _tmp10_ = gee_list_list_iterator (test_list);
 405         _g_object_unref0 (iterator);
 406         iterator = _tmp10_;
 407         _tmp11_ = iterator;
 408         _tmp12_ = gee_iterator_next ((GeeIterator*) _tmp11_);
 409         _vala_assert (_tmp12_, "iterator.next()");
 410         _tmp13_ = iterator;
 411         _tmp14_ = gee_iterator_get ((GeeIterator*) _tmp13_);
 412         _tmp15_ = (gchar*) _tmp14_;
 413         _vala_assert (g_strcmp0 (_tmp15_, "one") == 0, "iterator.get () == \"one\"");
 414         _g_free0 (_tmp15_);
 415         _tmp16_ = iterator;
 416         _tmp17_ = gee_list_iterator_index (_tmp16_);
 417         _vala_assert (_tmp17_ == 0, "iterator.index () == 0");
 418         _tmp18_ = iterator;
 419         gee_list_iterator_set (_tmp18_, "new one");
 420         _tmp19_ = iterator;
 421         _tmp20_ = gee_iterator_next ((GeeIterator*) _tmp19_);
 422         _vala_assert (_tmp20_, "iterator.next()");
 423         _tmp21_ = iterator;
 424         _tmp22_ = gee_iterator_get ((GeeIterator*) _tmp21_);
 425         _tmp23_ = (gchar*) _tmp22_;
 426         _vala_assert (g_strcmp0 (_tmp23_, "two") == 0, "iterator.get () == \"two\"");
 427         _g_free0 (_tmp23_);
 428         _tmp24_ = iterator;
 429         _tmp25_ = gee_list_iterator_index (_tmp24_);
 430         _vala_assert (_tmp25_ == 1, "iterator.index () == 1");
 431         _tmp26_ = iterator;
 432         gee_list_iterator_set (_tmp26_, "new two");
 433         _tmp27_ = gee_collection_get_size ((GeeCollection*) test_list);
 434         _tmp28_ = _tmp27_;
 435         _vala_assert (_tmp28_ == 3, "test_list.size == 3");
 436         _tmp29_ = iterator;
 437         _tmp30_ = gee_list_iterator_index (_tmp29_);
 438         _vala_assert (_tmp30_ == 1, "iterator.index () == 1");
 439         _tmp31_ = iterator;
 440         gee_list_iterator_add (_tmp31_, "after two");
 441         _tmp32_ = gee_collection_get_size ((GeeCollection*) test_list);
 442         _tmp33_ = _tmp32_;
 443         _vala_assert (_tmp33_ == 4, "test_list.size == 4");
 444         _tmp34_ = iterator;
 445         _tmp35_ = gee_list_iterator_index (_tmp34_);
 446         _vala_assert (_tmp35_ == 2, "iterator.index () == 2");
 447         _tmp36_ = iterator;
 448         _tmp37_ = gee_iterator_next ((GeeIterator*) _tmp36_);
 449         _vala_assert (_tmp37_, "iterator.next()");
 450         _tmp38_ = iterator;
 451         _tmp39_ = gee_iterator_get ((GeeIterator*) _tmp38_);
 452         _tmp40_ = (gchar*) _tmp39_;
 453         _vala_assert (g_strcmp0 (_tmp40_, "three") == 0, "iterator.get () == \"three\"");
 454         _g_free0 (_tmp40_);
 455         _tmp41_ = iterator;
 456         _tmp42_ = gee_list_iterator_index (_tmp41_);
 457         _vala_assert (_tmp42_ == 3, "iterator.index () == 3");
 458         _tmp43_ = iterator;
 459         gee_list_iterator_set (_tmp43_, "new three");
 460         _tmp44_ = iterator;
 461         _tmp45_ = gee_iterator_has_next ((GeeIterator*) _tmp44_);
 462         _vala_assert (!_tmp45_, "! iterator.has_next ()");
 463         _tmp46_ = iterator;
 464         _tmp47_ = gee_iterator_next ((GeeIterator*) _tmp46_);
 465         _vala_assert (!_tmp47_, "! iterator.next ()");
 466         _tmp48_ = gee_list_list_iterator (test_list);
 467         _g_object_unref0 (iterator);
 468         iterator = _tmp48_;
 469         _tmp49_ = iterator;
 470         _tmp50_ = gee_iterator_next ((GeeIterator*) _tmp49_);
 471         _vala_assert (_tmp50_, "iterator.next ()");
 472         _tmp51_ = iterator;
 473         _tmp52_ = gee_iterator_get ((GeeIterator*) _tmp51_);
 474         _tmp53_ = (gchar*) _tmp52_;
 475         _vala_assert (g_strcmp0 (_tmp53_, "new one") == 0, "iterator.get () == \"new one\"");
 476         _g_free0 (_tmp53_);
 477         _tmp54_ = iterator;
 478         _tmp55_ = gee_list_iterator_index (_tmp54_);
 479         _vala_assert (_tmp55_ == 0, "iterator.index () == 0");
 480         _g_object_unref0 (iterator);
 481         _g_object_unref0 (test_list);
 482 }
 483
 484
 485 static void list_tests_real_test_duplicates_are_retained (ListTests* self) {
 486         GeeCollection* _tmp0_;
 487         GeeList* _tmp1_;
 488         GeeList* test_list;
 489         gboolean _tmp2_ = FALSE;
 490         gboolean _tmp3_ = FALSE;
 491         gint _tmp4_;
 492         gint _tmp5_;
 493         gboolean _tmp6_ = FALSE;
 494         gboolean _tmp7_ = FALSE;
 495         gint _tmp8_;
 496         gint _tmp9_;
 497         gboolean _tmp10_ = FALSE;
 498         gboolean _tmp11_ = FALSE;
 499         gint _tmp12_;
 500         gint _tmp13_;
 501         gboolean _tmp14_ = FALSE;
 502         gboolean _tmp15_ = FALSE;
 503         gint _tmp16_;
 504         gint _tmp17_;
 505         gboolean _tmp18_ = FALSE;
 506         gboolean _tmp19_ = FALSE;
 507         gint _tmp20_;
 508         gint _tmp21_;
 509         gboolean _tmp22_ = FALSE;
 510         gboolean _tmp23_ = FALSE;
 511         gint _tmp24_;
 512         gint _tmp25_;
 513         _tmp0_ = ((CollectionTests*) self)->test_collection;
 514         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
 515         test_list = _tmp1_;
 516         _vala_assert (test_list != NULL, "test_list != null");
 517         _tmp2_ = gee_collection_add ((GeeCollection*) test_list, "one");
 518         _vala_assert (_tmp2_, "test_list.add (\"one\")");
 519         _tmp3_ = gee_collection_contains ((GeeCollection*) test_list, "one");
 520         _vala_assert (_tmp3_, "test_list.contains (\"one\")");
 521         _tmp4_ = gee_collection_get_size ((GeeCollection*) test_list);
 522         _tmp5_ = _tmp4_;
 523         _vala_assert (_tmp5_ == 1, "test_list.size == 1");
 524         _tmp6_ = gee_collection_add ((GeeCollection*) test_list, "one");
 525         _vala_assert (_tmp6_, "test_list.add (\"one\")");
 526         _tmp7_ = gee_collection_contains ((GeeCollection*) test_list, "one");
 527         _vala_assert (_tmp7_, "test_list.contains (\"one\")");
 528         _tmp8_ = gee_collection_get_size ((GeeCollection*) test_list);
 529         _tmp9_ = _tmp8_;
 530         _vala_assert (_tmp9_ == 2, "test_list.size == 2");
 531         _tmp10_ = gee_collection_add ((GeeCollection*) test_list, "one");
 532         _vala_assert (_tmp10_, "test_list.add (\"one\")");
 533         _tmp11_ = gee_collection_contains ((GeeCollection*) test_list, "one");
 534         _vala_assert (_tmp11_, "test_list.contains (\"one\")");
 535         _tmp12_ = gee_collection_get_size ((GeeCollection*) test_list);
 536         _tmp13_ = _tmp12_;
 537         _vala_assert (_tmp13_ == 3, "test_list.size == 3");
 538         _tmp14_ = gee_collection_remove ((GeeCollection*) test_list, "one");
 539         _vala_assert (_tmp14_, "test_list.remove (\"one\")");
 540         _tmp15_ = gee_collection_contains ((GeeCollection*) test_list, "one");
 541         _vala_assert (_tmp15_, "test_list.contains (\"one\")");
 542         _tmp16_ = gee_collection_get_size ((GeeCollection*) test_list);
 543         _tmp17_ = _tmp16_;
 544         _vala_assert (_tmp17_ == 2, "test_list.size == 2");
 545         _tmp18_ = gee_collection_remove ((GeeCollection*) test_list, "one");
 546         _vala_assert (_tmp18_, "test_list.remove (\"one\")");
 547         _tmp19_ = gee_collection_contains ((GeeCollection*) test_list, "one");
 548         _vala_assert (_tmp19_, "test_list.contains (\"one\")");
 549         _tmp20_ = gee_collection_get_size ((GeeCollection*) test_list);
 550         _tmp21_ = _tmp20_;
 551         _vala_assert (_tmp21_ == 1, "test_list.size == 1");
 552         _tmp22_ = gee_collection_remove ((GeeCollection*) test_list, "one");
 553         _vala_assert (_tmp22_, "test_list.remove (\"one\")");
 554         _tmp23_ = gee_collection_contains ((GeeCollection*) test_list, "one");
 555         _vala_assert (!_tmp23_, "!test_list.contains (\"one\")");
 556         _tmp24_ = gee_collection_get_size ((GeeCollection*) test_list);
 557         _tmp25_ = _tmp24_;
 558         _vala_assert (_tmp25_ == 0, "test_list.size == 0");
 559         _g_object_unref0 (test_list);
 560 }
 561
 562
 563 void list_tests_test_duplicates_are_retained (ListTests* self) {
 564         g_return_if_fail (self != NULL);
 565         LIST_TESTS_GET_CLASS (self)->test_duplicates_are_retained (self);
 566 }
 567
 568
 569 void list_tests_test_get (ListTests* self) {
 570         GeeCollection* _tmp0_;
 571         GeeList* _tmp1_;
 572         GeeList* test_list;
 573         GeeList* _tmp2_;
 574         gboolean _tmp3_ = FALSE;
 575         GeeList* _tmp7_;
 576         gboolean _tmp8_ = FALSE;
 577         GeeList* _tmp9_;
 578         gpointer _tmp10_ = NULL;
 579         gchar* _tmp11_;
 580         gboolean _tmp12_ = FALSE;
 581         gboolean _tmp16_ = FALSE;
 582         GeeList* _tmp20_;
 583         gboolean _tmp21_ = FALSE;
 584         GeeList* _tmp22_;
 585         gboolean _tmp23_ = FALSE;
 586         GeeList* _tmp24_;
 587         gpointer _tmp25_ = NULL;
 588         gchar* _tmp26_;
 589         GeeList* _tmp27_;
 590         gpointer _tmp28_ = NULL;
 591         gchar* _tmp29_;
 592         GeeList* _tmp30_;
 593         gpointer _tmp31_ = NULL;
 594         gchar* _tmp32_;
 595         GeeList* _tmp33_;
 596         gboolean _tmp34_ = FALSE;
 597         g_return_if_fail (self != NULL);
 598         _tmp0_ = ((CollectionTests*) self)->test_collection;
 599         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
 600         test_list = _tmp1_;
 601         _tmp2_ = test_list;
 602         _vala_assert (_tmp2_ != NULL, "test_list != null");
 603         _tmp3_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
 604         if (_tmp3_) {
 605                 GeeList* _tmp4_;
 606                 gpointer _tmp5_ = NULL;
 607                 gchar* _tmp6_;
 608                 _tmp4_ = test_list;
 609                 _tmp5_ = gee_list_get (_tmp4_, 0);
 610                 _tmp6_ = (gchar*) _tmp5_;
 611                 _g_free0 (_tmp6_);
 612                 exit (0);
 613         }
 614         g_test_trap_assert_failed ();
 615         _tmp7_ = test_list;
 616         _tmp8_ = gee_collection_add ((GeeCollection*) _tmp7_, "one");
 617         _vala_assert (_tmp8_, "test_list.add (\"one\")");
 618         _tmp9_ = test_list;
 619         _tmp10_ = gee_list_get (_tmp9_, 0);
 620         _tmp11_ = (gchar*) _tmp10_;
 621         _vala_assert (g_strcmp0 (_tmp11_, "one") == 0, "test_list.get (0) == \"one\"");
 622         _g_free0 (_tmp11_);
 623         _tmp12_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
 624         if (_tmp12_) {
 625                 GeeList* _tmp13_;
 626                 gpointer _tmp14_ = NULL;
 627                 gchar* _tmp15_;
 628                 _tmp13_ = test_list;
 629                 _tmp14_ = gee_list_get (_tmp13_, 1);
 630                 _tmp15_ = (gchar*) _tmp14_;
 631                 _g_free0 (_tmp15_);
 632                 exit (0);
 633         }
 634         g_test_trap_assert_failed ();
 635         _tmp16_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
 636         if (_tmp16_) {
 637                 GeeList* _tmp17_;
 638                 gpointer _tmp18_ = NULL;
 639                 gchar* _tmp19_;
 640                 _tmp17_ = test_list;
 641                 _tmp18_ = gee_list_get (_tmp17_, -1);
 642                 _tmp19_ = (gchar*) _tmp18_;
 643                 _g_free0 (_tmp19_);
 644                 exit (0);
 645         }
 646         g_test_trap_assert_failed ();
 647         _tmp20_ = test_list;
 648         _tmp21_ = gee_collection_add ((GeeCollection*) _tmp20_, "two");
 649         _vala_assert (_tmp21_, "test_list.add (\"two\")");
 650         _tmp22_ = test_list;
 651         _tmp23_ = gee_collection_add ((GeeCollection*) _tmp22_, "three");
 652         _vala_assert (_tmp23_, "test_list.add (\"three\")");
 653         _tmp24_ = test_list;
 654         _tmp25_ = gee_list_get (_tmp24_, 0);
 655         _tmp26_ = (gchar*) _tmp25_;
 656         _vala_assert (g_strcmp0 (_tmp26_, "one") == 0, "test_list.get (0) == \"one\"");
 657         _g_free0 (_tmp26_);
 658         _tmp27_ = test_list;
 659         _tmp28_ = gee_list_get (_tmp27_, 1);
 660         _tmp29_ = (gchar*) _tmp28_;
 661         _vala_assert (g_strcmp0 (_tmp29_, "two") == 0, "test_list.get (1) == \"two\"");
 662         _g_free0 (_tmp29_);
 663         _tmp30_ = test_list;
 664         _tmp31_ = gee_list_get (_tmp30_, 2);
 665         _tmp32_ = (gchar*) _tmp31_;
 666         _vala_assert (g_strcmp0 (_tmp32_, "three") == 0, "test_list.get (2) == \"three\"");
 667         _g_free0 (_tmp32_);
 668         _tmp33_ = test_list;
 669         gee_collection_clear ((GeeCollection*) _tmp33_);
 670         _tmp34_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
 671         if (_tmp34_) {
 672                 GeeList* _tmp35_;
 673                 gpointer _tmp36_ = NULL;
 674                 gchar* _tmp37_;
 675                 _tmp35_ = test_list;
 676                 _tmp36_ = gee_list_get (_tmp35_, 0);
 677                 _tmp37_ = (gchar*) _tmp36_;
 678                 _g_free0 (_tmp37_);
 679                 exit (0);
 680         }
 681         g_test_trap_assert_failed ();
 682         _g_object_unref0 (test_list);
 683 }
 684
 685
 686 void list_tests_test_set (ListTests* self) {
 687         GeeCollection* _tmp0_;
 688         GeeList* _tmp1_;
 689         GeeList* test_list;
 690         GeeList* _tmp2_;
 691         GeeList* _tmp3_;
 692         gint _tmp4_;
 693         gint _tmp5_;
 694         gboolean _tmp6_ = FALSE;
 695         GeeList* _tmp8_;
 696         gint _tmp9_;
 697         gint _tmp10_;
 698         GeeList* _tmp11_;
 699         gboolean _tmp12_ = FALSE;
 700         GeeList* _tmp13_;
 701         gint _tmp14_;
 702         gint _tmp15_;
 703         GeeList* _tmp16_;
 704         gpointer _tmp17_ = NULL;
 705         gchar* _tmp18_;
 706         GeeList* _tmp19_;
 707         GeeList* _tmp20_;
 708         gint _tmp21_;
 709         gint _tmp22_;
 710         GeeList* _tmp23_;
 711         gpointer _tmp24_ = NULL;
 712         gchar* _tmp25_;
 713         GeeList* _tmp26_;
 714         gint _tmp27_;
 715         gint _tmp28_;
 716         gboolean _tmp29_ = FALSE;
 717         GeeList* _tmp31_;
 718         gint _tmp32_;
 719         gint _tmp33_;
 720         g_return_if_fail (self != NULL);
 721         _tmp0_ = ((CollectionTests*) self)->test_collection;
 722         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
 723         test_list = _tmp1_;
 724         _tmp2_ = test_list;
 725         _vala_assert (_tmp2_ != NULL, "test_list != null");
 726         _tmp3_ = test_list;
 727         _tmp4_ = gee_collection_get_size ((GeeCollection*) _tmp3_);
 728         _tmp5_ = _tmp4_;
 729         _vala_assert (_tmp5_ == 0, "test_list.size == 0");
 730         _tmp6_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
 731         if (_tmp6_) {
 732                 GeeList* _tmp7_;
 733                 _tmp7_ = test_list;
 734                 gee_list_set (_tmp7_, 0, "zero");
 735                 exit (0);
 736         }
 737         g_test_trap_assert_failed ();
 738         _tmp8_ = test_list;
 739         _tmp9_ = gee_collection_get_size ((GeeCollection*) _tmp8_);
 740         _tmp10_ = _tmp9_;
 741         _vala_assert (_tmp10_ == 0, "test_list.size == 0");
 742         _tmp11_ = test_list;
 743         _tmp12_ = gee_collection_add ((GeeCollection*) _tmp11_, "one");
 744         _vala_assert (_tmp12_, "test_list.add (\"one\")");
 745         _tmp13_ = test_list;
 746         _tmp14_ = gee_collection_get_size ((GeeCollection*) _tmp13_);
 747         _tmp15_ = _tmp14_;
 748         _vala_assert (_tmp15_ == 1, "test_list.size == 1");
 749         _tmp16_ = test_list;
 750         _tmp17_ = gee_list_get (_tmp16_, 0);
 751         _tmp18_ = (gchar*) _tmp17_;
 752         _vala_assert (g_strcmp0 (_tmp18_, "one") == 0, "test_list.get (0) == \"one\"");
 753         _g_free0 (_tmp18_);
 754         _tmp19_ = test_list;
 755         gee_list_set (_tmp19_, 0, "two");
 756         _tmp20_ = test_list;
 757         _tmp21_ = gee_collection_get_size ((GeeCollection*) _tmp20_);
 758         _tmp22_ = _tmp21_;
 759         _vala_assert (_tmp22_ == 1, "test_list.size == 1");
 760         _tmp23_ = test_list;
 761         _tmp24_ = gee_list_get (_tmp23_, 0);
 762         _tmp25_ = (gchar*) _tmp24_;
 763         _vala_assert (g_strcmp0 (_tmp25_, "two") == 0, "test_list.get (0) == \"two\"");
 764         _g_free0 (_tmp25_);
 765         _tmp26_ = test_list;
 766         _tmp27_ = gee_collection_get_size ((GeeCollection*) _tmp26_);
 767         _tmp28_ = _tmp27_;
 768         _vala_assert (_tmp28_ == 1, "test_list.size == 1");
 769         _tmp29_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
 770         if (_tmp29_) {
 771                 GeeList* _tmp30_;
 772                 _tmp30_ = test_list;
 773                 gee_list_set (_tmp30_, 1, "zero");
 774                 exit (0);
 775         }
 776         g_test_trap_assert_failed ();
 777         _tmp31_ = test_list;
 778         _tmp32_ = gee_collection_get_size ((GeeCollection*) _tmp31_);
 779         _tmp33_ = _tmp32_;
 780         _vala_assert (_tmp33_ == 1, "test_list.size == 1");
 781         _g_object_unref0 (test_list);
 782 }
 783
 784
 785 void list_tests_test_insert (ListTests* self) {
 786         GeeCollection* _tmp0_;
 787         GeeList* _tmp1_;
 788         GeeList* test_list;
 789         GeeList* _tmp2_;
 790         gboolean _tmp3_ = FALSE;
 791         GeeList* _tmp5_;
 792         gint _tmp6_;
 793         gint _tmp7_;
 794         GeeList* _tmp8_;
 795         GeeList* _tmp9_;
 796         gint _tmp10_;
 797         gint _tmp11_;
 798         GeeList* _tmp12_;
 799         gpointer _tmp13_ = NULL;
 800         gchar* _tmp14_;
 801         GeeList* _tmp15_;
 802         GeeList* _tmp16_;
 803         gpointer _tmp17_ = NULL;
 804         gchar* _tmp18_;
 805         GeeList* _tmp19_;
 806         gpointer _tmp20_ = NULL;
 807         gchar* _tmp21_;
 808         GeeList* _tmp22_;
 809         GeeList* _tmp23_;
 810         gpointer _tmp24_ = NULL;
 811         gchar* _tmp25_;
 812         GeeList* _tmp26_;
 813         gpointer _tmp27_ = NULL;
 814         gchar* _tmp28_;
 815         GeeList* _tmp29_;
 816         gpointer _tmp30_ = NULL;
 817         gchar* _tmp31_;
 818         gboolean _tmp32_ = FALSE;
 819         GeeList* _tmp34_;
 820         GeeList* _tmp35_;
 821         gpointer _tmp36_ = NULL;
 822         gchar* _tmp37_;
 823         GeeList* _tmp38_;
 824         gpointer _tmp39_ = NULL;
 825         gchar* _tmp40_;
 826         GeeList* _tmp41_;
 827         gpointer _tmp42_ = NULL;
 828         gchar* _tmp43_;
 829         GeeList* _tmp44_;
 830         gpointer _tmp45_ = NULL;
 831         gchar* _tmp46_;
 832         gboolean _tmp47_ = FALSE;
 833         g_return_if_fail (self != NULL);
 834         _tmp0_ = ((CollectionTests*) self)->test_collection;
 835         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
 836         test_list = _tmp1_;
 837         _tmp2_ = test_list;
 838         _vala_assert (_tmp2_ != NULL, "test_list != null");
 839         _tmp3_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
 840         if (_tmp3_) {
 841                 GeeList* _tmp4_;
 842                 _tmp4_ = test_list;
 843                 gee_list_insert (_tmp4_, 1, "zero");
 844                 exit (0);
 845         }
 846         g_test_trap_assert_failed ();
 847         _tmp5_ = test_list;
 848         _tmp6_ = gee_collection_get_size ((GeeCollection*) _tmp5_);
 849         _tmp7_ = _tmp6_;
 850         _vala_assert (_tmp7_ == 0, "test_list.size == 0");
 851         _tmp8_ = test_list;
 852         gee_list_insert (_tmp8_, 0, "one");
 853         _tmp9_ = test_list;
 854         _tmp10_ = gee_collection_get_size ((GeeCollection*) _tmp9_);
 855         _tmp11_ = _tmp10_;
 856         _vala_assert (_tmp11_ == 1, "test_list.size == 1");
 857         _tmp12_ = test_list;
 858         _tmp13_ = gee_list_get (_tmp12_, 0);
 859         _tmp14_ = (gchar*) _tmp13_;
 860         _vala_assert (g_strcmp0 (_tmp14_, "one") == 0, "test_list.get (0) == \"one\"");
 861         _g_free0 (_tmp14_);
 862         _tmp15_ = test_list;
 863         gee_list_insert (_tmp15_, 0, "two");
 864         _tmp16_ = test_list;
 865         _tmp17_ = gee_list_get (_tmp16_, 0);
 866         _tmp18_ = (gchar*) _tmp17_;
 867         _vala_assert (g_strcmp0 (_tmp18_, "two") == 0, "test_list.get (0) == \"two\"");
 868         _g_free0 (_tmp18_);
 869         _tmp19_ = test_list;
 870         _tmp20_ = gee_list_get (_tmp19_, 1);
 871         _tmp21_ = (gchar*) _tmp20_;
 872         _vala_assert (g_strcmp0 (_tmp21_, "one") == 0, "test_list.get (1) == \"one\"");
 873         _g_free0 (_tmp21_);
 874         _tmp22_ = test_list;
 875         gee_list_insert (_tmp22_, 1, "three");
 876         _tmp23_ = test_list;
 877         _tmp24_ = gee_list_get (_tmp23_, 0);
 878         _tmp25_ = (gchar*) _tmp24_;
 879         _vala_assert (g_strcmp0 (_tmp25_, "two") == 0, "test_list.get (0) == \"two\"");
 880         _g_free0 (_tmp25_);
 881         _tmp26_ = test_list;
 882         _tmp27_ = gee_list_get (_tmp26_, 1);
 883         _tmp28_ = (gchar*) _tmp27_;
 884         _vala_assert (g_strcmp0 (_tmp28_, "three") == 0, "test_list.get (1) == \"three\"");
 885         _g_free0 (_tmp28_);
 886         _tmp29_ = test_list;
 887         _tmp30_ = gee_list_get (_tmp29_, 2);
 888         _tmp31_ = (gchar*) _tmp30_;
 889         _vala_assert (g_strcmp0 (_tmp31_, "one") == 0, "test_list.get (2) == \"one\"");
 890         _g_free0 (_tmp31_);
 891         _tmp32_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
 892         if (_tmp32_) {
 893                 GeeList* _tmp33_;
 894                 _tmp33_ = test_list;
 895                 gee_list_insert (_tmp33_, 4, "four");
 896                 exit (0);
 897         }
 898         g_test_trap_assert_failed ();
 899         _tmp34_ = test_list;
 900         gee_list_insert (_tmp34_, 3, "four");
 901         _tmp35_ = test_list;
 902         _tmp36_ = gee_list_get (_tmp35_, 0);
 903         _tmp37_ = (gchar*) _tmp36_;
 904         _vala_assert (g_strcmp0 (_tmp37_, "two") == 0, "test_list.get (0) == \"two\"");
 905         _g_free0 (_tmp37_);
 906         _tmp38_ = test_list;
 907         _tmp39_ = gee_list_get (_tmp38_, 1);
 908         _tmp40_ = (gchar*) _tmp39_;
 909         _vala_assert (g_strcmp0 (_tmp40_, "three") == 0, "test_list.get (1) == \"three\"");
 910         _g_free0 (_tmp40_);
 911         _tmp41_ = test_list;
 912         _tmp42_ = gee_list_get (_tmp41_, 2);
 913         _tmp43_ = (gchar*) _tmp42_;
 914         _vala_assert (g_strcmp0 (_tmp43_, "one") == 0, "test_list.get (2) == \"one\"");
 915         _g_free0 (_tmp43_);
 916         _tmp44_ = test_list;
 917         _tmp45_ = gee_list_get (_tmp44_, 3);
 918         _tmp46_ = (gchar*) _tmp45_;
 919         _vala_assert (g_strcmp0 (_tmp46_, "four") == 0, "test_list.get (3) == \"four\"");
 920         _g_free0 (_tmp46_);
 921         _tmp47_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
 922         if (_tmp47_) {
 923                 GeeList* _tmp48_;
 924                 _tmp48_ = test_list;
 925                 gee_list_insert (_tmp48_, -1, "zero");
 926                 exit (0);
 927         }
 928         g_test_trap_assert_failed ();
 929         _g_object_unref0 (test_list);
 930 }
 931
 932
 933 void list_tests_test_remove_at (ListTests* self) {
 934         GeeCollection* _tmp0_;
 935         GeeList* _tmp1_;
 936         GeeList* test_list;
 937         GeeList* _tmp2_;
 938         gboolean _tmp3_ = FALSE;
 939         gboolean _tmp7_ = FALSE;
 940         GeeList* _tmp11_;
 941         gboolean _tmp12_ = FALSE;
 942         GeeList* _tmp13_;
 943         gboolean _tmp14_ = FALSE;
 944         GeeList* _tmp15_;
 945         gboolean _tmp16_ = FALSE;
 946         GeeList* _tmp17_;
 947         gboolean _tmp18_ = FALSE;
 948         GeeList* _tmp19_;
 949         gboolean _tmp20_ = FALSE;
 950         GeeList* _tmp21_;
 951         gint _tmp22_;
 952         gint _tmp23_;
 953         GeeList* _tmp24_;
 954         gpointer _tmp25_ = NULL;
 955         gchar* _tmp26_;
 956         GeeList* _tmp27_;
 957         gint _tmp28_;
 958         gint _tmp29_;
 959         GeeList* _tmp30_;
 960         gpointer _tmp31_ = NULL;
 961         gchar* _tmp32_;
 962         GeeList* _tmp33_;
 963         gpointer _tmp34_ = NULL;
 964         gchar* _tmp35_;
 965         GeeList* _tmp36_;
 966         gpointer _tmp37_ = NULL;
 967         gchar* _tmp38_;
 968         GeeList* _tmp39_;
 969         gpointer _tmp40_ = NULL;
 970         gchar* _tmp41_;
 971         GeeList* _tmp42_;
 972         gpointer _tmp43_ = NULL;
 973         gchar* _tmp44_;
 974         GeeList* _tmp45_;
 975         gint _tmp46_;
 976         gint _tmp47_;
 977         GeeList* _tmp48_;
 978         gpointer _tmp49_ = NULL;
 979         gchar* _tmp50_;
 980         GeeList* _tmp51_;
 981         gpointer _tmp52_ = NULL;
 982         gchar* _tmp53_;
 983         GeeList* _tmp54_;
 984         gpointer _tmp55_ = NULL;
 985         gchar* _tmp56_;
 986         GeeList* _tmp57_;
 987         gpointer _tmp58_ = NULL;
 988         gchar* _tmp59_;
 989         GeeList* _tmp60_;
 990         gint _tmp61_;
 991         gint _tmp62_;
 992         GeeList* _tmp63_;
 993         gpointer _tmp64_ = NULL;
 994         gchar* _tmp65_;
 995         GeeList* _tmp66_;
 996         gpointer _tmp67_ = NULL;
 997         gchar* _tmp68_;
 998         gboolean _tmp69_ = FALSE;
 999         gboolean _tmp73_ = FALSE;
1000         g_return_if_fail (self != NULL);
1001         _tmp0_ = ((CollectionTests*) self)->test_collection;
1002         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
1003         test_list = _tmp1_;
1004         _tmp2_ = test_list;
1005         _vala_assert (_tmp2_ != NULL, "test_list != null");
1006         _tmp3_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1007         if (_tmp3_) {
1008                 GeeList* _tmp4_;
1009                 gpointer _tmp5_ = NULL;
1010                 gchar* _tmp6_;
1011                 _tmp4_ = test_list;
1012                 _tmp5_ = gee_list_remove_at (_tmp4_, 0);
1013                 _tmp6_ = (gchar*) _tmp5_;
1014                 _g_free0 (_tmp6_);
1015                 exit (0);
1016         }
1017         g_test_trap_assert_failed ();
1018         _tmp7_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1019         if (_tmp7_) {
1020                 GeeList* _tmp8_;
1021                 gpointer _tmp9_ = NULL;
1022                 gchar* _tmp10_;
1023                 _tmp8_ = test_list;
1024                 _tmp9_ = gee_list_remove_at (_tmp8_, 1);
1025                 _tmp10_ = (gchar*) _tmp9_;
1026                 _g_free0 (_tmp10_);
1027                 exit (0);
1028         }
1029         g_test_trap_assert_failed ();
1030         _tmp11_ = test_list;
1031         _tmp12_ = gee_collection_add ((GeeCollection*) _tmp11_, "one");
1032         _vala_assert (_tmp12_, "test_list.add (\"one\")");
1033         _tmp13_ = test_list;
1034         _tmp14_ = gee_collection_add ((GeeCollection*) _tmp13_, "two");
1035         _vala_assert (_tmp14_, "test_list.add (\"two\")");
1036         _tmp15_ = test_list;
1037         _tmp16_ = gee_collection_add ((GeeCollection*) _tmp15_, "three");
1038         _vala_assert (_tmp16_, "test_list.add (\"three\")");
1039         _tmp17_ = test_list;
1040         _tmp18_ = gee_collection_add ((GeeCollection*) _tmp17_, "four");
1041         _vala_assert (_tmp18_, "test_list.add (\"four\")");
1042         _tmp19_ = test_list;
1043         _tmp20_ = gee_collection_add ((GeeCollection*) _tmp19_, "five");
1044         _vala_assert (_tmp20_, "test_list.add (\"five\")");
1045         _tmp21_ = test_list;
1046         _tmp22_ = gee_collection_get_size ((GeeCollection*) _tmp21_);
1047         _tmp23_ = _tmp22_;
1048         _vala_assert (_tmp23_ == 5, "test_list.size == 5");
1049         _tmp24_ = test_list;
1050         _tmp25_ = gee_list_remove_at (_tmp24_, 0);
1051         _tmp26_ = (gchar*) _tmp25_;
1052         _vala_assert (g_strcmp0 (_tmp26_, "one") == 0, "test_list.remove_at (0) == \"one\"");
1053         _g_free0 (_tmp26_);
1054         _tmp27_ = test_list;
1055         _tmp28_ = gee_collection_get_size ((GeeCollection*) _tmp27_);
1056         _tmp29_ = _tmp28_;
1057         _vala_assert (_tmp29_ == 4, "test_list.size == 4");
1058         _tmp30_ = test_list;
1059         _tmp31_ = gee_list_get (_tmp30_, 0);
1060         _tmp32_ = (gchar*) _tmp31_;
1061         _vala_assert (g_strcmp0 (_tmp32_, "two") == 0, "test_list.get (0) == \"two\"");
1062         _g_free0 (_tmp32_);
1063         _tmp33_ = test_list;
1064         _tmp34_ = gee_list_get (_tmp33_, 1);
1065         _tmp35_ = (gchar*) _tmp34_;
1066         _vala_assert (g_strcmp0 (_tmp35_, "three") == 0, "test_list.get (1) == \"three\"");
1067         _g_free0 (_tmp35_);
1068         _tmp36_ = test_list;
1069         _tmp37_ = gee_list_get (_tmp36_, 2);
1070         _tmp38_ = (gchar*) _tmp37_;
1071         _vala_assert (g_strcmp0 (_tmp38_, "four") == 0, "test_list.get (2) == \"four\"");
1072         _g_free0 (_tmp38_);
1073         _tmp39_ = test_list;
1074         _tmp40_ = gee_list_get (_tmp39_, 3);
1075         _tmp41_ = (gchar*) _tmp40_;
1076         _vala_assert (g_strcmp0 (_tmp41_, "five") == 0, "test_list.get (3) == \"five\"");
1077         _g_free0 (_tmp41_);
1078         _tmp42_ = test_list;
1079         _tmp43_ = gee_list_remove_at (_tmp42_, 3);
1080         _tmp44_ = (gchar*) _tmp43_;
1081         _vala_assert (g_strcmp0 (_tmp44_, "five") == 0, "test_list.remove_at (3) == \"five\"");
1082         _g_free0 (_tmp44_);
1083         _tmp45_ = test_list;
1084         _tmp46_ = gee_collection_get_size ((GeeCollection*) _tmp45_);
1085         _tmp47_ = _tmp46_;
1086         _vala_assert (_tmp47_ == 3, "test_list.size == 3");
1087         _tmp48_ = test_list;
1088         _tmp49_ = gee_list_get (_tmp48_, 0);
1089         _tmp50_ = (gchar*) _tmp49_;
1090         _vala_assert (g_strcmp0 (_tmp50_, "two") == 0, "test_list.get (0) == \"two\"");
1091         _g_free0 (_tmp50_);
1092         _tmp51_ = test_list;
1093         _tmp52_ = gee_list_get (_tmp51_, 1);
1094         _tmp53_ = (gchar*) _tmp52_;
1095         _vala_assert (g_strcmp0 (_tmp53_, "three") == 0, "test_list.get (1) == \"three\"");
1096         _g_free0 (_tmp53_);
1097         _tmp54_ = test_list;
1098         _tmp55_ = gee_list_get (_tmp54_, 2);
1099         _tmp56_ = (gchar*) _tmp55_;
1100         _vala_assert (g_strcmp0 (_tmp56_, "four") == 0, "test_list.get (2) == \"four\"");
1101         _g_free0 (_tmp56_);
1102         _tmp57_ = test_list;
1103         _tmp58_ = gee_list_remove_at (_tmp57_, 1);
1104         _tmp59_ = (gchar*) _tmp58_;
1105         _vala_assert (g_strcmp0 (_tmp59_, "three") == 0, "test_list.remove_at (1) == \"three\"");
1106         _g_free0 (_tmp59_);
1107         _tmp60_ = test_list;
1108         _tmp61_ = gee_collection_get_size ((GeeCollection*) _tmp60_);
1109         _tmp62_ = _tmp61_;
1110         _vala_assert (_tmp62_ == 2, "test_list.size == 2");
1111         _tmp63_ = test_list;
1112         _tmp64_ = gee_list_get (_tmp63_, 0);
1113         _tmp65_ = (gchar*) _tmp64_;
1114         _vala_assert (g_strcmp0 (_tmp65_, "two") == 0, "test_list.get (0) == \"two\"");
1115         _g_free0 (_tmp65_);
1116         _tmp66_ = test_list;
1117         _tmp67_ = gee_list_get (_tmp66_, 1);
1118         _tmp68_ = (gchar*) _tmp67_;
1119         _vala_assert (g_strcmp0 (_tmp68_, "four") == 0, "test_list.get (1) == \"four\"");
1120         _g_free0 (_tmp68_);
1121         _tmp69_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1122         if (_tmp69_) {
1123                 GeeList* _tmp70_;
1124                 gpointer _tmp71_ = NULL;
1125                 gchar* _tmp72_;
1126                 _tmp70_ = test_list;
1127                 _tmp71_ = gee_list_remove_at (_tmp70_, 2);
1128                 _tmp72_ = (gchar*) _tmp71_;
1129                 _g_free0 (_tmp72_);
1130                 exit (0);
1131         }
1132         g_test_trap_assert_failed ();
1133         _tmp73_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1134         if (_tmp73_) {
1135                 GeeList* _tmp74_;
1136                 gpointer _tmp75_ = NULL;
1137                 gchar* _tmp76_;
1138                 _tmp74_ = test_list;
1139                 _tmp75_ = gee_list_remove_at (_tmp74_, -1);
1140                 _tmp76_ = (gchar*) _tmp75_;
1141                 _g_free0 (_tmp76_);
1142                 exit (0);
1143         }
1144         g_test_trap_assert_failed ();
1145         _g_object_unref0 (test_list);
1146 }
1147
1148
1149 void list_tests_test_index_of (ListTests* self) {
1150         GeeCollection* _tmp0_;
1151         GeeList* _tmp1_;
1152         GeeList* test_list;
1153         gint _tmp2_ = 0;
1154         gboolean _tmp3_ = FALSE;
1155         gint _tmp4_ = 0;
1156         gint _tmp5_ = 0;
1157         gboolean _tmp6_ = FALSE;
1158         gboolean _tmp7_ = FALSE;
1159         gboolean _tmp8_ = FALSE;
1160         gint _tmp9_ = 0;
1161         gint _tmp10_ = 0;
1162         gint _tmp11_ = 0;
1163         gint _tmp12_ = 0;
1164         gint _tmp13_ = 0;
1165         g_return_if_fail (self != NULL);
1166         _tmp0_ = ((CollectionTests*) self)->test_collection;
1167         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
1168         test_list = _tmp1_;
1169         _vala_assert (test_list != NULL, "test_list != null");
1170         _tmp2_ = gee_list_index_of (test_list, "one");
1171         _vala_assert (_tmp2_ == (-1), "test_list.index_of (\"one\") == -1");
1172         _tmp3_ = gee_collection_add ((GeeCollection*) test_list, "one");
1173         _vala_assert (_tmp3_, "test_list.add (\"one\")");
1174         _tmp4_ = gee_list_index_of (test_list, "one");
1175         _vala_assert (_tmp4_ == 0, "test_list.index_of (\"one\") == 0");
1176         _tmp5_ = gee_list_index_of (test_list, "two");
1177         _vala_assert (_tmp5_ == (-1), "test_list.index_of (\"two\") == -1");
1178         _tmp6_ = gee_collection_add ((GeeCollection*) test_list, "two");
1179         _vala_assert (_tmp6_, "test_list.add (\"two\")");
1180         _tmp7_ = gee_collection_add ((GeeCollection*) test_list, "three");
1181         _vala_assert (_tmp7_, "test_list.add (\"three\")");
1182         _tmp8_ = gee_collection_add ((GeeCollection*) test_list, "four");
1183         _vala_assert (_tmp8_, "test_list.add (\"four\")");
1184         _tmp9_ = gee_list_index_of (test_list, "one");
1185         _vala_assert (_tmp9_ == 0, "test_list.index_of (\"one\") == 0");
1186         _tmp10_ = gee_list_index_of (test_list, "two");
1187         _vala_assert (_tmp10_ == 1, "test_list.index_of (\"two\") == 1");
1188         _tmp11_ = gee_list_index_of (test_list, "three");
1189         _vala_assert (_tmp11_ == 2, "test_list.index_of (\"three\") == 2");
1190         _tmp12_ = gee_list_index_of (test_list, "four");
1191         _vala_assert (_tmp12_ == 3, "test_list.index_of (\"four\") == 3");
1192         _tmp13_ = gee_list_index_of (test_list, "five");
1193         _vala_assert (_tmp13_ == (-1), "test_list.index_of (\"five\") == -1");
1194         _g_object_unref0 (test_list);
1195 }
1196
1197
1198 void list_tests_test_first (ListTests* self) {
1199         GeeCollection* _tmp0_;
1200         GeeList* _tmp1_;
1201         GeeList* test_list;
1202         GeeList* _tmp2_;
1203         gboolean _tmp3_ = FALSE;
1204         GeeList* _tmp7_;
1205         gboolean _tmp8_ = FALSE;
1206         GeeList* _tmp9_;
1207         gpointer _tmp10_ = NULL;
1208         gchar* _tmp11_;
1209         GeeList* _tmp12_;
1210         gpointer _tmp13_ = NULL;
1211         gchar* _tmp14_;
1212         GeeList* _tmp15_;
1213         gpointer _tmp16_ = NULL;
1214         gchar* _tmp17_;
1215         GeeList* _tmp18_;
1216         gboolean _tmp19_ = FALSE;
1217         GeeList* _tmp20_;
1218         gboolean _tmp21_ = FALSE;
1219         GeeList* _tmp22_;
1220         gpointer _tmp23_ = NULL;
1221         gchar* _tmp24_;
1222         GeeList* _tmp25_;
1223         gpointer _tmp26_ = NULL;
1224         gchar* _tmp27_;
1225         GeeList* _tmp28_;
1226         gpointer _tmp29_ = NULL;
1227         gchar* _tmp30_;
1228         GeeList* _tmp31_;
1229         gboolean _tmp32_ = FALSE;
1230         g_return_if_fail (self != NULL);
1231         _tmp0_ = ((CollectionTests*) self)->test_collection;
1232         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
1233         test_list = _tmp1_;
1234         _tmp2_ = test_list;
1235         _vala_assert (_tmp2_ != NULL, "test_list != null");
1236         _tmp3_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1237         if (_tmp3_) {
1238                 GeeList* _tmp4_;
1239                 gpointer _tmp5_ = NULL;
1240                 gchar* _tmp6_;
1241                 _tmp4_ = test_list;
1242                 _tmp5_ = gee_list_first (_tmp4_);
1243                 _tmp6_ = (gchar*) _tmp5_;
1244                 _g_free0 (_tmp6_);
1245                 exit (0);
1246         }
1247         g_test_trap_assert_failed ();
1248         _tmp7_ = test_list;
1249         _tmp8_ = gee_collection_add ((GeeCollection*) _tmp7_, "one");
1250         _vala_assert (_tmp8_, "test_list.add (\"one\")");
1251         _tmp9_ = test_list;
1252         _tmp10_ = gee_list_first (_tmp9_);
1253         _tmp11_ = (gchar*) _tmp10_;
1254         _vala_assert (g_strcmp0 (_tmp11_, "one") == 0, "test_list.first () == \"one\"");
1255         _g_free0 (_tmp11_);
1256         _tmp12_ = test_list;
1257         _tmp13_ = gee_list_first (_tmp12_);
1258         _tmp14_ = (gchar*) _tmp13_;
1259         _tmp15_ = test_list;
1260         _tmp16_ = gee_list_get (_tmp15_, 0);
1261         _tmp17_ = (gchar*) _tmp16_;
1262         _vala_assert (g_strcmp0 (_tmp14_, _tmp17_) == 0, "test_list.first () == test_list.get (0)");
1263         _g_free0 (_tmp17_);
1264         _g_free0 (_tmp14_);
1265         _tmp18_ = test_list;
1266         _tmp19_ = gee_collection_add ((GeeCollection*) _tmp18_, "two");
1267         _vala_assert (_tmp19_, "test_list.add (\"two\")");
1268         _tmp20_ = test_list;
1269         _tmp21_ = gee_collection_add ((GeeCollection*) _tmp20_, "three");
1270         _vala_assert (_tmp21_, "test_list.add (\"three\")");
1271         _tmp22_ = test_list;
1272         _tmp23_ = gee_list_first (_tmp22_);
1273         _tmp24_ = (gchar*) _tmp23_;
1274         _vala_assert (g_strcmp0 (_tmp24_, "one") == 0, "test_list.first () == \"one\"");
1275         _g_free0 (_tmp24_);
1276         _tmp25_ = test_list;
1277         _tmp26_ = gee_list_first (_tmp25_);
1278         _tmp27_ = (gchar*) _tmp26_;
1279         _tmp28_ = test_list;
1280         _tmp29_ = gee_list_get (_tmp28_, 0);
1281         _tmp30_ = (gchar*) _tmp29_;
1282         _vala_assert (g_strcmp0 (_tmp27_, _tmp30_) == 0, "test_list.first () == test_list.get (0)");
1283         _g_free0 (_tmp30_);
1284         _g_free0 (_tmp27_);
1285         _tmp31_ = test_list;
1286         gee_collection_clear ((GeeCollection*) _tmp31_);
1287         _tmp32_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1288         if (_tmp32_) {
1289                 GeeList* _tmp33_;
1290                 gpointer _tmp34_ = NULL;
1291                 gchar* _tmp35_;
1292                 _tmp33_ = test_list;
1293                 _tmp34_ = gee_list_first (_tmp33_);
1294                 _tmp35_ = (gchar*) _tmp34_;
1295                 _g_free0 (_tmp35_);
1296                 exit (0);
1297         }
1298         g_test_trap_assert_failed ();
1299         _g_object_unref0 (test_list);
1300 }
1301
1302
1303 void list_tests_test_last (ListTests* self) {
1304         GeeCollection* _tmp0_;
1305         GeeList* _tmp1_;
1306         GeeList* test_list;
1307         GeeList* _tmp2_;
1308         gboolean _tmp3_ = FALSE;
1309         GeeList* _tmp7_;
1310         gboolean _tmp8_ = FALSE;
1311         GeeList* _tmp9_;
1312         gpointer _tmp10_ = NULL;
1313         gchar* _tmp11_;
1314         GeeList* _tmp12_;
1315         gpointer _tmp13_ = NULL;
1316         gchar* _tmp14_;
1317         GeeList* _tmp15_;
1318         GeeList* _tmp16_;
1319         gint _tmp17_;
1320         gint _tmp18_;
1321         gpointer _tmp19_ = NULL;
1322         gchar* _tmp20_;
1323         GeeList* _tmp21_;
1324         gboolean _tmp22_ = FALSE;
1325         GeeList* _tmp23_;
1326         gboolean _tmp24_ = FALSE;
1327         GeeList* _tmp25_;
1328         gpointer _tmp26_ = NULL;
1329         gchar* _tmp27_;
1330         GeeList* _tmp28_;
1331         gpointer _tmp29_ = NULL;
1332         gchar* _tmp30_;
1333         GeeList* _tmp31_;
1334         GeeList* _tmp32_;
1335         gint _tmp33_;
1336         gint _tmp34_;
1337         gpointer _tmp35_ = NULL;
1338         gchar* _tmp36_;
1339         GeeList* _tmp37_;
1340         gboolean _tmp38_ = FALSE;
1341         g_return_if_fail (self != NULL);
1342         _tmp0_ = ((CollectionTests*) self)->test_collection;
1343         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
1344         test_list = _tmp1_;
1345         _tmp2_ = test_list;
1346         _vala_assert (_tmp2_ != NULL, "test_list != null");
1347         _tmp3_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1348         if (_tmp3_) {
1349                 GeeList* _tmp4_;
1350                 gpointer _tmp5_ = NULL;
1351                 gchar* _tmp6_;
1352                 _tmp4_ = test_list;
1353                 _tmp5_ = gee_list_last (_tmp4_);
1354                 _tmp6_ = (gchar*) _tmp5_;
1355                 _g_free0 (_tmp6_);
1356                 exit (0);
1357         }
1358         g_test_trap_assert_failed ();
1359         _tmp7_ = test_list;
1360         _tmp8_ = gee_collection_add ((GeeCollection*) _tmp7_, "one");
1361         _vala_assert (_tmp8_, "test_list.add (\"one\")");
1362         _tmp9_ = test_list;
1363         _tmp10_ = gee_list_last (_tmp9_);
1364         _tmp11_ = (gchar*) _tmp10_;
1365         _vala_assert (g_strcmp0 (_tmp11_, "one") == 0, "test_list.last () == \"one\"");
1366         _g_free0 (_tmp11_);
1367         _tmp12_ = test_list;
1368         _tmp13_ = gee_list_last (_tmp12_);
1369         _tmp14_ = (gchar*) _tmp13_;
1370         _tmp15_ = test_list;
1371         _tmp16_ = test_list;
1372         _tmp17_ = gee_collection_get_size ((GeeCollection*) _tmp16_);
1373         _tmp18_ = _tmp17_;
1374         _tmp19_ = gee_list_get (_tmp15_, _tmp18_ - 1);
1375         _tmp20_ = (gchar*) _tmp19_;
1376         _vala_assert (g_strcmp0 (_tmp14_, _tmp20_) == 0, "test_list.last () == test_list.get (test_list.size - 1)");
1377         _g_free0 (_tmp20_);
1378         _g_free0 (_tmp14_);
1379         _tmp21_ = test_list;
1380         _tmp22_ = gee_collection_add ((GeeCollection*) _tmp21_, "two");
1381         _vala_assert (_tmp22_, "test_list.add (\"two\")");
1382         _tmp23_ = test_list;
1383         _tmp24_ = gee_collection_add ((GeeCollection*) _tmp23_, "three");
1384         _vala_assert (_tmp24_, "test_list.add (\"three\")");
1385         _tmp25_ = test_list;
1386         _tmp26_ = gee_list_last (_tmp25_);
1387         _tmp27_ = (gchar*) _tmp26_;
1388         _vala_assert (g_strcmp0 (_tmp27_, "three") == 0, "test_list.last () == \"three\"");
1389         _g_free0 (_tmp27_);
1390         _tmp28_ = test_list;
1391         _tmp29_ = gee_list_last (_tmp28_);
1392         _tmp30_ = (gchar*) _tmp29_;
1393         _tmp31_ = test_list;
1394         _tmp32_ = test_list;
1395         _tmp33_ = gee_collection_get_size ((GeeCollection*) _tmp32_);
1396         _tmp34_ = _tmp33_;
1397         _tmp35_ = gee_list_get (_tmp31_, _tmp34_ - 1);
1398         _tmp36_ = (gchar*) _tmp35_;
1399         _vala_assert (g_strcmp0 (_tmp30_, _tmp36_) == 0, "test_list.last () == test_list.get (test_list.size - 1)");
1400         _g_free0 (_tmp36_);
1401         _g_free0 (_tmp30_);
1402         _tmp37_ = test_list;
1403         gee_collection_clear ((GeeCollection*) _tmp37_);
1404         _tmp38_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1405         if (_tmp38_) {
1406                 GeeList* _tmp39_;
1407                 gpointer _tmp40_ = NULL;
1408                 gchar* _tmp41_;
1409                 _tmp39_ = test_list;
1410                 _tmp40_ = gee_list_last (_tmp39_);
1411                 _tmp41_ = (gchar*) _tmp40_;
1412                 _g_free0 (_tmp41_);
1413                 exit (0);
1414         }
1415         g_test_trap_assert_failed ();
1416         _g_object_unref0 (test_list);
1417 }
1418
1419
1420 void list_tests_test_insert_all (ListTests* self) {
1421         GeeCollection* _tmp0_;
1422         GeeList* _tmp1_;
1423         GeeList* test_list;
1424         GeeList* _tmp2_;
1425         GeeArrayList* _tmp3_;
1426         GeeArrayList* dummy;
1427         GeeList* _tmp4_;
1428         gboolean _tmp5_ = FALSE;
1429         GeeList* _tmp6_;
1430         gboolean _tmp7_ = FALSE;
1431         GeeList* _tmp8_;
1432         gboolean _tmp9_ = FALSE;
1433         GeeList* _tmp10_;
1434         gint _tmp11_;
1435         gint _tmp12_;
1436         GeeArrayList* _tmp13_;
1437         gboolean _tmp14_;
1438         gboolean _tmp15_;
1439         GeeList* _tmp16_;
1440         GeeArrayList* _tmp17_;
1441         GeeList* _tmp18_;
1442         gint _tmp19_;
1443         gint _tmp20_;
1444         GeeArrayList* _tmp21_;
1445         gboolean _tmp22_;
1446         gboolean _tmp23_;
1447         GeeList* _tmp24_;
1448         GeeArrayList* _tmp25_;
1449         GeeArrayList* _tmp26_;
1450         gboolean _tmp27_ = FALSE;
1451         GeeArrayList* _tmp28_;
1452         gboolean _tmp29_ = FALSE;
1453         GeeArrayList* _tmp30_;
1454         gboolean _tmp31_ = FALSE;
1455         GeeList* _tmp32_;
1456         gboolean _tmp33_;
1457         gboolean _tmp34_;
1458         GeeArrayList* _tmp35_;
1459         gint _tmp36_;
1460         gint _tmp37_;
1461         GeeList* _tmp38_;
1462         GeeArrayList* _tmp39_;
1463         GeeList* _tmp40_;
1464         gint _tmp41_;
1465         gint _tmp42_;
1466         GeeArrayList* _tmp43_;
1467         gint _tmp44_;
1468         gint _tmp45_;
1469         GeeList* _tmp46_;
1470         GeeArrayList* _tmp47_;
1471         GeeArrayList* _tmp48_;
1472         gboolean _tmp49_ = FALSE;
1473         GeeArrayList* _tmp50_;
1474         gboolean _tmp51_ = FALSE;
1475         GeeArrayList* _tmp52_;
1476         gboolean _tmp53_ = FALSE;
1477         GeeList* _tmp54_;
1478         gboolean _tmp55_;
1479         gboolean _tmp56_;
1480         gboolean _tmp57_ = FALSE;
1481         GeeList* _tmp60_;
1482         GeeArrayList* _tmp61_;
1483         GeeList* _tmp62_;
1484         gboolean _tmp63_ = FALSE;
1485         GeeList* _tmp64_;
1486         gboolean _tmp65_ = FALSE;
1487         GeeList* _tmp66_;
1488         gboolean _tmp67_ = FALSE;
1489         GeeArrayList* _tmp68_;
1490         gboolean _tmp69_ = FALSE;
1491         GeeArrayList* _tmp70_;
1492         gboolean _tmp71_ = FALSE;
1493         GeeArrayList* _tmp72_;
1494         gboolean _tmp73_ = FALSE;
1495         GeeList* _tmp74_;
1496         gint _tmp75_;
1497         gint _tmp76_;
1498         GeeArrayList* _tmp77_;
1499         gint _tmp78_;
1500         gint _tmp79_;
1501         GeeList* _tmp80_;
1502         GeeArrayList* _tmp81_;
1503         GeeList* _tmp82_;
1504         gint _tmp83_;
1505         gint _tmp84_;
1506         GeeArrayList* _tmp85_;
1507         gint _tmp86_;
1508         gint _tmp87_;
1509         GeeList* _tmp88_;
1510         gpointer _tmp89_ = NULL;
1511         gchar* _tmp90_;
1512         GeeList* _tmp91_;
1513         gpointer _tmp92_ = NULL;
1514         gchar* _tmp93_;
1515         GeeList* _tmp94_;
1516         gpointer _tmp95_ = NULL;
1517         gchar* _tmp96_;
1518         GeeList* _tmp97_;
1519         gpointer _tmp98_ = NULL;
1520         gchar* _tmp99_;
1521         GeeList* _tmp100_;
1522         gpointer _tmp101_ = NULL;
1523         gchar* _tmp102_;
1524         GeeList* _tmp103_;
1525         gpointer _tmp104_ = NULL;
1526         gchar* _tmp105_;
1527         GeeList* _tmp106_;
1528         GeeArrayList* _tmp107_;
1529         GeeList* _tmp108_;
1530         gboolean _tmp109_ = FALSE;
1531         GeeList* _tmp110_;
1532         gboolean _tmp111_ = FALSE;
1533         GeeList* _tmp112_;
1534         gboolean _tmp113_ = FALSE;
1535         GeeList* _tmp114_;
1536         gboolean _tmp115_ = FALSE;
1537         GeeArrayList* _tmp116_;
1538         gboolean _tmp117_ = FALSE;
1539         GeeArrayList* _tmp118_;
1540         gboolean _tmp119_ = FALSE;
1541         GeeArrayList* _tmp120_;
1542         gboolean _tmp121_ = FALSE;
1543         GeeList* _tmp122_;
1544         gint _tmp123_;
1545         gint _tmp124_;
1546         GeeArrayList* _tmp125_;
1547         gint _tmp126_;
1548         gint _tmp127_;
1549         GeeList* _tmp128_;
1550         GeeArrayList* _tmp129_;
1551         GeeList* _tmp130_;
1552         gint _tmp131_;
1553         gint _tmp132_;
1554         GeeArrayList* _tmp133_;
1555         gint _tmp134_;
1556         gint _tmp135_;
1557         GeeList* _tmp136_;
1558         gpointer _tmp137_ = NULL;
1559         gchar* _tmp138_;
1560         GeeList* _tmp139_;
1561         gpointer _tmp140_ = NULL;
1562         gchar* _tmp141_;
1563         GeeList* _tmp142_;
1564         gpointer _tmp143_ = NULL;
1565         gchar* _tmp144_;
1566         GeeList* _tmp145_;
1567         gpointer _tmp146_ = NULL;
1568         gchar* _tmp147_;
1569         GeeList* _tmp148_;
1570         gpointer _tmp149_ = NULL;
1571         gchar* _tmp150_;
1572         GeeList* _tmp151_;
1573         gpointer _tmp152_ = NULL;
1574         gchar* _tmp153_;
1575         GeeList* _tmp154_;
1576         gpointer _tmp155_ = NULL;
1577         gchar* _tmp156_;
1578         GeeList* _tmp157_;
1579         GeeArrayList* _tmp158_;
1580         GeeList* _tmp159_;
1581         gboolean _tmp160_ = FALSE;
1582         GeeList* _tmp161_;
1583         gboolean _tmp162_ = FALSE;
1584         GeeList* _tmp163_;
1585         gboolean _tmp164_ = FALSE;
1586         GeeArrayList* _tmp165_;
1587         gboolean _tmp166_ = FALSE;
1588         GeeArrayList* _tmp167_;
1589         gboolean _tmp168_ = FALSE;
1590         GeeArrayList* _tmp169_;
1591         gboolean _tmp170_ = FALSE;
1592         GeeList* _tmp171_;
1593         gint _tmp172_;
1594         gint _tmp173_;
1595         GeeArrayList* _tmp174_;
1596         gint _tmp175_;
1597         gint _tmp176_;
1598         GeeList* _tmp177_;
1599         GeeArrayList* _tmp178_;
1600         GeeList* _tmp179_;
1601         gint _tmp180_;
1602         gint _tmp181_;
1603         GeeArrayList* _tmp182_;
1604         gint _tmp183_;
1605         gint _tmp184_;
1606         GeeList* _tmp185_;
1607         gpointer _tmp186_ = NULL;
1608         gchar* _tmp187_;
1609         GeeList* _tmp188_;
1610         gpointer _tmp189_ = NULL;
1611         gchar* _tmp190_;
1612         GeeList* _tmp191_;
1613         gpointer _tmp192_ = NULL;
1614         gchar* _tmp193_;
1615         GeeList* _tmp194_;
1616         gpointer _tmp195_ = NULL;
1617         gchar* _tmp196_;
1618         GeeList* _tmp197_;
1619         gpointer _tmp198_ = NULL;
1620         gchar* _tmp199_;
1621         GeeList* _tmp200_;
1622         gpointer _tmp201_ = NULL;
1623         gchar* _tmp202_;
1624         g_return_if_fail (self != NULL);
1625         _tmp0_ = ((CollectionTests*) self)->test_collection;
1626         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
1627         test_list = _tmp1_;
1628         _tmp2_ = test_list;
1629         _vala_assert (_tmp2_ != NULL, "test_list != null");
1630         _tmp3_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);
1631         dummy = _tmp3_;
1632         _tmp4_ = test_list;
1633         _tmp5_ = gee_collection_add ((GeeCollection*) _tmp4_, "zero");
1634         _vala_assert (_tmp5_, "test_list.add (\"zero\")");
1635         _tmp6_ = test_list;
1636         _tmp7_ = gee_collection_add ((GeeCollection*) _tmp6_, "one");
1637         _vala_assert (_tmp7_, "test_list.add (\"one\")");
1638         _tmp8_ = test_list;
1639         _tmp9_ = gee_collection_add ((GeeCollection*) _tmp8_, "two");
1640         _vala_assert (_tmp9_, "test_list.add (\"two\")");
1641         _tmp10_ = test_list;
1642         _tmp11_ = gee_collection_get_size ((GeeCollection*) _tmp10_);
1643         _tmp12_ = _tmp11_;
1644         _vala_assert (_tmp12_ == 3, "test_list.size == 3");
1645         _tmp13_ = dummy;
1646         _tmp14_ = gee_collection_get_is_empty ((GeeCollection*) _tmp13_);
1647         _tmp15_ = _tmp14_;
1648         _vala_assert (_tmp15_, "dummy.is_empty");
1649         _tmp16_ = test_list;
1650         _tmp17_ = dummy;
1651         gee_list_insert_all (_tmp16_, 0, (GeeCollection*) _tmp17_);
1652         _tmp18_ = test_list;
1653         _tmp19_ = gee_collection_get_size ((GeeCollection*) _tmp18_);
1654         _tmp20_ = _tmp19_;
1655         _vala_assert (_tmp20_ == 3, "test_list.size == 3");
1656         _tmp21_ = dummy;
1657         _tmp22_ = gee_collection_get_is_empty ((GeeCollection*) _tmp21_);
1658         _tmp23_ = _tmp22_;
1659         _vala_assert (_tmp23_, "dummy.is_empty");
1660         _tmp24_ = test_list;
1661         gee_collection_clear ((GeeCollection*) _tmp24_);
1662         _tmp25_ = dummy;
1663         gee_abstract_collection_clear ((GeeAbstractCollection*) _tmp25_);
1664         _tmp26_ = dummy;
1665         _tmp27_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp26_, "zero");
1666         _vala_assert (_tmp27_, "dummy.add (\"zero\")");
1667         _tmp28_ = dummy;
1668         _tmp29_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp28_, "one");
1669         _vala_assert (_tmp29_, "dummy.add (\"one\")");
1670         _tmp30_ = dummy;
1671         _tmp31_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp30_, "two");
1672         _vala_assert (_tmp31_, "dummy.add (\"two\")");
1673         _tmp32_ = test_list;
1674         _tmp33_ = gee_collection_get_is_empty ((GeeCollection*) _tmp32_);
1675         _tmp34_ = _tmp33_;
1676         _vala_assert (_tmp34_, "test_list.is_empty");
1677         _tmp35_ = dummy;
1678         _tmp36_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp35_);
1679         _tmp37_ = _tmp36_;
1680         _vala_assert (_tmp37_ == 3, "dummy.size == 3");
1681         _tmp38_ = test_list;
1682         _tmp39_ = dummy;
1683         gee_list_insert_all (_tmp38_, 0, (GeeCollection*) _tmp39_);
1684         _tmp40_ = test_list;
1685         _tmp41_ = gee_collection_get_size ((GeeCollection*) _tmp40_);
1686         _tmp42_ = _tmp41_;
1687         _vala_assert (_tmp42_ == 3, "test_list.size == 3");
1688         _tmp43_ = dummy;
1689         _tmp44_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp43_);
1690         _tmp45_ = _tmp44_;
1691         _vala_assert (_tmp45_ == 3, "dummy.size == 3");
1692         _tmp46_ = test_list;
1693         gee_collection_clear ((GeeCollection*) _tmp46_);
1694         _tmp47_ = dummy;
1695         gee_abstract_collection_clear ((GeeAbstractCollection*) _tmp47_);
1696         _tmp48_ = dummy;
1697         _tmp49_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp48_, "zero");
1698         _vala_assert (_tmp49_, "dummy.add (\"zero\")");
1699         _tmp50_ = dummy;
1700         _tmp51_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp50_, "one");
1701         _vala_assert (_tmp51_, "dummy.add (\"one\")");
1702         _tmp52_ = dummy;
1703         _tmp53_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp52_, "two");
1704         _vala_assert (_tmp53_, "dummy.add (\"two\")");
1705         _tmp54_ = test_list;
1706         _tmp55_ = gee_collection_get_is_empty ((GeeCollection*) _tmp54_);
1707         _tmp56_ = _tmp55_;
1708         _vala_assert (_tmp56_, "test_list.is_empty");
1709         _tmp57_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1710         if (_tmp57_) {
1711                 GeeList* _tmp58_;
1712                 GeeArrayList* _tmp59_;
1713                 _tmp58_ = test_list;
1714                 _tmp59_ = dummy;
1715                 gee_list_insert_all (_tmp58_, 1, (GeeCollection*) _tmp59_);
1716                 exit (0);
1717         }
1718         g_test_trap_assert_failed ();
1719         _tmp60_ = test_list;
1720         gee_collection_clear ((GeeCollection*) _tmp60_);
1721         _tmp61_ = dummy;
1722         gee_abstract_collection_clear ((GeeAbstractCollection*) _tmp61_);
1723         _tmp62_ = test_list;
1724         _tmp63_ = gee_collection_add ((GeeCollection*) _tmp62_, "three");
1725         _vala_assert (_tmp63_, "test_list.add (\"three\")");
1726         _tmp64_ = test_list;
1727         _tmp65_ = gee_collection_add ((GeeCollection*) _tmp64_, "four");
1728         _vala_assert (_tmp65_, "test_list.add (\"four\")");
1729         _tmp66_ = test_list;
1730         _tmp67_ = gee_collection_add ((GeeCollection*) _tmp66_, "five");
1731         _vala_assert (_tmp67_, "test_list.add (\"five\")");
1732         _tmp68_ = dummy;
1733         _tmp69_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp68_, "zero");
1734         _vala_assert (_tmp69_, "dummy.add (\"zero\")");
1735         _tmp70_ = dummy;
1736         _tmp71_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp70_, "one");
1737         _vala_assert (_tmp71_, "dummy.add (\"one\")");
1738         _tmp72_ = dummy;
1739         _tmp73_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp72_, "two");
1740         _vala_assert (_tmp73_, "dummy.add (\"two\")");
1741         _tmp74_ = test_list;
1742         _tmp75_ = gee_collection_get_size ((GeeCollection*) _tmp74_);
1743         _tmp76_ = _tmp75_;
1744         _vala_assert (_tmp76_ == 3, "test_list.size == 3");
1745         _tmp77_ = dummy;
1746         _tmp78_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp77_);
1747         _tmp79_ = _tmp78_;
1748         _vala_assert (_tmp79_ == 3, "dummy.size == 3");
1749         _tmp80_ = test_list;
1750         _tmp81_ = dummy;
1751         gee_list_insert_all (_tmp80_, 0, (GeeCollection*) _tmp81_);
1752         _tmp82_ = test_list;
1753         _tmp83_ = gee_collection_get_size ((GeeCollection*) _tmp82_);
1754         _tmp84_ = _tmp83_;
1755         _vala_assert (_tmp84_ == 6, "test_list.size == 6");
1756         _tmp85_ = dummy;
1757         _tmp86_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp85_);
1758         _tmp87_ = _tmp86_;
1759         _vala_assert (_tmp87_ == 3, "dummy.size == 3");
1760         _tmp88_ = test_list;
1761         _tmp89_ = gee_list_get (_tmp88_, 0);
1762         _tmp90_ = (gchar*) _tmp89_;
1763         _vala_assert (g_strcmp0 (_tmp90_, "zero") == 0, "test_list.get (0) == \"zero\"");
1764         _g_free0 (_tmp90_);
1765         _tmp91_ = test_list;
1766         _tmp92_ = gee_list_get (_tmp91_, 1);
1767         _tmp93_ = (gchar*) _tmp92_;
1768         _vala_assert (g_strcmp0 (_tmp93_, "one") == 0, "test_list.get (1) == \"one\"");
1769         _g_free0 (_tmp93_);
1770         _tmp94_ = test_list;
1771         _tmp95_ = gee_list_get (_tmp94_, 2);
1772         _tmp96_ = (gchar*) _tmp95_;
1773         _vala_assert (g_strcmp0 (_tmp96_, "two") == 0, "test_list.get (2) == \"two\"");
1774         _g_free0 (_tmp96_);
1775         _tmp97_ = test_list;
1776         _tmp98_ = gee_list_get (_tmp97_, 3);
1777         _tmp99_ = (gchar*) _tmp98_;
1778         _vala_assert (g_strcmp0 (_tmp99_, "three") == 0, "test_list.get (3) == \"three\"");
1779         _g_free0 (_tmp99_);
1780         _tmp100_ = test_list;
1781         _tmp101_ = gee_list_get (_tmp100_, 4);
1782         _tmp102_ = (gchar*) _tmp101_;
1783         _vala_assert (g_strcmp0 (_tmp102_, "four") == 0, "test_list.get (4) == \"four\"");
1784         _g_free0 (_tmp102_);
1785         _tmp103_ = test_list;
1786         _tmp104_ = gee_list_get (_tmp103_, 5);
1787         _tmp105_ = (gchar*) _tmp104_;
1788         _vala_assert (g_strcmp0 (_tmp105_, "five") == 0, "test_list.get (5) == \"five\"");
1789         _g_free0 (_tmp105_);
1790         _tmp106_ = test_list;
1791         gee_collection_clear ((GeeCollection*) _tmp106_);
1792         _tmp107_ = dummy;
1793         gee_abstract_collection_clear ((GeeAbstractCollection*) _tmp107_);
1794         _tmp108_ = test_list;
1795         _tmp109_ = gee_collection_add ((GeeCollection*) _tmp108_, "zero");
1796         _vala_assert (_tmp109_, "test_list.add (\"zero\")");
1797         _tmp110_ = test_list;
1798         _tmp111_ = gee_collection_add ((GeeCollection*) _tmp110_, "one");
1799         _vala_assert (_tmp111_, "test_list.add (\"one\")");
1800         _tmp112_ = test_list;
1801         _tmp113_ = gee_collection_add ((GeeCollection*) _tmp112_, "five");
1802         _vala_assert (_tmp113_, "test_list.add (\"five\")");
1803         _tmp114_ = test_list;
1804         _tmp115_ = gee_collection_add ((GeeCollection*) _tmp114_, "six");
1805         _vala_assert (_tmp115_, "test_list.add (\"six\")");
1806         _tmp116_ = dummy;
1807         _tmp117_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp116_, "two");
1808         _vala_assert (_tmp117_, "dummy.add (\"two\")");
1809         _tmp118_ = dummy;
1810         _tmp119_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp118_, "three");
1811         _vala_assert (_tmp119_, "dummy.add (\"three\")");
1812         _tmp120_ = dummy;
1813         _tmp121_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp120_, "four");
1814         _vala_assert (_tmp121_, "dummy.add (\"four\")");
1815         _tmp122_ = test_list;
1816         _tmp123_ = gee_collection_get_size ((GeeCollection*) _tmp122_);
1817         _tmp124_ = _tmp123_;
1818         _vala_assert (_tmp124_ == 4, "test_list.size == 4");
1819         _tmp125_ = dummy;
1820         _tmp126_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp125_);
1821         _tmp127_ = _tmp126_;
1822         _vala_assert (_tmp127_ == 3, "dummy.size == 3");
1823         _tmp128_ = test_list;
1824         _tmp129_ = dummy;
1825         gee_list_insert_all (_tmp128_, 2, (GeeCollection*) _tmp129_);
1826         _tmp130_ = test_list;
1827         _tmp131_ = gee_collection_get_size ((GeeCollection*) _tmp130_);
1828         _tmp132_ = _tmp131_;
1829         _vala_assert (_tmp132_ == 7, "test_list.size == 7");
1830         _tmp133_ = dummy;
1831         _tmp134_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp133_);
1832         _tmp135_ = _tmp134_;
1833         _vala_assert (_tmp135_ == 3, "dummy.size == 3");
1834         _tmp136_ = test_list;
1835         _tmp137_ = gee_list_get (_tmp136_, 0);
1836         _tmp138_ = (gchar*) _tmp137_;
1837         _vala_assert (g_strcmp0 (_tmp138_, "zero") == 0, "test_list.get (0) == \"zero\"");
1838         _g_free0 (_tmp138_);
1839         _tmp139_ = test_list;
1840         _tmp140_ = gee_list_get (_tmp139_, 1);
1841         _tmp141_ = (gchar*) _tmp140_;
1842         _vala_assert (g_strcmp0 (_tmp141_, "one") == 0, "test_list.get (1) == \"one\"");
1843         _g_free0 (_tmp141_);
1844         _tmp142_ = test_list;
1845         _tmp143_ = gee_list_get (_tmp142_, 2);
1846         _tmp144_ = (gchar*) _tmp143_;
1847         _vala_assert (g_strcmp0 (_tmp144_, "two") == 0, "test_list.get (2) == \"two\"");
1848         _g_free0 (_tmp144_);
1849         _tmp145_ = test_list;
1850         _tmp146_ = gee_list_get (_tmp145_, 3);
1851         _tmp147_ = (gchar*) _tmp146_;
1852         _vala_assert (g_strcmp0 (_tmp147_, "three") == 0, "test_list.get (3) == \"three\"");
1853         _g_free0 (_tmp147_);
1854         _tmp148_ = test_list;
1855         _tmp149_ = gee_list_get (_tmp148_, 4);
1856         _tmp150_ = (gchar*) _tmp149_;
1857         _vala_assert (g_strcmp0 (_tmp150_, "four") == 0, "test_list.get (4) == \"four\"");
1858         _g_free0 (_tmp150_);
1859         _tmp151_ = test_list;
1860         _tmp152_ = gee_list_get (_tmp151_, 5);
1861         _tmp153_ = (gchar*) _tmp152_;
1862         _vala_assert (g_strcmp0 (_tmp153_, "five") == 0, "test_list.get (5) == \"five\"");
1863         _g_free0 (_tmp153_);
1864         _tmp154_ = test_list;
1865         _tmp155_ = gee_list_get (_tmp154_, 6);
1866         _tmp156_ = (gchar*) _tmp155_;
1867         _vala_assert (g_strcmp0 (_tmp156_, "six") == 0, "test_list.get (6) == \"six\"");
1868         _g_free0 (_tmp156_);
1869         _tmp157_ = test_list;
1870         gee_collection_clear ((GeeCollection*) _tmp157_);
1871         _tmp158_ = dummy;
1872         gee_abstract_collection_clear ((GeeAbstractCollection*) _tmp158_);
1873         _tmp159_ = test_list;
1874         _tmp160_ = gee_collection_add ((GeeCollection*) _tmp159_, "zero");
1875         _vala_assert (_tmp160_, "test_list.add (\"zero\")");
1876         _tmp161_ = test_list;
1877         _tmp162_ = gee_collection_add ((GeeCollection*) _tmp161_, "one");
1878         _vala_assert (_tmp162_, "test_list.add (\"one\")");
1879         _tmp163_ = test_list;
1880         _tmp164_ = gee_collection_add ((GeeCollection*) _tmp163_, "two");
1881         _vala_assert (_tmp164_, "test_list.add (\"two\")");
1882         _tmp165_ = dummy;
1883         _tmp166_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp165_, "three");
1884         _vala_assert (_tmp166_, "dummy.add (\"three\")");
1885         _tmp167_ = dummy;
1886         _tmp168_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp167_, "four");
1887         _vala_assert (_tmp168_, "dummy.add (\"four\")");
1888         _tmp169_ = dummy;
1889         _tmp170_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp169_, "five");
1890         _vala_assert (_tmp170_, "dummy.add (\"five\")");
1891         _tmp171_ = test_list;
1892         _tmp172_ = gee_collection_get_size ((GeeCollection*) _tmp171_);
1893         _tmp173_ = _tmp172_;
1894         _vala_assert (_tmp173_ == 3, "test_list.size == 3");
1895         _tmp174_ = dummy;
1896         _tmp175_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp174_);
1897         _tmp176_ = _tmp175_;
1898         _vala_assert (_tmp176_ == 3, "dummy.size == 3");
1899         _tmp177_ = test_list;
1900         _tmp178_ = dummy;
1901         gee_list_insert_all (_tmp177_, 3, (GeeCollection*) _tmp178_);
1902         _tmp179_ = test_list;
1903         _tmp180_ = gee_collection_get_size ((GeeCollection*) _tmp179_);
1904         _tmp181_ = _tmp180_;
1905         _vala_assert (_tmp181_ == 6, "test_list.size == 6");
1906         _tmp182_ = dummy;
1907         _tmp183_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp182_);
1908         _tmp184_ = _tmp183_;
1909         _vala_assert (_tmp184_ == 3, "dummy.size == 3");
1910         _tmp185_ = test_list;
1911         _tmp186_ = gee_list_get (_tmp185_, 0);
1912         _tmp187_ = (gchar*) _tmp186_;
1913         _vala_assert (g_strcmp0 (_tmp187_, "zero") == 0, "test_list.get (0) == \"zero\"");
1914         _g_free0 (_tmp187_);
1915         _tmp188_ = test_list;
1916         _tmp189_ = gee_list_get (_tmp188_, 1);
1917         _tmp190_ = (gchar*) _tmp189_;
1918         _vala_assert (g_strcmp0 (_tmp190_, "one") == 0, "test_list.get (1) == \"one\"");
1919         _g_free0 (_tmp190_);
1920         _tmp191_ = test_list;
1921         _tmp192_ = gee_list_get (_tmp191_, 2);
1922         _tmp193_ = (gchar*) _tmp192_;
1923         _vala_assert (g_strcmp0 (_tmp193_, "two") == 0, "test_list.get (2) == \"two\"");
1924         _g_free0 (_tmp193_);
1925         _tmp194_ = test_list;
1926         _tmp195_ = gee_list_get (_tmp194_, 3);
1927         _tmp196_ = (gchar*) _tmp195_;
1928         _vala_assert (g_strcmp0 (_tmp196_, "three") == 0, "test_list.get (3) == \"three\"");
1929         _g_free0 (_tmp196_);
1930         _tmp197_ = test_list;
1931         _tmp198_ = gee_list_get (_tmp197_, 4);
1932         _tmp199_ = (gchar*) _tmp198_;
1933         _vala_assert (g_strcmp0 (_tmp199_, "four") == 0, "test_list.get (4) == \"four\"");
1934         _g_free0 (_tmp199_);
1935         _tmp200_ = test_list;
1936         _tmp201_ = gee_list_get (_tmp200_, 5);
1937         _tmp202_ = (gchar*) _tmp201_;
1938         _vala_assert (g_strcmp0 (_tmp202_, "five") == 0, "test_list.get (5) == \"five\"");
1939         _g_free0 (_tmp202_);
1940         _g_object_unref0 (dummy);
1941         _g_object_unref0 (test_list);
1942 }
1943
1944
1945 void list_tests_test_slice (ListTests* self) {
1946         GeeCollection* _tmp0_;
1947         GeeList* _tmp1_;
1948         GeeList* test_list;
1949         GeeList* _tmp2_;
1950         GeeList* dummy = NULL;
1951         gboolean _tmp3_ = FALSE;
1952         GeeList* _tmp6_;
1953         gboolean _tmp7_ = FALSE;
1954         GeeList* _tmp8_;
1955         gboolean _tmp9_ = FALSE;
1956         GeeList* _tmp10_;
1957         gboolean _tmp11_ = FALSE;
1958         GeeList* _tmp12_;
1959         gboolean _tmp13_ = FALSE;
1960         GeeList* _tmp14_;
1961         gboolean _tmp15_ = FALSE;
1962         GeeList* _tmp16_;
1963         gboolean _tmp17_ = FALSE;
1964         GeeList* _tmp18_;
1965         gint _tmp19_;
1966         gint _tmp20_;
1967         GeeList* _tmp21_;
1968         GeeList* _tmp22_ = NULL;
1969         GeeList* _tmp23_;
1970         gint _tmp24_;
1971         gint _tmp25_;
1972         GeeList* _tmp26_;
1973         gint _tmp27_;
1974         gint _tmp28_;
1975         GeeList* _tmp29_;
1976         gpointer _tmp30_ = NULL;
1977         gchar* _tmp31_;
1978         GeeList* _tmp32_;
1979         gpointer _tmp33_ = NULL;
1980         gchar* _tmp34_;
1981         GeeList* _tmp35_;
1982         gpointer _tmp36_ = NULL;
1983         gchar* _tmp37_;
1984         gboolean _tmp38_ = FALSE;
1985         g_return_if_fail (self != NULL);
1986         _tmp0_ = ((CollectionTests*) self)->test_collection;
1987         _tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, GEE_TYPE_LIST) ? ((GeeList*) _tmp0_) : NULL);
1988         test_list = _tmp1_;
1989         _tmp2_ = test_list;
1990         _vala_assert (_tmp2_ != NULL, "test_list != null");
1991         _tmp3_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
1992         if (_tmp3_) {
1993                 GeeList* _tmp4_;
1994                 GeeList* _tmp5_ = NULL;
1995                 _tmp4_ = test_list;
1996                 _tmp5_ = gee_list_slice (_tmp4_, 1, 4);
1997                 _g_object_unref0 (dummy);
1998                 dummy = _tmp5_;
1999                 exit (0);
2000         }
2001         g_test_trap_assert_failed ();
2002         _tmp6_ = test_list;
2003         _tmp7_ = gee_collection_add ((GeeCollection*) _tmp6_, "zero");
2004         _vala_assert (_tmp7_, "test_list.add (\"zero\")");
2005         _tmp8_ = test_list;
2006         _tmp9_ = gee_collection_add ((GeeCollection*) _tmp8_, "one");
2007         _vala_assert (_tmp9_, "test_list.add (\"one\")");
2008         _tmp10_ = test_list;
2009         _tmp11_ = gee_collection_add ((GeeCollection*) _tmp10_, "two");
2010         _vala_assert (_tmp11_, "test_list.add (\"two\")");
2011         _tmp12_ = test_list;
2012         _tmp13_ = gee_collection_add ((GeeCollection*) _tmp12_, "three");
2013         _vala_assert (_tmp13_, "test_list.add (\"three\")");
2014         _tmp14_ = test_list;
2015         _tmp15_ = gee_collection_add ((GeeCollection*) _tmp14_, "four");
2016         _vala_assert (_tmp15_, "test_list.add (\"four\")");
2017         _tmp16_ = test_list;
2018         _tmp17_ = gee_collection_add ((GeeCollection*) _tmp16_, "five");
2019         _vala_assert (_tmp17_, "test_list.add (\"five\")");
2020         _tmp18_ = test_list;
2021         _tmp19_ = gee_collection_get_size ((GeeCollection*) _tmp18_);
2022         _tmp20_ = _tmp19_;
2023         _vala_assert (_tmp20_ == 6, "test_list.size == 6");
2024         _tmp21_ = test_list;
2025         _tmp22_ = gee_list_slice (_tmp21_, 1, 4);
2026         _g_object_unref0 (dummy);
2027         dummy = _tmp22_;
2028         _tmp23_ = dummy;
2029         _tmp24_ = gee_collection_get_size ((GeeCollection*) _tmp23_);
2030         _tmp25_ = _tmp24_;
2031         _vala_assert (_tmp25_ == 3, "dummy.size == 3");
2032         _tmp26_ = test_list;
2033         _tmp27_ = gee_collection_get_size ((GeeCollection*) _tmp26_);
2034         _tmp28_ = _tmp27_;
2035         _vala_assert (_tmp28_ == 6, "test_list.size == 6");
2036         _tmp29_ = dummy;
2037         _tmp30_ = gee_list_get (_tmp29_, 0);
2038         _tmp31_ = (gchar*) _tmp30_;
2039         _vala_assert (g_strcmp0 (_tmp31_, "one") == 0, "dummy.get (0) == \"one\"");
2040         _g_free0 (_tmp31_);
2041         _tmp32_ = dummy;
2042         _tmp33_ = gee_list_get (_tmp32_, 1);
2043         _tmp34_ = (gchar*) _tmp33_;
2044         _vala_assert (g_strcmp0 (_tmp34_, "two") == 0, "dummy.get (1) == \"two\"");
2045         _g_free0 (_tmp34_);
2046         _tmp35_ = dummy;
2047         _tmp36_ = gee_list_get (_tmp35_, 2);
2048         _tmp37_ = (gchar*) _tmp36_;
2049         _vala_assert (g_strcmp0 (_tmp37_, "three") == 0, "dummy.get (2) == \"three\"");
2050         _g_free0 (_tmp37_);
2051         _tmp38_ = g_test_trap_fork ((guint64) 0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR);
2052         if (_tmp38_) {
2053                 GeeList* _tmp39_;
2054                 GeeList* _tmp40_ = NULL;
2055                 _tmp39_ = test_list;
2056                 _tmp40_ = gee_list_slice (_tmp39_, 0, 9);
2057                 _g_object_unref0 (dummy);
2058                 dummy = _tmp40_;
2059                 exit (0);
2060         }
2061         g_test_trap_assert_failed ();
2062         _g_object_unref0 (dummy);
2063         _g_object_unref0 (test_list);
2064 }
2065
2066
2067 static void list_tests_class_init (ListTestsClass * klass) {
2068         list_tests_parent_class = g_type_class_peek_parent (klass);
2069         LIST_TESTS_CLASS (klass)->test_duplicates_are_retained = list_tests_real_test_duplicates_are_retained;
2070 }
2071
2072
2073 static void list_tests_instance_init (ListTests * self) {
2074 }
2075
2076
2077 GType list_tests_get_type (void) {
2078         static volatile gsize list_tests_type_id__volatile = 0;
2079         if (g_once_init_enter (&list_tests_type_id__volatile)) {
2080                 static const GTypeInfo g_define_type_info = { sizeof (ListTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) list_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ListTests), 0, (GInstanceInitFunc) list_tests_instance_init, NULL };
2081                 GType list_tests_type_id;
2082                 list_tests_type_id = g_type_register_static (TYPE_COLLECTION_TESTS, "ListTests", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
2083                 g_once_init_leave (&list_tests_type_id__volatile, list_tests_type_id);
2084         }
2085         return list_tests_type_id__volatile;
2086 }
2087
2088
2089