git.maemo.org Git - fillmore/blob - src/test/debug/ProjectLoading.c

   1 /* ProjectLoading.c generated by valac, the Vala compiler
   2  * generated from ProjectLoading.vala, do not modify */
   3
   4 /* Copyright 2009 Yorba Foundation
   5  *
   6  * This software is licensed under the GNU Lesser General Public License
   7  * (version 2.1 or later).  See the COPYING file in this distribution.
   8  */
   9
  10 #include <glib.h>
  11 #include <glib-object.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <gobject/gvaluecollector.h>
  15
  16
  17 #define MODEL_TYPE_CLIP_FETCHER (model_clip_fetcher_get_type ())
  18 #define MODEL_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcher))
  19 #define MODEL_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass))
  20 #define MODEL_IS_CLIP_FETCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FETCHER))
  21 #define MODEL_IS_CLIP_FETCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FETCHER))
  22 #define MODEL_CLIP_FETCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherClass))
  23
  24 typedef struct _ModelClipFetcher ModelClipFetcher;
  25 typedef struct _ModelClipFetcherClass ModelClipFetcherClass;
  26 typedef struct _ModelClipFetcherPrivate ModelClipFetcherPrivate;
  27
  28 #define MODEL_TYPE_CLIP_FILE (model_clip_file_get_type ())
  29 #define MODEL_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFile))
  30 #define MODEL_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  31 #define MODEL_IS_CLIP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_CLIP_FILE))
  32 #define MODEL_IS_CLIP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_CLIP_FILE))
  33 #define MODEL_CLIP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_CLIP_FILE, ModelClipFileClass))
  34
  35 typedef struct _ModelClipFile ModelClipFile;
  36 typedef struct _ModelClipFileClass ModelClipFileClass;
  37 #define _g_free0(var) (var = (g_free (var), NULL))
  38 #define _model_clip_file_unref0(var) ((var == NULL) ? NULL : (var = (model_clip_file_unref (var), NULL)))
  39 typedef struct _ModelParamSpecClipFetcher ModelParamSpecClipFetcher;
  40 typedef struct _ModelClipFilePrivate ModelClipFilePrivate;
  41 typedef struct _ModelParamSpecClipFile ModelParamSpecClipFile;
  42
  43 #define TYPE_VALID_DOCUMENT (valid_document_get_type ())
  44 typedef struct _ValidDocument ValidDocument;
  45
  46 #define TYPE_STATE_CHANGE_FIXTURE (state_change_fixture_get_type ())
  47
  48 #define MODEL_TYPE_XML_ELEMENT (model_xml_element_get_type ())
  49 #define MODEL_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElement))
  50 #define MODEL_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass))
  51 #define MODEL_IS_XML_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_ELEMENT))
  52 #define MODEL_IS_XML_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_ELEMENT))
  53 #define MODEL_XML_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_ELEMENT, ModelXmlElementClass))
  54
  55 typedef struct _ModelXmlElement ModelXmlElement;
  56 typedef struct _ModelXmlElementClass ModelXmlElementClass;
  57
  58 #define MODEL_TYPE_PROJECT_BUILDER (model_project_builder_get_type ())
  59 #define MODEL_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilder))
  60 #define MODEL_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass))
  61 #define MODEL_IS_PROJECT_BUILDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_PROJECT_BUILDER))
  62 #define MODEL_IS_PROJECT_BUILDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_PROJECT_BUILDER))
  63 #define MODEL_PROJECT_BUILDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_PROJECT_BUILDER, ModelProjectBuilderClass))
  64
  65 typedef struct _ModelProjectBuilder ModelProjectBuilder;
  66 typedef struct _ModelProjectBuilderClass ModelProjectBuilderClass;
  67 typedef struct _StateChangeFixture StateChangeFixture;
  68 #define _model_xml_element_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_element_unref (var), NULL)))
  69 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  70
  71 #define MODEL_TYPE_XML_TREE_LOADER (model_xml_tree_loader_get_type ())
  72 #define MODEL_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoader))
  73 #define MODEL_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass))
  74 #define MODEL_IS_XML_TREE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_XML_TREE_LOADER))
  75 #define MODEL_IS_XML_TREE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_XML_TREE_LOADER))
  76 #define MODEL_XML_TREE_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_XML_TREE_LOADER, ModelXmlTreeLoaderClass))
  77
  78 typedef struct _ModelXmlTreeLoader ModelXmlTreeLoader;
  79 typedef struct _ModelXmlTreeLoaderClass ModelXmlTreeLoaderClass;
  80 typedef struct _ModelXmlTreeLoaderPrivate ModelXmlTreeLoaderPrivate;
  81
  82 #define MODEL_TYPE_LOADER_HANDLER (model_loader_handler_get_type ())
  83 #define MODEL_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandler))
  84 #define MODEL_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass))
  85 #define MODEL_IS_LOADER_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_LOADER_HANDLER))
  86 #define MODEL_IS_LOADER_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_LOADER_HANDLER))
  87 #define MODEL_LOADER_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_LOADER_HANDLER, ModelLoaderHandlerClass))
  88
  89 typedef struct _ModelLoaderHandler ModelLoaderHandler;
  90 typedef struct _ModelLoaderHandlerClass ModelLoaderHandlerClass;
  91 #define _model_xml_tree_loader_unref0(var) ((var == NULL) ? NULL : (var = (model_xml_tree_loader_unref (var), NULL)))
  92 typedef GTestSuite ProjectLoaderSuite;
  93
  94 struct _ModelClipFetcher {
  95         GTypeInstance parent_instance;
  96         volatile int ref_count;
  97         ModelClipFetcherPrivate * priv;
  98         char* error_string;
  99         ModelClipFile* clipfile;
 100 };
 101
 102 struct _ModelClipFetcherClass {
 103         GTypeClass parent_class;
 104         void (*finalize) (ModelClipFetcher *self);
 105 };
 106
 107 struct _ModelClipFetcherPrivate {
 108         char* filename;
 109 };
 110
 111 struct _ModelParamSpecClipFetcher {
 112         GParamSpec parent_instance;
 113 };
 114
 115 struct _ModelClipFile {
 116         GTypeInstance parent_instance;
 117         volatile int ref_count;
 118         ModelClipFilePrivate * priv;
 119         char* filename;
 120 };
 121
 122 struct _ModelClipFileClass {
 123         GTypeClass parent_class;
 124         void (*finalize) (ModelClipFile *self);
 125 };
 126
 127 struct _ModelParamSpecClipFile {
 128         GParamSpec parent_instance;
 129 };
 130
 131 struct _ValidDocument {
 132         gboolean valid;
 133         char* document;
 134 };
 135
 136 struct _StateChangeFixture {
 137         ModelXmlElement* root;
 138         ModelProjectBuilder* project_builder;
 139         gboolean valid;
 140 };
 141
 142 struct _ModelXmlTreeLoader {
 143         GTypeInstance parent_instance;
 144         volatile int ref_count;
 145         ModelXmlTreeLoaderPrivate * priv;
 146         ModelXmlElement* root;
 147 };
 148
 149 struct _ModelXmlTreeLoaderClass {
 150         GTypeClass parent_class;
 151         void (*finalize) (ModelXmlTreeLoader *self);
 152 };
 153
 154
 155 static gpointer model_clip_fetcher_parent_class = NULL;
 156 static gpointer model_clip_file_parent_class = NULL;
 157 extern ValidDocument* project_documents;
 158 extern gint project_documents_length1;
 159 ValidDocument* project_documents = NULL;
 160 gint project_documents_length1 = 0;
 161 static gint _project_documents_size_ = 0;
 162 extern gint current_document;
 163 gint current_document = 0;
 164 extern gboolean document_valid;
 165 gboolean document_valid = FALSE;
 166
 167 gpointer model_clip_fetcher_ref (gpointer instance);
 168 void model_clip_fetcher_unref (gpointer instance);
 169 GParamSpec* model_param_spec_clip_fetcher (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 170 void model_value_set_clip_fetcher (GValue* value, gpointer v_object);
 171 void model_value_take_clip_fetcher (GValue* value, gpointer v_object);
 172 gpointer model_value_get_clip_fetcher (const GValue* value);
 173 GType model_clip_fetcher_get_type (void);
 174 gpointer model_clip_file_ref (gpointer instance);
 175 void model_clip_file_unref (gpointer instance);
 176 GParamSpec* model_param_spec_clip_file (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 177 void model_value_set_clip_file (GValue* value, gpointer v_object);
 178 void model_value_take_clip_file (GValue* value, gpointer v_object);
 179 gpointer model_value_get_clip_file (const GValue* value);
 180 GType model_clip_file_get_type (void);
 181 #define MODEL_CLIP_FETCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_CLIP_FETCHER, ModelClipFetcherPrivate))
 182 enum  {
 183         MODEL_CLIP_FETCHER_DUMMY_PROPERTY
 184 };
 185 ModelClipFetcher* model_clip_fetcher_new (const char* filename);
 186 ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename);
 187 char* model_clip_fetcher_get_filename (ModelClipFetcher* self);
 188 static void model_clip_fetcher_finalize (ModelClipFetcher* obj);
 189 enum  {
 190         MODEL_CLIP_FILE_DUMMY_PROPERTY
 191 };
 192 ModelClipFile* model_clip_file_new (void);
 193 ModelClipFile* model_clip_file_construct (GType object_type);
 194 static void model_clip_file_finalize (ModelClipFile* obj);
 195 GType valid_document_get_type (void);
 196 ValidDocument* valid_document_dup (const ValidDocument* self);
 197 void valid_document_free (ValidDocument* self);
 198 void valid_document_copy (const ValidDocument* self, ValidDocument* dest);
 199 void valid_document_destroy (ValidDocument* self);
 200 void valid_document_init (ValidDocument *self, gboolean valid, const char* document);
 201 GType state_change_fixture_get_type (void);
 202 gpointer model_xml_element_ref (gpointer instance);
 203 void model_xml_element_unref (gpointer instance);
 204 GParamSpec* model_param_spec_xml_element (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 205 void model_value_set_xml_element (GValue* value, gpointer v_object);
 206 void model_value_take_xml_element (GValue* value, gpointer v_object);
 207 gpointer model_value_get_xml_element (const GValue* value);
 208 GType model_xml_element_get_type (void);
 209 GType model_project_builder_get_type (void);
 210 StateChangeFixture* state_change_fixture_dup (const StateChangeFixture* self);
 211 void state_change_fixture_free (StateChangeFixture* self);
 212 void state_change_fixture_copy (const StateChangeFixture* self, StateChangeFixture* dest);
 213 void state_change_fixture_destroy (StateChangeFixture* self);
 214 ModelXmlTreeLoader* model_xml_tree_loader_new (const char* document);
 215 ModelXmlTreeLoader* model_xml_tree_loader_construct (GType object_type, const char* document);
 216 gpointer model_xml_tree_loader_ref (gpointer instance);
 217 void model_xml_tree_loader_unref (gpointer instance);
 218 GParamSpec* model_param_spec_xml_tree_loader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 219 void model_value_set_xml_tree_loader (GValue* value, gpointer v_object);
 220 void model_value_take_xml_tree_loader (GValue* value, gpointer v_object);
 221 gpointer model_value_get_xml_tree_loader (const GValue* value);
 222 GType model_xml_tree_loader_get_type (void);
 223 ModelLoaderHandler* model_loader_handler_new (void);
 224 ModelLoaderHandler* model_loader_handler_construct (GType object_type);
 225 GType model_loader_handler_get_type (void);
 226 ModelProjectBuilder* model_project_builder_new (ModelLoaderHandler* handler);
 227 ModelProjectBuilder* model_project_builder_construct (GType object_type, ModelLoaderHandler* handler);
 228 void state_change_fixture_buildup (void* fixture);
 229 void state_change_fixture_teardown (void* fixture);
 230 void on_error_occurred (const char* message);
 231 static void _on_error_occurred_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self);
 232 gboolean model_project_builder_check_project (ModelProjectBuilder* self, ModelXmlElement* root);
 233 void model_project_builder_build_project (ModelProjectBuilder* self, ModelXmlElement* root);
 234 void check_document (void* fixture);
 235 static void _vala_ValidDocument_array_free (ValidDocument* array, gint array_length);
 236 static void _state_change_fixture_buildup_gtest_func (void* fixture, gpointer self);
 237 static void _check_document_gtest_func (void* fixture, gpointer self);
 238 static void _state_change_fixture_teardown_gtest_func (void* fixture, gpointer self);
 239 ProjectLoaderSuite* project_loader_suite_new (void);
 240 ProjectLoaderSuite* project_loader_suite_new (void);
 241
 242
 243 static void g_cclosure_user_marshal_VOID__MODEL_CLIP_FETCHER (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 244
 245 #line 14 "ProjectLoading.vala"
 246 ModelClipFetcher* model_clip_fetcher_construct (GType object_type, const char* filename) {
 247 #line 248 "ProjectLoading.c"
 248         ModelClipFetcher* self;
 249         char* _tmp0_;
 250 #line 14 "ProjectLoading.vala"
 251         g_return_val_if_fail (filename != NULL, NULL);
 252 #line 253 "ProjectLoading.c"
 253         self = (ModelClipFetcher*) g_type_create_instance (object_type);
 254 #line 15 "ProjectLoading.vala"
 255         self->priv->filename = (_tmp0_ = g_strdup (filename), _g_free0 (self->priv->filename), _tmp0_);
 256 #line 257 "ProjectLoading.c"
 257         return self;
 258 }
 259
 260
 261 #line 14 "ProjectLoading.vala"
 262 ModelClipFetcher* model_clip_fetcher_new (const char* filename) {
 263 #line 14 "ProjectLoading.vala"
 264         return model_clip_fetcher_construct (MODEL_TYPE_CLIP_FETCHER, filename);
 265 #line 266 "ProjectLoading.c"
 266 }
 267
 268
 269 #line 17 "ProjectLoading.vala"
 270 char* model_clip_fetcher_get_filename (ModelClipFetcher* self) {
 271 #line 272 "ProjectLoading.c"
 272         char* result = NULL;
 273 #line 17 "ProjectLoading.vala"
 274         g_return_val_if_fail (MODEL_IS_CLIP_FETCHER (self), NULL);
 275 #line 276 "ProjectLoading.c"
 276         result = g_strdup (self->priv->filename);
 277 #line 18 "ProjectLoading.vala"
 278         return result;
 279 #line 280 "ProjectLoading.c"
 280 }
 281
 282
 283 static void model_value_clip_fetcher_init (GValue* value) {
 284         value->data[0].v_pointer = NULL;
 285 }
 286
 287
 288 static void model_value_clip_fetcher_free_value (GValue* value) {
 289         if (value->data[0].v_pointer) {
 290                 model_clip_fetcher_unref (value->data[0].v_pointer);
 291         }
 292 }
 293
 294
 295 static void model_value_clip_fetcher_copy_value (const GValue* src_value, GValue* dest_value) {
 296         if (src_value->data[0].v_pointer) {
 297                 dest_value->data[0].v_pointer = model_clip_fetcher_ref (src_value->data[0].v_pointer);
 298         } else {
 299                 dest_value->data[0].v_pointer = NULL;
 300         }
 301 }
 302
 303
 304 static gpointer model_value_clip_fetcher_peek_pointer (const GValue* value) {
 305         return value->data[0].v_pointer;
 306 }
 307
 308
 309 static gchar* model_value_clip_fetcher_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 310         if (collect_values[0].v_pointer) {
 311                 ModelClipFetcher* object;
 312                 object = collect_values[0].v_pointer;
 313                 if (object->parent_instance.g_class == NULL) {
 314                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 315                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 316                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 317                 }
 318                 value->data[0].v_pointer = model_clip_fetcher_ref (object);
 319         } else {
 320                 value->data[0].v_pointer = NULL;
 321         }
 322         return NULL;
 323 }
 324
 325
 326 static gchar* model_value_clip_fetcher_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 327         ModelClipFetcher** object_p;
 328         object_p = collect_values[0].v_pointer;
 329         if (!object_p) {
 330                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 331         }
 332         if (!value->data[0].v_pointer) {
 333                 *object_p = NULL;
 334         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
 335                 *object_p = value->data[0].v_pointer;
 336         } else {
 337                 *object_p = model_clip_fetcher_ref (value->data[0].v_pointer);
 338         }
 339         return NULL;
 340 }
 341
 342
 343 GParamSpec* model_param_spec_clip_fetcher (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 344         ModelParamSpecClipFetcher* spec;
 345         g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_CLIP_FETCHER), NULL);
 346         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 347         G_PARAM_SPEC (spec)->value_type = object_type;
 348         return G_PARAM_SPEC (spec);
 349 }
 350
 351
 352 gpointer model_value_get_clip_fetcher (const GValue* value) {
 353         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FETCHER), NULL);
 354         return value->data[0].v_pointer;
 355 }
 356
 357
 358 void model_value_set_clip_fetcher (GValue* value, gpointer v_object) {
 359         ModelClipFetcher* old;
 360         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FETCHER));
 361         old = value->data[0].v_pointer;
 362         if (v_object) {
 363                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_CLIP_FETCHER));
 364                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 365                 value->data[0].v_pointer = v_object;
 366                 model_clip_fetcher_ref (value->data[0].v_pointer);
 367         } else {
 368                 value->data[0].v_pointer = NULL;
 369         }
 370         if (old) {
 371                 model_clip_fetcher_unref (old);
 372         }
 373 }
 374
 375
 376 void model_value_take_clip_fetcher (GValue* value, gpointer v_object) {
 377         ModelClipFetcher* old;
 378         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FETCHER));
 379         old = value->data[0].v_pointer;
 380         if (v_object) {
 381                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_CLIP_FETCHER));
 382                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 383                 value->data[0].v_pointer = v_object;
 384         } else {
 385                 value->data[0].v_pointer = NULL;
 386         }
 387         if (old) {
 388                 model_clip_fetcher_unref (old);
 389         }
 390 }
 391
 392
 393 static void model_clip_fetcher_class_init (ModelClipFetcherClass * klass) {
 394         model_clip_fetcher_parent_class = g_type_class_peek_parent (klass);
 395         MODEL_CLIP_FETCHER_CLASS (klass)->finalize = model_clip_fetcher_finalize;
 396         g_type_class_add_private (klass, sizeof (ModelClipFetcherPrivate));
 397         g_signal_new ("ready", MODEL_TYPE_CLIP_FETCHER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__MODEL_CLIP_FETCHER, G_TYPE_NONE, 1, MODEL_TYPE_CLIP_FETCHER);
 398 }
 399
 400
 401 static void model_clip_fetcher_instance_init (ModelClipFetcher * self) {
 402         self->priv = MODEL_CLIP_FETCHER_GET_PRIVATE (self);
 403         self->ref_count = 1;
 404 }
 405
 406
 407 static void model_clip_fetcher_finalize (ModelClipFetcher* obj) {
 408         ModelClipFetcher * self;
 409         self = MODEL_CLIP_FETCHER (obj);
 410         _g_free0 (self->error_string);
 411         _model_clip_file_unref0 (self->clipfile);
 412         _g_free0 (self->priv->filename);
 413 }
 414
 415
 416 GType model_clip_fetcher_get_type (void) {
 417         static volatile gsize model_clip_fetcher_type_id__volatile = 0;
 418         if (g_once_init_enter (&model_clip_fetcher_type_id__volatile)) {
 419                 static const GTypeValueTable g_define_type_value_table = { model_value_clip_fetcher_init, model_value_clip_fetcher_free_value, model_value_clip_fetcher_copy_value, model_value_clip_fetcher_peek_pointer, "p", model_value_clip_fetcher_collect_value, "p", model_value_clip_fetcher_lcopy_value };
 420                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipFetcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_fetcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFetcher), 0, (GInstanceInitFunc) model_clip_fetcher_instance_init, &g_define_type_value_table };
 421                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 422                 GType model_clip_fetcher_type_id;
 423                 model_clip_fetcher_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelClipFetcher", &g_define_type_info, &g_define_type_fundamental_info, 0);
 424                 g_once_init_leave (&model_clip_fetcher_type_id__volatile, model_clip_fetcher_type_id);
 425         }
 426         return model_clip_fetcher_type_id__volatile;
 427 }
 428
 429
 430 gpointer model_clip_fetcher_ref (gpointer instance) {
 431         ModelClipFetcher* self;
 432         self = instance;
 433         g_atomic_int_inc (&self->ref_count);
 434         return instance;
 435 }
 436
 437
 438 void model_clip_fetcher_unref (gpointer instance) {
 439         ModelClipFetcher* self;
 440         self = instance;
 441         if (g_atomic_int_dec_and_test (&self->ref_count)) {
 442                 MODEL_CLIP_FETCHER_GET_CLASS (self)->finalize (self);
 443                 g_type_free_instance ((GTypeInstance *) self);
 444         }
 445 }
 446
 447
 448 #line 23 "ProjectLoading.vala"
 449 ModelClipFile* model_clip_file_construct (GType object_type) {
 450 #line 451 "ProjectLoading.c"
 451         ModelClipFile* self;
 452         self = (ModelClipFile*) g_type_create_instance (object_type);
 453         return self;
 454 }
 455
 456
 457 #line 23 "ProjectLoading.vala"
 458 ModelClipFile* model_clip_file_new (void) {
 459 #line 23 "ProjectLoading.vala"
 460         return model_clip_file_construct (MODEL_TYPE_CLIP_FILE);
 461 #line 462 "ProjectLoading.c"
 462 }
 463
 464
 465 static void model_value_clip_file_init (GValue* value) {
 466         value->data[0].v_pointer = NULL;
 467 }
 468
 469
 470 static void model_value_clip_file_free_value (GValue* value) {
 471         if (value->data[0].v_pointer) {
 472                 model_clip_file_unref (value->data[0].v_pointer);
 473         }
 474 }
 475
 476
 477 static void model_value_clip_file_copy_value (const GValue* src_value, GValue* dest_value) {
 478         if (src_value->data[0].v_pointer) {
 479                 dest_value->data[0].v_pointer = model_clip_file_ref (src_value->data[0].v_pointer);
 480         } else {
 481                 dest_value->data[0].v_pointer = NULL;
 482         }
 483 }
 484
 485
 486 static gpointer model_value_clip_file_peek_pointer (const GValue* value) {
 487         return value->data[0].v_pointer;
 488 }
 489
 490
 491 static gchar* model_value_clip_file_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 492         if (collect_values[0].v_pointer) {
 493                 ModelClipFile* object;
 494                 object = collect_values[0].v_pointer;
 495                 if (object->parent_instance.g_class == NULL) {
 496                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 497                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 498                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 499                 }
 500                 value->data[0].v_pointer = model_clip_file_ref (object);
 501         } else {
 502                 value->data[0].v_pointer = NULL;
 503         }
 504         return NULL;
 505 }
 506
 507
 508 static gchar* model_value_clip_file_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 509         ModelClipFile** object_p;
 510         object_p = collect_values[0].v_pointer;
 511         if (!object_p) {
 512                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 513         }
 514         if (!value->data[0].v_pointer) {
 515                 *object_p = NULL;
 516         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
 517                 *object_p = value->data[0].v_pointer;
 518         } else {
 519                 *object_p = model_clip_file_ref (value->data[0].v_pointer);
 520         }
 521         return NULL;
 522 }
 523
 524
 525 GParamSpec* model_param_spec_clip_file (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 526         ModelParamSpecClipFile* spec;
 527         g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_CLIP_FILE), NULL);
 528         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 529         G_PARAM_SPEC (spec)->value_type = object_type;
 530         return G_PARAM_SPEC (spec);
 531 }
 532
 533
 534 gpointer model_value_get_clip_file (const GValue* value) {
 535         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FILE), NULL);
 536         return value->data[0].v_pointer;
 537 }
 538
 539
 540 void model_value_set_clip_file (GValue* value, gpointer v_object) {
 541         ModelClipFile* old;
 542         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FILE));
 543         old = value->data[0].v_pointer;
 544         if (v_object) {
 545                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_CLIP_FILE));
 546                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 547                 value->data[0].v_pointer = v_object;
 548                 model_clip_file_ref (value->data[0].v_pointer);
 549         } else {
 550                 value->data[0].v_pointer = NULL;
 551         }
 552         if (old) {
 553                 model_clip_file_unref (old);
 554         }
 555 }
 556
 557
 558 void model_value_take_clip_file (GValue* value, gpointer v_object) {
 559         ModelClipFile* old;
 560         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_CLIP_FILE));
 561         old = value->data[0].v_pointer;
 562         if (v_object) {
 563                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_CLIP_FILE));
 564                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 565                 value->data[0].v_pointer = v_object;
 566         } else {
 567                 value->data[0].v_pointer = NULL;
 568         }
 569         if (old) {
 570                 model_clip_file_unref (old);
 571         }
 572 }
 573
 574
 575 static void model_clip_file_class_init (ModelClipFileClass * klass) {
 576         model_clip_file_parent_class = g_type_class_peek_parent (klass);
 577         MODEL_CLIP_FILE_CLASS (klass)->finalize = model_clip_file_finalize;
 578 }
 579
 580
 581 static void model_clip_file_instance_init (ModelClipFile * self) {
 582         self->ref_count = 1;
 583 }
 584
 585
 586 static void model_clip_file_finalize (ModelClipFile* obj) {
 587         ModelClipFile * self;
 588         self = MODEL_CLIP_FILE (obj);
 589         _g_free0 (self->filename);
 590 }
 591
 592
 593 GType model_clip_file_get_type (void) {
 594         static volatile gsize model_clip_file_type_id__volatile = 0;
 595         if (g_once_init_enter (&model_clip_file_type_id__volatile)) {
 596                 static const GTypeValueTable g_define_type_value_table = { model_value_clip_file_init, model_value_clip_file_free_value, model_value_clip_file_copy_value, model_value_clip_file_peek_pointer, "p", model_value_clip_file_collect_value, "p", model_value_clip_file_lcopy_value };
 597                 static const GTypeInfo g_define_type_info = { sizeof (ModelClipFileClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_clip_file_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelClipFile), 0, (GInstanceInitFunc) model_clip_file_instance_init, &g_define_type_value_table };
 598                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 599                 GType model_clip_file_type_id;
 600                 model_clip_file_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelClipFile", &g_define_type_info, &g_define_type_fundamental_info, 0);
 601                 g_once_init_leave (&model_clip_file_type_id__volatile, model_clip_file_type_id);
 602         }
 603         return model_clip_file_type_id__volatile;
 604 }
 605
 606
 607 gpointer model_clip_file_ref (gpointer instance) {
 608         ModelClipFile* self;
 609         self = instance;
 610         g_atomic_int_inc (&self->ref_count);
 611         return instance;
 612 }
 613
 614
 615 void model_clip_file_unref (gpointer instance) {
 616         ModelClipFile* self;
 617         self = instance;
 618         if (g_atomic_int_dec_and_test (&self->ref_count)) {
 619                 MODEL_CLIP_FILE_GET_CLASS (self)->finalize (self);
 620                 g_type_free_instance ((GTypeInstance *) self);
 621         }
 622 }
 623
 624
 625 #line 32 "ProjectLoading.vala"
 626 void valid_document_init (ValidDocument *self, gboolean valid, const char* document) {
 627 #line 628 "ProjectLoading.c"
 628         char* _tmp0_;
 629 #line 32 "ProjectLoading.vala"
 630         g_return_if_fail (document != NULL);
 631 #line 632 "ProjectLoading.c"
 632         memset (self, 0, sizeof (ValidDocument));
 633 #line 33 "ProjectLoading.vala"
 634         (*self).valid = valid;
 635 #line 34 "ProjectLoading.vala"
 636         (*self).document = (_tmp0_ = g_strdup (document), _g_free0 ((*self).document), _tmp0_);
 637 #line 638 "ProjectLoading.c"
 638 }
 639
 640
 641 void valid_document_copy (const ValidDocument* self, ValidDocument* dest) {
 642         dest->valid = self->valid;
 643         dest->document = g_strdup (self->document);
 644 }
 645
 646
 647 void valid_document_destroy (ValidDocument* self) {
 648         _g_free0 (self->document);
 649 }
 650
 651
 652 ValidDocument* valid_document_dup (const ValidDocument* self) {
 653         ValidDocument* dup;
 654         dup = g_new0 (ValidDocument, 1);
 655         valid_document_copy (self, dup);
 656         return dup;
 657 }
 658
 659
 660 void valid_document_free (ValidDocument* self) {
 661         valid_document_destroy (self);
 662         g_free (self);
 663 }
 664
 665
 666 GType valid_document_get_type (void) {
 667         static volatile gsize valid_document_type_id__volatile = 0;
 668         if (g_once_init_enter (&valid_document_type_id__volatile)) {
 669                 GType valid_document_type_id;
 670                 valid_document_type_id = g_boxed_type_register_static ("ValidDocument", (GBoxedCopyFunc) valid_document_dup, (GBoxedFreeFunc) valid_document_free);
 671                 g_once_init_leave (&valid_document_type_id__volatile, valid_document_type_id);
 672         }
 673         return valid_document_type_id__volatile;
 674 }
 675
 676
 677 static gpointer _model_xml_element_ref0 (gpointer self) {
 678         return self ? model_xml_element_ref (self) : NULL;
 679 }
 680
 681
 682 static gpointer _g_object_ref0 (gpointer self) {
 683         return self ? g_object_ref (self) : NULL;
 684 }
 685
 686
 687 void state_change_fixture_copy (const StateChangeFixture* self, StateChangeFixture* dest) {
 688         dest->root = _model_xml_element_ref0 (self->root);
 689         dest->project_builder = _g_object_ref0 (self->project_builder);
 690         dest->valid = self->valid;
 691 }
 692
 693
 694 void state_change_fixture_destroy (StateChangeFixture* self) {
 695         _model_xml_element_unref0 (self->root);
 696         _g_object_unref0 (self->project_builder);
 697 }
 698
 699
 700 StateChangeFixture* state_change_fixture_dup (const StateChangeFixture* self) {
 701         StateChangeFixture* dup;
 702         dup = g_new0 (StateChangeFixture, 1);
 703         state_change_fixture_copy (self, dup);
 704         return dup;
 705 }
 706
 707
 708 void state_change_fixture_free (StateChangeFixture* self) {
 709         state_change_fixture_destroy (self);
 710         g_free (self);
 711 }
 712
 713
 714 GType state_change_fixture_get_type (void) {
 715         static volatile gsize state_change_fixture_type_id__volatile = 0;
 716         if (g_once_init_enter (&state_change_fixture_type_id__volatile)) {
 717                 GType state_change_fixture_type_id;
 718                 state_change_fixture_type_id = g_boxed_type_register_static ("StateChangeFixture", (GBoxedCopyFunc) state_change_fixture_dup, (GBoxedFreeFunc) state_change_fixture_free);
 719                 g_once_init_leave (&state_change_fixture_type_id__volatile, state_change_fixture_type_id);
 720         }
 721         return state_change_fixture_type_id__volatile;
 722 }
 723
 724
 725 #line 49 "ProjectLoading.vala"
 726 void state_change_fixture_buildup (void* fixture) {
 727 #line 728 "ProjectLoading.c"
 728         StateChangeFixture* state_change_fixture;
 729         ModelXmlTreeLoader* tree_loader;
 730         ModelXmlElement* _tmp0_;
 731         ModelProjectBuilder* _tmp2_;
 732         ModelLoaderHandler* _tmp1_;
 733 #line 50 "ProjectLoading.vala"
 734         state_change_fixture = (StateChangeFixture*) fixture;
 735 #line 51 "ProjectLoading.vala"
 736         tree_loader = model_xml_tree_loader_new (project_documents[current_document].document);
 737 #line 52 "ProjectLoading.vala"
 738         (*state_change_fixture).root = (_tmp0_ = _model_xml_element_ref0 (tree_loader->root), _model_xml_element_unref0 ((*state_change_fixture).root), _tmp0_);
 739 #line 53 "ProjectLoading.vala"
 740         (*state_change_fixture).project_builder = (_tmp2_ = model_project_builder_new (_tmp1_ = model_loader_handler_new ()), _g_object_unref0 ((*state_change_fixture).project_builder), _tmp2_);
 741 #line 742 "ProjectLoading.c"
 742         _g_object_unref0 (_tmp1_);
 743 #line 54 "ProjectLoading.vala"
 744         (*state_change_fixture).valid = project_documents[current_document].valid;
 745 #line 55 "ProjectLoading.vala"
 746         current_document = current_document + 1;
 747 #line 748 "ProjectLoading.c"
 748         _model_xml_tree_loader_unref0 (tree_loader);
 749 }
 750
 751
 752 #line 58 "ProjectLoading.vala"
 753 void state_change_fixture_teardown (void* fixture) {
 754 #line 755 "ProjectLoading.c"
 755         StateChangeFixture* state_change_fixture;
 756         ModelXmlElement* _tmp0_;
 757         ModelProjectBuilder* _tmp1_;
 758 #line 59 "ProjectLoading.vala"
 759         state_change_fixture = (StateChangeFixture*) fixture;
 760 #line 60 "ProjectLoading.vala"
 761         (*state_change_fixture).root = (_tmp0_ = NULL, _model_xml_element_unref0 ((*state_change_fixture).root), _tmp0_);
 762 #line 61 "ProjectLoading.vala"
 763         (*state_change_fixture).project_builder = (_tmp1_ = NULL, _g_object_unref0 ((*state_change_fixture).project_builder), _tmp1_);
 764 #line 765 "ProjectLoading.c"
 765 }
 766
 767
 768 #line 66 "ProjectLoading.vala"
 769 void on_error_occurred (const char* message) {
 770 #line 67 "ProjectLoading.vala"
 771         g_test_message ("received error: %s", message);
 772 #line 68 "ProjectLoading.vala"
 773         document_valid = FALSE;
 774 #line 775 "ProjectLoading.c"
 775 }
 776
 777
 778 #line 66 "ProjectLoading.vala"
 779 static void _on_error_occurred_model_project_builder_error_occurred (ModelProjectBuilder* _sender, const char* _error_, gpointer self) {
 780 #line 781 "ProjectLoading.c"
 781         on_error_occurred (_error_);
 782 }
 783
 784
 785 #line 73 "ProjectLoading.vala"
 786 void check_document (void* fixture) {
 787 #line 788 "ProjectLoading.c"
 788         StateChangeFixture* state_change_fixture;
 789         const char* _tmp0_;
 790         ModelXmlElement* root;
 791         ModelProjectBuilder* project_builder;
 792 #line 74 "ProjectLoading.vala"
 793         state_change_fixture = (StateChangeFixture*) fixture;
 794 #line 795 "ProjectLoading.c"
 795         _tmp0_ = NULL;
 796 #line 77 "ProjectLoading.vala"
 797         if ((*state_change_fixture).valid) {
 798 #line 77 "ProjectLoading.vala"
 799                 _tmp0_ = "valid";
 800 #line 801 "ProjectLoading.c"
 801         } else {
 802 #line 77 "ProjectLoading.vala"
 803                 _tmp0_ = "invalid";
 804 #line 805 "ProjectLoading.c"
 805         }
 806 #line 76 "ProjectLoading.vala"
 807         g_test_message ("checking document expecting to be %s", _tmp0_);
 808 #line 79 "ProjectLoading.vala"
 809         root = _model_xml_element_ref0 ((*state_change_fixture).root);
 810 #line 80 "ProjectLoading.vala"
 811         project_builder = _g_object_ref0 ((*state_change_fixture).project_builder);
 812 #line 82 "ProjectLoading.vala"
 813         document_valid = TRUE;
 814 #line 83 "ProjectLoading.vala"
 815         g_signal_connect (project_builder, "error-occurred", (GCallback) _on_error_occurred_model_project_builder_error_occurred, NULL);
 816 #line 87 "ProjectLoading.vala"
 817         if (model_project_builder_check_project (project_builder, root)) {
 818 #line 88 "ProjectLoading.vala"
 819                 model_project_builder_build_project (project_builder, root);
 820 #line 821 "ProjectLoading.c"
 821         }
 822 #line 89 "ProjectLoading.vala"
 823         g_assert (document_valid == (*state_change_fixture).valid);
 824 #line 90 "ProjectLoading.vala"
 825         g_test_message ("finished executing check document");
 826 #line 827 "ProjectLoading.c"
 827         _model_xml_element_unref0 (root);
 828         _g_object_unref0 (project_builder);
 829 }
 830
 831
 832 static void _vala_ValidDocument_array_free (ValidDocument* array, gint array_length) {
 833         if (array != NULL) {
 834                 int i;
 835                 for (i = 0; i < array_length; i = i + 1) {
 836                         valid_document_destroy (&array[i]);
 837                 }
 838         }
 839         g_free (array);
 840 }
 841
 842
 843 #line 49 "ProjectLoading.vala"
 844 static void _state_change_fixture_buildup_gtest_func (void* fixture, gpointer self) {
 845 #line 846 "ProjectLoading.c"
 846         state_change_fixture_buildup (fixture);
 847 }
 848
 849
 850 #line 73 "ProjectLoading.vala"
 851 static void _check_document_gtest_func (void* fixture, gpointer self) {
 852 #line 853 "ProjectLoading.c"
 853         check_document (fixture);
 854 }
 855
 856
 857 #line 58 "ProjectLoading.vala"
 858 static void _state_change_fixture_teardown_gtest_func (void* fixture, gpointer self) {
 859 #line 860 "ProjectLoading.c"
 860         state_change_fixture_teardown (fixture);
 861 }
 862
 863
 864 #line 95 "ProjectLoading.vala"
 865 ProjectLoaderSuite* project_loader_suite_new (void) {
 866 #line 867 "ProjectLoading.c"
 867         ProjectLoaderSuite* self;
 868         ValidDocument* _tmp37_;
 869         ValidDocument* _tmp36_ = NULL;
 870         ValidDocument _tmp0_ = {0};
 871         ValidDocument _tmp1_ = {0};
 872         ValidDocument _tmp2_ = {0};
 873         ValidDocument _tmp3_ = {0};
 874         ValidDocument _tmp4_ = {0};
 875         ValidDocument _tmp5_ = {0};
 876         ValidDocument _tmp6_ = {0};
 877         ValidDocument _tmp7_ = {0};
 878         ValidDocument _tmp8_ = {0};
 879         ValidDocument _tmp9_ = {0};
 880         ValidDocument _tmp10_ = {0};
 881         ValidDocument _tmp11_ = {0};
 882         ValidDocument _tmp12_ = {0};
 883         ValidDocument _tmp13_ = {0};
 884         ValidDocument _tmp14_ = {0};
 885         ValidDocument _tmp15_ = {0};
 886         ValidDocument _tmp16_ = {0};
 887         ValidDocument _tmp17_ = {0};
 888         ValidDocument _tmp18_ = {0};
 889         ValidDocument _tmp19_ = {0};
 890         ValidDocument _tmp20_ = {0};
 891         ValidDocument _tmp21_ = {0};
 892         ValidDocument _tmp22_ = {0};
 893         ValidDocument _tmp23_ = {0};
 894         ValidDocument _tmp24_ = {0};
 895         ValidDocument _tmp25_ = {0};
 896         ValidDocument _tmp26_ = {0};
 897         ValidDocument _tmp27_ = {0};
 898         ValidDocument _tmp28_ = {0};
 899         ValidDocument _tmp29_ = {0};
 900         ValidDocument _tmp30_ = {0};
 901         ValidDocument _tmp31_ = {0};
 902         ValidDocument _tmp32_ = {0};
 903         ValidDocument _tmp33_ = {0};
 904         ValidDocument _tmp34_ = {0};
 905         ValidDocument _tmp35_ = {0};
 906         gint length;
 907 #line 96 "ProjectLoading.vala"
 908         self = (ProjectLoaderSuite*) g_test_create_suite ("ProjectLoaderSuite");
 909 #line 98 "ProjectLoading.vala"
 910         current_document = 0;
 911 #line 99 "ProjectLoading.vala"
 912         project_documents = (_tmp37_ = (_tmp36_ = g_new0 (ValidDocument, 36), _tmp36_[0] = (valid_document_init (&_tmp0_, TRUE, "<marina><library></library><tracks><track><clip /><clip /></track>" "<track><clip /></track></tracks><preferences /></marina>"), _tmp0_), _tmp36_[1] = (valid_document_init (&_tmp1_, TRUE, "<marina><library /><tracks /><preferences/>" "<maps><tempo /><time_signature /></marina>"), _tmp1_), _tmp36_[2] = (valid_document_init (&_tmp2_, TRUE, "<marina><library /><tracks /><preferences/><maps><tempo />" "</marina>"), _tmp2_), _tmp36_[3] = (valid_document_init (&_tmp3_, TRUE, "<marina><library /><tracks /><preferences/>" "<maps><time_signature /></marina>"), _tmp3_), _tmp36_[4] = (valid_document_init (&_tmp4_, TRUE, "<marina><library></library><tracks><track /></tracks>" "<preferences/></marina>"), _tmp4_), _tmp36_[5] = (valid_document_init (&_tmp5_, TRUE, "<marina><library></library><tracks><track><clip /></track>" "</tracks><preferences/></marina>"), _tmp5_), _tmp36_[6] = (valid_document_init (&_tmp6_, TRUE, "<marina><library/><tracks/><preferences/>" "<maps><tempo><entry></tempo></maps></marina>"), _tmp6_), _tmp36_[7] = (valid_document_init (&_tmp7_, TRUE, "<marina><library/><tracks/><preferences/>" "<maps><time_signature><entry></time_signature></maps></marina>"), _tmp7_), _tmp36_[8] = (valid_document_init (&_tmp8_, TRUE, "<marina><library/><tracks/><preferences/></marina>"), _tmp8_), _tmp36_[9] = (valid_document_init (&_tmp9_, TRUE, "<marina><library/><tracks/><preferences><click/></preferences>" "</marina>"), _tmp9_), _tmp36_[10] = (valid_document_init (&_tmp10_, TRUE, "<marina><library/><tracks/><preferences><library/>" "</preferences></marina>"), _tmp10_), _tmp36_[11] = (valid_document_init (&_tmp11_, TRUE, "<marina><library/><tracks/><preferences><click/><library/>" "</preferences></marina>"), _tmp11_), _tmp36_[12] = (valid_document_init (&_tmp12_, FALSE, "<marina><tracks></tracks><library></library></marina>"), _tmp12_), _tmp36_[13] = (valid_document_init (&_tmp13_, FALSE, "<marina><library></library><track></track></marina>"), _tmp13_), _tmp36_[14] = (valid_document_init (&_tmp14_, FALSE, "<marina><library><clip /></library><tracks><clipfile />" "</tracks></marina>"), _tmp14_), _tmp36_[15] = (valid_document_init (&_tmp15_, FALSE, "<marina />"), _tmp15_), _tmp36_[16] = (valid_document_init (&_tmp16_, FALSE, "<library />"), _tmp16_), _tmp36_[17] = (valid_document_init (&_tmp17_, FALSE, "<track />"), _tmp17_), _tmp36_[18] = (valid_document_init (&_tmp18_, FALSE, "<clip />"), _tmp18_), _tmp36_[19] = (valid_document_init (&_tmp19_, FALSE, "<entry />"), _tmp19_), _tmp36_[20] = (valid_document_init (&_tmp20_, FALSE, "<tempo />"), _tmp20_), _tmp36_[21] = (valid_document_init (&_tmp21_, FALSE, "<maps />"), _tmp21_), _tmp36_[22] = (valid_document_init (&_tmp22_, FALSE, "<preferences />"), _tmp22_), _tmp36_[23] = (valid_document_init (&_tmp23_, FALSE, "<click />"), _tmp23_), _tmp36_[24] = (valid_document_init (&_tmp24_, FALSE, "<time_signature />"), _tmp24_), _tmp36_[25] = (valid_document_init (&_tmp25_, FALSE, "<marina><clip /></marina>"), _tmp25_), _tmp36_[26] = (valid_document_init (&_tmp26_, FALSE, "<marina><track><clip><track /></clip></track></marina>"), _tmp26_), _tmp36_[27] = (valid_document_init (&_tmp27_, FALSE, "<unknown />"), _tmp27_), _tmp36_[28] = (valid_document_init (&_tmp28_, FALSE, "<marina><foo /></marina>"), _tmp28_), _tmp36_[29] = (valid_document_init (&_tmp29_, FALSE, "<marina><track><foo /></track></track></marina>"), _tmp29_), _tmp36_[30] = (valid_document_init (&_tmp30_, FALSE, "<marina><track><clip><foo /></clip></track></marina>"), _tmp30_), _tmp36_[31] = (valid_document_init (&_tmp31_, FALSE, "<marina><library/><tracks/><maps><foo/></maps></marina>"), _tmp31_), _tmp36_[32] = (valid_document_init (&_tmp32_, FALSE, "<marina><library/><tracks/><maps><time_signature>" "<tempo/></time_signature></marina>"), _tmp32_), _tmp36_[33] = (valid_document_init (&_tmp33_, FALSE, "<marina><library/><tracks/><click/></marina>"), _tmp33_), _tmp36_[34] = (valid_document_init (&_tmp34_, FALSE, "<marina><library/><tracks/><preferences><tracks/>" "</preferences></marina>"), _tmp34_), _tmp36_[35] = (valid_document_init (&_tmp35_, FALSE, "<marina><library/><tracks/><maps/><preferences/></marina>"), _tmp35_), _tmp36_), project_documents = (_vala_ValidDocument_array_free (project_documents, project_documents_length1), NULL), project_documents_length1 = 36, _project_documents_size_ = project_documents_length1, _tmp37_);
 913 #line 152 "ProjectLoading.vala"
 914         length = project_documents_length1;
 915 #line 916 "ProjectLoading.c"
 916         {
 917                 gint i;
 918 #line 154 "ProjectLoading.vala"
 919                 i = 0;
 920 #line 921 "ProjectLoading.c"
 921                 {
 922                         gboolean _tmp38_;
 923 #line 154 "ProjectLoading.vala"
 924                         _tmp38_ = TRUE;
 925 #line 154 "ProjectLoading.vala"
 926                         while (TRUE) {
 927 #line 928 "ProjectLoading.c"
 928                                 gboolean _tmp39_ = FALSE;
 929 #line 154 "ProjectLoading.vala"
 930                                 if (!_tmp38_) {
 931 #line 154 "ProjectLoading.vala"
 932                                         i = i + 1;
 933 #line 934 "ProjectLoading.c"
 934                                 }
 935 #line 154 "ProjectLoading.vala"
 936                                 _tmp38_ = FALSE;
 937 #line 154 "ProjectLoading.vala"
 938                                 if (!(i < length)) {
 939 #line 154 "ProjectLoading.vala"
 940                                         break;
 941 #line 942 "ProjectLoading.c"
 942                                 }
 943 #line 155 "ProjectLoading.vala"
 944                                 if (g_test_thorough ()) {
 945 #line 155 "ProjectLoading.vala"
 946                                         _tmp39_ = TRUE;
 947 #line 948 "ProjectLoading.c"
 948                                 } else {
 949 #line 155 "ProjectLoading.vala"
 950                                         _tmp39_ = project_documents[i].valid;
 951 #line 952 "ProjectLoading.c"
 952                                 }
 953 #line 155 "ProjectLoading.vala"
 954                                 if (_tmp39_) {
 955 #line 956 "ProjectLoading.c"
 956                                         char* _tmp40_;
 957 #line 156 "ProjectLoading.vala"
 958                                         g_test_suite_add ((GTestSuite*) self, g_test_create_case (_tmp40_ = g_strdup_printf ("Document%d", i), (gsize) sizeof (StateChangeFixture), NULL, (void (*) (void)) _state_change_fixture_buildup_gtest_func, (void (*) (void)) _check_document_gtest_func, (void (*) (void)) _state_change_fixture_teardown_gtest_func));
 959 #line 960 "ProjectLoading.c"
 960                                         _g_free0 (_tmp40_);
 961                                 }
 962                         }
 963                 }
 964         }
 965         return self;
 966 }
 967
 968
 969
 970 static void g_cclosure_user_marshal_VOID__MODEL_CLIP_FETCHER (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
 971         typedef void (*GMarshalFunc_VOID__MODEL_CLIP_FETCHER) (gpointer data1, gpointer arg_1, gpointer data2);
 972         register GMarshalFunc_VOID__MODEL_CLIP_FETCHER callback;
 973         register GCClosure * cc;
 974         register gpointer data1, data2;
 975         cc = (GCClosure *) closure;
 976         g_return_if_fail (n_param_values == 2);
 977         if (G_CCLOSURE_SWAP_DATA (closure)) {
 978                 data1 = closure->data;
 979                 data2 = param_values->data[0].v_pointer;
 980         } else {
 981                 data1 = param_values->data[0].v_pointer;
 982                 data2 = closure->data;
 983         }
 984         callback = (GMarshalFunc_VOID__MODEL_CLIP_FETCHER) (marshal_data ? marshal_data : cc->callback);
 985         callback (data1, model_value_get_clip_fetcher (param_values + 1), data2);
 986 }
 987
 988
 989