generated/googleapis/test/games/v1_test.dart - Issue 595873002: Api roll 1: 2014-09-23

Side by Side Diff: generated/googleapis/test/games/v1_test.dart

Issue 595873002: Api roll 1: 2014-09-23 (Closed) Base URL: git@github.com:dart-lang/googleapis.git@master

Patch Set: Update config.yaml to include v0.2.0 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:

« discovery/googleapis/prediction__v1.6.json ('K') | « generated/googleapis/test/fusiontables/v1_test.dart ('k') | generated/googleapis/test/gamesmanagement/v1management_test.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
1 library googleapis.games.v1.test;	1 library googleapis.games.v1.test;

2	2

3 import "dart:core" as core;	3 import "dart:core" as core;

4 import "dart:collection" as collection;	4 import "dart:collection" as collection;

5 import "dart:async" as async;	5 import "dart:async" as async;

6 import "dart:convert" as convert;	6 import "dart:convert" as convert;

7	7

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

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

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

(...skipping 4084 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4095 var mock = new common_test.HttpServerMock();	4095 var mock = new common_test.HttpServerMock();

4096 api.AchievementDefinitionsResourceApi res = new api.GamesApi(mock).achieve mentDefinitions;	4096 api.AchievementDefinitionsResourceApi res = new api.GamesApi(mock).achieve mentDefinitions;

4097 var arg_language = "foo";	4097 var arg_language = "foo";

4098 var arg_maxResults = 42;	4098 var arg_maxResults = 42;

4099 var arg_pageToken = "foo";	4099 var arg_pageToken = "foo";

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

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

4102 var pathOffset = 0;	4102 var pathOffset = 0;

4103 var index;	4103 var index;

4104 var subPart;	4104 var subPart;

4105 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4105 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4106 pathOffset += 10;	4106 pathOffset += 1;

	4107 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4108 pathOffset += 9;

4107 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("achievements"));	4109 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("achievements"));

4108 pathOffset += 12;	4110 pathOffset += 12;

4109	4111

4110 var query = (req.url).query;	4112 var query = (req.url).query;

4111 var queryOffset = 0;	4113 var queryOffset = 0;

4112 var queryMap = {};	4114 var queryMap = {};

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

4114 parseBool(n) {	4116 parseBool(n) {

4115 if (n == "true") return true;	4117 if (n == "true") return true;

4116 if (n == "false") return false;	4118 if (n == "false") return false;

(...skipping 31 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4148 var mock = new common_test.HttpServerMock();	4150 var mock = new common_test.HttpServerMock();

4149 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;	4151 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4150 var arg_achievementId = "foo";	4152 var arg_achievementId = "foo";

4151 var arg_stepsToIncrement = 42;	4153 var arg_stepsToIncrement = 42;

4152 var arg_requestId = "foo";	4154 var arg_requestId = "foo";

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

4154 var path = (req.url).path;	4156 var path = (req.url).path;

4155 var pathOffset = 0;	4157 var pathOffset = 0;

4156 var index;	4158 var index;

4157 var subPart;	4159 var subPart;

4158 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4160 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4159 pathOffset += 10;	4161 pathOffset += 1;

	4162 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4163 pathOffset += 9;

4160 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));	4164 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));

4161 pathOffset += 13;	4165 pathOffset += 13;

4162 index = path.indexOf("/increment", pathOffset);	4166 index = path.indexOf("/increment", pathOffset);

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

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

4165 pathOffset = index;	4169 pathOffset = index;

4166 unittest.expect(subPart, unittest.equals("$arg_achievementId"));	4170 unittest.expect(subPart, unittest.equals("$arg_achievementId"));

4167 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/increment"));	4171 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/increment"));

4168 pathOffset += 10;	4172 pathOffset += 10;

4169	4173

(...skipping 35 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4205 var arg_playerId = "foo";	4209 var arg_playerId = "foo";

4206 var arg_language = "foo";	4210 var arg_language = "foo";

4207 var arg_maxResults = 42;	4211 var arg_maxResults = 42;

4208 var arg_pageToken = "foo";	4212 var arg_pageToken = "foo";

4209 var arg_state = "foo";	4213 var arg_state = "foo";

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

4211 var path = (req.url).path;	4215 var path = (req.url).path;

4212 var pathOffset = 0;	4216 var pathOffset = 0;

4213 var index;	4217 var index;

4214 var subPart;	4218 var subPart;

4215 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4219 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4216 pathOffset += 10;	4220 pathOffset += 1;

	4221 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4222 pathOffset += 9;

4217 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));	4223 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));

4218 pathOffset += 8;	4224 pathOffset += 8;

4219 index = path.indexOf("/achievements", pathOffset);	4225 index = path.indexOf("/achievements", pathOffset);

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

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

4222 pathOffset = index;	4228 pathOffset = index;

4223 unittest.expect(subPart, unittest.equals("$arg_playerId"));	4229 unittest.expect(subPart, unittest.equals("$arg_playerId"));

4224 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/achievements"));	4230 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/achievements"));

4225 pathOffset += 13;	4231 pathOffset += 13;

4226	4232

(...skipping 33 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4260 unittest.test("method--reveal", () {	4266 unittest.test("method--reveal", () {

4261	4267

4262 var mock = new common_test.HttpServerMock();	4268 var mock = new common_test.HttpServerMock();

4263 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;	4269 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4264 var arg_achievementId = "foo";	4270 var arg_achievementId = "foo";

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

4266 var path = (req.url).path;	4272 var path = (req.url).path;

4267 var pathOffset = 0;	4273 var pathOffset = 0;

4268 var index;	4274 var index;

4269 var subPart;	4275 var subPart;

4270 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4276 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4271 pathOffset += 10;	4277 pathOffset += 1;

	4278 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4279 pathOffset += 9;

4272 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));	4280 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));

4273 pathOffset += 13;	4281 pathOffset += 13;

4274 index = path.indexOf("/reveal", pathOffset);	4282 index = path.indexOf("/reveal", pathOffset);

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

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

4277 pathOffset = index;	4285 pathOffset = index;

4278 unittest.expect(subPart, unittest.equals("$arg_achievementId"));	4286 unittest.expect(subPart, unittest.equals("$arg_achievementId"));

4279 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/reveal"));	4287 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/reveal"));

4280 pathOffset += 7;	4288 pathOffset += 7;

4281	4289

(...skipping 30 matching lines...) Expand all Loading...
4312	4320

4313 var mock = new common_test.HttpServerMock();	4321 var mock = new common_test.HttpServerMock();

4314 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;	4322 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4315 var arg_achievementId = "foo";	4323 var arg_achievementId = "foo";

4316 var arg_steps = 42;	4324 var arg_steps = 42;

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

4318 var path = (req.url).path;	4326 var path = (req.url).path;

4319 var pathOffset = 0;	4327 var pathOffset = 0;

4320 var index;	4328 var index;

4321 var subPart;	4329 var subPart;

4322 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4330 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4323 pathOffset += 10;	4331 pathOffset += 1;

	4332 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4333 pathOffset += 9;

4324 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));	4334 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));

4325 pathOffset += 13;	4335 pathOffset += 13;

4326 index = path.indexOf("/setStepsAtLeast", pathOffset);	4336 index = path.indexOf("/setStepsAtLeast", pathOffset);

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

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

4329 pathOffset = index;	4339 pathOffset = index;

4330 unittest.expect(subPart, unittest.equals("$arg_achievementId"));	4340 unittest.expect(subPart, unittest.equals("$arg_achievementId"));

4331 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/setStepsAtLeast"));	4341 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/setStepsAtLeast"));

4332 pathOffset += 16;	4342 pathOffset += 16;

4333	4343

(...skipping 30 matching lines...) Expand all Loading...
4364 unittest.test("method--unlock", () {	4374 unittest.test("method--unlock", () {

4365	4375

4366 var mock = new common_test.HttpServerMock();	4376 var mock = new common_test.HttpServerMock();

4367 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;	4377 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4368 var arg_achievementId = "foo";	4378 var arg_achievementId = "foo";

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

4370 var path = (req.url).path;	4380 var path = (req.url).path;

4371 var pathOffset = 0;	4381 var pathOffset = 0;

4372 var index;	4382 var index;

4373 var subPart;	4383 var subPart;

4374 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4384 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4375 pathOffset += 10;	4385 pathOffset += 1;

	4386 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4387 pathOffset += 9;

4376 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));	4388 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("achievements/"));

4377 pathOffset += 13;	4389 pathOffset += 13;

4378 index = path.indexOf("/unlock", pathOffset);	4390 index = path.indexOf("/unlock", pathOffset);

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

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

4381 pathOffset = index;	4393 pathOffset = index;

4382 unittest.expect(subPart, unittest.equals("$arg_achievementId"));	4394 unittest.expect(subPart, unittest.equals("$arg_achievementId"));

4383 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/unlock"));	4395 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/unlock"));

4384 pathOffset += 7;	4396 pathOffset += 7;

4385	4397

(...skipping 32 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4418 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;	4430 api.AchievementsResourceApi res = new api.GamesApi(mock).achievements;

4419 var arg_request = buildAchievementUpdateMultipleRequest();	4431 var arg_request = buildAchievementUpdateMultipleRequest();

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

4421 var obj = new api.AchievementUpdateMultipleRequest.fromJson(json);	4433 var obj = new api.AchievementUpdateMultipleRequest.fromJson(json);

4422 checkAchievementUpdateMultipleRequest(obj);	4434 checkAchievementUpdateMultipleRequest(obj);

4423	4435

4424 var path = (req.url).path;	4436 var path = (req.url).path;

4425 var pathOffset = 0;	4437 var pathOffset = 0;

4426 var index;	4438 var index;

4427 var subPart;	4439 var subPart;

4428 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4440 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4429 pathOffset += 10;	4441 pathOffset += 1;

	4442 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4443 pathOffset += 9;

4430 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("achievements/updateMultiple"));	4444 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("achievements/updateMultiple"));

4431 pathOffset += 27;	4445 pathOffset += 27;

4432	4446

4433 var query = (req.url).query;	4447 var query = (req.url).query;

4434 var queryOffset = 0;	4448 var queryOffset = 0;

4435 var queryMap = {};	4449 var queryMap = {};

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

4437 parseBool(n) {	4451 parseBool(n) {

4438 if (n == "true") return true;	4452 if (n == "true") return true;

4439 if (n == "false") return false;	4453 if (n == "false") return false;

(...skipping 28 matching lines...) Expand all Loading...
4468 var mock = new common_test.HttpServerMock();	4482 var mock = new common_test.HttpServerMock();

4469 api.ApplicationsResourceApi res = new api.GamesApi(mock).applications;	4483 api.ApplicationsResourceApi res = new api.GamesApi(mock).applications;

4470 var arg_applicationId = "foo";	4484 var arg_applicationId = "foo";

4471 var arg_language = "foo";	4485 var arg_language = "foo";

4472 var arg_platformType = "foo";	4486 var arg_platformType = "foo";

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

4474 var path = (req.url).path;	4488 var path = (req.url).path;

4475 var pathOffset = 0;	4489 var pathOffset = 0;

4476 var index;	4490 var index;

4477 var subPart;	4491 var subPart;

4478 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4492 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4479 pathOffset += 10;	4493 pathOffset += 1;

	4494 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4495 pathOffset += 9;

4480 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("applications/"));	4496 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("applications/"));

4481 pathOffset += 13;	4497 pathOffset += 13;

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

4483 pathOffset = path.length;	4499 pathOffset = path.length;

4484 unittest.expect(subPart, unittest.equals("$arg_applicationId"));	4500 unittest.expect(subPart, unittest.equals("$arg_applicationId"));

4485	4501

4486 var query = (req.url).query;	4502 var query = (req.url).query;

4487 var queryOffset = 0;	4503 var queryOffset = 0;

4488 var queryMap = {};	4504 var queryMap = {};

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

(...skipping 26 matching lines...) Expand all Loading...
4516	4532

4517 unittest.test("method--played", () {	4533 unittest.test("method--played", () {

4518	4534

4519 var mock = new common_test.HttpServerMock();	4535 var mock = new common_test.HttpServerMock();

4520 api.ApplicationsResourceApi res = new api.GamesApi(mock).applications;	4536 api.ApplicationsResourceApi res = new api.GamesApi(mock).applications;

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

4522 var path = (req.url).path;	4538 var path = (req.url).path;

4523 var pathOffset = 0;	4539 var pathOffset = 0;

4524 var index;	4540 var index;

4525 var subPart;	4541 var subPart;

4526 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4542 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4527 pathOffset += 10;	4543 pathOffset += 1;

	4544 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4545 pathOffset += 9;

4528 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("applications/played"));	4546 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("applications/played"));

4529 pathOffset += 19;	4547 pathOffset += 19;

4530	4548

4531 var query = (req.url).query;	4549 var query = (req.url).query;

4532 var queryOffset = 0;	4550 var queryOffset = 0;

4533 var queryMap = {};	4551 var queryMap = {};

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

4535 parseBool(n) {	4553 parseBool(n) {

4536 if (n == "true") return true;	4554 if (n == "true") return true;

4537 if (n == "false") return false;	4555 if (n == "false") return false;

(...skipping 26 matching lines...) Expand all Loading...
4564 var mock = new common_test.HttpServerMock();	4582 var mock = new common_test.HttpServerMock();

4565 api.EventsResourceApi res = new api.GamesApi(mock).events;	4583 api.EventsResourceApi res = new api.GamesApi(mock).events;

4566 var arg_language = "foo";	4584 var arg_language = "foo";

4567 var arg_maxResults = 42;	4585 var arg_maxResults = 42;

4568 var arg_pageToken = "foo";	4586 var arg_pageToken = "foo";

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

4570 var path = (req.url).path;	4588 var path = (req.url).path;

4571 var pathOffset = 0;	4589 var pathOffset = 0;

4572 var index;	4590 var index;

4573 var subPart;	4591 var subPart;

4574 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4592 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4575 pathOffset += 10;	4593 pathOffset += 1;

	4594 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4595 pathOffset += 9;

4576 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("events"));	4596 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("events"));

4577 pathOffset += 6;	4597 pathOffset += 6;

4578	4598

4579 var query = (req.url).query;	4599 var query = (req.url).query;

4580 var queryOffset = 0;	4600 var queryOffset = 0;

4581 var queryMap = {};	4601 var queryMap = {};

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

4583 parseBool(n) {	4603 parseBool(n) {

4584 if (n == "true") return true;	4604 if (n == "true") return true;

4585 if (n == "false") return false;	4605 if (n == "false") return false;

(...skipping 27 matching lines...) Expand all Loading...
4613 var mock = new common_test.HttpServerMock();	4633 var mock = new common_test.HttpServerMock();

4614 api.EventsResourceApi res = new api.GamesApi(mock).events;	4634 api.EventsResourceApi res = new api.GamesApi(mock).events;

4615 var arg_language = "foo";	4635 var arg_language = "foo";

4616 var arg_maxResults = 42;	4636 var arg_maxResults = 42;

4617 var arg_pageToken = "foo";	4637 var arg_pageToken = "foo";

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

4619 var path = (req.url).path;	4639 var path = (req.url).path;

4620 var pathOffset = 0;	4640 var pathOffset = 0;

4621 var index;	4641 var index;

4622 var subPart;	4642 var subPart;

4623 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4643 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4624 pathOffset += 10;	4644 pathOffset += 1;

	4645 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4646 pathOffset += 9;

4625 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("eventDefinitions"));	4647 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("eventDefinitions"));

4626 pathOffset += 16;	4648 pathOffset += 16;

4627	4649

4628 var query = (req.url).query;	4650 var query = (req.url).query;

4629 var queryOffset = 0;	4651 var queryOffset = 0;

4630 var queryMap = {};	4652 var queryMap = {};

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

4632 parseBool(n) {	4654 parseBool(n) {

4633 if (n == "true") return true;	4655 if (n == "true") return true;

4634 if (n == "false") return false;	4656 if (n == "false") return false;

(...skipping 29 matching lines...) Expand all Loading...
4664 var arg_request = buildEventRecordRequest();	4686 var arg_request = buildEventRecordRequest();

4665 var arg_language = "foo";	4687 var arg_language = "foo";

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

4667 var obj = new api.EventRecordRequest.fromJson(json);	4689 var obj = new api.EventRecordRequest.fromJson(json);

4668 checkEventRecordRequest(obj);	4690 checkEventRecordRequest(obj);

4669	4691

4670 var path = (req.url).path;	4692 var path = (req.url).path;

4671 var pathOffset = 0;	4693 var pathOffset = 0;

4672 var index;	4694 var index;

4673 var subPart;	4695 var subPart;

4674 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4696 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4675 pathOffset += 10;	4697 pathOffset += 1;

	4698 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4699 pathOffset += 9;

4676 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("events"));	4700 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("events"));

4677 pathOffset += 6;	4701 pathOffset += 6;

4678	4702

4679 var query = (req.url).query;	4703 var query = (req.url).query;

4680 var queryOffset = 0;	4704 var queryOffset = 0;

4681 var queryMap = {};	4705 var queryMap = {};

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

4683 parseBool(n) {	4707 parseBool(n) {

4684 if (n == "true") return true;	4708 if (n == "true") return true;

4685 if (n == "false") return false;	4709 if (n == "false") return false;

(...skipping 28 matching lines...) Expand all Loading...
4714	4738

4715 var mock = new common_test.HttpServerMock();	4739 var mock = new common_test.HttpServerMock();

4716 api.LeaderboardsResourceApi res = new api.GamesApi(mock).leaderboards;	4740 api.LeaderboardsResourceApi res = new api.GamesApi(mock).leaderboards;

4717 var arg_leaderboardId = "foo";	4741 var arg_leaderboardId = "foo";

4718 var arg_language = "foo";	4742 var arg_language = "foo";

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

4720 var path = (req.url).path;	4744 var path = (req.url).path;

4721 var pathOffset = 0;	4745 var pathOffset = 0;

4722 var index;	4746 var index;

4723 var subPart;	4747 var subPart;

4724 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4748 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4725 pathOffset += 10;	4749 pathOffset += 1;

	4750 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4751 pathOffset += 9;

4726 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));	4752 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));

4727 pathOffset += 13;	4753 pathOffset += 13;

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

4729 pathOffset = path.length;	4755 pathOffset = path.length;

4730 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));	4756 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));

4731	4757

4732 var query = (req.url).query;	4758 var query = (req.url).query;

4733 var queryOffset = 0;	4759 var queryOffset = 0;

4734 var queryMap = {};	4760 var queryMap = {};

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

(...skipping 28 matching lines...) Expand all Loading...
4764 var mock = new common_test.HttpServerMock();	4790 var mock = new common_test.HttpServerMock();

4765 api.LeaderboardsResourceApi res = new api.GamesApi(mock).leaderboards;	4791 api.LeaderboardsResourceApi res = new api.GamesApi(mock).leaderboards;

4766 var arg_language = "foo";	4792 var arg_language = "foo";

4767 var arg_maxResults = 42;	4793 var arg_maxResults = 42;

4768 var arg_pageToken = "foo";	4794 var arg_pageToken = "foo";

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

4770 var path = (req.url).path;	4796 var path = (req.url).path;

4771 var pathOffset = 0;	4797 var pathOffset = 0;

4772 var index;	4798 var index;

4773 var subPart;	4799 var subPart;

4774 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4800 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4775 pathOffset += 10;	4801 pathOffset += 1;

	4802 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4803 pathOffset += 9;

4776 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("leaderboards"));	4804 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("leaderboards"));

4777 pathOffset += 12;	4805 pathOffset += 12;

4778	4806

4779 var query = (req.url).query;	4807 var query = (req.url).query;

4780 var queryOffset = 0;	4808 var queryOffset = 0;

4781 var queryMap = {};	4809 var queryMap = {};

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

4783 parseBool(n) {	4811 parseBool(n) {

4784 if (n == "true") return true;	4812 if (n == "true") return true;

4785 if (n == "false") return false;	4813 if (n == "false") return false;

(...skipping 28 matching lines...) Expand all Loading...
4814 unittest.group("resource-MetagameResourceApi", () {	4842 unittest.group("resource-MetagameResourceApi", () {

4815 unittest.test("method--getMetagameConfig", () {	4843 unittest.test("method--getMetagameConfig", () {

4816	4844

4817 var mock = new common_test.HttpServerMock();	4845 var mock = new common_test.HttpServerMock();

4818 api.MetagameResourceApi res = new api.GamesApi(mock).metagame;	4846 api.MetagameResourceApi res = new api.GamesApi(mock).metagame;

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

4820 var path = (req.url).path;	4848 var path = (req.url).path;

4821 var pathOffset = 0;	4849 var pathOffset = 0;

4822 var index;	4850 var index;

4823 var subPart;	4851 var subPart;

4824 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4852 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4825 pathOffset += 10;	4853 pathOffset += 1;

	4854 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4855 pathOffset += 9;

4826 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("metagameConfig"));	4856 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("metagameConfig"));

4827 pathOffset += 14;	4857 pathOffset += 14;

4828	4858

4829 var query = (req.url).query;	4859 var query = (req.url).query;

4830 var queryOffset = 0;	4860 var queryOffset = 0;

4831 var queryMap = {};	4861 var queryMap = {};

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

4833 parseBool(n) {	4863 parseBool(n) {

4834 if (n == "true") return true;	4864 if (n == "true") return true;

4835 if (n == "false") return false;	4865 if (n == "false") return false;

(...skipping 26 matching lines...) Expand all Loading...
4862 var arg_playerId = "foo";	4892 var arg_playerId = "foo";

4863 var arg_collection = "foo";	4893 var arg_collection = "foo";

4864 var arg_language = "foo";	4894 var arg_language = "foo";

4865 var arg_maxResults = 42;	4895 var arg_maxResults = 42;

4866 var arg_pageToken = "foo";	4896 var arg_pageToken = "foo";

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

4868 var path = (req.url).path;	4898 var path = (req.url).path;

4869 var pathOffset = 0;	4899 var pathOffset = 0;

4870 var index;	4900 var index;

4871 var subPart;	4901 var subPart;

4872 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4902 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4873 pathOffset += 10;	4903 pathOffset += 1;

	4904 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4905 pathOffset += 9;

4874 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));	4906 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));

4875 pathOffset += 8;	4907 pathOffset += 8;

4876 index = path.indexOf("/categories/", pathOffset);	4908 index = path.indexOf("/categories/", pathOffset);

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

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

4879 pathOffset = index;	4911 pathOffset = index;

4880 unittest.expect(subPart, unittest.equals("$arg_playerId"));	4912 unittest.expect(subPart, unittest.equals("$arg_playerId"));

4881 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/categories/"));	4913 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/categories/"));

4882 pathOffset += 12;	4914 pathOffset += 12;

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

(...skipping 40 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4924	4956

4925 var mock = new common_test.HttpServerMock();	4957 var mock = new common_test.HttpServerMock();

4926 api.PlayersResourceApi res = new api.GamesApi(mock).players;	4958 api.PlayersResourceApi res = new api.GamesApi(mock).players;

4927 var arg_playerId = "foo";	4959 var arg_playerId = "foo";

4928 var arg_language = "foo";	4960 var arg_language = "foo";

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

4930 var path = (req.url).path;	4962 var path = (req.url).path;

4931 var pathOffset = 0;	4963 var pathOffset = 0;

4932 var index;	4964 var index;

4933 var subPart;	4965 var subPart;

4934 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	4966 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4935 pathOffset += 10;	4967 pathOffset += 1;

	4968 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	4969 pathOffset += 9;

4936 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));	4970 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));

4937 pathOffset += 8;	4971 pathOffset += 8;

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

4939 pathOffset = path.length;	4973 pathOffset = path.length;

4940 unittest.expect(subPart, unittest.equals("$arg_playerId"));	4974 unittest.expect(subPart, unittest.equals("$arg_playerId"));

4941	4975

4942 var query = (req.url).query;	4976 var query = (req.url).query;

4943 var queryOffset = 0;	4977 var queryOffset = 0;

4944 var queryMap = {};	4978 var queryMap = {};

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

(...skipping 29 matching lines...) Expand all Loading...
4975 api.PlayersResourceApi res = new api.GamesApi(mock).players;	5009 api.PlayersResourceApi res = new api.GamesApi(mock).players;

4976 var arg_collection = "foo";	5010 var arg_collection = "foo";

4977 var arg_language = "foo";	5011 var arg_language = "foo";

4978 var arg_maxResults = 42;	5012 var arg_maxResults = 42;

4979 var arg_pageToken = "foo";	5013 var arg_pageToken = "foo";

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

4981 var path = (req.url).path;	5015 var path = (req.url).path;

4982 var pathOffset = 0;	5016 var pathOffset = 0;

4983 var index;	5017 var index;

4984 var subPart;	5018 var subPart;

4985 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5019 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4986 pathOffset += 10;	5020 pathOffset += 1;

	5021 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5022 pathOffset += 9;

4987 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("players/me/players/"));	5023 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("players/me/players/"));

4988 pathOffset += 19;	5024 pathOffset += 19;

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

4990 pathOffset = path.length;	5026 pathOffset = path.length;

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

4992	5028

4993 var query = (req.url).query;	5029 var query = (req.url).query;

4994 var queryOffset = 0;	5030 var queryOffset = 0;

4995 var queryMap = {};	5031 var queryMap = {};

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

(...skipping 35 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5032 api.PushtokensResourceApi res = new api.GamesApi(mock).pushtokens;	5068 api.PushtokensResourceApi res = new api.GamesApi(mock).pushtokens;

5033 var arg_request = buildPushTokenId();	5069 var arg_request = buildPushTokenId();

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

5035 var obj = new api.PushTokenId.fromJson(json);	5071 var obj = new api.PushTokenId.fromJson(json);

5036 checkPushTokenId(obj);	5072 checkPushTokenId(obj);

5037	5073

5038 var path = (req.url).path;	5074 var path = (req.url).path;

5039 var pathOffset = 0;	5075 var pathOffset = 0;

5040 var index;	5076 var index;

5041 var subPart;	5077 var subPart;

5042 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5078 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5043 pathOffset += 10;	5079 pathOffset += 1;

	5080 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5081 pathOffset += 9;

5044 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("pushtokens/remove"));	5082 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("pushtokens/remove"));

5045 pathOffset += 17;	5083 pathOffset += 17;

5046	5084

5047 var query = (req.url).query;	5085 var query = (req.url).query;

5048 var queryOffset = 0;	5086 var queryOffset = 0;

5049 var queryMap = {};	5087 var queryMap = {};

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

5051 parseBool(n) {	5089 parseBool(n) {

5052 if (n == "true") return true;	5090 if (n == "true") return true;

5053 if (n == "false") return false;	5091 if (n == "false") return false;

(...skipping 23 matching lines...) Expand all Loading...
5077 api.PushtokensResourceApi res = new api.GamesApi(mock).pushtokens;	5115 api.PushtokensResourceApi res = new api.GamesApi(mock).pushtokens;

5078 var arg_request = buildPushToken();	5116 var arg_request = buildPushToken();

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

5080 var obj = new api.PushToken.fromJson(json);	5118 var obj = new api.PushToken.fromJson(json);

5081 checkPushToken(obj);	5119 checkPushToken(obj);

5082	5120

5083 var path = (req.url).path;	5121 var path = (req.url).path;

5084 var pathOffset = 0;	5122 var pathOffset = 0;

5085 var index;	5123 var index;

5086 var subPart;	5124 var subPart;

5087 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5125 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5088 pathOffset += 10;	5126 pathOffset += 1;

	5127 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5128 pathOffset += 9;

5089 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("pushtokens"));	5129 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("pushtokens"));

5090 pathOffset += 10;	5130 pathOffset += 10;

5091	5131

5092 var query = (req.url).query;	5132 var query = (req.url).query;

5093 var queryOffset = 0;	5133 var queryOffset = 0;

5094 var queryMap = {};	5134 var queryMap = {};

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

5096 parseBool(n) {	5136 parseBool(n) {

5097 if (n == "true") return true;	5137 if (n == "true") return true;

5098 if (n == "false") return false;	5138 if (n == "false") return false;

(...skipping 26 matching lines...) Expand all Loading...
5125 var mock = new common_test.HttpServerMock();	5165 var mock = new common_test.HttpServerMock();

5126 api.QuestMilestonesResourceApi res = new api.GamesApi(mock).questMilestone s;	5166 api.QuestMilestonesResourceApi res = new api.GamesApi(mock).questMilestone s;

5127 var arg_questId = "foo";	5167 var arg_questId = "foo";

5128 var arg_milestoneId = "foo";	5168 var arg_milestoneId = "foo";

5129 var arg_requestId = "foo";	5169 var arg_requestId = "foo";

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

5131 var path = (req.url).path;	5171 var path = (req.url).path;

5132 var pathOffset = 0;	5172 var pathOffset = 0;

5133 var index;	5173 var index;

5134 var subPart;	5174 var subPart;

5135 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5175 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5136 pathOffset += 10;	5176 pathOffset += 1;

	5177 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5178 pathOffset += 9;

5137 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("quests/"));	5179 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("quests/"));

5138 pathOffset += 7;	5180 pathOffset += 7;

5139 index = path.indexOf("/milestones/", pathOffset);	5181 index = path.indexOf("/milestones/", pathOffset);

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

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

5142 pathOffset = index;	5184 pathOffset = index;

5143 unittest.expect(subPart, unittest.equals("$arg_questId"));	5185 unittest.expect(subPart, unittest.equals("$arg_questId"));

5144 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/milestones/"));	5186 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/milestones/"));

5145 pathOffset += 12;	5187 pathOffset += 12;

5146 index = path.indexOf("/claim", pathOffset);	5188 index = path.indexOf("/claim", pathOffset);

(...skipping 40 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5187	5229

5188 var mock = new common_test.HttpServerMock();	5230 var mock = new common_test.HttpServerMock();

5189 api.QuestsResourceApi res = new api.GamesApi(mock).quests;	5231 api.QuestsResourceApi res = new api.GamesApi(mock).quests;

5190 var arg_questId = "foo";	5232 var arg_questId = "foo";

5191 var arg_language = "foo";	5233 var arg_language = "foo";

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

5193 var path = (req.url).path;	5235 var path = (req.url).path;

5194 var pathOffset = 0;	5236 var pathOffset = 0;

5195 var index;	5237 var index;

5196 var subPart;	5238 var subPart;

5197 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5239 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5198 pathOffset += 10;	5240 pathOffset += 1;

	5241 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5242 pathOffset += 9;

5199 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("quests/"));	5243 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("quests/"));

5200 pathOffset += 7;	5244 pathOffset += 7;

5201 index = path.indexOf("/accept", pathOffset);	5245 index = path.indexOf("/accept", pathOffset);

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

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

5204 pathOffset = index;	5248 pathOffset = index;

5205 unittest.expect(subPart, unittest.equals("$arg_questId"));	5249 unittest.expect(subPart, unittest.equals("$arg_questId"));

5206 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/accept"));	5250 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/accept"));

5207 pathOffset += 7;	5251 pathOffset += 7;

5208	5252

(...skipping 33 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5242 api.QuestsResourceApi res = new api.GamesApi(mock).quests;	5286 api.QuestsResourceApi res = new api.GamesApi(mock).quests;

5243 var arg_playerId = "foo";	5287 var arg_playerId = "foo";

5244 var arg_language = "foo";	5288 var arg_language = "foo";

5245 var arg_maxResults = 42;	5289 var arg_maxResults = 42;

5246 var arg_pageToken = "foo";	5290 var arg_pageToken = "foo";

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

5248 var path = (req.url).path;	5292 var path = (req.url).path;

5249 var pathOffset = 0;	5293 var pathOffset = 0;

5250 var index;	5294 var index;

5251 var subPart;	5295 var subPart;

5252 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5296 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5253 pathOffset += 10;	5297 pathOffset += 1;

	5298 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5299 pathOffset += 9;

5254 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));	5300 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));

5255 pathOffset += 8;	5301 pathOffset += 8;

5256 index = path.indexOf("/quests", pathOffset);	5302 index = path.indexOf("/quests", pathOffset);

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

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

5259 pathOffset = index;	5305 pathOffset = index;

5260 unittest.expect(subPart, unittest.equals("$arg_playerId"));	5306 unittest.expect(subPart, unittest.equals("$arg_playerId"));

5261 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/quests"));	5307 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/quests"));

5262 pathOffset += 7;	5308 pathOffset += 7;

5263	5309

(...skipping 36 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5300 unittest.test("method--check", () {	5346 unittest.test("method--check", () {

5301	5347

5302 var mock = new common_test.HttpServerMock();	5348 var mock = new common_test.HttpServerMock();

5303 api.RevisionsResourceApi res = new api.GamesApi(mock).revisions;	5349 api.RevisionsResourceApi res = new api.GamesApi(mock).revisions;

5304 var arg_clientRevision = "foo";	5350 var arg_clientRevision = "foo";

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

5306 var path = (req.url).path;	5352 var path = (req.url).path;

5307 var pathOffset = 0;	5353 var pathOffset = 0;

5308 var index;	5354 var index;

5309 var subPart;	5355 var subPart;

5310 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5356 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5311 pathOffset += 10;	5357 pathOffset += 1;

	5358 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5359 pathOffset += 9;

5312 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("revisions/check"));	5360 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("revisions/check"));

5313 pathOffset += 15;	5361 pathOffset += 15;

5314	5362

5315 var query = (req.url).query;	5363 var query = (req.url).query;

5316 var queryOffset = 0;	5364 var queryOffset = 0;

5317 var queryMap = {};	5365 var queryMap = {};

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

5319 parseBool(n) {	5367 parseBool(n) {

5320 if (n == "true") return true;	5368 if (n == "true") return true;

5321 if (n == "false") return false;	5369 if (n == "false") return false;

(...skipping 31 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5353 var arg_request = buildRoomCreateRequest();	5401 var arg_request = buildRoomCreateRequest();

5354 var arg_language = "foo";	5402 var arg_language = "foo";

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

5356 var obj = new api.RoomCreateRequest.fromJson(json);	5404 var obj = new api.RoomCreateRequest.fromJson(json);

5357 checkRoomCreateRequest(obj);	5405 checkRoomCreateRequest(obj);

5358	5406

5359 var path = (req.url).path;	5407 var path = (req.url).path;

5360 var pathOffset = 0;	5408 var pathOffset = 0;

5361 var index;	5409 var index;

5362 var subPart;	5410 var subPart;

5363 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5411 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5364 pathOffset += 10;	5412 pathOffset += 1;

	5413 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5414 pathOffset += 9;

5365 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("rooms/create"));	5415 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("rooms/create"));

5366 pathOffset += 12;	5416 pathOffset += 12;

5367	5417

5368 var query = (req.url).query;	5418 var query = (req.url).query;

5369 var queryOffset = 0;	5419 var queryOffset = 0;

5370 var queryMap = {};	5420 var queryMap = {};

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

5372 parseBool(n) {	5422 parseBool(n) {

5373 if (n == "true") return true;	5423 if (n == "true") return true;

5374 if (n == "false") return false;	5424 if (n == "false") return false;

(...skipping 24 matching lines...) Expand all Loading...
5399	5449

5400 var mock = new common_test.HttpServerMock();	5450 var mock = new common_test.HttpServerMock();

5401 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;	5451 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5402 var arg_roomId = "foo";	5452 var arg_roomId = "foo";

5403 var arg_language = "foo";	5453 var arg_language = "foo";

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

5405 var path = (req.url).path;	5455 var path = (req.url).path;

5406 var pathOffset = 0;	5456 var pathOffset = 0;

5407 var index;	5457 var index;

5408 var subPart;	5458 var subPart;

5409 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5459 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5410 pathOffset += 10;	5460 pathOffset += 1;

	5461 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5462 pathOffset += 9;

5411 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));	5463 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5412 pathOffset += 6;	5464 pathOffset += 6;

5413 index = path.indexOf("/decline", pathOffset);	5465 index = path.indexOf("/decline", pathOffset);

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

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

5416 pathOffset = index;	5468 pathOffset = index;

5417 unittest.expect(subPart, unittest.equals("$arg_roomId"));	5469 unittest.expect(subPart, unittest.equals("$arg_roomId"));

5418 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/decline"));	5470 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/decline"));

5419 pathOffset += 8;	5471 pathOffset += 8;

5420	5472

(...skipping 30 matching lines...) Expand all Loading...
5451 unittest.test("method--dismiss", () {	5503 unittest.test("method--dismiss", () {

5452	5504

5453 var mock = new common_test.HttpServerMock();	5505 var mock = new common_test.HttpServerMock();

5454 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;	5506 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5455 var arg_roomId = "foo";	5507 var arg_roomId = "foo";

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

5457 var path = (req.url).path;	5509 var path = (req.url).path;

5458 var pathOffset = 0;	5510 var pathOffset = 0;

5459 var index;	5511 var index;

5460 var subPart;	5512 var subPart;

5461 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5513 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5462 pathOffset += 10;	5514 pathOffset += 1;

	5515 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5516 pathOffset += 9;

5463 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));	5517 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5464 pathOffset += 6;	5518 pathOffset += 6;

5465 index = path.indexOf("/dismiss", pathOffset);	5519 index = path.indexOf("/dismiss", pathOffset);

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

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

5468 pathOffset = index;	5522 pathOffset = index;

5469 unittest.expect(subPart, unittest.equals("$arg_roomId"));	5523 unittest.expect(subPart, unittest.equals("$arg_roomId"));

5470 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/dismiss"));	5524 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/dismiss"));

5471 pathOffset += 8;	5525 pathOffset += 8;

5472	5526

(...skipping 28 matching lines...) Expand all Loading...
5501	5555

5502 var mock = new common_test.HttpServerMock();	5556 var mock = new common_test.HttpServerMock();

5503 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;	5557 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5504 var arg_roomId = "foo";	5558 var arg_roomId = "foo";

5505 var arg_language = "foo";	5559 var arg_language = "foo";

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

5507 var path = (req.url).path;	5561 var path = (req.url).path;

5508 var pathOffset = 0;	5562 var pathOffset = 0;

5509 var index;	5563 var index;

5510 var subPart;	5564 var subPart;

5511 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5565 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5512 pathOffset += 10;	5566 pathOffset += 1;

	5567 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5568 pathOffset += 9;

5513 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));	5569 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5514 pathOffset += 6;	5570 pathOffset += 6;

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

5516 pathOffset = path.length;	5572 pathOffset = path.length;

5517 unittest.expect(subPart, unittest.equals("$arg_roomId"));	5573 unittest.expect(subPart, unittest.equals("$arg_roomId"));

5518	5574

5519 var query = (req.url).query;	5575 var query = (req.url).query;

5520 var queryOffset = 0;	5576 var queryOffset = 0;

5521 var queryMap = {};	5577 var queryMap = {};

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

(...skipping 31 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5554 var arg_roomId = "foo";	5610 var arg_roomId = "foo";

5555 var arg_language = "foo";	5611 var arg_language = "foo";

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

5557 var obj = new api.RoomJoinRequest.fromJson(json);	5613 var obj = new api.RoomJoinRequest.fromJson(json);

5558 checkRoomJoinRequest(obj);	5614 checkRoomJoinRequest(obj);

5559	5615

5560 var path = (req.url).path;	5616 var path = (req.url).path;

5561 var pathOffset = 0;	5617 var pathOffset = 0;

5562 var index;	5618 var index;

5563 var subPart;	5619 var subPart;

5564 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5620 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5565 pathOffset += 10;	5621 pathOffset += 1;

	5622 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5623 pathOffset += 9;

5566 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));	5624 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5567 pathOffset += 6;	5625 pathOffset += 6;

5568 index = path.indexOf("/join", pathOffset);	5626 index = path.indexOf("/join", pathOffset);

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

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

5571 pathOffset = index;	5629 pathOffset = index;

5572 unittest.expect(subPart, unittest.equals("$arg_roomId"));	5630 unittest.expect(subPart, unittest.equals("$arg_roomId"));

5573 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/join"));	5631 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/join"));

5574 pathOffset += 5;	5632 pathOffset += 5;

5575	5633

(...skipping 35 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5611 var arg_roomId = "foo";	5669 var arg_roomId = "foo";

5612 var arg_language = "foo";	5670 var arg_language = "foo";

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

5614 var obj = new api.RoomLeaveRequest.fromJson(json);	5672 var obj = new api.RoomLeaveRequest.fromJson(json);

5615 checkRoomLeaveRequest(obj);	5673 checkRoomLeaveRequest(obj);

5616	5674

5617 var path = (req.url).path;	5675 var path = (req.url).path;

5618 var pathOffset = 0;	5676 var pathOffset = 0;

5619 var index;	5677 var index;

5620 var subPart;	5678 var subPart;

5621 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5679 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5622 pathOffset += 10;	5680 pathOffset += 1;

	5681 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5682 pathOffset += 9;

5623 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));	5683 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5624 pathOffset += 6;	5684 pathOffset += 6;

5625 index = path.indexOf("/leave", pathOffset);	5685 index = path.indexOf("/leave", pathOffset);

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

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

5628 pathOffset = index;	5688 pathOffset = index;

5629 unittest.expect(subPart, unittest.equals("$arg_roomId"));	5689 unittest.expect(subPart, unittest.equals("$arg_roomId"));

5630 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/leave"));	5690 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/leave"));

5631 pathOffset += 6;	5691 pathOffset += 6;

5632	5692

(...skipping 32 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5665 var mock = new common_test.HttpServerMock();	5725 var mock = new common_test.HttpServerMock();

5666 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;	5726 api.RoomsResourceApi res = new api.GamesApi(mock).rooms;

5667 var arg_language = "foo";	5727 var arg_language = "foo";

5668 var arg_maxResults = 42;	5728 var arg_maxResults = 42;

5669 var arg_pageToken = "foo";	5729 var arg_pageToken = "foo";

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

5671 var path = (req.url).path;	5731 var path = (req.url).path;

5672 var pathOffset = 0;	5732 var pathOffset = 0;

5673 var index;	5733 var index;

5674 var subPart;	5734 var subPart;

5675 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5735 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5676 pathOffset += 10;	5736 pathOffset += 1;

	5737 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5738 pathOffset += 9;

5677 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("rooms"));	5739 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("rooms"));

5678 pathOffset += 5;	5740 pathOffset += 5;

5679	5741

5680 var query = (req.url).query;	5742 var query = (req.url).query;

5681 var queryOffset = 0;	5743 var queryOffset = 0;

5682 var queryMap = {};	5744 var queryMap = {};

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

5684 parseBool(n) {	5746 parseBool(n) {

5685 if (n == "true") return true;	5747 if (n == "true") return true;

5686 if (n == "false") return false;	5748 if (n == "false") return false;

(...skipping 30 matching lines...) Expand all Loading...
5717 var arg_roomId = "foo";	5779 var arg_roomId = "foo";

5718 var arg_language = "foo";	5780 var arg_language = "foo";

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

5720 var obj = new api.RoomP2PStatuses.fromJson(json);	5782 var obj = new api.RoomP2PStatuses.fromJson(json);

5721 checkRoomP2PStatuses(obj);	5783 checkRoomP2PStatuses(obj);

5722	5784

5723 var path = (req.url).path;	5785 var path = (req.url).path;

5724 var pathOffset = 0;	5786 var pathOffset = 0;

5725 var index;	5787 var index;

5726 var subPart;	5788 var subPart;

5727 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5789 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5728 pathOffset += 10;	5790 pathOffset += 1;

	5791 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5792 pathOffset += 9;

5729 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));	5793 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("rooms/"));

5730 pathOffset += 6;	5794 pathOffset += 6;

5731 index = path.indexOf("/reportstatus", pathOffset);	5795 index = path.indexOf("/reportstatus", pathOffset);

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

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

5734 pathOffset = index;	5798 pathOffset = index;

5735 unittest.expect(subPart, unittest.equals("$arg_roomId"));	5799 unittest.expect(subPart, unittest.equals("$arg_roomId"));

5736 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/reportstatus"));	5800 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/reportstatus"));

5737 pathOffset += 13;	5801 pathOffset += 13;

5738	5802

(...skipping 40 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5779 var arg_timeSpan = "foo";	5843 var arg_timeSpan = "foo";

5780 var arg_includeRankType = "foo";	5844 var arg_includeRankType = "foo";

5781 var arg_language = "foo";	5845 var arg_language = "foo";

5782 var arg_maxResults = 42;	5846 var arg_maxResults = 42;

5783 var arg_pageToken = "foo";	5847 var arg_pageToken = "foo";

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

5785 var path = (req.url).path;	5849 var path = (req.url).path;

5786 var pathOffset = 0;	5850 var pathOffset = 0;

5787 var index;	5851 var index;

5788 var subPart;	5852 var subPart;

5789 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5853 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5790 pathOffset += 10;	5854 pathOffset += 1;

	5855 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5856 pathOffset += 9;

5791 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));	5857 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));

5792 pathOffset += 8;	5858 pathOffset += 8;

5793 index = path.indexOf("/leaderboards/", pathOffset);	5859 index = path.indexOf("/leaderboards/", pathOffset);

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

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

5796 pathOffset = index;	5862 pathOffset = index;

5797 unittest.expect(subPart, unittest.equals("$arg_playerId"));	5863 unittest.expect(subPart, unittest.equals("$arg_playerId"));

5798 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/leaderboards/"));	5864 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/leaderboards/"));

5799 pathOffset += 14;	5865 pathOffset += 14;

5800 index = path.indexOf("/scores/", pathOffset);	5866 index = path.indexOf("/scores/", pathOffset);

(...skipping 48 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5849 var arg_collection = "foo";	5915 var arg_collection = "foo";

5850 var arg_timeSpan = "foo";	5916 var arg_timeSpan = "foo";

5851 var arg_language = "foo";	5917 var arg_language = "foo";

5852 var arg_maxResults = 42;	5918 var arg_maxResults = 42;

5853 var arg_pageToken = "foo";	5919 var arg_pageToken = "foo";

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

5855 var path = (req.url).path;	5921 var path = (req.url).path;

5856 var pathOffset = 0;	5922 var pathOffset = 0;

5857 var index;	5923 var index;

5858 var subPart;	5924 var subPart;

5859 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5925 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5860 pathOffset += 10;	5926 pathOffset += 1;

	5927 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5928 pathOffset += 9;

5861 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));	5929 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));

5862 pathOffset += 13;	5930 pathOffset += 13;

5863 index = path.indexOf("/scores/", pathOffset);	5931 index = path.indexOf("/scores/", pathOffset);

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

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

5866 pathOffset = index;	5934 pathOffset = index;

5867 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));	5935 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));

5868 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/scores/"));	5936 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/scores/"));

5869 pathOffset += 8;	5937 pathOffset += 8;

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

(...skipping 43 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5914 var arg_language = "foo";	5982 var arg_language = "foo";

5915 var arg_maxResults = 42;	5983 var arg_maxResults = 42;

5916 var arg_pageToken = "foo";	5984 var arg_pageToken = "foo";

5917 var arg_resultsAbove = 42;	5985 var arg_resultsAbove = 42;

5918 var arg_returnTopIfAbsent = true;	5986 var arg_returnTopIfAbsent = true;

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

5920 var path = (req.url).path;	5988 var path = (req.url).path;

5921 var pathOffset = 0;	5989 var pathOffset = 0;

5922 var index;	5990 var index;

5923 var subPart;	5991 var subPart;

5924 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	5992 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5925 pathOffset += 10;	5993 pathOffset += 1;

	5994 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	5995 pathOffset += 9;

5926 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));	5996 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));

5927 pathOffset += 13;	5997 pathOffset += 13;

5928 index = path.indexOf("/window/", pathOffset);	5998 index = path.indexOf("/window/", pathOffset);

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

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

5931 pathOffset = index;	6001 pathOffset = index;

5932 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));	6002 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));

5933 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/window/"));	6003 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/window/"));

5934 pathOffset += 8;	6004 pathOffset += 8;

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

(...skipping 41 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5977 api.ScoresResourceApi res = new api.GamesApi(mock).scores;	6047 api.ScoresResourceApi res = new api.GamesApi(mock).scores;

5978 var arg_leaderboardId = "foo";	6048 var arg_leaderboardId = "foo";

5979 var arg_score = "foo";	6049 var arg_score = "foo";

5980 var arg_language = "foo";	6050 var arg_language = "foo";

5981 var arg_scoreTag = "foo";	6051 var arg_scoreTag = "foo";

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

5983 var path = (req.url).path;	6053 var path = (req.url).path;

5984 var pathOffset = 0;	6054 var pathOffset = 0;

5985 var index;	6055 var index;

5986 var subPart;	6056 var subPart;

5987 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6057 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5988 pathOffset += 10;	6058 pathOffset += 1;

	6059 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6060 pathOffset += 9;

5989 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));	6061 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("leaderboards/"));

5990 pathOffset += 13;	6062 pathOffset += 13;

5991 index = path.indexOf("/scores", pathOffset);	6063 index = path.indexOf("/scores", pathOffset);

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

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

5994 pathOffset = index;	6066 pathOffset = index;

5995 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));	6067 unittest.expect(subPart, unittest.equals("$arg_leaderboardId"));

5996 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/scores"));	6068 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/scores"));

5997 pathOffset += 7;	6069 pathOffset += 7;

5998	6070

(...skipping 36 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6035 var arg_request = buildPlayerScoreSubmissionList();	6107 var arg_request = buildPlayerScoreSubmissionList();

6036 var arg_language = "foo";	6108 var arg_language = "foo";

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

6038 var obj = new api.PlayerScoreSubmissionList.fromJson(json);	6110 var obj = new api.PlayerScoreSubmissionList.fromJson(json);

6039 checkPlayerScoreSubmissionList(obj);	6111 checkPlayerScoreSubmissionList(obj);

6040	6112

6041 var path = (req.url).path;	6113 var path = (req.url).path;

6042 var pathOffset = 0;	6114 var pathOffset = 0;

6043 var index;	6115 var index;

6044 var subPart;	6116 var subPart;

6045 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6117 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6046 pathOffset += 10;	6118 pathOffset += 1;

	6119 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6120 pathOffset += 9;

6047 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("leaderboards/scores"));	6121 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("leaderboards/scores"));

6048 pathOffset += 19;	6122 pathOffset += 19;

6049	6123

6050 var query = (req.url).query;	6124 var query = (req.url).query;

6051 var queryOffset = 0;	6125 var queryOffset = 0;

6052 var queryMap = {};	6126 var queryMap = {};

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

6054 parseBool(n) {	6128 parseBool(n) {

6055 if (n == "true") return true;	6129 if (n == "true") return true;

6056 if (n == "false") return false;	6130 if (n == "false") return false;

(...skipping 28 matching lines...) Expand all Loading...
6085	6159

6086 var mock = new common_test.HttpServerMock();	6160 var mock = new common_test.HttpServerMock();

6087 api.SnapshotsResourceApi res = new api.GamesApi(mock).snapshots;	6161 api.SnapshotsResourceApi res = new api.GamesApi(mock).snapshots;

6088 var arg_snapshotId = "foo";	6162 var arg_snapshotId = "foo";

6089 var arg_language = "foo";	6163 var arg_language = "foo";

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

6091 var path = (req.url).path;	6165 var path = (req.url).path;

6092 var pathOffset = 0;	6166 var pathOffset = 0;

6093 var index;	6167 var index;

6094 var subPart;	6168 var subPart;

6095 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6169 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6096 pathOffset += 10;	6170 pathOffset += 1;

	6171 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6172 pathOffset += 9;

6097 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("snapshots/"));	6173 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("snapshots/"));

6098 pathOffset += 10;	6174 pathOffset += 10;

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

6100 pathOffset = path.length;	6176 pathOffset = path.length;

6101 unittest.expect(subPart, unittest.equals("$arg_snapshotId"));	6177 unittest.expect(subPart, unittest.equals("$arg_snapshotId"));

6102	6178

6103 var query = (req.url).query;	6179 var query = (req.url).query;

6104 var queryOffset = 0;	6180 var queryOffset = 0;

6105 var queryMap = {};	6181 var queryMap = {};

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

(...skipping 29 matching lines...) Expand all Loading...
6136 api.SnapshotsResourceApi res = new api.GamesApi(mock).snapshots;	6212 api.SnapshotsResourceApi res = new api.GamesApi(mock).snapshots;

6137 var arg_playerId = "foo";	6213 var arg_playerId = "foo";

6138 var arg_language = "foo";	6214 var arg_language = "foo";

6139 var arg_maxResults = 42;	6215 var arg_maxResults = 42;

6140 var arg_pageToken = "foo";	6216 var arg_pageToken = "foo";

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

6142 var path = (req.url).path;	6218 var path = (req.url).path;

6143 var pathOffset = 0;	6219 var pathOffset = 0;

6144 var index;	6220 var index;

6145 var subPart;	6221 var subPart;

6146 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6222 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6147 pathOffset += 10;	6223 pathOffset += 1;

	6224 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6225 pathOffset += 9;

6148 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));	6226 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("players/"));

6149 pathOffset += 8;	6227 pathOffset += 8;

6150 index = path.indexOf("/snapshots", pathOffset);	6228 index = path.indexOf("/snapshots", pathOffset);

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

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

6153 pathOffset = index;	6231 pathOffset = index;

6154 unittest.expect(subPart, unittest.equals("$arg_playerId"));	6232 unittest.expect(subPart, unittest.equals("$arg_playerId"));

6155 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/snapshots"));	6233 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/snapshots"));

6156 pathOffset += 10;	6234 pathOffset += 10;

6157	6235

(...skipping 36 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6194 unittest.test("method--cancel", () {	6272 unittest.test("method--cancel", () {

6195	6273

6196 var mock = new common_test.HttpServerMock();	6274 var mock = new common_test.HttpServerMock();

6197 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;	6275 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6198 var arg_matchId = "foo";	6276 var arg_matchId = "foo";

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

6200 var path = (req.url).path;	6278 var path = (req.url).path;

6201 var pathOffset = 0;	6279 var pathOffset = 0;

6202 var index;	6280 var index;

6203 var subPart;	6281 var subPart;

6204 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6282 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6205 pathOffset += 10;	6283 pathOffset += 1;

	6284 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6285 pathOffset += 9;

6206 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6286 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6207 pathOffset += 17;	6287 pathOffset += 17;

6208 index = path.indexOf("/cancel", pathOffset);	6288 index = path.indexOf("/cancel", pathOffset);

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

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

6211 pathOffset = index;	6291 pathOffset = index;

6212 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6292 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6213 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/cancel"));	6293 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/cancel"));

6214 pathOffset += 7;	6294 pathOffset += 7;

6215	6295

(...skipping 31 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6247 var arg_request = buildTurnBasedMatchCreateRequest();	6327 var arg_request = buildTurnBasedMatchCreateRequest();

6248 var arg_language = "foo";	6328 var arg_language = "foo";

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

6250 var obj = new api.TurnBasedMatchCreateRequest.fromJson(json);	6330 var obj = new api.TurnBasedMatchCreateRequest.fromJson(json);

6251 checkTurnBasedMatchCreateRequest(obj);	6331 checkTurnBasedMatchCreateRequest(obj);

6252	6332

6253 var path = (req.url).path;	6333 var path = (req.url).path;

6254 var pathOffset = 0;	6334 var pathOffset = 0;

6255 var index;	6335 var index;

6256 var subPart;	6336 var subPart;

6257 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6337 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6258 pathOffset += 10;	6338 pathOffset += 1;

	6339 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6340 pathOffset += 9;

6259 unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.eq uals("turnbasedmatches/create"));	6341 unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.eq uals("turnbasedmatches/create"));

6260 pathOffset += 23;	6342 pathOffset += 23;

6261	6343

6262 var query = (req.url).query;	6344 var query = (req.url).query;

6263 var queryOffset = 0;	6345 var queryOffset = 0;

6264 var queryMap = {};	6346 var queryMap = {};

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

6266 parseBool(n) {	6348 parseBool(n) {

6267 if (n == "true") return true;	6349 if (n == "true") return true;

6268 if (n == "false") return false;	6350 if (n == "false") return false;

(...skipping 24 matching lines...) Expand all Loading...
6293	6375

6294 var mock = new common_test.HttpServerMock();	6376 var mock = new common_test.HttpServerMock();

6295 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;	6377 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6296 var arg_matchId = "foo";	6378 var arg_matchId = "foo";

6297 var arg_language = "foo";	6379 var arg_language = "foo";

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

6299 var path = (req.url).path;	6381 var path = (req.url).path;

6300 var pathOffset = 0;	6382 var pathOffset = 0;

6301 var index;	6383 var index;

6302 var subPart;	6384 var subPart;

6303 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6385 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6304 pathOffset += 10;	6386 pathOffset += 1;

	6387 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6388 pathOffset += 9;

6305 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6389 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6306 pathOffset += 17;	6390 pathOffset += 17;

6307 index = path.indexOf("/decline", pathOffset);	6391 index = path.indexOf("/decline", pathOffset);

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

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

6310 pathOffset = index;	6394 pathOffset = index;

6311 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6395 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6312 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/decline"));	6396 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/decline"));

6313 pathOffset += 8;	6397 pathOffset += 8;

6314	6398

(...skipping 30 matching lines...) Expand all Loading...
6345 unittest.test("method--dismiss", () {	6429 unittest.test("method--dismiss", () {

6346	6430

6347 var mock = new common_test.HttpServerMock();	6431 var mock = new common_test.HttpServerMock();

6348 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;	6432 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6349 var arg_matchId = "foo";	6433 var arg_matchId = "foo";

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

6351 var path = (req.url).path;	6435 var path = (req.url).path;

6352 var pathOffset = 0;	6436 var pathOffset = 0;

6353 var index;	6437 var index;

6354 var subPart;	6438 var subPart;

6355 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6439 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6356 pathOffset += 10;	6440 pathOffset += 1;

	6441 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6442 pathOffset += 9;

6357 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6443 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6358 pathOffset += 17;	6444 pathOffset += 17;

6359 index = path.indexOf("/dismiss", pathOffset);	6445 index = path.indexOf("/dismiss", pathOffset);

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

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

6362 pathOffset = index;	6448 pathOffset = index;

6363 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6449 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6364 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/dismiss"));	6450 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/dismiss"));

6365 pathOffset += 8;	6451 pathOffset += 8;

6366	6452

(...skipping 32 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6399 var arg_matchId = "foo";	6485 var arg_matchId = "foo";

6400 var arg_language = "foo";	6486 var arg_language = "foo";

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

6402 var obj = new api.TurnBasedMatchResults.fromJson(json);	6488 var obj = new api.TurnBasedMatchResults.fromJson(json);

6403 checkTurnBasedMatchResults(obj);	6489 checkTurnBasedMatchResults(obj);

6404	6490

6405 var path = (req.url).path;	6491 var path = (req.url).path;

6406 var pathOffset = 0;	6492 var pathOffset = 0;

6407 var index;	6493 var index;

6408 var subPart;	6494 var subPart;

6409 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6495 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6410 pathOffset += 10;	6496 pathOffset += 1;

	6497 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6498 pathOffset += 9;

6411 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6499 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6412 pathOffset += 17;	6500 pathOffset += 17;

6413 index = path.indexOf("/finish", pathOffset);	6501 index = path.indexOf("/finish", pathOffset);

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

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

6416 pathOffset = index;	6504 pathOffset = index;

6417 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6505 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6418 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/finish"));	6506 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/finish"));

6419 pathOffset += 7;	6507 pathOffset += 7;

6420	6508

(...skipping 32 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6453 var mock = new common_test.HttpServerMock();	6541 var mock = new common_test.HttpServerMock();

6454 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;	6542 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6455 var arg_matchId = "foo";	6543 var arg_matchId = "foo";

6456 var arg_includeMatchData = true;	6544 var arg_includeMatchData = true;

6457 var arg_language = "foo";	6545 var arg_language = "foo";

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

6459 var path = (req.url).path;	6547 var path = (req.url).path;

6460 var pathOffset = 0;	6548 var pathOffset = 0;

6461 var index;	6549 var index;

6462 var subPart;	6550 var subPart;

6463 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6551 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6464 pathOffset += 10;	6552 pathOffset += 1;

	6553 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6554 pathOffset += 9;

6465 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6555 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6466 pathOffset += 17;	6556 pathOffset += 17;

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

6468 pathOffset = path.length;	6558 pathOffset = path.length;

6469 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6559 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6470	6560

6471 var query = (req.url).query;	6561 var query = (req.url).query;

6472 var queryOffset = 0;	6562 var queryOffset = 0;

6473 var queryMap = {};	6563 var queryMap = {};

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

(...skipping 28 matching lines...) Expand all Loading...
6503	6593

6504 var mock = new common_test.HttpServerMock();	6594 var mock = new common_test.HttpServerMock();

6505 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;	6595 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6506 var arg_matchId = "foo";	6596 var arg_matchId = "foo";

6507 var arg_language = "foo";	6597 var arg_language = "foo";

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

6509 var path = (req.url).path;	6599 var path = (req.url).path;

6510 var pathOffset = 0;	6600 var pathOffset = 0;

6511 var index;	6601 var index;

6512 var subPart;	6602 var subPart;

6513 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6603 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6514 pathOffset += 10;	6604 pathOffset += 1;

	6605 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6606 pathOffset += 9;

6515 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6607 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6516 pathOffset += 17;	6608 pathOffset += 17;

6517 index = path.indexOf("/join", pathOffset);	6609 index = path.indexOf("/join", pathOffset);

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

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

6520 pathOffset = index;	6612 pathOffset = index;

6521 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6613 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6522 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/join"));	6614 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/join"));

6523 pathOffset += 5;	6615 pathOffset += 5;

6524	6616

(...skipping 31 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6556	6648

6557 var mock = new common_test.HttpServerMock();	6649 var mock = new common_test.HttpServerMock();

6558 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;	6650 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6559 var arg_matchId = "foo";	6651 var arg_matchId = "foo";

6560 var arg_language = "foo";	6652 var arg_language = "foo";

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

6562 var path = (req.url).path;	6654 var path = (req.url).path;

6563 var pathOffset = 0;	6655 var pathOffset = 0;

6564 var index;	6656 var index;

6565 var subPart;	6657 var subPart;

6566 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6658 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6567 pathOffset += 10;	6659 pathOffset += 1;

	6660 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6661 pathOffset += 9;

6568 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6662 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6569 pathOffset += 17;	6663 pathOffset += 17;

6570 index = path.indexOf("/leave", pathOffset);	6664 index = path.indexOf("/leave", pathOffset);

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

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

6573 pathOffset = index;	6667 pathOffset = index;

6574 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6668 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6575 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/leave"));	6669 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/leave"));

6576 pathOffset += 6;	6670 pathOffset += 6;

6577	6671

(...skipping 33 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6611 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;	6705 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6612 var arg_matchId = "foo";	6706 var arg_matchId = "foo";

6613 var arg_matchVersion = 42;	6707 var arg_matchVersion = 42;

6614 var arg_language = "foo";	6708 var arg_language = "foo";

6615 var arg_pendingParticipantId = "foo";	6709 var arg_pendingParticipantId = "foo";

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

6617 var path = (req.url).path;	6711 var path = (req.url).path;

6618 var pathOffset = 0;	6712 var pathOffset = 0;

6619 var index;	6713 var index;

6620 var subPart;	6714 var subPart;

6621 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6715 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6622 pathOffset += 10;	6716 pathOffset += 1;

	6717 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6718 pathOffset += 9;

6623 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6719 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6624 pathOffset += 17;	6720 pathOffset += 17;

6625 index = path.indexOf("/leaveTurn", pathOffset);	6721 index = path.indexOf("/leaveTurn", pathOffset);

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

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

6628 pathOffset = index;	6724 pathOffset = index;

6629 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6725 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6630 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/leaveTurn"));	6726 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/leaveTurn"));

6631 pathOffset += 10;	6727 pathOffset += 10;

6632	6728

(...skipping 36 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6669 var arg_includeMatchData = true;	6765 var arg_includeMatchData = true;

6670 var arg_language = "foo";	6766 var arg_language = "foo";

6671 var arg_maxCompletedMatches = 42;	6767 var arg_maxCompletedMatches = 42;

6672 var arg_maxResults = 42;	6768 var arg_maxResults = 42;

6673 var arg_pageToken = "foo";	6769 var arg_pageToken = "foo";

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

6675 var path = (req.url).path;	6771 var path = (req.url).path;

6676 var pathOffset = 0;	6772 var pathOffset = 0;

6677 var index;	6773 var index;

6678 var subPart;	6774 var subPart;

6679 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6775 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6680 pathOffset += 10;	6776 pathOffset += 1;

	6777 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6778 pathOffset += 9;

6681 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("turnbasedmatches"));	6779 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("turnbasedmatches"));

6682 pathOffset += 16;	6780 pathOffset += 16;

6683	6781

6684 var query = (req.url).query;	6782 var query = (req.url).query;

6685 var queryOffset = 0;	6783 var queryOffset = 0;

6686 var queryMap = {};	6784 var queryMap = {};

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

6688 parseBool(n) {	6786 parseBool(n) {

6689 if (n == "true") return true;	6787 if (n == "true") return true;

6690 if (n == "false") return false;	6788 if (n == "false") return false;

(...skipping 29 matching lines...) Expand all Loading...
6720 var mock = new common_test.HttpServerMock();	6818 var mock = new common_test.HttpServerMock();

6721 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;	6819 api.TurnBasedMatchesResourceApi res = new api.GamesApi(mock).turnBasedMatc hes;

6722 var arg_matchId = "foo";	6820 var arg_matchId = "foo";

6723 var arg_language = "foo";	6821 var arg_language = "foo";

6724 var arg_requestId = "foo";	6822 var arg_requestId = "foo";

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

6726 var path = (req.url).path;	6824 var path = (req.url).path;

6727 var pathOffset = 0;	6825 var pathOffset = 0;

6728 var index;	6826 var index;

6729 var subPart;	6827 var subPart;

6730 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6828 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6731 pathOffset += 10;	6829 pathOffset += 1;

	6830 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6831 pathOffset += 9;

6732 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6832 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6733 pathOffset += 17;	6833 pathOffset += 17;

6734 index = path.indexOf("/rematch", pathOffset);	6834 index = path.indexOf("/rematch", pathOffset);

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

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

6737 pathOffset = index;	6837 pathOffset = index;

6738 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6838 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6739 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/rematch"));	6839 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/rematch"));

6740 pathOffset += 8;	6840 pathOffset += 8;

6741	6841

(...skipping 35 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6777 var arg_includeMatchData = true;	6877 var arg_includeMatchData = true;

6778 var arg_language = "foo";	6878 var arg_language = "foo";

6779 var arg_maxCompletedMatches = 42;	6879 var arg_maxCompletedMatches = 42;

6780 var arg_maxResults = 42;	6880 var arg_maxResults = 42;

6781 var arg_pageToken = "foo";	6881 var arg_pageToken = "foo";

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

6783 var path = (req.url).path;	6883 var path = (req.url).path;

6784 var pathOffset = 0;	6884 var pathOffset = 0;

6785 var index;	6885 var index;

6786 var subPart;	6886 var subPart;

6787 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6887 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6788 pathOffset += 10;	6888 pathOffset += 1;

	6889 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6890 pathOffset += 9;

6789 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("turnbasedmatches/sync"));	6891 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("turnbasedmatches/sync"));

6790 pathOffset += 21;	6892 pathOffset += 21;

6791	6893

6792 var query = (req.url).query;	6894 var query = (req.url).query;

6793 var queryOffset = 0;	6895 var queryOffset = 0;

6794 var queryMap = {};	6896 var queryMap = {};

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

6796 parseBool(n) {	6898 parseBool(n) {

6797 if (n == "true") return true;	6899 if (n == "true") return true;

6798 if (n == "false") return false;	6900 if (n == "false") return false;

(...skipping 32 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6831 var arg_matchId = "foo";	6933 var arg_matchId = "foo";

6832 var arg_language = "foo";	6934 var arg_language = "foo";

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

6834 var obj = new api.TurnBasedMatchTurn.fromJson(json);	6936 var obj = new api.TurnBasedMatchTurn.fromJson(json);

6835 checkTurnBasedMatchTurn(obj);	6937 checkTurnBasedMatchTurn(obj);

6836	6938

6837 var path = (req.url).path;	6939 var path = (req.url).path;

6838 var pathOffset = 0;	6940 var pathOffset = 0;

6839 var index;	6941 var index;

6840 var subPart;	6942 var subPart;

6841 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/games/v1/"));	6943 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6842 pathOffset += 10;	6944 pathOffset += 1;

	6945 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("games/v1/"));

	6946 pathOffset += 9;

6843 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));	6947 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("turnbasedmatches/"));

6844 pathOffset += 17;	6948 pathOffset += 17;

6845 index = path.indexOf("/turn", pathOffset);	6949 index = path.indexOf("/turn", pathOffset);

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

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

6848 pathOffset = index;	6952 pathOffset = index;

6849 unittest.expect(subPart, unittest.equals("$arg_matchId"));	6953 unittest.expect(subPart, unittest.equals("$arg_matchId"));

6850 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/turn"));	6954 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/turn"));

6851 pathOffset += 5;	6955 pathOffset += 5;

6852	6956

(...skipping 25 matching lines...) Expand all Loading...
6878 res.takeTurn(arg_request, arg_matchId, language: arg_language).then(unitte st.expectAsync(((api.TurnBasedMatch response) {	6982 res.takeTurn(arg_request, arg_matchId, language: arg_language).then(unitte st.expectAsync(((api.TurnBasedMatch response) {

6879 checkTurnBasedMatch(response);	6983 checkTurnBasedMatch(response);

6880 })));	6984 })));

6881 });	6985 });

6882	6986

6883 });	6987 });

6884	6988

6885	6989

6886 }	6990 }

6887	6991

OLD	NEW