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

Side by Side Diff: generated/googleapis/test/games/v1.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.games.v1.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/games/v1.dart' as api;

16

17

18

19 core.int buildCounterAchievementDefinition = 0;

20 buildAchievementDefinition() {

21 var o = new api.AchievementDefinition();

22 buildCounterAchievementDefinition++;

23 if (buildCounterAchievementDefinition < 3) {

24 o.achievementType = "foo";

25 o.description = "foo";

26 o.experiencePoints = "foo";

27 o.formattedTotalSteps = "foo";

28 o.id = "foo";

29 o.initialState = "foo";

30 o.isRevealedIconUrlDefault = true;

31 o.isUnlockedIconUrlDefault = true;

32 o.kind = "foo";

33 o.name = "foo";

34 o.revealedIconUrl = "foo";

35 o.totalSteps = 42;

36 o.unlockedIconUrl = "foo";

37 }

38 buildCounterAchievementDefinition--;

39 return o;

40 }

41

42 checkAchievementDefinition(api.AchievementDefinition o) {

43 buildCounterAchievementDefinition++;

44 if (buildCounterAchievementDefinition < 3) {

45 unittest.expect(o.achievementType, unittest.equals('foo'));

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

47 unittest.expect(o.experiencePoints, unittest.equals('foo'));

48 unittest.expect(o.formattedTotalSteps, unittest.equals('foo'));

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

50 unittest.expect(o.initialState, unittest.equals('foo'));

51 unittest.expect(o.isRevealedIconUrlDefault, unittest.isTrue);

52 unittest.expect(o.isUnlockedIconUrlDefault, unittest.isTrue);

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

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

55 unittest.expect(o.revealedIconUrl, unittest.equals('foo'));

56 unittest.expect(o.totalSteps, unittest.equals(42));

57 unittest.expect(o.unlockedIconUrl, unittest.equals('foo'));

58 }

59 buildCounterAchievementDefinition--;

60 }

61

62 buildUnnamed20() {

63 var o = new core.List<api.AchievementDefinition>();

64 o.add(buildAchievementDefinition());

65 o.add(buildAchievementDefinition());

66 return o;

67 }

68

69 checkUnnamed20(core.List<api.AchievementDefinition> o) {

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

71 checkAchievementDefinition(o[0]);

72 checkAchievementDefinition(o[1]);

73 }

74

75 core.int buildCounterAchievementDefinitionsListResponse = 0;

76 buildAchievementDefinitionsListResponse() {

77 var o = new api.AchievementDefinitionsListResponse();

78 buildCounterAchievementDefinitionsListResponse++;

79 if (buildCounterAchievementDefinitionsListResponse < 3) {

80 o.items = buildUnnamed20();

81 o.kind = "foo";

82 o.nextPageToken = "foo";

83 }

84 buildCounterAchievementDefinitionsListResponse--;

85 return o;

86 }

87

88 checkAchievementDefinitionsListResponse(api.AchievementDefinitionsListResponse o ) {

89 buildCounterAchievementDefinitionsListResponse++;

90 if (buildCounterAchievementDefinitionsListResponse < 3) {

91 checkUnnamed20(o.items);

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

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

94 }

95 buildCounterAchievementDefinitionsListResponse--;

96 }

97

98 core.int buildCounterAchievementIncrementResponse = 0;

99 buildAchievementIncrementResponse() {

100 var o = new api.AchievementIncrementResponse();

101 buildCounterAchievementIncrementResponse++;

102 if (buildCounterAchievementIncrementResponse < 3) {

103 o.currentSteps = 42;

104 o.kind = "foo";

105 o.newlyUnlocked = true;

106 }

107 buildCounterAchievementIncrementResponse--;

108 return o;

109 }

110

111 checkAchievementIncrementResponse(api.AchievementIncrementResponse o) {

112 buildCounterAchievementIncrementResponse++;

113 if (buildCounterAchievementIncrementResponse < 3) {

114 unittest.expect(o.currentSteps, unittest.equals(42));

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

116 unittest.expect(o.newlyUnlocked, unittest.isTrue);

117 }

118 buildCounterAchievementIncrementResponse--;

119 }

120

121 core.int buildCounterAchievementRevealResponse = 0;

122 buildAchievementRevealResponse() {

123 var o = new api.AchievementRevealResponse();

124 buildCounterAchievementRevealResponse++;

125 if (buildCounterAchievementRevealResponse < 3) {

126 o.currentState = "foo";

127 o.kind = "foo";

128 }

129 buildCounterAchievementRevealResponse--;

130 return o;

131 }

132

133 checkAchievementRevealResponse(api.AchievementRevealResponse o) {

134 buildCounterAchievementRevealResponse++;

135 if (buildCounterAchievementRevealResponse < 3) {

136 unittest.expect(o.currentState, unittest.equals('foo'));

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

138 }

139 buildCounterAchievementRevealResponse--;

140 }

141

142 core.int buildCounterAchievementSetStepsAtLeastResponse = 0;

143 buildAchievementSetStepsAtLeastResponse() {

144 var o = new api.AchievementSetStepsAtLeastResponse();

145 buildCounterAchievementSetStepsAtLeastResponse++;

146 if (buildCounterAchievementSetStepsAtLeastResponse < 3) {

147 o.currentSteps = 42;

148 o.kind = "foo";

149 o.newlyUnlocked = true;

150 }

151 buildCounterAchievementSetStepsAtLeastResponse--;

152 return o;

153 }

154

155 checkAchievementSetStepsAtLeastResponse(api.AchievementSetStepsAtLeastResponse o ) {

156 buildCounterAchievementSetStepsAtLeastResponse++;

157 if (buildCounterAchievementSetStepsAtLeastResponse < 3) {

158 unittest.expect(o.currentSteps, unittest.equals(42));

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

160 unittest.expect(o.newlyUnlocked, unittest.isTrue);

161 }

162 buildCounterAchievementSetStepsAtLeastResponse--;

163 }

164

165 core.int buildCounterAchievementUnlockResponse = 0;

166 buildAchievementUnlockResponse() {

167 var o = new api.AchievementUnlockResponse();

168 buildCounterAchievementUnlockResponse++;

169 if (buildCounterAchievementUnlockResponse < 3) {

170 o.kind = "foo";

171 o.newlyUnlocked = true;

172 }

173 buildCounterAchievementUnlockResponse--;

174 return o;

175 }

176

177 checkAchievementUnlockResponse(api.AchievementUnlockResponse o) {

178 buildCounterAchievementUnlockResponse++;

179 if (buildCounterAchievementUnlockResponse < 3) {

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

181 unittest.expect(o.newlyUnlocked, unittest.isTrue);

182 }

183 buildCounterAchievementUnlockResponse--;

184 }

185

186 buildUnnamed21() {

187 var o = new core.List<api.AchievementUpdateRequest>();

188 o.add(buildAchievementUpdateRequest());

189 o.add(buildAchievementUpdateRequest());

190 return o;

191 }

192

193 checkUnnamed21(core.List<api.AchievementUpdateRequest> o) {

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

195 checkAchievementUpdateRequest(o[0]);

196 checkAchievementUpdateRequest(o[1]);

197 }

198

199 core.int buildCounterAchievementUpdateMultipleRequest = 0;

200 buildAchievementUpdateMultipleRequest() {

201 var o = new api.AchievementUpdateMultipleRequest();

202 buildCounterAchievementUpdateMultipleRequest++;

203 if (buildCounterAchievementUpdateMultipleRequest < 3) {

204 o.kind = "foo";

205 o.updates = buildUnnamed21();

206 }

207 buildCounterAchievementUpdateMultipleRequest--;

208 return o;

209 }

210

211 checkAchievementUpdateMultipleRequest(api.AchievementUpdateMultipleRequest o) {

212 buildCounterAchievementUpdateMultipleRequest++;

213 if (buildCounterAchievementUpdateMultipleRequest < 3) {

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

215 checkUnnamed21(o.updates);

216 }

217 buildCounterAchievementUpdateMultipleRequest--;

218 }

219

220 buildUnnamed22() {

221 var o = new core.List<api.AchievementUpdateResponse>();

222 o.add(buildAchievementUpdateResponse());

223 o.add(buildAchievementUpdateResponse());

224 return o;

225 }

226

227 checkUnnamed22(core.List<api.AchievementUpdateResponse> o) {

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

229 checkAchievementUpdateResponse(o[0]);

230 checkAchievementUpdateResponse(o[1]);

231 }

232

233 core.int buildCounterAchievementUpdateMultipleResponse = 0;

234 buildAchievementUpdateMultipleResponse() {

235 var o = new api.AchievementUpdateMultipleResponse();

236 buildCounterAchievementUpdateMultipleResponse++;

237 if (buildCounterAchievementUpdateMultipleResponse < 3) {

238 o.kind = "foo";

239 o.updatedAchievements = buildUnnamed22();

240 }

241 buildCounterAchievementUpdateMultipleResponse--;

242 return o;

243 }

244

245 checkAchievementUpdateMultipleResponse(api.AchievementUpdateMultipleResponse o) {

246 buildCounterAchievementUpdateMultipleResponse++;

247 if (buildCounterAchievementUpdateMultipleResponse < 3) {

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

249 checkUnnamed22(o.updatedAchievements);

250 }

251 buildCounterAchievementUpdateMultipleResponse--;

252 }

253

254 core.int buildCounterAchievementUpdateRequest = 0;

255 buildAchievementUpdateRequest() {

256 var o = new api.AchievementUpdateRequest();

257 buildCounterAchievementUpdateRequest++;

258 if (buildCounterAchievementUpdateRequest < 3) {

259 o.achievementId = "foo";

260 o.incrementPayload = buildGamesAchievementIncrement();

261 o.kind = "foo";

262 o.setStepsAtLeastPayload = buildGamesAchievementSetStepsAtLeast();

263 o.updateType = "foo";

264 }

265 buildCounterAchievementUpdateRequest--;

266 return o;

267 }

268

269 checkAchievementUpdateRequest(api.AchievementUpdateRequest o) {

270 buildCounterAchievementUpdateRequest++;

271 if (buildCounterAchievementUpdateRequest < 3) {

272 unittest.expect(o.achievementId, unittest.equals('foo'));

273 checkGamesAchievementIncrement(o.incrementPayload);

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

275 checkGamesAchievementSetStepsAtLeast(o.setStepsAtLeastPayload);

276 unittest.expect(o.updateType, unittest.equals('foo'));

277 }

278 buildCounterAchievementUpdateRequest--;

279 }

280

281 core.int buildCounterAchievementUpdateResponse = 0;

282 buildAchievementUpdateResponse() {

283 var o = new api.AchievementUpdateResponse();

284 buildCounterAchievementUpdateResponse++;

285 if (buildCounterAchievementUpdateResponse < 3) {

286 o.achievementId = "foo";

287 o.currentState = "foo";

288 o.currentSteps = 42;

289 o.kind = "foo";

290 o.newlyUnlocked = true;

291 o.updateOccurred = true;

292 }

293 buildCounterAchievementUpdateResponse--;

294 return o;

295 }

296

297 checkAchievementUpdateResponse(api.AchievementUpdateResponse o) {

298 buildCounterAchievementUpdateResponse++;

299 if (buildCounterAchievementUpdateResponse < 3) {

300 unittest.expect(o.achievementId, unittest.equals('foo'));

301 unittest.expect(o.currentState, unittest.equals('foo'));

302 unittest.expect(o.currentSteps, unittest.equals(42));

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

304 unittest.expect(o.newlyUnlocked, unittest.isTrue);

305 unittest.expect(o.updateOccurred, unittest.isTrue);

306 }

307 buildCounterAchievementUpdateResponse--;

308 }

309

310 core.int buildCounterAggregateStats = 0;

311 buildAggregateStats() {

312 var o = new api.AggregateStats();

313 buildCounterAggregateStats++;

314 if (buildCounterAggregateStats < 3) {

315 o.count = "foo";

316 o.kind = "foo";

317 o.max = "foo";

318 o.min = "foo";

319 o.sum = "foo";

320 }

321 buildCounterAggregateStats--;

322 return o;

323 }

324

325 checkAggregateStats(api.AggregateStats o) {

326 buildCounterAggregateStats++;

327 if (buildCounterAggregateStats < 3) {

328 unittest.expect(o.count, unittest.equals('foo'));

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

330 unittest.expect(o.max, unittest.equals('foo'));

331 unittest.expect(o.min, unittest.equals('foo'));

332 unittest.expect(o.sum, unittest.equals('foo'));

333 }

334 buildCounterAggregateStats--;

335 }

336

337 core.int buildCounterAnonymousPlayer = 0;

338 buildAnonymousPlayer() {

339 var o = new api.AnonymousPlayer();

340 buildCounterAnonymousPlayer++;

341 if (buildCounterAnonymousPlayer < 3) {

342 o.avatarImageUrl = "foo";

343 o.displayName = "foo";

344 o.kind = "foo";

345 }

346 buildCounterAnonymousPlayer--;

347 return o;

348 }

349

350 checkAnonymousPlayer(api.AnonymousPlayer o) {

351 buildCounterAnonymousPlayer++;

352 if (buildCounterAnonymousPlayer < 3) {

353 unittest.expect(o.avatarImageUrl, unittest.equals('foo'));

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

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

356 }

357 buildCounterAnonymousPlayer--;

358 }

359

360 buildUnnamed23() {

361 var o = new core.List<api.ImageAsset>();

362 o.add(buildImageAsset());

363 o.add(buildImageAsset());

364 return o;

365 }

366

367 checkUnnamed23(core.List<api.ImageAsset> o) {

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

369 checkImageAsset(o[0]);

370 checkImageAsset(o[1]);

371 }

372

373 buildUnnamed24() {

374 var o = new core.List<core.String>();

375 o.add("foo");

376 o.add("foo");

377 return o;

378 }

379

380 checkUnnamed24(core.List<core.String> o) {

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

382 unittest.expect(o[0], unittest.equals('foo'));

383 unittest.expect(o[1], unittest.equals('foo'));

384 }

385

386 buildUnnamed25() {

387 var o = new core.List<api.Instance>();

388 o.add(buildInstance());

389 o.add(buildInstance());

390 return o;

391 }

392

393 checkUnnamed25(core.List<api.Instance> o) {

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

395 checkInstance(o[0]);

396 checkInstance(o[1]);

397 }

398

399 core.int buildCounterApplication = 0;

400 buildApplication() {

401 var o = new api.Application();

402 buildCounterApplication++;

403 if (buildCounterApplication < 3) {

404 o.achievementCount = 42;

405 o.assets = buildUnnamed23();

406 o.author = "foo";

407 o.category = buildApplicationCategory();

408 o.description = "foo";

409 o.enabledFeatures = buildUnnamed24();

410 o.id = "foo";

411 o.instances = buildUnnamed25();

412 o.kind = "foo";

413 o.lastUpdatedTimestamp = "foo";

414 o.leaderboardCount = 42;

415 o.name = "foo";

416 }

417 buildCounterApplication--;

418 return o;

419 }

420

421 checkApplication(api.Application o) {

422 buildCounterApplication++;

423 if (buildCounterApplication < 3) {

424 unittest.expect(o.achievementCount, unittest.equals(42));

425 checkUnnamed23(o.assets);

426 unittest.expect(o.author, unittest.equals('foo'));

427 checkApplicationCategory(o.category);

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

429 checkUnnamed24(o.enabledFeatures);

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

431 checkUnnamed25(o.instances);

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

433 unittest.expect(o.lastUpdatedTimestamp, unittest.equals('foo'));

434 unittest.expect(o.leaderboardCount, unittest.equals(42));

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

436 }

437 buildCounterApplication--;

438 }

439

440 core.int buildCounterApplicationCategory = 0;

441 buildApplicationCategory() {

442 var o = new api.ApplicationCategory();

443 buildCounterApplicationCategory++;

444 if (buildCounterApplicationCategory < 3) {

445 o.kind = "foo";

446 o.primary = "foo";

447 o.secondary = "foo";

448 }

449 buildCounterApplicationCategory--;

450 return o;

451 }

452

453 checkApplicationCategory(api.ApplicationCategory o) {

454 buildCounterApplicationCategory++;

455 if (buildCounterApplicationCategory < 3) {

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

457 unittest.expect(o.primary, unittest.equals('foo'));

458 unittest.expect(o.secondary, unittest.equals('foo'));

459 }

460 buildCounterApplicationCategory--;

461 }

462

463 core.int buildCounterCategory = 0;

464 buildCategory() {

465 var o = new api.Category();

466 buildCounterCategory++;

467 if (buildCounterCategory < 3) {

468 o.category = "foo";

469 o.experiencePoints = "foo";

470 o.kind = "foo";

471 }

472 buildCounterCategory--;

473 return o;

474 }

475

476 checkCategory(api.Category o) {

477 buildCounterCategory++;

478 if (buildCounterCategory < 3) {

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

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

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

482 }

483 buildCounterCategory--;

484 }

485

486 buildUnnamed26() {

487 var o = new core.List<api.Category>();

488 o.add(buildCategory());

489 o.add(buildCategory());

490 return o;

491 }

492

493 checkUnnamed26(core.List<api.Category> o) {

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

495 checkCategory(o[0]);

496 checkCategory(o[1]);

497 }

498

499 core.int buildCounterCategoryListResponse = 0;

500 buildCategoryListResponse() {

501 var o = new api.CategoryListResponse();

502 buildCounterCategoryListResponse++;

503 if (buildCounterCategoryListResponse < 3) {

504 o.items = buildUnnamed26();

505 o.kind = "foo";

506 o.nextPageToken = "foo";

507 }

508 buildCounterCategoryListResponse--;

509 return o;

510 }

511

512 checkCategoryListResponse(api.CategoryListResponse o) {

513 buildCounterCategoryListResponse++;

514 if (buildCounterCategoryListResponse < 3) {

515 checkUnnamed26(o.items);

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

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

518 }

519 buildCounterCategoryListResponse--;

520 }

521

522 core.int buildCounterEventBatchRecordFailure = 0;

523 buildEventBatchRecordFailure() {

524 var o = new api.EventBatchRecordFailure();

525 buildCounterEventBatchRecordFailure++;

526 if (buildCounterEventBatchRecordFailure < 3) {

527 o.failureCause = "foo";

528 o.kind = "foo";

529 o.range = buildEventPeriodRange();

530 }

531 buildCounterEventBatchRecordFailure--;

532 return o;

533 }

534

535 checkEventBatchRecordFailure(api.EventBatchRecordFailure o) {

536 buildCounterEventBatchRecordFailure++;

537 if (buildCounterEventBatchRecordFailure < 3) {

538 unittest.expect(o.failureCause, unittest.equals('foo'));

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

540 checkEventPeriodRange(o.range);

541 }

542 buildCounterEventBatchRecordFailure--;

543 }

544

545 core.int buildCounterEventChild = 0;

546 buildEventChild() {

547 var o = new api.EventChild();

548 buildCounterEventChild++;

549 if (buildCounterEventChild < 3) {

550 o.childId = "foo";

551 o.kind = "foo";

552 }

553 buildCounterEventChild--;

554 return o;

555 }

556

557 checkEventChild(api.EventChild o) {

558 buildCounterEventChild++;

559 if (buildCounterEventChild < 3) {

560 unittest.expect(o.childId, unittest.equals('foo'));

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

562 }

563 buildCounterEventChild--;

564 }

565

566 buildUnnamed27() {

567 var o = new core.List<api.EventChild>();

568 o.add(buildEventChild());

569 o.add(buildEventChild());

570 return o;

571 }

572

573 checkUnnamed27(core.List<api.EventChild> o) {

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

575 checkEventChild(o[0]);

576 checkEventChild(o[1]);

577 }

578

579 core.int buildCounterEventDefinition = 0;

580 buildEventDefinition() {

581 var o = new api.EventDefinition();

582 buildCounterEventDefinition++;

583 if (buildCounterEventDefinition < 3) {

584 o.childEvents = buildUnnamed27();

585 o.description = "foo";

586 o.displayName = "foo";

587 o.id = "foo";

588 o.imageUrl = "foo";

589 o.isDefaultImageUrl = true;

590 o.kind = "foo";

591 o.visibility = "foo";

592 }

593 buildCounterEventDefinition--;

594 return o;

595 }

596

597 checkEventDefinition(api.EventDefinition o) {

598 buildCounterEventDefinition++;

599 if (buildCounterEventDefinition < 3) {

600 checkUnnamed27(o.childEvents);

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

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

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

604 unittest.expect(o.imageUrl, unittest.equals('foo'));

605 unittest.expect(o.isDefaultImageUrl, unittest.isTrue);

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

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

608 }

609 buildCounterEventDefinition--;

610 }

611

612 buildUnnamed28() {

613 var o = new core.List<api.EventDefinition>();

614 o.add(buildEventDefinition());

615 o.add(buildEventDefinition());

616 return o;

617 }

618

619 checkUnnamed28(core.List<api.EventDefinition> o) {

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

621 checkEventDefinition(o[0]);

622 checkEventDefinition(o[1]);

623 }

624

625 core.int buildCounterEventDefinitionListResponse = 0;

626 buildEventDefinitionListResponse() {

627 var o = new api.EventDefinitionListResponse();

628 buildCounterEventDefinitionListResponse++;

629 if (buildCounterEventDefinitionListResponse < 3) {

630 o.items = buildUnnamed28();

631 o.kind = "foo";

632 o.nextPageToken = "foo";

633 }

634 buildCounterEventDefinitionListResponse--;

635 return o;

636 }

637

638 checkEventDefinitionListResponse(api.EventDefinitionListResponse o) {

639 buildCounterEventDefinitionListResponse++;

640 if (buildCounterEventDefinitionListResponse < 3) {

641 checkUnnamed28(o.items);

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

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

644 }

645 buildCounterEventDefinitionListResponse--;

646 }

647

648 core.int buildCounterEventPeriodRange = 0;

649 buildEventPeriodRange() {

650 var o = new api.EventPeriodRange();

651 buildCounterEventPeriodRange++;

652 if (buildCounterEventPeriodRange < 3) {

653 o.kind = "foo";

654 o.periodEndMillis = "foo";

655 o.periodStartMillis = "foo";

656 }

657 buildCounterEventPeriodRange--;

658 return o;

659 }

660

661 checkEventPeriodRange(api.EventPeriodRange o) {

662 buildCounterEventPeriodRange++;

663 if (buildCounterEventPeriodRange < 3) {

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

665 unittest.expect(o.periodEndMillis, unittest.equals('foo'));

666 unittest.expect(o.periodStartMillis, unittest.equals('foo'));

667 }

668 buildCounterEventPeriodRange--;

669 }

670

671 buildUnnamed29() {

672 var o = new core.List<api.EventUpdateRequest>();

673 o.add(buildEventUpdateRequest());

674 o.add(buildEventUpdateRequest());

675 return o;

676 }

677

678 checkUnnamed29(core.List<api.EventUpdateRequest> o) {

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

680 checkEventUpdateRequest(o[0]);

681 checkEventUpdateRequest(o[1]);

682 }

683

684 core.int buildCounterEventPeriodUpdate = 0;

685 buildEventPeriodUpdate() {

686 var o = new api.EventPeriodUpdate();

687 buildCounterEventPeriodUpdate++;

688 if (buildCounterEventPeriodUpdate < 3) {

689 o.kind = "foo";

690 o.timePeriod = buildEventPeriodRange();

691 o.updates = buildUnnamed29();

692 }

693 buildCounterEventPeriodUpdate--;

694 return o;

695 }

696

697 checkEventPeriodUpdate(api.EventPeriodUpdate o) {

698 buildCounterEventPeriodUpdate++;

699 if (buildCounterEventPeriodUpdate < 3) {

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

701 checkEventPeriodRange(o.timePeriod);

702 checkUnnamed29(o.updates);

703 }

704 buildCounterEventPeriodUpdate--;

705 }

706

707 core.int buildCounterEventRecordFailure = 0;

708 buildEventRecordFailure() {

709 var o = new api.EventRecordFailure();

710 buildCounterEventRecordFailure++;

711 if (buildCounterEventRecordFailure < 3) {

712 o.eventId = "foo";

713 o.failureCause = "foo";

714 o.kind = "foo";

715 }

716 buildCounterEventRecordFailure--;

717 return o;

718 }

719

720 checkEventRecordFailure(api.EventRecordFailure o) {

721 buildCounterEventRecordFailure++;

722 if (buildCounterEventRecordFailure < 3) {

723 unittest.expect(o.eventId, unittest.equals('foo'));

724 unittest.expect(o.failureCause, unittest.equals('foo'));

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

726 }

727 buildCounterEventRecordFailure--;

728 }

729

730 buildUnnamed30() {

731 var o = new core.List<api.EventPeriodUpdate>();

732 o.add(buildEventPeriodUpdate());

733 o.add(buildEventPeriodUpdate());

734 return o;

735 }

736

737 checkUnnamed30(core.List<api.EventPeriodUpdate> o) {

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

739 checkEventPeriodUpdate(o[0]);

740 checkEventPeriodUpdate(o[1]);

741 }

742

743 core.int buildCounterEventRecordRequest = 0;

744 buildEventRecordRequest() {

745 var o = new api.EventRecordRequest();

746 buildCounterEventRecordRequest++;

747 if (buildCounterEventRecordRequest < 3) {

748 o.currentTimeMillis = "foo";

749 o.kind = "foo";

750 o.requestId = "foo";

751 o.timePeriods = buildUnnamed30();

752 }

753 buildCounterEventRecordRequest--;

754 return o;

755 }

756

757 checkEventRecordRequest(api.EventRecordRequest o) {

758 buildCounterEventRecordRequest++;

759 if (buildCounterEventRecordRequest < 3) {

760 unittest.expect(o.currentTimeMillis, unittest.equals('foo'));

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

762 unittest.expect(o.requestId, unittest.equals('foo'));

763 checkUnnamed30(o.timePeriods);

764 }

765 buildCounterEventRecordRequest--;

766 }

767

768 core.int buildCounterEventUpdateRequest = 0;

769 buildEventUpdateRequest() {

770 var o = new api.EventUpdateRequest();

771 buildCounterEventUpdateRequest++;

772 if (buildCounterEventUpdateRequest < 3) {

773 o.definitionId = "foo";

774 o.kind = "foo";

775 o.updateCount = "foo";

776 }

777 buildCounterEventUpdateRequest--;

778 return o;

779 }

780

781 checkEventUpdateRequest(api.EventUpdateRequest o) {

782 buildCounterEventUpdateRequest++;

783 if (buildCounterEventUpdateRequest < 3) {

784 unittest.expect(o.definitionId, unittest.equals('foo'));

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

786 unittest.expect(o.updateCount, unittest.equals('foo'));

787 }

788 buildCounterEventUpdateRequest--;

789 }

790

791 buildUnnamed31() {

792 var o = new core.List<api.EventBatchRecordFailure>();

793 o.add(buildEventBatchRecordFailure());

794 o.add(buildEventBatchRecordFailure());

795 return o;

796 }

797

798 checkUnnamed31(core.List<api.EventBatchRecordFailure> o) {

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

800 checkEventBatchRecordFailure(o[0]);

801 checkEventBatchRecordFailure(o[1]);

802 }

803

804 buildUnnamed32() {

805 var o = new core.List<api.EventRecordFailure>();

806 o.add(buildEventRecordFailure());

807 o.add(buildEventRecordFailure());

808 return o;

809 }

810

811 checkUnnamed32(core.List<api.EventRecordFailure> o) {

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

813 checkEventRecordFailure(o[0]);

814 checkEventRecordFailure(o[1]);

815 }

816

817 buildUnnamed33() {

818 var o = new core.List<api.PlayerEvent>();

819 o.add(buildPlayerEvent());

820 o.add(buildPlayerEvent());

821 return o;

822 }

823

824 checkUnnamed33(core.List<api.PlayerEvent> o) {

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

826 checkPlayerEvent(o[0]);

827 checkPlayerEvent(o[1]);

828 }

829

830 core.int buildCounterEventUpdateResponse = 0;

831 buildEventUpdateResponse() {

832 var o = new api.EventUpdateResponse();

833 buildCounterEventUpdateResponse++;

834 if (buildCounterEventUpdateResponse < 3) {

835 o.batchFailures = buildUnnamed31();

836 o.eventFailures = buildUnnamed32();

837 o.kind = "foo";

838 o.playerEvents = buildUnnamed33();

839 }

840 buildCounterEventUpdateResponse--;

841 return o;

842 }

843

844 checkEventUpdateResponse(api.EventUpdateResponse o) {

845 buildCounterEventUpdateResponse++;

846 if (buildCounterEventUpdateResponse < 3) {

847 checkUnnamed31(o.batchFailures);

848 checkUnnamed32(o.eventFailures);

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

850 checkUnnamed33(o.playerEvents);

851 }

852 buildCounterEventUpdateResponse--;

853 }

854

855 core.int buildCounterGamesAchievementIncrement = 0;

856 buildGamesAchievementIncrement() {

857 var o = new api.GamesAchievementIncrement();

858 buildCounterGamesAchievementIncrement++;

859 if (buildCounterGamesAchievementIncrement < 3) {

860 o.kind = "foo";

861 o.requestId = "foo";

862 o.steps = 42;

863 }

864 buildCounterGamesAchievementIncrement--;

865 return o;

866 }

867

868 checkGamesAchievementIncrement(api.GamesAchievementIncrement o) {

869 buildCounterGamesAchievementIncrement++;

870 if (buildCounterGamesAchievementIncrement < 3) {

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

872 unittest.expect(o.requestId, unittest.equals('foo'));

873 unittest.expect(o.steps, unittest.equals(42));

874 }

875 buildCounterGamesAchievementIncrement--;

876 }

877

878 core.int buildCounterGamesAchievementSetStepsAtLeast = 0;

879 buildGamesAchievementSetStepsAtLeast() {

880 var o = new api.GamesAchievementSetStepsAtLeast();

881 buildCounterGamesAchievementSetStepsAtLeast++;

882 if (buildCounterGamesAchievementSetStepsAtLeast < 3) {

883 o.kind = "foo";

884 o.steps = 42;

885 }

886 buildCounterGamesAchievementSetStepsAtLeast--;

887 return o;

888 }

889

890 checkGamesAchievementSetStepsAtLeast(api.GamesAchievementSetStepsAtLeast o) {

891 buildCounterGamesAchievementSetStepsAtLeast++;

892 if (buildCounterGamesAchievementSetStepsAtLeast < 3) {

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

894 unittest.expect(o.steps, unittest.equals(42));

895 }

896 buildCounterGamesAchievementSetStepsAtLeast--;

897 }

898

899 core.int buildCounterImageAsset = 0;

900 buildImageAsset() {

901 var o = new api.ImageAsset();

902 buildCounterImageAsset++;

903 if (buildCounterImageAsset < 3) {

904 o.height = 42;

905 o.kind = "foo";

906 o.name = "foo";

907 o.url = "foo";

908 o.width = 42;

909 }

910 buildCounterImageAsset--;

911 return o;

912 }

913

914 checkImageAsset(api.ImageAsset o) {

915 buildCounterImageAsset++;

916 if (buildCounterImageAsset < 3) {

917 unittest.expect(o.height, unittest.equals(42));

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

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

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

921 unittest.expect(o.width, unittest.equals(42));

922 }

923 buildCounterImageAsset--;

924 }

925

926 core.int buildCounterInstance = 0;

927 buildInstance() {

928 var o = new api.Instance();

929 buildCounterInstance++;

930 if (buildCounterInstance < 3) {

931 o.acquisitionUri = "foo";

932 o.androidInstance = buildInstanceAndroidDetails();

933 o.iosInstance = buildInstanceIosDetails();

934 o.kind = "foo";

935 o.name = "foo";

936 o.platformType = "foo";

937 o.realtimePlay = true;

938 o.turnBasedPlay = true;

939 o.webInstance = buildInstanceWebDetails();

940 }

941 buildCounterInstance--;

942 return o;

943 }

944

945 checkInstance(api.Instance o) {

946 buildCounterInstance++;

947 if (buildCounterInstance < 3) {

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

949 checkInstanceAndroidDetails(o.androidInstance);

950 checkInstanceIosDetails(o.iosInstance);

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

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

953 unittest.expect(o.platformType, unittest.equals('foo'));

954 unittest.expect(o.realtimePlay, unittest.isTrue);

955 unittest.expect(o.turnBasedPlay, unittest.isTrue);

956 checkInstanceWebDetails(o.webInstance);

957 }

958 buildCounterInstance--;

959 }

960

961 core.int buildCounterInstanceAndroidDetails = 0;

962 buildInstanceAndroidDetails() {

963 var o = new api.InstanceAndroidDetails();

964 buildCounterInstanceAndroidDetails++;

965 if (buildCounterInstanceAndroidDetails < 3) {

966 o.enablePiracyCheck = true;

967 o.kind = "foo";

968 o.packageName = "foo";

969 o.preferred = true;

970 }

971 buildCounterInstanceAndroidDetails--;

972 return o;

973 }

974

975 checkInstanceAndroidDetails(api.InstanceAndroidDetails o) {

976 buildCounterInstanceAndroidDetails++;

977 if (buildCounterInstanceAndroidDetails < 3) {

978 unittest.expect(o.enablePiracyCheck, unittest.isTrue);

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

980 unittest.expect(o.packageName, unittest.equals('foo'));

981 unittest.expect(o.preferred, unittest.isTrue);

982 }

983 buildCounterInstanceAndroidDetails--;

984 }

985

986 core.int buildCounterInstanceIosDetails = 0;

987 buildInstanceIosDetails() {

988 var o = new api.InstanceIosDetails();

989 buildCounterInstanceIosDetails++;

990 if (buildCounterInstanceIosDetails < 3) {

991 o.bundleIdentifier = "foo";

992 o.itunesAppId = "foo";

993 o.kind = "foo";

994 o.preferredForIpad = true;

995 o.preferredForIphone = true;

996 o.supportIpad = true;

997 o.supportIphone = true;

998 }

999 buildCounterInstanceIosDetails--;

1000 return o;

1001 }

1002

1003 checkInstanceIosDetails(api.InstanceIosDetails o) {

1004 buildCounterInstanceIosDetails++;

1005 if (buildCounterInstanceIosDetails < 3) {

1006 unittest.expect(o.bundleIdentifier, unittest.equals('foo'));

1007 unittest.expect(o.itunesAppId, unittest.equals('foo'));

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

1009 unittest.expect(o.preferredForIpad, unittest.isTrue);

1010 unittest.expect(o.preferredForIphone, unittest.isTrue);

1011 unittest.expect(o.supportIpad, unittest.isTrue);

1012 unittest.expect(o.supportIphone, unittest.isTrue);

1013 }

1014 buildCounterInstanceIosDetails--;

1015 }

1016

1017 core.int buildCounterInstanceWebDetails = 0;

1018 buildInstanceWebDetails() {

1019 var o = new api.InstanceWebDetails();

1020 buildCounterInstanceWebDetails++;

1021 if (buildCounterInstanceWebDetails < 3) {

1022 o.kind = "foo";

1023 o.launchUrl = "foo";

1024 o.preferred = true;

1025 }

1026 buildCounterInstanceWebDetails--;

1027 return o;

1028 }

1029

1030 checkInstanceWebDetails(api.InstanceWebDetails o) {

1031 buildCounterInstanceWebDetails++;

1032 if (buildCounterInstanceWebDetails < 3) {

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

1034 unittest.expect(o.launchUrl, unittest.equals('foo'));

1035 unittest.expect(o.preferred, unittest.isTrue);

1036 }

1037 buildCounterInstanceWebDetails--;

1038 }

1039

1040 core.int buildCounterLeaderboard = 0;

1041 buildLeaderboard() {

1042 var o = new api.Leaderboard();

1043 buildCounterLeaderboard++;

1044 if (buildCounterLeaderboard < 3) {

1045 o.iconUrl = "foo";

1046 o.id = "foo";

1047 o.isIconUrlDefault = true;

1048 o.kind = "foo";

1049 o.name = "foo";

1050 o.order = "foo";

1051 }

1052 buildCounterLeaderboard--;

1053 return o;

1054 }

1055

1056 checkLeaderboard(api.Leaderboard o) {

1057 buildCounterLeaderboard++;

1058 if (buildCounterLeaderboard < 3) {

1059 unittest.expect(o.iconUrl, unittest.equals('foo'));

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

1061 unittest.expect(o.isIconUrlDefault, unittest.isTrue);

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

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

1064 unittest.expect(o.order, unittest.equals('foo'));

1065 }

1066 buildCounterLeaderboard--;

1067 }

1068

1069 core.int buildCounterLeaderboardEntry = 0;

1070 buildLeaderboardEntry() {

1071 var o = new api.LeaderboardEntry();

1072 buildCounterLeaderboardEntry++;

1073 if (buildCounterLeaderboardEntry < 3) {

1074 o.formattedScore = "foo";

1075 o.formattedScoreRank = "foo";

1076 o.kind = "foo";

1077 o.player = buildPlayer();

1078 o.scoreRank = "foo";

1079 o.scoreTag = "foo";

1080 o.scoreValue = "foo";

1081 o.timeSpan = "foo";

1082 o.writeTimestampMillis = "foo";

1083 }

1084 buildCounterLeaderboardEntry--;

1085 return o;

1086 }

1087

1088 checkLeaderboardEntry(api.LeaderboardEntry o) {

1089 buildCounterLeaderboardEntry++;

1090 if (buildCounterLeaderboardEntry < 3) {

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

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

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

1094 checkPlayer(o.player);

1095 unittest.expect(o.scoreRank, unittest.equals('foo'));

1096 unittest.expect(o.scoreTag, unittest.equals('foo'));

1097 unittest.expect(o.scoreValue, unittest.equals('foo'));

1098 unittest.expect(o.timeSpan, unittest.equals('foo'));

1099 unittest.expect(o.writeTimestampMillis, unittest.equals('foo'));

1100 }

1101 buildCounterLeaderboardEntry--;

1102 }

1103

1104 buildUnnamed34() {

1105 var o = new core.List<api.Leaderboard>();

1106 o.add(buildLeaderboard());

1107 o.add(buildLeaderboard());

1108 return o;

1109 }

1110

1111 checkUnnamed34(core.List<api.Leaderboard> o) {

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

1113 checkLeaderboard(o[0]);

1114 checkLeaderboard(o[1]);

1115 }

1116

1117 core.int buildCounterLeaderboardListResponse = 0;

1118 buildLeaderboardListResponse() {

1119 var o = new api.LeaderboardListResponse();

1120 buildCounterLeaderboardListResponse++;

1121 if (buildCounterLeaderboardListResponse < 3) {

1122 o.items = buildUnnamed34();

1123 o.kind = "foo";

1124 o.nextPageToken = "foo";

1125 }

1126 buildCounterLeaderboardListResponse--;

1127 return o;

1128 }

1129

1130 checkLeaderboardListResponse(api.LeaderboardListResponse o) {

1131 buildCounterLeaderboardListResponse++;

1132 if (buildCounterLeaderboardListResponse < 3) {

1133 checkUnnamed34(o.items);

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

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

1136 }

1137 buildCounterLeaderboardListResponse--;

1138 }

1139

1140 core.int buildCounterLeaderboardScoreRank = 0;

1141 buildLeaderboardScoreRank() {

1142 var o = new api.LeaderboardScoreRank();

1143 buildCounterLeaderboardScoreRank++;

1144 if (buildCounterLeaderboardScoreRank < 3) {

1145 o.formattedNumScores = "foo";

1146 o.formattedRank = "foo";

1147 o.kind = "foo";

1148 o.numScores = "foo";

1149 o.rank = "foo";

1150 }

1151 buildCounterLeaderboardScoreRank--;

1152 return o;

1153 }

1154

1155 checkLeaderboardScoreRank(api.LeaderboardScoreRank o) {

1156 buildCounterLeaderboardScoreRank++;

1157 if (buildCounterLeaderboardScoreRank < 3) {

1158 unittest.expect(o.formattedNumScores, unittest.equals('foo'));

1159 unittest.expect(o.formattedRank, unittest.equals('foo'));

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

1161 unittest.expect(o.numScores, unittest.equals('foo'));

1162 unittest.expect(o.rank, unittest.equals('foo'));

1163 }

1164 buildCounterLeaderboardScoreRank--;

1165 }

1166

1167 buildUnnamed35() {

1168 var o = new core.List<api.LeaderboardEntry>();

1169 o.add(buildLeaderboardEntry());

1170 o.add(buildLeaderboardEntry());

1171 return o;

1172 }

1173

1174 checkUnnamed35(core.List<api.LeaderboardEntry> o) {

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

1176 checkLeaderboardEntry(o[0]);

1177 checkLeaderboardEntry(o[1]);

1178 }

1179

1180 core.int buildCounterLeaderboardScores = 0;

1181 buildLeaderboardScores() {

1182 var o = new api.LeaderboardScores();

1183 buildCounterLeaderboardScores++;

1184 if (buildCounterLeaderboardScores < 3) {

1185 o.items = buildUnnamed35();

1186 o.kind = "foo";

1187 o.nextPageToken = "foo";

1188 o.numScores = "foo";

1189 o.playerScore = buildLeaderboardEntry();

1190 o.prevPageToken = "foo";

1191 }

1192 buildCounterLeaderboardScores--;

1193 return o;

1194 }

1195

1196 checkLeaderboardScores(api.LeaderboardScores o) {

1197 buildCounterLeaderboardScores++;

1198 if (buildCounterLeaderboardScores < 3) {

1199 checkUnnamed35(o.items);

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

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

1202 unittest.expect(o.numScores, unittest.equals('foo'));

1203 checkLeaderboardEntry(o.playerScore);

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

1205 }

1206 buildCounterLeaderboardScores--;

1207 }

1208

1209 buildUnnamed36() {

1210 var o = new core.List<api.PlayerLevel>();

1211 o.add(buildPlayerLevel());

1212 o.add(buildPlayerLevel());

1213 return o;

1214 }

1215

1216 checkUnnamed36(core.List<api.PlayerLevel> o) {

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

1218 checkPlayerLevel(o[0]);

1219 checkPlayerLevel(o[1]);

1220 }

1221

1222 core.int buildCounterMetagameConfig = 0;

1223 buildMetagameConfig() {

1224 var o = new api.MetagameConfig();

1225 buildCounterMetagameConfig++;

1226 if (buildCounterMetagameConfig < 3) {

1227 o.currentVersion = 42;

1228 o.kind = "foo";

1229 o.playerLevels = buildUnnamed36();

1230 }

1231 buildCounterMetagameConfig--;

1232 return o;

1233 }

1234

1235 checkMetagameConfig(api.MetagameConfig o) {

1236 buildCounterMetagameConfig++;

1237 if (buildCounterMetagameConfig < 3) {

1238 unittest.expect(o.currentVersion, unittest.equals(42));

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

1240 checkUnnamed36(o.playerLevels);

1241 }

1242 buildCounterMetagameConfig--;

1243 }

1244

1245 core.int buildCounterNetworkDiagnostics = 0;

1246 buildNetworkDiagnostics() {

1247 var o = new api.NetworkDiagnostics();

1248 buildCounterNetworkDiagnostics++;

1249 if (buildCounterNetworkDiagnostics < 3) {

1250 o.androidNetworkSubtype = 42;

1251 o.androidNetworkType = 42;

1252 o.iosNetworkType = 42;

1253 o.kind = "foo";

1254 o.networkOperatorCode = "foo";

1255 o.networkOperatorName = "foo";

1256 o.registrationLatencyMillis = 42;

1257 }

1258 buildCounterNetworkDiagnostics--;

1259 return o;

1260 }

1261

1262 checkNetworkDiagnostics(api.NetworkDiagnostics o) {

1263 buildCounterNetworkDiagnostics++;

1264 if (buildCounterNetworkDiagnostics < 3) {

1265 unittest.expect(o.androidNetworkSubtype, unittest.equals(42));

1266 unittest.expect(o.androidNetworkType, unittest.equals(42));

1267 unittest.expect(o.iosNetworkType, unittest.equals(42));

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

1269 unittest.expect(o.networkOperatorCode, unittest.equals('foo'));

1270 unittest.expect(o.networkOperatorName, unittest.equals('foo'));

1271 unittest.expect(o.registrationLatencyMillis, unittest.equals(42));

1272 }

1273 buildCounterNetworkDiagnostics--;

1274 }

1275

1276 core.int buildCounterParticipantResult = 0;

1277 buildParticipantResult() {

1278 var o = new api.ParticipantResult();

1279 buildCounterParticipantResult++;

1280 if (buildCounterParticipantResult < 3) {

1281 o.kind = "foo";

1282 o.participantId = "foo";

1283 o.placing = 42;

1284 o.result = "foo";

1285 }

1286 buildCounterParticipantResult--;

1287 return o;

1288 }

1289

1290 checkParticipantResult(api.ParticipantResult o) {

1291 buildCounterParticipantResult++;

1292 if (buildCounterParticipantResult < 3) {

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

1294 unittest.expect(o.participantId, unittest.equals('foo'));

1295 unittest.expect(o.placing, unittest.equals(42));

1296 unittest.expect(o.result, unittest.equals('foo'));

1297 }

1298 buildCounterParticipantResult--;

1299 }

1300

1301 core.int buildCounterPeerChannelDiagnostics = 0;

1302 buildPeerChannelDiagnostics() {

1303 var o = new api.PeerChannelDiagnostics();

1304 buildCounterPeerChannelDiagnostics++;

1305 if (buildCounterPeerChannelDiagnostics < 3) {

1306 o.bytesReceived = buildAggregateStats();

1307 o.bytesSent = buildAggregateStats();

1308 o.kind = "foo";

1309 o.numMessagesLost = 42;

1310 o.numMessagesReceived = 42;

1311 o.numMessagesSent = 42;

1312 o.numSendFailures = 42;

1313 o.roundtripLatencyMillis = buildAggregateStats();

1314 }

1315 buildCounterPeerChannelDiagnostics--;

1316 return o;

1317 }

1318

1319 checkPeerChannelDiagnostics(api.PeerChannelDiagnostics o) {

1320 buildCounterPeerChannelDiagnostics++;

1321 if (buildCounterPeerChannelDiagnostics < 3) {

1322 checkAggregateStats(o.bytesReceived);

1323 checkAggregateStats(o.bytesSent);

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

1325 unittest.expect(o.numMessagesLost, unittest.equals(42));

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

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

1328 unittest.expect(o.numSendFailures, unittest.equals(42));

1329 checkAggregateStats(o.roundtripLatencyMillis);

1330 }

1331 buildCounterPeerChannelDiagnostics--;

1332 }

1333

1334 core.int buildCounterPeerSessionDiagnostics = 0;

1335 buildPeerSessionDiagnostics() {

1336 var o = new api.PeerSessionDiagnostics();

1337 buildCounterPeerSessionDiagnostics++;

1338 if (buildCounterPeerSessionDiagnostics < 3) {

1339 o.connectedTimestampMillis = "foo";

1340 o.kind = "foo";

1341 o.participantId = "foo";

1342 o.reliableChannel = buildPeerChannelDiagnostics();

1343 o.unreliableChannel = buildPeerChannelDiagnostics();

1344 }

1345 buildCounterPeerSessionDiagnostics--;

1346 return o;

1347 }

1348

1349 checkPeerSessionDiagnostics(api.PeerSessionDiagnostics o) {

1350 buildCounterPeerSessionDiagnostics++;

1351 if (buildCounterPeerSessionDiagnostics < 3) {

1352 unittest.expect(o.connectedTimestampMillis, unittest.equals('foo'));

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

1354 unittest.expect(o.participantId, unittest.equals('foo'));

1355 checkPeerChannelDiagnostics(o.reliableChannel);

1356 checkPeerChannelDiagnostics(o.unreliableChannel);

1357 }

1358 buildCounterPeerSessionDiagnostics--;

1359 }

1360

1361 core.int buildCounterPlayed = 0;

1362 buildPlayed() {

1363 var o = new api.Played();

1364 buildCounterPlayed++;

1365 if (buildCounterPlayed < 3) {

1366 o.autoMatched = true;

1367 o.kind = "foo";

1368 o.timeMillis = "foo";

1369 }

1370 buildCounterPlayed--;

1371 return o;

1372 }

1373

1374 checkPlayed(api.Played o) {

1375 buildCounterPlayed++;

1376 if (buildCounterPlayed < 3) {

1377 unittest.expect(o.autoMatched, unittest.isTrue);

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

1379 unittest.expect(o.timeMillis, unittest.equals('foo'));

1380 }

1381 buildCounterPlayed--;

1382 }

1383

1384 core.int buildCounterPlayerName = 0;

1385 buildPlayerName() {

1386 var o = new api.PlayerName();

1387 buildCounterPlayerName++;

1388 if (buildCounterPlayerName < 3) {

1389 o.familyName = "foo";

1390 o.givenName = "foo";

1391 }

1392 buildCounterPlayerName--;

1393 return o;

1394 }

1395

1396 checkPlayerName(api.PlayerName o) {

1397 buildCounterPlayerName++;

1398 if (buildCounterPlayerName < 3) {

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

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

1401 }

1402 buildCounterPlayerName--;

1403 }

1404

1405 core.int buildCounterPlayer = 0;

1406 buildPlayer() {

1407 var o = new api.Player();

1408 buildCounterPlayer++;

1409 if (buildCounterPlayer < 3) {

1410 o.avatarImageUrl = "foo";

1411 o.displayName = "foo";

1412 o.experienceInfo = buildPlayerExperienceInfo();

1413 o.kind = "foo";

1414 o.lastPlayedWith = buildPlayed();

1415 o.name = buildPlayerName();

1416 o.playerId = "foo";

1417 o.title = "foo";

1418 }

1419 buildCounterPlayer--;

1420 return o;

1421 }

1422

1423 checkPlayer(api.Player o) {

1424 buildCounterPlayer++;

1425 if (buildCounterPlayer < 3) {

1426 unittest.expect(o.avatarImageUrl, unittest.equals('foo'));

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

1428 checkPlayerExperienceInfo(o.experienceInfo);

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

1430 checkPlayed(o.lastPlayedWith);

1431 checkPlayerName(o.name);

1432 unittest.expect(o.playerId, unittest.equals('foo'));

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

1434 }

1435 buildCounterPlayer--;

1436 }

1437

1438 core.int buildCounterPlayerAchievement = 0;

1439 buildPlayerAchievement() {

1440 var o = new api.PlayerAchievement();

1441 buildCounterPlayerAchievement++;

1442 if (buildCounterPlayerAchievement < 3) {

1443 o.achievementState = "foo";

1444 o.currentSteps = 42;

1445 o.experiencePoints = "foo";

1446 o.formattedCurrentStepsString = "foo";

1447 o.id = "foo";

1448 o.kind = "foo";

1449 o.lastUpdatedTimestamp = "foo";

1450 }

1451 buildCounterPlayerAchievement--;

1452 return o;

1453 }

1454

1455 checkPlayerAchievement(api.PlayerAchievement o) {

1456 buildCounterPlayerAchievement++;

1457 if (buildCounterPlayerAchievement < 3) {

1458 unittest.expect(o.achievementState, unittest.equals('foo'));

1459 unittest.expect(o.currentSteps, unittest.equals(42));

1460 unittest.expect(o.experiencePoints, unittest.equals('foo'));

1461 unittest.expect(o.formattedCurrentStepsString, unittest.equals('foo'));

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

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

1464 unittest.expect(o.lastUpdatedTimestamp, unittest.equals('foo'));

1465 }

1466 buildCounterPlayerAchievement--;

1467 }

1468

1469 buildUnnamed37() {

1470 var o = new core.List<api.PlayerAchievement>();

1471 o.add(buildPlayerAchievement());

1472 o.add(buildPlayerAchievement());

1473 return o;

1474 }

1475

1476 checkUnnamed37(core.List<api.PlayerAchievement> o) {

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

1478 checkPlayerAchievement(o[0]);

1479 checkPlayerAchievement(o[1]);

1480 }

1481

1482 core.int buildCounterPlayerAchievementListResponse = 0;

1483 buildPlayerAchievementListResponse() {

1484 var o = new api.PlayerAchievementListResponse();

1485 buildCounterPlayerAchievementListResponse++;

1486 if (buildCounterPlayerAchievementListResponse < 3) {

1487 o.items = buildUnnamed37();

1488 o.kind = "foo";

1489 o.nextPageToken = "foo";

1490 }

1491 buildCounterPlayerAchievementListResponse--;

1492 return o;

1493 }

1494

1495 checkPlayerAchievementListResponse(api.PlayerAchievementListResponse o) {

1496 buildCounterPlayerAchievementListResponse++;

1497 if (buildCounterPlayerAchievementListResponse < 3) {

1498 checkUnnamed37(o.items);

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

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

1501 }

1502 buildCounterPlayerAchievementListResponse--;

1503 }

1504

1505 core.int buildCounterPlayerEvent = 0;

1506 buildPlayerEvent() {

1507 var o = new api.PlayerEvent();

1508 buildCounterPlayerEvent++;

1509 if (buildCounterPlayerEvent < 3) {

1510 o.definitionId = "foo";

1511 o.formattedNumEvents = "foo";

1512 o.kind = "foo";

1513 o.numEvents = "foo";

1514 o.playerId = "foo";

1515 }

1516 buildCounterPlayerEvent--;

1517 return o;

1518 }

1519

1520 checkPlayerEvent(api.PlayerEvent o) {

1521 buildCounterPlayerEvent++;

1522 if (buildCounterPlayerEvent < 3) {

1523 unittest.expect(o.definitionId, unittest.equals('foo'));

1524 unittest.expect(o.formattedNumEvents, unittest.equals('foo'));

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

1526 unittest.expect(o.numEvents, unittest.equals('foo'));

1527 unittest.expect(o.playerId, unittest.equals('foo'));

1528 }

1529 buildCounterPlayerEvent--;

1530 }

1531

1532 buildUnnamed38() {

1533 var o = new core.List<api.PlayerEvent>();

1534 o.add(buildPlayerEvent());

1535 o.add(buildPlayerEvent());

1536 return o;

1537 }

1538

1539 checkUnnamed38(core.List<api.PlayerEvent> o) {

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

1541 checkPlayerEvent(o[0]);

1542 checkPlayerEvent(o[1]);

1543 }

1544

1545 core.int buildCounterPlayerEventListResponse = 0;

1546 buildPlayerEventListResponse() {

1547 var o = new api.PlayerEventListResponse();

1548 buildCounterPlayerEventListResponse++;

1549 if (buildCounterPlayerEventListResponse < 3) {

1550 o.items = buildUnnamed38();

1551 o.kind = "foo";

1552 o.nextPageToken = "foo";

1553 }

1554 buildCounterPlayerEventListResponse--;

1555 return o;

1556 }

1557

1558 checkPlayerEventListResponse(api.PlayerEventListResponse o) {

1559 buildCounterPlayerEventListResponse++;

1560 if (buildCounterPlayerEventListResponse < 3) {

1561 checkUnnamed38(o.items);

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

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

1564 }

1565 buildCounterPlayerEventListResponse--;

1566 }

1567

1568 core.int buildCounterPlayerExperienceInfo = 0;

1569 buildPlayerExperienceInfo() {

1570 var o = new api.PlayerExperienceInfo();

1571 buildCounterPlayerExperienceInfo++;

1572 if (buildCounterPlayerExperienceInfo < 3) {

1573 o.currentExperiencePoints = "foo";

1574 o.currentLevel = buildPlayerLevel();

1575 o.kind = "foo";

1576 o.lastLevelUpTimestampMillis = "foo";

1577 o.nextLevel = buildPlayerLevel();

1578 }

1579 buildCounterPlayerExperienceInfo--;

1580 return o;

1581 }

1582

1583 checkPlayerExperienceInfo(api.PlayerExperienceInfo o) {

1584 buildCounterPlayerExperienceInfo++;

1585 if (buildCounterPlayerExperienceInfo < 3) {

1586 unittest.expect(o.currentExperiencePoints, unittest.equals('foo'));

1587 checkPlayerLevel(o.currentLevel);

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

1589 unittest.expect(o.lastLevelUpTimestampMillis, unittest.equals('foo'));

1590 checkPlayerLevel(o.nextLevel);

1591 }

1592 buildCounterPlayerExperienceInfo--;

1593 }

1594

1595 core.int buildCounterPlayerLeaderboardScore = 0;

1596 buildPlayerLeaderboardScore() {

1597 var o = new api.PlayerLeaderboardScore();

1598 buildCounterPlayerLeaderboardScore++;

1599 if (buildCounterPlayerLeaderboardScore < 3) {

1600 o.kind = "foo";

1601 o.leaderboardId = "foo";

1602 o.publicRank = buildLeaderboardScoreRank();

1603 o.scoreString = "foo";

1604 o.scoreTag = "foo";

1605 o.scoreValue = "foo";

1606 o.socialRank = buildLeaderboardScoreRank();

1607 o.timeSpan = "foo";

1608 o.writeTimestamp = "foo";

1609 }

1610 buildCounterPlayerLeaderboardScore--;

1611 return o;

1612 }

1613

1614 checkPlayerLeaderboardScore(api.PlayerLeaderboardScore o) {

1615 buildCounterPlayerLeaderboardScore++;

1616 if (buildCounterPlayerLeaderboardScore < 3) {

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

1618 unittest.expect(o.leaderboardId, unittest.equals('foo'));

1619 checkLeaderboardScoreRank(o.publicRank);

1620 unittest.expect(o.scoreString, unittest.equals('foo'));

1621 unittest.expect(o.scoreTag, unittest.equals('foo'));

1622 unittest.expect(o.scoreValue, unittest.equals('foo'));

1623 checkLeaderboardScoreRank(o.socialRank);

1624 unittest.expect(o.timeSpan, unittest.equals('foo'));

1625 unittest.expect(o.writeTimestamp, unittest.equals('foo'));

1626 }

1627 buildCounterPlayerLeaderboardScore--;

1628 }

1629

1630 buildUnnamed39() {

1631 var o = new core.List<api.PlayerLeaderboardScore>();

1632 o.add(buildPlayerLeaderboardScore());

1633 o.add(buildPlayerLeaderboardScore());

1634 return o;

1635 }

1636

1637 checkUnnamed39(core.List<api.PlayerLeaderboardScore> o) {

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

1639 checkPlayerLeaderboardScore(o[0]);

1640 checkPlayerLeaderboardScore(o[1]);

1641 }

1642

1643 core.int buildCounterPlayerLeaderboardScoreListResponse = 0;

1644 buildPlayerLeaderboardScoreListResponse() {

1645 var o = new api.PlayerLeaderboardScoreListResponse();

1646 buildCounterPlayerLeaderboardScoreListResponse++;

1647 if (buildCounterPlayerLeaderboardScoreListResponse < 3) {

1648 o.items = buildUnnamed39();

1649 o.kind = "foo";

1650 o.nextPageToken = "foo";

1651 o.player = buildPlayer();

1652 }

1653 buildCounterPlayerLeaderboardScoreListResponse--;

1654 return o;

1655 }

1656

1657 checkPlayerLeaderboardScoreListResponse(api.PlayerLeaderboardScoreListResponse o ) {

1658 buildCounterPlayerLeaderboardScoreListResponse++;

1659 if (buildCounterPlayerLeaderboardScoreListResponse < 3) {

1660 checkUnnamed39(o.items);

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

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

1663 checkPlayer(o.player);

1664 }

1665 buildCounterPlayerLeaderboardScoreListResponse--;

1666 }

1667

1668 core.int buildCounterPlayerLevel = 0;

1669 buildPlayerLevel() {

1670 var o = new api.PlayerLevel();

1671 buildCounterPlayerLevel++;

1672 if (buildCounterPlayerLevel < 3) {

1673 o.kind = "foo";

1674 o.level = 42;

1675 o.maxExperiencePoints = "foo";

1676 o.minExperiencePoints = "foo";

1677 }

1678 buildCounterPlayerLevel--;

1679 return o;

1680 }

1681

1682 checkPlayerLevel(api.PlayerLevel o) {

1683 buildCounterPlayerLevel++;

1684 if (buildCounterPlayerLevel < 3) {

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

1686 unittest.expect(o.level, unittest.equals(42));

1687 unittest.expect(o.maxExperiencePoints, unittest.equals('foo'));

1688 unittest.expect(o.minExperiencePoints, unittest.equals('foo'));

1689 }

1690 buildCounterPlayerLevel--;

1691 }

1692

1693 buildUnnamed40() {

1694 var o = new core.List<api.Player>();

1695 o.add(buildPlayer());

1696 o.add(buildPlayer());

1697 return o;

1698 }

1699

1700 checkUnnamed40(core.List<api.Player> o) {

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

1702 checkPlayer(o[0]);

1703 checkPlayer(o[1]);

1704 }

1705

1706 core.int buildCounterPlayerListResponse = 0;

1707 buildPlayerListResponse() {

1708 var o = new api.PlayerListResponse();

1709 buildCounterPlayerListResponse++;

1710 if (buildCounterPlayerListResponse < 3) {

1711 o.items = buildUnnamed40();

1712 o.kind = "foo";

1713 o.nextPageToken = "foo";

1714 }

1715 buildCounterPlayerListResponse--;

1716 return o;

1717 }

1718

1719 checkPlayerListResponse(api.PlayerListResponse o) {

1720 buildCounterPlayerListResponse++;

1721 if (buildCounterPlayerListResponse < 3) {

1722 checkUnnamed40(o.items);

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

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

1725 }

1726 buildCounterPlayerListResponse--;

1727 }

1728

1729 core.int buildCounterPlayerScore = 0;

1730 buildPlayerScore() {

1731 var o = new api.PlayerScore();

1732 buildCounterPlayerScore++;

1733 if (buildCounterPlayerScore < 3) {

1734 o.formattedScore = "foo";

1735 o.kind = "foo";

1736 o.score = "foo";

1737 o.scoreTag = "foo";

1738 o.timeSpan = "foo";

1739 }

1740 buildCounterPlayerScore--;

1741 return o;

1742 }

1743

1744 checkPlayerScore(api.PlayerScore o) {

1745 buildCounterPlayerScore++;

1746 if (buildCounterPlayerScore < 3) {

1747 unittest.expect(o.formattedScore, unittest.equals('foo'));

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

1749 unittest.expect(o.score, unittest.equals('foo'));

1750 unittest.expect(o.scoreTag, unittest.equals('foo'));

1751 unittest.expect(o.timeSpan, unittest.equals('foo'));

1752 }

1753 buildCounterPlayerScore--;

1754 }

1755

1756 buildUnnamed41() {

1757 var o = new core.List<api.PlayerScoreResponse>();

1758 o.add(buildPlayerScoreResponse());

1759 o.add(buildPlayerScoreResponse());

1760 return o;

1761 }

1762

1763 checkUnnamed41(core.List<api.PlayerScoreResponse> o) {

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

1765 checkPlayerScoreResponse(o[0]);

1766 checkPlayerScoreResponse(o[1]);

1767 }

1768

1769 core.int buildCounterPlayerScoreListResponse = 0;

1770 buildPlayerScoreListResponse() {

1771 var o = new api.PlayerScoreListResponse();

1772 buildCounterPlayerScoreListResponse++;

1773 if (buildCounterPlayerScoreListResponse < 3) {

1774 o.kind = "foo";

1775 o.submittedScores = buildUnnamed41();

1776 }

1777 buildCounterPlayerScoreListResponse--;

1778 return o;

1779 }

1780

1781 checkPlayerScoreListResponse(api.PlayerScoreListResponse o) {

1782 buildCounterPlayerScoreListResponse++;

1783 if (buildCounterPlayerScoreListResponse < 3) {

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

1785 checkUnnamed41(o.submittedScores);

1786 }

1787 buildCounterPlayerScoreListResponse--;

1788 }

1789

1790 buildUnnamed42() {

1791 var o = new core.List<core.String>();

1792 o.add("foo");

1793 o.add("foo");

1794 return o;

1795 }

1796

1797 checkUnnamed42(core.List<core.String> o) {

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

1799 unittest.expect(o[0], unittest.equals('foo'));

1800 unittest.expect(o[1], unittest.equals('foo'));

1801 }

1802

1803 buildUnnamed43() {

1804 var o = new core.List<api.PlayerScore>();

1805 o.add(buildPlayerScore());

1806 o.add(buildPlayerScore());

1807 return o;

1808 }

1809

1810 checkUnnamed43(core.List<api.PlayerScore> o) {

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

1812 checkPlayerScore(o[0]);

1813 checkPlayerScore(o[1]);

1814 }

1815

1816 core.int buildCounterPlayerScoreResponse = 0;

1817 buildPlayerScoreResponse() {

1818 var o = new api.PlayerScoreResponse();

1819 buildCounterPlayerScoreResponse++;

1820 if (buildCounterPlayerScoreResponse < 3) {

1821 o.beatenScoreTimeSpans = buildUnnamed42();

1822 o.formattedScore = "foo";

1823 o.kind = "foo";

1824 o.leaderboardId = "foo";

1825 o.scoreTag = "foo";

1826 o.unbeatenScores = buildUnnamed43();

1827 }

1828 buildCounterPlayerScoreResponse--;

1829 return o;

1830 }

1831

1832 checkPlayerScoreResponse(api.PlayerScoreResponse o) {

1833 buildCounterPlayerScoreResponse++;

1834 if (buildCounterPlayerScoreResponse < 3) {

1835 checkUnnamed42(o.beatenScoreTimeSpans);

1836 unittest.expect(o.formattedScore, unittest.equals('foo'));

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

1838 unittest.expect(o.leaderboardId, unittest.equals('foo'));

1839 unittest.expect(o.scoreTag, unittest.equals('foo'));

1840 checkUnnamed43(o.unbeatenScores);

1841 }

1842 buildCounterPlayerScoreResponse--;

1843 }

1844

1845 buildUnnamed44() {

1846 var o = new core.List<api.ScoreSubmission>();

1847 o.add(buildScoreSubmission());

1848 o.add(buildScoreSubmission());

1849 return o;

1850 }

1851

1852 checkUnnamed44(core.List<api.ScoreSubmission> o) {

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

1854 checkScoreSubmission(o[0]);

1855 checkScoreSubmission(o[1]);

1856 }

1857

1858 core.int buildCounterPlayerScoreSubmissionList = 0;

1859 buildPlayerScoreSubmissionList() {

1860 var o = new api.PlayerScoreSubmissionList();

1861 buildCounterPlayerScoreSubmissionList++;

1862 if (buildCounterPlayerScoreSubmissionList < 3) {

1863 o.kind = "foo";

1864 o.scores = buildUnnamed44();

1865 }

1866 buildCounterPlayerScoreSubmissionList--;

1867 return o;

1868 }

1869

1870 checkPlayerScoreSubmissionList(api.PlayerScoreSubmissionList o) {

1871 buildCounterPlayerScoreSubmissionList++;

1872 if (buildCounterPlayerScoreSubmissionList < 3) {

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

1874 checkUnnamed44(o.scores);

1875 }

1876 buildCounterPlayerScoreSubmissionList--;

1877 }

1878

1879 core.int buildCounterPushToken = 0;

1880 buildPushToken() {

1881 var o = new api.PushToken();

1882 buildCounterPushToken++;

1883 if (buildCounterPushToken < 3) {

1884 o.clientRevision = "foo";

1885 o.id = buildPushTokenId();

1886 o.kind = "foo";

1887 o.language = "foo";

1888 }

1889 buildCounterPushToken--;

1890 return o;

1891 }

1892

1893 checkPushToken(api.PushToken o) {

1894 buildCounterPushToken++;

1895 if (buildCounterPushToken < 3) {

1896 unittest.expect(o.clientRevision, unittest.equals('foo'));

1897 checkPushTokenId(o.id);

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

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

1900 }

1901 buildCounterPushToken--;

1902 }

1903

1904 core.int buildCounterPushTokenIdIos = 0;

1905 buildPushTokenIdIos() {

1906 var o = new api.PushTokenIdIos();

1907 buildCounterPushTokenIdIos++;

1908 if (buildCounterPushTokenIdIos < 3) {

1909 o.apnsDeviceToken = "foo";

1910 o.apnsEnvironment = "foo";

1911 }

1912 buildCounterPushTokenIdIos--;

1913 return o;

1914 }

1915

1916 checkPushTokenIdIos(api.PushTokenIdIos o) {

1917 buildCounterPushTokenIdIos++;

1918 if (buildCounterPushTokenIdIos < 3) {

1919 unittest.expect(o.apnsDeviceToken, unittest.equals('foo'));

1920 unittest.expect(o.apnsEnvironment, unittest.equals('foo'));

1921 }

1922 buildCounterPushTokenIdIos--;

1923 }

1924

1925 core.int buildCounterPushTokenId = 0;

1926 buildPushTokenId() {

1927 var o = new api.PushTokenId();

1928 buildCounterPushTokenId++;

1929 if (buildCounterPushTokenId < 3) {

1930 o.ios = buildPushTokenIdIos();

1931 o.kind = "foo";

1932 }

1933 buildCounterPushTokenId--;

1934 return o;

1935 }

1936

1937 checkPushTokenId(api.PushTokenId o) {

1938 buildCounterPushTokenId++;

1939 if (buildCounterPushTokenId < 3) {

1940 checkPushTokenIdIos(o.ios);

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

1942 }

1943 buildCounterPushTokenId--;

1944 }

1945

1946 buildUnnamed45() {

1947 var o = new core.List<api.QuestMilestone>();

1948 o.add(buildQuestMilestone());

1949 o.add(buildQuestMilestone());

1950 return o;

1951 }

1952

1953 checkUnnamed45(core.List<api.QuestMilestone> o) {

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

1955 checkQuestMilestone(o[0]);

1956 checkQuestMilestone(o[1]);

1957 }

1958

1959 core.int buildCounterQuest = 0;

1960 buildQuest() {

1961 var o = new api.Quest();

1962 buildCounterQuest++;

1963 if (buildCounterQuest < 3) {

1964 o.acceptedTimestampMillis = "foo";

1965 o.applicationId = "foo";

1966 o.bannerUrl = "foo";

1967 o.description = "foo";

1968 o.endTimestampMillis = "foo";

1969 o.iconUrl = "foo";

1970 o.id = "foo";

1971 o.isDefaultBannerUrl = true;

1972 o.isDefaultIconUrl = true;

1973 o.kind = "foo";

1974 o.lastUpdatedTimestampMillis = "foo";

1975 o.milestones = buildUnnamed45();

1976 o.name = "foo";

1977 o.notifyTimestampMillis = "foo";

1978 o.startTimestampMillis = "foo";

1979 o.state = "foo";

1980 }

1981 buildCounterQuest--;

1982 return o;

1983 }

1984

1985 checkQuest(api.Quest o) {

1986 buildCounterQuest++;

1987 if (buildCounterQuest < 3) {

1988 unittest.expect(o.acceptedTimestampMillis, unittest.equals('foo'));

1989 unittest.expect(o.applicationId, unittest.equals('foo'));

1990 unittest.expect(o.bannerUrl, unittest.equals('foo'));

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

1992 unittest.expect(o.endTimestampMillis, unittest.equals('foo'));

1993 unittest.expect(o.iconUrl, unittest.equals('foo'));

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

1995 unittest.expect(o.isDefaultBannerUrl, unittest.isTrue);

1996 unittest.expect(o.isDefaultIconUrl, unittest.isTrue);

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

1998 unittest.expect(o.lastUpdatedTimestampMillis, unittest.equals('foo'));

1999 checkUnnamed45(o.milestones);

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

2001 unittest.expect(o.notifyTimestampMillis, unittest.equals('foo'));

2002 unittest.expect(o.startTimestampMillis, unittest.equals('foo'));

2003 unittest.expect(o.state, unittest.equals('foo'));

2004 }

2005 buildCounterQuest--;

2006 }

2007

2008 core.int buildCounterQuestContribution = 0;

2009 buildQuestContribution() {

2010 var o = new api.QuestContribution();

2011 buildCounterQuestContribution++;

2012 if (buildCounterQuestContribution < 3) {

2013 o.formattedValue = "foo";

2014 o.kind = "foo";

2015 o.value = "foo";

2016 }

2017 buildCounterQuestContribution--;

2018 return o;

2019 }

2020

2021 checkQuestContribution(api.QuestContribution o) {

2022 buildCounterQuestContribution++;

2023 if (buildCounterQuestContribution < 3) {

2024 unittest.expect(o.formattedValue, unittest.equals('foo'));

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

2026 unittest.expect(o.value, unittest.equals('foo'));

2027 }

2028 buildCounterQuestContribution--;

2029 }

2030

2031 core.int buildCounterQuestCriterion = 0;

2032 buildQuestCriterion() {

2033 var o = new api.QuestCriterion();

2034 buildCounterQuestCriterion++;

2035 if (buildCounterQuestCriterion < 3) {

2036 o.completionContribution = buildQuestContribution();

2037 o.currentContribution = buildQuestContribution();

2038 o.eventId = "foo";

2039 o.initialPlayerProgress = buildQuestContribution();

2040 o.kind = "foo";

2041 }

2042 buildCounterQuestCriterion--;

2043 return o;

2044 }

2045

2046 checkQuestCriterion(api.QuestCriterion o) {

2047 buildCounterQuestCriterion++;

2048 if (buildCounterQuestCriterion < 3) {

2049 checkQuestContribution(o.completionContribution);

2050 checkQuestContribution(o.currentContribution);

2051 unittest.expect(o.eventId, unittest.equals('foo'));

2052 checkQuestContribution(o.initialPlayerProgress);

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

2054 }

2055 buildCounterQuestCriterion--;

2056 }

2057

2058 buildUnnamed46() {

2059 var o = new core.List<api.Quest>();

2060 o.add(buildQuest());

2061 o.add(buildQuest());

2062 return o;

2063 }

2064

2065 checkUnnamed46(core.List<api.Quest> o) {

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

2067 checkQuest(o[0]);

2068 checkQuest(o[1]);

2069 }

2070

2071 core.int buildCounterQuestListResponse = 0;

2072 buildQuestListResponse() {

2073 var o = new api.QuestListResponse();

2074 buildCounterQuestListResponse++;

2075 if (buildCounterQuestListResponse < 3) {

2076 o.items = buildUnnamed46();

2077 o.kind = "foo";

2078 o.nextPageToken = "foo";

2079 }

2080 buildCounterQuestListResponse--;

2081 return o;

2082 }

2083

2084 checkQuestListResponse(api.QuestListResponse o) {

2085 buildCounterQuestListResponse++;

2086 if (buildCounterQuestListResponse < 3) {

2087 checkUnnamed46(o.items);

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

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

2090 }

2091 buildCounterQuestListResponse--;

2092 }

2093

2094 buildUnnamed47() {

2095 var o = new core.List<api.QuestCriterion>();

2096 o.add(buildQuestCriterion());

2097 o.add(buildQuestCriterion());

2098 return o;

2099 }

2100

2101 checkUnnamed47(core.List<api.QuestCriterion> o) {

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

2103 checkQuestCriterion(o[0]);

2104 checkQuestCriterion(o[1]);

2105 }

2106

2107 core.int buildCounterQuestMilestone = 0;

2108 buildQuestMilestone() {

2109 var o = new api.QuestMilestone();

2110 buildCounterQuestMilestone++;

2111 if (buildCounterQuestMilestone < 3) {

2112 o.completionRewardData = "foo";

2113 o.criteria = buildUnnamed47();

2114 o.id = "foo";

2115 o.kind = "foo";

2116 o.state = "foo";

2117 }

2118 buildCounterQuestMilestone--;

2119 return o;

2120 }

2121

2122 checkQuestMilestone(api.QuestMilestone o) {

2123 buildCounterQuestMilestone++;

2124 if (buildCounterQuestMilestone < 3) {

2125 unittest.expect(o.completionRewardData, unittest.equals('foo'));

2126 checkUnnamed47(o.criteria);

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

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

2129 unittest.expect(o.state, unittest.equals('foo'));

2130 }

2131 buildCounterQuestMilestone--;

2132 }

2133

2134 core.int buildCounterRevisionCheckResponse = 0;

2135 buildRevisionCheckResponse() {

2136 var o = new api.RevisionCheckResponse();

2137 buildCounterRevisionCheckResponse++;

2138 if (buildCounterRevisionCheckResponse < 3) {

2139 o.apiVersion = "foo";

2140 o.kind = "foo";

2141 o.revisionStatus = "foo";

2142 }

2143 buildCounterRevisionCheckResponse--;

2144 return o;

2145 }

2146

2147 checkRevisionCheckResponse(api.RevisionCheckResponse o) {

2148 buildCounterRevisionCheckResponse++;

2149 if (buildCounterRevisionCheckResponse < 3) {

2150 unittest.expect(o.apiVersion, unittest.equals('foo'));

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

2152 unittest.expect(o.revisionStatus, unittest.equals('foo'));

2153 }

2154 buildCounterRevisionCheckResponse--;

2155 }

2156

2157 buildUnnamed48() {

2158 var o = new core.List<api.RoomParticipant>();

2159 o.add(buildRoomParticipant());

2160 o.add(buildRoomParticipant());

2161 return o;

2162 }

2163

2164 checkUnnamed48(core.List<api.RoomParticipant> o) {

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

2166 checkRoomParticipant(o[0]);

2167 checkRoomParticipant(o[1]);

2168 }

2169

2170 core.int buildCounterRoom = 0;

2171 buildRoom() {

2172 var o = new api.Room();

2173 buildCounterRoom++;

2174 if (buildCounterRoom < 3) {

2175 o.applicationId = "foo";

2176 o.autoMatchingCriteria = buildRoomAutoMatchingCriteria();

2177 o.autoMatchingStatus = buildRoomAutoMatchStatus();

2178 o.creationDetails = buildRoomModification();

2179 o.description = "foo";

2180 o.inviterId = "foo";

2181 o.kind = "foo";

2182 o.lastUpdateDetails = buildRoomModification();

2183 o.participants = buildUnnamed48();

2184 o.roomId = "foo";

2185 o.roomStatusVersion = 42;

2186 o.status = "foo";

2187 o.variant = 42;

2188 }

2189 buildCounterRoom--;

2190 return o;

2191 }

2192

2193 checkRoom(api.Room o) {

2194 buildCounterRoom++;

2195 if (buildCounterRoom < 3) {

2196 unittest.expect(o.applicationId, unittest.equals('foo'));

2197 checkRoomAutoMatchingCriteria(o.autoMatchingCriteria);

2198 checkRoomAutoMatchStatus(o.autoMatchingStatus);

2199 checkRoomModification(o.creationDetails);

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

2201 unittest.expect(o.inviterId, unittest.equals('foo'));

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

2203 checkRoomModification(o.lastUpdateDetails);

2204 checkUnnamed48(o.participants);

2205 unittest.expect(o.roomId, unittest.equals('foo'));

2206 unittest.expect(o.roomStatusVersion, unittest.equals(42));

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

2208 unittest.expect(o.variant, unittest.equals(42));

2209 }

2210 buildCounterRoom--;

2211 }

2212

2213 core.int buildCounterRoomAutoMatchStatus = 0;

2214 buildRoomAutoMatchStatus() {

2215 var o = new api.RoomAutoMatchStatus();

2216 buildCounterRoomAutoMatchStatus++;

2217 if (buildCounterRoomAutoMatchStatus < 3) {

2218 o.kind = "foo";

2219 o.waitEstimateSeconds = 42;

2220 }

2221 buildCounterRoomAutoMatchStatus--;

2222 return o;

2223 }

2224

2225 checkRoomAutoMatchStatus(api.RoomAutoMatchStatus o) {

2226 buildCounterRoomAutoMatchStatus++;

2227 if (buildCounterRoomAutoMatchStatus < 3) {

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

2229 unittest.expect(o.waitEstimateSeconds, unittest.equals(42));

2230 }

2231 buildCounterRoomAutoMatchStatus--;

2232 }

2233

2234 core.int buildCounterRoomAutoMatchingCriteria = 0;

2235 buildRoomAutoMatchingCriteria() {

2236 var o = new api.RoomAutoMatchingCriteria();

2237 buildCounterRoomAutoMatchingCriteria++;

2238 if (buildCounterRoomAutoMatchingCriteria < 3) {

2239 o.exclusiveBitmask = "foo";

2240 o.kind = "foo";

2241 o.maxAutoMatchingPlayers = 42;

2242 o.minAutoMatchingPlayers = 42;

2243 }

2244 buildCounterRoomAutoMatchingCriteria--;

2245 return o;

2246 }

2247

2248 checkRoomAutoMatchingCriteria(api.RoomAutoMatchingCriteria o) {

2249 buildCounterRoomAutoMatchingCriteria++;

2250 if (buildCounterRoomAutoMatchingCriteria < 3) {

2251 unittest.expect(o.exclusiveBitmask, unittest.equals('foo'));

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

2253 unittest.expect(o.maxAutoMatchingPlayers, unittest.equals(42));

2254 unittest.expect(o.minAutoMatchingPlayers, unittest.equals(42));

2255 }

2256 buildCounterRoomAutoMatchingCriteria--;

2257 }

2258

2259 core.int buildCounterRoomClientAddress = 0;

2260 buildRoomClientAddress() {

2261 var o = new api.RoomClientAddress();

2262 buildCounterRoomClientAddress++;

2263 if (buildCounterRoomClientAddress < 3) {

2264 o.kind = "foo";

2265 o.xmppAddress = "foo";

2266 }

2267 buildCounterRoomClientAddress--;

2268 return o;

2269 }

2270

2271 checkRoomClientAddress(api.RoomClientAddress o) {

2272 buildCounterRoomClientAddress++;

2273 if (buildCounterRoomClientAddress < 3) {

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

2275 unittest.expect(o.xmppAddress, unittest.equals('foo'));

2276 }

2277 buildCounterRoomClientAddress--;

2278 }

2279

2280 buildUnnamed49() {

2281 var o = new core.List<core.String>();

2282 o.add("foo");

2283 o.add("foo");

2284 return o;

2285 }

2286

2287 checkUnnamed49(core.List<core.String> o) {

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

2289 unittest.expect(o[0], unittest.equals('foo'));

2290 unittest.expect(o[1], unittest.equals('foo'));

2291 }

2292

2293 buildUnnamed50() {

2294 var o = new core.List<core.String>();

2295 o.add("foo");

2296 o.add("foo");

2297 return o;

2298 }

2299

2300 checkUnnamed50(core.List<core.String> o) {

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

2302 unittest.expect(o[0], unittest.equals('foo'));

2303 unittest.expect(o[1], unittest.equals('foo'));

2304 }

2305

2306 core.int buildCounterRoomCreateRequest = 0;

2307 buildRoomCreateRequest() {

2308 var o = new api.RoomCreateRequest();

2309 buildCounterRoomCreateRequest++;

2310 if (buildCounterRoomCreateRequest < 3) {

2311 o.autoMatchingCriteria = buildRoomAutoMatchingCriteria();

2312 o.capabilities = buildUnnamed49();

2313 o.clientAddress = buildRoomClientAddress();

2314 o.invitedPlayerIds = buildUnnamed50();

2315 o.kind = "foo";

2316 o.networkDiagnostics = buildNetworkDiagnostics();

2317 o.requestId = "foo";

2318 o.variant = 42;

2319 }

2320 buildCounterRoomCreateRequest--;

2321 return o;

2322 }

2323

2324 checkRoomCreateRequest(api.RoomCreateRequest o) {

2325 buildCounterRoomCreateRequest++;

2326 if (buildCounterRoomCreateRequest < 3) {

2327 checkRoomAutoMatchingCriteria(o.autoMatchingCriteria);

2328 checkUnnamed49(o.capabilities);

2329 checkRoomClientAddress(o.clientAddress);

2330 checkUnnamed50(o.invitedPlayerIds);

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

2332 checkNetworkDiagnostics(o.networkDiagnostics);

2333 unittest.expect(o.requestId, unittest.equals('foo'));

2334 unittest.expect(o.variant, unittest.equals(42));

2335 }

2336 buildCounterRoomCreateRequest--;

2337 }

2338

2339 buildUnnamed51() {

2340 var o = new core.List<core.String>();

2341 o.add("foo");

2342 o.add("foo");

2343 return o;

2344 }

2345

2346 checkUnnamed51(core.List<core.String> o) {

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

2348 unittest.expect(o[0], unittest.equals('foo'));

2349 unittest.expect(o[1], unittest.equals('foo'));

2350 }

2351

2352 core.int buildCounterRoomJoinRequest = 0;

2353 buildRoomJoinRequest() {

2354 var o = new api.RoomJoinRequest();

2355 buildCounterRoomJoinRequest++;

2356 if (buildCounterRoomJoinRequest < 3) {

2357 o.capabilities = buildUnnamed51();

2358 o.clientAddress = buildRoomClientAddress();

2359 o.kind = "foo";

2360 o.networkDiagnostics = buildNetworkDiagnostics();

2361 }

2362 buildCounterRoomJoinRequest--;

2363 return o;

2364 }

2365

2366 checkRoomJoinRequest(api.RoomJoinRequest o) {

2367 buildCounterRoomJoinRequest++;

2368 if (buildCounterRoomJoinRequest < 3) {

2369 checkUnnamed51(o.capabilities);

2370 checkRoomClientAddress(o.clientAddress);

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

2372 checkNetworkDiagnostics(o.networkDiagnostics);

2373 }

2374 buildCounterRoomJoinRequest--;

2375 }

2376

2377 buildUnnamed52() {

2378 var o = new core.List<api.PeerSessionDiagnostics>();

2379 o.add(buildPeerSessionDiagnostics());

2380 o.add(buildPeerSessionDiagnostics());

2381 return o;

2382 }

2383

2384 checkUnnamed52(core.List<api.PeerSessionDiagnostics> o) {

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

2386 checkPeerSessionDiagnostics(o[0]);

2387 checkPeerSessionDiagnostics(o[1]);

2388 }

2389

2390 core.int buildCounterRoomLeaveDiagnostics = 0;

2391 buildRoomLeaveDiagnostics() {

2392 var o = new api.RoomLeaveDiagnostics();

2393 buildCounterRoomLeaveDiagnostics++;

2394 if (buildCounterRoomLeaveDiagnostics < 3) {

2395 o.androidNetworkSubtype = 42;

2396 o.androidNetworkType = 42;

2397 o.iosNetworkType = 42;

2398 o.kind = "foo";

2399 o.networkOperatorCode = "foo";

2400 o.networkOperatorName = "foo";

2401 o.peerSession = buildUnnamed52();

2402 o.socketsUsed = true;

2403 }

2404 buildCounterRoomLeaveDiagnostics--;

2405 return o;

2406 }

2407

2408 checkRoomLeaveDiagnostics(api.RoomLeaveDiagnostics o) {

2409 buildCounterRoomLeaveDiagnostics++;

2410 if (buildCounterRoomLeaveDiagnostics < 3) {

2411 unittest.expect(o.androidNetworkSubtype, unittest.equals(42));

2412 unittest.expect(o.androidNetworkType, unittest.equals(42));

2413 unittest.expect(o.iosNetworkType, unittest.equals(42));

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

2415 unittest.expect(o.networkOperatorCode, unittest.equals('foo'));

2416 unittest.expect(o.networkOperatorName, unittest.equals('foo'));

2417 checkUnnamed52(o.peerSession);

2418 unittest.expect(o.socketsUsed, unittest.isTrue);

2419 }

2420 buildCounterRoomLeaveDiagnostics--;

2421 }

2422

2423 core.int buildCounterRoomLeaveRequest = 0;

2424 buildRoomLeaveRequest() {

2425 var o = new api.RoomLeaveRequest();

2426 buildCounterRoomLeaveRequest++;

2427 if (buildCounterRoomLeaveRequest < 3) {

2428 o.kind = "foo";

2429 o.leaveDiagnostics = buildRoomLeaveDiagnostics();

2430 o.reason = "foo";

2431 }

2432 buildCounterRoomLeaveRequest--;

2433 return o;

2434 }

2435

2436 checkRoomLeaveRequest(api.RoomLeaveRequest o) {

2437 buildCounterRoomLeaveRequest++;

2438 if (buildCounterRoomLeaveRequest < 3) {

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

2440 checkRoomLeaveDiagnostics(o.leaveDiagnostics);

2441 unittest.expect(o.reason, unittest.equals('foo'));

2442 }

2443 buildCounterRoomLeaveRequest--;

2444 }

2445

2446 buildUnnamed53() {

2447 var o = new core.List<api.Room>();

2448 o.add(buildRoom());

2449 o.add(buildRoom());

2450 return o;

2451 }

2452

2453 checkUnnamed53(core.List<api.Room> o) {

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

2455 checkRoom(o[0]);

2456 checkRoom(o[1]);

2457 }

2458

2459 core.int buildCounterRoomList = 0;

2460 buildRoomList() {

2461 var o = new api.RoomList();

2462 buildCounterRoomList++;

2463 if (buildCounterRoomList < 3) {

2464 o.items = buildUnnamed53();

2465 o.kind = "foo";

2466 o.nextPageToken = "foo";

2467 }

2468 buildCounterRoomList--;

2469 return o;

2470 }

2471

2472 checkRoomList(api.RoomList o) {

2473 buildCounterRoomList++;

2474 if (buildCounterRoomList < 3) {

2475 checkUnnamed53(o.items);

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

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

2478 }

2479 buildCounterRoomList--;

2480 }

2481

2482 core.int buildCounterRoomModification = 0;

2483 buildRoomModification() {

2484 var o = new api.RoomModification();

2485 buildCounterRoomModification++;

2486 if (buildCounterRoomModification < 3) {

2487 o.kind = "foo";

2488 o.modifiedTimestampMillis = "foo";

2489 o.participantId = "foo";

2490 }

2491 buildCounterRoomModification--;

2492 return o;

2493 }

2494

2495 checkRoomModification(api.RoomModification o) {

2496 buildCounterRoomModification++;

2497 if (buildCounterRoomModification < 3) {

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

2499 unittest.expect(o.modifiedTimestampMillis, unittest.equals('foo'));

2500 unittest.expect(o.participantId, unittest.equals('foo'));

2501 }

2502 buildCounterRoomModification--;

2503 }

2504

2505 core.int buildCounterRoomP2PStatus = 0;

2506 buildRoomP2PStatus() {

2507 var o = new api.RoomP2PStatus();

2508 buildCounterRoomP2PStatus++;

2509 if (buildCounterRoomP2PStatus < 3) {

2510 o.connectionSetupLatencyMillis = 42;

2511 o.error = "foo";

2512 o.errorReason = "foo";

2513 o.kind = "foo";

2514 o.participantId = "foo";

2515 o.status = "foo";

2516 o.unreliableRoundtripLatencyMillis = 42;

2517 }

2518 buildCounterRoomP2PStatus--;

2519 return o;

2520 }

2521

2522 checkRoomP2PStatus(api.RoomP2PStatus o) {

2523 buildCounterRoomP2PStatus++;

2524 if (buildCounterRoomP2PStatus < 3) {

2525 unittest.expect(o.connectionSetupLatencyMillis, unittest.equals(42));

2526 unittest.expect(o.error, unittest.equals('foo'));

2527 unittest.expect(o.errorReason, unittest.equals('foo'));

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

2529 unittest.expect(o.participantId, unittest.equals('foo'));

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

2531 unittest.expect(o.unreliableRoundtripLatencyMillis, unittest.equals(42));

2532 }

2533 buildCounterRoomP2PStatus--;

2534 }

2535

2536 buildUnnamed54() {

2537 var o = new core.List<api.RoomP2PStatus>();

2538 o.add(buildRoomP2PStatus());

2539 o.add(buildRoomP2PStatus());

2540 return o;

2541 }

2542

2543 checkUnnamed54(core.List<api.RoomP2PStatus> o) {

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

2545 checkRoomP2PStatus(o[0]);

2546 checkRoomP2PStatus(o[1]);

2547 }

2548

2549 core.int buildCounterRoomP2PStatuses = 0;

2550 buildRoomP2PStatuses() {

2551 var o = new api.RoomP2PStatuses();

2552 buildCounterRoomP2PStatuses++;

2553 if (buildCounterRoomP2PStatuses < 3) {

2554 o.kind = "foo";

2555 o.updates = buildUnnamed54();

2556 }

2557 buildCounterRoomP2PStatuses--;

2558 return o;

2559 }

2560

2561 checkRoomP2PStatuses(api.RoomP2PStatuses o) {

2562 buildCounterRoomP2PStatuses++;

2563 if (buildCounterRoomP2PStatuses < 3) {

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

2565 checkUnnamed54(o.updates);

2566 }

2567 buildCounterRoomP2PStatuses--;

2568 }

2569

2570 buildUnnamed55() {

2571 var o = new core.List<core.String>();

2572 o.add("foo");

2573 o.add("foo");

2574 return o;

2575 }

2576

2577 checkUnnamed55(core.List<core.String> o) {

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

2579 unittest.expect(o[0], unittest.equals('foo'));

2580 unittest.expect(o[1], unittest.equals('foo'));

2581 }

2582

2583 core.int buildCounterRoomParticipant = 0;

2584 buildRoomParticipant() {

2585 var o = new api.RoomParticipant();

2586 buildCounterRoomParticipant++;

2587 if (buildCounterRoomParticipant < 3) {

2588 o.autoMatched = true;

2589 o.autoMatchedPlayer = buildAnonymousPlayer();

2590 o.capabilities = buildUnnamed55();

2591 o.clientAddress = buildRoomClientAddress();

2592 o.connected = true;

2593 o.id = "foo";

2594 o.kind = "foo";

2595 o.leaveReason = "foo";

2596 o.player = buildPlayer();

2597 o.status = "foo";

2598 }

2599 buildCounterRoomParticipant--;

2600 return o;

2601 }

2602

2603 checkRoomParticipant(api.RoomParticipant o) {

2604 buildCounterRoomParticipant++;

2605 if (buildCounterRoomParticipant < 3) {

2606 unittest.expect(o.autoMatched, unittest.isTrue);

2607 checkAnonymousPlayer(o.autoMatchedPlayer);

2608 checkUnnamed55(o.capabilities);

2609 checkRoomClientAddress(o.clientAddress);

2610 unittest.expect(o.connected, unittest.isTrue);

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

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

2613 unittest.expect(o.leaveReason, unittest.equals('foo'));

2614 checkPlayer(o.player);

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

2616 }

2617 buildCounterRoomParticipant--;

2618 }

2619

2620 buildUnnamed56() {

2621 var o = new core.List<api.RoomParticipant>();

2622 o.add(buildRoomParticipant());

2623 o.add(buildRoomParticipant());

2624 return o;

2625 }

2626

2627 checkUnnamed56(core.List<api.RoomParticipant> o) {

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

2629 checkRoomParticipant(o[0]);

2630 checkRoomParticipant(o[1]);

2631 }

2632

2633 core.int buildCounterRoomStatus = 0;

2634 buildRoomStatus() {

2635 var o = new api.RoomStatus();

2636 buildCounterRoomStatus++;

2637 if (buildCounterRoomStatus < 3) {

2638 o.autoMatchingStatus = buildRoomAutoMatchStatus();

2639 o.kind = "foo";

2640 o.participants = buildUnnamed56();

2641 o.roomId = "foo";

2642 o.status = "foo";

2643 o.statusVersion = 42;

2644 }

2645 buildCounterRoomStatus--;

2646 return o;

2647 }

2648

2649 checkRoomStatus(api.RoomStatus o) {

2650 buildCounterRoomStatus++;

2651 if (buildCounterRoomStatus < 3) {

2652 checkRoomAutoMatchStatus(o.autoMatchingStatus);

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

2654 checkUnnamed56(o.participants);

2655 unittest.expect(o.roomId, unittest.equals('foo'));

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

2657 unittest.expect(o.statusVersion, unittest.equals(42));

2658 }

2659 buildCounterRoomStatus--;

2660 }

2661

2662 core.int buildCounterScoreSubmission = 0;

2663 buildScoreSubmission() {

2664 var o = new api.ScoreSubmission();

2665 buildCounterScoreSubmission++;

2666 if (buildCounterScoreSubmission < 3) {

2667 o.kind = "foo";

2668 o.leaderboardId = "foo";

2669 o.score = "foo";

2670 o.scoreTag = "foo";

2671 o.signature = "foo";

2672 }

2673 buildCounterScoreSubmission--;

2674 return o;

2675 }

2676

2677 checkScoreSubmission(api.ScoreSubmission o) {

2678 buildCounterScoreSubmission++;

2679 if (buildCounterScoreSubmission < 3) {

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

2681 unittest.expect(o.leaderboardId, unittest.equals('foo'));

2682 unittest.expect(o.score, unittest.equals('foo'));

2683 unittest.expect(o.scoreTag, unittest.equals('foo'));

2684 unittest.expect(o.signature, unittest.equals('foo'));

2685 }

2686 buildCounterScoreSubmission--;

2687 }

2688

2689 core.int buildCounterSnapshot = 0;

2690 buildSnapshot() {

2691 var o = new api.Snapshot();

2692 buildCounterSnapshot++;

2693 if (buildCounterSnapshot < 3) {

2694 o.coverImage = buildSnapshotImage();

2695 o.description = "foo";

2696 o.driveId = "foo";

2697 o.durationMillis = "foo";

2698 o.id = "foo";

2699 o.kind = "foo";

2700 o.lastModifiedMillis = "foo";

2701 o.title = "foo";

2702 o.type = "foo";

2703 o.uniqueName = "foo";

2704 }

2705 buildCounterSnapshot--;

2706 return o;

2707 }

2708

2709 checkSnapshot(api.Snapshot o) {

2710 buildCounterSnapshot++;

2711 if (buildCounterSnapshot < 3) {

2712 checkSnapshotImage(o.coverImage);

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

2714 unittest.expect(o.driveId, unittest.equals('foo'));

2715 unittest.expect(o.durationMillis, unittest.equals('foo'));

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

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

2718 unittest.expect(o.lastModifiedMillis, unittest.equals('foo'));

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

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

2721 unittest.expect(o.uniqueName, unittest.equals('foo'));

2722 }

2723 buildCounterSnapshot--;

2724 }

2725

2726 core.int buildCounterSnapshotImage = 0;

2727 buildSnapshotImage() {

2728 var o = new api.SnapshotImage();

2729 buildCounterSnapshotImage++;

2730 if (buildCounterSnapshotImage < 3) {

2731 o.height = 42;

2732 o.kind = "foo";

2733 o.mimeType = "foo";

2734 o.url = "foo";

2735 o.width = 42;

2736 }

2737 buildCounterSnapshotImage--;

2738 return o;

2739 }

2740

2741 checkSnapshotImage(api.SnapshotImage o) {

2742 buildCounterSnapshotImage++;

2743 if (buildCounterSnapshotImage < 3) {

2744 unittest.expect(o.height, unittest.equals(42));

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

2746 unittest.expect(o.mimeType, unittest.equals('foo'));

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

2748 unittest.expect(o.width, unittest.equals(42));

2749 }

2750 buildCounterSnapshotImage--;

2751 }

2752

2753 buildUnnamed57() {

2754 var o = new core.List<api.Snapshot>();

2755 o.add(buildSnapshot());

2756 o.add(buildSnapshot());

2757 return o;

2758 }

2759

2760 checkUnnamed57(core.List<api.Snapshot> o) {

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

2762 checkSnapshot(o[0]);

2763 checkSnapshot(o[1]);

2764 }

2765

2766 core.int buildCounterSnapshotListResponse = 0;

2767 buildSnapshotListResponse() {

2768 var o = new api.SnapshotListResponse();

2769 buildCounterSnapshotListResponse++;

2770 if (buildCounterSnapshotListResponse < 3) {

2771 o.items = buildUnnamed57();

2772 o.kind = "foo";

2773 o.nextPageToken = "foo";

2774 }

2775 buildCounterSnapshotListResponse--;

2776 return o;

2777 }

2778

2779 checkSnapshotListResponse(api.SnapshotListResponse o) {

2780 buildCounterSnapshotListResponse++;

2781 if (buildCounterSnapshotListResponse < 3) {

2782 checkUnnamed57(o.items);

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

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

2785 }

2786 buildCounterSnapshotListResponse--;

2787 }

2788

2789 core.int buildCounterTurnBasedAutoMatchingCriteria = 0;

2790 buildTurnBasedAutoMatchingCriteria() {

2791 var o = new api.TurnBasedAutoMatchingCriteria();

2792 buildCounterTurnBasedAutoMatchingCriteria++;

2793 if (buildCounterTurnBasedAutoMatchingCriteria < 3) {

2794 o.exclusiveBitmask = "foo";

2795 o.kind = "foo";

2796 o.maxAutoMatchingPlayers = 42;

2797 o.minAutoMatchingPlayers = 42;

2798 }

2799 buildCounterTurnBasedAutoMatchingCriteria--;

2800 return o;

2801 }

2802

2803 checkTurnBasedAutoMatchingCriteria(api.TurnBasedAutoMatchingCriteria o) {

2804 buildCounterTurnBasedAutoMatchingCriteria++;

2805 if (buildCounterTurnBasedAutoMatchingCriteria < 3) {

2806 unittest.expect(o.exclusiveBitmask, unittest.equals('foo'));

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

2808 unittest.expect(o.maxAutoMatchingPlayers, unittest.equals(42));

2809 unittest.expect(o.minAutoMatchingPlayers, unittest.equals(42));

2810 }

2811 buildCounterTurnBasedAutoMatchingCriteria--;

2812 }

2813

2814 buildUnnamed58() {

2815 var o = new core.List<api.TurnBasedMatchParticipant>();

2816 o.add(buildTurnBasedMatchParticipant());

2817 o.add(buildTurnBasedMatchParticipant());

2818 return o;

2819 }

2820

2821 checkUnnamed58(core.List<api.TurnBasedMatchParticipant> o) {

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

2823 checkTurnBasedMatchParticipant(o[0]);

2824 checkTurnBasedMatchParticipant(o[1]);

2825 }

2826

2827 buildUnnamed59() {

2828 var o = new core.List<api.ParticipantResult>();

2829 o.add(buildParticipantResult());

2830 o.add(buildParticipantResult());

2831 return o;

2832 }

2833

2834 checkUnnamed59(core.List<api.ParticipantResult> o) {

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

2836 checkParticipantResult(o[0]);

2837 checkParticipantResult(o[1]);

2838 }

2839

2840 core.int buildCounterTurnBasedMatch = 0;

2841 buildTurnBasedMatch() {

2842 var o = new api.TurnBasedMatch();

2843 buildCounterTurnBasedMatch++;

2844 if (buildCounterTurnBasedMatch < 3) {

2845 o.applicationId = "foo";

2846 o.autoMatchingCriteria = buildTurnBasedAutoMatchingCriteria();

2847 o.creationDetails = buildTurnBasedMatchModification();

2848 o.data = buildTurnBasedMatchData();

2849 o.description = "foo";

2850 o.inviterId = "foo";

2851 o.kind = "foo";

2852 o.lastUpdateDetails = buildTurnBasedMatchModification();

2853 o.matchId = "foo";

2854 o.matchNumber = 42;

2855 o.matchVersion = 42;

2856 o.participants = buildUnnamed58();

2857 o.pendingParticipantId = "foo";

2858 o.previousMatchData = buildTurnBasedMatchData();

2859 o.rematchId = "foo";

2860 o.results = buildUnnamed59();

2861 o.status = "foo";

2862 o.userMatchStatus = "foo";

2863 o.variant = 42;

2864 o.withParticipantId = "foo";

2865 }

2866 buildCounterTurnBasedMatch--;

2867 return o;

2868 }

2869

2870 checkTurnBasedMatch(api.TurnBasedMatch o) {

2871 buildCounterTurnBasedMatch++;

2872 if (buildCounterTurnBasedMatch < 3) {

2873 unittest.expect(o.applicationId, unittest.equals('foo'));

2874 checkTurnBasedAutoMatchingCriteria(o.autoMatchingCriteria);

2875 checkTurnBasedMatchModification(o.creationDetails);

2876 checkTurnBasedMatchData(o.data);

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

2878 unittest.expect(o.inviterId, unittest.equals('foo'));

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

2880 checkTurnBasedMatchModification(o.lastUpdateDetails);

2881 unittest.expect(o.matchId, unittest.equals('foo'));

2882 unittest.expect(o.matchNumber, unittest.equals(42));

2883 unittest.expect(o.matchVersion, unittest.equals(42));

2884 checkUnnamed58(o.participants);

2885 unittest.expect(o.pendingParticipantId, unittest.equals('foo'));

2886 checkTurnBasedMatchData(o.previousMatchData);

2887 unittest.expect(o.rematchId, unittest.equals('foo'));

2888 checkUnnamed59(o.results);

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

2890 unittest.expect(o.userMatchStatus, unittest.equals('foo'));

2891 unittest.expect(o.variant, unittest.equals(42));

2892 unittest.expect(o.withParticipantId, unittest.equals('foo'));

2893 }

2894 buildCounterTurnBasedMatch--;

2895 }

2896

2897 buildUnnamed60() {

2898 var o = new core.List<core.String>();

2899 o.add("foo");

2900 o.add("foo");

2901 return o;

2902 }

2903

2904 checkUnnamed60(core.List<core.String> o) {

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

2906 unittest.expect(o[0], unittest.equals('foo'));

2907 unittest.expect(o[1], unittest.equals('foo'));

2908 }

2909

2910 core.int buildCounterTurnBasedMatchCreateRequest = 0;

2911 buildTurnBasedMatchCreateRequest() {

2912 var o = new api.TurnBasedMatchCreateRequest();

2913 buildCounterTurnBasedMatchCreateRequest++;

2914 if (buildCounterTurnBasedMatchCreateRequest < 3) {

2915 o.autoMatchingCriteria = buildTurnBasedAutoMatchingCriteria();

2916 o.invitedPlayerIds = buildUnnamed60();

2917 o.kind = "foo";

2918 o.requestId = "foo";

2919 o.variant = 42;

2920 }

2921 buildCounterTurnBasedMatchCreateRequest--;

2922 return o;

2923 }

2924

2925 checkTurnBasedMatchCreateRequest(api.TurnBasedMatchCreateRequest o) {

2926 buildCounterTurnBasedMatchCreateRequest++;

2927 if (buildCounterTurnBasedMatchCreateRequest < 3) {

2928 checkTurnBasedAutoMatchingCriteria(o.autoMatchingCriteria);

2929 checkUnnamed60(o.invitedPlayerIds);

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

2931 unittest.expect(o.requestId, unittest.equals('foo'));

2932 unittest.expect(o.variant, unittest.equals(42));

2933 }

2934 buildCounterTurnBasedMatchCreateRequest--;

2935 }

2936

2937 core.int buildCounterTurnBasedMatchData = 0;

2938 buildTurnBasedMatchData() {

2939 var o = new api.TurnBasedMatchData();

2940 buildCounterTurnBasedMatchData++;

2941 if (buildCounterTurnBasedMatchData < 3) {

2942 o.data = "foo";

2943 o.dataAvailable = true;

2944 o.kind = "foo";

2945 }

2946 buildCounterTurnBasedMatchData--;

2947 return o;

2948 }

2949

2950 checkTurnBasedMatchData(api.TurnBasedMatchData o) {

2951 buildCounterTurnBasedMatchData++;

2952 if (buildCounterTurnBasedMatchData < 3) {

2953 unittest.expect(o.data, unittest.equals('foo'));

2954 unittest.expect(o.dataAvailable, unittest.isTrue);

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

2956 }

2957 buildCounterTurnBasedMatchData--;

2958 }

2959

2960 core.int buildCounterTurnBasedMatchDataRequest = 0;

2961 buildTurnBasedMatchDataRequest() {

2962 var o = new api.TurnBasedMatchDataRequest();

2963 buildCounterTurnBasedMatchDataRequest++;

2964 if (buildCounterTurnBasedMatchDataRequest < 3) {

2965 o.data = "foo";

2966 o.kind = "foo";

2967 }

2968 buildCounterTurnBasedMatchDataRequest--;

2969 return o;

2970 }

2971

2972 checkTurnBasedMatchDataRequest(api.TurnBasedMatchDataRequest o) {

2973 buildCounterTurnBasedMatchDataRequest++;

2974 if (buildCounterTurnBasedMatchDataRequest < 3) {

2975 unittest.expect(o.data, unittest.equals('foo'));

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

2977 }

2978 buildCounterTurnBasedMatchDataRequest--;

2979 }

2980

2981 buildUnnamed61() {

2982 var o = new core.List<api.TurnBasedMatch>();

2983 o.add(buildTurnBasedMatch());

2984 o.add(buildTurnBasedMatch());

2985 return o;

2986 }

2987

2988 checkUnnamed61(core.List<api.TurnBasedMatch> o) {

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

2990 checkTurnBasedMatch(o[0]);

2991 checkTurnBasedMatch(o[1]);

2992 }

2993

2994 core.int buildCounterTurnBasedMatchList = 0;

2995 buildTurnBasedMatchList() {

2996 var o = new api.TurnBasedMatchList();

2997 buildCounterTurnBasedMatchList++;

2998 if (buildCounterTurnBasedMatchList < 3) {

2999 o.items = buildUnnamed61();

3000 o.kind = "foo";

3001 o.nextPageToken = "foo";

3002 }

3003 buildCounterTurnBasedMatchList--;

3004 return o;

3005 }

3006

3007 checkTurnBasedMatchList(api.TurnBasedMatchList o) {

3008 buildCounterTurnBasedMatchList++;

3009 if (buildCounterTurnBasedMatchList < 3) {

3010 checkUnnamed61(o.items);

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

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

3013 }

3014 buildCounterTurnBasedMatchList--;

3015 }

3016

3017 core.int buildCounterTurnBasedMatchModification = 0;

3018 buildTurnBasedMatchModification() {

3019 var o = new api.TurnBasedMatchModification();

3020 buildCounterTurnBasedMatchModification++;

3021 if (buildCounterTurnBasedMatchModification < 3) {

3022 o.kind = "foo";

3023 o.modifiedTimestampMillis = "foo";

3024 o.participantId = "foo";

3025 }

3026 buildCounterTurnBasedMatchModification--;

3027 return o;

3028 }

3029

3030 checkTurnBasedMatchModification(api.TurnBasedMatchModification o) {

3031 buildCounterTurnBasedMatchModification++;

3032 if (buildCounterTurnBasedMatchModification < 3) {

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

3034 unittest.expect(o.modifiedTimestampMillis, unittest.equals('foo'));

3035 unittest.expect(o.participantId, unittest.equals('foo'));

3036 }

3037 buildCounterTurnBasedMatchModification--;

3038 }

3039

3040 core.int buildCounterTurnBasedMatchParticipant = 0;

3041 buildTurnBasedMatchParticipant() {

3042 var o = new api.TurnBasedMatchParticipant();

3043 buildCounterTurnBasedMatchParticipant++;

3044 if (buildCounterTurnBasedMatchParticipant < 3) {

3045 o.autoMatched = true;

3046 o.autoMatchedPlayer = buildAnonymousPlayer();

3047 o.id = "foo";

3048 o.kind = "foo";

3049 o.player = buildPlayer();

3050 o.status = "foo";

3051 }

3052 buildCounterTurnBasedMatchParticipant--;

3053 return o;

3054 }

3055

3056 checkTurnBasedMatchParticipant(api.TurnBasedMatchParticipant o) {

3057 buildCounterTurnBasedMatchParticipant++;

3058 if (buildCounterTurnBasedMatchParticipant < 3) {

3059 unittest.expect(o.autoMatched, unittest.isTrue);

3060 checkAnonymousPlayer(o.autoMatchedPlayer);

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

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

3063 checkPlayer(o.player);

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

3065 }

3066 buildCounterTurnBasedMatchParticipant--;

3067 }

3068

3069 core.int buildCounterTurnBasedMatchRematch = 0;

3070 buildTurnBasedMatchRematch() {

3071 var o = new api.TurnBasedMatchRematch();

3072 buildCounterTurnBasedMatchRematch++;

3073 if (buildCounterTurnBasedMatchRematch < 3) {

3074 o.kind = "foo";

3075 o.previousMatch = buildTurnBasedMatch();

3076 o.rematch = buildTurnBasedMatch();

3077 }

3078 buildCounterTurnBasedMatchRematch--;

3079 return o;

3080 }

3081

3082 checkTurnBasedMatchRematch(api.TurnBasedMatchRematch o) {

3083 buildCounterTurnBasedMatchRematch++;

3084 if (buildCounterTurnBasedMatchRematch < 3) {

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

3086 checkTurnBasedMatch(o.previousMatch);

3087 checkTurnBasedMatch(o.rematch);

3088 }

3089 buildCounterTurnBasedMatchRematch--;

3090 }

3091

3092 buildUnnamed62() {

3093 var o = new core.List<api.ParticipantResult>();

3094 o.add(buildParticipantResult());

3095 o.add(buildParticipantResult());

3096 return o;

3097 }

3098

3099 checkUnnamed62(core.List<api.ParticipantResult> o) {

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

3101 checkParticipantResult(o[0]);

3102 checkParticipantResult(o[1]);

3103 }

3104

3105 core.int buildCounterTurnBasedMatchResults = 0;

3106 buildTurnBasedMatchResults() {

3107 var o = new api.TurnBasedMatchResults();

3108 buildCounterTurnBasedMatchResults++;

3109 if (buildCounterTurnBasedMatchResults < 3) {

3110 o.data = buildTurnBasedMatchDataRequest();

3111 o.kind = "foo";

3112 o.matchVersion = 42;

3113 o.results = buildUnnamed62();

3114 }

3115 buildCounterTurnBasedMatchResults--;

3116 return o;

3117 }

3118

3119 checkTurnBasedMatchResults(api.TurnBasedMatchResults o) {

3120 buildCounterTurnBasedMatchResults++;

3121 if (buildCounterTurnBasedMatchResults < 3) {

3122 checkTurnBasedMatchDataRequest(o.data);

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

3124 unittest.expect(o.matchVersion, unittest.equals(42));

3125 checkUnnamed62(o.results);

3126 }

3127 buildCounterTurnBasedMatchResults--;

3128 }

3129

3130 buildUnnamed63() {

3131 var o = new core.List<api.TurnBasedMatch>();

3132 o.add(buildTurnBasedMatch());

3133 o.add(buildTurnBasedMatch());

3134 return o;

3135 }

3136

3137 checkUnnamed63(core.List<api.TurnBasedMatch> o) {

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

3139 checkTurnBasedMatch(o[0]);

3140 checkTurnBasedMatch(o[1]);

3141 }

3142

3143 core.int buildCounterTurnBasedMatchSync = 0;

3144 buildTurnBasedMatchSync() {

3145 var o = new api.TurnBasedMatchSync();

3146 buildCounterTurnBasedMatchSync++;

3147 if (buildCounterTurnBasedMatchSync < 3) {

3148 o.items = buildUnnamed63();

3149 o.kind = "foo";

3150 o.moreAvailable = true;

3151 o.nextPageToken = "foo";

3152 }

3153 buildCounterTurnBasedMatchSync--;

3154 return o;

3155 }

3156

3157 checkTurnBasedMatchSync(api.TurnBasedMatchSync o) {

3158 buildCounterTurnBasedMatchSync++;

3159 if (buildCounterTurnBasedMatchSync < 3) {

3160 checkUnnamed63(o.items);

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

3162 unittest.expect(o.moreAvailable, unittest.isTrue);

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

3164 }

3165 buildCounterTurnBasedMatchSync--;

3166 }

3167

3168 buildUnnamed64() {

3169 var o = new core.List<api.ParticipantResult>();

3170 o.add(buildParticipantResult());

3171 o.add(buildParticipantResult());

3172 return o;

3173 }

3174

3175 checkUnnamed64(core.List<api.ParticipantResult> o) {

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

3177 checkParticipantResult(o[0]);

3178 checkParticipantResult(o[1]);

3179 }

3180

3181 core.int buildCounterTurnBasedMatchTurn = 0;

3182 buildTurnBasedMatchTurn() {

3183 var o = new api.TurnBasedMatchTurn();

3184 buildCounterTurnBasedMatchTurn++;

3185 if (buildCounterTurnBasedMatchTurn < 3) {

3186 o.data = buildTurnBasedMatchDataRequest();

3187 o.kind = "foo";

3188 o.matchVersion = 42;

3189 o.pendingParticipantId = "foo";

3190 o.results = buildUnnamed64();

3191 }

3192 buildCounterTurnBasedMatchTurn--;

3193 return o;

3194 }

3195

3196 checkTurnBasedMatchTurn(api.TurnBasedMatchTurn o) {

3197 buildCounterTurnBasedMatchTurn++;

3198 if (buildCounterTurnBasedMatchTurn < 3) {

3199 checkTurnBasedMatchDataRequest(o.data);

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

3201 unittest.expect(o.matchVersion, unittest.equals(42));

3202 unittest.expect(o.pendingParticipantId, unittest.equals('foo'));

3203 checkUnnamed64(o.results);

3204 }

3205 buildCounterTurnBasedMatchTurn--;

3206 }

3207

3208

3209 main() {

3210 unittest.group("obj-schema-AchievementDefinition", () {

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

3212 var o = buildAchievementDefinition();

3213 var od = new api.AchievementDefinition.fromJson(o.toJson());

3214 checkAchievementDefinition(od);

3215 });

3216 });

3217

3218

3219 unittest.group("obj-schema-AchievementDefinitionsListResponse", () {

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

3221 var o = buildAchievementDefinitionsListResponse();

3222 var od = new api.AchievementDefinitionsListResponse.fromJson(o.toJson());

3223 checkAchievementDefinitionsListResponse(od);

3224 });

3225 });

3226

3227

3228 unittest.group("obj-schema-AchievementIncrementResponse", () {

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

3230 var o = buildAchievementIncrementResponse();

3231 var od = new api.AchievementIncrementResponse.fromJson(o.toJson());

3232 checkAchievementIncrementResponse(od);

3233 });

3234 });

3235

3236

3237 unittest.group("obj-schema-AchievementRevealResponse", () {

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

3239 var o = buildAchievementRevealResponse();

3240 var od = new api.AchievementRevealResponse.fromJson(o.toJson());

3241 checkAchievementRevealResponse(od);

3242 });

3243 });

3244

3245

3246 unittest.group("obj-schema-AchievementSetStepsAtLeastResponse", () {

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

3248 var o = buildAchievementSetStepsAtLeastResponse();

3249 var od = new api.AchievementSetStepsAtLeastResponse.fromJson(o.toJson());

3250 checkAchievementSetStepsAtLeastResponse(od);

3251 });

3252 });

3253

3254

3255 unittest.group("obj-schema-AchievementUnlockResponse", () {

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

3257 var o = buildAchievementUnlockResponse();

3258 var od = new api.AchievementUnlockResponse.fromJson(o.toJson());

3259 checkAchievementUnlockResponse(od);

3260 });

3261 });

3262

3263

3264 unittest.group("obj-schema-AchievementUpdateMultipleRequest", () {

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

3266 var o = buildAchievementUpdateMultipleRequest();

3267 var od = new api.AchievementUpdateMultipleRequest.fromJson(o.toJson());

3268 checkAchievementUpdateMultipleRequest(od);

3269 });

3270 });

3271

3272

3273 unittest.group("obj-schema-AchievementUpdateMultipleResponse", () {

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

3275 var o = buildAchievementUpdateMultipleResponse();

3276 var od = new api.AchievementUpdateMultipleResponse.fromJson(o.toJson());

3277 checkAchievementUpdateMultipleResponse(od);

3278 });

3279 });

3280

3281

3282 unittest.group("obj-schema-AchievementUpdateRequest", () {

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

3284 var o = buildAchievementUpdateRequest();

3285 var od = new api.AchievementUpdateRequest.fromJson(o.toJson());

3286 checkAchievementUpdateRequest(od);

3287 });

3288 });

3289

3290

3291 unittest.group("obj-schema-AchievementUpdateResponse", () {

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

3293 var o = buildAchievementUpdateResponse();

3294 var od = new api.AchievementUpdateResponse.fromJson(o.toJson());

3295 checkAchievementUpdateResponse(od);

3296 });

3297 });

3298

3299

3300 unittest.group("obj-schema-AggregateStats", () {

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

3302 var o = buildAggregateStats();

3303 var od = new api.AggregateStats.fromJson(o.toJson());

3304 checkAggregateStats(od);

3305 });

3306 });

3307

3308

3309 unittest.group("obj-schema-AnonymousPlayer", () {

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

3311 var o = buildAnonymousPlayer();

3312 var od = new api.AnonymousPlayer.fromJson(o.toJson());

3313 checkAnonymousPlayer(od);

3314 });

3315 });

3316

3317

3318 unittest.group("obj-schema-Application", () {

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

3320 var o = buildApplication();

3321 var od = new api.Application.fromJson(o.toJson());

3322 checkApplication(od);

3323 });

3324 });

3325

3326

3327 unittest.group("obj-schema-ApplicationCategory", () {

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

3329 var o = buildApplicationCategory();

3330 var od = new api.ApplicationCategory.fromJson(o.toJson());

3331 checkApplicationCategory(od);

3332 });

3333 });

3334

3335

3336 unittest.group("obj-schema-Category", () {

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

3338 var o = buildCategory();

3339 var od = new api.Category.fromJson(o.toJson());

3340 checkCategory(od);

3341 });

3342 });

3343

3344

3345 unittest.group("obj-schema-CategoryListResponse", () {

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

3347 var o = buildCategoryListResponse();

3348 var od = new api.CategoryListResponse.fromJson(o.toJson());

3349 checkCategoryListResponse(od);

3350 });

3351 });

3352

3353

3354 unittest.group("obj-schema-EventBatchRecordFailure", () {

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

3356 var o = buildEventBatchRecordFailure();

3357 var od = new api.EventBatchRecordFailure.fromJson(o.toJson());

3358 checkEventBatchRecordFailure(od);

3359 });

3360 });

3361

3362

3363 unittest.group("obj-schema-EventChild", () {

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

3365 var o = buildEventChild();

3366 var od = new api.EventChild.fromJson(o.toJson());

3367 checkEventChild(od);

3368 });

3369 });

3370

3371

3372 unittest.group("obj-schema-EventDefinition", () {

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

3374 var o = buildEventDefinition();

3375 var od = new api.EventDefinition.fromJson(o.toJson());

3376 checkEventDefinition(od);

3377 });

3378 });

3379

3380

3381 unittest.group("obj-schema-EventDefinitionListResponse", () {

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

3383 var o = buildEventDefinitionListResponse();

3384 var od = new api.EventDefinitionListResponse.fromJson(o.toJson());

3385 checkEventDefinitionListResponse(od);

3386 });

3387 });

3388

3389

3390 unittest.group("obj-schema-EventPeriodRange", () {

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

3392 var o = buildEventPeriodRange();

3393 var od = new api.EventPeriodRange.fromJson(o.toJson());

3394 checkEventPeriodRange(od);

3395 });

3396 });

3397

3398

3399 unittest.group("obj-schema-EventPeriodUpdate", () {

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

3401 var o = buildEventPeriodUpdate();

3402 var od = new api.EventPeriodUpdate.fromJson(o.toJson());

3403 checkEventPeriodUpdate(od);

3404 });

3405 });

3406

3407

3408 unittest.group("obj-schema-EventRecordFailure", () {

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

3410 var o = buildEventRecordFailure();

3411 var od = new api.EventRecordFailure.fromJson(o.toJson());

3412 checkEventRecordFailure(od);

3413 });

3414 });

3415

3416

3417 unittest.group("obj-schema-EventRecordRequest", () {

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

3419 var o = buildEventRecordRequest();

3420 var od = new api.EventRecordRequest.fromJson(o.toJson());

3421 checkEventRecordRequest(od);

3422 });

3423 });

3424

3425

3426 unittest.group("obj-schema-EventUpdateRequest", () {

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

3428 var o = buildEventUpdateRequest();

3429 var od = new api.EventUpdateRequest.fromJson(o.toJson());

3430 checkEventUpdateRequest(od);

3431 });

3432 });

3433

3434

3435 unittest.group("obj-schema-EventUpdateResponse", () {

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

3437 var o = buildEventUpdateResponse();

3438 var od = new api.EventUpdateResponse.fromJson(o.toJson());

3439 checkEventUpdateResponse(od);

3440 });

3441 });

3442

3443

3444 unittest.group("obj-schema-GamesAchievementIncrement", () {

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

3446 var o = buildGamesAchievementIncrement();

3447 var od = new api.GamesAchievementIncrement.fromJson(o.toJson());

3448 checkGamesAchievementIncrement(od);

3449 });

3450 });

3451

3452

3453 unittest.group("obj-schema-GamesAchievementSetStepsAtLeast", () {

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

3455 var o = buildGamesAchievementSetStepsAtLeast();

3456 var od = new api.GamesAchievementSetStepsAtLeast.fromJson(o.toJson());

3457 checkGamesAchievementSetStepsAtLeast(od);

3458 });

3459 });

3460

3461

3462 unittest.group("obj-schema-ImageAsset", () {

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

3464 var o = buildImageAsset();

3465 var od = new api.ImageAsset.fromJson(o.toJson());

3466 checkImageAsset(od);

3467 });

3468 });

3469

3470

3471 unittest.group("obj-schema-Instance", () {

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

3473 var o = buildInstance();

3474 var od = new api.Instance.fromJson(o.toJson());

3475 checkInstance(od);

3476 });

3477 });

3478

3479

3480 unittest.group("obj-schema-InstanceAndroidDetails", () {

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

3482 var o = buildInstanceAndroidDetails();

3483 var od = new api.InstanceAndroidDetails.fromJson(o.toJson());

3484 checkInstanceAndroidDetails(od);

3485 });

3486 });

3487

3488

3489 unittest.group("obj-schema-InstanceIosDetails", () {

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

3491 var o = buildInstanceIosDetails();

3492 var od = new api.InstanceIosDetails.fromJson(o.toJson());

3493 checkInstanceIosDetails(od);

3494 });

3495 });

3496

3497

3498 unittest.group("obj-schema-InstanceWebDetails", () {

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

3500 var o = buildInstanceWebDetails();

3501 var od = new api.InstanceWebDetails.fromJson(o.toJson());

3502 checkInstanceWebDetails(od);

3503 });

3504 });

3505

3506

3507 unittest.group("obj-schema-Leaderboard", () {

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

3509 var o = buildLeaderboard();

3510 var od = new api.Leaderboard.fromJson(o.toJson());

3511 checkLeaderboard(od);

3512 });

3513 });

3514

3515

3516 unittest.group("obj-schema-LeaderboardEntry", () {

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

3518 var o = buildLeaderboardEntry();

3519 var od = new api.LeaderboardEntry.fromJson(o.toJson());

3520 checkLeaderboardEntry(od);

3521 });

3522 });

3523

3524

3525 unittest.group("obj-schema-LeaderboardListResponse", () {

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

3527 var o = buildLeaderboardListResponse();

3528 var od = new api.LeaderboardListResponse.fromJson(o.toJson());

3529 checkLeaderboardListResponse(od);

3530 });

3531 });

3532

3533

3534 unittest.group("obj-schema-LeaderboardScoreRank", () {

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

3536 var o = buildLeaderboardScoreRank();

3537 var od = new api.LeaderboardScoreRank.fromJson(o.toJson());

3538 checkLeaderboardScoreRank(od);

3539 });

3540 });

3541

3542

3543 unittest.group("obj-schema-LeaderboardScores", () {

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

3545 var o = buildLeaderboardScores();

3546 var od = new api.LeaderboardScores.fromJson(o.toJson());

3547 checkLeaderboardScores(od);

3548 });

3549 });

3550

3551

3552 unittest.group("obj-schema-MetagameConfig", () {

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

3554 var o = buildMetagameConfig();

3555 var od = new api.MetagameConfig.fromJson(o.toJson());

3556 checkMetagameConfig(od);

3557 });

3558 });

3559

3560

3561 unittest.group("obj-schema-NetworkDiagnostics", () {

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

3563 var o = buildNetworkDiagnostics();

3564 var od = new api.NetworkDiagnostics.fromJson(o.toJson());

3565 checkNetworkDiagnostics(od);

3566 });

3567 });

3568

3569

3570 unittest.group("obj-schema-ParticipantResult", () {

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

3572 var o = buildParticipantResult();

3573 var od = new api.ParticipantResult.fromJson(o.toJson());

3574 checkParticipantResult(od);

3575 });

3576 });

3577

3578

3579 unittest.group("obj-schema-PeerChannelDiagnostics", () {

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

3581 var o = buildPeerChannelDiagnostics();

3582 var od = new api.PeerChannelDiagnostics.fromJson(o.toJson());

3583 checkPeerChannelDiagnostics(od);

3584 });

3585 });

3586

3587

3588 unittest.group("obj-schema-PeerSessionDiagnostics", () {

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

3590 var o = buildPeerSessionDiagnostics();

3591 var od = new api.PeerSessionDiagnostics.fromJson(o.toJson());

3592 checkPeerSessionDiagnostics(od);

3593 });

3594 });

3595

3596

3597 unittest.group("obj-schema-Played", () {

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

3599 var o = buildPlayed();

3600 var od = new api.Played.fromJson(o.toJson());

3601 checkPlayed(od);

3602 });

3603 });

3604

3605

3606 unittest.group("obj-schema-PlayerName", () {

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

3608 var o = buildPlayerName();

3609 var od = new api.PlayerName.fromJson(o.toJson());

3610 checkPlayerName(od);

3611 });

3612 });

3613

3614

3615 unittest.group("obj-schema-Player", () {

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

3617 var o = buildPlayer();

3618 var od = new api.Player.fromJson(o.toJson());

3619 checkPlayer(od);

3620 });

3621 });

3622

3623

3624 unittest.group("obj-schema-PlayerAchievement", () {

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

3626 var o = buildPlayerAchievement();

3627 var od = new api.PlayerAchievement.fromJson(o.toJson());

3628 checkPlayerAchievement(od);

3629 });

3630 });

3631

3632

3633 unittest.group("obj-schema-PlayerAchievementListResponse", () {

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

3635 var o = buildPlayerAchievementListResponse();

3636 var od = new api.PlayerAchievementListResponse.fromJson(o.toJson());

3637 checkPlayerAchievementListResponse(od);

3638 });

3639 });

3640

3641

3642 unittest.group("obj-schema-PlayerEvent", () {

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

3644 var o = buildPlayerEvent();

3645 var od = new api.PlayerEvent.fromJson(o.toJson());

3646 checkPlayerEvent(od);

3647 });

3648 });

3649

3650

3651 unittest.group("obj-schema-PlayerEventListResponse", () {

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

3653 var o = buildPlayerEventListResponse();

3654 var od = new api.PlayerEventListResponse.fromJson(o.toJson());

3655 checkPlayerEventListResponse(od);

3656 });

3657 });

3658

3659

3660 unittest.group("obj-schema-PlayerExperienceInfo", () {

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

3662 var o = buildPlayerExperienceInfo();

3663 var od = new api.PlayerExperienceInfo.fromJson(o.toJson());

3664 checkPlayerExperienceInfo(od);

3665 });

3666 });

3667

3668

3669 unittest.group("obj-schema-PlayerLeaderboardScore", () {

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

3671 var o = buildPlayerLeaderboardScore();

3672 var od = new api.PlayerLeaderboardScore.fromJson(o.toJson());

3673 checkPlayerLeaderboardScore(od);

3674 });

3675 });

3676

3677

3678 unittest.group("obj-schema-PlayerLeaderboardScoreListResponse", () {

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

3680 var o = buildPlayerLeaderboardScoreListResponse();

3681 var od = new api.PlayerLeaderboardScoreListResponse.fromJson(o.toJson());

3682 checkPlayerLeaderboardScoreListResponse(od);

3683 });

3684 });

3685

3686

3687 unittest.group("obj-schema-PlayerLevel", () {

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

3689 var o = buildPlayerLevel();

3690 var od = new api.PlayerLevel.fromJson(o.toJson());

3691 checkPlayerLevel(od);

3692 });

3693 });

3694

3695

3696 unittest.group("obj-schema-PlayerListResponse", () {

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

3698 var o = buildPlayerListResponse();

3699 var od = new api.PlayerListResponse.fromJson(o.toJson());

3700 checkPlayerListResponse(od);

3701 });

3702 });

3703

3704

3705 unittest.group("obj-schema-PlayerScore", () {

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

3707 var o = buildPlayerScore();

3708 var od = new api.PlayerScore.fromJson(o.toJson());

3709 checkPlayerScore(od);

3710 });

3711 });

3712

3713

3714 unittest.group("obj-schema-PlayerScoreListResponse", () {

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

3716 var o = buildPlayerScoreListResponse();

3717 var od = new api.PlayerScoreListResponse.fromJson(o.toJson());

3718 checkPlayerScoreListResponse(od);

3719 });

3720 });

3721

3722

3723 unittest.group("obj-schema-PlayerScoreResponse", () {

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

3725 var o = buildPlayerScoreResponse();

3726 var od = new api.PlayerScoreResponse.fromJson(o.toJson());

3727 checkPlayerScoreResponse(od);

3728 });

3729 });

3730

3731

3732 unittest.group("obj-schema-PlayerScoreSubmissionList", () {

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

3734 var o = buildPlayerScoreSubmissionList();

3735 var od = new api.PlayerScoreSubmissionList.fromJson(o.toJson());

3736 checkPlayerScoreSubmissionList(od);

3737 });

3738 });

3739

3740

3741 unittest.group("obj-schema-PushToken", () {

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

3743 var o = buildPushToken();

3744 var od = new api.PushToken.fromJson(o.toJson());

3745 checkPushToken(od);

3746 });

3747 });

3748

3749

3750 unittest.group("obj-schema-PushTokenIdIos", () {

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

3752 var o = buildPushTokenIdIos();

3753 var od = new api.PushTokenIdIos.fromJson(o.toJson());

3754 checkPushTokenIdIos(od);

3755 });

3756 });

3757

3758

3759 unittest.group("obj-schema-PushTokenId", () {

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

3761 var o = buildPushTokenId();

3762 var od = new api.PushTokenId.fromJson(o.toJson());

3763 checkPushTokenId(od);

3764 });

3765 });

3766

3767

3768 unittest.group("obj-schema-Quest", () {

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

3770 var o = buildQuest();

3771 var od = new api.Quest.fromJson(o.toJson());

3772 checkQuest(od);

3773 });

3774 });

3775

3776

3777 unittest.group("obj-schema-QuestContribution", () {

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

3779 var o = buildQuestContribution();

3780 var od = new api.QuestContribution.fromJson(o.toJson());

3781 checkQuestContribution(od);

3782 });

3783 });

3784

3785

3786 unittest.group("obj-schema-QuestCriterion", () {

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

3788 var o = buildQuestCriterion();

3789 var od = new api.QuestCriterion.fromJson(o.toJson());

3790 checkQuestCriterion(od);

3791 });

3792 });

3793

3794

3795 unittest.group("obj-schema-QuestListResponse", () {

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

3797 var o = buildQuestListResponse();

3798 var od = new api.QuestListResponse.fromJson(o.toJson());

3799 checkQuestListResponse(od);

3800 });

3801 });

3802

3803

3804 unittest.group("obj-schema-QuestMilestone", () {

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

3806 var o = buildQuestMilestone();

3807 var od = new api.QuestMilestone.fromJson(o.toJson());

3808 checkQuestMilestone(od);

3809 });

3810 });

3811

3812

3813 unittest.group("obj-schema-RevisionCheckResponse", () {

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

3815 var o = buildRevisionCheckResponse();

3816 var od = new api.RevisionCheckResponse.fromJson(o.toJson());

3817 checkRevisionCheckResponse(od);

3818 });

3819 });

3820

3821

3822 unittest.group("obj-schema-Room", () {

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

3824 var o = buildRoom();

3825 var od = new api.Room.fromJson(o.toJson());

3826 checkRoom(od);

3827 });

3828 });

3829

3830

3831 unittest.group("obj-schema-RoomAutoMatchStatus", () {

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

3833 var o = buildRoomAutoMatchStatus();

3834 var od = new api.RoomAutoMatchStatus.fromJson(o.toJson());

3835 checkRoomAutoMatchStatus(od);

3836 });

3837 });

3838

3839

3840 unittest.group("obj-schema-RoomAutoMatchingCriteria", () {

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

3842 var o = buildRoomAutoMatchingCriteria();

3843 var od = new api.RoomAutoMatchingCriteria.fromJson(o.toJson());

3844 checkRoomAutoMatchingCriteria(od);

3845 });

3846 });

3847

3848

3849 unittest.group("obj-schema-RoomClientAddress", () {

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

3851 var o = buildRoomClientAddress();

3852 var od = new api.RoomClientAddress.fromJson(o.toJson());

3853 checkRoomClientAddress(od);

3854 });

3855 });

3856

3857

3858 unittest.group("obj-schema-RoomCreateRequest", () {

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

3860 var o = buildRoomCreateRequest();

3861 var od = new api.RoomCreateRequest.fromJson(o.toJson());

3862 checkRoomCreateRequest(od);

3863 });

3864 });

3865

3866

3867 unittest.group("obj-schema-RoomJoinRequest", () {

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

3869 var o = buildRoomJoinRequest();

3870 var od = new api.RoomJoinRequest.fromJson(o.toJson());

3871 checkRoomJoinRequest(od);

3872 });

3873 });

3874

3875

3876 unittest.group("obj-schema-RoomLeaveDiagnostics", () {

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

3878 var o = buildRoomLeaveDiagnostics();

3879 var od = new api.RoomLeaveDiagnostics.fromJson(o.toJson());

3880 checkRoomLeaveDiagnostics(od);

3881 });

3882 });

3883

3884

3885 unittest.group("obj-schema-RoomLeaveRequest", () {

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

3887 var o = buildRoomLeaveRequest();

3888 var od = new api.RoomLeaveRequest.fromJson(o.toJson());

3889 checkRoomLeaveRequest(od);

3890 });

3891 });

3892

3893

3894 unittest.group("obj-schema-RoomList", () {

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

3896 var o = buildRoomList();

3897 var od = new api.RoomList.fromJson(o.toJson());

3898 checkRoomList(od);

3899 });

3900 });

3901

3902

3903 unittest.group("obj-schema-RoomModification", () {

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

3905 var o = buildRoomModification();

3906 var od = new api.RoomModification.fromJson(o.toJson());

3907 checkRoomModification(od);

3908 });

3909 });

3910

3911

3912 unittest.group("obj-schema-RoomP2PStatus", () {

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

3914 var o = buildRoomP2PStatus();

3915 var od = new api.RoomP2PStatus.fromJson(o.toJson());

3916 checkRoomP2PStatus(od);

3917 });

3918 });

3919

3920

3921 unittest.group("obj-schema-RoomP2PStatuses", () {

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

3923 var o = buildRoomP2PStatuses();

3924 var od = new api.RoomP2PStatuses.fromJson(o.toJson());

3925 checkRoomP2PStatuses(od);

3926 });

3927 });

3928

3929

3930 unittest.group("obj-schema-RoomParticipant", () {

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

3932 var o = buildRoomParticipant();

3933 var od = new api.RoomParticipant.fromJson(o.toJson());

3934 checkRoomParticipant(od);

3935 });

3936 });

3937

3938

3939 unittest.group("obj-schema-RoomStatus", () {

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

3941 var o = buildRoomStatus();

3942 var od = new api.RoomStatus.fromJson(o.toJson());

3943 checkRoomStatus(od);

3944 });

3945 });

3946

3947

3948 unittest.group("obj-schema-ScoreSubmission", () {

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

3950 var o = buildScoreSubmission();

3951 var od = new api.ScoreSubmission.fromJson(o.toJson());

3952 checkScoreSubmission(od);

3953 });

3954 });

3955

3956

3957 unittest.group("obj-schema-Snapshot", () {

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

3959 var o = buildSnapshot();

3960 var od = new api.Snapshot.fromJson(o.toJson());

3961 checkSnapshot(od);

3962 });

3963 });

3964

3965

3966 unittest.group("obj-schema-SnapshotImage", () {

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

3968 var o = buildSnapshotImage();

3969 var od = new api.SnapshotImage.fromJson(o.toJson());

3970 checkSnapshotImage(od);

3971 });

3972 });

3973

3974

3975 unittest.group("obj-schema-SnapshotListResponse", () {

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

3977 var o = buildSnapshotListResponse();

3978 var od = new api.SnapshotListResponse.fromJson(o.toJson());

3979 checkSnapshotListResponse(od);

3980 });

3981 });

3982

3983

3984 unittest.group("obj-schema-TurnBasedAutoMatchingCriteria", () {

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

3986 var o = buildTurnBasedAutoMatchingCriteria();

3987 var od = new api.TurnBasedAutoMatchingCriteria.fromJson(o.toJson());

3988 checkTurnBasedAutoMatchingCriteria(od);

3989 });

3990 });

3991

3992

3993 unittest.group("obj-schema-TurnBasedMatch", () {

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

3995 var o = buildTurnBasedMatch();

3996 var od = new api.TurnBasedMatch.fromJson(o.toJson());

3997 checkTurnBasedMatch(od);

3998 });

3999 });

4000

4001

4002 unittest.group("obj-schema-TurnBasedMatchCreateRequest", () {

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

4004 var o = buildTurnBasedMatchCreateRequest();

4005 var od = new api.TurnBasedMatchCreateRequest.fromJson(o.toJson());

4006 checkTurnBasedMatchCreateRequest(od);

4007 });

4008 });

4009

4010

4011 unittest.group("obj-schema-TurnBasedMatchData", () {

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

4013 var o = buildTurnBasedMatchData();

4014 var od = new api.TurnBasedMatchData.fromJson(o.toJson());

4015 checkTurnBasedMatchData(od);

4016 });

4017 });

4018

4019

4020 unittest.group("obj-schema-TurnBasedMatchDataRequest", () {

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

4022 var o = buildTurnBasedMatchDataRequest();

4023 var od = new api.TurnBasedMatchDataRequest.fromJson(o.toJson());

4024 checkTurnBasedMatchDataRequest(od);

4025 });

4026 });

4027

4028

4029 unittest.group("obj-schema-TurnBasedMatchList", () {

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

4031 var o = buildTurnBasedMatchList();

4032 var od = new api.TurnBasedMatchList.fromJson(o.toJson());

4033 checkTurnBasedMatchList(od);

4034 });

4035 });

4036

4037

4038 unittest.group("obj-schema-TurnBasedMatchModification", () {

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

4040 var o = buildTurnBasedMatchModification();

4041 var od = new api.TurnBasedMatchModification.fromJson(o.toJson());

4042 checkTurnBasedMatchModification(od);

4043 });

4044 });

4045

4046

4047 unittest.group("obj-schema-TurnBasedMatchParticipant", () {

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

4049 var o = buildTurnBasedMatchParticipant();

4050 var od = new api.TurnBasedMatchParticipant.fromJson(o.toJson());

4051 checkTurnBasedMatchParticipant(od);

4052 });

4053 });

4054

4055

4056 unittest.group("obj-schema-TurnBasedMatchRematch", () {

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

4058 var o = buildTurnBasedMatchRematch();

4059 var od = new api.TurnBasedMatchRematch.fromJson(o.toJson());

4060 checkTurnBasedMatchRematch(od);

4061 });

4062 });

4063

4064

4065 unittest.group("obj-schema-TurnBasedMatchResults", () {

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

4067 var o = buildTurnBasedMatchResults();

4068 var od = new api.TurnBasedMatchResults.fromJson(o.toJson());

4069 checkTurnBasedMatchResults(od);

4070 });

4071 });

4072

4073

4074 unittest.group("obj-schema-TurnBasedMatchSync", () {

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

4076 var o = buildTurnBasedMatchSync();

4077 var od = new api.TurnBasedMatchSync.fromJson(o.toJson());

4078 checkTurnBasedMatchSync(od);

4079 });

4080 });

4081

4082

4083 unittest.group("obj-schema-TurnBasedMatchTurn", () {

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

4085 var o = buildTurnBasedMatchTurn();

4086 var od = new api.TurnBasedMatchTurn.fromJson(o.toJson());

4087 checkTurnBasedMatchTurn(od);

4088 });

4089 });

4090

4091

4092 unittest.group("resource-AchievementDefinitionsResourceApi", () {

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

4094

4095 var mock = new common_test.HttpServerMock();

4096 api.AchievementDefinitionsResourceApi res = new api.GamesApi(mock).achieve mentDefinitions;

4097 var arg_language = "foo";

4098 var arg_maxResults = 42;

4099 var arg_pageToken = "foo";

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

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

4102 var pathOffset = 0;

4103 var index;

4104 var subPart;

4105 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4106 pathOffset += 10;

4107 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("achievements"));

4108 pathOffset += 12;

4109

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

4111 var queryOffset = 0;

4112 var queryMap = {};

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

4114 parseBool(n) {

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

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

4117 if (n == null) return null;

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

4119 }

4120 if (query.length > 0) {

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

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

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

4124 }

4125 }

4126 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

4129

4130

4131 var h = {

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

4133 };

4134 var resp = convert.JSON.encode(buildAchievementDefinitionsListResponse() );

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

4136 }), true);

4137 res.list(language: arg_language, maxResults: arg_maxResults, pageToken: ar g_pageToken).then(unittest.expectAsync(((api.AchievementDefinitionsListResponse response) {

4138 checkAchievementDefinitionsListResponse(response);

4139 })));

4140 });

4141

4142 });

4143

4144

4145 unittest.group("resource-AchievementsResourceApi", () {

4146 unittest.test("method--increment", () {

4147

4148 var mock = new common_test.HttpServerMock();

4149 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4150 var arg_achievementId = "foo";

4151 var arg_stepsToIncrement = 42;

4152 var arg_requestId = "foo";

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

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

4155 var pathOffset = 0;

4156 var index;

4157 var subPart;

4158 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4159 pathOffset += 10;

4160 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));

4161 pathOffset += 13;

4162 index = path.indexOf("/increment", pathOffset);

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

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

4165 pathOffset = index;

4166 unittest.expect(subPart, unittest.equals("$arg_achievementId"));

4167 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/increment"));

4168 pathOffset += 10;

4169

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

4171 var queryOffset = 0;

4172 var queryMap = {};

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

4174 parseBool(n) {

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

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

4177 if (n == null) return null;

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

4179 }

4180 if (query.length > 0) {

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

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

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

4184 }

4185 }

4186 unittest.expect(core.int.parse(queryMap["stepsToIncrement"].first), unit test.equals(arg_stepsToIncrement));

4187 unittest.expect(queryMap["requestId"].first, unittest.equals(arg_request Id));

4188

4189

4190 var h = {

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

4192 };

4193 var resp = convert.JSON.encode(buildAchievementIncrementResponse());

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

4195 }), true);

4196 res.increment(arg_achievementId, arg_stepsToIncrement, requestId: arg_requ estId).then(unittest.expectAsync(((api.AchievementIncrementResponse response) {

4197 checkAchievementIncrementResponse(response);

4198 })));

4199 });

4200

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

4202

4203 var mock = new common_test.HttpServerMock();

4204 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4205 var arg_playerId = "foo";

4206 var arg_language = "foo";

4207 var arg_maxResults = 42;

4208 var arg_pageToken = "foo";

4209 var arg_state = "foo";

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

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

4212 var pathOffset = 0;

4213 var index;

4214 var subPart;

4215 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4216 pathOffset += 10;

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

4218 pathOffset += 8;

4219 index = path.indexOf("/achievements", pathOffset);

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

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

4222 pathOffset = index;

4223 unittest.expect(subPart, unittest.equals("$arg_playerId"));

4224 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/achievements"));

4225 pathOffset += 13;

4226

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

4228 var queryOffset = 0;

4229 var queryMap = {};

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

4231 parseBool(n) {

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

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

4234 if (n == null) return null;

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

4236 }

4237 if (query.length > 0) {

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

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

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

4241 }

4242 }

4243 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

4246 unittest.expect(queryMap["state"].first, unittest.equals(arg_state));

4247

4248

4249 var h = {

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

4251 };

4252 var resp = convert.JSON.encode(buildPlayerAchievementListResponse());

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

4254 }), true);

4255 res.list(arg_playerId, language: arg_language, maxResults: arg_maxResults, pageToken: arg_pageToken, state: arg_state).then(unittest.expectAsync(((api.Pla yerAchievementListResponse response) {

4256 checkPlayerAchievementListResponse(response);

4257 })));

4258 });

4259

4260 unittest.test("method--reveal", () {

4261

4262 var mock = new common_test.HttpServerMock();

4263 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4264 var arg_achievementId = "foo";

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

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

4267 var pathOffset = 0;

4268 var index;

4269 var subPart;

4270 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4271 pathOffset += 10;

4272 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));

4273 pathOffset += 13;

4274 index = path.indexOf("/reveal", pathOffset);

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

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

4277 pathOffset = index;

4278 unittest.expect(subPart, unittest.equals("$arg_achievementId"));

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

4280 pathOffset += 7;

4281

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

4283 var queryOffset = 0;

4284 var queryMap = {};

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

4286 parseBool(n) {

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

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

4289 if (n == null) return null;

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

4291 }

4292 if (query.length > 0) {

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

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

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

4296 }

4297 }

4298

4299

4300 var h = {

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

4302 };

4303 var resp = convert.JSON.encode(buildAchievementRevealResponse());

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

4305 }), true);

4306 res.reveal(arg_achievementId).then(unittest.expectAsync(((api.AchievementR evealResponse response) {

4307 checkAchievementRevealResponse(response);

4308 })));

4309 });

4310

4311 unittest.test("method--setStepsAtLeast", () {

4312

4313 var mock = new common_test.HttpServerMock();

4314 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4315 var arg_achievementId = "foo";

4316 var arg_steps = 42;

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

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

4319 var pathOffset = 0;

4320 var index;

4321 var subPart;

4322 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4323 pathOffset += 10;

4324 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));

4325 pathOffset += 13;

4326 index = path.indexOf("/setStepsAtLeast", pathOffset);

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

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

4329 pathOffset = index;

4330 unittest.expect(subPart, unittest.equals("$arg_achievementId"));

4331 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/setStepsAtLeast"));

4332 pathOffset += 16;

4333

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

4335 var queryOffset = 0;

4336 var queryMap = {};

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

4338 parseBool(n) {

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

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

4341 if (n == null) return null;

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

4343 }

4344 if (query.length > 0) {

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

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

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

4348 }

4349 }

4350 unittest.expect(core.int.parse(queryMap["steps"].first), unittest.equals (arg_steps));

4351

4352

4353 var h = {

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

4355 };

4356 var resp = convert.JSON.encode(buildAchievementSetStepsAtLeastResponse() );

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

4358 }), true);

4359 res.setStepsAtLeast(arg_achievementId, arg_steps).then(unittest.expectAsyn c(((api.AchievementSetStepsAtLeastResponse response) {

4360 checkAchievementSetStepsAtLeastResponse(response);

4361 })));

4362 });

4363

4364 unittest.test("method--unlock", () {

4365

4366 var mock = new common_test.HttpServerMock();

4367 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4368 var arg_achievementId = "foo";

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

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

4371 var pathOffset = 0;

4372 var index;

4373 var subPart;

4374 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4375 pathOffset += 10;

4376 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));

4377 pathOffset += 13;

4378 index = path.indexOf("/unlock", pathOffset);

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

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

4381 pathOffset = index;

4382 unittest.expect(subPart, unittest.equals("$arg_achievementId"));

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

4384 pathOffset += 7;

4385

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

4387 var queryOffset = 0;

4388 var queryMap = {};

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

4390 parseBool(n) {

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

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

4393 if (n == null) return null;

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

4395 }

4396 if (query.length > 0) {

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

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

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

4400 }

4401 }

4402

4403

4404 var h = {

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

4406 };

4407 var resp = convert.JSON.encode(buildAchievementUnlockResponse());

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

4409 }), true);

4410 res.unlock(arg_achievementId).then(unittest.expectAsync(((api.AchievementU nlockResponse response) {

4411 checkAchievementUnlockResponse(response);

4412 })));

4413 });

4414

4415 unittest.test("method--updateMultiple", () {

4416

4417 var mock = new common_test.HttpServerMock();

4418 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4419 var arg_request = buildAchievementUpdateMultipleRequest();

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

4421 var obj = new api.AchievementUpdateMultipleRequest.fromJson(json);

4422 checkAchievementUpdateMultipleRequest(obj);

4423

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

4425 var pathOffset = 0;

4426 var index;

4427 var subPart;

4428 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4429 pathOffset += 10;

4430 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("achievements/updateMultiple"));

4431 pathOffset += 27;

4432

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

4434 var queryOffset = 0;

4435 var queryMap = {};

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

4437 parseBool(n) {

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

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

4440 if (n == null) return null;

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

4442 }

4443 if (query.length > 0) {

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

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

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

4447 }

4448 }

4449

4450

4451 var h = {

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

4453 };

4454 var resp = convert.JSON.encode(buildAchievementUpdateMultipleResponse()) ;

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

4456 }), true);

4457 res.updateMultiple(arg_request).then(unittest.expectAsync(((api.Achievemen tUpdateMultipleResponse response) {

4458 checkAchievementUpdateMultipleResponse(response);

4459 })));

4460 });

4461

4462 });

4463

4464

4465 unittest.group("resource-ApplicationsResourceApi", () {

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

4467

4468 var mock = new common_test.HttpServerMock();

4469 api.ApplicationsResourceApi res = new api.GamesApi(mock).applications;

4470 var arg_applicationId = "foo";

4471 var arg_language = "foo";

4472 var arg_platformType = "foo";

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

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

4475 var pathOffset = 0;

4476 var index;

4477 var subPart;

4478 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4479 pathOffset += 10;

4480 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("applications/"));

4481 pathOffset += 13;

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

4483 pathOffset = path.length;

4484 unittest.expect(subPart, unittest.equals("$arg_applicationId"));

4485

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

4487 var queryOffset = 0;

4488 var queryMap = {};

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

4490 parseBool(n) {

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

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

4493 if (n == null) return null;

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

4495 }

4496 if (query.length > 0) {

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

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

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

4500 }

4501 }

4502 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

4503 unittest.expect(queryMap["platformType"].first, unittest.equals(arg_plat formType));

4504

4505

4506 var h = {

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

4508 };

4509 var resp = convert.JSON.encode(buildApplication());

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

4511 }), true);

4512 res.get(arg_applicationId, language: arg_language, platformType: arg_platf ormType).then(unittest.expectAsync(((api.Application response) {

4513 checkApplication(response);

4514 })));

4515 });

4516

4517 unittest.test("method--played", () {

4518

4519 var mock = new common_test.HttpServerMock();

4520 api.ApplicationsResourceApi res = new api.GamesApi(mock).applications;

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

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

4523 var pathOffset = 0;

4524 var index;

4525 var subPart;

4526 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4527 pathOffset += 10;

4528 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("applications/played"));

4529 pathOffset += 19;

4530

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

4532 var queryOffset = 0;

4533 var queryMap = {};

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

4535 parseBool(n) {

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

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

4538 if (n == null) return null;

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

4540 }

4541 if (query.length > 0) {

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

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

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

4545 }

4546 }

4547

4548

4549 var h = {

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

4551 };

4552 var resp = "";

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

4554 }), true);

4555 res.played().then(unittest.expectAsync((_) {}));

4556 });

4557

4558 });

4559

4560

4561 unittest.group("resource-EventsResourceApi", () {

4562 unittest.test("method--listByPlayer", () {

4563

4564 var mock = new common_test.HttpServerMock();

4565 api.EventsResourceApi res = new api.GamesApi(mock).events;

4566 var arg_language = "foo";

4567 var arg_maxResults = 42;

4568 var arg_pageToken = "foo";

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

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

4571 var pathOffset = 0;

4572 var index;

4573 var subPart;

4574 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4575 pathOffset += 10;

4576 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("events"));

4577 pathOffset += 6;

4578

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

4580 var queryOffset = 0;

4581 var queryMap = {};

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

4583 parseBool(n) {

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

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

4586 if (n == null) return null;

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

4588 }

4589 if (query.length > 0) {

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

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

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

4593 }

4594 }

4595 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

4598

4599

4600 var h = {

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

4602 };

4603 var resp = convert.JSON.encode(buildPlayerEventListResponse());

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

4605 }), true);

4606 res.listByPlayer(language: arg_language, maxResults: arg_maxResults, pageT oken: arg_pageToken).then(unittest.expectAsync(((api.PlayerEventListResponse res ponse) {

4607 checkPlayerEventListResponse(response);

4608 })));

4609 });

4610

4611 unittest.test("method--listDefinitions", () {

4612

4613 var mock = new common_test.HttpServerMock();

4614 api.EventsResourceApi res = new api.GamesApi(mock).events;

4615 var arg_language = "foo";

4616 var arg_maxResults = 42;

4617 var arg_pageToken = "foo";

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

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

4620 var pathOffset = 0;

4621 var index;

4622 var subPart;

4623 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4624 pathOffset += 10;

4625 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("eventDefinitions"));

4626 pathOffset += 16;

4627

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

4629 var queryOffset = 0;

4630 var queryMap = {};

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

4632 parseBool(n) {

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

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

4635 if (n == null) return null;

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

4637 }

4638 if (query.length > 0) {

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

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

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

4642 }

4643 }

4644 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

4647

4648

4649 var h = {

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

4651 };

4652 var resp = convert.JSON.encode(buildEventDefinitionListResponse());

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

4654 }), true);

4655 res.listDefinitions(language: arg_language, maxResults: arg_maxResults, pa geToken: arg_pageToken).then(unittest.expectAsync(((api.EventDefinitionListRespo nse response) {

4656 checkEventDefinitionListResponse(response);

4657 })));

4658 });

4659

4660 unittest.test("method--record", () {

4661

4662 var mock = new common_test.HttpServerMock();

4663 api.EventsResourceApi res = new api.GamesApi(mock).events;

4664 var arg_request = buildEventRecordRequest();

4665 var arg_language = "foo";

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

4667 var obj = new api.EventRecordRequest.fromJson(json);

4668 checkEventRecordRequest(obj);

4669

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

4671 var pathOffset = 0;

4672 var index;

4673 var subPart;

4674 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4675 pathOffset += 10;

4676 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("events"));

4677 pathOffset += 6;

4678

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

4680 var queryOffset = 0;

4681 var queryMap = {};

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

4683 parseBool(n) {

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

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

4686 if (n == null) return null;

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

4688 }

4689 if (query.length > 0) {

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

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

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

4693 }

4694 }

4695 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

4696

4697

4698 var h = {

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

4700 };

4701 var resp = convert.JSON.encode(buildEventUpdateResponse());

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

4703 }), true);

4704 res.record(arg_request, language: arg_language).then(unittest.expectAsync( ((api.EventUpdateResponse response) {

4705 checkEventUpdateResponse(response);

4706 })));

4707 });

4708

4709 });

4710

4711

4712 unittest.group("resource-LeaderboardsResourceApi", () {

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

4714

4715 var mock = new common_test.HttpServerMock();

4716 api.LeaderboardsResourceApi res = new api.GamesApi(mock).leaderboards;

4717 var arg_leaderboardId = "foo";

4718 var arg_language = "foo";

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

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

4721 var pathOffset = 0;

4722 var index;

4723 var subPart;

4724 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4725 pathOffset += 10;

4726 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));

4727 pathOffset += 13;

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

4729 pathOffset = path.length;

4730 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));

4731

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

4733 var queryOffset = 0;

4734 var queryMap = {};

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

4736 parseBool(n) {

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

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

4739 if (n == null) return null;

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

4741 }

4742 if (query.length > 0) {

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

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

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

4746 }

4747 }

4748 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

4749

4750

4751 var h = {

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

4753 };

4754 var resp = convert.JSON.encode(buildLeaderboard());

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

4756 }), true);

4757 res.get(arg_leaderboardId, language: arg_language).then(unittest.expectAsy nc(((api.Leaderboard response) {

4758 checkLeaderboard(response);

4759 })));

4760 });

4761

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

4763

4764 var mock = new common_test.HttpServerMock();

4765 api.LeaderboardsResourceApi res = new api.GamesApi(mock).leaderboards;

4766 var arg_language = "foo";

4767 var arg_maxResults = 42;

4768 var arg_pageToken = "foo";

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

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

4771 var pathOffset = 0;

4772 var index;

4773 var subPart;

4774 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4775 pathOffset += 10;

4776 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("leaderboards"));

4777 pathOffset += 12;

4778

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

4780 var queryOffset = 0;

4781 var queryMap = {};

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

4783 parseBool(n) {

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

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

4786 if (n == null) return null;

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

4788 }

4789 if (query.length > 0) {

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

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

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

4793 }

4794 }

4795 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

4798

4799

4800 var h = {

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

4802 };

4803 var resp = convert.JSON.encode(buildLeaderboardListResponse());

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

4805 }), true);

4806 res.list(language: arg_language, maxResults: arg_maxResults, pageToken: ar g_pageToken).then(unittest.expectAsync(((api.LeaderboardListResponse response) {

4807 checkLeaderboardListResponse(response);

4808 })));

4809 });

4810

4811 });

4812

4813

4814 unittest.group("resource-MetagameResourceApi", () {

4815 unittest.test("method--getMetagameConfig", () {

4816

4817 var mock = new common_test.HttpServerMock();

4818 api.MetagameResourceApi res = new api.GamesApi(mock).metagame;

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

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

4821 var pathOffset = 0;

4822 var index;

4823 var subPart;

4824 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4825 pathOffset += 10;

4826 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("metagameConfig"));

4827 pathOffset += 14;

4828

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

4830 var queryOffset = 0;

4831 var queryMap = {};

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

4833 parseBool(n) {

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

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

4836 if (n == null) return null;

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

4838 }

4839 if (query.length > 0) {

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

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

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

4843 }

4844 }

4845

4846

4847 var h = {

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

4849 };

4850 var resp = convert.JSON.encode(buildMetagameConfig());

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

4852 }), true);

4853 res.getMetagameConfig().then(unittest.expectAsync(((api.MetagameConfig res ponse) {

4854 checkMetagameConfig(response);

4855 })));

4856 });

4857

4858 unittest.test("method--listCategoriesByPlayer", () {

4859

4860 var mock = new common_test.HttpServerMock();

4861 api.MetagameResourceApi res = new api.GamesApi(mock).metagame;

4862 var arg_playerId = "foo";

4863 var arg_collection = "foo";

4864 var arg_language = "foo";

4865 var arg_maxResults = 42;

4866 var arg_pageToken = "foo";

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

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

4869 var pathOffset = 0;

4870 var index;

4871 var subPart;

4872 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4873 pathOffset += 10;

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

4875 pathOffset += 8;

4876 index = path.indexOf("/categories/", pathOffset);

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

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

4879 pathOffset = index;

4880 unittest.expect(subPart, unittest.equals("$arg_playerId"));

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

4882 pathOffset += 12;

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

4884 pathOffset = path.length;

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

4886

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

4888 var queryOffset = 0;

4889 var queryMap = {};

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

4891 parseBool(n) {

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

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

4894 if (n == null) return null;

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

4896 }

4897 if (query.length > 0) {

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

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

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

4901 }

4902 }

4903 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

4906

4907

4908 var h = {

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

4910 };

4911 var resp = convert.JSON.encode(buildCategoryListResponse());

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

4913 }), true);

4914 res.listCategoriesByPlayer(arg_playerId, arg_collection, language: arg_lan guage, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expec tAsync(((api.CategoryListResponse response) {

4915 checkCategoryListResponse(response);

4916 })));

4917 });

4918

4919 });

4920

4921

4922 unittest.group("resource-PlayersResourceApi", () {

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

4924

4925 var mock = new common_test.HttpServerMock();

4926 api.PlayersResourceApi res = new api.GamesApi(mock).players;

4927 var arg_playerId = "foo";

4928 var arg_language = "foo";

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

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

4931 var pathOffset = 0;

4932 var index;

4933 var subPart;

4934 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4935 pathOffset += 10;

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

4937 pathOffset += 8;

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

4939 pathOffset = path.length;

4940 unittest.expect(subPart, unittest.equals("$arg_playerId"));

4941

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

4943 var queryOffset = 0;

4944 var queryMap = {};

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

4946 parseBool(n) {

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

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

4949 if (n == null) return null;

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

4951 }

4952 if (query.length > 0) {

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

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

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

4956 }

4957 }

4958 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

4959

4960

4961 var h = {

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

4963 };

4964 var resp = convert.JSON.encode(buildPlayer());

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

4966 }), true);

4967 res.get(arg_playerId, language: arg_language).then(unittest.expectAsync((( api.Player response) {

4968 checkPlayer(response);

4969 })));

4970 });

4971

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

4973

4974 var mock = new common_test.HttpServerMock();

4975 api.PlayersResourceApi res = new api.GamesApi(mock).players;

4976 var arg_collection = "foo";

4977 var arg_language = "foo";

4978 var arg_maxResults = 42;

4979 var arg_pageToken = "foo";

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

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

4982 var pathOffset = 0;

4983 var index;

4984 var subPart;

4985 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

4986 pathOffset += 10;

4987 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("players/me/players/"));

4988 pathOffset += 19;

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

4990 pathOffset = path.length;

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

4992

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

4994 var queryOffset = 0;

4995 var queryMap = {};

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

4997 parseBool(n) {

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

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

5000 if (n == null) return null;

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

5002 }

5003 if (query.length > 0) {

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

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

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

5007 }

5008 }

5009 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

5012

5013

5014 var h = {

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

5016 };

5017 var resp = convert.JSON.encode(buildPlayerListResponse());

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

5019 }), true);

5020 res.list(arg_collection, language: arg_language, maxResults: arg_maxResult s, pageToken: arg_pageToken).then(unittest.expectAsync(((api.PlayerListResponse response) {

5021 checkPlayerListResponse(response);

5022 })));

5023 });

5024

5025 });

5026

5027

5028 unittest.group("resource-PushtokensResourceApi", () {

5029 unittest.test("method--remove", () {

5030

5031 var mock = new common_test.HttpServerMock();

5032 api.PushtokensResourceApi res = new api.GamesApi(mock).pushtokens;

5033 var arg_request = buildPushTokenId();

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

5035 var obj = new api.PushTokenId.fromJson(json);

5036 checkPushTokenId(obj);

5037

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

5039 var pathOffset = 0;

5040 var index;

5041 var subPart;

5042 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5043 pathOffset += 10;

5044 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("pushtokens/remove"));

5045 pathOffset += 17;

5046

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

5048 var queryOffset = 0;

5049 var queryMap = {};

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

5051 parseBool(n) {

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

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

5054 if (n == null) return null;

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

5056 }

5057 if (query.length > 0) {

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

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

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

5061 }

5062 }

5063

5064

5065 var h = {

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

5067 };

5068 var resp = "";

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

5070 }), true);

5071 res.remove(arg_request).then(unittest.expectAsync((_) {}));

5072 });

5073

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

5075

5076 var mock = new common_test.HttpServerMock();

5077 api.PushtokensResourceApi res = new api.GamesApi(mock).pushtokens;

5078 var arg_request = buildPushToken();

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

5080 var obj = new api.PushToken.fromJson(json);

5081 checkPushToken(obj);

5082

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

5084 var pathOffset = 0;

5085 var index;

5086 var subPart;

5087 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5088 pathOffset += 10;

5089 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("pushtokens"));

5090 pathOffset += 10;

5091

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

5093 var queryOffset = 0;

5094 var queryMap = {};

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

5096 parseBool(n) {

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

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

5099 if (n == null) return null;

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

5101 }

5102 if (query.length > 0) {

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

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

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

5106 }

5107 }

5108

5109

5110 var h = {

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

5112 };

5113 var resp = "";

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

5115 }), true);

5116 res.update(arg_request).then(unittest.expectAsync((_) {}));

5117 });

5118

5119 });

5120

5121

5122 unittest.group("resource-QuestMilestonesResourceApi", () {

5123 unittest.test("method--claim", () {

5124

5125 var mock = new common_test.HttpServerMock();

5126 api.QuestMilestonesResourceApi res = new api.GamesApi(mock).questMilestone s;

5127 var arg_questId = "foo";

5128 var arg_milestoneId = "foo";

5129 var arg_requestId = "foo";

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

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

5132 var pathOffset = 0;

5133 var index;

5134 var subPart;

5135 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5136 pathOffset += 10;

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

5138 pathOffset += 7;

5139 index = path.indexOf("/milestones/", pathOffset);

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

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

5142 pathOffset = index;

5143 unittest.expect(subPart, unittest.equals("$arg_questId"));

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

5145 pathOffset += 12;

5146 index = path.indexOf("/claim", pathOffset);

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

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

5149 pathOffset = index;

5150 unittest.expect(subPart, unittest.equals("$arg_milestoneId"));

5151 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/claim"));

5152 pathOffset += 6;

5153

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

5155 var queryOffset = 0;

5156 var queryMap = {};

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

5158 parseBool(n) {

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

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

5161 if (n == null) return null;

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

5163 }

5164 if (query.length > 0) {

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

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

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

5168 }

5169 }

5170 unittest.expect(queryMap["requestId"].first, unittest.equals(arg_request Id));

5171

5172

5173 var h = {

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

5175 };

5176 var resp = "";

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

5178 }), true);

5179 res.claim(arg_questId, arg_milestoneId, arg_requestId).then(unittest.expec tAsync((_) {}));

5180 });

5181

5182 });

5183

5184

5185 unittest.group("resource-QuestsResourceApi", () {

5186 unittest.test("method--accept", () {

5187

5188 var mock = new common_test.HttpServerMock();

5189 api.QuestsResourceApi res = new api.GamesApi(mock).quests;

5190 var arg_questId = "foo";

5191 var arg_language = "foo";

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

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

5194 var pathOffset = 0;

5195 var index;

5196 var subPart;

5197 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5198 pathOffset += 10;

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

5200 pathOffset += 7;

5201 index = path.indexOf("/accept", pathOffset);

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

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

5204 pathOffset = index;

5205 unittest.expect(subPart, unittest.equals("$arg_questId"));

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

5207 pathOffset += 7;

5208

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

5210 var queryOffset = 0;

5211 var queryMap = {};

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

5213 parseBool(n) {

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

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

5216 if (n == null) return null;

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

5218 }

5219 if (query.length > 0) {

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

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

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

5223 }

5224 }

5225 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

5226

5227

5228 var h = {

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

5230 };

5231 var resp = convert.JSON.encode(buildQuest());

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

5233 }), true);

5234 res.accept(arg_questId, language: arg_language).then(unittest.expectAsync( ((api.Quest response) {

5235 checkQuest(response);

5236 })));

5237 });

5238

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

5240

5241 var mock = new common_test.HttpServerMock();

5242 api.QuestsResourceApi res = new api.GamesApi(mock).quests;

5243 var arg_playerId = "foo";

5244 var arg_language = "foo";

5245 var arg_maxResults = 42;

5246 var arg_pageToken = "foo";

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

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

5249 var pathOffset = 0;

5250 var index;

5251 var subPart;

5252 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5253 pathOffset += 10;

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

5255 pathOffset += 8;

5256 index = path.indexOf("/quests", pathOffset);

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

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

5259 pathOffset = index;

5260 unittest.expect(subPart, unittest.equals("$arg_playerId"));

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

5262 pathOffset += 7;

5263

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

5265 var queryOffset = 0;

5266 var queryMap = {};

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

5268 parseBool(n) {

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

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

5271 if (n == null) return null;

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

5273 }

5274 if (query.length > 0) {

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

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

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

5278 }

5279 }

5280 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

5283

5284

5285 var h = {

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

5287 };

5288 var resp = convert.JSON.encode(buildQuestListResponse());

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

5290 }), true);

5291 res.list(arg_playerId, language: arg_language, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.QuestListResponse res ponse) {

5292 checkQuestListResponse(response);

5293 })));

5294 });

5295

5296 });

5297

5298

5299 unittest.group("resource-RevisionsResourceApi", () {

5300 unittest.test("method--check", () {

5301

5302 var mock = new common_test.HttpServerMock();

5303 api.RevisionsResourceApi res = new api.GamesApi(mock).revisions;

5304 var arg_clientRevision = "foo";

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

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

5307 var pathOffset = 0;

5308 var index;

5309 var subPart;

5310 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5311 pathOffset += 10;

5312 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("revisions/check"));

5313 pathOffset += 15;

5314

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

5316 var queryOffset = 0;

5317 var queryMap = {};

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

5319 parseBool(n) {

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

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

5322 if (n == null) return null;

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

5324 }

5325 if (query.length > 0) {

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

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

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

5329 }

5330 }

5331 unittest.expect(queryMap["clientRevision"].first, unittest.equals(arg_cl ientRevision));

5332

5333

5334 var h = {

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

5336 };

5337 var resp = convert.JSON.encode(buildRevisionCheckResponse());

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

5339 }), true);

5340 res.check(arg_clientRevision).then(unittest.expectAsync(((api.RevisionChec kResponse response) {

5341 checkRevisionCheckResponse(response);

5342 })));

5343 });

5344

5345 });

5346

5347

5348 unittest.group("resource-RoomsResourceApi", () {

5349 unittest.test("method--create", () {

5350

5351 var mock = new common_test.HttpServerMock();

5352 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5353 var arg_request = buildRoomCreateRequest();

5354 var arg_language = "foo";

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

5356 var obj = new api.RoomCreateRequest.fromJson(json);

5357 checkRoomCreateRequest(obj);

5358

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

5360 var pathOffset = 0;

5361 var index;

5362 var subPart;

5363 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5364 pathOffset += 10;

5365 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("rooms/create"));

5366 pathOffset += 12;

5367

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

5369 var queryOffset = 0;

5370 var queryMap = {};

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

5372 parseBool(n) {

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

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

5375 if (n == null) return null;

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

5377 }

5378 if (query.length > 0) {

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

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

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

5382 }

5383 }

5384 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

5385

5386

5387 var h = {

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

5389 };

5390 var resp = convert.JSON.encode(buildRoom());

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

5392 }), true);

5393 res.create(arg_request, language: arg_language).then(unittest.expectAsync( ((api.Room response) {

5394 checkRoom(response);

5395 })));

5396 });

5397

5398 unittest.test("method--decline", () {

5399

5400 var mock = new common_test.HttpServerMock();

5401 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5402 var arg_roomId = "foo";

5403 var arg_language = "foo";

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

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

5406 var pathOffset = 0;

5407 var index;

5408 var subPart;

5409 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5410 pathOffset += 10;

5411 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5412 pathOffset += 6;

5413 index = path.indexOf("/decline", pathOffset);

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

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

5416 pathOffset = index;

5417 unittest.expect(subPart, unittest.equals("$arg_roomId"));

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

5419 pathOffset += 8;

5420

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

5422 var queryOffset = 0;

5423 var queryMap = {};

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

5425 parseBool(n) {

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

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

5428 if (n == null) return null;

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

5430 }

5431 if (query.length > 0) {

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

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

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

5435 }

5436 }

5437 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

5438

5439

5440 var h = {

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

5442 };

5443 var resp = convert.JSON.encode(buildRoom());

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

5445 }), true);

5446 res.decline(arg_roomId, language: arg_language).then(unittest.expectAsync( ((api.Room response) {

5447 checkRoom(response);

5448 })));

5449 });

5450

5451 unittest.test("method--dismiss", () {

5452

5453 var mock = new common_test.HttpServerMock();

5454 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5455 var arg_roomId = "foo";

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

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

5458 var pathOffset = 0;

5459 var index;

5460 var subPart;

5461 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5462 pathOffset += 10;

5463 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5464 pathOffset += 6;

5465 index = path.indexOf("/dismiss", pathOffset);

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

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

5468 pathOffset = index;

5469 unittest.expect(subPart, unittest.equals("$arg_roomId"));

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

5471 pathOffset += 8;

5472

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

5474 var queryOffset = 0;

5475 var queryMap = {};

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

5477 parseBool(n) {

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

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

5480 if (n == null) return null;

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

5482 }

5483 if (query.length > 0) {

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

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

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

5487 }

5488 }

5489

5490

5491 var h = {

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

5493 };

5494 var resp = "";

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

5496 }), true);

5497 res.dismiss(arg_roomId).then(unittest.expectAsync((_) {}));

5498 });

5499

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

5501

5502 var mock = new common_test.HttpServerMock();

5503 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5504 var arg_roomId = "foo";

5505 var arg_language = "foo";

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

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

5508 var pathOffset = 0;

5509 var index;

5510 var subPart;

5511 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5512 pathOffset += 10;

5513 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5514 pathOffset += 6;

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

5516 pathOffset = path.length;

5517 unittest.expect(subPart, unittest.equals("$arg_roomId"));

5518

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

5520 var queryOffset = 0;

5521 var queryMap = {};

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

5523 parseBool(n) {

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

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

5526 if (n == null) return null;

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

5528 }

5529 if (query.length > 0) {

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

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

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

5533 }

5534 }

5535 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

5536

5537

5538 var h = {

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

5540 };

5541 var resp = convert.JSON.encode(buildRoom());

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

5543 }), true);

5544 res.get(arg_roomId, language: arg_language).then(unittest.expectAsync(((ap i.Room response) {

5545 checkRoom(response);

5546 })));

5547 });

5548

5549 unittest.test("method--join", () {

5550

5551 var mock = new common_test.HttpServerMock();

5552 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5553 var arg_request = buildRoomJoinRequest();

5554 var arg_roomId = "foo";

5555 var arg_language = "foo";

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

5557 var obj = new api.RoomJoinRequest.fromJson(json);

5558 checkRoomJoinRequest(obj);

5559

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

5561 var pathOffset = 0;

5562 var index;

5563 var subPart;

5564 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5565 pathOffset += 10;

5566 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5567 pathOffset += 6;

5568 index = path.indexOf("/join", pathOffset);

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

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

5571 pathOffset = index;

5572 unittest.expect(subPart, unittest.equals("$arg_roomId"));

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

5574 pathOffset += 5;

5575

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

5577 var queryOffset = 0;

5578 var queryMap = {};

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

5580 parseBool(n) {

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

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

5583 if (n == null) return null;

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

5585 }

5586 if (query.length > 0) {

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

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

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

5590 }

5591 }

5592 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

5593

5594

5595 var h = {

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

5597 };

5598 var resp = convert.JSON.encode(buildRoom());

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

5600 }), true);

5601 res.join(arg_request, arg_roomId, language: arg_language).then(unittest.ex pectAsync(((api.Room response) {

5602 checkRoom(response);

5603 })));

5604 });

5605

5606 unittest.test("method--leave", () {

5607

5608 var mock = new common_test.HttpServerMock();

5609 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5610 var arg_request = buildRoomLeaveRequest();

5611 var arg_roomId = "foo";

5612 var arg_language = "foo";

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

5614 var obj = new api.RoomLeaveRequest.fromJson(json);

5615 checkRoomLeaveRequest(obj);

5616

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

5618 var pathOffset = 0;

5619 var index;

5620 var subPart;

5621 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5622 pathOffset += 10;

5623 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5624 pathOffset += 6;

5625 index = path.indexOf("/leave", pathOffset);

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

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

5628 pathOffset = index;

5629 unittest.expect(subPart, unittest.equals("$arg_roomId"));

5630 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/leave"));

5631 pathOffset += 6;

5632

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

5634 var queryOffset = 0;

5635 var queryMap = {};

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

5637 parseBool(n) {

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

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

5640 if (n == null) return null;

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

5642 }

5643 if (query.length > 0) {

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

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

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

5647 }

5648 }

5649 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

5650

5651

5652 var h = {

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

5654 };

5655 var resp = convert.JSON.encode(buildRoom());

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

5657 }), true);

5658 res.leave(arg_request, arg_roomId, language: arg_language).then(unittest.e xpectAsync(((api.Room response) {

5659 checkRoom(response);

5660 })));

5661 });

5662

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

5664

5665 var mock = new common_test.HttpServerMock();

5666 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5667 var arg_language = "foo";

5668 var arg_maxResults = 42;

5669 var arg_pageToken = "foo";

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

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

5672 var pathOffset = 0;

5673 var index;

5674 var subPart;

5675 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5676 pathOffset += 10;

5677 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("rooms"));

5678 pathOffset += 5;

5679

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

5681 var queryOffset = 0;

5682 var queryMap = {};

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

5684 parseBool(n) {

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

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

5687 if (n == null) return null;

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

5689 }

5690 if (query.length > 0) {

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

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

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

5694 }

5695 }

5696 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

5699

5700

5701 var h = {

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

5703 };

5704 var resp = convert.JSON.encode(buildRoomList());

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

5706 }), true);

5707 res.list(language: arg_language, maxResults: arg_maxResults, pageToken: ar g_pageToken).then(unittest.expectAsync(((api.RoomList response) {

5708 checkRoomList(response);

5709 })));

5710 });

5711

5712 unittest.test("method--reportStatus", () {

5713

5714 var mock = new common_test.HttpServerMock();

5715 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5716 var arg_request = buildRoomP2PStatuses();

5717 var arg_roomId = "foo";

5718 var arg_language = "foo";

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

5720 var obj = new api.RoomP2PStatuses.fromJson(json);

5721 checkRoomP2PStatuses(obj);

5722

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

5724 var pathOffset = 0;

5725 var index;

5726 var subPart;

5727 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5728 pathOffset += 10;

5729 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5730 pathOffset += 6;

5731 index = path.indexOf("/reportstatus", pathOffset);

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

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

5734 pathOffset = index;

5735 unittest.expect(subPart, unittest.equals("$arg_roomId"));

5736 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/reportstatus"));

5737 pathOffset += 13;

5738

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

5740 var queryOffset = 0;

5741 var queryMap = {};

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

5743 parseBool(n) {

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

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

5746 if (n == null) return null;

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

5748 }

5749 if (query.length > 0) {

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

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

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

5753 }

5754 }

5755 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

5756

5757

5758 var h = {

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

5760 };

5761 var resp = convert.JSON.encode(buildRoomStatus());

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

5763 }), true);

5764 res.reportStatus(arg_request, arg_roomId, language: arg_language).then(uni ttest.expectAsync(((api.RoomStatus response) {

5765 checkRoomStatus(response);

5766 })));

5767 });

5768

5769 });

5770

5771

5772 unittest.group("resource-ScoresResourceApi", () {

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

5774

5775 var mock = new common_test.HttpServerMock();

5776 api.ScoresResourceApi res = new api.GamesApi(mock).scores;

5777 var arg_playerId = "foo";

5778 var arg_leaderboardId = "foo";

5779 var arg_timeSpan = "foo";

5780 var arg_includeRankType = "foo";

5781 var arg_language = "foo";

5782 var arg_maxResults = 42;

5783 var arg_pageToken = "foo";

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

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

5786 var pathOffset = 0;

5787 var index;

5788 var subPart;

5789 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5790 pathOffset += 10;

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

5792 pathOffset += 8;

5793 index = path.indexOf("/leaderboards/", pathOffset);

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

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

5796 pathOffset = index;

5797 unittest.expect(subPart, unittest.equals("$arg_playerId"));

5798 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/leaderboards/"));

5799 pathOffset += 14;

5800 index = path.indexOf("/scores/", pathOffset);

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

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

5803 pathOffset = index;

5804 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));

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

5806 pathOffset += 8;

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

5808 pathOffset = path.length;

5809 unittest.expect(subPart, unittest.equals("$arg_timeSpan"));

5810

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

5812 var queryOffset = 0;

5813 var queryMap = {};

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

5815 parseBool(n) {

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

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

5818 if (n == null) return null;

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

5820 }

5821 if (query.length > 0) {

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

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

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

5825 }

5826 }

5827 unittest.expect(queryMap["includeRankType"].first, unittest.equals(arg_i ncludeRankType));

5828 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

5831

5832

5833 var h = {

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

5835 };

5836 var resp = convert.JSON.encode(buildPlayerLeaderboardScoreListResponse() );

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

5838 }), true);

5839 res.get(arg_playerId, arg_leaderboardId, arg_timeSpan, includeRankType: ar g_includeRankType, language: arg_language, maxResults: arg_maxResults, pageToken : arg_pageToken).then(unittest.expectAsync(((api.PlayerLeaderboardScoreListRespo nse response) {

5840 checkPlayerLeaderboardScoreListResponse(response);

5841 })));

5842 });

5843

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

5845

5846 var mock = new common_test.HttpServerMock();

5847 api.ScoresResourceApi res = new api.GamesApi(mock).scores;

5848 var arg_leaderboardId = "foo";

5849 var arg_collection = "foo";

5850 var arg_timeSpan = "foo";

5851 var arg_language = "foo";

5852 var arg_maxResults = 42;

5853 var arg_pageToken = "foo";

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

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

5856 var pathOffset = 0;

5857 var index;

5858 var subPart;

5859 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5860 pathOffset += 10;

5861 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));

5862 pathOffset += 13;

5863 index = path.indexOf("/scores/", pathOffset);

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

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

5866 pathOffset = index;

5867 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));

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

5869 pathOffset += 8;

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

5871 pathOffset = path.length;

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

5873

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

5875 var queryOffset = 0;

5876 var queryMap = {};

5877 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5878 parseBool(n) {

5879 if (n == "true") return true;

5880 if (n == "false") return false;

5881 if (n == null) return null;

5882 throw new core.ArgumentError("Invalid boolean: $n");

5883 }

5884 if (query.length > 0) {

5885 for (var part in query.split("&")) {

5886 var keyvalue = part.split("=");

5887 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5888 }

5889 }

5890 unittest.expect(queryMap["timeSpan"].first, unittest.equals(arg_timeSpan ));

5891 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

5892 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5893 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5894

5895

5896 var h = {

5897 "content-type" : "application/json; charset=utf-8",

5898 };

5899 var resp = convert.JSON.encode(buildLeaderboardScores());

5900 return new async.Future.value(common_test.stringResponse(200, h, resp));

5901 }), true);

5902 res.list(arg_leaderboardId, arg_collection, arg_timeSpan, language: arg_la nguage, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expe ctAsync(((api.LeaderboardScores response) {

5903 checkLeaderboardScores(response);

5904 })));

5905 });

5906

5907 unittest.test("method--listWindow", () {

5908

5909 var mock = new common_test.HttpServerMock();

5910 api.ScoresResourceApi res = new api.GamesApi(mock).scores;

5911 var arg_leaderboardId = "foo";

5912 var arg_collection = "foo";

5913 var arg_timeSpan = "foo";

5914 var arg_language = "foo";

5915 var arg_maxResults = 42;

5916 var arg_pageToken = "foo";

5917 var arg_resultsAbove = 42;

5918 var arg_returnTopIfAbsent = true;

5919 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5920 var path = (req.url).path;

5921 var pathOffset = 0;

5922 var index;

5923 var subPart;

5924 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5925 pathOffset += 10;

5926 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));

5927 pathOffset += 13;

5928 index = path.indexOf("/window/", pathOffset);

5929 unittest.expect(index >= 0, unittest.isTrue);

5930 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5931 pathOffset = index;

5932 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));

5933 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/window/"));

5934 pathOffset += 8;

5935 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5936 pathOffset = path.length;

5937 unittest.expect(subPart, unittest.equals("$arg_collection"));

5938

5939 var query = (req.url).query;

5940 var queryOffset = 0;

5941 var queryMap = {};

5942 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5943 parseBool(n) {

5944 if (n == "true") return true;

5945 if (n == "false") return false;

5946 if (n == null) return null;

5947 throw new core.ArgumentError("Invalid boolean: $n");

5948 }

5949 if (query.length > 0) {

5950 for (var part in query.split("&")) {

5951 var keyvalue = part.split("=");

5952 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5953 }

5954 }

5955 unittest.expect(queryMap["timeSpan"].first, unittest.equals(arg_timeSpan ));

5956 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

5957 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5958 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5959 unittest.expect(core.int.parse(queryMap["resultsAbove"].first), unittest .equals(arg_resultsAbove));

5960 unittest.expect(queryMap["returnTopIfAbsent"].first, unittest.equals("$a rg_returnTopIfAbsent"));

5961

5962

5963 var h = {

5964 "content-type" : "application/json; charset=utf-8",

5965 };

5966 var resp = convert.JSON.encode(buildLeaderboardScores());

5967 return new async.Future.value(common_test.stringResponse(200, h, resp));

5968 }), true);

5969 res.listWindow(arg_leaderboardId, arg_collection, arg_timeSpan, language: arg_language, maxResults: arg_maxResults, pageToken: arg_pageToken, resultsAbove : arg_resultsAbove, returnTopIfAbsent: arg_returnTopIfAbsent).then(unittest.expe ctAsync(((api.LeaderboardScores response) {

5970 checkLeaderboardScores(response);

5971 })));

5972 });

5973

5974 unittest.test("method--submit", () {

5975

5976 var mock = new common_test.HttpServerMock();

5977 api.ScoresResourceApi res = new api.GamesApi(mock).scores;

5978 var arg_leaderboardId = "foo";

5979 var arg_score = "foo";

5980 var arg_language = "foo";

5981 var arg_scoreTag = "foo";

5982 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5983 var path = (req.url).path;

5984 var pathOffset = 0;

5985 var index;

5986 var subPart;

5987 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

5988 pathOffset += 10;

5989 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));

5990 pathOffset += 13;

5991 index = path.indexOf("/scores", pathOffset);

5992 unittest.expect(index >= 0, unittest.isTrue);

5993 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5994 pathOffset = index;

5995 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));

5996 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/scores"));

5997 pathOffset += 7;

5998

5999 var query = (req.url).query;

6000 var queryOffset = 0;

6001 var queryMap = {};

6002 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6003 parseBool(n) {

6004 if (n == "true") return true;

6005 if (n == "false") return false;

6006 if (n == null) return null;

6007 throw new core.ArgumentError("Invalid boolean: $n");

6008 }

6009 if (query.length > 0) {

6010 for (var part in query.split("&")) {

6011 var keyvalue = part.split("=");

6012 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6013 }

6014 }

6015 unittest.expect(queryMap["score"].first, unittest.equals(arg_score));

6016 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6017 unittest.expect(queryMap["scoreTag"].first, unittest.equals(arg_scoreTag ));

6018

6019

6020 var h = {

6021 "content-type" : "application/json; charset=utf-8",

6022 };

6023 var resp = convert.JSON.encode(buildPlayerScoreResponse());

6024 return new async.Future.value(common_test.stringResponse(200, h, resp));

6025 }), true);

6026 res.submit(arg_leaderboardId, arg_score, language: arg_language, scoreTag: arg_scoreTag).then(unittest.expectAsync(((api.PlayerScoreResponse response) {

6027 checkPlayerScoreResponse(response);

6028 })));

6029 });

6030

6031 unittest.test("method--submitMultiple", () {

6032

6033 var mock = new common_test.HttpServerMock();

6034 api.ScoresResourceApi res = new api.GamesApi(mock).scores;

6035 var arg_request = buildPlayerScoreSubmissionList();

6036 var arg_language = "foo";

6037 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6038 var obj = new api.PlayerScoreSubmissionList.fromJson(json);

6039 checkPlayerScoreSubmissionList(obj);

6040

6041 var path = (req.url).path;

6042 var pathOffset = 0;

6043 var index;

6044 var subPart;

6045 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6046 pathOffset += 10;

6047 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("leaderboards/scores"));

6048 pathOffset += 19;

6049

6050 var query = (req.url).query;

6051 var queryOffset = 0;

6052 var queryMap = {};

6053 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6054 parseBool(n) {

6055 if (n == "true") return true;

6056 if (n == "false") return false;

6057 if (n == null) return null;

6058 throw new core.ArgumentError("Invalid boolean: $n");

6059 }

6060 if (query.length > 0) {

6061 for (var part in query.split("&")) {

6062 var keyvalue = part.split("=");

6063 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6064 }

6065 }

6066 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6067

6068

6069 var h = {

6070 "content-type" : "application/json; charset=utf-8",

6071 };

6072 var resp = convert.JSON.encode(buildPlayerScoreListResponse());

6073 return new async.Future.value(common_test.stringResponse(200, h, resp));

6074 }), true);

6075 res.submitMultiple(arg_request, language: arg_language).then(unittest.expe ctAsync(((api.PlayerScoreListResponse response) {

6076 checkPlayerScoreListResponse(response);

6077 })));

6078 });

6079

6080 });

6081

6082

6083 unittest.group("resource-SnapshotsResourceApi", () {

6084 unittest.test("method--get", () {

6085

6086 var mock = new common_test.HttpServerMock();

6087 api.SnapshotsResourceApi res = new api.GamesApi(mock).snapshots;

6088 var arg_snapshotId = "foo";

6089 var arg_language = "foo";

6090 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6091 var path = (req.url).path;

6092 var pathOffset = 0;

6093 var index;

6094 var subPart;

6095 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6096 pathOffset += 10;

6097 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("snapshots/"));

6098 pathOffset += 10;

6099 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6100 pathOffset = path.length;

6101 unittest.expect(subPart, unittest.equals("$arg_snapshotId"));

6102

6103 var query = (req.url).query;

6104 var queryOffset = 0;

6105 var queryMap = {};

6106 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6107 parseBool(n) {

6108 if (n == "true") return true;

6109 if (n == "false") return false;

6110 if (n == null) return null;

6111 throw new core.ArgumentError("Invalid boolean: $n");

6112 }

6113 if (query.length > 0) {

6114 for (var part in query.split("&")) {

6115 var keyvalue = part.split("=");

6116 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6117 }

6118 }

6119 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6120

6121

6122 var h = {

6123 "content-type" : "application/json; charset=utf-8",

6124 };

6125 var resp = convert.JSON.encode(buildSnapshot());

6126 return new async.Future.value(common_test.stringResponse(200, h, resp));

6127 }), true);

6128 res.get(arg_snapshotId, language: arg_language).then(unittest.expectAsync( ((api.Snapshot response) {

6129 checkSnapshot(response);

6130 })));

6131 });

6132

6133 unittest.test("method--list", () {

6134

6135 var mock = new common_test.HttpServerMock();

6136 api.SnapshotsResourceApi res = new api.GamesApi(mock).snapshots;

6137 var arg_playerId = "foo";

6138 var arg_language = "foo";

6139 var arg_maxResults = 42;

6140 var arg_pageToken = "foo";

6141 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6142 var path = (req.url).path;

6143 var pathOffset = 0;

6144 var index;

6145 var subPart;

6146 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6147 pathOffset += 10;

6148 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));

6149 pathOffset += 8;

6150 index = path.indexOf("/snapshots", pathOffset);

6151 unittest.expect(index >= 0, unittest.isTrue);

6152 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6153 pathOffset = index;

6154 unittest.expect(subPart, unittest.equals("$arg_playerId"));

6155 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/snapshots"));

6156 pathOffset += 10;

6157

6158 var query = (req.url).query;

6159 var queryOffset = 0;

6160 var queryMap = {};

6161 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6162 parseBool(n) {

6163 if (n == "true") return true;

6164 if (n == "false") return false;

6165 if (n == null) return null;

6166 throw new core.ArgumentError("Invalid boolean: $n");

6167 }

6168 if (query.length > 0) {

6169 for (var part in query.split("&")) {

6170 var keyvalue = part.split("=");

6171 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6172 }

6173 }

6174 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6175 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6176 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6177

6178

6179 var h = {

6180 "content-type" : "application/json; charset=utf-8",

6181 };

6182 var resp = convert.JSON.encode(buildSnapshotListResponse());

6183 return new async.Future.value(common_test.stringResponse(200, h, resp));

6184 }), true);

6185 res.list(arg_playerId, language: arg_language, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.SnapshotListResponse response) {

6186 checkSnapshotListResponse(response);

6187 })));

6188 });

6189

6190 });

6191

6192

6193 unittest.group("resource-TurnBasedMatchesResourceApi", () {

6194 unittest.test("method--cancel", () {

6195

6196 var mock = new common_test.HttpServerMock();

6197 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6198 var arg_matchId = "foo";

6199 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6200 var path = (req.url).path;

6201 var pathOffset = 0;

6202 var index;

6203 var subPart;

6204 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6205 pathOffset += 10;

6206 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6207 pathOffset += 17;

6208 index = path.indexOf("/cancel", pathOffset);

6209 unittest.expect(index >= 0, unittest.isTrue);

6210 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6211 pathOffset = index;

6212 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6213 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/cancel"));

6214 pathOffset += 7;

6215

6216 var query = (req.url).query;

6217 var queryOffset = 0;

6218 var queryMap = {};

6219 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6220 parseBool(n) {

6221 if (n == "true") return true;

6222 if (n == "false") return false;

6223 if (n == null) return null;

6224 throw new core.ArgumentError("Invalid boolean: $n");

6225 }

6226 if (query.length > 0) {

6227 for (var part in query.split("&")) {

6228 var keyvalue = part.split("=");

6229 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6230 }

6231 }

6232

6233

6234 var h = {

6235 "content-type" : "application/json; charset=utf-8",

6236 };

6237 var resp = "";

6238 return new async.Future.value(common_test.stringResponse(200, h, resp));

6239 }), true);

6240 res.cancel(arg_matchId).then(unittest.expectAsync((_) {}));

6241 });

6242

6243 unittest.test("method--create", () {

6244

6245 var mock = new common_test.HttpServerMock();

6246 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6247 var arg_request = buildTurnBasedMatchCreateRequest();

6248 var arg_language = "foo";

6249 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6250 var obj = new api.TurnBasedMatchCreateRequest.fromJson(json);

6251 checkTurnBasedMatchCreateRequest(obj);

6252

6253 var path = (req.url).path;

6254 var pathOffset = 0;

6255 var index;

6256 var subPart;

6257 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6258 pathOffset += 10;

6259 unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.eq uals("turnbasedmatches/create"));

6260 pathOffset += 23;

6261

6262 var query = (req.url).query;

6263 var queryOffset = 0;

6264 var queryMap = {};

6265 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6266 parseBool(n) {

6267 if (n == "true") return true;

6268 if (n == "false") return false;

6269 if (n == null) return null;

6270 throw new core.ArgumentError("Invalid boolean: $n");

6271 }

6272 if (query.length > 0) {

6273 for (var part in query.split("&")) {

6274 var keyvalue = part.split("=");

6275 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6276 }

6277 }

6278 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6279

6280

6281 var h = {

6282 "content-type" : "application/json; charset=utf-8",

6283 };

6284 var resp = convert.JSON.encode(buildTurnBasedMatch());

6285 return new async.Future.value(common_test.stringResponse(200, h, resp));

6286 }), true);

6287 res.create(arg_request, language: arg_language).then(unittest.expectAsync( ((api.TurnBasedMatch response) {

6288 checkTurnBasedMatch(response);

6289 })));

6290 });

6291

6292 unittest.test("method--decline", () {

6293

6294 var mock = new common_test.HttpServerMock();

6295 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6296 var arg_matchId = "foo";

6297 var arg_language = "foo";

6298 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6299 var path = (req.url).path;

6300 var pathOffset = 0;

6301 var index;

6302 var subPart;

6303 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6304 pathOffset += 10;

6305 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6306 pathOffset += 17;

6307 index = path.indexOf("/decline", pathOffset);

6308 unittest.expect(index >= 0, unittest.isTrue);

6309 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6310 pathOffset = index;

6311 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6312 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/decline"));

6313 pathOffset += 8;

6314

6315 var query = (req.url).query;

6316 var queryOffset = 0;

6317 var queryMap = {};

6318 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6319 parseBool(n) {

6320 if (n == "true") return true;

6321 if (n == "false") return false;

6322 if (n == null) return null;

6323 throw new core.ArgumentError("Invalid boolean: $n");

6324 }

6325 if (query.length > 0) {

6326 for (var part in query.split("&")) {

6327 var keyvalue = part.split("=");

6328 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6329 }

6330 }

6331 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6332

6333

6334 var h = {

6335 "content-type" : "application/json; charset=utf-8",

6336 };

6337 var resp = convert.JSON.encode(buildTurnBasedMatch());

6338 return new async.Future.value(common_test.stringResponse(200, h, resp));

6339 }), true);

6340 res.decline(arg_matchId, language: arg_language).then(unittest.expectAsync (((api.TurnBasedMatch response) {

6341 checkTurnBasedMatch(response);

6342 })));

6343 });

6344

6345 unittest.test("method--dismiss", () {

6346

6347 var mock = new common_test.HttpServerMock();

6348 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6349 var arg_matchId = "foo";

6350 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6351 var path = (req.url).path;

6352 var pathOffset = 0;

6353 var index;

6354 var subPart;

6355 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6356 pathOffset += 10;

6357 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6358 pathOffset += 17;

6359 index = path.indexOf("/dismiss", pathOffset);

6360 unittest.expect(index >= 0, unittest.isTrue);

6361 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6362 pathOffset = index;

6363 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6364 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/dismiss"));

6365 pathOffset += 8;

6366

6367 var query = (req.url).query;

6368 var queryOffset = 0;

6369 var queryMap = {};

6370 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6371 parseBool(n) {

6372 if (n == "true") return true;

6373 if (n == "false") return false;

6374 if (n == null) return null;

6375 throw new core.ArgumentError("Invalid boolean: $n");

6376 }

6377 if (query.length > 0) {

6378 for (var part in query.split("&")) {

6379 var keyvalue = part.split("=");

6380 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6381 }

6382 }

6383

6384

6385 var h = {

6386 "content-type" : "application/json; charset=utf-8",

6387 };

6388 var resp = "";

6389 return new async.Future.value(common_test.stringResponse(200, h, resp));

6390 }), true);

6391 res.dismiss(arg_matchId).then(unittest.expectAsync((_) {}));

6392 });

6393

6394 unittest.test("method--finish", () {

6395

6396 var mock = new common_test.HttpServerMock();

6397 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6398 var arg_request = buildTurnBasedMatchResults();

6399 var arg_matchId = "foo";

6400 var arg_language = "foo";

6401 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6402 var obj = new api.TurnBasedMatchResults.fromJson(json);

6403 checkTurnBasedMatchResults(obj);

6404

6405 var path = (req.url).path;

6406 var pathOffset = 0;

6407 var index;

6408 var subPart;

6409 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6410 pathOffset += 10;

6411 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6412 pathOffset += 17;

6413 index = path.indexOf("/finish", pathOffset);

6414 unittest.expect(index >= 0, unittest.isTrue);

6415 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6416 pathOffset = index;

6417 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6418 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/finish"));

6419 pathOffset += 7;

6420

6421 var query = (req.url).query;

6422 var queryOffset = 0;

6423 var queryMap = {};

6424 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6425 parseBool(n) {

6426 if (n == "true") return true;

6427 if (n == "false") return false;

6428 if (n == null) return null;

6429 throw new core.ArgumentError("Invalid boolean: $n");

6430 }

6431 if (query.length > 0) {

6432 for (var part in query.split("&")) {

6433 var keyvalue = part.split("=");

6434 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6435 }

6436 }

6437 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6438

6439

6440 var h = {

6441 "content-type" : "application/json; charset=utf-8",

6442 };

6443 var resp = convert.JSON.encode(buildTurnBasedMatch());

6444 return new async.Future.value(common_test.stringResponse(200, h, resp));

6445 }), true);

6446 res.finish(arg_request, arg_matchId, language: arg_language).then(unittest .expectAsync(((api.TurnBasedMatch response) {

6447 checkTurnBasedMatch(response);

6448 })));

6449 });

6450

6451 unittest.test("method--get", () {

6452

6453 var mock = new common_test.HttpServerMock();

6454 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6455 var arg_matchId = "foo";

6456 var arg_includeMatchData = true;

6457 var arg_language = "foo";

6458 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6459 var path = (req.url).path;

6460 var pathOffset = 0;

6461 var index;

6462 var subPart;

6463 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6464 pathOffset += 10;

6465 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6466 pathOffset += 17;

6467 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6468 pathOffset = path.length;

6469 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6470

6471 var query = (req.url).query;

6472 var queryOffset = 0;

6473 var queryMap = {};

6474 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6475 parseBool(n) {

6476 if (n == "true") return true;

6477 if (n == "false") return false;

6478 if (n == null) return null;

6479 throw new core.ArgumentError("Invalid boolean: $n");

6480 }

6481 if (query.length > 0) {

6482 for (var part in query.split("&")) {

6483 var keyvalue = part.split("=");

6484 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6485 }

6486 }

6487 unittest.expect(queryMap["includeMatchData"].first, unittest.equals("$ar g_includeMatchData"));

6488 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6489

6490

6491 var h = {

6492 "content-type" : "application/json; charset=utf-8",

6493 };

6494 var resp = convert.JSON.encode(buildTurnBasedMatch());

6495 return new async.Future.value(common_test.stringResponse(200, h, resp));

6496 }), true);

6497 res.get(arg_matchId, includeMatchData: arg_includeMatchData, language: arg _language).then(unittest.expectAsync(((api.TurnBasedMatch response) {

6498 checkTurnBasedMatch(response);

6499 })));

6500 });

6501

6502 unittest.test("method--join", () {

6503

6504 var mock = new common_test.HttpServerMock();

6505 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6506 var arg_matchId = "foo";

6507 var arg_language = "foo";

6508 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6509 var path = (req.url).path;

6510 var pathOffset = 0;

6511 var index;

6512 var subPart;

6513 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6514 pathOffset += 10;

6515 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6516 pathOffset += 17;

6517 index = path.indexOf("/join", pathOffset);

6518 unittest.expect(index >= 0, unittest.isTrue);

6519 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6520 pathOffset = index;

6521 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6522 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/join"));

6523 pathOffset += 5;

6524

6525 var query = (req.url).query;

6526 var queryOffset = 0;

6527 var queryMap = {};

6528 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6529 parseBool(n) {

6530 if (n == "true") return true;

6531 if (n == "false") return false;

6532 if (n == null) return null;

6533 throw new core.ArgumentError("Invalid boolean: $n");

6534 }

6535 if (query.length > 0) {

6536 for (var part in query.split("&")) {

6537 var keyvalue = part.split("=");

6538 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6539 }

6540 }

6541 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6542

6543

6544 var h = {

6545 "content-type" : "application/json; charset=utf-8",

6546 };

6547 var resp = convert.JSON.encode(buildTurnBasedMatch());

6548 return new async.Future.value(common_test.stringResponse(200, h, resp));

6549 }), true);

6550 res.join(arg_matchId, language: arg_language).then(unittest.expectAsync((( api.TurnBasedMatch response) {

6551 checkTurnBasedMatch(response);

6552 })));

6553 });

6554

6555 unittest.test("method--leave", () {

6556

6557 var mock = new common_test.HttpServerMock();

6558 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6559 var arg_matchId = "foo";

6560 var arg_language = "foo";

6561 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6562 var path = (req.url).path;

6563 var pathOffset = 0;

6564 var index;

6565 var subPart;

6566 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6567 pathOffset += 10;

6568 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6569 pathOffset += 17;

6570 index = path.indexOf("/leave", pathOffset);

6571 unittest.expect(index >= 0, unittest.isTrue);

6572 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6573 pathOffset = index;

6574 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6575 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/leave"));

6576 pathOffset += 6;

6577

6578 var query = (req.url).query;

6579 var queryOffset = 0;

6580 var queryMap = {};

6581 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6582 parseBool(n) {

6583 if (n == "true") return true;

6584 if (n == "false") return false;

6585 if (n == null) return null;

6586 throw new core.ArgumentError("Invalid boolean: $n");

6587 }

6588 if (query.length > 0) {

6589 for (var part in query.split("&")) {

6590 var keyvalue = part.split("=");

6591 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6592 }

6593 }

6594 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6595

6596

6597 var h = {

6598 "content-type" : "application/json; charset=utf-8",

6599 };

6600 var resp = convert.JSON.encode(buildTurnBasedMatch());

6601 return new async.Future.value(common_test.stringResponse(200, h, resp));

6602 }), true);

6603 res.leave(arg_matchId, language: arg_language).then(unittest.expectAsync(( (api.TurnBasedMatch response) {

6604 checkTurnBasedMatch(response);

6605 })));

6606 });

6607

6608 unittest.test("method--leaveTurn", () {

6609

6610 var mock = new common_test.HttpServerMock();

6611 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6612 var arg_matchId = "foo";

6613 var arg_matchVersion = 42;

6614 var arg_language = "foo";

6615 var arg_pendingParticipantId = "foo";

6616 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6617 var path = (req.url).path;

6618 var pathOffset = 0;

6619 var index;

6620 var subPart;

6621 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6622 pathOffset += 10;

6623 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6624 pathOffset += 17;

6625 index = path.indexOf("/leaveTurn", pathOffset);

6626 unittest.expect(index >= 0, unittest.isTrue);

6627 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6628 pathOffset = index;

6629 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6630 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/leaveTurn"));

6631 pathOffset += 10;

6632

6633 var query = (req.url).query;

6634 var queryOffset = 0;

6635 var queryMap = {};

6636 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6637 parseBool(n) {

6638 if (n == "true") return true;

6639 if (n == "false") return false;

6640 if (n == null) return null;

6641 throw new core.ArgumentError("Invalid boolean: $n");

6642 }

6643 if (query.length > 0) {

6644 for (var part in query.split("&")) {

6645 var keyvalue = part.split("=");

6646 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6647 }

6648 }

6649 unittest.expect(core.int.parse(queryMap["matchVersion"].first), unittest .equals(arg_matchVersion));

6650 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6651 unittest.expect(queryMap["pendingParticipantId"].first, unittest.equals( arg_pendingParticipantId));

6652

6653

6654 var h = {

6655 "content-type" : "application/json; charset=utf-8",

6656 };

6657 var resp = convert.JSON.encode(buildTurnBasedMatch());

6658 return new async.Future.value(common_test.stringResponse(200, h, resp));

6659 }), true);

6660 res.leaveTurn(arg_matchId, arg_matchVersion, language: arg_language, pendi ngParticipantId: arg_pendingParticipantId).then(unittest.expectAsync(((api.TurnB asedMatch response) {

6661 checkTurnBasedMatch(response);

6662 })));

6663 });

6664

6665 unittest.test("method--list", () {

6666

6667 var mock = new common_test.HttpServerMock();

6668 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6669 var arg_includeMatchData = true;

6670 var arg_language = "foo";

6671 var arg_maxCompletedMatches = 42;

6672 var arg_maxResults = 42;

6673 var arg_pageToken = "foo";

6674 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6675 var path = (req.url).path;

6676 var pathOffset = 0;

6677 var index;

6678 var subPart;

6679 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6680 pathOffset += 10;

6681 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("turnbasedmatches"));

6682 pathOffset += 16;

6683

6684 var query = (req.url).query;

6685 var queryOffset = 0;

6686 var queryMap = {};

6687 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6688 parseBool(n) {

6689 if (n == "true") return true;

6690 if (n == "false") return false;

6691 if (n == null) return null;

6692 throw new core.ArgumentError("Invalid boolean: $n");

6693 }

6694 if (query.length > 0) {

6695 for (var part in query.split("&")) {

6696 var keyvalue = part.split("=");

6697 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6698 }

6699 }

6700 unittest.expect(queryMap["includeMatchData"].first, unittest.equals("$ar g_includeMatchData"));

6701 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6702 unittest.expect(core.int.parse(queryMap["maxCompletedMatches"].first), u nittest.equals(arg_maxCompletedMatches));

6703 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6704 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6705

6706

6707 var h = {

6708 "content-type" : "application/json; charset=utf-8",

6709 };

6710 var resp = convert.JSON.encode(buildTurnBasedMatchList());

6711 return new async.Future.value(common_test.stringResponse(200, h, resp));

6712 }), true);

6713 res.list(includeMatchData: arg_includeMatchData, language: arg_language, m axCompletedMatches: arg_maxCompletedMatches, maxResults: arg_maxResults, pageTok en: arg_pageToken).then(unittest.expectAsync(((api.TurnBasedMatchList response) {

6714 checkTurnBasedMatchList(response);

6715 })));

6716 });

6717

6718 unittest.test("method--rematch", () {

6719

6720 var mock = new common_test.HttpServerMock();

6721 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6722 var arg_matchId = "foo";

6723 var arg_language = "foo";

6724 var arg_requestId = "foo";

6725 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6726 var path = (req.url).path;

6727 var pathOffset = 0;

6728 var index;

6729 var subPart;

6730 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6731 pathOffset += 10;

6732 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6733 pathOffset += 17;

6734 index = path.indexOf("/rematch", pathOffset);

6735 unittest.expect(index >= 0, unittest.isTrue);

6736 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6737 pathOffset = index;

6738 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6739 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/rematch"));

6740 pathOffset += 8;

6741

6742 var query = (req.url).query;

6743 var queryOffset = 0;

6744 var queryMap = {};

6745 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6746 parseBool(n) {

6747 if (n == "true") return true;

6748 if (n == "false") return false;

6749 if (n == null) return null;

6750 throw new core.ArgumentError("Invalid boolean: $n");

6751 }

6752 if (query.length > 0) {

6753 for (var part in query.split("&")) {

6754 var keyvalue = part.split("=");

6755 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6756 }

6757 }

6758 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6759 unittest.expect(queryMap["requestId"].first, unittest.equals(arg_request Id));

6760

6761

6762 var h = {

6763 "content-type" : "application/json; charset=utf-8",

6764 };

6765 var resp = convert.JSON.encode(buildTurnBasedMatchRematch());

6766 return new async.Future.value(common_test.stringResponse(200, h, resp));

6767 }), true);

6768 res.rematch(arg_matchId, language: arg_language, requestId: arg_requestId) .then(unittest.expectAsync(((api.TurnBasedMatchRematch response) {

6769 checkTurnBasedMatchRematch(response);

6770 })));

6771 });

6772

6773 unittest.test("method--sync", () {

6774

6775 var mock = new common_test.HttpServerMock();

6776 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6777 var arg_includeMatchData = true;

6778 var arg_language = "foo";

6779 var arg_maxCompletedMatches = 42;

6780 var arg_maxResults = 42;

6781 var arg_pageToken = "foo";

6782 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6783 var path = (req.url).path;

6784 var pathOffset = 0;

6785 var index;

6786 var subPart;

6787 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6788 pathOffset += 10;

6789 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("turnbasedmatches/sync"));

6790 pathOffset += 21;

6791

6792 var query = (req.url).query;

6793 var queryOffset = 0;

6794 var queryMap = {};

6795 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6796 parseBool(n) {

6797 if (n == "true") return true;

6798 if (n == "false") return false;

6799 if (n == null) return null;

6800 throw new core.ArgumentError("Invalid boolean: $n");

6801 }

6802 if (query.length > 0) {

6803 for (var part in query.split("&")) {

6804 var keyvalue = part.split("=");

6805 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6806 }

6807 }

6808 unittest.expect(queryMap["includeMatchData"].first, unittest.equals("$ar g_includeMatchData"));

6809 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6810 unittest.expect(core.int.parse(queryMap["maxCompletedMatches"].first), u nittest.equals(arg_maxCompletedMatches));

6811 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6812 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6813

6814

6815 var h = {

6816 "content-type" : "application/json; charset=utf-8",

6817 };

6818 var resp = convert.JSON.encode(buildTurnBasedMatchSync());

6819 return new async.Future.value(common_test.stringResponse(200, h, resp));

6820 }), true);

6821 res.sync(includeMatchData: arg_includeMatchData, language: arg_language, m axCompletedMatches: arg_maxCompletedMatches, maxResults: arg_maxResults, pageTok en: arg_pageToken).then(unittest.expectAsync(((api.TurnBasedMatchSync response) {

6822 checkTurnBasedMatchSync(response);

6823 })));

6824 });

6825

6826 unittest.test("method--takeTurn", () {

6827

6828 var mock = new common_test.HttpServerMock();

6829 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6830 var arg_request = buildTurnBasedMatchTurn();

6831 var arg_matchId = "foo";

6832 var arg_language = "foo";

6833 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6834 var obj = new api.TurnBasedMatchTurn.fromJson(json);

6835 checkTurnBasedMatchTurn(obj);

6836

6837 var path = (req.url).path;

6838 var pathOffset = 0;

6839 var index;

6840 var subPart;

6841 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));

6842 pathOffset += 10;

6843 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6844 pathOffset += 17;

6845 index = path.indexOf("/turn", pathOffset);

6846 unittest.expect(index >= 0, unittest.isTrue);

6847 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6848 pathOffset = index;

6849 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6850 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/turn"));

6851 pathOffset += 5;

6852

6853 var query = (req.url).query;

6854 var queryOffset = 0;

6855 var queryMap = {};

6856 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6857 parseBool(n) {

6858 if (n == "true") return true;

6859 if (n == "false") return false;

6860 if (n == null) return null;

6861 throw new core.ArgumentError("Invalid boolean: $n");

6862 }

6863 if (query.length > 0) {

6864 for (var part in query.split("&")) {

6865 var keyvalue = part.split("=");

6866 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6867 }

6868 }

6869 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

6870

6871

6872 var h = {

6873 "content-type" : "application/json; charset=utf-8",

6874 };

6875 var resp = convert.JSON.encode(buildTurnBasedMatch());

6876 return new async.Future.value(common_test.stringResponse(200, h, resp));

6877 }), true);

6878 res.takeTurn(arg_request, arg_matchId, language: arg_language).then(unitte st.expectAsync(((api.TurnBasedMatch response) {

6879 checkTurnBasedMatch(response);

6880 })));

6881 });

6882

6883 });

6884

6885

6886 }

6887

OLD	NEW

« no previous file with comments | « generated/googleapis/test/fusiontables/v1_test.dart ('k') | generated/googleapis/test/games/v1_test.dart » ('j') | no next file with comments »