~ubuntu-branches/ubuntu/precise/folks/precise

static void backend_loading_tests_test_disabling_async (BackendLoadingTests* self, FolksBackendStore* store, GAsyncReadyCallback _callback_, gpointer _user_data_);

152

182

static void backend_loading_tests_test_disabling_finish (BackendLoadingTests* self, GAsyncResult* _res_);

153

static void _lambda4_ (GObject* o, GAsyncResult* r, BackendLoadingTests* self);

154

static void __lambda4__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);

183

static void _lambda2_ (GObject* o, GAsyncResult* r, BackendLoadingTests* self);

184

static void __lambda2__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);

155

185

static void backend_loading_tests_test_disabling_async_data_free (gpointer _data);

156

186

static gboolean backend_loading_tests_test_disabling_async_co (BackendLoadingTestsTestDisablingAsyncData* data);

157

static Block2Data* block2_data_ref (Block2Data* _data2_);

158

static void block2_data_unref (Block2Data* _data2_);

159

187

static void backend_loading_tests_test_disabling_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);

160

static void _lambda3_ (FolksBackend* i, Block2Data* _data2_);

161

static void __lambda3__gfunc (gconstpointer data, gpointer self);

162

188

static void backend_loading_tests_test_reloading_async (BackendLoadingTests* self, FolksBackendStore* store, GAsyncReadyCallback _callback_, gpointer _user_data_);

163

189

static void backend_loading_tests_test_reloading_finish (BackendLoadingTests* self, GAsyncResult* _res_);

164

static void _lambda9_ (GObject* o, GAsyncResult* r, BackendLoadingTests* self);

165

static void __lambda9__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);

190

static void _lambda3_ (GObject* o, GAsyncResult* r, BackendLoadingTests* self);

191

static void __lambda3__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);

166

192

static void backend_loading_tests_test_reloading_async_data_free (gpointer _data);

167

193

static gboolean backend_loading_tests_test_reloading_async_co (BackendLoadingTestsTestReloadingAsyncData* data);

168

static Block3Data* block3_data_ref (Block3Data* _data3_);

169

static void block3_data_unref (Block3Data* _data3_);

170

194

static void backend_loading_tests_test_reloading_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);

171

static void _lambda5_ (FolksBackend* i, Block3Data* _data3_);

172

static void __lambda5__gfunc (gconstpointer data, gpointer self);

173

static void _lambda6_ (FolksBackend* i, Block3Data* _data3_);

174

static void __lambda6__gfunc (gconstpointer data, gpointer self);

175

static void _lambda7_ (FolksBackend* i, Block3Data* _data3_);

176

static void __lambda7__gfunc (gconstpointer data, gpointer self);

177

static void _lambda8_ (FolksBackend* i, Block3Data* _data3_);

178

static void __lambda8__gfunc (gconstpointer data, gpointer self);

179

195

static void backend_loading_tests_finalize (GObject* obj);

180

196

gint _vala_main (gchar** args, int args_length1);

181

197

219

235

void* _tmp0_ = NULL;

220

236

const gchar* _tmp1_ = NULL;

221

237

gchar* _tmp2_ = NULL;

222

gchar* _tmp3_;

223

const gchar* _tmp4_ = NULL;

238

gchar* kf_path;

239

GKeyFile* _tmp3_ = NULL;

240

GKeyFile* kf;

241

GFile* _tmp4_ = NULL;

242

GFile* backend_f;

224

243

gchar* _tmp5_ = NULL;

225

gchar* _tmp6_;

244

gchar* data;

245

gint _tmp6_;

246

GError * _inner_error_ = NULL;

226

247

self = (BackendLoadingTests*) base;

227

248

tp_test_backend_set_up (self->priv->_tp_backend);

228

249

_tmp0_ = tp_test_backend_add_account (self->priv->_tp_backend, "protocol", "me@example.com", "cm", "account");

229

250

self->priv->_account_handle = _tmp0_;

230

251

_tmp1_ = g_get_tmp_dir ();

231

252

_tmp2_ = g_build_filename (_tmp1_, BACKEND_LOADING_TESTS_STORE_FILE_PATH, NULL, NULL);

232

_tmp3_ = _tmp2_;

233

g_remove (_tmp3_);

234

_g_free0 (_tmp3_);

235

_tmp4_ = g_get_tmp_dir ();

236

_tmp5_ = g_build_filename (_tmp4_, BACKEND_LOADING_TESTS_STORE_FILE_PATH, NULL, NULL);

237

_tmp6_ = _tmp5_;

238

g_setenv ("FOLKS_BACKEND_STORE_KEY_FILE_PATH", _tmp6_, TRUE);

239

_g_free0 (_tmp6_);

253

kf_path = _tmp2_;

254

g_remove (kf_path);

255

_tmp3_ = g_key_file_new ();

256

kf = _tmp3_;

257

g_key_file_set_boolean (kf, "all-others", "enabled", FALSE);

258

g_key_file_set_boolean (kf, "telepathy", "enabled", TRUE);

259

g_key_file_set_boolean (kf, "key-file", "enabled", TRUE);

260

_tmp4_ = g_file_new_for_path (kf_path);

261

backend_f = _tmp4_;

262

_tmp5_ = g_key_file_to_data (kf, NULL, NULL);

263

data = _tmp5_;

264

_tmp6_ = strlen (data);

265

g_file_replace_contents (backend_f, data, (gsize) _tmp6_, NULL, FALSE, G_FILE_CREATE_PRIVATE, NULL, NULL, &_inner_error_);

266

if (_inner_error_ != NULL) {

267

_g_free0 (data);

268

_g_object_unref0 (backend_f);

269

goto __catch0_g_error;

270

}

271

_g_free0 (data);

272

_g_object_unref0 (backend_f);

273

goto __finally0;

274

__catch0_g_error:

275

{

276

GError * e;

277

e = _inner_error_;

278

_inner_error_ = NULL;

279

g_warning ("backend-loading.vala:49: Could not write updated backend key file '%s'" \

280

": %s", kf_path, e->message);

281

_g_error_free0 (e);

282

}

283

__finally0:

284

if (_inner_error_ != NULL) {

285

_g_key_file_free0 (kf);

286

_g_free0 (kf_path);

287

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

288

g_clear_error (&_inner_error_);

289

return;

290

}

291

g_setenv ("FOLKS_BACKEND_STORE_KEY_FILE_PATH", kf_path, TRUE);

292

_g_key_file_free0 (kf);

293

_g_free0 (kf_path);

240

294

}

241

295

242

296

287

341

}

288

342

289

343

290

static gpointer _g_object_ref0 (gpointer self) {

291

return self ? g_object_ref (self) : NULL;

292

}

293

294

295

static void _lambda2_ (FolksBackend* i, Block1Data* _data1_) {

296

BackendLoadingTests * self;

297

FolksBackend* _tmp0_;

298

FolksBackend* backend;

299

const gchar* _tmp1_ = NULL;

300

gboolean _tmp2_;

301

const gchar* _tmp3_ = NULL;

302

self = _data1_->self;

303

g_return_if_fail (i != NULL);

304

_tmp0_ = _g_object_ref0 (FOLKS_BACKEND (i));

305

backend = _tmp0_;

306

_tmp1_ = folks_backend_get_name (backend);

307

_tmp2_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _data1_->backends_expected, _tmp1_);

308

g_assert (_tmp2_);

309

_tmp3_ = folks_backend_get_name (backend);

310

gee_abstract_collection_remove ((GeeAbstractCollection*) _data1_->backends_expected, _tmp3_);

311

_g_object_unref0 (backend);

312

}

313

314

315

static void __lambda2__gfunc (gconstpointer data, gpointer self) {

316

_lambda2_ (data, self);

317

}

318

319

320

static void _g_object_unref0_ (gpointer var) {

321

(var == NULL) ? NULL : (var = (g_object_unref (var), NULL));

322

}

323

324

325

static void _g_list_free__g_object_unref0_ (GList* self) {

326

g_list_foreach (self, (GFunc) _g_object_unref0_, NULL);

327

g_list_free (self);

328

}

329

330

331

344

static void _lambda1_ (GObject* o, GAsyncResult* r, Block1Data* _data1_) {

332

345

BackendLoadingTests * self;

333

GList* _tmp0_ = NULL;

334

GList* _tmp1_;

335

gint _tmp2_;

346

gint _tmp10_;

336

347

GError * _inner_error_ = NULL;

337

348

self = _data1_->self;

338

349

g_return_if_fail (r != NULL);

339

350

folks_backend_store_load_backends_finish (_data1_->store, r, &_inner_error_);

340

351

if (_inner_error_ != NULL) {

341

goto __catch0_g_error;

342

}

343

_tmp0_ = folks_backend_store_dup_enabled_backends (_data1_->store);

344

_tmp1_ = _tmp0_;

345

g_list_foreach (_tmp1_, __lambda2__gfunc, _data1_);

346

__g_list_free__g_object_unref0_0 (_tmp1_);

347

_tmp2_ = gee_collection_get_size ((GeeCollection*) _data1_->backends_expected);

348

g_assert (_tmp2_ == 0);

352

goto __catch1_g_error;

353

}

354

{

355

GeeMap* _tmp0_ = NULL;

356

GeeCollection* _tmp1_ = NULL;

357

GeeCollection* _tmp2_;

358

GeeIterator* _tmp3_ = NULL;

359

GeeIterator* _tmp4_;

360

GeeIterator* _backend_it;

361

_tmp0_ = folks_backend_store_get_enabled_backends (_data1_->store);

362

_tmp1_ = gee_map_get_values (_tmp0_);

363

_tmp2_ = _tmp1_;

364

_tmp3_ = gee_iterable_iterator ((GeeIterable*) _tmp2_);

365

_tmp4_ = _tmp3_;

366

_g_object_unref0 (_tmp2_);

367

_backend_it = _tmp4_;

368

while (TRUE) {

369

gboolean _tmp5_;

370

gpointer _tmp6_ = NULL;

371

FolksBackend* backend;

372

const gchar* _tmp7_ = NULL;

373

gboolean _tmp8_;

374

const gchar* _tmp9_ = NULL;

375

_tmp5_ = gee_iterator_next (_backend_it);

376

if (!_tmp5_) {

377

break;

378

}

379

_tmp6_ = gee_iterator_get (_backend_it);

380

backend = (FolksBackend*) _tmp6_;

381

_tmp7_ = folks_backend_get_name (backend);

382

_tmp8_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _data1_->backends_expected, _tmp7_);

383

g_assert (_tmp8_);

384

_tmp9_ = folks_backend_get_name (backend);

385

gee_abstract_collection_remove ((GeeAbstractCollection*) _data1_->backends_expected, _tmp9_);

386

_g_object_unref0 (backend);

387

}

388

_g_object_unref0 (_backend_it);

389

}

390

_tmp10_ = gee_collection_get_size ((GeeCollection*) _data1_->backends_expected);

391

g_assert (_tmp10_ == 0);

349

392

g_main_loop_quit (_data1_->main_loop);

350

goto __finally0;

351

__catch0_g_error:

393

goto __finally1;

394

__catch1_g_error:

352

395

{

353

396

GError * e;

354

397

e = _inner_error_;

355

398

_inner_error_ = NULL;

356

g_error ("backend-loading.vala:79: Failed to load backends: %s", e->message);

399

g_error ("backend-loading.vala:97: Failed to load backends: %s", e->message);

357

400

_g_error_free0 (e);

358

401

}

359

__finally0:

402

__finally1:

360

403

if (_inner_error_ != NULL) {

361

404

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

362

405

g_clear_error (&_inner_error_);

396

439

}

397

440

398

441

399

static void _lambda4_ (GObject* o, GAsyncResult* r, BackendLoadingTests* self) {

442

static void _lambda2_ (GObject* o, GAsyncResult* r, BackendLoadingTests* self) {

400

443

g_return_if_fail (r != NULL);

401

444

backend_loading_tests_test_disabling_finish (self, r);

402

445

}

403

446

404

447

405

static void __lambda4__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {

406

_lambda4_ (source_object, res, self);

448

static void __lambda2__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {

449

_lambda2_ (source_object, res, self);

407

450

g_object_unref (self);

408

451

}

409

452

418

461

self->priv->main_loop = _tmp0_;

419

462

_tmp1_ = folks_backend_store_dup ();

420

463

store = _tmp1_;

421

backend_loading_tests_test_disabling_async (self, store, __lambda4__gasync_ready_callback, g_object_ref (self));

464

backend_loading_tests_test_disabling_async (self, store, __lambda2__gasync_ready_callback, g_object_ref (self));

422

465

g_main_loop_run (self->priv->main_loop);

423

466

_g_object_unref0 (store);

424

467

}

433

476

}

434

477

435

478

479

static gpointer _g_object_ref0 (gpointer self) {

480

return self ? g_object_ref (self) : NULL;

481

}

482

483

436

484

static void backend_loading_tests_test_disabling_async (BackendLoadingTests* self, FolksBackendStore* store, GAsyncReadyCallback _callback_, gpointer _user_data_) {

437

485

BackendLoadingTestsTestDisablingAsyncData* _data_;

438

486

_data_ = g_slice_new0 (BackendLoadingTestsTestDisablingAsyncData);

450

498

}

451

499

452

500

453

static Block2Data* block2_data_ref (Block2Data* _data2_) {

454

g_atomic_int_inc (&_data2_->_ref_count_);

455

return _data2_;

456

}

457

458

459

static void block2_data_unref (Block2Data* _data2_) {

460

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

461

_g_object_unref0 (_data2_->self);

462

_g_object_unref0 (_data2_->backends_expected);

463

g_slice_free (Block2Data, _data2_);

464

}

465

}

466

467

468

501

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

469

502

BackendLoadingTestsTestDisablingAsyncData* data;

470

503

data = _user_data_;

474

507

}

475

508

476

509

477

static void _lambda3_ (FolksBackend* i, Block2Data* _data2_) {

478

BackendLoadingTests * self;

479

FolksBackend* _tmp0_;

480

FolksBackend* backend;

481

const gchar* _tmp1_ = NULL;

482

gboolean _tmp2_;

483

const gchar* _tmp3_ = NULL;

484

self = _data2_->self;

485

g_return_if_fail (i != NULL);

486

_tmp0_ = _g_object_ref0 (FOLKS_BACKEND (i));

487

backend = _tmp0_;

488

_tmp1_ = folks_backend_get_name (backend);

489

_tmp2_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _data2_->backends_expected, _tmp1_);

490

g_assert (_tmp2_);

491

_tmp3_ = folks_backend_get_name (backend);

492

gee_abstract_collection_remove ((GeeAbstractCollection*) _data2_->backends_expected, _tmp3_);

493

_g_object_unref0 (backend);

494

}

495

496

497

static void __lambda3__gfunc (gconstpointer data, gpointer self) {

498

_lambda3_ (data, self);

499

}

500

501

502

510

static gboolean backend_loading_tests_test_disabling_async_co (BackendLoadingTestsTestDisablingAsyncData* data) {

503

511

switch (data->_state_) {

504

512

case 0:

513

521

g_assert_not_reached ();

514

522

}

515

523

_state_0:

516

data->_data2_ = g_slice_new0 (Block2Data);

517

data->_data2_->_ref_count_ = 1;

518

data->_data2_->self = g_object_ref (data->self);

519

data->_data2_->_async_data_ = data;

520

524

data->_tmp0_ = NULL;

521

525

data->_tmp0_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);

522

data->_data2_->backends_expected = data->_tmp0_;

523

gee_abstract_collection_add ((GeeAbstractCollection*) data->_data2_->backends_expected, "key-file");

526

data->backends_expected = data->_tmp0_;

527

gee_abstract_collection_add ((GeeAbstractCollection*) data->backends_expected, "key-file");

524

528

data->_state_ = 1;

525

529

folks_backend_store_prepare (data->store, backend_loading_tests_test_disabling_async_ready, data);

526

530

return FALSE;

537

541

_state_3:

538

542

folks_backend_store_load_backends_finish (data->store, data->_res_, &data->_inner_error_);

539

543

if (data->_inner_error_ != NULL) {

540

goto __catch1_g_error;

541

}

542

data->_tmp1_ = NULL;

543

data->_tmp1_ = folks_backend_store_dup_enabled_backends (data->store);

544

data->_tmp2_ = data->_tmp1_;

545

g_list_foreach (data->_tmp2_, __lambda3__gfunc, data->_data2_);

546

__g_list_free__g_object_unref0_0 (data->_tmp2_);

547

data->_tmp3_ = gee_collection_get_size ((GeeCollection*) data->_data2_->backends_expected);

548

g_assert (data->_tmp3_ == 0);

544

goto __catch2_g_error;

545

}

546

{

547

data->_tmp1_ = NULL;

548

data->_tmp1_ = folks_backend_store_get_enabled_backends (data->store);

549

data->_tmp2_ = NULL;

550

data->_tmp2_ = gee_map_get_values (data->_tmp1_);

551

data->_tmp3_ = data->_tmp2_;

552

data->_tmp4_ = NULL;

553

data->_tmp4_ = gee_iterable_iterator ((GeeIterable*) data->_tmp3_);

554

data->_tmp5_ = data->_tmp4_;

555

_g_object_unref0 (data->_tmp3_);

556

data->_backend_it = data->_tmp5_;

557

while (TRUE) {

558

data->_tmp6_ = gee_iterator_next (data->_backend_it);

559

if (!data->_tmp6_) {

560

break;

561

}

562

data->_tmp7_ = NULL;

563

data->_tmp7_ = gee_iterator_get (data->_backend_it);

564

data->backend = (FolksBackend*) data->_tmp7_;

565

data->_tmp8_ = NULL;

566

data->_tmp8_ = folks_backend_get_name (data->backend);

567

data->_tmp9_ = gee_abstract_collection_contains ((GeeAbstractCollection*) data->backends_expected, data->_tmp8_);

568

g_assert (data->_tmp9_);

569

data->_tmp10_ = NULL;

570

data->_tmp10_ = folks_backend_get_name (data->backend);

571

gee_abstract_collection_remove ((GeeAbstractCollection*) data->backends_expected, data->_tmp10_);

572

_g_object_unref0 (data->backend);

573

}

574

_g_object_unref0 (data->_backend_it);

575

}

576

data->_tmp11_ = gee_collection_get_size ((GeeCollection*) data->backends_expected);

577

g_assert (data->_tmp11_ == 0);

549

578

g_main_loop_quit (data->self->priv->main_loop);

550

goto __finally1;

551

__catch1_g_error:

579

goto __finally2;

580

__catch2_g_error:

552

581

{

553

582

data->e = data->_inner_error_;

554

583

data->_inner_error_ = NULL;

555

g_error ("backend-loading.vala:124: Failed to load backends: %s", data->e->message);

584

g_error ("backend-loading.vala:141: Failed to load backends: %s", data->e->message);

556

585

_g_error_free0 (data->e);

557

586

}

558

__finally1:

587

__finally2:

559

588

if (data->_inner_error_ != NULL) {

560

block2_data_unref (data->_data2_);

561

data->_data2_ = NULL;

589

_g_object_unref0 (data->backends_expected);

562

590

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

563

591

g_clear_error (&data->_inner_error_);

564

592

return FALSE;

565

593

}

566

block2_data_unref (data->_data2_);

567

data->_data2_ = NULL;

594

_g_object_unref0 (data->backends_expected);

568

595

if (data->_state_ == 0) {

569

596

g_simple_async_result_complete_in_idle (data->_async_result);

570

597

} else {

575

602

}

576

603

577

604

578

static void _lambda9_ (GObject* o, GAsyncResult* r, BackendLoadingTests* self) {

605

static void _lambda3_ (GObject* o, GAsyncResult* r, BackendLoadingTests* self) {

579

606

g_return_if_fail (r != NULL);

580

607

backend_loading_tests_test_reloading_finish (self, r);

581

608

}

582

609

583

610

584

static void __lambda9__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {

585

_lambda9_ (source_object, res, self);

611

static void __lambda3__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {

612

_lambda3_ (source_object, res, self);

586

613

g_object_unref (self);

587

614

}

588

615

597

624

self->priv->main_loop = _tmp0_;

598

625

_tmp1_ = folks_backend_store_dup ();

599

626

store = _tmp1_;

600

backend_loading_tests_test_reloading_async (self, store, __lambda9__gasync_ready_callback, g_object_ref (self));

627

backend_loading_tests_test_reloading_async (self, store, __lambda3__gasync_ready_callback, g_object_ref (self));

601

628

g_main_loop_run (self->priv->main_loop);

602

629

_g_object_unref0 (store);

603

630

}

629

656

}

630

657

631

658

632

static Block3Data* block3_data_ref (Block3Data* _data3_) {

633

g_atomic_int_inc (&_data3_->_ref_count_);

634

return _data3_;

635

}

636

637

638

static void block3_data_unref (Block3Data* _data3_) {

639

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

640

_g_object_unref0 (_data3_->self);

641

_g_object_unref0 (_data3_->backends_expected);

642

g_slice_free (Block3Data, _data3_);

643

}

644

}

645

646

647

659

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

648

660

BackendLoadingTestsTestReloadingAsyncData* data;

649

661

data = _user_data_;

653

665

}

654

666

655

667

656

static void _lambda5_ (FolksBackend* i, Block3Data* _data3_) {

657

BackendLoadingTests * self;

658

FolksBackend* _tmp0_;

659

FolksBackend* backend;

660

const gchar* _tmp1_ = NULL;

661

gboolean _tmp2_;

662

const gchar* _tmp3_ = NULL;

663

self = _data3_->self;

664

g_return_if_fail (i != NULL);

665

_tmp0_ = _g_object_ref0 (FOLKS_BACKEND (i));

666

backend = _tmp0_;

667

_tmp1_ = folks_backend_get_name (backend);

668

_tmp2_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _data3_->backends_expected, _tmp1_);

669

g_assert (_tmp2_);

670

_tmp3_ = folks_backend_get_name (backend);

671

gee_abstract_collection_remove ((GeeAbstractCollection*) _data3_->backends_expected, _tmp3_);

672

_g_object_unref0 (backend);

673

}

674

675

676

static void __lambda5__gfunc (gconstpointer data, gpointer self) {

677

_lambda5_ (data, self);

678

}

679

680

681

static void _lambda6_ (FolksBackend* i, Block3Data* _data3_) {

682

BackendLoadingTests * self;

683

FolksBackend* _tmp0_;

684

FolksBackend* backend;

685

const gchar* _tmp1_ = NULL;

686

gboolean _tmp2_;

687

const gchar* _tmp3_ = NULL;

688

self = _data3_->self;

689

g_return_if_fail (i != NULL);

690

_tmp0_ = _g_object_ref0 (FOLKS_BACKEND (i));

691

backend = _tmp0_;

692

_tmp1_ = folks_backend_get_name (backend);

693

_tmp2_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _data3_->backends_expected, _tmp1_);

694

g_assert (_tmp2_);

695

_tmp3_ = folks_backend_get_name (backend);

696

gee_abstract_collection_remove ((GeeAbstractCollection*) _data3_->backends_expected, _tmp3_);

697

_g_object_unref0 (backend);

698

}

699

700

701

static void __lambda6__gfunc (gconstpointer data, gpointer self) {

702

_lambda6_ (data, self);

703

}

704

705

706

static void _lambda7_ (FolksBackend* i, Block3Data* _data3_) {

707

BackendLoadingTests * self;

708

FolksBackend* _tmp0_;

709

FolksBackend* backend;

710

const gchar* _tmp1_ = NULL;

711

gboolean _tmp2_;

712

const gchar* _tmp3_ = NULL;

713

self = _data3_->self;

714

g_return_if_fail (i != NULL);

715

_tmp0_ = _g_object_ref0 (FOLKS_BACKEND (i));

716

backend = _tmp0_;

717

_tmp1_ = folks_backend_get_name (backend);

718

_tmp2_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _data3_->backends_expected, _tmp1_);

719

g_assert (_tmp2_);

720

_tmp3_ = folks_backend_get_name (backend);

721

gee_abstract_collection_remove ((GeeAbstractCollection*) _data3_->backends_expected, _tmp3_);

722

_g_object_unref0 (backend);

723

}

724

725

726

static void __lambda7__gfunc (gconstpointer data, gpointer self) {

727

_lambda7_ (data, self);

728

}

729

730

731

static void _lambda8_ (FolksBackend* i, Block3Data* _data3_) {

732

BackendLoadingTests * self;

733

FolksBackend* _tmp0_;

734

FolksBackend* backend;

735

const gchar* _tmp1_ = NULL;

736

gboolean _tmp2_;

737

const gchar* _tmp3_ = NULL;

738

self = _data3_->self;

739

g_return_if_fail (i != NULL);

740

_tmp0_ = _g_object_ref0 (FOLKS_BACKEND (i));

741

backend = _tmp0_;

742

_tmp1_ = folks_backend_get_name (backend);

743

_tmp2_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _data3_->backends_expected, _tmp1_);

744

g_assert (_tmp2_);

745

_tmp3_ = folks_backend_get_name (backend);

746

gee_abstract_collection_remove ((GeeAbstractCollection*) _data3_->backends_expected, _tmp3_);

747

_g_object_unref0 (backend);

748

}

749

750

751

static void __lambda8__gfunc (gconstpointer data, gpointer self) {

752

_lambda8_ (data, self);

753

}

754

755

756

668

static gboolean backend_loading_tests_test_reloading_async_co (BackendLoadingTestsTestReloadingAsyncData* data) {

757

669

switch (data->_state_) {

758

670

case 0:

773

685

g_assert_not_reached ();

774

686

}

775

687

_state_0:

776

data->_data3_ = g_slice_new0 (Block3Data);

777

data->_data3_->_ref_count_ = 1;

778

data->_data3_->self = g_object_ref (data->self);

779

data->_data3_->_async_data_ = data;

780

688

data->_tmp0_ = NULL;

781

689

data->_tmp0_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);

782

_g_object_unref0 (data->_data3_->backends_expected);

783

data->_data3_->backends_expected = data->_tmp0_;

784

gee_abstract_collection_add ((GeeAbstractCollection*) data->_data3_->backends_expected, "key-file");

785

gee_abstract_collection_add ((GeeAbstractCollection*) data->_data3_->backends_expected, "telepathy");

690

_g_object_unref0 (data->backends_expected);

691

data->backends_expected = data->_tmp0_;

692

gee_abstract_collection_add ((GeeAbstractCollection*) data->backends_expected, "key-file");

693

gee_abstract_collection_add ((GeeAbstractCollection*) data->backends_expected, "telepathy");

786

694

data->_state_ = 1;

787

695

folks_backend_store_load_backends (data->store, backend_loading_tests_test_reloading_async_ready, data);

788

696

return FALSE;

789

697

_state_1:

790

698

folks_backend_store_load_backends_finish (data->store, data->_res_, &data->_inner_error_);

791

699

if (data->_inner_error_ != NULL) {

792

goto __catch2_g_error;

793

}

794

data->_tmp1_ = NULL;

795

data->_tmp1_ = folks_backend_store_dup_enabled_backends (data->store);

796

data->_tmp2_ = data->_tmp1_;

797

g_list_foreach (data->_tmp2_, __lambda5__gfunc, data->_data3_);

798

__g_list_free__g_object_unref0_0 (data->_tmp2_);

799

data->_tmp3_ = gee_collection_get_size ((GeeCollection*) data->_data3_->backends_expected);

800

g_assert (data->_tmp3_ == 0);

801

goto __finally2;

802

__catch2_g_error:

700

goto __catch3_g_error;

701

}

702

{

703

data->_tmp1_ = NULL;

704

data->_tmp1_ = folks_backend_store_get_enabled_backends (data->store);

705

data->_tmp2_ = NULL;

706

data->_tmp2_ = gee_map_get_values (data->_tmp1_);

707

data->_tmp3_ = data->_tmp2_;

708

data->_tmp4_ = NULL;

709

data->_tmp4_ = gee_iterable_iterator ((GeeIterable*) data->_tmp3_);

710

data->_tmp5_ = data->_tmp4_;

711

_g_object_unref0 (data->_tmp3_);

712

data->_backend1_it = data->_tmp5_;

713

while (TRUE) {

714

data->_tmp6_ = gee_iterator_next (data->_backend1_it);

715

if (!data->_tmp6_) {

716

break;

717

}

718

data->_tmp7_ = NULL;

719

data->_tmp7_ = gee_iterator_get (data->_backend1_it);

720

data->backend1 = (FolksBackend*) data->_tmp7_;

721

data->_tmp8_ = NULL;

722

data->_tmp8_ = folks_backend_get_name (data->backend1);

723

data->_tmp9_ = gee_abstract_collection_contains ((GeeAbstractCollection*) data->backends_expected, data->_tmp8_);

724

g_assert (data->_tmp9_);

725

data->_tmp10_ = NULL;

726

data->_tmp10_ = folks_backend_get_name (data->backend1);

727

gee_abstract_collection_remove ((GeeAbstractCollection*) data->backends_expected, data->_tmp10_);

728

_g_object_unref0 (data->backend1);

729

}

730

_g_object_unref0 (data->_backend1_it);

731

}

732

data->_tmp11_ = gee_collection_get_size ((GeeCollection*) data->backends_expected);

733

g_assert (data->_tmp11_ == 0);

734

goto __finally3;

735

__catch3_g_error:

803

736

{

804

737

data->e1 = data->_inner_error_;

805

738

data->_inner_error_ = NULL;

806

g_error ("backend-loading.vala:167: Failed to load backends: %s", data->e1->message);

739

g_error ("backend-loading.vala:183: Failed to load backends: %s", data->e1->message);

807

740

_g_error_free0 (data->e1);

808

741

}

809

__finally2:

742

__finally3:

810

743

if (data->_inner_error_ != NULL) {

811

block3_data_unref (data->_data3_);

812

data->_data3_ = NULL;

744

_g_object_unref0 (data->backends_expected);

813

745

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

814

746

g_clear_error (&data->_inner_error_);

815

747

return FALSE;

816

748

}

817

data->_tmp4_ = NULL;

818

data->_tmp4_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);

819

_g_object_unref0 (data->_data3_->backends_expected);

820

data->_data3_->backends_expected = data->_tmp4_;

821

gee_abstract_collection_add ((GeeAbstractCollection*) data->_data3_->backends_expected, "telepathy");

749

data->_tmp12_ = NULL;

750

data->_tmp12_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);

751

_g_object_unref0 (data->backends_expected);

752

data->backends_expected = data->_tmp12_;

753

gee_abstract_collection_add ((GeeAbstractCollection*) data->backends_expected, "telepathy");

822

754

data->_state_ = 2;

823

755

folks_backend_store_disable_backend (data->store, "key-file", backend_loading_tests_test_reloading_async_ready, data);

824

756

return FALSE;

830

762

_state_3:

831

763

folks_backend_store_load_backends_finish (data->store, data->_res_, &data->_inner_error_);

832

764

if (data->_inner_error_ != NULL) {

833

goto __catch3_g_error;

834

}

835

data->_tmp5_ = NULL;

836

data->_tmp5_ = folks_backend_store_dup_enabled_backends (data->store);

837

data->_tmp6_ = data->_tmp5_;

838

g_list_foreach (data->_tmp6_, __lambda6__gfunc, data->_data3_);

839

__g_list_free__g_object_unref0_0 (data->_tmp6_);

840

data->_tmp7_ = gee_collection_get_size ((GeeCollection*) data->_data3_->backends_expected);

841

g_assert (data->_tmp7_ == 0);

842

goto __finally3;

843

__catch3_g_error:

765

goto __catch4_g_error;

766

}

767

{

768

data->_tmp13_ = NULL;

769

data->_tmp13_ = folks_backend_store_get_enabled_backends (data->store);

770

data->_tmp14_ = NULL;

771

data->_tmp14_ = gee_map_get_values (data->_tmp13_);

772

data->_tmp15_ = data->_tmp14_;

773

data->_tmp16_ = NULL;

774

data->_tmp16_ = gee_iterable_iterator ((GeeIterable*) data->_tmp15_);

775

data->_tmp17_ = data->_tmp16_;

776

_g_object_unref0 (data->_tmp15_);

777

data->_backend2_it = data->_tmp17_;

778

while (TRUE) {

779

data->_tmp18_ = gee_iterator_next (data->_backend2_it);

780

if (!data->_tmp18_) {

781

break;

782

}

783

data->_tmp19_ = NULL;

784

data->_tmp19_ = gee_iterator_get (data->_backend2_it);

785

data->backend2 = (FolksBackend*) data->_tmp19_;

786

data->_tmp20_ = NULL;

787

data->_tmp20_ = folks_backend_get_name (data->backend2);

788

data->_tmp21_ = gee_abstract_collection_contains ((GeeAbstractCollection*) data->backends_expected, data->_tmp20_);

789

g_assert (data->_tmp21_);

790

data->_tmp22_ = NULL;

791

data->_tmp22_ = folks_backend_get_name (data->backend2);

792

gee_abstract_collection_remove ((GeeAbstractCollection*) data->backends_expected, data->_tmp22_);

793

_g_object_unref0 (data->backend2);

794

}

795

_g_object_unref0 (data->_backend2_it);

796

}

797

data->_tmp23_ = gee_collection_get_size ((GeeCollection*) data->backends_expected);

798

g_assert (data->_tmp23_ == 0);

799

goto __finally4;

800

__catch4_g_error:

844

801

{

845

802

data->e2 = data->_inner_error_;

846

803

data->_inner_error_ = NULL;

847

g_error ("backend-loading.vala:195: Failed to load backends: %s", data->e2->message);

804

g_error ("backend-loading.vala:210: Failed to load backends: %s", data->e2->message);

848

805

_g_error_free0 (data->e2);

849

806

}

850

__finally3:

807

__finally4:

851

808

if (data->_inner_error_ != NULL) {

852

block3_data_unref (data->_data3_);

853

data->_data3_ = NULL;

809

_g_object_unref0 (data->backends_expected);

854

810

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

855

811

g_clear_error (&data->_inner_error_);

856

812

return FALSE;

857

813

}

858

data->_tmp8_ = NULL;

859

data->_tmp8_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);

860

_g_object_unref0 (data->_data3_->backends_expected);

861

data->_data3_->backends_expected = data->_tmp8_;

862

gee_abstract_collection_add ((GeeAbstractCollection*) data->_data3_->backends_expected, "key-file");

863

gee_abstract_collection_add ((GeeAbstractCollection*) data->_data3_->backends_expected, "telepathy");

814

data->_tmp24_ = NULL;

815

data->_tmp24_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);

816

_g_object_unref0 (data->backends_expected);

817

data->backends_expected = data->_tmp24_;

818

gee_abstract_collection_add ((GeeAbstractCollection*) data->backends_expected, "key-file");

819

gee_abstract_collection_add ((GeeAbstractCollection*) data->backends_expected, "telepathy");

864

820

data->_state_ = 4;

865

821

folks_backend_store_enable_backend (data->store, "key-file", backend_loading_tests_test_reloading_async_ready, data);

866

822

return FALSE;

872

828

_state_5:

873

829

folks_backend_store_load_backends_finish (data->store, data->_res_, &data->_inner_error_);

874

830

if (data->_inner_error_ != NULL) {

875

goto __catch4_g_error;

876

}

877

data->_tmp9_ = NULL;

878

data->_tmp9_ = folks_backend_store_dup_enabled_backends (data->store);

879

data->_tmp10_ = data->_tmp9_;

880

g_list_foreach (data->_tmp10_, __lambda7__gfunc, data->_data3_);

881

__g_list_free__g_object_unref0_0 (data->_tmp10_);

882

data->_tmp11_ = gee_collection_get_size ((GeeCollection*) data->_data3_->backends_expected);

883

g_assert (data->_tmp11_ == 0);

884

goto __finally4;

885

__catch4_g_error:

831

goto __catch5_g_error;

832

}

833

{

834

data->_tmp25_ = NULL;

835

data->_tmp25_ = folks_backend_store_get_enabled_backends (data->store);

836

data->_tmp26_ = NULL;

837

data->_tmp26_ = gee_map_get_values (data->_tmp25_);

838

data->_tmp27_ = data->_tmp26_;

839

data->_tmp28_ = NULL;

840

data->_tmp28_ = gee_iterable_iterator ((GeeIterable*) data->_tmp27_);

841

data->_tmp29_ = data->_tmp28_;

842

_g_object_unref0 (data->_tmp27_);

843

data->_backend3_it = data->_tmp29_;

844

while (TRUE) {

845

data->_tmp30_ = gee_iterator_next (data->_backend3_it);

846

if (!data->_tmp30_) {

847

break;

848

}

849

data->_tmp31_ = NULL;

850

data->_tmp31_ = gee_iterator_get (data->_backend3_it);

851

data->backend3 = (FolksBackend*) data->_tmp31_;

852

data->_tmp32_ = NULL;

853

data->_tmp32_ = folks_backend_get_name (data->backend3);

854

data->_tmp33_ = gee_abstract_collection_contains ((GeeAbstractCollection*) data->backends_expected, data->_tmp32_);

855

g_assert (data->_tmp33_);

856

data->_tmp34_ = NULL;

857

data->_tmp34_ = folks_backend_get_name (data->backend3);

858

gee_abstract_collection_remove ((GeeAbstractCollection*) data->backends_expected, data->_tmp34_);

859

_g_object_unref0 (data->backend3);

860

}

861

_g_object_unref0 (data->_backend3_it);

862

}

863

data->_tmp35_ = gee_collection_get_size ((GeeCollection*) data->backends_expected);

864

g_assert (data->_tmp35_ == 0);

865

goto __finally5;

866

__catch5_g_error:

886

867

{

887

868

data->e3 = data->_inner_error_;

888

869

data->_inner_error_ = NULL;

889

g_error ("backend-loading.vala:224: Failed to load backends: %s", data->e3->message);

870

g_error ("backend-loading.vala:238: Failed to load backends: %s", data->e3->message);

890

871

_g_error_free0 (data->e3);

891

872

}

892

__finally4:

873

__finally5:

893

874

if (data->_inner_error_ != NULL) {

894

block3_data_unref (data->_data3_);

895

data->_data3_ = NULL;

875

_g_object_unref0 (data->backends_expected);

896

876

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

897

877

g_clear_error (&data->_inner_error_);

898

878

return FALSE;

899

879

}

900

data->_tmp12_ = NULL;

901

data->_tmp12_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);

902

_g_object_unref0 (data->_data3_->backends_expected);

903

data->_data3_->backends_expected = data->_tmp12_;

904

gee_abstract_collection_add ((GeeAbstractCollection*) data->_data3_->backends_expected, "key-file");

905

gee_abstract_collection_add ((GeeAbstractCollection*) data->_data3_->backends_expected, "telepathy");

880

data->_tmp36_ = NULL;

881

data->_tmp36_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal);

882

_g_object_unref0 (data->backends_expected);

883

data->backends_expected = data->_tmp36_;

884

gee_abstract_collection_add ((GeeAbstractCollection*) data->backends_expected, "key-file");

885

gee_abstract_collection_add ((GeeAbstractCollection*) data->backends_expected, "telepathy");

906

886

data->_state_ = 6;

907

887

folks_backend_store_load_backends (data->store, backend_loading_tests_test_reloading_async_ready, data);

908

888

return FALSE;

909

889

_state_6:

910

890

folks_backend_store_load_backends_finish (data->store, data->_res_, &data->_inner_error_);

911

891

if (data->_inner_error_ != NULL) {

912

goto __catch5_g_error;

913

}

914

data->_tmp13_ = NULL;

915

data->_tmp13_ = folks_backend_store_dup_enabled_backends (data->store);

916

data->_tmp14_ = data->_tmp13_;

917

g_list_foreach (data->_tmp14_, __lambda8__gfunc, data->_data3_);

918

__g_list_free__g_object_unref0_0 (data->_tmp14_);

919

data->_tmp15_ = gee_collection_get_size ((GeeCollection*) data->_data3_->backends_expected);

920

g_assert (data->_tmp15_ == 0);

921

goto __finally5;

922

__catch5_g_error:

892

goto __catch6_g_error;

893

}

894

{

895

data->_tmp37_ = NULL;

896

data->_tmp37_ = folks_backend_store_get_enabled_backends (data->store);

897

data->_tmp38_ = NULL;

898

data->_tmp38_ = gee_map_get_values (data->_tmp37_);

899

data->_tmp39_ = data->_tmp38_;

900

data->_tmp40_ = NULL;

901

data->_tmp40_ = gee_iterable_iterator ((GeeIterable*) data->_tmp39_);

902

data->_tmp41_ = data->_tmp40_;

903

_g_object_unref0 (data->_tmp39_);

904

data->_backend_it = data->_tmp41_;

905

while (TRUE) {

906

data->_tmp42_ = gee_iterator_next (data->_backend_it);

907

if (!data->_tmp42_) {

908

break;

909

}

910

data->_tmp43_ = NULL;

911

data->_tmp43_ = gee_iterator_get (data->_backend_it);

912

data->backend = (FolksBackend*) data->_tmp43_;

913

data->_tmp44_ = NULL;

914

data->_tmp44_ = folks_backend_get_name (data->backend);

915

data->_tmp45_ = gee_abstract_collection_contains ((GeeAbstractCollection*) data->backends_expected, data->_tmp44_);

916

g_assert (data->_tmp45_);

917

data->_tmp46_ = NULL;

918

data->_tmp46_ = folks_backend_get_name (data->backend);

919

gee_abstract_collection_remove ((GeeAbstractCollection*) data->backends_expected, data->_tmp46_);

920

_g_object_unref0 (data->backend);

921

}

922

_g_object_unref0 (data->_backend_it);

923

}

924

data->_tmp47_ = gee_collection_get_size ((GeeCollection*) data->backends_expected);

925

g_assert (data->_tmp47_ == 0);

926

goto __finally6;

927

__catch6_g_error:

923

928

{

924

929

data->e4 = data->_inner_error_;

925

930

data->_inner_error_ = NULL;

926

g_error ("backend-loading.vala:252: Failed to load backends: %s", data->e4->message);

931

g_error ("backend-loading.vala:264: Failed to load backends: %s", data->e4->message);

927

932

_g_error_free0 (data->e4);

928

933

}

929

__finally5:

934

__finally6:

930

935

if (data->_inner_error_ != NULL) {

931

block3_data_unref (data->_data3_);

932

data->_data3_ = NULL;

936

_g_object_unref0 (data->backends_expected);

933

937

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

934

938

g_clear_error (&data->_inner_error_);

935

939

return FALSE;

936

940

}

937

941

g_main_loop_quit (data->self->priv->main_loop);

938

block3_data_unref (data->_data3_);

939

data->_data3_ = NULL;

942

_g_object_unref0 (data->backends_expected);

940

943

if (data->_state_ == 0) {

941

944

g_simple_async_result_complete_in_idle (data->_async_result);

942

945

} else {

Older »