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

Side by Side Diff: generated/googleapis/test/gamesmanagement/v1management.dart

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

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

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

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 library googleapis.gamesManagement.v1management.test;

2

3 import "dart:core" as core;

4 import "dart:collection" as collection;

5 import "dart:async" as async;

6 import "dart:convert" as convert;

7

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

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

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

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

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

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

14

15 import 'package:googleapis/gamesmanagement/v1management.dart' as api;

16

17

18

19 buildUnnamed431() {

20 var o = new core.List<api.AchievementResetResponse>();

21 o.add(buildAchievementResetResponse());

22 o.add(buildAchievementResetResponse());

23 return o;

24 }

25

26 checkUnnamed431(core.List<api.AchievementResetResponse> o) {

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

28 checkAchievementResetResponse(o[0]);

29 checkAchievementResetResponse(o[1]);

30 }

31

32 core.int buildCounterAchievementResetAllResponse = 0;

33 buildAchievementResetAllResponse() {

34 var o = new api.AchievementResetAllResponse();

35 buildCounterAchievementResetAllResponse++;

36 if (buildCounterAchievementResetAllResponse < 3) {

37 o.kind = "foo";

38 o.results = buildUnnamed431();

39 }

40 buildCounterAchievementResetAllResponse--;

41 return o;

42 }

43

44 checkAchievementResetAllResponse(api.AchievementResetAllResponse o) {

45 buildCounterAchievementResetAllResponse++;

46 if (buildCounterAchievementResetAllResponse < 3) {

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

48 checkUnnamed431(o.results);

49 }

50 buildCounterAchievementResetAllResponse--;

51 }

52

53 core.int buildCounterAchievementResetResponse = 0;

54 buildAchievementResetResponse() {

55 var o = new api.AchievementResetResponse();

56 buildCounterAchievementResetResponse++;

57 if (buildCounterAchievementResetResponse < 3) {

58 o.currentState = "foo";

59 o.definitionId = "foo";

60 o.kind = "foo";

61 o.updateOccurred = true;

62 }

63 buildCounterAchievementResetResponse--;

64 return o;

65 }

66

67 checkAchievementResetResponse(api.AchievementResetResponse o) {

68 buildCounterAchievementResetResponse++;

69 if (buildCounterAchievementResetResponse < 3) {

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

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

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

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

74 }

75 buildCounterAchievementResetResponse--;

76 }

77

78 core.int buildCounterGamesPlayedResource = 0;

79 buildGamesPlayedResource() {

80 var o = new api.GamesPlayedResource();

81 buildCounterGamesPlayedResource++;

82 if (buildCounterGamesPlayedResource < 3) {

83 o.autoMatched = true;

84 o.timeMillis = "foo";

85 }

86 buildCounterGamesPlayedResource--;

87 return o;

88 }

89

90 checkGamesPlayedResource(api.GamesPlayedResource o) {

91 buildCounterGamesPlayedResource++;

92 if (buildCounterGamesPlayedResource < 3) {

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

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

95 }

96 buildCounterGamesPlayedResource--;

97 }

98

99 core.int buildCounterGamesPlayerExperienceInfoResource = 0;

100 buildGamesPlayerExperienceInfoResource() {

101 var o = new api.GamesPlayerExperienceInfoResource();

102 buildCounterGamesPlayerExperienceInfoResource++;

103 if (buildCounterGamesPlayerExperienceInfoResource < 3) {

104 o.currentExperiencePoints = "foo";

105 o.currentLevel = buildGamesPlayerLevelResource();

106 o.lastLevelUpTimestampMillis = "foo";

107 o.nextLevel = buildGamesPlayerLevelResource();

108 }

109 buildCounterGamesPlayerExperienceInfoResource--;

110 return o;

111 }

112

113 checkGamesPlayerExperienceInfoResource(api.GamesPlayerExperienceInfoResource o) {

114 buildCounterGamesPlayerExperienceInfoResource++;

115 if (buildCounterGamesPlayerExperienceInfoResource < 3) {

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

117 checkGamesPlayerLevelResource(o.currentLevel);

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

119 checkGamesPlayerLevelResource(o.nextLevel);

120 }

121 buildCounterGamesPlayerExperienceInfoResource--;

122 }

123

124 core.int buildCounterGamesPlayerLevelResource = 0;

125 buildGamesPlayerLevelResource() {

126 var o = new api.GamesPlayerLevelResource();

127 buildCounterGamesPlayerLevelResource++;

128 if (buildCounterGamesPlayerLevelResource < 3) {

129 o.level = 42;

130 o.maxExperiencePoints = "foo";

131 o.minExperiencePoints = "foo";

132 }

133 buildCounterGamesPlayerLevelResource--;

134 return o;

135 }

136

137 checkGamesPlayerLevelResource(api.GamesPlayerLevelResource o) {

138 buildCounterGamesPlayerLevelResource++;

139 if (buildCounterGamesPlayerLevelResource < 3) {

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

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

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

143 }

144 buildCounterGamesPlayerLevelResource--;

145 }

146

147 core.int buildCounterHiddenPlayer = 0;

148 buildHiddenPlayer() {

149 var o = new api.HiddenPlayer();

150 buildCounterHiddenPlayer++;

151 if (buildCounterHiddenPlayer < 3) {

152 o.hiddenTimeMillis = "foo";

153 o.kind = "foo";

154 o.player = buildPlayer();

155 }

156 buildCounterHiddenPlayer--;

157 return o;

158 }

159

160 checkHiddenPlayer(api.HiddenPlayer o) {

161 buildCounterHiddenPlayer++;

162 if (buildCounterHiddenPlayer < 3) {

163 unittest.expect(o.hiddenTimeMillis, unittest.equals('foo'));

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

165 checkPlayer(o.player);

166 }

167 buildCounterHiddenPlayer--;

168 }

169

170 buildUnnamed432() {

171 var o = new core.List<api.HiddenPlayer>();

172 o.add(buildHiddenPlayer());

173 o.add(buildHiddenPlayer());

174 return o;

175 }

176

177 checkUnnamed432(core.List<api.HiddenPlayer> o) {

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

179 checkHiddenPlayer(o[0]);

180 checkHiddenPlayer(o[1]);

181 }

182

183 core.int buildCounterHiddenPlayerList = 0;

184 buildHiddenPlayerList() {

185 var o = new api.HiddenPlayerList();

186 buildCounterHiddenPlayerList++;

187 if (buildCounterHiddenPlayerList < 3) {

188 o.items = buildUnnamed432();

189 o.kind = "foo";

190 o.nextPageToken = "foo";

191 }

192 buildCounterHiddenPlayerList--;

193 return o;

194 }

195

196 checkHiddenPlayerList(api.HiddenPlayerList o) {

197 buildCounterHiddenPlayerList++;

198 if (buildCounterHiddenPlayerList < 3) {

199 checkUnnamed432(o.items);

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

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

202 }

203 buildCounterHiddenPlayerList--;

204 }

205

206 core.int buildCounterPlayerName = 0;

207 buildPlayerName() {

208 var o = new api.PlayerName();

209 buildCounterPlayerName++;

210 if (buildCounterPlayerName < 3) {

211 o.familyName = "foo";

212 o.givenName = "foo";

213 }

214 buildCounterPlayerName--;

215 return o;

216 }

217

218 checkPlayerName(api.PlayerName o) {

219 buildCounterPlayerName++;

220 if (buildCounterPlayerName < 3) {

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

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

223 }

224 buildCounterPlayerName--;

225 }

226

227 core.int buildCounterPlayer = 0;

228 buildPlayer() {

229 var o = new api.Player();

230 buildCounterPlayer++;

231 if (buildCounterPlayer < 3) {

232 o.avatarImageUrl = "foo";

233 o.displayName = "foo";

234 o.experienceInfo = buildGamesPlayerExperienceInfoResource();

235 o.kind = "foo";

236 o.lastPlayedWith = buildGamesPlayedResource();

237 o.name = buildPlayerName();

238 o.playerId = "foo";

239 o.title = "foo";

240 }

241 buildCounterPlayer--;

242 return o;

243 }

244

245 checkPlayer(api.Player o) {

246 buildCounterPlayer++;

247 if (buildCounterPlayer < 3) {

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

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

250 checkGamesPlayerExperienceInfoResource(o.experienceInfo);

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

252 checkGamesPlayedResource(o.lastPlayedWith);

253 checkPlayerName(o.name);

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

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

256 }

257 buildCounterPlayer--;

258 }

259

260 buildUnnamed433() {

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

262 o.add("foo");

263 o.add("foo");

264 return o;

265 }

266

267 checkUnnamed433(core.List<core.String> o) {

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

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

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

271 }

272

273 core.int buildCounterPlayerScoreResetResponse = 0;

274 buildPlayerScoreResetResponse() {

275 var o = new api.PlayerScoreResetResponse();

276 buildCounterPlayerScoreResetResponse++;

277 if (buildCounterPlayerScoreResetResponse < 3) {

278 o.kind = "foo";

279 o.resetScoreTimeSpans = buildUnnamed433();

280 }

281 buildCounterPlayerScoreResetResponse--;

282 return o;

283 }

284

285 checkPlayerScoreResetResponse(api.PlayerScoreResetResponse o) {

286 buildCounterPlayerScoreResetResponse++;

287 if (buildCounterPlayerScoreResetResponse < 3) {

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

289 checkUnnamed433(o.resetScoreTimeSpans);

290 }

291 buildCounterPlayerScoreResetResponse--;

292 }

293

294

295 main() {

296 unittest.group("obj-schema-AchievementResetAllResponse", () {

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

298 var o = buildAchievementResetAllResponse();

299 var od = new api.AchievementResetAllResponse.fromJson(o.toJson());

300 checkAchievementResetAllResponse(od);

301 });

302 });

303

304

305 unittest.group("obj-schema-AchievementResetResponse", () {

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

307 var o = buildAchievementResetResponse();

308 var od = new api.AchievementResetResponse.fromJson(o.toJson());

309 checkAchievementResetResponse(od);

310 });

311 });

312

313

314 unittest.group("obj-schema-GamesPlayedResource", () {

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

316 var o = buildGamesPlayedResource();

317 var od = new api.GamesPlayedResource.fromJson(o.toJson());

318 checkGamesPlayedResource(od);

319 });

320 });

321

322

323 unittest.group("obj-schema-GamesPlayerExperienceInfoResource", () {

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

325 var o = buildGamesPlayerExperienceInfoResource();

326 var od = new api.GamesPlayerExperienceInfoResource.fromJson(o.toJson());

327 checkGamesPlayerExperienceInfoResource(od);

328 });

329 });

330

331

332 unittest.group("obj-schema-GamesPlayerLevelResource", () {

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

334 var o = buildGamesPlayerLevelResource();

335 var od = new api.GamesPlayerLevelResource.fromJson(o.toJson());

336 checkGamesPlayerLevelResource(od);

337 });

338 });

339

340

341 unittest.group("obj-schema-HiddenPlayer", () {

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

343 var o = buildHiddenPlayer();

344 var od = new api.HiddenPlayer.fromJson(o.toJson());

345 checkHiddenPlayer(od);

346 });

347 });

348

349

350 unittest.group("obj-schema-HiddenPlayerList", () {

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

352 var o = buildHiddenPlayerList();

353 var od = new api.HiddenPlayerList.fromJson(o.toJson());

354 checkHiddenPlayerList(od);

355 });

356 });

357

358

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

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

361 var o = buildPlayerName();

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

363 checkPlayerName(od);

364 });

365 });

366

367

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

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

370 var o = buildPlayer();

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

372 checkPlayer(od);

373 });

374 });

375

376

377 unittest.group("obj-schema-PlayerScoreResetResponse", () {

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

379 var o = buildPlayerScoreResetResponse();

380 var od = new api.PlayerScoreResetResponse.fromJson(o.toJson());

381 checkPlayerScoreResetResponse(od);

382 });

383 });

384

385

386 unittest.group("resource-AchievementsResourceApi", () {

387 unittest.test("method--reset", () {

388

389 var mock = new common_test.HttpServerMock();

390 api.AchievementsResourceApi res = new api.GamesManagementApi(mock).achieve ments;

391 var arg_achievementId = "foo";

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

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

394 var pathOffset = 0;

395 var index;

396 var subPart;

397 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

398 pathOffset += 20;

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

400 pathOffset += 13;

401 index = path.indexOf("/reset", pathOffset);

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

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

404 pathOffset = index;

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

406 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/reset"));

407 pathOffset += 6;

408

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

410 var queryOffset = 0;

411 var queryMap = {};

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

413 parseBool(n) {

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

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

416 if (n == null) return null;

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

418 }

419 if (query.length > 0) {

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

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

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

423 }

424 }

425

426

427 var h = {

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

429 };

430 var resp = convert.JSON.encode(buildAchievementResetResponse());

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

432 }), true);

433 res.reset(arg_achievementId).then(unittest.expectAsync(((api.AchievementRe setResponse response) {

434 checkAchievementResetResponse(response);

435 })));

436 });

437

438 unittest.test("method--resetAll", () {

439

440 var mock = new common_test.HttpServerMock();

441 api.AchievementsResourceApi res = new api.GamesManagementApi(mock).achieve ments;

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

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

444 var pathOffset = 0;

445 var index;

446 var subPart;

447 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

448 pathOffset += 20;

449 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("achievements/reset"));

450 pathOffset += 18;

451

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

453 var queryOffset = 0;

454 var queryMap = {};

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

456 parseBool(n) {

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

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

459 if (n == null) return null;

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

461 }

462 if (query.length > 0) {

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

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

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

466 }

467 }

468

469

470 var h = {

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

472 };

473 var resp = convert.JSON.encode(buildAchievementResetAllResponse());

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

475 }), true);

476 res.resetAll().then(unittest.expectAsync(((api.AchievementResetAllResponse response) {

477 checkAchievementResetAllResponse(response);

478 })));

479 });

480

481 unittest.test("method--resetForAllPlayers", () {

482

483 var mock = new common_test.HttpServerMock();

484 api.AchievementsResourceApi res = new api.GamesManagementApi(mock).achieve ments;

485 var arg_achievementId = "foo";

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

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

488 var pathOffset = 0;

489 var index;

490 var subPart;

491 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

492 pathOffset += 20;

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

494 pathOffset += 13;

495 index = path.indexOf("/resetForAllPlayers", pathOffset);

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

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

498 pathOffset = index;

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

500 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("/resetForAllPlayers"));

501 pathOffset += 19;

502

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

504 var queryOffset = 0;

505 var queryMap = {};

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

507 parseBool(n) {

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

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

510 if (n == null) return null;

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

512 }

513 if (query.length > 0) {

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

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

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

517 }

518 }

519

520

521 var h = {

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

523 };

524 var resp = "";

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

526 }), true);

527 res.resetForAllPlayers(arg_achievementId).then(unittest.expectAsync((_) {} ));

528 });

529

530 });

531

532

533 unittest.group("resource-ApplicationsResourceApi", () {

534 unittest.test("method--listHidden", () {

535

536 var mock = new common_test.HttpServerMock();

537 api.ApplicationsResourceApi res = new api.GamesManagementApi(mock).applica tions;

538 var arg_applicationId = "foo";

539 var arg_maxResults = 42;

540 var arg_pageToken = "foo";

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

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

543 var pathOffset = 0;

544 var index;

545 var subPart;

546 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

547 pathOffset += 20;

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

549 pathOffset += 13;

550 index = path.indexOf("/players/hidden", pathOffset);

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

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

553 pathOffset = index;

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

555 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/players/hidden"));

556 pathOffset += 15;

557

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

559 var queryOffset = 0;

560 var queryMap = {};

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

562 parseBool(n) {

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

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

565 if (n == null) return null;

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

567 }

568 if (query.length > 0) {

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

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

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

572 }

573 }

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

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

576

577

578 var h = {

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

580 };

581 var resp = convert.JSON.encode(buildHiddenPlayerList());

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

583 }), true);

584 res.listHidden(arg_applicationId, maxResults: arg_maxResults, pageToken: a rg_pageToken).then(unittest.expectAsync(((api.HiddenPlayerList response) {

585 checkHiddenPlayerList(response);

586 })));

587 });

588

589 });

590

591

592 unittest.group("resource-EventsResourceApi", () {

593 unittest.test("method--reset", () {

594

595 var mock = new common_test.HttpServerMock();

596 api.EventsResourceApi res = new api.GamesManagementApi(mock).events;

597 var arg_eventId = "foo";

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

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

600 var pathOffset = 0;

601 var index;

602 var subPart;

603 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

604 pathOffset += 20;

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

606 pathOffset += 7;

607 index = path.indexOf("/reset", pathOffset);

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

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

610 pathOffset = index;

611 unittest.expect(subPart, unittest.equals("$arg_eventId"));

612 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/reset"));

613 pathOffset += 6;

614

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

616 var queryOffset = 0;

617 var queryMap = {};

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

619 parseBool(n) {

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

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

622 if (n == null) return null;

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

624 }

625 if (query.length > 0) {

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

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

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

629 }

630 }

631

632

633 var h = {

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

635 };

636 var resp = "";

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

638 }), true);

639 res.reset(arg_eventId).then(unittest.expectAsync((_) {}));

640 });

641

642 unittest.test("method--resetAll", () {

643

644 var mock = new common_test.HttpServerMock();

645 api.EventsResourceApi res = new api.GamesManagementApi(mock).events;

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

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

648 var pathOffset = 0;

649 var index;

650 var subPart;

651 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

652 pathOffset += 20;

653 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("events/reset"));

654 pathOffset += 12;

655

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

657 var queryOffset = 0;

658 var queryMap = {};

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

660 parseBool(n) {

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

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

663 if (n == null) return null;

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

665 }

666 if (query.length > 0) {

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

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

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

670 }

671 }

672

673

674 var h = {

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

676 };

677 var resp = "";

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

679 }), true);

680 res.resetAll().then(unittest.expectAsync((_) {}));

681 });

682

683 unittest.test("method--resetForAllPlayers", () {

684

685 var mock = new common_test.HttpServerMock();

686 api.EventsResourceApi res = new api.GamesManagementApi(mock).events;

687 var arg_eventId = "foo";

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

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

690 var pathOffset = 0;

691 var index;

692 var subPart;

693 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

694 pathOffset += 20;

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

696 pathOffset += 7;

697 index = path.indexOf("/resetForAllPlayers", pathOffset);

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

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

700 pathOffset = index;

701 unittest.expect(subPart, unittest.equals("$arg_eventId"));

702 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("/resetForAllPlayers"));

703 pathOffset += 19;

704

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

706 var queryOffset = 0;

707 var queryMap = {};

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

709 parseBool(n) {

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

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

712 if (n == null) return null;

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

714 }

715 if (query.length > 0) {

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

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

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

719 }

720 }

721

722

723 var h = {

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

725 };

726 var resp = "";

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

728 }), true);

729 res.resetForAllPlayers(arg_eventId).then(unittest.expectAsync((_) {}));

730 });

731

732 });

733

734

735 unittest.group("resource-PlayersResourceApi", () {

736 unittest.test("method--hide", () {

737

738 var mock = new common_test.HttpServerMock();

739 api.PlayersResourceApi res = new api.GamesManagementApi(mock).players;

740 var arg_applicationId = "foo";

741 var arg_playerId = "foo";

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

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

744 var pathOffset = 0;

745 var index;

746 var subPart;

747 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

748 pathOffset += 20;

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

750 pathOffset += 13;

751 index = path.indexOf("/players/hidden/", pathOffset);

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

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

754 pathOffset = index;

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

756 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/players/hidden/"));

757 pathOffset += 16;

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

759 pathOffset = path.length;

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

761

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

763 var queryOffset = 0;

764 var queryMap = {};

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

766 parseBool(n) {

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

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

769 if (n == null) return null;

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

771 }

772 if (query.length > 0) {

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

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

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

776 }

777 }

778

779

780 var h = {

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

782 };

783 var resp = "";

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

785 }), true);

786 res.hide(arg_applicationId, arg_playerId).then(unittest.expectAsync((_) {} ));

787 });

788

789 unittest.test("method--unhide", () {

790

791 var mock = new common_test.HttpServerMock();

792 api.PlayersResourceApi res = new api.GamesManagementApi(mock).players;

793 var arg_applicationId = "foo";

794 var arg_playerId = "foo";

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

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

797 var pathOffset = 0;

798 var index;

799 var subPart;

800 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

801 pathOffset += 20;

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

803 pathOffset += 13;

804 index = path.indexOf("/players/hidden/", pathOffset);

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

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

807 pathOffset = index;

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

809 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/players/hidden/"));

810 pathOffset += 16;

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

812 pathOffset = path.length;

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

814

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

816 var queryOffset = 0;

817 var queryMap = {};

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

819 parseBool(n) {

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

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

822 if (n == null) return null;

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

824 }

825 if (query.length > 0) {

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

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

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

829 }

830 }

831

832

833 var h = {

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

835 };

836 var resp = "";

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

838 }), true);

839 res.unhide(arg_applicationId, arg_playerId).then(unittest.expectAsync((_) {}));

840 });

841

842 });

843

844

845 unittest.group("resource-QuestsResourceApi", () {

846 unittest.test("method--reset", () {

847

848 var mock = new common_test.HttpServerMock();

849 api.QuestsResourceApi res = new api.GamesManagementApi(mock).quests;

850 var arg_questId = "foo";

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

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

853 var pathOffset = 0;

854 var index;

855 var subPart;

856 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

857 pathOffset += 20;

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

859 pathOffset += 7;

860 index = path.indexOf("/reset", pathOffset);

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

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

863 pathOffset = index;

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

865 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/reset"));

866 pathOffset += 6;

867

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

869 var queryOffset = 0;

870 var queryMap = {};

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

872 parseBool(n) {

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

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

875 if (n == null) return null;

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

877 }

878 if (query.length > 0) {

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

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

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

882 }

883 }

884

885

886 var h = {

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

888 };

889 var resp = "";

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

891 }), true);

892 res.reset(arg_questId).then(unittest.expectAsync((_) {}));

893 });

894

895 });

896

897

898 unittest.group("resource-RoomsResourceApi", () {

899 unittest.test("method--reset", () {

900

901 var mock = new common_test.HttpServerMock();

902 api.RoomsResourceApi res = new api.GamesManagementApi(mock).rooms;

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

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

905 var pathOffset = 0;

906 var index;

907 var subPart;

908 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

909 pathOffset += 20;

910 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("rooms/reset"));

911 pathOffset += 11;

912

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

914 var queryOffset = 0;

915 var queryMap = {};

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

917 parseBool(n) {

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

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

920 if (n == null) return null;

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

922 }

923 if (query.length > 0) {

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

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

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

927 }

928 }

929

930

931 var h = {

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

933 };

934 var resp = "";

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

936 }), true);

937 res.reset().then(unittest.expectAsync((_) {}));

938 });

939

940 });

941

942

943 unittest.group("resource-ScoresResourceApi", () {

944 unittest.test("method--reset", () {

945

946 var mock = new common_test.HttpServerMock();

947 api.ScoresResourceApi res = new api.GamesManagementApi(mock).scores;

948 var arg_leaderboardId = "foo";

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

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

951 var pathOffset = 0;

952 var index;

953 var subPart;

954 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

955 pathOffset += 20;

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

957 pathOffset += 13;

958 index = path.indexOf("/scores/reset", pathOffset);

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

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

961 pathOffset = index;

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

963 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/scores/reset"));

964 pathOffset += 13;

965

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

967 var queryOffset = 0;

968 var queryMap = {};

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

970 parseBool(n) {

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

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

973 if (n == null) return null;

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

975 }

976 if (query.length > 0) {

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

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

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

980 }

981 }

982

983

984 var h = {

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

986 };

987 var resp = convert.JSON.encode(buildPlayerScoreResetResponse());

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

989 }), true);

990 res.reset(arg_leaderboardId).then(unittest.expectAsync(((api.PlayerScoreRe setResponse response) {

991 checkPlayerScoreResetResponse(response);

992 })));

993 });

994

995 unittest.test("method--resetForAllPlayers", () {

996

997 var mock = new common_test.HttpServerMock();

998 api.ScoresResourceApi res = new api.GamesManagementApi(mock).scores;

999 var arg_leaderboardId = "foo";

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

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

1002 var pathOffset = 0;

1003 var index;

1004 var subPart;

1005 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

1006 pathOffset += 20;

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

1008 pathOffset += 13;

1009 index = path.indexOf("/scores/resetForAllPlayers", pathOffset);

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

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

1012 pathOffset = index;

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

1014 unittest.expect(path.substring(pathOffset, pathOffset + 26), unittest.eq uals("/scores/resetForAllPlayers"));

1015 pathOffset += 26;

1016

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

1018 var queryOffset = 0;

1019 var queryMap = {};

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

1021 parseBool(n) {

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

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

1024 if (n == null) return null;

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

1026 }

1027 if (query.length > 0) {

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

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

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

1031 }

1032 }

1033

1034

1035 var h = {

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

1037 };

1038 var resp = "";

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

1040 }), true);

1041 res.resetForAllPlayers(arg_leaderboardId).then(unittest.expectAsync((_) {} ));

1042 });

1043

1044 });

1045

1046

1047 unittest.group("resource-TurnBasedMatchesResourceApi", () {

1048 unittest.test("method--reset", () {

1049

1050 var mock = new common_test.HttpServerMock();

1051 api.TurnBasedMatchesResourceApi res = new api.GamesManagementApi(mock).tur nBasedMatches;

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

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

1054 var pathOffset = 0;

1055 var index;

1056 var subPart;

1057 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/games/v1management/"));

1058 pathOffset += 20;

1059 unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.eq uals("turnbasedmatches/reset"));

1060 pathOffset += 22;

1061

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

1063 var queryOffset = 0;

1064 var queryMap = {};

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

1066 parseBool(n) {

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

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

1069 if (n == null) return null;

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

1071 }

1072 if (query.length > 0) {

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

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

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

1076 }

1077 }

1078

1079

1080 var h = {

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

1082 };

1083 var resp = "";

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

1085 }), true);

1086 res.reset().then(unittest.expectAsync((_) {}));

1087 });

1088

1089 });

1090

1091

1092 }

1093

OLD	NEW

« no previous file with comments | « generated/googleapis/test/games/v1_test.dart ('k') | generated/googleapis/test/gamesmanagement/v1management_test.dart » ('j') | no next file with comments »