generated/googleapis/test/orkut/v2.dart - Issue 560323003: Add discovery service to stable APIs

Side by Side Diff: generated/googleapis/test/orkut/v2.dart

Issue 560323003: Add discovery service to stable APIs (Closed) Base URL: git@github.com:dart-lang/googleapis.git@master

Patch Set: New generator hash in pubspec.yaml, test files renamed ot have _test.dart postfix Created 6 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 library googleapis.orkut.v2.test;

2

3 import "dart:core" as core;

4 import "dart:collection" as collection;

5 import "dart:async" as async;

6 import "dart:convert" as convert;

7

8 import 'package:http/http.dart' as http;

9 import 'package:http/testing.dart' as http_testing;

10 import 'package:unittest/unittest.dart' as unittest;

11 import 'package:googleapis/common/common.dart' as common;

12 import 'package:googleapis/src/common_internal.dart' as common_internal;

13 import '../common/common_internal_test.dart' as common_test;

14

15 import 'package:googleapis/orkut/v2.dart' as api;

16

17

18

19 core.int buildCounterAclItems = 0;

20 buildAclItems() {

21 var o = new api.AclItems();

22 buildCounterAclItems++;

23 if (buildCounterAclItems < 3) {

24 o.id = "foo";

25 o.type = "foo";

26 }

27 buildCounterAclItems--;

28 return o;

29 }

30

31 checkAclItems(api.AclItems o) {

32 buildCounterAclItems++;

33 if (buildCounterAclItems < 3) {

34 unittest.expect(o.id, unittest.equals('foo'));

35 unittest.expect(o.type, unittest.equals('foo'));

36 }

37 buildCounterAclItems--;

38 }

39

40 buildUnnamed140() {

41 var o = new core.List<api.AclItems>();

42 o.add(buildAclItems());

43 o.add(buildAclItems());

44 return o;

45 }

46

47 checkUnnamed140(core.List<api.AclItems> o) {

48 unittest.expect(o, unittest.hasLength(2));

49 checkAclItems(o[0]);

50 checkAclItems(o[1]);

51 }

52

53 core.int buildCounterAcl = 0;

54 buildAcl() {

55 var o = new api.Acl();

56 buildCounterAcl++;

57 if (buildCounterAcl < 3) {

58 o.description = "foo";

59 o.items = buildUnnamed140();

60 o.kind = "foo";

61 o.totalParticipants = 42;

62 }

63 buildCounterAcl--;

64 return o;

65 }

66

67 checkAcl(api.Acl o) {

68 buildCounterAcl++;

69 if (buildCounterAcl < 3) {

70 unittest.expect(o.description, unittest.equals('foo'));

71 checkUnnamed140(o.items);

72 unittest.expect(o.kind, unittest.equals('foo'));

73 unittest.expect(o.totalParticipants, unittest.equals(42));

74 }

75 buildCounterAcl--;

76 }

77

78 buildUnnamed141() {

79 var o = new core.List<api.OrkutLinkResource>();

80 o.add(buildOrkutLinkResource());

81 o.add(buildOrkutLinkResource());

82 return o;

83 }

84

85 checkUnnamed141(core.List<api.OrkutLinkResource> o) {

86 unittest.expect(o, unittest.hasLength(2));

87 checkOrkutLinkResource(o[0]);

88 checkOrkutLinkResource(o[1]);

89 }

90

91 buildUnnamed142() {

92 var o = new core.List<api.OrkutActivityobjectsResource>();

93 o.add(buildOrkutActivityobjectsResource());

94 o.add(buildOrkutActivityobjectsResource());

95 return o;

96 }

97

98 checkUnnamed142(core.List<api.OrkutActivityobjectsResource> o) {

99 unittest.expect(o, unittest.hasLength(2));

100 checkOrkutActivityobjectsResource(o[0]);

101 checkOrkutActivityobjectsResource(o[1]);

102 }

103

104 buildUnnamed143() {

105 var o = new core.List<api.Comment>();

106 o.add(buildComment());

107 o.add(buildComment());

108 return o;

109 }

110

111 checkUnnamed143(core.List<api.Comment> o) {

112 unittest.expect(o, unittest.hasLength(2));

113 checkComment(o[0]);

114 checkComment(o[1]);

115 }

116

117 core.int buildCounterActivityObjectReplies = 0;

118 buildActivityObjectReplies() {

119 var o = new api.ActivityObjectReplies();

120 buildCounterActivityObjectReplies++;

121 if (buildCounterActivityObjectReplies < 3) {

122 o.items = buildUnnamed143();

123 o.totalItems = "foo";

124 o.url = "foo";

125 }

126 buildCounterActivityObjectReplies--;

127 return o;

128 }

129

130 checkActivityObjectReplies(api.ActivityObjectReplies o) {

131 buildCounterActivityObjectReplies++;

132 if (buildCounterActivityObjectReplies < 3) {

133 checkUnnamed143(o.items);

134 unittest.expect(o.totalItems, unittest.equals('foo'));

135 unittest.expect(o.url, unittest.equals('foo'));

136 }

137 buildCounterActivityObjectReplies--;

138 }

139

140 core.int buildCounterActivityObject = 0;

141 buildActivityObject() {

142 var o = new api.ActivityObject();

143 buildCounterActivityObject++;

144 if (buildCounterActivityObject < 3) {

145 o.content = "foo";

146 o.items = buildUnnamed142();

147 o.objectType = "foo";

148 o.replies = buildActivityObjectReplies();

149 }

150 buildCounterActivityObject--;

151 return o;

152 }

153

154 checkActivityObject(api.ActivityObject o) {

155 buildCounterActivityObject++;

156 if (buildCounterActivityObject < 3) {

157 unittest.expect(o.content, unittest.equals('foo'));

158 checkUnnamed142(o.items);

159 unittest.expect(o.objectType, unittest.equals('foo'));

160 checkActivityObjectReplies(o.replies);

161 }

162 buildCounterActivityObject--;

163 }

164

165 core.int buildCounterActivity = 0;

166 buildActivity() {

167 var o = new api.Activity();

168 buildCounterActivity++;

169 if (buildCounterActivity < 3) {

170 o.access = buildAcl();

171 o.actor = buildOrkutAuthorResource();

172 o.id = "foo";

173 o.kind = "foo";

174 o.links = buildUnnamed141();

175 o.object = buildActivityObject();

176 o.published = core.DateTime.parse("2002-02-27T14:01:02");

177 o.title = "foo";

178 o.updated = core.DateTime.parse("2002-02-27T14:01:02");

179 o.verb = "foo";

180 }

181 buildCounterActivity--;

182 return o;

183 }

184

185 checkActivity(api.Activity o) {

186 buildCounterActivity++;

187 if (buildCounterActivity < 3) {

188 checkAcl(o.access);

189 checkOrkutAuthorResource(o.actor);

190 unittest.expect(o.id, unittest.equals('foo'));

191 unittest.expect(o.kind, unittest.equals('foo'));

192 checkUnnamed141(o.links);

193 checkActivityObject(o.object);

194 unittest.expect(o.published, unittest.equals(core.DateTime.parse("2002-02-27 T14:01:02")));

195 unittest.expect(o.title, unittest.equals('foo'));

196 unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T1 4:01:02")));

197 unittest.expect(o.verb, unittest.equals('foo'));

198 }

199 buildCounterActivity--;

200 }

201

202 buildUnnamed144() {

203 var o = new core.List<api.Activity>();

204 o.add(buildActivity());

205 o.add(buildActivity());

206 return o;

207 }

208

209 checkUnnamed144(core.List<api.Activity> o) {

210 unittest.expect(o, unittest.hasLength(2));

211 checkActivity(o[0]);

212 checkActivity(o[1]);

213 }

214

215 core.int buildCounterActivityList = 0;

216 buildActivityList() {

217 var o = new api.ActivityList();

218 buildCounterActivityList++;

219 if (buildCounterActivityList < 3) {

220 o.items = buildUnnamed144();

221 o.kind = "foo";

222 o.nextPageToken = "foo";

223 }

224 buildCounterActivityList--;

225 return o;

226 }

227

228 checkActivityList(api.ActivityList o) {

229 buildCounterActivityList++;

230 if (buildCounterActivityList < 3) {

231 checkUnnamed144(o.items);

232 unittest.expect(o.kind, unittest.equals('foo'));

233 unittest.expect(o.nextPageToken, unittest.equals('foo'));

234 }

235 buildCounterActivityList--;

236 }

237

238 core.int buildCounterBadge = 0;

239 buildBadge() {

240 var o = new api.Badge();

241 buildCounterBadge++;

242 if (buildCounterBadge < 3) {

243 o.badgeLargeLogo = "foo";

244 o.badgeSmallLogo = "foo";

245 o.caption = "foo";

246 o.description = "foo";

247 o.id = "foo";

248 o.kind = "foo";

249 o.sponsorLogo = "foo";

250 o.sponsorName = "foo";

251 o.sponsorUrl = "foo";

252 }

253 buildCounterBadge--;

254 return o;

255 }

256

257 checkBadge(api.Badge o) {

258 buildCounterBadge++;

259 if (buildCounterBadge < 3) {

260 unittest.expect(o.badgeLargeLogo, unittest.equals('foo'));

261 unittest.expect(o.badgeSmallLogo, unittest.equals('foo'));

262 unittest.expect(o.caption, unittest.equals('foo'));

263 unittest.expect(o.description, unittest.equals('foo'));

264 unittest.expect(o.id, unittest.equals('foo'));

265 unittest.expect(o.kind, unittest.equals('foo'));

266 unittest.expect(o.sponsorLogo, unittest.equals('foo'));

267 unittest.expect(o.sponsorName, unittest.equals('foo'));

268 unittest.expect(o.sponsorUrl, unittest.equals('foo'));

269 }

270 buildCounterBadge--;

271 }

272

273 buildUnnamed145() {

274 var o = new core.List<api.Badge>();

275 o.add(buildBadge());

276 o.add(buildBadge());

277 return o;

278 }

279

280 checkUnnamed145(core.List<api.Badge> o) {

281 unittest.expect(o, unittest.hasLength(2));

282 checkBadge(o[0]);

283 checkBadge(o[1]);

284 }

285

286 core.int buildCounterBadgeList = 0;

287 buildBadgeList() {

288 var o = new api.BadgeList();

289 buildCounterBadgeList++;

290 if (buildCounterBadgeList < 3) {

291 o.items = buildUnnamed145();

292 o.kind = "foo";

293 }

294 buildCounterBadgeList--;

295 return o;

296 }

297

298 checkBadgeList(api.BadgeList o) {

299 buildCounterBadgeList++;

300 if (buildCounterBadgeList < 3) {

301 checkUnnamed145(o.items);

302 unittest.expect(o.kind, unittest.equals('foo'));

303 }

304 buildCounterBadgeList--;

305 }

306

307 core.int buildCounterCommentInReplyTo = 0;

308 buildCommentInReplyTo() {

309 var o = new api.CommentInReplyTo();

310 buildCounterCommentInReplyTo++;

311 if (buildCounterCommentInReplyTo < 3) {

312 o.href = "foo";

313 o.ref = "foo";

314 o.rel = "foo";

315 o.type = "foo";

316 }

317 buildCounterCommentInReplyTo--;

318 return o;

319 }

320

321 checkCommentInReplyTo(api.CommentInReplyTo o) {

322 buildCounterCommentInReplyTo++;

323 if (buildCounterCommentInReplyTo < 3) {

324 unittest.expect(o.href, unittest.equals('foo'));

325 unittest.expect(o.ref, unittest.equals('foo'));

326 unittest.expect(o.rel, unittest.equals('foo'));

327 unittest.expect(o.type, unittest.equals('foo'));

328 }

329 buildCounterCommentInReplyTo--;

330 }

331

332 buildUnnamed146() {

333 var o = new core.List<api.OrkutLinkResource>();

334 o.add(buildOrkutLinkResource());

335 o.add(buildOrkutLinkResource());

336 return o;

337 }

338

339 checkUnnamed146(core.List<api.OrkutLinkResource> o) {

340 unittest.expect(o, unittest.hasLength(2));

341 checkOrkutLinkResource(o[0]);

342 checkOrkutLinkResource(o[1]);

343 }

344

345 core.int buildCounterComment = 0;

346 buildComment() {

347 var o = new api.Comment();

348 buildCounterComment++;

349 if (buildCounterComment < 3) {

350 o.actor = buildOrkutAuthorResource();

351 o.content = "foo";

352 o.id = "foo";

353 o.inReplyTo = buildCommentInReplyTo();

354 o.kind = "foo";

355 o.links = buildUnnamed146();

356 o.published = core.DateTime.parse("2002-02-27T14:01:02");

357 }

358 buildCounterComment--;

359 return o;

360 }

361

362 checkComment(api.Comment o) {

363 buildCounterComment++;

364 if (buildCounterComment < 3) {

365 checkOrkutAuthorResource(o.actor);

366 unittest.expect(o.content, unittest.equals('foo'));

367 unittest.expect(o.id, unittest.equals('foo'));

368 checkCommentInReplyTo(o.inReplyTo);

369 unittest.expect(o.kind, unittest.equals('foo'));

370 checkUnnamed146(o.links);

371 unittest.expect(o.published, unittest.equals(core.DateTime.parse("2002-02-27 T14:01:02")));

372 }

373 buildCounterComment--;

374 }

375

376 buildUnnamed147() {

377 var o = new core.List<api.Comment>();

378 o.add(buildComment());

379 o.add(buildComment());

380 return o;

381 }

382

383 checkUnnamed147(core.List<api.Comment> o) {

384 unittest.expect(o, unittest.hasLength(2));

385 checkComment(o[0]);

386 checkComment(o[1]);

387 }

388

389 core.int buildCounterCommentList = 0;

390 buildCommentList() {

391 var o = new api.CommentList();

392 buildCounterCommentList++;

393 if (buildCounterCommentList < 3) {

394 o.items = buildUnnamed147();

395 o.kind = "foo";

396 o.nextPageToken = "foo";

397 o.previousPageToken = "foo";

398 }

399 buildCounterCommentList--;

400 return o;

401 }

402

403 checkCommentList(api.CommentList o) {

404 buildCounterCommentList++;

405 if (buildCounterCommentList < 3) {

406 checkUnnamed147(o.items);

407 unittest.expect(o.kind, unittest.equals('foo'));

408 unittest.expect(o.nextPageToken, unittest.equals('foo'));

409 unittest.expect(o.previousPageToken, unittest.equals('foo'));

410 }

411 buildCounterCommentList--;

412 }

413

414 buildUnnamed148() {

415 var o = new core.List<api.OrkutAuthorResource>();

416 o.add(buildOrkutAuthorResource());

417 o.add(buildOrkutAuthorResource());

418 return o;

419 }

420

421 checkUnnamed148(core.List<api.OrkutAuthorResource> o) {

422 unittest.expect(o, unittest.hasLength(2));

423 checkOrkutAuthorResource(o[0]);

424 checkOrkutAuthorResource(o[1]);

425 }

426

427 buildUnnamed149() {

428 var o = new core.List<api.OrkutLinkResource>();

429 o.add(buildOrkutLinkResource());

430 o.add(buildOrkutLinkResource());

431 return o;

432 }

433

434 checkUnnamed149(core.List<api.OrkutLinkResource> o) {

435 unittest.expect(o, unittest.hasLength(2));

436 checkOrkutLinkResource(o[0]);

437 checkOrkutLinkResource(o[1]);

438 }

439

440 buildUnnamed150() {

441 var o = new core.List<api.OrkutAuthorResource>();

442 o.add(buildOrkutAuthorResource());

443 o.add(buildOrkutAuthorResource());

444 return o;

445 }

446

447 checkUnnamed150(core.List<api.OrkutAuthorResource> o) {

448 unittest.expect(o, unittest.hasLength(2));

449 checkOrkutAuthorResource(o[0]);

450 checkOrkutAuthorResource(o[1]);

451 }

452

453 core.int buildCounterCommunity = 0;

454 buildCommunity() {

455 var o = new api.Community();

456 buildCounterCommunity++;

457 if (buildCounterCommunity < 3) {

458 o.category = "foo";

459 o.coOwners = buildUnnamed148();

460 o.creationDate = core.DateTime.parse("2002-02-27T14:01:02");

461 o.description = "foo";

462 o.id = 42;

463 o.kind = "foo";

464 o.language = "foo";

465 o.links = buildUnnamed149();

466 o.location = "foo";

467 o.memberCount = 42;

468 o.moderators = buildUnnamed150();

469 o.name = "foo";

470 o.owner = buildOrkutAuthorResource();

471 o.photoUrl = "foo";

472 }

473 buildCounterCommunity--;

474 return o;

475 }

476

477 checkCommunity(api.Community o) {

478 buildCounterCommunity++;

479 if (buildCounterCommunity < 3) {

480 unittest.expect(o.category, unittest.equals('foo'));

481 checkUnnamed148(o.coOwners);

482 unittest.expect(o.creationDate, unittest.equals(core.DateTime.parse("2002-02 -27T14:01:02")));

483 unittest.expect(o.description, unittest.equals('foo'));

484 unittest.expect(o.id, unittest.equals(42));

485 unittest.expect(o.kind, unittest.equals('foo'));

486 unittest.expect(o.language, unittest.equals('foo'));

487 checkUnnamed149(o.links);

488 unittest.expect(o.location, unittest.equals('foo'));

489 unittest.expect(o.memberCount, unittest.equals(42));

490 checkUnnamed150(o.moderators);

491 unittest.expect(o.name, unittest.equals('foo'));

492 checkOrkutAuthorResource(o.owner);

493 unittest.expect(o.photoUrl, unittest.equals('foo'));

494 }

495 buildCounterCommunity--;

496 }

497

498 buildUnnamed151() {

499 var o = new core.List<api.Community>();

500 o.add(buildCommunity());

501 o.add(buildCommunity());

502 return o;

503 }

504

505 checkUnnamed151(core.List<api.Community> o) {

506 unittest.expect(o, unittest.hasLength(2));

507 checkCommunity(o[0]);

508 checkCommunity(o[1]);

509 }

510

511 core.int buildCounterCommunityList = 0;

512 buildCommunityList() {

513 var o = new api.CommunityList();

514 buildCounterCommunityList++;

515 if (buildCounterCommunityList < 3) {

516 o.items = buildUnnamed151();

517 o.kind = "foo";

518 }

519 buildCounterCommunityList--;

520 return o;

521 }

522

523 checkCommunityList(api.CommunityList o) {

524 buildCounterCommunityList++;

525 if (buildCounterCommunityList < 3) {

526 checkUnnamed151(o.items);

527 unittest.expect(o.kind, unittest.equals('foo'));

528 }

529 buildCounterCommunityList--;

530 }

531

532 core.int buildCounterCommunityMembers = 0;

533 buildCommunityMembers() {

534 var o = new api.CommunityMembers();

535 buildCounterCommunityMembers++;

536 if (buildCounterCommunityMembers < 3) {

537 o.communityMembershipStatus = buildCommunityMembershipStatus();

538 o.kind = "foo";

539 o.person = buildOrkutActivitypersonResource();

540 }

541 buildCounterCommunityMembers--;

542 return o;

543 }

544

545 checkCommunityMembers(api.CommunityMembers o) {

546 buildCounterCommunityMembers++;

547 if (buildCounterCommunityMembers < 3) {

548 checkCommunityMembershipStatus(o.communityMembershipStatus);

549 unittest.expect(o.kind, unittest.equals('foo'));

550 checkOrkutActivitypersonResource(o.person);

551 }

552 buildCounterCommunityMembers--;

553 }

554

555 buildUnnamed152() {

556 var o = new core.List<api.CommunityMembers>();

557 o.add(buildCommunityMembers());

558 o.add(buildCommunityMembers());

559 return o;

560 }

561

562 checkUnnamed152(core.List<api.CommunityMembers> o) {

563 unittest.expect(o, unittest.hasLength(2));

564 checkCommunityMembers(o[0]);

565 checkCommunityMembers(o[1]);

566 }

567

568 core.int buildCounterCommunityMembersList = 0;

569 buildCommunityMembersList() {

570 var o = new api.CommunityMembersList();

571 buildCounterCommunityMembersList++;

572 if (buildCounterCommunityMembersList < 3) {

573 o.firstPageToken = "foo";

574 o.items = buildUnnamed152();

575 o.kind = "foo";

576 o.lastPageToken = "foo";

577 o.nextPageToken = "foo";

578 o.prevPageToken = "foo";

579 }

580 buildCounterCommunityMembersList--;

581 return o;

582 }

583

584 checkCommunityMembersList(api.CommunityMembersList o) {

585 buildCounterCommunityMembersList++;

586 if (buildCounterCommunityMembersList < 3) {

587 unittest.expect(o.firstPageToken, unittest.equals('foo'));

588 checkUnnamed152(o.items);

589 unittest.expect(o.kind, unittest.equals('foo'));

590 unittest.expect(o.lastPageToken, unittest.equals('foo'));

591 unittest.expect(o.nextPageToken, unittest.equals('foo'));

592 unittest.expect(o.prevPageToken, unittest.equals('foo'));

593 }

594 buildCounterCommunityMembersList--;

595 }

596

597 core.int buildCounterCommunityMembershipStatus = 0;

598 buildCommunityMembershipStatus() {

599 var o = new api.CommunityMembershipStatus();

600 buildCounterCommunityMembershipStatus++;

601 if (buildCounterCommunityMembershipStatus < 3) {

602 o.canCreatePoll = true;

603 o.canCreateTopic = true;

604 o.canShout = true;

605 o.isCoOwner = true;

606 o.isFollowing = true;

607 o.isModerator = true;

608 o.isOwner = true;

609 o.isRestoreAvailable = true;

610 o.isTakebackAvailable = true;

611 o.kind = "foo";

612 o.status = "foo";

613 }

614 buildCounterCommunityMembershipStatus--;

615 return o;

616 }

617

618 checkCommunityMembershipStatus(api.CommunityMembershipStatus o) {

619 buildCounterCommunityMembershipStatus++;

620 if (buildCounterCommunityMembershipStatus < 3) {

621 unittest.expect(o.canCreatePoll, unittest.isTrue);

622 unittest.expect(o.canCreateTopic, unittest.isTrue);

623 unittest.expect(o.canShout, unittest.isTrue);

624 unittest.expect(o.isCoOwner, unittest.isTrue);

625 unittest.expect(o.isFollowing, unittest.isTrue);

626 unittest.expect(o.isModerator, unittest.isTrue);

627 unittest.expect(o.isOwner, unittest.isTrue);

628 unittest.expect(o.isRestoreAvailable, unittest.isTrue);

629 unittest.expect(o.isTakebackAvailable, unittest.isTrue);

630 unittest.expect(o.kind, unittest.equals('foo'));

631 unittest.expect(o.status, unittest.equals('foo'));

632 }

633 buildCounterCommunityMembershipStatus--;

634 }

635

636 buildUnnamed153() {

637 var o = new core.List<api.OrkutLinkResource>();

638 o.add(buildOrkutLinkResource());

639 o.add(buildOrkutLinkResource());

640 return o;

641 }

642

643 checkUnnamed153(core.List<api.OrkutLinkResource> o) {

644 unittest.expect(o, unittest.hasLength(2));

645 checkOrkutLinkResource(o[0]);

646 checkOrkutLinkResource(o[1]);

647 }

648

649 core.int buildCounterCommunityMessage = 0;

650 buildCommunityMessage() {

651 var o = new api.CommunityMessage();

652 buildCounterCommunityMessage++;

653 if (buildCounterCommunityMessage < 3) {

654 o.addedDate = core.DateTime.parse("2002-02-27T14:01:02");

655 o.author = buildOrkutAuthorResource();

656 o.body = "foo";

657 o.id = "foo";

658 o.isSpam = true;

659 o.kind = "foo";

660 o.links = buildUnnamed153();

661 o.subject = "foo";

662 }

663 buildCounterCommunityMessage--;

664 return o;

665 }

666

667 checkCommunityMessage(api.CommunityMessage o) {

668 buildCounterCommunityMessage++;

669 if (buildCounterCommunityMessage < 3) {

670 unittest.expect(o.addedDate, unittest.equals(core.DateTime.parse("2002-02-27 T14:01:02")));

671 checkOrkutAuthorResource(o.author);

672 unittest.expect(o.body, unittest.equals('foo'));

673 unittest.expect(o.id, unittest.equals('foo'));

674 unittest.expect(o.isSpam, unittest.isTrue);

675 unittest.expect(o.kind, unittest.equals('foo'));

676 checkUnnamed153(o.links);

677 unittest.expect(o.subject, unittest.equals('foo'));

678 }

679 buildCounterCommunityMessage--;

680 }

681

682 buildUnnamed154() {

683 var o = new core.List<api.CommunityMessage>();

684 o.add(buildCommunityMessage());

685 o.add(buildCommunityMessage());

686 return o;

687 }

688

689 checkUnnamed154(core.List<api.CommunityMessage> o) {

690 unittest.expect(o, unittest.hasLength(2));

691 checkCommunityMessage(o[0]);

692 checkCommunityMessage(o[1]);

693 }

694

695 core.int buildCounterCommunityMessageList = 0;

696 buildCommunityMessageList() {

697 var o = new api.CommunityMessageList();

698 buildCounterCommunityMessageList++;

699 if (buildCounterCommunityMessageList < 3) {

700 o.firstPageToken = "foo";

701 o.items = buildUnnamed154();

702 o.kind = "foo";

703 o.lastPageToken = "foo";

704 o.nextPageToken = "foo";

705 o.prevPageToken = "foo";

706 }

707 buildCounterCommunityMessageList--;

708 return o;

709 }

710

711 checkCommunityMessageList(api.CommunityMessageList o) {

712 buildCounterCommunityMessageList++;

713 if (buildCounterCommunityMessageList < 3) {

714 unittest.expect(o.firstPageToken, unittest.equals('foo'));

715 checkUnnamed154(o.items);

716 unittest.expect(o.kind, unittest.equals('foo'));

717 unittest.expect(o.lastPageToken, unittest.equals('foo'));

718 unittest.expect(o.nextPageToken, unittest.equals('foo'));

719 unittest.expect(o.prevPageToken, unittest.equals('foo'));

720 }

721 buildCounterCommunityMessageList--;

722 }

723

724 core.int buildCounterCommunityPollImage = 0;

725 buildCommunityPollImage() {

726 var o = new api.CommunityPollImage();

727 buildCounterCommunityPollImage++;

728 if (buildCounterCommunityPollImage < 3) {

729 o.url = "foo";

730 }

731 buildCounterCommunityPollImage--;

732 return o;

733 }

734

735 checkCommunityPollImage(api.CommunityPollImage o) {

736 buildCounterCommunityPollImage++;

737 if (buildCounterCommunityPollImage < 3) {

738 unittest.expect(o.url, unittest.equals('foo'));

739 }

740 buildCounterCommunityPollImage--;

741 }

742

743 buildUnnamed155() {

744 var o = new core.List<api.OrkutLinkResource>();

745 o.add(buildOrkutLinkResource());

746 o.add(buildOrkutLinkResource());

747 return o;

748 }

749

750 checkUnnamed155(core.List<api.OrkutLinkResource> o) {

751 unittest.expect(o, unittest.hasLength(2));

752 checkOrkutLinkResource(o[0]);

753 checkOrkutLinkResource(o[1]);

754 }

755

756 buildUnnamed156() {

757 var o = new core.List<api.OrkutCommunitypolloptionResource>();

758 o.add(buildOrkutCommunitypolloptionResource());

759 o.add(buildOrkutCommunitypolloptionResource());

760 return o;

761 }

762

763 checkUnnamed156(core.List<api.OrkutCommunitypolloptionResource> o) {

764 unittest.expect(o, unittest.hasLength(2));

765 checkOrkutCommunitypolloptionResource(o[0]);

766 checkOrkutCommunitypolloptionResource(o[1]);

767 }

768

769 buildUnnamed157() {

770 var o = new core.List<core.int>();

771 o.add(42);

772 o.add(42);

773 return o;

774 }

775

776 checkUnnamed157(core.List<core.int> o) {

777 unittest.expect(o, unittest.hasLength(2));

778 unittest.expect(o[0], unittest.equals(42));

779 unittest.expect(o[1], unittest.equals(42));

780 }

781

782 core.int buildCounterCommunityPoll = 0;

783 buildCommunityPoll() {

784 var o = new api.CommunityPoll();

785 buildCounterCommunityPoll++;

786 if (buildCounterCommunityPoll < 3) {

787 o.author = buildOrkutAuthorResource();

788 o.communityId = 42;

789 o.creationTime = core.DateTime.parse("2002-02-27T14:01:02");

790 o.description = "foo";

791 o.endingTime = core.DateTime.parse("2002-02-27T14:01:02");

792 o.hasVoted = true;

793 o.id = "foo";

794 o.image = buildCommunityPollImage();

795 o.isClosed = true;

796 o.isMultipleAnswers = true;

797 o.isOpenForVoting = true;

798 o.isRestricted = true;

799 o.isSpam = true;

800 o.isUsersVotePublic = true;

801 o.isVotingAllowedForNonMembers = true;

802 o.kind = "foo";

803 o.lastUpdate = core.DateTime.parse("2002-02-27T14:01:02");

804 o.links = buildUnnamed155();

805 o.options = buildUnnamed156();

806 o.question = "foo";

807 o.totalNumberOfVotes = 42;

808 o.votedOptions = buildUnnamed157();

809 }

810 buildCounterCommunityPoll--;

811 return o;

812 }

813

814 checkCommunityPoll(api.CommunityPoll o) {

815 buildCounterCommunityPoll++;

816 if (buildCounterCommunityPoll < 3) {

817 checkOrkutAuthorResource(o.author);

818 unittest.expect(o.communityId, unittest.equals(42));

819 unittest.expect(o.creationTime, unittest.equals(core.DateTime.parse("2002-02 -27T14:01:02")));

820 unittest.expect(o.description, unittest.equals('foo'));

821 unittest.expect(o.endingTime, unittest.equals(core.DateTime.parse("2002-02-2 7T14:01:02")));

822 unittest.expect(o.hasVoted, unittest.isTrue);

823 unittest.expect(o.id, unittest.equals('foo'));

824 checkCommunityPollImage(o.image);

825 unittest.expect(o.isClosed, unittest.isTrue);

826 unittest.expect(o.isMultipleAnswers, unittest.isTrue);

827 unittest.expect(o.isOpenForVoting, unittest.isTrue);

828 unittest.expect(o.isRestricted, unittest.isTrue);

829 unittest.expect(o.isSpam, unittest.isTrue);

830 unittest.expect(o.isUsersVotePublic, unittest.isTrue);

831 unittest.expect(o.isVotingAllowedForNonMembers, unittest.isTrue);

832 unittest.expect(o.kind, unittest.equals('foo'));

833 unittest.expect(o.lastUpdate, unittest.equals(core.DateTime.parse("2002-02-2 7T14:01:02")));

834 checkUnnamed155(o.links);

835 checkUnnamed156(o.options);

836 unittest.expect(o.question, unittest.equals('foo'));

837 unittest.expect(o.totalNumberOfVotes, unittest.equals(42));

838 checkUnnamed157(o.votedOptions);

839 }

840 buildCounterCommunityPoll--;

841 }

842

843 core.int buildCounterCommunityPollComment = 0;

844 buildCommunityPollComment() {

845 var o = new api.CommunityPollComment();

846 buildCounterCommunityPollComment++;

847 if (buildCounterCommunityPollComment < 3) {

848 o.addedDate = core.DateTime.parse("2002-02-27T14:01:02");

849 o.author = buildOrkutAuthorResource();

850 o.body = "foo";

851 o.id = 42;

852 o.kind = "foo";

853 }

854 buildCounterCommunityPollComment--;

855 return o;

856 }

857

858 checkCommunityPollComment(api.CommunityPollComment o) {

859 buildCounterCommunityPollComment++;

860 if (buildCounterCommunityPollComment < 3) {

861 unittest.expect(o.addedDate, unittest.equals(core.DateTime.parse("2002-02-27 T14:01:02")));

862 checkOrkutAuthorResource(o.author);

863 unittest.expect(o.body, unittest.equals('foo'));

864 unittest.expect(o.id, unittest.equals(42));

865 unittest.expect(o.kind, unittest.equals('foo'));

866 }

867 buildCounterCommunityPollComment--;

868 }

869

870 buildUnnamed158() {

871 var o = new core.List<api.CommunityPollComment>();

872 o.add(buildCommunityPollComment());

873 o.add(buildCommunityPollComment());

874 return o;

875 }

876

877 checkUnnamed158(core.List<api.CommunityPollComment> o) {

878 unittest.expect(o, unittest.hasLength(2));

879 checkCommunityPollComment(o[0]);

880 checkCommunityPollComment(o[1]);

881 }

882

883 core.int buildCounterCommunityPollCommentList = 0;

884 buildCommunityPollCommentList() {

885 var o = new api.CommunityPollCommentList();

886 buildCounterCommunityPollCommentList++;

887 if (buildCounterCommunityPollCommentList < 3) {

888 o.firstPageToken = "foo";

889 o.items = buildUnnamed158();

890 o.kind = "foo";

891 o.lastPageToken = "foo";

892 o.nextPageToken = "foo";

893 o.prevPageToken = "foo";

894 }

895 buildCounterCommunityPollCommentList--;

896 return o;

897 }

898

899 checkCommunityPollCommentList(api.CommunityPollCommentList o) {

900 buildCounterCommunityPollCommentList++;

901 if (buildCounterCommunityPollCommentList < 3) {

902 unittest.expect(o.firstPageToken, unittest.equals('foo'));

903 checkUnnamed158(o.items);

904 unittest.expect(o.kind, unittest.equals('foo'));

905 unittest.expect(o.lastPageToken, unittest.equals('foo'));

906 unittest.expect(o.nextPageToken, unittest.equals('foo'));

907 unittest.expect(o.prevPageToken, unittest.equals('foo'));

908 }

909 buildCounterCommunityPollCommentList--;

910 }

911

912 buildUnnamed159() {

913 var o = new core.List<api.CommunityPoll>();

914 o.add(buildCommunityPoll());

915 o.add(buildCommunityPoll());

916 return o;

917 }

918

919 checkUnnamed159(core.List<api.CommunityPoll> o) {

920 unittest.expect(o, unittest.hasLength(2));

921 checkCommunityPoll(o[0]);

922 checkCommunityPoll(o[1]);

923 }

924

925 core.int buildCounterCommunityPollList = 0;

926 buildCommunityPollList() {

927 var o = new api.CommunityPollList();

928 buildCounterCommunityPollList++;

929 if (buildCounterCommunityPollList < 3) {

930 o.firstPageToken = "foo";

931 o.items = buildUnnamed159();

932 o.kind = "foo";

933 o.lastPageToken = "foo";

934 o.nextPageToken = "foo";

935 o.prevPageToken = "foo";

936 }

937 buildCounterCommunityPollList--;

938 return o;

939 }

940

941 checkCommunityPollList(api.CommunityPollList o) {

942 buildCounterCommunityPollList++;

943 if (buildCounterCommunityPollList < 3) {

944 unittest.expect(o.firstPageToken, unittest.equals('foo'));

945 checkUnnamed159(o.items);

946 unittest.expect(o.kind, unittest.equals('foo'));

947 unittest.expect(o.lastPageToken, unittest.equals('foo'));

948 unittest.expect(o.nextPageToken, unittest.equals('foo'));

949 unittest.expect(o.prevPageToken, unittest.equals('foo'));

950 }

951 buildCounterCommunityPollList--;

952 }

953

954 buildUnnamed160() {

955 var o = new core.List<core.int>();

956 o.add(42);

957 o.add(42);

958 return o;

959 }

960

961 checkUnnamed160(core.List<core.int> o) {

962 unittest.expect(o, unittest.hasLength(2));

963 unittest.expect(o[0], unittest.equals(42));

964 unittest.expect(o[1], unittest.equals(42));

965 }

966

967 core.int buildCounterCommunityPollVote = 0;

968 buildCommunityPollVote() {

969 var o = new api.CommunityPollVote();

970 buildCounterCommunityPollVote++;

971 if (buildCounterCommunityPollVote < 3) {

972 o.isVotevisible = true;

973 o.kind = "foo";

974 o.optionIds = buildUnnamed160();

975 }

976 buildCounterCommunityPollVote--;

977 return o;

978 }

979

980 checkCommunityPollVote(api.CommunityPollVote o) {

981 buildCounterCommunityPollVote++;

982 if (buildCounterCommunityPollVote < 3) {

983 unittest.expect(o.isVotevisible, unittest.isTrue);

984 unittest.expect(o.kind, unittest.equals('foo'));

985 checkUnnamed160(o.optionIds);

986 }

987 buildCounterCommunityPollVote--;

988 }

989

990 buildUnnamed161() {

991 var o = new core.List<api.OrkutLinkResource>();

992 o.add(buildOrkutLinkResource());

993 o.add(buildOrkutLinkResource());

994 return o;

995 }

996

997 checkUnnamed161(core.List<api.OrkutLinkResource> o) {

998 unittest.expect(o, unittest.hasLength(2));

999 checkOrkutLinkResource(o[0]);

1000 checkOrkutLinkResource(o[1]);

1001 }

1002

1003 buildUnnamed162() {

1004 var o = new core.List<api.CommunityMessage>();

1005 o.add(buildCommunityMessage());

1006 o.add(buildCommunityMessage());

1007 return o;

1008 }

1009

1010 checkUnnamed162(core.List<api.CommunityMessage> o) {

1011 unittest.expect(o, unittest.hasLength(2));

1012 checkCommunityMessage(o[0]);

1013 checkCommunityMessage(o[1]);

1014 }

1015

1016 core.int buildCounterCommunityTopic = 0;

1017 buildCommunityTopic() {

1018 var o = new api.CommunityTopic();

1019 buildCounterCommunityTopic++;

1020 if (buildCounterCommunityTopic < 3) {

1021 o.author = buildOrkutAuthorResource();

1022 o.body = "foo";

1023 o.id = "foo";

1024 o.isClosed = true;

1025 o.kind = "foo";

1026 o.lastUpdate = core.DateTime.parse("2002-02-27T14:01:02");

1027 o.latestMessageSnippet = "foo";

1028 o.links = buildUnnamed161();

1029 o.messages = buildUnnamed162();

1030 o.numberOfReplies = 42;

1031 o.title = "foo";

1032 }

1033 buildCounterCommunityTopic--;

1034 return o;

1035 }

1036

1037 checkCommunityTopic(api.CommunityTopic o) {

1038 buildCounterCommunityTopic++;

1039 if (buildCounterCommunityTopic < 3) {

1040 checkOrkutAuthorResource(o.author);

1041 unittest.expect(o.body, unittest.equals('foo'));

1042 unittest.expect(o.id, unittest.equals('foo'));

1043 unittest.expect(o.isClosed, unittest.isTrue);

1044 unittest.expect(o.kind, unittest.equals('foo'));

1045 unittest.expect(o.lastUpdate, unittest.equals(core.DateTime.parse("2002-02-2 7T14:01:02")));

1046 unittest.expect(o.latestMessageSnippet, unittest.equals('foo'));

1047 checkUnnamed161(o.links);

1048 checkUnnamed162(o.messages);

1049 unittest.expect(o.numberOfReplies, unittest.equals(42));

1050 unittest.expect(o.title, unittest.equals('foo'));

1051 }

1052 buildCounterCommunityTopic--;

1053 }

1054

1055 buildUnnamed163() {

1056 var o = new core.List<api.CommunityTopic>();

1057 o.add(buildCommunityTopic());

1058 o.add(buildCommunityTopic());

1059 return o;

1060 }

1061

1062 checkUnnamed163(core.List<api.CommunityTopic> o) {

1063 unittest.expect(o, unittest.hasLength(2));

1064 checkCommunityTopic(o[0]);

1065 checkCommunityTopic(o[1]);

1066 }

1067

1068 core.int buildCounterCommunityTopicList = 0;

1069 buildCommunityTopicList() {

1070 var o = new api.CommunityTopicList();

1071 buildCounterCommunityTopicList++;

1072 if (buildCounterCommunityTopicList < 3) {

1073 o.firstPageToken = "foo";

1074 o.items = buildUnnamed163();

1075 o.kind = "foo";

1076 o.lastPageToken = "foo";

1077 o.nextPageToken = "foo";

1078 o.prevPageToken = "foo";

1079 }

1080 buildCounterCommunityTopicList--;

1081 return o;

1082 }

1083

1084 checkCommunityTopicList(api.CommunityTopicList o) {

1085 buildCounterCommunityTopicList++;

1086 if (buildCounterCommunityTopicList < 3) {

1087 unittest.expect(o.firstPageToken, unittest.equals('foo'));

1088 checkUnnamed163(o.items);

1089 unittest.expect(o.kind, unittest.equals('foo'));

1090 unittest.expect(o.lastPageToken, unittest.equals('foo'));

1091 unittest.expect(o.nextPageToken, unittest.equals('foo'));

1092 unittest.expect(o.prevPageToken, unittest.equals('foo'));

1093 }

1094 buildCounterCommunityTopicList--;

1095 }

1096

1097 buildUnnamed164() {

1098 var o = new core.List<api.OrkutCounterResource>();

1099 o.add(buildOrkutCounterResource());

1100 o.add(buildOrkutCounterResource());

1101 return o;

1102 }

1103

1104 checkUnnamed164(core.List<api.OrkutCounterResource> o) {

1105 unittest.expect(o, unittest.hasLength(2));

1106 checkOrkutCounterResource(o[0]);

1107 checkOrkutCounterResource(o[1]);

1108 }

1109

1110 core.int buildCounterCounters = 0;

1111 buildCounters() {

1112 var o = new api.Counters();

1113 buildCounterCounters++;

1114 if (buildCounterCounters < 3) {

1115 o.items = buildUnnamed164();

1116 o.kind = "foo";

1117 }

1118 buildCounterCounters--;

1119 return o;

1120 }

1121

1122 checkCounters(api.Counters o) {

1123 buildCounterCounters++;

1124 if (buildCounterCounters < 3) {

1125 checkUnnamed164(o.items);

1126 unittest.expect(o.kind, unittest.equals('foo'));

1127 }

1128 buildCounterCounters--;

1129 }

1130

1131 buildUnnamed165() {

1132 var o = new core.List<api.OrkutLinkResource>();

1133 o.add(buildOrkutLinkResource());

1134 o.add(buildOrkutLinkResource());

1135 return o;

1136 }

1137

1138 checkUnnamed165(core.List<api.OrkutLinkResource> o) {

1139 unittest.expect(o, unittest.hasLength(2));

1140 checkOrkutLinkResource(o[0]);

1141 checkOrkutLinkResource(o[1]);

1142 }

1143

1144 core.int buildCounterOrkutActivityobjectsResource = 0;

1145 buildOrkutActivityobjectsResource() {

1146 var o = new api.OrkutActivityobjectsResource();

1147 buildCounterOrkutActivityobjectsResource++;

1148 if (buildCounterOrkutActivityobjectsResource < 3) {

1149 o.community = buildCommunity();

1150 o.content = "foo";

1151 o.displayName = "foo";

1152 o.id = "foo";

1153 o.links = buildUnnamed165();

1154 o.objectType = "foo";

1155 o.person = buildOrkutActivitypersonResource();

1156 }

1157 buildCounterOrkutActivityobjectsResource--;

1158 return o;

1159 }

1160

1161 checkOrkutActivityobjectsResource(api.OrkutActivityobjectsResource o) {

1162 buildCounterOrkutActivityobjectsResource++;

1163 if (buildCounterOrkutActivityobjectsResource < 3) {

1164 checkCommunity(o.community);

1165 unittest.expect(o.content, unittest.equals('foo'));

1166 unittest.expect(o.displayName, unittest.equals('foo'));

1167 unittest.expect(o.id, unittest.equals('foo'));

1168 checkUnnamed165(o.links);

1169 unittest.expect(o.objectType, unittest.equals('foo'));

1170 checkOrkutActivitypersonResource(o.person);

1171 }

1172 buildCounterOrkutActivityobjectsResource--;

1173 }

1174

1175 core.int buildCounterOrkutActivitypersonResourceImage = 0;

1176 buildOrkutActivitypersonResourceImage() {

1177 var o = new api.OrkutActivitypersonResourceImage();

1178 buildCounterOrkutActivitypersonResourceImage++;

1179 if (buildCounterOrkutActivitypersonResourceImage < 3) {

1180 o.url = "foo";

1181 }

1182 buildCounterOrkutActivitypersonResourceImage--;

1183 return o;

1184 }

1185

1186 checkOrkutActivitypersonResourceImage(api.OrkutActivitypersonResourceImage o) {

1187 buildCounterOrkutActivitypersonResourceImage++;

1188 if (buildCounterOrkutActivitypersonResourceImage < 3) {

1189 unittest.expect(o.url, unittest.equals('foo'));

1190 }

1191 buildCounterOrkutActivitypersonResourceImage--;

1192 }

1193

1194 core.int buildCounterOrkutActivitypersonResourceName = 0;

1195 buildOrkutActivitypersonResourceName() {

1196 var o = new api.OrkutActivitypersonResourceName();

1197 buildCounterOrkutActivitypersonResourceName++;

1198 if (buildCounterOrkutActivitypersonResourceName < 3) {

1199 o.familyName = "foo";

1200 o.givenName = "foo";

1201 }

1202 buildCounterOrkutActivitypersonResourceName--;

1203 return o;

1204 }

1205

1206 checkOrkutActivitypersonResourceName(api.OrkutActivitypersonResourceName o) {

1207 buildCounterOrkutActivitypersonResourceName++;

1208 if (buildCounterOrkutActivitypersonResourceName < 3) {

1209 unittest.expect(o.familyName, unittest.equals('foo'));

1210 unittest.expect(o.givenName, unittest.equals('foo'));

1211 }

1212 buildCounterOrkutActivitypersonResourceName--;

1213 }

1214

1215 core.int buildCounterOrkutActivitypersonResource = 0;

1216 buildOrkutActivitypersonResource() {

1217 var o = new api.OrkutActivitypersonResource();

1218 buildCounterOrkutActivitypersonResource++;

1219 if (buildCounterOrkutActivitypersonResource < 3) {

1220 o.birthday = "foo";

1221 o.gender = "foo";

1222 o.id = "foo";

1223 o.image = buildOrkutActivitypersonResourceImage();

1224 o.name = buildOrkutActivitypersonResourceName();

1225 o.url = "foo";

1226 }

1227 buildCounterOrkutActivitypersonResource--;

1228 return o;

1229 }

1230

1231 checkOrkutActivitypersonResource(api.OrkutActivitypersonResource o) {

1232 buildCounterOrkutActivitypersonResource++;

1233 if (buildCounterOrkutActivitypersonResource < 3) {

1234 unittest.expect(o.birthday, unittest.equals('foo'));

1235 unittest.expect(o.gender, unittest.equals('foo'));

1236 unittest.expect(o.id, unittest.equals('foo'));

1237 checkOrkutActivitypersonResourceImage(o.image);

1238 checkOrkutActivitypersonResourceName(o.name);

1239 unittest.expect(o.url, unittest.equals('foo'));

1240 }

1241 buildCounterOrkutActivitypersonResource--;

1242 }

1243

1244 core.int buildCounterOrkutAuthorResourceImage = 0;

1245 buildOrkutAuthorResourceImage() {

1246 var o = new api.OrkutAuthorResourceImage();

1247 buildCounterOrkutAuthorResourceImage++;

1248 if (buildCounterOrkutAuthorResourceImage < 3) {

1249 o.url = "foo";

1250 }

1251 buildCounterOrkutAuthorResourceImage--;

1252 return o;

1253 }

1254

1255 checkOrkutAuthorResourceImage(api.OrkutAuthorResourceImage o) {

1256 buildCounterOrkutAuthorResourceImage++;

1257 if (buildCounterOrkutAuthorResourceImage < 3) {

1258 unittest.expect(o.url, unittest.equals('foo'));

1259 }

1260 buildCounterOrkutAuthorResourceImage--;

1261 }

1262

1263 core.int buildCounterOrkutAuthorResource = 0;

1264 buildOrkutAuthorResource() {

1265 var o = new api.OrkutAuthorResource();

1266 buildCounterOrkutAuthorResource++;

1267 if (buildCounterOrkutAuthorResource < 3) {

1268 o.displayName = "foo";

1269 o.id = "foo";

1270 o.image = buildOrkutAuthorResourceImage();

1271 o.url = "foo";

1272 }

1273 buildCounterOrkutAuthorResource--;

1274 return o;

1275 }

1276

1277 checkOrkutAuthorResource(api.OrkutAuthorResource o) {

1278 buildCounterOrkutAuthorResource++;

1279 if (buildCounterOrkutAuthorResource < 3) {

1280 unittest.expect(o.displayName, unittest.equals('foo'));

1281 unittest.expect(o.id, unittest.equals('foo'));

1282 checkOrkutAuthorResourceImage(o.image);

1283 unittest.expect(o.url, unittest.equals('foo'));

1284 }

1285 buildCounterOrkutAuthorResource--;

1286 }

1287

1288 core.int buildCounterOrkutCommunitypolloptionResourceImage = 0;

1289 buildOrkutCommunitypolloptionResourceImage() {

1290 var o = new api.OrkutCommunitypolloptionResourceImage();

1291 buildCounterOrkutCommunitypolloptionResourceImage++;

1292 if (buildCounterOrkutCommunitypolloptionResourceImage < 3) {

1293 o.url = "foo";

1294 }

1295 buildCounterOrkutCommunitypolloptionResourceImage--;

1296 return o;

1297 }

1298

1299 checkOrkutCommunitypolloptionResourceImage(api.OrkutCommunitypolloptionResourceI mage o) {

1300 buildCounterOrkutCommunitypolloptionResourceImage++;

1301 if (buildCounterOrkutCommunitypolloptionResourceImage < 3) {

1302 unittest.expect(o.url, unittest.equals('foo'));

1303 }

1304 buildCounterOrkutCommunitypolloptionResourceImage--;

1305 }

1306

1307 core.int buildCounterOrkutCommunitypolloptionResource = 0;

1308 buildOrkutCommunitypolloptionResource() {

1309 var o = new api.OrkutCommunitypolloptionResource();

1310 buildCounterOrkutCommunitypolloptionResource++;

1311 if (buildCounterOrkutCommunitypolloptionResource < 3) {

1312 o.description = "foo";

1313 o.image = buildOrkutCommunitypolloptionResourceImage();

1314 o.numberOfVotes = 42;

1315 o.optionId = 42;

1316 }

1317 buildCounterOrkutCommunitypolloptionResource--;

1318 return o;

1319 }

1320

1321 checkOrkutCommunitypolloptionResource(api.OrkutCommunitypolloptionResource o) {

1322 buildCounterOrkutCommunitypolloptionResource++;

1323 if (buildCounterOrkutCommunitypolloptionResource < 3) {

1324 unittest.expect(o.description, unittest.equals('foo'));

1325 checkOrkutCommunitypolloptionResourceImage(o.image);

1326 unittest.expect(o.numberOfVotes, unittest.equals(42));

1327 unittest.expect(o.optionId, unittest.equals(42));

1328 }

1329 buildCounterOrkutCommunitypolloptionResource--;

1330 }

1331

1332 core.int buildCounterOrkutCounterResource = 0;

1333 buildOrkutCounterResource() {

1334 var o = new api.OrkutCounterResource();

1335 buildCounterOrkutCounterResource++;

1336 if (buildCounterOrkutCounterResource < 3) {

1337 o.link = buildOrkutLinkResource();

1338 o.name = "foo";

1339 o.total = 42;

1340 }

1341 buildCounterOrkutCounterResource--;

1342 return o;

1343 }

1344

1345 checkOrkutCounterResource(api.OrkutCounterResource o) {

1346 buildCounterOrkutCounterResource++;

1347 if (buildCounterOrkutCounterResource < 3) {

1348 checkOrkutLinkResource(o.link);

1349 unittest.expect(o.name, unittest.equals('foo'));

1350 unittest.expect(o.total, unittest.equals(42));

1351 }

1352 buildCounterOrkutCounterResource--;

1353 }

1354

1355 core.int buildCounterOrkutLinkResource = 0;

1356 buildOrkutLinkResource() {

1357 var o = new api.OrkutLinkResource();

1358 buildCounterOrkutLinkResource++;

1359 if (buildCounterOrkutLinkResource < 3) {

1360 o.href = "foo";

1361 o.rel = "foo";

1362 o.title = "foo";

1363 o.type = "foo";

1364 }

1365 buildCounterOrkutLinkResource--;

1366 return o;

1367 }

1368

1369 checkOrkutLinkResource(api.OrkutLinkResource o) {

1370 buildCounterOrkutLinkResource++;

1371 if (buildCounterOrkutLinkResource < 3) {

1372 unittest.expect(o.href, unittest.equals('foo'));

1373 unittest.expect(o.rel, unittest.equals('foo'));

1374 unittest.expect(o.title, unittest.equals('foo'));

1375 unittest.expect(o.type, unittest.equals('foo'));

1376 }

1377 buildCounterOrkutLinkResource--;

1378 }

1379

1380 buildUnnamed166() {

1381 var o = new core.List<api.OrkutLinkResource>();

1382 o.add(buildOrkutLinkResource());

1383 o.add(buildOrkutLinkResource());

1384 return o;

1385 }

1386

1387 checkUnnamed166(core.List<api.OrkutLinkResource> o) {

1388 unittest.expect(o, unittest.hasLength(2));

1389 checkOrkutLinkResource(o[0]);

1390 checkOrkutLinkResource(o[1]);

1391 }

1392

1393 core.int buildCounterVisibility = 0;

1394 buildVisibility() {

1395 var o = new api.Visibility();

1396 buildCounterVisibility++;

1397 if (buildCounterVisibility < 3) {

1398 o.kind = "foo";

1399 o.links = buildUnnamed166();

1400 o.visibility = "foo";

1401 }

1402 buildCounterVisibility--;

1403 return o;

1404 }

1405

1406 checkVisibility(api.Visibility o) {

1407 buildCounterVisibility++;

1408 if (buildCounterVisibility < 3) {

1409 unittest.expect(o.kind, unittest.equals('foo'));

1410 checkUnnamed166(o.links);

1411 unittest.expect(o.visibility, unittest.equals('foo'));

1412 }

1413 buildCounterVisibility--;

1414 }

1415

1416

1417 main() {

1418 unittest.group("obj-schema-AclItems", () {

1419 unittest.test("to-json--from-json", () {

1420 var o = buildAclItems();

1421 var od = new api.AclItems.fromJson(o.toJson());

1422 checkAclItems(od);

1423 });

1424 });

1425

1426

1427 unittest.group("obj-schema-Acl", () {

1428 unittest.test("to-json--from-json", () {

1429 var o = buildAcl();

1430 var od = new api.Acl.fromJson(o.toJson());

1431 checkAcl(od);

1432 });

1433 });

1434

1435

1436 unittest.group("obj-schema-ActivityObjectReplies", () {

1437 unittest.test("to-json--from-json", () {

1438 var o = buildActivityObjectReplies();

1439 var od = new api.ActivityObjectReplies.fromJson(o.toJson());

1440 checkActivityObjectReplies(od);

1441 });

1442 });

1443

1444

1445 unittest.group("obj-schema-ActivityObject", () {

1446 unittest.test("to-json--from-json", () {

1447 var o = buildActivityObject();

1448 var od = new api.ActivityObject.fromJson(o.toJson());

1449 checkActivityObject(od);

1450 });

1451 });

1452

1453

1454 unittest.group("obj-schema-Activity", () {

1455 unittest.test("to-json--from-json", () {

1456 var o = buildActivity();

1457 var od = new api.Activity.fromJson(o.toJson());

1458 checkActivity(od);

1459 });

1460 });

1461

1462

1463 unittest.group("obj-schema-ActivityList", () {

1464 unittest.test("to-json--from-json", () {

1465 var o = buildActivityList();

1466 var od = new api.ActivityList.fromJson(o.toJson());

1467 checkActivityList(od);

1468 });

1469 });

1470

1471

1472 unittest.group("obj-schema-Badge", () {

1473 unittest.test("to-json--from-json", () {

1474 var o = buildBadge();

1475 var od = new api.Badge.fromJson(o.toJson());

1476 checkBadge(od);

1477 });

1478 });

1479

1480

1481 unittest.group("obj-schema-BadgeList", () {

1482 unittest.test("to-json--from-json", () {

1483 var o = buildBadgeList();

1484 var od = new api.BadgeList.fromJson(o.toJson());

1485 checkBadgeList(od);

1486 });

1487 });

1488

1489

1490 unittest.group("obj-schema-CommentInReplyTo", () {

1491 unittest.test("to-json--from-json", () {

1492 var o = buildCommentInReplyTo();

1493 var od = new api.CommentInReplyTo.fromJson(o.toJson());

1494 checkCommentInReplyTo(od);

1495 });

1496 });

1497

1498

1499 unittest.group("obj-schema-Comment", () {

1500 unittest.test("to-json--from-json", () {

1501 var o = buildComment();

1502 var od = new api.Comment.fromJson(o.toJson());

1503 checkComment(od);

1504 });

1505 });

1506

1507

1508 unittest.group("obj-schema-CommentList", () {

1509 unittest.test("to-json--from-json", () {

1510 var o = buildCommentList();

1511 var od = new api.CommentList.fromJson(o.toJson());

1512 checkCommentList(od);

1513 });

1514 });

1515

1516

1517 unittest.group("obj-schema-Community", () {

1518 unittest.test("to-json--from-json", () {

1519 var o = buildCommunity();

1520 var od = new api.Community.fromJson(o.toJson());

1521 checkCommunity(od);

1522 });

1523 });

1524

1525

1526 unittest.group("obj-schema-CommunityList", () {

1527 unittest.test("to-json--from-json", () {

1528 var o = buildCommunityList();

1529 var od = new api.CommunityList.fromJson(o.toJson());

1530 checkCommunityList(od);

1531 });

1532 });

1533

1534

1535 unittest.group("obj-schema-CommunityMembers", () {

1536 unittest.test("to-json--from-json", () {

1537 var o = buildCommunityMembers();

1538 var od = new api.CommunityMembers.fromJson(o.toJson());

1539 checkCommunityMembers(od);

1540 });

1541 });

1542

1543

1544 unittest.group("obj-schema-CommunityMembersList", () {

1545 unittest.test("to-json--from-json", () {

1546 var o = buildCommunityMembersList();

1547 var od = new api.CommunityMembersList.fromJson(o.toJson());

1548 checkCommunityMembersList(od);

1549 });

1550 });

1551

1552

1553 unittest.group("obj-schema-CommunityMembershipStatus", () {

1554 unittest.test("to-json--from-json", () {

1555 var o = buildCommunityMembershipStatus();

1556 var od = new api.CommunityMembershipStatus.fromJson(o.toJson());

1557 checkCommunityMembershipStatus(od);

1558 });

1559 });

1560

1561

1562 unittest.group("obj-schema-CommunityMessage", () {

1563 unittest.test("to-json--from-json", () {

1564 var o = buildCommunityMessage();

1565 var od = new api.CommunityMessage.fromJson(o.toJson());

1566 checkCommunityMessage(od);

1567 });

1568 });

1569

1570

1571 unittest.group("obj-schema-CommunityMessageList", () {

1572 unittest.test("to-json--from-json", () {

1573 var o = buildCommunityMessageList();

1574 var od = new api.CommunityMessageList.fromJson(o.toJson());

1575 checkCommunityMessageList(od);

1576 });

1577 });

1578

1579

1580 unittest.group("obj-schema-CommunityPollImage", () {

1581 unittest.test("to-json--from-json", () {

1582 var o = buildCommunityPollImage();

1583 var od = new api.CommunityPollImage.fromJson(o.toJson());

1584 checkCommunityPollImage(od);

1585 });

1586 });

1587

1588

1589 unittest.group("obj-schema-CommunityPoll", () {

1590 unittest.test("to-json--from-json", () {

1591 var o = buildCommunityPoll();

1592 var od = new api.CommunityPoll.fromJson(o.toJson());

1593 checkCommunityPoll(od);

1594 });

1595 });

1596

1597

1598 unittest.group("obj-schema-CommunityPollComment", () {

1599 unittest.test("to-json--from-json", () {

1600 var o = buildCommunityPollComment();

1601 var od = new api.CommunityPollComment.fromJson(o.toJson());

1602 checkCommunityPollComment(od);

1603 });

1604 });

1605

1606

1607 unittest.group("obj-schema-CommunityPollCommentList", () {

1608 unittest.test("to-json--from-json", () {

1609 var o = buildCommunityPollCommentList();

1610 var od = new api.CommunityPollCommentList.fromJson(o.toJson());

1611 checkCommunityPollCommentList(od);

1612 });

1613 });

1614

1615

1616 unittest.group("obj-schema-CommunityPollList", () {

1617 unittest.test("to-json--from-json", () {

1618 var o = buildCommunityPollList();

1619 var od = new api.CommunityPollList.fromJson(o.toJson());

1620 checkCommunityPollList(od);

1621 });

1622 });

1623

1624

1625 unittest.group("obj-schema-CommunityPollVote", () {

1626 unittest.test("to-json--from-json", () {

1627 var o = buildCommunityPollVote();

1628 var od = new api.CommunityPollVote.fromJson(o.toJson());

1629 checkCommunityPollVote(od);

1630 });

1631 });

1632

1633

1634 unittest.group("obj-schema-CommunityTopic", () {

1635 unittest.test("to-json--from-json", () {

1636 var o = buildCommunityTopic();

1637 var od = new api.CommunityTopic.fromJson(o.toJson());

1638 checkCommunityTopic(od);

1639 });

1640 });

1641

1642

1643 unittest.group("obj-schema-CommunityTopicList", () {

1644 unittest.test("to-json--from-json", () {

1645 var o = buildCommunityTopicList();

1646 var od = new api.CommunityTopicList.fromJson(o.toJson());

1647 checkCommunityTopicList(od);

1648 });

1649 });

1650

1651

1652 unittest.group("obj-schema-Counters", () {

1653 unittest.test("to-json--from-json", () {

1654 var o = buildCounters();

1655 var od = new api.Counters.fromJson(o.toJson());

1656 checkCounters(od);

1657 });

1658 });

1659

1660

1661 unittest.group("obj-schema-OrkutActivityobjectsResource", () {

1662 unittest.test("to-json--from-json", () {

1663 var o = buildOrkutActivityobjectsResource();

1664 var od = new api.OrkutActivityobjectsResource.fromJson(o.toJson());

1665 checkOrkutActivityobjectsResource(od);

1666 });

1667 });

1668

1669

1670 unittest.group("obj-schema-OrkutActivitypersonResourceImage", () {

1671 unittest.test("to-json--from-json", () {

1672 var o = buildOrkutActivitypersonResourceImage();

1673 var od = new api.OrkutActivitypersonResourceImage.fromJson(o.toJson());

1674 checkOrkutActivitypersonResourceImage(od);

1675 });

1676 });

1677

1678

1679 unittest.group("obj-schema-OrkutActivitypersonResourceName", () {

1680 unittest.test("to-json--from-json", () {

1681 var o = buildOrkutActivitypersonResourceName();

1682 var od = new api.OrkutActivitypersonResourceName.fromJson(o.toJson());

1683 checkOrkutActivitypersonResourceName(od);

1684 });

1685 });

1686

1687

1688 unittest.group("obj-schema-OrkutActivitypersonResource", () {

1689 unittest.test("to-json--from-json", () {

1690 var o = buildOrkutActivitypersonResource();

1691 var od = new api.OrkutActivitypersonResource.fromJson(o.toJson());

1692 checkOrkutActivitypersonResource(od);

1693 });

1694 });

1695

1696

1697 unittest.group("obj-schema-OrkutAuthorResourceImage", () {

1698 unittest.test("to-json--from-json", () {

1699 var o = buildOrkutAuthorResourceImage();

1700 var od = new api.OrkutAuthorResourceImage.fromJson(o.toJson());

1701 checkOrkutAuthorResourceImage(od);

1702 });

1703 });

1704

1705

1706 unittest.group("obj-schema-OrkutAuthorResource", () {

1707 unittest.test("to-json--from-json", () {

1708 var o = buildOrkutAuthorResource();

1709 var od = new api.OrkutAuthorResource.fromJson(o.toJson());

1710 checkOrkutAuthorResource(od);

1711 });

1712 });

1713

1714

1715 unittest.group("obj-schema-OrkutCommunitypolloptionResourceImage", () {

1716 unittest.test("to-json--from-json", () {

1717 var o = buildOrkutCommunitypolloptionResourceImage();

1718 var od = new api.OrkutCommunitypolloptionResourceImage.fromJson(o.toJson() );

1719 checkOrkutCommunitypolloptionResourceImage(od);

1720 });

1721 });

1722

1723

1724 unittest.group("obj-schema-OrkutCommunitypolloptionResource", () {

1725 unittest.test("to-json--from-json", () {

1726 var o = buildOrkutCommunitypolloptionResource();

1727 var od = new api.OrkutCommunitypolloptionResource.fromJson(o.toJson());

1728 checkOrkutCommunitypolloptionResource(od);

1729 });

1730 });

1731

1732

1733 unittest.group("obj-schema-OrkutCounterResource", () {

1734 unittest.test("to-json--from-json", () {

1735 var o = buildOrkutCounterResource();

1736 var od = new api.OrkutCounterResource.fromJson(o.toJson());

1737 checkOrkutCounterResource(od);

1738 });

1739 });

1740

1741

1742 unittest.group("obj-schema-OrkutLinkResource", () {

1743 unittest.test("to-json--from-json", () {

1744 var o = buildOrkutLinkResource();

1745 var od = new api.OrkutLinkResource.fromJson(o.toJson());

1746 checkOrkutLinkResource(od);

1747 });

1748 });

1749

1750

1751 unittest.group("obj-schema-Visibility", () {

1752 unittest.test("to-json--from-json", () {

1753 var o = buildVisibility();

1754 var od = new api.Visibility.fromJson(o.toJson());

1755 checkVisibility(od);

1756 });

1757 });

1758

1759

1760 unittest.group("resource-AclResourceApi", () {

1761 unittest.test("method--delete", () {

1762

1763 var mock = new common_test.HttpServerMock();

1764 api.AclResourceApi res = new api.OrkutApi(mock).acl;

1765 var arg_activityId = "foo";

1766 var arg_userId = "foo";

1767 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1768 var path = (req.url).path;

1769 var pathOffset = 0;

1770 var index;

1771 var subPart;

1772 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

1773 pathOffset += 10;

1774 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("activities/"));

1775 pathOffset += 11;

1776 index = path.indexOf("/acl/", pathOffset);

1777 unittest.expect(index >= 0, unittest.isTrue);

1778 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1779 pathOffset = index;

1780 unittest.expect(subPart, unittest.equals("$arg_activityId"));

1781 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/acl/"));

1782 pathOffset += 5;

1783 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

1784 pathOffset = path.length;

1785 unittest.expect(subPart, unittest.equals("$arg_userId"));

1786

1787 var query = (req.url).query;

1788 var queryOffset = 0;

1789 var queryMap = {};

1790 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1791 parseBool(n) {

1792 if (n == "true") return true;

1793 if (n == "false") return false;

1794 if (n == null) return null;

1795 throw new core.ArgumentError("Invalid boolean: $n");

1796 }

1797 if (query.length > 0) {

1798 for (var part in query.split("&")) {

1799 var keyvalue = part.split("=");

1800 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1801 }

1802 }

1803

1804

1805 var h = {

1806 "content-type" : "application/json; charset=utf-8",

1807 };

1808 var resp = "";

1809 return new async.Future.value(common_test.stringResponse(200, h, resp));

1810 }), true);

1811 res.delete(arg_activityId, arg_userId).then(unittest.expectAsync((_) {}));

1812 });

1813

1814 });

1815

1816

1817 unittest.group("resource-ActivitiesResourceApi", () {

1818 unittest.test("method--delete", () {

1819

1820 var mock = new common_test.HttpServerMock();

1821 api.ActivitiesResourceApi res = new api.OrkutApi(mock).activities;

1822 var arg_activityId = "foo";

1823 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1824 var path = (req.url).path;

1825 var pathOffset = 0;

1826 var index;

1827 var subPart;

1828 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

1829 pathOffset += 10;

1830 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("activities/"));

1831 pathOffset += 11;

1832 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

1833 pathOffset = path.length;

1834 unittest.expect(subPart, unittest.equals("$arg_activityId"));

1835

1836 var query = (req.url).query;

1837 var queryOffset = 0;

1838 var queryMap = {};

1839 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1840 parseBool(n) {

1841 if (n == "true") return true;

1842 if (n == "false") return false;

1843 if (n == null) return null;

1844 throw new core.ArgumentError("Invalid boolean: $n");

1845 }

1846 if (query.length > 0) {

1847 for (var part in query.split("&")) {

1848 var keyvalue = part.split("=");

1849 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1850 }

1851 }

1852

1853

1854 var h = {

1855 "content-type" : "application/json; charset=utf-8",

1856 };

1857 var resp = "";

1858 return new async.Future.value(common_test.stringResponse(200, h, resp));

1859 }), true);

1860 res.delete(arg_activityId).then(unittest.expectAsync((_) {}));

1861 });

1862

1863 unittest.test("method--list", () {

1864

1865 var mock = new common_test.HttpServerMock();

1866 api.ActivitiesResourceApi res = new api.OrkutApi(mock).activities;

1867 var arg_userId = "foo";

1868 var arg_collection = "foo";

1869 var arg_hl = "foo";

1870 var arg_maxResults = 42;

1871 var arg_pageToken = "foo";

1872 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1873 var path = (req.url).path;

1874 var pathOffset = 0;

1875 var index;

1876 var subPart;

1877 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

1878 pathOffset += 10;

1879 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("people/"));

1880 pathOffset += 7;

1881 index = path.indexOf("/activities/", pathOffset);

1882 unittest.expect(index >= 0, unittest.isTrue);

1883 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1884 pathOffset = index;

1885 unittest.expect(subPart, unittest.equals("$arg_userId"));

1886 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/activities/"));

1887 pathOffset += 12;

1888 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

1889 pathOffset = path.length;

1890 unittest.expect(subPart, unittest.equals("$arg_collection"));

1891

1892 var query = (req.url).query;

1893 var queryOffset = 0;

1894 var queryMap = {};

1895 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1896 parseBool(n) {

1897 if (n == "true") return true;

1898 if (n == "false") return false;

1899 if (n == null) return null;

1900 throw new core.ArgumentError("Invalid boolean: $n");

1901 }

1902 if (query.length > 0) {

1903 for (var part in query.split("&")) {

1904 var keyvalue = part.split("=");

1905 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1906 }

1907 }

1908 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

1909 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

1910 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

1911

1912

1913 var h = {

1914 "content-type" : "application/json; charset=utf-8",

1915 };

1916 var resp = convert.JSON.encode(buildActivityList());

1917 return new async.Future.value(common_test.stringResponse(200, h, resp));

1918 }), true);

1919 res.list(arg_userId, arg_collection, hl: arg_hl, maxResults: arg_maxResult s, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ActivityList respon se) {

1920 checkActivityList(response);

1921 })));

1922 });

1923

1924 });

1925

1926

1927 unittest.group("resource-ActivityVisibilityResourceApi", () {

1928 unittest.test("method--get", () {

1929

1930 var mock = new common_test.HttpServerMock();

1931 api.ActivityVisibilityResourceApi res = new api.OrkutApi(mock).activityVis ibility;

1932 var arg_activityId = "foo";

1933 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1934 var path = (req.url).path;

1935 var pathOffset = 0;

1936 var index;

1937 var subPart;

1938 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

1939 pathOffset += 10;

1940 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("activities/"));

1941 pathOffset += 11;

1942 index = path.indexOf("/visibility", pathOffset);

1943 unittest.expect(index >= 0, unittest.isTrue);

1944 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1945 pathOffset = index;

1946 unittest.expect(subPart, unittest.equals("$arg_activityId"));

1947 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/visibility"));

1948 pathOffset += 11;

1949

1950 var query = (req.url).query;

1951 var queryOffset = 0;

1952 var queryMap = {};

1953 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1954 parseBool(n) {

1955 if (n == "true") return true;

1956 if (n == "false") return false;

1957 if (n == null) return null;

1958 throw new core.ArgumentError("Invalid boolean: $n");

1959 }

1960 if (query.length > 0) {

1961 for (var part in query.split("&")) {

1962 var keyvalue = part.split("=");

1963 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1964 }

1965 }

1966

1967

1968 var h = {

1969 "content-type" : "application/json; charset=utf-8",

1970 };

1971 var resp = convert.JSON.encode(buildVisibility());

1972 return new async.Future.value(common_test.stringResponse(200, h, resp));

1973 }), true);

1974 res.get(arg_activityId).then(unittest.expectAsync(((api.Visibility respons e) {

1975 checkVisibility(response);

1976 })));

1977 });

1978

1979 unittest.test("method--patch", () {

1980

1981 var mock = new common_test.HttpServerMock();

1982 api.ActivityVisibilityResourceApi res = new api.OrkutApi(mock).activityVis ibility;

1983 var arg_request = buildVisibility();

1984 var arg_activityId = "foo";

1985 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1986 var obj = new api.Visibility.fromJson(json);

1987 checkVisibility(obj);

1988

1989 var path = (req.url).path;

1990 var pathOffset = 0;

1991 var index;

1992 var subPart;

1993 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

1994 pathOffset += 10;

1995 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("activities/"));

1996 pathOffset += 11;

1997 index = path.indexOf("/visibility", pathOffset);

1998 unittest.expect(index >= 0, unittest.isTrue);

1999 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2000 pathOffset = index;

2001 unittest.expect(subPart, unittest.equals("$arg_activityId"));

2002 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/visibility"));

2003 pathOffset += 11;

2004

2005 var query = (req.url).query;

2006 var queryOffset = 0;

2007 var queryMap = {};

2008 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2009 parseBool(n) {

2010 if (n == "true") return true;

2011 if (n == "false") return false;

2012 if (n == null) return null;

2013 throw new core.ArgumentError("Invalid boolean: $n");

2014 }

2015 if (query.length > 0) {

2016 for (var part in query.split("&")) {

2017 var keyvalue = part.split("=");

2018 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2019 }

2020 }

2021

2022

2023 var h = {

2024 "content-type" : "application/json; charset=utf-8",

2025 };

2026 var resp = convert.JSON.encode(buildVisibility());

2027 return new async.Future.value(common_test.stringResponse(200, h, resp));

2028 }), true);

2029 res.patch(arg_request, arg_activityId).then(unittest.expectAsync(((api.Vis ibility response) {

2030 checkVisibility(response);

2031 })));

2032 });

2033

2034 unittest.test("method--update", () {

2035

2036 var mock = new common_test.HttpServerMock();

2037 api.ActivityVisibilityResourceApi res = new api.OrkutApi(mock).activityVis ibility;

2038 var arg_request = buildVisibility();

2039 var arg_activityId = "foo";

2040 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2041 var obj = new api.Visibility.fromJson(json);

2042 checkVisibility(obj);

2043

2044 var path = (req.url).path;

2045 var pathOffset = 0;

2046 var index;

2047 var subPart;

2048 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2049 pathOffset += 10;

2050 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("activities/"));

2051 pathOffset += 11;

2052 index = path.indexOf("/visibility", pathOffset);

2053 unittest.expect(index >= 0, unittest.isTrue);

2054 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2055 pathOffset = index;

2056 unittest.expect(subPart, unittest.equals("$arg_activityId"));

2057 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/visibility"));

2058 pathOffset += 11;

2059

2060 var query = (req.url).query;

2061 var queryOffset = 0;

2062 var queryMap = {};

2063 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2064 parseBool(n) {

2065 if (n == "true") return true;

2066 if (n == "false") return false;

2067 if (n == null) return null;

2068 throw new core.ArgumentError("Invalid boolean: $n");

2069 }

2070 if (query.length > 0) {

2071 for (var part in query.split("&")) {

2072 var keyvalue = part.split("=");

2073 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2074 }

2075 }

2076

2077

2078 var h = {

2079 "content-type" : "application/json; charset=utf-8",

2080 };

2081 var resp = convert.JSON.encode(buildVisibility());

2082 return new async.Future.value(common_test.stringResponse(200, h, resp));

2083 }), true);

2084 res.update(arg_request, arg_activityId).then(unittest.expectAsync(((api.Vi sibility response) {

2085 checkVisibility(response);

2086 })));

2087 });

2088

2089 });

2090

2091

2092 unittest.group("resource-BadgesResourceApi", () {

2093 unittest.test("method--get", () {

2094

2095 var mock = new common_test.HttpServerMock();

2096 api.BadgesResourceApi res = new api.OrkutApi(mock).badges;

2097 var arg_userId = "foo";

2098 var arg_badgeId = "foo";

2099 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2100 var path = (req.url).path;

2101 var pathOffset = 0;

2102 var index;

2103 var subPart;

2104 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2105 pathOffset += 10;

2106 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("people/"));

2107 pathOffset += 7;

2108 index = path.indexOf("/badges/", pathOffset);

2109 unittest.expect(index >= 0, unittest.isTrue);

2110 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2111 pathOffset = index;

2112 unittest.expect(subPart, unittest.equals("$arg_userId"));

2113 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/badges/"));

2114 pathOffset += 8;

2115 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2116 pathOffset = path.length;

2117 unittest.expect(subPart, unittest.equals("$arg_badgeId"));

2118

2119 var query = (req.url).query;

2120 var queryOffset = 0;

2121 var queryMap = {};

2122 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2123 parseBool(n) {

2124 if (n == "true") return true;

2125 if (n == "false") return false;

2126 if (n == null) return null;

2127 throw new core.ArgumentError("Invalid boolean: $n");

2128 }

2129 if (query.length > 0) {

2130 for (var part in query.split("&")) {

2131 var keyvalue = part.split("=");

2132 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2133 }

2134 }

2135

2136

2137 var h = {

2138 "content-type" : "application/json; charset=utf-8",

2139 };

2140 var resp = convert.JSON.encode(buildBadge());

2141 return new async.Future.value(common_test.stringResponse(200, h, resp));

2142 }), true);

2143 res.get(arg_userId, arg_badgeId).then(unittest.expectAsync(((api.Badge res ponse) {

2144 checkBadge(response);

2145 })));

2146 });

2147

2148 unittest.test("method--list", () {

2149

2150 var mock = new common_test.HttpServerMock();

2151 api.BadgesResourceApi res = new api.OrkutApi(mock).badges;

2152 var arg_userId = "foo";

2153 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2154 var path = (req.url).path;

2155 var pathOffset = 0;

2156 var index;

2157 var subPart;

2158 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2159 pathOffset += 10;

2160 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("people/"));

2161 pathOffset += 7;

2162 index = path.indexOf("/badges", pathOffset);

2163 unittest.expect(index >= 0, unittest.isTrue);

2164 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2165 pathOffset = index;

2166 unittest.expect(subPart, unittest.equals("$arg_userId"));

2167 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/badges"));

2168 pathOffset += 7;

2169

2170 var query = (req.url).query;

2171 var queryOffset = 0;

2172 var queryMap = {};

2173 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2174 parseBool(n) {

2175 if (n == "true") return true;

2176 if (n == "false") return false;

2177 if (n == null) return null;

2178 throw new core.ArgumentError("Invalid boolean: $n");

2179 }

2180 if (query.length > 0) {

2181 for (var part in query.split("&")) {

2182 var keyvalue = part.split("=");

2183 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2184 }

2185 }

2186

2187

2188 var h = {

2189 "content-type" : "application/json; charset=utf-8",

2190 };

2191 var resp = convert.JSON.encode(buildBadgeList());

2192 return new async.Future.value(common_test.stringResponse(200, h, resp));

2193 }), true);

2194 res.list(arg_userId).then(unittest.expectAsync(((api.BadgeList response) {

2195 checkBadgeList(response);

2196 })));

2197 });

2198

2199 });

2200

2201

2202 unittest.group("resource-CommentsResourceApi", () {

2203 unittest.test("method--delete", () {

2204

2205 var mock = new common_test.HttpServerMock();

2206 api.CommentsResourceApi res = new api.OrkutApi(mock).comments;

2207 var arg_commentId = "foo";

2208 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2209 var path = (req.url).path;

2210 var pathOffset = 0;

2211 var index;

2212 var subPart;

2213 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2214 pathOffset += 10;

2215 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("comments/"));

2216 pathOffset += 9;

2217 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2218 pathOffset = path.length;

2219 unittest.expect(subPart, unittest.equals("$arg_commentId"));

2220

2221 var query = (req.url).query;

2222 var queryOffset = 0;

2223 var queryMap = {};

2224 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2225 parseBool(n) {

2226 if (n == "true") return true;

2227 if (n == "false") return false;

2228 if (n == null) return null;

2229 throw new core.ArgumentError("Invalid boolean: $n");

2230 }

2231 if (query.length > 0) {

2232 for (var part in query.split("&")) {

2233 var keyvalue = part.split("=");

2234 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2235 }

2236 }

2237

2238

2239 var h = {

2240 "content-type" : "application/json; charset=utf-8",

2241 };

2242 var resp = "";

2243 return new async.Future.value(common_test.stringResponse(200, h, resp));

2244 }), true);

2245 res.delete(arg_commentId).then(unittest.expectAsync((_) {}));

2246 });

2247

2248 unittest.test("method--get", () {

2249

2250 var mock = new common_test.HttpServerMock();

2251 api.CommentsResourceApi res = new api.OrkutApi(mock).comments;

2252 var arg_commentId = "foo";

2253 var arg_hl = "foo";

2254 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2255 var path = (req.url).path;

2256 var pathOffset = 0;

2257 var index;

2258 var subPart;

2259 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2260 pathOffset += 10;

2261 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("comments/"));

2262 pathOffset += 9;

2263 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2264 pathOffset = path.length;

2265 unittest.expect(subPart, unittest.equals("$arg_commentId"));

2266

2267 var query = (req.url).query;

2268 var queryOffset = 0;

2269 var queryMap = {};

2270 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2271 parseBool(n) {

2272 if (n == "true") return true;

2273 if (n == "false") return false;

2274 if (n == null) return null;

2275 throw new core.ArgumentError("Invalid boolean: $n");

2276 }

2277 if (query.length > 0) {

2278 for (var part in query.split("&")) {

2279 var keyvalue = part.split("=");

2280 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2281 }

2282 }

2283 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

2284

2285

2286 var h = {

2287 "content-type" : "application/json; charset=utf-8",

2288 };

2289 var resp = convert.JSON.encode(buildComment());

2290 return new async.Future.value(common_test.stringResponse(200, h, resp));

2291 }), true);

2292 res.get(arg_commentId, hl: arg_hl).then(unittest.expectAsync(((api.Comment response) {

2293 checkComment(response);

2294 })));

2295 });

2296

2297 unittest.test("method--insert", () {

2298

2299 var mock = new common_test.HttpServerMock();

2300 api.CommentsResourceApi res = new api.OrkutApi(mock).comments;

2301 var arg_request = buildComment();

2302 var arg_activityId = "foo";

2303 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2304 var obj = new api.Comment.fromJson(json);

2305 checkComment(obj);

2306

2307 var path = (req.url).path;

2308 var pathOffset = 0;

2309 var index;

2310 var subPart;

2311 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2312 pathOffset += 10;

2313 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("activities/"));

2314 pathOffset += 11;

2315 index = path.indexOf("/comments", pathOffset);

2316 unittest.expect(index >= 0, unittest.isTrue);

2317 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2318 pathOffset = index;

2319 unittest.expect(subPart, unittest.equals("$arg_activityId"));

2320 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/comments"));

2321 pathOffset += 9;

2322

2323 var query = (req.url).query;

2324 var queryOffset = 0;

2325 var queryMap = {};

2326 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2327 parseBool(n) {

2328 if (n == "true") return true;

2329 if (n == "false") return false;

2330 if (n == null) return null;

2331 throw new core.ArgumentError("Invalid boolean: $n");

2332 }

2333 if (query.length > 0) {

2334 for (var part in query.split("&")) {

2335 var keyvalue = part.split("=");

2336 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2337 }

2338 }

2339

2340

2341 var h = {

2342 "content-type" : "application/json; charset=utf-8",

2343 };

2344 var resp = convert.JSON.encode(buildComment());

2345 return new async.Future.value(common_test.stringResponse(200, h, resp));

2346 }), true);

2347 res.insert(arg_request, arg_activityId).then(unittest.expectAsync(((api.Co mment response) {

2348 checkComment(response);

2349 })));

2350 });

2351

2352 unittest.test("method--list", () {

2353

2354 var mock = new common_test.HttpServerMock();

2355 api.CommentsResourceApi res = new api.OrkutApi(mock).comments;

2356 var arg_activityId = "foo";

2357 var arg_hl = "foo";

2358 var arg_maxResults = 42;

2359 var arg_orderBy = "foo";

2360 var arg_pageToken = "foo";

2361 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2362 var path = (req.url).path;

2363 var pathOffset = 0;

2364 var index;

2365 var subPart;

2366 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2367 pathOffset += 10;

2368 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("activities/"));

2369 pathOffset += 11;

2370 index = path.indexOf("/comments", pathOffset);

2371 unittest.expect(index >= 0, unittest.isTrue);

2372 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2373 pathOffset = index;

2374 unittest.expect(subPart, unittest.equals("$arg_activityId"));

2375 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/comments"));

2376 pathOffset += 9;

2377

2378 var query = (req.url).query;

2379 var queryOffset = 0;

2380 var queryMap = {};

2381 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2382 parseBool(n) {

2383 if (n == "true") return true;

2384 if (n == "false") return false;

2385 if (n == null) return null;

2386 throw new core.ArgumentError("Invalid boolean: $n");

2387 }

2388 if (query.length > 0) {

2389 for (var part in query.split("&")) {

2390 var keyvalue = part.split("=");

2391 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2392 }

2393 }

2394 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

2395 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2396 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

2397 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2398

2399

2400 var h = {

2401 "content-type" : "application/json; charset=utf-8",

2402 };

2403 var resp = convert.JSON.encode(buildCommentList());

2404 return new async.Future.value(common_test.stringResponse(200, h, resp));

2405 }), true);

2406 res.list(arg_activityId, hl: arg_hl, maxResults: arg_maxResults, orderBy: arg_orderBy, pageToken: arg_pageToken).then(unittest.expectAsync(((api.CommentLi st response) {

2407 checkCommentList(response);

2408 })));

2409 });

2410

2411 });

2412

2413

2414 unittest.group("resource-CommunitiesResourceApi", () {

2415 unittest.test("method--get", () {

2416

2417 var mock = new common_test.HttpServerMock();

2418 api.CommunitiesResourceApi res = new api.OrkutApi(mock).communities;

2419 var arg_communityId = 42;

2420 var arg_hl = "foo";

2421 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2422 var path = (req.url).path;

2423 var pathOffset = 0;

2424 var index;

2425 var subPart;

2426 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2427 pathOffset += 10;

2428 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

2429 pathOffset += 12;

2430 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2431 pathOffset = path.length;

2432 unittest.expect(subPart, unittest.equals("$arg_communityId"));

2433

2434 var query = (req.url).query;

2435 var queryOffset = 0;

2436 var queryMap = {};

2437 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2438 parseBool(n) {

2439 if (n == "true") return true;

2440 if (n == "false") return false;

2441 if (n == null) return null;

2442 throw new core.ArgumentError("Invalid boolean: $n");

2443 }

2444 if (query.length > 0) {

2445 for (var part in query.split("&")) {

2446 var keyvalue = part.split("=");

2447 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2448 }

2449 }

2450 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

2451

2452

2453 var h = {

2454 "content-type" : "application/json; charset=utf-8",

2455 };

2456 var resp = convert.JSON.encode(buildCommunity());

2457 return new async.Future.value(common_test.stringResponse(200, h, resp));

2458 }), true);

2459 res.get(arg_communityId, hl: arg_hl).then(unittest.expectAsync(((api.Commu nity response) {

2460 checkCommunity(response);

2461 })));

2462 });

2463

2464 unittest.test("method--list", () {

2465

2466 var mock = new common_test.HttpServerMock();

2467 api.CommunitiesResourceApi res = new api.OrkutApi(mock).communities;

2468 var arg_userId = "foo";

2469 var arg_hl = "foo";

2470 var arg_maxResults = 42;

2471 var arg_orderBy = "foo";

2472 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2473 var path = (req.url).path;

2474 var pathOffset = 0;

2475 var index;

2476 var subPart;

2477 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2478 pathOffset += 10;

2479 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("people/"));

2480 pathOffset += 7;

2481 index = path.indexOf("/communities", pathOffset);

2482 unittest.expect(index >= 0, unittest.isTrue);

2483 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2484 pathOffset = index;

2485 unittest.expect(subPart, unittest.equals("$arg_userId"));

2486 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/communities"));

2487 pathOffset += 12;

2488

2489 var query = (req.url).query;

2490 var queryOffset = 0;

2491 var queryMap = {};

2492 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2493 parseBool(n) {

2494 if (n == "true") return true;

2495 if (n == "false") return false;

2496 if (n == null) return null;

2497 throw new core.ArgumentError("Invalid boolean: $n");

2498 }

2499 if (query.length > 0) {

2500 for (var part in query.split("&")) {

2501 var keyvalue = part.split("=");

2502 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2503 }

2504 }

2505 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

2506 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2507 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

2508

2509

2510 var h = {

2511 "content-type" : "application/json; charset=utf-8",

2512 };

2513 var resp = convert.JSON.encode(buildCommunityList());

2514 return new async.Future.value(common_test.stringResponse(200, h, resp));

2515 }), true);

2516 res.list(arg_userId, hl: arg_hl, maxResults: arg_maxResults, orderBy: arg_ orderBy).then(unittest.expectAsync(((api.CommunityList response) {

2517 checkCommunityList(response);

2518 })));

2519 });

2520

2521 });

2522

2523

2524 unittest.group("resource-CommunityFollowResourceApi", () {

2525 unittest.test("method--delete", () {

2526

2527 var mock = new common_test.HttpServerMock();

2528 api.CommunityFollowResourceApi res = new api.OrkutApi(mock).communityFollo w;

2529 var arg_communityId = 42;

2530 var arg_userId = "foo";

2531 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2532 var path = (req.url).path;

2533 var pathOffset = 0;

2534 var index;

2535 var subPart;

2536 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2537 pathOffset += 10;

2538 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

2539 pathOffset += 12;

2540 index = path.indexOf("/followers/", pathOffset);

2541 unittest.expect(index >= 0, unittest.isTrue);

2542 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2543 pathOffset = index;

2544 unittest.expect(subPart, unittest.equals("$arg_communityId"));

2545 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/followers/"));

2546 pathOffset += 11;

2547 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2548 pathOffset = path.length;

2549 unittest.expect(subPart, unittest.equals("$arg_userId"));

2550

2551 var query = (req.url).query;

2552 var queryOffset = 0;

2553 var queryMap = {};

2554 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2555 parseBool(n) {

2556 if (n == "true") return true;

2557 if (n == "false") return false;

2558 if (n == null) return null;

2559 throw new core.ArgumentError("Invalid boolean: $n");

2560 }

2561 if (query.length > 0) {

2562 for (var part in query.split("&")) {

2563 var keyvalue = part.split("=");

2564 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2565 }

2566 }

2567

2568

2569 var h = {

2570 "content-type" : "application/json; charset=utf-8",

2571 };

2572 var resp = "";

2573 return new async.Future.value(common_test.stringResponse(200, h, resp));

2574 }), true);

2575 res.delete(arg_communityId, arg_userId).then(unittest.expectAsync((_) {})) ;

2576 });

2577

2578 unittest.test("method--insert", () {

2579

2580 var mock = new common_test.HttpServerMock();

2581 api.CommunityFollowResourceApi res = new api.OrkutApi(mock).communityFollo w;

2582 var arg_communityId = 42;

2583 var arg_userId = "foo";

2584 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2585 var path = (req.url).path;

2586 var pathOffset = 0;

2587 var index;

2588 var subPart;

2589 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2590 pathOffset += 10;

2591 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

2592 pathOffset += 12;

2593 index = path.indexOf("/followers/", pathOffset);

2594 unittest.expect(index >= 0, unittest.isTrue);

2595 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2596 pathOffset = index;

2597 unittest.expect(subPart, unittest.equals("$arg_communityId"));

2598 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/followers/"));

2599 pathOffset += 11;

2600 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2601 pathOffset = path.length;

2602 unittest.expect(subPart, unittest.equals("$arg_userId"));

2603

2604 var query = (req.url).query;

2605 var queryOffset = 0;

2606 var queryMap = {};

2607 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2608 parseBool(n) {

2609 if (n == "true") return true;

2610 if (n == "false") return false;

2611 if (n == null) return null;

2612 throw new core.ArgumentError("Invalid boolean: $n");

2613 }

2614 if (query.length > 0) {

2615 for (var part in query.split("&")) {

2616 var keyvalue = part.split("=");

2617 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2618 }

2619 }

2620

2621

2622 var h = {

2623 "content-type" : "application/json; charset=utf-8",

2624 };

2625 var resp = convert.JSON.encode(buildCommunityMembers());

2626 return new async.Future.value(common_test.stringResponse(200, h, resp));

2627 }), true);

2628 res.insert(arg_communityId, arg_userId).then(unittest.expectAsync(((api.Co mmunityMembers response) {

2629 checkCommunityMembers(response);

2630 })));

2631 });

2632

2633 });

2634

2635

2636 unittest.group("resource-CommunityMembersResourceApi", () {

2637 unittest.test("method--delete", () {

2638

2639 var mock = new common_test.HttpServerMock();

2640 api.CommunityMembersResourceApi res = new api.OrkutApi(mock).communityMemb ers;

2641 var arg_communityId = 42;

2642 var arg_userId = "foo";

2643 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2644 var path = (req.url).path;

2645 var pathOffset = 0;

2646 var index;

2647 var subPart;

2648 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2649 pathOffset += 10;

2650 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

2651 pathOffset += 12;

2652 index = path.indexOf("/members/", pathOffset);

2653 unittest.expect(index >= 0, unittest.isTrue);

2654 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2655 pathOffset = index;

2656 unittest.expect(subPart, unittest.equals("$arg_communityId"));

2657 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/members/"));

2658 pathOffset += 9;

2659 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2660 pathOffset = path.length;

2661 unittest.expect(subPart, unittest.equals("$arg_userId"));

2662

2663 var query = (req.url).query;

2664 var queryOffset = 0;

2665 var queryMap = {};

2666 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2667 parseBool(n) {

2668 if (n == "true") return true;

2669 if (n == "false") return false;

2670 if (n == null) return null;

2671 throw new core.ArgumentError("Invalid boolean: $n");

2672 }

2673 if (query.length > 0) {

2674 for (var part in query.split("&")) {

2675 var keyvalue = part.split("=");

2676 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2677 }

2678 }

2679

2680

2681 var h = {

2682 "content-type" : "application/json; charset=utf-8",

2683 };

2684 var resp = "";

2685 return new async.Future.value(common_test.stringResponse(200, h, resp));

2686 }), true);

2687 res.delete(arg_communityId, arg_userId).then(unittest.expectAsync((_) {})) ;

2688 });

2689

2690 unittest.test("method--get", () {

2691

2692 var mock = new common_test.HttpServerMock();

2693 api.CommunityMembersResourceApi res = new api.OrkutApi(mock).communityMemb ers;

2694 var arg_communityId = 42;

2695 var arg_userId = "foo";

2696 var arg_hl = "foo";

2697 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2698 var path = (req.url).path;

2699 var pathOffset = 0;

2700 var index;

2701 var subPart;

2702 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2703 pathOffset += 10;

2704 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

2705 pathOffset += 12;

2706 index = path.indexOf("/members/", pathOffset);

2707 unittest.expect(index >= 0, unittest.isTrue);

2708 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2709 pathOffset = index;

2710 unittest.expect(subPart, unittest.equals("$arg_communityId"));

2711 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/members/"));

2712 pathOffset += 9;

2713 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2714 pathOffset = path.length;

2715 unittest.expect(subPart, unittest.equals("$arg_userId"));

2716

2717 var query = (req.url).query;

2718 var queryOffset = 0;

2719 var queryMap = {};

2720 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2721 parseBool(n) {

2722 if (n == "true") return true;

2723 if (n == "false") return false;

2724 if (n == null) return null;

2725 throw new core.ArgumentError("Invalid boolean: $n");

2726 }

2727 if (query.length > 0) {

2728 for (var part in query.split("&")) {

2729 var keyvalue = part.split("=");

2730 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2731 }

2732 }

2733 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

2734

2735

2736 var h = {

2737 "content-type" : "application/json; charset=utf-8",

2738 };

2739 var resp = convert.JSON.encode(buildCommunityMembers());

2740 return new async.Future.value(common_test.stringResponse(200, h, resp));

2741 }), true);

2742 res.get(arg_communityId, arg_userId, hl: arg_hl).then(unittest.expectAsync (((api.CommunityMembers response) {

2743 checkCommunityMembers(response);

2744 })));

2745 });

2746

2747 unittest.test("method--insert", () {

2748

2749 var mock = new common_test.HttpServerMock();

2750 api.CommunityMembersResourceApi res = new api.OrkutApi(mock).communityMemb ers;

2751 var arg_communityId = 42;

2752 var arg_userId = "foo";

2753 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2754 var path = (req.url).path;

2755 var pathOffset = 0;

2756 var index;

2757 var subPart;

2758 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2759 pathOffset += 10;

2760 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

2761 pathOffset += 12;

2762 index = path.indexOf("/members/", pathOffset);

2763 unittest.expect(index >= 0, unittest.isTrue);

2764 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2765 pathOffset = index;

2766 unittest.expect(subPart, unittest.equals("$arg_communityId"));

2767 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/members/"));

2768 pathOffset += 9;

2769 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2770 pathOffset = path.length;

2771 unittest.expect(subPart, unittest.equals("$arg_userId"));

2772

2773 var query = (req.url).query;

2774 var queryOffset = 0;

2775 var queryMap = {};

2776 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2777 parseBool(n) {

2778 if (n == "true") return true;

2779 if (n == "false") return false;

2780 if (n == null) return null;

2781 throw new core.ArgumentError("Invalid boolean: $n");

2782 }

2783 if (query.length > 0) {

2784 for (var part in query.split("&")) {

2785 var keyvalue = part.split("=");

2786 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2787 }

2788 }

2789

2790

2791 var h = {

2792 "content-type" : "application/json; charset=utf-8",

2793 };

2794 var resp = convert.JSON.encode(buildCommunityMembers());

2795 return new async.Future.value(common_test.stringResponse(200, h, resp));

2796 }), true);

2797 res.insert(arg_communityId, arg_userId).then(unittest.expectAsync(((api.Co mmunityMembers response) {

2798 checkCommunityMembers(response);

2799 })));

2800 });

2801

2802 unittest.test("method--list", () {

2803

2804 var mock = new common_test.HttpServerMock();

2805 api.CommunityMembersResourceApi res = new api.OrkutApi(mock).communityMemb ers;

2806 var arg_communityId = 42;

2807 var arg_friendsOnly = true;

2808 var arg_hl = "foo";

2809 var arg_maxResults = 42;

2810 var arg_pageToken = "foo";

2811 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2812 var path = (req.url).path;

2813 var pathOffset = 0;

2814 var index;

2815 var subPart;

2816 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2817 pathOffset += 10;

2818 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

2819 pathOffset += 12;

2820 index = path.indexOf("/members", pathOffset);

2821 unittest.expect(index >= 0, unittest.isTrue);

2822 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2823 pathOffset = index;

2824 unittest.expect(subPart, unittest.equals("$arg_communityId"));

2825 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/members"));

2826 pathOffset += 8;

2827

2828 var query = (req.url).query;

2829 var queryOffset = 0;

2830 var queryMap = {};

2831 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2832 parseBool(n) {

2833 if (n == "true") return true;

2834 if (n == "false") return false;

2835 if (n == null) return null;

2836 throw new core.ArgumentError("Invalid boolean: $n");

2837 }

2838 if (query.length > 0) {

2839 for (var part in query.split("&")) {

2840 var keyvalue = part.split("=");

2841 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2842 }

2843 }

2844 unittest.expect(queryMap["friendsOnly"].first, unittest.equals("$arg_fri endsOnly"));

2845 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

2846 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2847 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2848

2849

2850 var h = {

2851 "content-type" : "application/json; charset=utf-8",

2852 };

2853 var resp = convert.JSON.encode(buildCommunityMembersList());

2854 return new async.Future.value(common_test.stringResponse(200, h, resp));

2855 }), true);

2856 res.list(arg_communityId, friendsOnly: arg_friendsOnly, hl: arg_hl, maxRes ults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api. CommunityMembersList response) {

2857 checkCommunityMembersList(response);

2858 })));

2859 });

2860

2861 });

2862

2863

2864 unittest.group("resource-CommunityMessagesResourceApi", () {

2865 unittest.test("method--delete", () {

2866

2867 var mock = new common_test.HttpServerMock();

2868 api.CommunityMessagesResourceApi res = new api.OrkutApi(mock).communityMes sages;

2869 var arg_communityId = 42;

2870 var arg_topicId = "foo";

2871 var arg_messageId = "foo";

2872 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2873 var path = (req.url).path;

2874 var pathOffset = 0;

2875 var index;

2876 var subPart;

2877 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2878 pathOffset += 10;

2879 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

2880 pathOffset += 12;

2881 index = path.indexOf("/topics/", pathOffset);

2882 unittest.expect(index >= 0, unittest.isTrue);

2883 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2884 pathOffset = index;

2885 unittest.expect(subPart, unittest.equals("$arg_communityId"));

2886 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/topics/"));

2887 pathOffset += 8;

2888 index = path.indexOf("/messages/", pathOffset);

2889 unittest.expect(index >= 0, unittest.isTrue);

2890 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2891 pathOffset = index;

2892 unittest.expect(subPart, unittest.equals("$arg_topicId"));

2893 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/messages/"));

2894 pathOffset += 10;

2895 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2896 pathOffset = path.length;

2897 unittest.expect(subPart, unittest.equals("$arg_messageId"));

2898

2899 var query = (req.url).query;

2900 var queryOffset = 0;

2901 var queryMap = {};

2902 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2903 parseBool(n) {

2904 if (n == "true") return true;

2905 if (n == "false") return false;

2906 if (n == null) return null;

2907 throw new core.ArgumentError("Invalid boolean: $n");

2908 }

2909 if (query.length > 0) {

2910 for (var part in query.split("&")) {

2911 var keyvalue = part.split("=");

2912 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2913 }

2914 }

2915

2916

2917 var h = {

2918 "content-type" : "application/json; charset=utf-8",

2919 };

2920 var resp = "";

2921 return new async.Future.value(common_test.stringResponse(200, h, resp));

2922 }), true);

2923 res.delete(arg_communityId, arg_topicId, arg_messageId).then(unittest.expe ctAsync((_) {}));

2924 });

2925

2926 unittest.test("method--insert", () {

2927

2928 var mock = new common_test.HttpServerMock();

2929 api.CommunityMessagesResourceApi res = new api.OrkutApi(mock).communityMes sages;

2930 var arg_request = buildCommunityMessage();

2931 var arg_communityId = 42;

2932 var arg_topicId = "foo";

2933 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2934 var obj = new api.CommunityMessage.fromJson(json);

2935 checkCommunityMessage(obj);

2936

2937 var path = (req.url).path;

2938 var pathOffset = 0;

2939 var index;

2940 var subPart;

2941 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

2942 pathOffset += 10;

2943 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

2944 pathOffset += 12;

2945 index = path.indexOf("/topics/", pathOffset);

2946 unittest.expect(index >= 0, unittest.isTrue);

2947 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2948 pathOffset = index;

2949 unittest.expect(subPart, unittest.equals("$arg_communityId"));

2950 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/topics/"));

2951 pathOffset += 8;

2952 index = path.indexOf("/messages", pathOffset);

2953 unittest.expect(index >= 0, unittest.isTrue);

2954 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2955 pathOffset = index;

2956 unittest.expect(subPart, unittest.equals("$arg_topicId"));

2957 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/messages"));

2958 pathOffset += 9;

2959

2960 var query = (req.url).query;

2961 var queryOffset = 0;

2962 var queryMap = {};

2963 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2964 parseBool(n) {

2965 if (n == "true") return true;

2966 if (n == "false") return false;

2967 if (n == null) return null;

2968 throw new core.ArgumentError("Invalid boolean: $n");

2969 }

2970 if (query.length > 0) {

2971 for (var part in query.split("&")) {

2972 var keyvalue = part.split("=");

2973 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2974 }

2975 }

2976

2977

2978 var h = {

2979 "content-type" : "application/json; charset=utf-8",

2980 };

2981 var resp = convert.JSON.encode(buildCommunityMessage());

2982 return new async.Future.value(common_test.stringResponse(200, h, resp));

2983 }), true);

2984 res.insert(arg_request, arg_communityId, arg_topicId).then(unittest.expect Async(((api.CommunityMessage response) {

2985 checkCommunityMessage(response);

2986 })));

2987 });

2988

2989 unittest.test("method--list", () {

2990

2991 var mock = new common_test.HttpServerMock();

2992 api.CommunityMessagesResourceApi res = new api.OrkutApi(mock).communityMes sages;

2993 var arg_communityId = 42;

2994 var arg_topicId = "foo";

2995 var arg_hl = "foo";

2996 var arg_maxResults = 42;

2997 var arg_pageToken = "foo";

2998 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2999 var path = (req.url).path;

3000 var pathOffset = 0;

3001 var index;

3002 var subPart;

3003 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3004 pathOffset += 10;

3005 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3006 pathOffset += 12;

3007 index = path.indexOf("/topics/", pathOffset);

3008 unittest.expect(index >= 0, unittest.isTrue);

3009 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3010 pathOffset = index;

3011 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3012 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/topics/"));

3013 pathOffset += 8;

3014 index = path.indexOf("/messages", pathOffset);

3015 unittest.expect(index >= 0, unittest.isTrue);

3016 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3017 pathOffset = index;

3018 unittest.expect(subPart, unittest.equals("$arg_topicId"));

3019 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/messages"));

3020 pathOffset += 9;

3021

3022 var query = (req.url).query;

3023 var queryOffset = 0;

3024 var queryMap = {};

3025 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3026 parseBool(n) {

3027 if (n == "true") return true;

3028 if (n == "false") return false;

3029 if (n == null) return null;

3030 throw new core.ArgumentError("Invalid boolean: $n");

3031 }

3032 if (query.length > 0) {

3033 for (var part in query.split("&")) {

3034 var keyvalue = part.split("=");

3035 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3036 }

3037 }

3038 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

3039 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3040 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3041

3042

3043 var h = {

3044 "content-type" : "application/json; charset=utf-8",

3045 };

3046 var resp = convert.JSON.encode(buildCommunityMessageList());

3047 return new async.Future.value(common_test.stringResponse(200, h, resp));

3048 }), true);

3049 res.list(arg_communityId, arg_topicId, hl: arg_hl, maxResults: arg_maxResu lts, pageToken: arg_pageToken).then(unittest.expectAsync(((api.CommunityMessageL ist response) {

3050 checkCommunityMessageList(response);

3051 })));

3052 });

3053

3054 });

3055

3056

3057 unittest.group("resource-CommunityPollCommentsResourceApi", () {

3058 unittest.test("method--insert", () {

3059

3060 var mock = new common_test.HttpServerMock();

3061 api.CommunityPollCommentsResourceApi res = new api.OrkutApi(mock).communit yPollComments;

3062 var arg_request = buildCommunityPollComment();

3063 var arg_communityId = 42;

3064 var arg_pollId = "foo";

3065 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3066 var obj = new api.CommunityPollComment.fromJson(json);

3067 checkCommunityPollComment(obj);

3068

3069 var path = (req.url).path;

3070 var pathOffset = 0;

3071 var index;

3072 var subPart;

3073 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3074 pathOffset += 10;

3075 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3076 pathOffset += 12;

3077 index = path.indexOf("/polls/", pathOffset);

3078 unittest.expect(index >= 0, unittest.isTrue);

3079 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3080 pathOffset = index;

3081 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3082 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/polls/"));

3083 pathOffset += 7;

3084 index = path.indexOf("/comments", pathOffset);

3085 unittest.expect(index >= 0, unittest.isTrue);

3086 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3087 pathOffset = index;

3088 unittest.expect(subPart, unittest.equals("$arg_pollId"));

3089 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/comments"));

3090 pathOffset += 9;

3091

3092 var query = (req.url).query;

3093 var queryOffset = 0;

3094 var queryMap = {};

3095 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3096 parseBool(n) {

3097 if (n == "true") return true;

3098 if (n == "false") return false;

3099 if (n == null) return null;

3100 throw new core.ArgumentError("Invalid boolean: $n");

3101 }

3102 if (query.length > 0) {

3103 for (var part in query.split("&")) {

3104 var keyvalue = part.split("=");

3105 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3106 }

3107 }

3108

3109

3110 var h = {

3111 "content-type" : "application/json; charset=utf-8",

3112 };

3113 var resp = convert.JSON.encode(buildCommunityPollComment());

3114 return new async.Future.value(common_test.stringResponse(200, h, resp));

3115 }), true);

3116 res.insert(arg_request, arg_communityId, arg_pollId).then(unittest.expectA sync(((api.CommunityPollComment response) {

3117 checkCommunityPollComment(response);

3118 })));

3119 });

3120

3121 unittest.test("method--list", () {

3122

3123 var mock = new common_test.HttpServerMock();

3124 api.CommunityPollCommentsResourceApi res = new api.OrkutApi(mock).communit yPollComments;

3125 var arg_communityId = 42;

3126 var arg_pollId = "foo";

3127 var arg_hl = "foo";

3128 var arg_maxResults = 42;

3129 var arg_pageToken = "foo";

3130 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3131 var path = (req.url).path;

3132 var pathOffset = 0;

3133 var index;

3134 var subPart;

3135 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3136 pathOffset += 10;

3137 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3138 pathOffset += 12;

3139 index = path.indexOf("/polls/", pathOffset);

3140 unittest.expect(index >= 0, unittest.isTrue);

3141 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3142 pathOffset = index;

3143 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3144 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/polls/"));

3145 pathOffset += 7;

3146 index = path.indexOf("/comments", pathOffset);

3147 unittest.expect(index >= 0, unittest.isTrue);

3148 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3149 pathOffset = index;

3150 unittest.expect(subPart, unittest.equals("$arg_pollId"));

3151 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/comments"));

3152 pathOffset += 9;

3153

3154 var query = (req.url).query;

3155 var queryOffset = 0;

3156 var queryMap = {};

3157 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3158 parseBool(n) {

3159 if (n == "true") return true;

3160 if (n == "false") return false;

3161 if (n == null) return null;

3162 throw new core.ArgumentError("Invalid boolean: $n");

3163 }

3164 if (query.length > 0) {

3165 for (var part in query.split("&")) {

3166 var keyvalue = part.split("=");

3167 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3168 }

3169 }

3170 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

3171 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3172 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3173

3174

3175 var h = {

3176 "content-type" : "application/json; charset=utf-8",

3177 };

3178 var resp = convert.JSON.encode(buildCommunityPollCommentList());

3179 return new async.Future.value(common_test.stringResponse(200, h, resp));

3180 }), true);

3181 res.list(arg_communityId, arg_pollId, hl: arg_hl, maxResults: arg_maxResul ts, pageToken: arg_pageToken).then(unittest.expectAsync(((api.CommunityPollComme ntList response) {

3182 checkCommunityPollCommentList(response);

3183 })));

3184 });

3185

3186 });

3187

3188

3189 unittest.group("resource-CommunityPollVotesResourceApi", () {

3190 unittest.test("method--insert", () {

3191

3192 var mock = new common_test.HttpServerMock();

3193 api.CommunityPollVotesResourceApi res = new api.OrkutApi(mock).communityPo llVotes;

3194 var arg_request = buildCommunityPollVote();

3195 var arg_communityId = 42;

3196 var arg_pollId = "foo";

3197 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3198 var obj = new api.CommunityPollVote.fromJson(json);

3199 checkCommunityPollVote(obj);

3200

3201 var path = (req.url).path;

3202 var pathOffset = 0;

3203 var index;

3204 var subPart;

3205 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3206 pathOffset += 10;

3207 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3208 pathOffset += 12;

3209 index = path.indexOf("/polls/", pathOffset);

3210 unittest.expect(index >= 0, unittest.isTrue);

3211 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3212 pathOffset = index;

3213 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3214 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/polls/"));

3215 pathOffset += 7;

3216 index = path.indexOf("/votes", pathOffset);

3217 unittest.expect(index >= 0, unittest.isTrue);

3218 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3219 pathOffset = index;

3220 unittest.expect(subPart, unittest.equals("$arg_pollId"));

3221 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/votes"));

3222 pathOffset += 6;

3223

3224 var query = (req.url).query;

3225 var queryOffset = 0;

3226 var queryMap = {};

3227 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3228 parseBool(n) {

3229 if (n == "true") return true;

3230 if (n == "false") return false;

3231 if (n == null) return null;

3232 throw new core.ArgumentError("Invalid boolean: $n");

3233 }

3234 if (query.length > 0) {

3235 for (var part in query.split("&")) {

3236 var keyvalue = part.split("=");

3237 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3238 }

3239 }

3240

3241

3242 var h = {

3243 "content-type" : "application/json; charset=utf-8",

3244 };

3245 var resp = convert.JSON.encode(buildCommunityPollVote());

3246 return new async.Future.value(common_test.stringResponse(200, h, resp));

3247 }), true);

3248 res.insert(arg_request, arg_communityId, arg_pollId).then(unittest.expectA sync(((api.CommunityPollVote response) {

3249 checkCommunityPollVote(response);

3250 })));

3251 });

3252

3253 });

3254

3255

3256 unittest.group("resource-CommunityPollsResourceApi", () {

3257 unittest.test("method--get", () {

3258

3259 var mock = new common_test.HttpServerMock();

3260 api.CommunityPollsResourceApi res = new api.OrkutApi(mock).communityPolls;

3261 var arg_communityId = 42;

3262 var arg_pollId = "foo";

3263 var arg_hl = "foo";

3264 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3265 var path = (req.url).path;

3266 var pathOffset = 0;

3267 var index;

3268 var subPart;

3269 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3270 pathOffset += 10;

3271 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3272 pathOffset += 12;

3273 index = path.indexOf("/polls/", pathOffset);

3274 unittest.expect(index >= 0, unittest.isTrue);

3275 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3276 pathOffset = index;

3277 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3278 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/polls/"));

3279 pathOffset += 7;

3280 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3281 pathOffset = path.length;

3282 unittest.expect(subPart, unittest.equals("$arg_pollId"));

3283

3284 var query = (req.url).query;

3285 var queryOffset = 0;

3286 var queryMap = {};

3287 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3288 parseBool(n) {

3289 if (n == "true") return true;

3290 if (n == "false") return false;

3291 if (n == null) return null;

3292 throw new core.ArgumentError("Invalid boolean: $n");

3293 }

3294 if (query.length > 0) {

3295 for (var part in query.split("&")) {

3296 var keyvalue = part.split("=");

3297 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3298 }

3299 }

3300 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

3301

3302

3303 var h = {

3304 "content-type" : "application/json; charset=utf-8",

3305 };

3306 var resp = convert.JSON.encode(buildCommunityPoll());

3307 return new async.Future.value(common_test.stringResponse(200, h, resp));

3308 }), true);

3309 res.get(arg_communityId, arg_pollId, hl: arg_hl).then(unittest.expectAsync (((api.CommunityPoll response) {

3310 checkCommunityPoll(response);

3311 })));

3312 });

3313

3314 unittest.test("method--list", () {

3315

3316 var mock = new common_test.HttpServerMock();

3317 api.CommunityPollsResourceApi res = new api.OrkutApi(mock).communityPolls;

3318 var arg_communityId = 42;

3319 var arg_hl = "foo";

3320 var arg_maxResults = 42;

3321 var arg_pageToken = "foo";

3322 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3323 var path = (req.url).path;

3324 var pathOffset = 0;

3325 var index;

3326 var subPart;

3327 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3328 pathOffset += 10;

3329 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3330 pathOffset += 12;

3331 index = path.indexOf("/polls", pathOffset);

3332 unittest.expect(index >= 0, unittest.isTrue);

3333 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3334 pathOffset = index;

3335 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3336 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/polls"));

3337 pathOffset += 6;

3338

3339 var query = (req.url).query;

3340 var queryOffset = 0;

3341 var queryMap = {};

3342 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3343 parseBool(n) {

3344 if (n == "true") return true;

3345 if (n == "false") return false;

3346 if (n == null) return null;

3347 throw new core.ArgumentError("Invalid boolean: $n");

3348 }

3349 if (query.length > 0) {

3350 for (var part in query.split("&")) {

3351 var keyvalue = part.split("=");

3352 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3353 }

3354 }

3355 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

3356 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3357 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3358

3359

3360 var h = {

3361 "content-type" : "application/json; charset=utf-8",

3362 };

3363 var resp = convert.JSON.encode(buildCommunityPollList());

3364 return new async.Future.value(common_test.stringResponse(200, h, resp));

3365 }), true);

3366 res.list(arg_communityId, hl: arg_hl, maxResults: arg_maxResults, pageToke n: arg_pageToken).then(unittest.expectAsync(((api.CommunityPollList response) {

3367 checkCommunityPollList(response);

3368 })));

3369 });

3370

3371 });

3372

3373

3374 unittest.group("resource-CommunityRelatedResourceApi", () {

3375 unittest.test("method--list", () {

3376

3377 var mock = new common_test.HttpServerMock();

3378 api.CommunityRelatedResourceApi res = new api.OrkutApi(mock).communityRela ted;

3379 var arg_communityId = 42;

3380 var arg_hl = "foo";

3381 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3382 var path = (req.url).path;

3383 var pathOffset = 0;

3384 var index;

3385 var subPart;

3386 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3387 pathOffset += 10;

3388 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3389 pathOffset += 12;

3390 index = path.indexOf("/related", pathOffset);

3391 unittest.expect(index >= 0, unittest.isTrue);

3392 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3393 pathOffset = index;

3394 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3395 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/related"));

3396 pathOffset += 8;

3397

3398 var query = (req.url).query;

3399 var queryOffset = 0;

3400 var queryMap = {};

3401 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3402 parseBool(n) {

3403 if (n == "true") return true;

3404 if (n == "false") return false;

3405 if (n == null) return null;

3406 throw new core.ArgumentError("Invalid boolean: $n");

3407 }

3408 if (query.length > 0) {

3409 for (var part in query.split("&")) {

3410 var keyvalue = part.split("=");

3411 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3412 }

3413 }

3414 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

3415

3416

3417 var h = {

3418 "content-type" : "application/json; charset=utf-8",

3419 };

3420 var resp = convert.JSON.encode(buildCommunityList());

3421 return new async.Future.value(common_test.stringResponse(200, h, resp));

3422 }), true);

3423 res.list(arg_communityId, hl: arg_hl).then(unittest.expectAsync(((api.Comm unityList response) {

3424 checkCommunityList(response);

3425 })));

3426 });

3427

3428 });

3429

3430

3431 unittest.group("resource-CommunityTopicsResourceApi", () {

3432 unittest.test("method--delete", () {

3433

3434 var mock = new common_test.HttpServerMock();

3435 api.CommunityTopicsResourceApi res = new api.OrkutApi(mock).communityTopic s;

3436 var arg_communityId = 42;

3437 var arg_topicId = "foo";

3438 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3439 var path = (req.url).path;

3440 var pathOffset = 0;

3441 var index;

3442 var subPart;

3443 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3444 pathOffset += 10;

3445 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3446 pathOffset += 12;

3447 index = path.indexOf("/topics/", pathOffset);

3448 unittest.expect(index >= 0, unittest.isTrue);

3449 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3450 pathOffset = index;

3451 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3452 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/topics/"));

3453 pathOffset += 8;

3454 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3455 pathOffset = path.length;

3456 unittest.expect(subPart, unittest.equals("$arg_topicId"));

3457

3458 var query = (req.url).query;

3459 var queryOffset = 0;

3460 var queryMap = {};

3461 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3462 parseBool(n) {

3463 if (n == "true") return true;

3464 if (n == "false") return false;

3465 if (n == null) return null;

3466 throw new core.ArgumentError("Invalid boolean: $n");

3467 }

3468 if (query.length > 0) {

3469 for (var part in query.split("&")) {

3470 var keyvalue = part.split("=");

3471 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3472 }

3473 }

3474

3475

3476 var h = {

3477 "content-type" : "application/json; charset=utf-8",

3478 };

3479 var resp = "";

3480 return new async.Future.value(common_test.stringResponse(200, h, resp));

3481 }), true);

3482 res.delete(arg_communityId, arg_topicId).then(unittest.expectAsync((_) {}) );

3483 });

3484

3485 unittest.test("method--get", () {

3486

3487 var mock = new common_test.HttpServerMock();

3488 api.CommunityTopicsResourceApi res = new api.OrkutApi(mock).communityTopic s;

3489 var arg_communityId = 42;

3490 var arg_topicId = "foo";

3491 var arg_hl = "foo";

3492 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3493 var path = (req.url).path;

3494 var pathOffset = 0;

3495 var index;

3496 var subPart;

3497 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3498 pathOffset += 10;

3499 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3500 pathOffset += 12;

3501 index = path.indexOf("/topics/", pathOffset);

3502 unittest.expect(index >= 0, unittest.isTrue);

3503 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3504 pathOffset = index;

3505 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3506 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/topics/"));

3507 pathOffset += 8;

3508 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3509 pathOffset = path.length;

3510 unittest.expect(subPart, unittest.equals("$arg_topicId"));

3511

3512 var query = (req.url).query;

3513 var queryOffset = 0;

3514 var queryMap = {};

3515 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3516 parseBool(n) {

3517 if (n == "true") return true;

3518 if (n == "false") return false;

3519 if (n == null) return null;

3520 throw new core.ArgumentError("Invalid boolean: $n");

3521 }

3522 if (query.length > 0) {

3523 for (var part in query.split("&")) {

3524 var keyvalue = part.split("=");

3525 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3526 }

3527 }

3528 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

3529

3530

3531 var h = {

3532 "content-type" : "application/json; charset=utf-8",

3533 };

3534 var resp = convert.JSON.encode(buildCommunityTopic());

3535 return new async.Future.value(common_test.stringResponse(200, h, resp));

3536 }), true);

3537 res.get(arg_communityId, arg_topicId, hl: arg_hl).then(unittest.expectAsyn c(((api.CommunityTopic response) {

3538 checkCommunityTopic(response);

3539 })));

3540 });

3541

3542 unittest.test("method--insert", () {

3543

3544 var mock = new common_test.HttpServerMock();

3545 api.CommunityTopicsResourceApi res = new api.OrkutApi(mock).communityTopic s;

3546 var arg_request = buildCommunityTopic();

3547 var arg_communityId = 42;

3548 var arg_isShout = true;

3549 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3550 var obj = new api.CommunityTopic.fromJson(json);

3551 checkCommunityTopic(obj);

3552

3553 var path = (req.url).path;

3554 var pathOffset = 0;

3555 var index;

3556 var subPart;

3557 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3558 pathOffset += 10;

3559 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3560 pathOffset += 12;

3561 index = path.indexOf("/topics", pathOffset);

3562 unittest.expect(index >= 0, unittest.isTrue);

3563 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3564 pathOffset = index;

3565 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3566 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/topics"));

3567 pathOffset += 7;

3568

3569 var query = (req.url).query;

3570 var queryOffset = 0;

3571 var queryMap = {};

3572 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3573 parseBool(n) {

3574 if (n == "true") return true;

3575 if (n == "false") return false;

3576 if (n == null) return null;

3577 throw new core.ArgumentError("Invalid boolean: $n");

3578 }

3579 if (query.length > 0) {

3580 for (var part in query.split("&")) {

3581 var keyvalue = part.split("=");

3582 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3583 }

3584 }

3585 unittest.expect(queryMap["isShout"].first, unittest.equals("$arg_isShout "));

3586

3587

3588 var h = {

3589 "content-type" : "application/json; charset=utf-8",

3590 };

3591 var resp = convert.JSON.encode(buildCommunityTopic());

3592 return new async.Future.value(common_test.stringResponse(200, h, resp));

3593 }), true);

3594 res.insert(arg_request, arg_communityId, isShout: arg_isShout).then(unitte st.expectAsync(((api.CommunityTopic response) {

3595 checkCommunityTopic(response);

3596 })));

3597 });

3598

3599 unittest.test("method--list", () {

3600

3601 var mock = new common_test.HttpServerMock();

3602 api.CommunityTopicsResourceApi res = new api.OrkutApi(mock).communityTopic s;

3603 var arg_communityId = 42;

3604 var arg_hl = "foo";

3605 var arg_maxResults = 42;

3606 var arg_pageToken = "foo";

3607 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3608 var path = (req.url).path;

3609 var pathOffset = 0;

3610 var index;

3611 var subPart;

3612 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3613 pathOffset += 10;

3614 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("communities/"));

3615 pathOffset += 12;

3616 index = path.indexOf("/topics", pathOffset);

3617 unittest.expect(index >= 0, unittest.isTrue);

3618 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3619 pathOffset = index;

3620 unittest.expect(subPart, unittest.equals("$arg_communityId"));

3621 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/topics"));

3622 pathOffset += 7;

3623

3624 var query = (req.url).query;

3625 var queryOffset = 0;

3626 var queryMap = {};

3627 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3628 parseBool(n) {

3629 if (n == "true") return true;

3630 if (n == "false") return false;

3631 if (n == null) return null;

3632 throw new core.ArgumentError("Invalid boolean: $n");

3633 }

3634 if (query.length > 0) {

3635 for (var part in query.split("&")) {

3636 var keyvalue = part.split("=");

3637 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3638 }

3639 }

3640 unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));

3641 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3642 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3643

3644

3645 var h = {

3646 "content-type" : "application/json; charset=utf-8",

3647 };

3648 var resp = convert.JSON.encode(buildCommunityTopicList());

3649 return new async.Future.value(common_test.stringResponse(200, h, resp));

3650 }), true);

3651 res.list(arg_communityId, hl: arg_hl, maxResults: arg_maxResults, pageToke n: arg_pageToken).then(unittest.expectAsync(((api.CommunityTopicList response) {

3652 checkCommunityTopicList(response);

3653 })));

3654 });

3655

3656 });

3657

3658

3659 unittest.group("resource-CountersResourceApi", () {

3660 unittest.test("method--list", () {

3661

3662 var mock = new common_test.HttpServerMock();

3663 api.CountersResourceApi res = new api.OrkutApi(mock).counters;

3664 var arg_userId = "foo";

3665 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3666 var path = (req.url).path;

3667 var pathOffset = 0;

3668 var index;

3669 var subPart;

3670 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3671 pathOffset += 10;

3672 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("people/"));

3673 pathOffset += 7;

3674 index = path.indexOf("/counters", pathOffset);

3675 unittest.expect(index >= 0, unittest.isTrue);

3676 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3677 pathOffset = index;

3678 unittest.expect(subPart, unittest.equals("$arg_userId"));

3679 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/counters"));

3680 pathOffset += 9;

3681

3682 var query = (req.url).query;

3683 var queryOffset = 0;

3684 var queryMap = {};

3685 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3686 parseBool(n) {

3687 if (n == "true") return true;

3688 if (n == "false") return false;

3689 if (n == null) return null;

3690 throw new core.ArgumentError("Invalid boolean: $n");

3691 }

3692 if (query.length > 0) {

3693 for (var part in query.split("&")) {

3694 var keyvalue = part.split("=");

3695 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3696 }

3697 }

3698

3699

3700 var h = {

3701 "content-type" : "application/json; charset=utf-8",

3702 };

3703 var resp = convert.JSON.encode(buildCounters());

3704 return new async.Future.value(common_test.stringResponse(200, h, resp));

3705 }), true);

3706 res.list(arg_userId).then(unittest.expectAsync(((api.Counters response) {

3707 checkCounters(response);

3708 })));

3709 });

3710

3711 });

3712

3713

3714 unittest.group("resource-ScrapsResourceApi", () {

3715 unittest.test("method--insert", () {

3716

3717 var mock = new common_test.HttpServerMock();

3718 api.ScrapsResourceApi res = new api.OrkutApi(mock).scraps;

3719 var arg_request = buildActivity();

3720 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3721 var obj = new api.Activity.fromJson(json);

3722 checkActivity(obj);

3723

3724 var path = (req.url).path;

3725 var pathOffset = 0;

3726 var index;

3727 var subPart;

3728 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/orkut/v2/"));

3729 pathOffset += 10;

3730 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("activities/scraps"));

3731 pathOffset += 17;

3732

3733 var query = (req.url).query;

3734 var queryOffset = 0;

3735 var queryMap = {};

3736 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3737 parseBool(n) {

3738 if (n == "true") return true;

3739 if (n == "false") return false;

3740 if (n == null) return null;

3741 throw new core.ArgumentError("Invalid boolean: $n");

3742 }

3743 if (query.length > 0) {

3744 for (var part in query.split("&")) {

3745 var keyvalue = part.split("=");

3746 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3747 }

3748 }

3749

3750

3751 var h = {

3752 "content-type" : "application/json; charset=utf-8",

3753 };

3754 var resp = convert.JSON.encode(buildActivity());

3755 return new async.Future.value(common_test.stringResponse(200, h, resp));

3756 }), true);

3757 res.insert(arg_request).then(unittest.expectAsync(((api.Activity response) {

3758 checkActivity(response);

3759 })));

3760 });

3761

3762 });

3763

3764

3765 }

3766

OLD	NEW

« no previous file with comments | « generated/googleapis/test/oauth2/v2_test.dart ('k') | generated/googleapis/test/orkut/v2_test.dart » ('j') | no next file with comments »