~ubuntu-branches/ubuntu/saucy/folks/saucy

 * generated from individual-retrieval.vala, do not modify */

 

/*

 

 

static void _individual_retrieval_tests_test_singleton_individuals_folks_test_case_test_method (gpointer self) {

        individual_retrieval_tests_test_singleton_individuals (self);

#line 118 "individual-retrieval.c"

}

IndividualRetrievalTests* individual_retrieval_tests_construct (GType object_type) {

        IndividualRetrievalTests * self = NULL;

        TrackerTestBackend* _tmp0_;

        self = (IndividualRetrievalTests*) folks_test_case_construct (object_type, "IndividualRetrieval");

        _tmp0_ = tracker_test_backend_new ();

        _tracker_test_backend_unref0 (self->priv->_tracker_backend);

        self->priv->_tracker_backend = _tmp0_;

        folks_test_case_add_test ((FolksTestCase*) self, "singleton individuals", _individual_retrieval_tests_test_singleton_individuals_folks_test_case_test_method, self);

        return self;

#line 137 "individual-retrieval.c"

}

 

 

IndividualRetrievalTests* individual_retrieval_tests_new (void) {

        return individual_retrieval_tests_construct (TYPE_INDIVIDUAL_RETRIEVAL_TESTS);

#line 144 "individual-retrieval.c"

}

 

static void individual_retrieval_tests_real_set_up (FolksTestCase* base) {

        IndividualRetrievalTests * self;

        self = (IndividualRetrievalTests*) base;

#line 152 "individual-retrieval.c"

}

 

static void individual_retrieval_tests_real_tear_down (FolksTestCase* base) {

        IndividualRetrievalTests * self;

        self = (IndividualRetrievalTests*) base;

#line 160 "individual-retrieval.c"

}

static gboolean __lambda2_ (IndividualRetrievalTests* self) {

        gboolean result = FALSE;

        GMainLoop* _tmp0_;

        _tmp0_ = self->priv->_main_loop;

        g_main_loop_quit (_tmp0_);

        g_assert_not_reached ();

        return result;

#line 175 "individual-retrieval.c"

}

static gboolean ___lambda2__gsource_func (gpointer self) {

        gboolean result;

        result = __lambda2_ (self);

        return result;

#line 184 "individual-retrieval.c"

}

        gint _tmp15_;

        gint _tmp16_;

        TrackerTestBackend* _tmp17_;

        g_return_if_fail (self != NULL);

        _tmp0_ = g_main_loop_new (NULL, FALSE);

        _g_main_loop_unref0 (self->priv->_main_loop);

        self->priv->_main_loop = _tmp0_;

        _tmp1_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);

        _g_object_unref0 (self->priv->_c1);

        self->priv->_c1 = _tmp1_;

        _tmp2_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);

        _g_object_unref0 (self->priv->_c2);

        self->priv->_c2 = _tmp2_;

        _tmp3_ = self->priv->_c1;

        gee_abstract_map_set ((GeeAbstractMap*) _tmp3_, TRF_ONTOLOGY_DEFS_NCO_FULLNAME, "persona #1");

        _tmp4_ = self->priv->_tracker_backend;

        _tmp5_ = self->priv->_c1;

        tracker_test_backend_add_contact (_tmp4_, _tmp5_);

        _tmp6_ = self->priv->_c2;

        gee_abstract_map_set ((GeeAbstractMap*) _tmp6_, TRF_ONTOLOGY_DEFS_NCO_FULLNAME, "persona #2");

        _tmp7_ = self->priv->_tracker_backend;

        _tmp8_ = self->priv->_c2;

        tracker_test_backend_add_contact (_tmp7_, _tmp8_);

        _tmp9_ = self->priv->_tracker_backend;

        tracker_test_backend_set_up (_tmp9_);

        _individual_retrieval_tests_test_singleton_individuals_async (self, NULL, NULL);

        g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 5, ___lambda2__gsource_func, g_object_ref (self), g_object_unref);

        _tmp10_ = self->priv->_main_loop;

        g_main_loop_run (_tmp10_);

        _tmp11_ = self->priv->_c1;

        _tmp12_ = gee_abstract_map_get_size ((GeeMap*) _tmp11_);

        _tmp13_ = _tmp12_;

        g_assert (_tmp13_ == 0);

        _tmp14_ = self->priv->_c2;

        _tmp15_ = gee_abstract_map_get_size ((GeeMap*) _tmp14_);

        _tmp16_ = _tmp15_;

        g_assert (_tmp16_ == 0);

        _tmp17_ = self->priv->_tracker_backend;

        tracker_test_backend_tear_down (_tmp17_);

#line 279 "individual-retrieval.c"

}

static void _individual_retrieval_tests_test_singleton_individuals_async_data_free (gpointer _data) {

        IndividualRetrievalTestsTestSingletonIndividualsAsyncData* _data_;

        _data_ = _data;

        _g_object_unref0 (_data_->self);

        g_slice_free (IndividualRetrievalTestsTestSingletonIndividualsAsyncData, _data_);

#line 290 "individual-retrieval.c"

}

 

 

static gpointer _g_object_ref0 (gpointer self) {

        return self ? g_object_ref (self) : NULL;

#line 297 "individual-retrieval.c"

}

static void _individual_retrieval_tests_test_singleton_individuals_async (IndividualRetrievalTests* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {

        IndividualRetrievalTestsTestSingletonIndividualsAsyncData* _data_;

        IndividualRetrievalTests* _tmp0_;

        _data_ = g_slice_new0 (IndividualRetrievalTestsTestSingletonIndividualsAsyncData);

        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, _individual_retrieval_tests_test_singleton_individuals_async);

        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, _individual_retrieval_tests_test_singleton_individuals_async_data_free);

        _tmp0_ = _g_object_ref0 (self);

        _data_->self = _tmp0_;

        _individual_retrieval_tests_test_singleton_individuals_async_co (_data_);

#line 316 "individual-retrieval.c"

}

 

static void _individual_retrieval_tests_test_singleton_individuals_finish (IndividualRetrievalTests* self, GAsyncResult* _res_) {

        IndividualRetrievalTestsTestSingletonIndividualsAsyncData* _data_;

        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));

#line 324 "individual-retrieval.c"

}

 

static void _individual_retrieval_tests_test_singleton_individuals_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {

        IndividualRetrievalTestsTestSingletonIndividualsAsyncData* _data_;

        _data_ = _user_data_;

        _data_->_source_object_ = source_object;

        _data_->_res_ = _res_;

        _individual_retrieval_tests_test_singleton_individuals_async_co (_data_);

#line 338 "individual-retrieval.c"

}

 

 

static void __individual_retrieval_tests_individuals_changed_cb_folks_individual_aggregator_individuals_changed_detailed (FolksIndividualAggregator* _sender, GeeMultiMap* changes, gpointer self) {

        _individual_retrieval_tests_individuals_changed_cb (self, changes);

#line 345 "individual-retrieval.c"

}

 

 

static gboolean _individual_retrieval_tests_test_singleton_individuals_async_co (IndividualRetrievalTestsTestSingletonIndividualsAsyncData* _data_) {

        switch (_data_->_state_) {

                case 0:

#line 354 "individual-retrieval.c"

                goto _state_0;

                case 1:

#line 358 "individual-retrieval.c"

                goto _state_1;

                case 2:

#line 362 "individual-retrieval.c"

                goto _state_2;

                default:

                g_assert_not_reached ();

#line 367 "individual-retrieval.c"

        }

        _state_0:

        _data_->_tmp0_ = NULL;

        _data_->_tmp0_ = folks_backend_store_dup ();

        _data_->store = _data_->_tmp0_;

        _data_->_state_ = 1;

        folks_backend_store_prepare (_data_->store, _individual_retrieval_tests_test_singleton_individuals_async_ready, _data_);

        return FALSE;

#line 382 "individual-retrieval.c"

        _state_1:

        folks_backend_store_prepare_finish (_data_->store, _data_->_res_);

        _data_->_tmp1_ = folks_individual_aggregator_new ();

        _g_object_unref0 (_data_->self->priv->_aggregator);

        _data_->self->priv->_aggregator = _data_->_tmp1_;

        _data_->_tmp2_ = _data_->self->priv->_aggregator;

        g_signal_connect_object (_data_->_tmp2_, "individuals-changed-detailed", (GCallback) __individual_retrieval_tests_individuals_changed_cb_folks_individual_aggregator_individuals_changed_detailed, _data_->self, 0);

#line 396 "individual-retrieval.c"

        {

                _data_->_tmp3_ = _data_->self->priv->_aggregator;

                _data_->_state_ = 2;

                folks_individual_aggregator_prepare (_data_->_tmp3_, _individual_retrieval_tests_test_singleton_individuals_async_ready, _data_);

                return FALSE;

#line 406 "individual-retrieval.c"

                _state_2:

                folks_individual_aggregator_prepare_finish (_data_->_tmp3_, _data_->_res_, &_data_->_inner_error_);

                if (_data_->_inner_error_ != NULL) {

#line 412 "individual-retrieval.c"

                        goto __catch0_g_error;

        goto __finally0;

        __catch0_g_error:

        {

                _data_->e = _data_->_inner_error_;

                _data_->_inner_error_ = NULL;

                _data_->_tmp4_ = _data_->e;

                _data_->_tmp5_ = _data_->_tmp4_->message;

                g_warning ("individual-retrieval.vala:92: Error when calling prepare: %s\n", _data_->_tmp5_);

                _g_error_free0 (_data_->e);

#line 431 "individual-retrieval.c"

        }

        __finally0:

        if (_data_->_inner_error_ != NULL) {

                _g_object_unref0 (_data_->store);

                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);

                g_clear_error (&_data_->_inner_error_);

                return FALSE;

#line 444 "individual-retrieval.c"

        }

        _g_object_unref0 (_data_->store);

        if (_data_->_state_ == 0) {

                g_simple_async_result_complete_in_idle (_data_->_async_result);

#line 452 "individual-retrieval.c"

        } else {

                g_simple_async_result_complete (_data_->_async_result);

#line 456 "individual-retrieval.c"

        }

        g_object_unref (_data_->_async_result);

        return FALSE;

#line 462 "individual-retrieval.c"

}

        GeeSet* _tmp37_;

        gint _tmp38_;

        gint _tmp39_;

        g_return_if_fail (self != NULL);

        g_return_if_fail (changes != NULL);

        _tmp0_ = changes;

        _tmp1_ = gee_multi_map_get_values (_tmp0_);

        added = _tmp1_;

        _tmp2_ = changes;

        _tmp3_ = gee_multi_map_get_keys (_tmp2_);

        removed = _tmp3_;

#line 497 "individual-retrieval.c"

        {

                GeeCollection* _tmp4_;

                GeeIterator* _tmp5_ = NULL;

                GeeIterator* _i_it;

                _tmp4_ = added;

                _tmp5_ = gee_iterable_iterator ((GeeIterable*) _tmp4_);

                _i_it = _tmp5_;

                while (TRUE) {

#line 510 "individual-retrieval.c"

                        GeeIterator* _tmp6_;

                        gchar* _tmp14_;

                        gchar* full_name;

                        const gchar* _tmp15_;

                        _tmp6_ = _i_it;

                        _tmp7_ = gee_iterator_next (_tmp6_);

                        if (!_tmp7_) {

                                break;

#line 531 "individual-retrieval.c"

                        }

                        _tmp8_ = _i_it;

                        _tmp9_ = gee_iterator_get (_tmp8_);

                        i = (FolksIndividual*) _tmp9_;

                        _tmp10_ = i;

                        g_assert (_tmp10_ != NULL);

                        _tmp11_ = i;

                        _tmp12_ = folks_name_details_get_full_name (FOLKS_NAME_DETAILS (_tmp11_));

                        _tmp13_ = _tmp12_;

                        _tmp14_ = g_strdup (_tmp13_);

                        full_name = _tmp14_;

                        _tmp15_ = full_name;

                        if (_tmp15_ != NULL) {

#line 557 "individual-retrieval.c"

                                GeeHashMap* _tmp16_;

                                gchar* _tmp24_;

                                const gchar* _tmp25_;

                                gboolean _tmp26_;

                                _tmp16_ = self->priv->_c1;

                                _tmp17_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp16_, TRF_ONTOLOGY_DEFS_NCO_FULLNAME);

                                _tmp18_ = (gchar*) _tmp17_;

                                _tmp19_ = full_name;

                                _tmp20_ = g_strcmp0 (_tmp18_, _tmp19_) == 0;

                                _g_free0 (_tmp18_);

                                if (_tmp20_) {

#line 582 "individual-retrieval.c"

                                        GeeHashMap* _tmp21_;

                                        _tmp21_ = self->priv->_c1;

                                        gee_abstract_map_unset ((GeeAbstractMap*) _tmp21_, TRF_ONTOLOGY_DEFS_NCO_FULLNAME, NULL);

#line 588 "individual-retrieval.c"

                                }

                                _tmp22_ = self->priv->_c2;

                                _tmp23_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp22_, TRF_ONTOLOGY_DEFS_NCO_FULLNAME);

                                _tmp24_ = (gchar*) _tmp23_;

                                _tmp25_ = full_name;

                                _tmp26_ = g_strcmp0 (_tmp24_, _tmp25_) == 0;

                                _g_free0 (_tmp24_);

                                if (_tmp26_) {

#line 604 "individual-retrieval.c"

                                        GeeHashMap* _tmp27_;

                                        _tmp27_ = self->priv->_c2;

                                        gee_abstract_map_unset ((GeeAbstractMap*) _tmp27_, TRF_ONTOLOGY_DEFS_NCO_FULLNAME, NULL);

#line 610 "individual-retrieval.c"

                                }

                        }

                        _g_free0 (full_name);

                        _g_object_unref0 (i);

#line 617 "individual-retrieval.c"

                }

                _g_object_unref0 (_i_it);

#line 621 "individual-retrieval.c"

        }

        _tmp29_ = self->priv->_c1;

        _tmp30_ = gee_abstract_map_get_size ((GeeMap*) _tmp29_);

        _tmp31_ = _tmp30_;

        if (_tmp31_ == 0) {

#line 631 "individual-retrieval.c"

                GeeHashMap* _tmp32_;

                gint _tmp33_;

                gint _tmp34_;

                _tmp32_ = self->priv->_c2;

                _tmp33_ = gee_abstract_map_get_size ((GeeMap*) _tmp32_);

                _tmp34_ = _tmp33_;

                _tmp28_ = _tmp34_ == 0;

#line 643 "individual-retrieval.c"

        } else {

                _tmp28_ = FALSE;

#line 647 "individual-retrieval.c"

        }

        _tmp35_ = _tmp28_;

        if (_tmp35_) {

#line 653 "individual-retrieval.c"

                GMainLoop* _tmp36_;

                _tmp36_ = self->priv->_main_loop;

                g_main_loop_quit (_tmp36_);

#line 659 "individual-retrieval.c"

        }

        _tmp37_ = removed;

        _tmp38_ = gee_collection_get_size ((GeeCollection*) _tmp37_);

        _tmp39_ = _tmp38_;

        g_assert (_tmp39_ == 1);

#line 669 "individual-retrieval.c"

        {

                GeeSet* _tmp40_;

                GeeIterator* _tmp41_ = NULL;

                GeeIterator* _i_it;

                _tmp40_ = removed;

                _tmp41_ = gee_iterable_iterator ((GeeIterable*) _tmp40_);

                _i_it = _tmp41_;

                while (TRUE) {

#line 682 "individual-retrieval.c"

                        GeeIterator* _tmp42_;

                        gpointer _tmp45_ = NULL;

                        FolksIndividual* i;

                        FolksIndividual* _tmp46_;

                        _tmp42_ = _i_it;

                        _tmp43_ = gee_iterator_next (_tmp42_);

                        if (!_tmp43_) {

                                break;

#line 697 "individual-retrieval.c"

                        }

                        _tmp44_ = _i_it;

                        _tmp45_ = gee_iterator_get (_tmp44_);

                        i = (FolksIndividual*) _tmp45_;

                        _tmp46_ = i;

                        g_assert (_tmp46_ == NULL);

                        _g_object_unref0 (i);

#line 711 "individual-retrieval.c"

                }

                _g_object_unref0 (_i_it);

#line 715 "individual-retrieval.c"

        }

        _g_object_unref0 (removed);

        _g_object_unref0 (added);

#line 721 "individual-retrieval.c"

}

 

 

static void individual_retrieval_tests_class_init (IndividualRetrievalTestsClass * klass) {

        individual_retrieval_tests_parent_class = g_type_class_peek_parent (klass);

        g_type_class_add_private (klass, sizeof (IndividualRetrievalTestsPrivate));

        FOLKS_TEST_CASE_CLASS (klass)->set_up = individual_retrieval_tests_real_set_up;

        FOLKS_TEST_CASE_CLASS (klass)->tear_down = individual_retrieval_tests_real_tear_down;

        G_OBJECT_CLASS (klass)->finalize = individual_retrieval_tests_finalize;

#line 736 "individual-retrieval.c"

}

 

 

static void individual_retrieval_tests_instance_init (IndividualRetrievalTests * self) {

        self->priv = INDIVIDUAL_RETRIEVAL_TESTS_GET_PRIVATE (self);

#line 743 "individual-retrieval.c"

}

 

static void individual_retrieval_tests_finalize (GObject* obj) {

        IndividualRetrievalTests * self;

        self = INDIVIDUAL_RETRIEVAL_TESTS (obj);

        _g_main_loop_unref0 (self->priv->_main_loop);

        _g_object_unref0 (self->priv->_aggregator);

        _tracker_test_backend_unref0 (self->priv->_tracker_backend);

        _g_object_unref0 (self->priv->_c1);

        _g_object_unref0 (self->priv->_c2);

        G_OBJECT_CLASS (individual_retrieval_tests_parent_class)->finalize (obj);

#line 763 "individual-retrieval.c"

}

        IndividualRetrievalTests* _tmp1_;

        IndividualRetrievalTests* _tmp2_;

        GTestSuite* _tmp3_ = NULL;

        g_test_init (&args_length1, &args, NULL);

        _tmp0_ = g_test_get_root ();

        root = _tmp0_;

        _tmp1_ = individual_retrieval_tests_new ();

        _tmp2_ = _tmp1_;

        _tmp3_ = folks_test_case_get_suite ((FolksTestCase*) _tmp2_);

        g_test_suite_add_suite (root, _tmp3_);

        _g_object_unref0 (_tmp2_);

        g_test_run ();

        result = 0;

        return result;

#line 808 "individual-retrieval.c"

}

 

 

int main (int argc, char ** argv) {

        g_type_init ();

        return _vala_main (argv, argc);

#line 817 "individual-retrieval.c"

}