~ubuntu-branches/ubuntu/quantal/folks/quantal

 * 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 114 "individual-retrieval.c"

}

 

 

static void _individual_retrieval_tests_test_aliases_folks_test_case_test_method (gpointer self) {

        individual_retrieval_tests_test_aliases (self);

#line 121 "individual-retrieval.c"

}

        IndividualRetrievalTests * self = NULL;

        KfTestBackend* _tmp0_;

        const gchar* _tmp1_ = NULL;

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

        _tmp0_ = kf_test_backend_new ();

        _kf_test_backend_unref0 (self->priv->kf_backend);

        self->priv->kf_backend = _tmp0_;

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

        folks_test_case_add_test ((FolksTestCase*) self, "aliases", _individual_retrieval_tests_test_aliases_folks_test_case_test_method, self);

        _tmp1_ = g_getenv ("FOLKS_TEST_VALGRIND");

        if (_tmp1_ != NULL) {

                self->priv->_test_timeout = 10;

#line 147 "individual-retrieval.c"

        }

        return self;

#line 151 "individual-retrieval.c"

}

 

 

IndividualRetrievalTests* individual_retrieval_tests_new (void) {

        return individual_retrieval_tests_construct (TYPE_INDIVIDUAL_RETRIEVAL_TESTS);

#line 158 "individual-retrieval.c"

}

 

static void individual_retrieval_tests_real_set_up (FolksTestCase* base) {

        IndividualRetrievalTests * self;

        self = (IndividualRetrievalTests*) base;

#line 166 "individual-retrieval.c"

}

 

static void individual_retrieval_tests_real_tear_down (FolksTestCase* base) {

        IndividualRetrievalTests * self;

        self = (IndividualRetrievalTests*) base;

#line 174 "individual-retrieval.c"

}

 

 

static Block1Data* block1_data_ref (Block1Data* _data1_) {

        g_atomic_int_inc (&_data1_->_ref_count_);

        return _data1_;

#line 183 "individual-retrieval.c"

}

static void block1_data_unref (void * _userdata_) {

        Block1Data* _data1_;

        _data1_ = (Block1Data*) _userdata_;

        if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {

#line 192 "individual-retrieval.c"

                IndividualRetrievalTests * self;

                self = _data1_->self;

                _g_object_unref0 (_data1_->expected_individuals);

                _g_main_loop_unref0 (_data1_->main_loop);

                _g_object_unref0 (self);

                g_slice_free (Block1Data, _data1_);

#line 204 "individual-retrieval.c"

        }

        GeeSet* _tmp27_;

        gint _tmp28_;

        gint _tmp29_;

        self = _data1_->self;

        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 236 "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 249 "individual-retrieval.c"

                        GeeIterator* _tmp6_;

                        GeeSet* _tmp13_;

                        gint _tmp14_;

                        gint _tmp15_;

                        _tmp6_ = _i_it;

                        _tmp7_ = gee_iterator_next (_tmp6_);

                        if (!_tmp7_) {

                                break;

#line 269 "individual-retrieval.c"

                        }

                        _tmp8_ = _i_it;

                        _tmp9_ = gee_iterator_get (_tmp8_);

                        i = (FolksIndividual*) _tmp9_;

                        _tmp10_ = i;

                        _vala_assert (_tmp10_ != NULL, "i != null");

                        _tmp11_ = i;

                        _tmp12_ = folks_individual_get_personas (_tmp11_);

                        _tmp13_ = _tmp12_;

                        _tmp14_ = gee_collection_get_size ((GeeCollection*) _tmp13_);

                        _tmp15_ = _tmp14_;

                        _vala_assert (_tmp15_ == 1, "i.personas.size == 1");

#line 293 "individual-retrieval.c"

                        {

                                GeeSet* _tmp18_;

                                GeeIterator* _tmp19_ = NULL;

                                GeeIterator* _persona_it;

                                _tmp16_ = i;

                                _tmp17_ = folks_individual_get_personas (_tmp16_);

                                _tmp18_ = _tmp17_;

                                _tmp19_ = gee_iterable_iterator ((GeeIterable*) _tmp18_);

                                _persona_it = _tmp19_;

                                while (TRUE) {

#line 312 "individual-retrieval.c"

                                        GeeIterator* _tmp20_;

                                        FolksPersona* _tmp24_;

                                        const gchar* _tmp25_;

                                        const gchar* _tmp26_;

                                        _tmp20_ = _persona_it;

                                        _tmp21_ = gee_iterator_next (_tmp20_);

                                        if (!_tmp21_) {

                                                break;

#line 329 "individual-retrieval.c"

                                        }

                                        _tmp22_ = _persona_it;

                                        _tmp23_ = gee_iterator_get (_tmp22_);

                                        persona = (FolksPersona*) _tmp23_;

                                        _tmp24_ = persona;

                                        _tmp25_ = folks_persona_get_display_id (_tmp24_);

                                        _tmp26_ = _tmp25_;

                                        gee_abstract_collection_remove ((GeeAbstractCollection*) _data1_->expected_individuals, _tmp26_);

                                        _g_object_unref0 (persona);

#line 347 "individual-retrieval.c"

                                }

                                _g_object_unref0 (_persona_it);

#line 351 "individual-retrieval.c"

                        }

                        _g_object_unref0 (i);

#line 355 "individual-retrieval.c"

                }

                _g_object_unref0 (_i_it);

#line 359 "individual-retrieval.c"

        }

        _tmp27_ = removed;

        _tmp28_ = gee_collection_get_size ((GeeCollection*) _tmp27_);

        _tmp29_ = _tmp28_;

        _vala_assert (_tmp29_ == 1, "removed.size == 1");

#line 369 "individual-retrieval.c"

        {

                GeeSet* _tmp30_;

                GeeIterator* _tmp31_ = NULL;

                GeeIterator* _i_it;

                _tmp30_ = removed;

                _tmp31_ = gee_iterable_iterator ((GeeIterable*) _tmp30_);

                _i_it = _tmp31_;

                while (TRUE) {

#line 382 "individual-retrieval.c"

                        GeeIterator* _tmp32_;

                        gpointer _tmp35_ = NULL;

                        FolksIndividual* i;

                        FolksIndividual* _tmp36_;

                        _tmp32_ = _i_it;

                        _tmp33_ = gee_iterator_next (_tmp32_);

                        if (!_tmp33_) {

                                break;

#line 397 "individual-retrieval.c"

                        }

                        _tmp34_ = _i_it;

                        _tmp35_ = gee_iterator_get (_tmp34_);

                        i = (FolksIndividual*) _tmp35_;

                        _tmp36_ = i;

                        _vala_assert (_tmp36_ == NULL, "i == null");

                        _g_object_unref0 (i);

#line 411 "individual-retrieval.c"

                }

                _g_object_unref0 (_i_it);

#line 415 "individual-retrieval.c"

        }

        _g_object_unref0 (removed);

        _g_object_unref0 (added);

#line 421 "individual-retrieval.c"

}

 

 

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

        __lambda2_ (self, changes);

#line 428 "individual-retrieval.c"

}

static gboolean __lambda3_ (Block1Data* _data1_) {

        IndividualRetrievalTests * self;

        gboolean result = FALSE;

        self = _data1_->self;

        g_main_loop_quit (_data1_->main_loop);

        result = FALSE;

        return result;

#line 443 "individual-retrieval.c"

}

static gboolean ___lambda3__gsource_func (gpointer self) {

        gboolean result;

        result = __lambda3_ (self);

        return result;

#line 452 "individual-retrieval.c"

}

        gint _tmp7_;

        gint _tmp8_;

        KfTestBackend* _tmp9_;

        g_return_if_fail (self != NULL);

        _data1_ = g_slice_new0 (Block1Data);

        _data1_->_ref_count_ = 1;

        _data1_->self = g_object_ref (self);

        _tmp0_ = g_main_loop_new (NULL, FALSE);

        _data1_->main_loop = _tmp0_;

        _tmp1_ = self->priv->kf_backend;

        kf_test_backend_set_up (_tmp1_, "[0]\n" "msn=foo@hotmail.com\n" "[1]\n" "__alias=Bar McBadgerson\n" "jabber=bar@jabber.org\n");

        _tmp2_ = g_str_hash;

        _tmp3_ = g_str_equal;

        _tmp4_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, _tmp2_, _tmp3_);

        _data1_->expected_individuals = _tmp4_;

        gee_abstract_collection_add ((GeeAbstractCollection*) _data1_->expected_individuals, "0");

        gee_abstract_collection_add ((GeeAbstractCollection*) _data1_->expected_individuals, "1");

        _tmp5_ = folks_individual_aggregator_new ();

        aggregator = _tmp5_;

        g_signal_connect_data (aggregator, "individuals-changed-detailed", (GCallback) ___lambda2__folks_individual_aggregator_individuals_changed_detailed, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);

        folks_individual_aggregator_prepare (aggregator, NULL, NULL);

        _tmp6_ = self->priv->_test_timeout;

        g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) _tmp6_, ___lambda3__gsource_func, block1_data_ref (_data1_), block1_data_unref);

        g_main_loop_run (_data1_->main_loop);

        _tmp7_ = gee_abstract_collection_get_size ((GeeCollection*) _data1_->expected_individuals);

        _tmp8_ = _tmp7_;

        _vala_assert (_tmp8_ == 0, "expected_individuals.size == 0");

        _tmp9_ = self->priv->kf_backend;

        kf_test_backend_tear_down (_tmp9_);

        _g_object_unref0 (aggregator);

        block1_data_unref (_data1_);

        _data1_ = NULL;

#line 527 "individual-retrieval.c"

}

 

 

static Block2Data* block2_data_ref (Block2Data* _data2_) {

        g_atomic_int_inc (&_data2_->_ref_count_);

        return _data2_;

#line 536 "individual-retrieval.c"

}

static void block2_data_unref (void * _userdata_) {

        Block2Data* _data2_;

        _data2_ = (Block2Data*) _userdata_;

        if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {

#line 545 "individual-retrieval.c"

                IndividualRetrievalTests * self;

                self = _data2_->self;

                _g_main_loop_unref0 (_data2_->main_loop);

                _g_object_unref0 (self);

                g_slice_free (Block2Data, _data2_);

#line 555 "individual-retrieval.c"

        }

        GeeSet* _tmp8_;

        gint _tmp9_;

        gint _tmp10_;

        self = _data2_->self;

        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_;

        _tmp4_ = _data2_->individuals_changed_count;

        _data2_->individuals_changed_count = _tmp4_ + 1;

        _tmp5_ = added;

        _tmp6_ = gee_collection_get_size (_tmp5_);

        _tmp7_ = _tmp6_;

        _vala_assert (_tmp7_ == 1, "added.size == 1");

        _tmp8_ = removed;

        _tmp9_ = gee_collection_get_size ((GeeCollection*) _tmp8_);

        _tmp10_ = _tmp9_;

        _vala_assert (_tmp10_ == 1, "removed.size == 1");

#line 611 "individual-retrieval.c"

        {

                GeeCollection* _tmp11_;

                GeeIterator* _tmp12_ = NULL;

                GeeIterator* _i_it;

                _tmp11_ = added;

                _tmp12_ = gee_iterable_iterator ((GeeIterable*) _tmp11_);

                _i_it = _tmp12_;

                while (TRUE) {

#line 624 "individual-retrieval.c"

                        GeeIterator* _tmp13_;

                        FolksIndividual* _tmp17_;

                        const gchar* _tmp18_;

                        const gchar* _tmp19_;

                        _tmp13_ = _i_it;

                        _tmp14_ = gee_iterator_next (_tmp13_);

                        if (!_tmp14_) {

                                break;

#line 641 "individual-retrieval.c"

                        }

                        _tmp15_ = _i_it;

                        _tmp16_ = gee_iterator_get (_tmp15_);

                        i = (FolksIndividual*) _tmp16_;

                        _tmp17_ = i;

                        _tmp18_ = folks_alias_details_get_alias ((FolksAliasDetails*) _tmp17_);

                        _tmp19_ = _tmp18_;

                        _vala_assert (g_strcmp0 (_tmp19_, "Brian Briansson") == 0, "i.alias == \"Brian Briansson\"");

                        _g_object_unref0 (i);

#line 659 "individual-retrieval.c"

                }

                _g_object_unref0 (_i_it);

#line 663 "individual-retrieval.c"

        }

                GeeSet* _tmp20_;

                GeeIterator* _tmp21_ = NULL;

                GeeIterator* _i_it;

                _tmp20_ = removed;

                _tmp21_ = gee_iterable_iterator ((GeeIterable*) _tmp20_);

                _i_it = _tmp21_;

                while (TRUE) {

#line 677 "individual-retrieval.c"

                        GeeIterator* _tmp22_;

                        gpointer _tmp25_ = NULL;

                        FolksIndividual* i;

                        FolksIndividual* _tmp26_;

                        _tmp22_ = _i_it;

                        _tmp23_ = gee_iterator_next (_tmp22_);

                        if (!_tmp23_) {

                                break;

#line 692 "individual-retrieval.c"

                        }

                        _tmp24_ = _i_it;

                        _tmp25_ = gee_iterator_get (_tmp24_);

                        i = (FolksIndividual*) _tmp25_;

                        _tmp26_ = i;

                        _vala_assert (_tmp26_ == NULL, "i == null");

                        _g_object_unref0 (i);

#line 706 "individual-retrieval.c"

                }

                _g_object_unref0 (_i_it);

#line 710 "individual-retrieval.c"

        }

        _g_object_unref0 (removed);

        _g_object_unref0 (added);

#line 716 "individual-retrieval.c"

}

 

 

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

        __lambda4_ (self, changes);

#line 723 "individual-retrieval.c"

}

static gboolean __lambda5_ (Block2Data* _data2_) {

        IndividualRetrievalTests * self;

        gboolean result = FALSE;

        self = _data2_->self;

        g_main_loop_quit (_data2_->main_loop);

        result = FALSE;

        return result;

#line 738 "individual-retrieval.c"

}

static gboolean ___lambda5__gsource_func (gpointer self) {

        gboolean result;

        result = __lambda5_ (self);

        return result;

#line 747 "individual-retrieval.c"

}

        FolksIndividualAggregator* aggregator;

        gint _tmp3_;

        KfTestBackend* _tmp4_;

        g_return_if_fail (self != NULL);

        _data2_ = g_slice_new0 (Block2Data);

        _data2_->_ref_count_ = 1;

        _data2_->self = g_object_ref (self);

        _tmp0_ = g_main_loop_new (NULL, FALSE);

        _data2_->main_loop = _tmp0_;

        _tmp1_ = self->priv->kf_backend;

        kf_test_backend_set_up (_tmp1_, "[0]\n" "__alias=Brian Briansson\n" "msn=foo@hotmail.com\n");

        _tmp2_ = folks_individual_aggregator_new ();

        aggregator = _tmp2_;

        _data2_->individuals_changed_count = (guint) 0;

        g_signal_connect_data (aggregator, "individuals-changed-detailed", (GCallback) ___lambda4__folks_individual_aggregator_individuals_changed_detailed, block2_data_ref (_data2_), (GClosureNotify) block2_data_unref, 0);

        folks_individual_aggregator_prepare (aggregator, NULL, NULL);

        _tmp3_ = self->priv->_test_timeout;

        g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) _tmp3_, ___lambda5__gsource_func, block2_data_ref (_data2_), block2_data_unref);

        g_main_loop_run (_data2_->main_loop);

        _vala_assert (_data2_->individuals_changed_count == ((guint) 1), "individuals_changed_count == 1");

        _tmp4_ = self->priv->kf_backend;

        kf_test_backend_tear_down (_tmp4_);

        _g_object_unref0 (aggregator);

        block2_data_unref (_data2_);

        _data2_ = NULL;

#line 803 "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 818 "individual-retrieval.c"

}

 

 

static void individual_retrieval_tests_instance_init (IndividualRetrievalTests * self) {

        self->priv = INDIVIDUAL_RETRIEVAL_TESTS_GET_PRIVATE (self);

        self->priv->_test_timeout = 3;

#line 827 "individual-retrieval.c"

}

 

static void individual_retrieval_tests_finalize (GObject* obj) {

        IndividualRetrievalTests * self;

        self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_INDIVIDUAL_RETRIEVAL_TESTS, IndividualRetrievalTests);

        _kf_test_backend_unref0 (self->priv->kf_backend);

        G_OBJECT_CLASS (individual_retrieval_tests_parent_class)->finalize (obj);

#line 839 "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 884 "individual-retrieval.c"

}

 

 

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

        g_type_init ();

        return _vala_main (argv, argc);

#line 893 "individual-retrieval.c"

}