generated/googleapis/test/mapsengine/v1_test.dart - Issue 1797933002: Api-roll 33: 2016-03-14

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

Issue 1797933002: Api-roll 33: 2016-03-14 (Closed) Base URL: git@github.com:dart-lang/googleapis.git@master

Patch Set: Added resources/*/CHANGELOG.md, addresssed comments Created 4 years, 9 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:

OLD	NEW
	(Empty)
1 library googleapis.mapsengine.v1.test;

2

3 import "dart:core" as core;

4 import "dart:collection" as collection;

5 import "dart:async" as async;

6 import "dart:convert" as convert;

7

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

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

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

11

12 import 'package:googleapis/mapsengine/v1.dart' as api;

13

14 class HttpServerMock extends http.BaseClient {

15 core.Function _callback;

16 core.bool _expectJson;

17

18 void register(core.Function callback, core.bool expectJson) {

19 _callback = callback;

20 _expectJson = expectJson;

21 }

22

23 async.Future<http.StreamedResponse> send(http.BaseRequest request) {

24 if (_expectJson) {

25 return request.finalize()

26 .transform(convert.UTF8.decoder)

27 .join('')

28 .then((core.String jsonString) {

29 if (jsonString.isEmpty) {

30 return _callback(request, null);

31 } else {

32 return _callback(request, convert.JSON.decode(jsonString));

33 }

34 });

35 } else {

36 var stream = request.finalize();

37 if (stream == null) {

38 return _callback(request, []);

39 } else {

40 return stream.toBytes().then((data) {

41 return _callback(request, data);

42 });

43 }

44 }

45 }

46 }

47

48 http.StreamedResponse stringResponse(

49 core.int status, core.Map headers, core.String body) {

50 var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]);

51 return new http.StreamedResponse(stream, status, headers: headers);

52 }

53

54 core.int buildCounterAcquisitionTime = 0;

55 buildAcquisitionTime() {

56 var o = new api.AcquisitionTime();

57 buildCounterAcquisitionTime++;

58 if (buildCounterAcquisitionTime < 3) {

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

60 o.precision = "foo";

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

62 }

63 buildCounterAcquisitionTime--;

64 return o;

65 }

66

67 checkAcquisitionTime(api.AcquisitionTime o) {

68 buildCounterAcquisitionTime++;

69 if (buildCounterAcquisitionTime < 3) {

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

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

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

73 }

74 buildCounterAcquisitionTime--;

75 }

76

77 buildUnnamed66() {

78 var o = new core.List<core.double>();

79 o.add(42.0);

80 o.add(42.0);

81 return o;

82 }

83

84 checkUnnamed66(core.List<core.double> o) {

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

86 unittest.expect(o[0], unittest.equals(42.0));

87 unittest.expect(o[1], unittest.equals(42.0));

88 }

89

90 buildUnnamed67() {

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

92 o.add("foo");

93 o.add("foo");

94 return o;

95 }

96

97 checkUnnamed67(core.List<core.String> o) {

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

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

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

101 }

102

103 core.int buildCounterAsset = 0;

104 buildAsset() {

105 var o = new api.Asset();

106 buildCounterAsset++;

107 if (buildCounterAsset < 3) {

108 o.bbox = buildUnnamed66();

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

110 o.creatorEmail = "foo";

111 o.description = "foo";

112 o.etag = "foo";

113 o.id = "foo";

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

115 o.lastModifierEmail = "foo";

116 o.name = "foo";

117 o.projectId = "foo";

118 o.resource = "foo";

119 o.tags = buildUnnamed67();

120 o.type = "foo";

121 o.writersCanEditPermissions = true;

122 }

123 buildCounterAsset--;

124 return o;

125 }

126

127 checkAsset(api.Asset o) {

128 buildCounterAsset++;

129 if (buildCounterAsset < 3) {

130 checkUnnamed66(o.bbox);

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

132 unittest.expect(o.creatorEmail, unittest.equals('foo'));

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

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

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

136 unittest.expect(o.lastModifiedTime, unittest.equals(core.DateTime.parse("200 2-02-27T14:01:02")));

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

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

139 unittest.expect(o.projectId, unittest.equals('foo'));

140 unittest.expect(o.resource, unittest.equals('foo'));

141 checkUnnamed67(o.tags);

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

143 unittest.expect(o.writersCanEditPermissions, unittest.isTrue);

144 }

145 buildCounterAsset--;

146 }

147

148 buildUnnamed68() {

149 var o = new core.List<api.Asset>();

150 o.add(buildAsset());

151 o.add(buildAsset());

152 return o;

153 }

154

155 checkUnnamed68(core.List<api.Asset> o) {

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

157 checkAsset(o[0]);

158 checkAsset(o[1]);

159 }

160

161 core.int buildCounterAssetsListResponse = 0;

162 buildAssetsListResponse() {

163 var o = new api.AssetsListResponse();

164 buildCounterAssetsListResponse++;

165 if (buildCounterAssetsListResponse < 3) {

166 o.assets = buildUnnamed68();

167 o.nextPageToken = "foo";

168 }

169 buildCounterAssetsListResponse--;

170 return o;

171 }

172

173 checkAssetsListResponse(api.AssetsListResponse o) {

174 buildCounterAssetsListResponse++;

175 if (buildCounterAssetsListResponse < 3) {

176 checkUnnamed68(o.assets);

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

178 }

179 buildCounterAssetsListResponse--;

180 }

181

182 core.int buildCounterBorder = 0;

183 buildBorder() {

184 var o = new api.Border();

185 buildCounterBorder++;

186 if (buildCounterBorder < 3) {

187 o.color = "foo";

188 o.opacity = 42.0;

189 o.width = 42.0;

190 }

191 buildCounterBorder--;

192 return o;

193 }

194

195 checkBorder(api.Border o) {

196 buildCounterBorder++;

197 if (buildCounterBorder < 3) {

198 unittest.expect(o.color, unittest.equals('foo'));

199 unittest.expect(o.opacity, unittest.equals(42.0));

200 unittest.expect(o.width, unittest.equals(42.0));

201 }

202 buildCounterBorder--;

203 }

204

205 core.int buildCounterColor = 0;

206 buildColor() {

207 var o = new api.Color();

208 buildCounterColor++;

209 if (buildCounterColor < 3) {

210 o.color = "foo";

211 o.opacity = 42.0;

212 }

213 buildCounterColor--;

214 return o;

215 }

216

217 checkColor(api.Color o) {

218 buildCounterColor++;

219 if (buildCounterColor < 3) {

220 unittest.expect(o.color, unittest.equals('foo'));

221 unittest.expect(o.opacity, unittest.equals(42.0));

222 }

223 buildCounterColor--;

224 }

225

226 core.int buildCounterDatasource = 0;

227 buildDatasource() {

228 var o = new api.Datasource();

229 buildCounterDatasource++;

230 if (buildCounterDatasource < 3) {

231 o.id = "foo";

232 }

233 buildCounterDatasource--;

234 return o;

235 }

236

237 checkDatasource(api.Datasource o) {

238 buildCounterDatasource++;

239 if (buildCounterDatasource < 3) {

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

241 }

242 buildCounterDatasource--;

243 }

244

245 buildDatasources() {

246 var o = new api.Datasources();

247 o.add(buildDatasource());

248 o.add(buildDatasource());

249 return o;

250 }

251

252 checkDatasources(api.Datasources o) {

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

254 checkDatasource(o[0]);

255 checkDatasource(o[1]);

256 }

257

258 buildUnnamed69() {

259 var o = new core.List<api.Filter>();

260 o.add(buildFilter());

261 o.add(buildFilter());

262 return o;

263 }

264

265 checkUnnamed69(core.List<api.Filter> o) {

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

267 checkFilter(o[0]);

268 checkFilter(o[1]);

269 }

270

271 core.int buildCounterDisplayRule = 0;

272 buildDisplayRule() {

273 var o = new api.DisplayRule();

274 buildCounterDisplayRule++;

275 if (buildCounterDisplayRule < 3) {

276 o.filters = buildUnnamed69();

277 o.lineOptions = buildLineStyle();

278 o.name = "foo";

279 o.pointOptions = buildPointStyle();

280 o.polygonOptions = buildPolygonStyle();

281 o.zoomLevels = buildZoomLevels();

282 }

283 buildCounterDisplayRule--;

284 return o;

285 }

286

287 checkDisplayRule(api.DisplayRule o) {

288 buildCounterDisplayRule++;

289 if (buildCounterDisplayRule < 3) {

290 checkUnnamed69(o.filters);

291 checkLineStyle(o.lineOptions);

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

293 checkPointStyle(o.pointOptions);

294 checkPolygonStyle(o.polygonOptions);

295 checkZoomLevels(o.zoomLevels);

296 }

297 buildCounterDisplayRule--;

298 }

299

300 core.int buildCounterFeature = 0;

301 buildFeature() {

302 var o = new api.Feature();

303 buildCounterFeature++;

304 if (buildCounterFeature < 3) {

305 o.geometry = buildGeoJsonGeometry();

306 o.properties = buildGeoJsonProperties();

307 o.type = "foo";

308 }

309 buildCounterFeature--;

310 return o;

311 }

312

313 checkFeature(api.Feature o) {

314 buildCounterFeature++;

315 if (buildCounterFeature < 3) {

316 checkGeoJsonGeometry(o.geometry);

317 checkGeoJsonProperties(o.properties);

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

319 }

320 buildCounterFeature--;

321 }

322

323 core.int buildCounterFeatureInfo = 0;

324 buildFeatureInfo() {

325 var o = new api.FeatureInfo();

326 buildCounterFeatureInfo++;

327 if (buildCounterFeatureInfo < 3) {

328 o.content = "foo";

329 }

330 buildCounterFeatureInfo--;

331 return o;

332 }

333

334 checkFeatureInfo(api.FeatureInfo o) {

335 buildCounterFeatureInfo++;

336 if (buildCounterFeatureInfo < 3) {

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

338 }

339 buildCounterFeatureInfo--;

340 }

341

342 buildUnnamed70() {

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

344 o.add("foo");

345 o.add("foo");

346 return o;

347 }

348

349 checkUnnamed70(core.List<core.String> o) {

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

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

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

353 }

354

355 buildUnnamed71() {

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

357 o.add("foo");

358 o.add("foo");

359 return o;

360 }

361

362 checkUnnamed71(core.List<core.String> o) {

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

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

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

366 }

367

368 core.int buildCounterFeaturesBatchDeleteRequest = 0;

369 buildFeaturesBatchDeleteRequest() {

370 var o = new api.FeaturesBatchDeleteRequest();

371 buildCounterFeaturesBatchDeleteRequest++;

372 if (buildCounterFeaturesBatchDeleteRequest < 3) {

373 o.gxIds = buildUnnamed70();

374 o.primaryKeys = buildUnnamed71();

375 }

376 buildCounterFeaturesBatchDeleteRequest--;

377 return o;

378 }

379

380 checkFeaturesBatchDeleteRequest(api.FeaturesBatchDeleteRequest o) {

381 buildCounterFeaturesBatchDeleteRequest++;

382 if (buildCounterFeaturesBatchDeleteRequest < 3) {

383 checkUnnamed70(o.gxIds);

384 checkUnnamed71(o.primaryKeys);

385 }

386 buildCounterFeaturesBatchDeleteRequest--;

387 }

388

389 buildUnnamed72() {

390 var o = new core.List<api.Feature>();

391 o.add(buildFeature());

392 o.add(buildFeature());

393 return o;

394 }

395

396 checkUnnamed72(core.List<api.Feature> o) {

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

398 checkFeature(o[0]);

399 checkFeature(o[1]);

400 }

401

402 core.int buildCounterFeaturesBatchInsertRequest = 0;

403 buildFeaturesBatchInsertRequest() {

404 var o = new api.FeaturesBatchInsertRequest();

405 buildCounterFeaturesBatchInsertRequest++;

406 if (buildCounterFeaturesBatchInsertRequest < 3) {

407 o.features = buildUnnamed72();

408 o.normalizeGeometries = true;

409 }

410 buildCounterFeaturesBatchInsertRequest--;

411 return o;

412 }

413

414 checkFeaturesBatchInsertRequest(api.FeaturesBatchInsertRequest o) {

415 buildCounterFeaturesBatchInsertRequest++;

416 if (buildCounterFeaturesBatchInsertRequest < 3) {

417 checkUnnamed72(o.features);

418 unittest.expect(o.normalizeGeometries, unittest.isTrue);

419 }

420 buildCounterFeaturesBatchInsertRequest--;

421 }

422

423 buildUnnamed73() {

424 var o = new core.List<api.Feature>();

425 o.add(buildFeature());

426 o.add(buildFeature());

427 return o;

428 }

429

430 checkUnnamed73(core.List<api.Feature> o) {

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

432 checkFeature(o[0]);

433 checkFeature(o[1]);

434 }

435

436 core.int buildCounterFeaturesBatchPatchRequest = 0;

437 buildFeaturesBatchPatchRequest() {

438 var o = new api.FeaturesBatchPatchRequest();

439 buildCounterFeaturesBatchPatchRequest++;

440 if (buildCounterFeaturesBatchPatchRequest < 3) {

441 o.features = buildUnnamed73();

442 o.normalizeGeometries = true;

443 }

444 buildCounterFeaturesBatchPatchRequest--;

445 return o;

446 }

447

448 checkFeaturesBatchPatchRequest(api.FeaturesBatchPatchRequest o) {

449 buildCounterFeaturesBatchPatchRequest++;

450 if (buildCounterFeaturesBatchPatchRequest < 3) {

451 checkUnnamed73(o.features);

452 unittest.expect(o.normalizeGeometries, unittest.isTrue);

453 }

454 buildCounterFeaturesBatchPatchRequest--;

455 }

456

457 buildUnnamed74() {

458 var o = new core.List<api.Feature>();

459 o.add(buildFeature());

460 o.add(buildFeature());

461 return o;

462 }

463

464 checkUnnamed74(core.List<api.Feature> o) {

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

466 checkFeature(o[0]);

467 checkFeature(o[1]);

468 }

469

470 core.int buildCounterFeaturesListResponse = 0;

471 buildFeaturesListResponse() {

472 var o = new api.FeaturesListResponse();

473 buildCounterFeaturesListResponse++;

474 if (buildCounterFeaturesListResponse < 3) {

475 o.allowedQueriesPerSecond = 42.0;

476 o.features = buildUnnamed74();

477 o.nextPageToken = "foo";

478 o.schema = buildSchema();

479 o.type = "foo";

480 }

481 buildCounterFeaturesListResponse--;

482 return o;

483 }

484

485 checkFeaturesListResponse(api.FeaturesListResponse o) {

486 buildCounterFeaturesListResponse++;

487 if (buildCounterFeaturesListResponse < 3) {

488 unittest.expect(o.allowedQueriesPerSecond, unittest.equals(42.0));

489 checkUnnamed74(o.features);

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

491 checkSchema(o.schema);

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

493 }

494 buildCounterFeaturesListResponse--;

495 }

496

497 core.int buildCounterFile = 0;

498 buildFile() {

499 var o = new api.File();

500 buildCounterFile++;

501 if (buildCounterFile < 3) {

502 o.filename = "foo";

503 o.size = "foo";

504 o.uploadStatus = "foo";

505 }

506 buildCounterFile--;

507 return o;

508 }

509

510 checkFile(api.File o) {

511 buildCounterFile++;

512 if (buildCounterFile < 3) {

513 unittest.expect(o.filename, unittest.equals('foo'));

514 unittest.expect(o.size, unittest.equals('foo'));

515 unittest.expect(o.uploadStatus, unittest.equals('foo'));

516 }

517 buildCounterFile--;

518 }

519

520 core.int buildCounterFilter = 0;

521 buildFilter() {

522 var o = new api.Filter();

523 buildCounterFilter++;

524 if (buildCounterFilter < 3) {

525 o.column = "foo";

526 o.operator = "foo";

527 o.value = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};

528 }

529 buildCounterFilter--;

530 return o;

531 }

532

533 checkFilter(api.Filter o) {

534 buildCounterFilter++;

535 if (buildCounterFilter < 3) {

536 unittest.expect(o.column, unittest.equals('foo'));

537 unittest.expect(o.operator, unittest.equals('foo'));

538 var casted1 = (o.value) as core.Map; unittest.expect(casted1, unittest.hasLe ngth(3)); unittest.expect(casted1["list"], unittest.equals([1, 2, 3])); unittest .expect(casted1["bool"], unittest.equals(true)); unittest.expect(casted1["string "], unittest.equals('foo'));

539 }

540 buildCounterFilter--;

541 }

542

543 buildGeoJsonGeometry() {

544 return buildGeoJsonGeometryCollection();

545 }

546

547 checkGeoJsonGeometry(api.GeoJsonGeometry o) {

548 checkGeoJsonGeometryCollection(api.GeoJsonGeometryCollection o) {

549 buildCounterGeoJsonGeometryCollection++;

550 if (buildCounterGeoJsonGeometryCollection < 3) {

551 checkUnnamed75(o.geometries);

552 }

553 buildCounterGeoJsonGeometryCollection--;

554 }

555

556 (o);

557 }

558

559 buildUnnamed75() {

560 var o = new core.List<api.GeoJsonGeometry>();

561 o.add(buildGeoJsonGeometry());

562 o.add(buildGeoJsonGeometry());

563 return o;

564 }

565

566 checkUnnamed75(core.List<api.GeoJsonGeometry> o) {

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

568 checkGeoJsonGeometry(o[0]);

569 checkGeoJsonGeometry(o[1]);

570 }

571

572 core.int buildCounterGeoJsonGeometryCollection = 0;

573 buildGeoJsonGeometryCollection() {

574 var o = new api.GeoJsonGeometryCollection();

575 buildCounterGeoJsonGeometryCollection++;

576 if (buildCounterGeoJsonGeometryCollection < 3) {

577 o.geometries = buildUnnamed75();

578 }

579 buildCounterGeoJsonGeometryCollection--;

580 return o;

581 }

582

583 checkGeoJsonGeometryCollection(api.GeoJsonGeometryCollection o) {

584 buildCounterGeoJsonGeometryCollection++;

585 if (buildCounterGeoJsonGeometryCollection < 3) {

586 checkUnnamed75(o.geometries);

587 }

588 buildCounterGeoJsonGeometryCollection--;

589 }

590

591 buildUnnamed76() {

592 var o = new core.List<api.GeoJsonPosition>();

593 o.add(buildGeoJsonPosition());

594 o.add(buildGeoJsonPosition());

595 return o;

596 }

597

598 checkUnnamed76(core.List<api.GeoJsonPosition> o) {

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

600 checkGeoJsonPosition(o[0]);

601 checkGeoJsonPosition(o[1]);

602 }

603

604 core.int buildCounterGeoJsonLineString = 0;

605 buildGeoJsonLineString() {

606 var o = new api.GeoJsonLineString();

607 buildCounterGeoJsonLineString++;

608 if (buildCounterGeoJsonLineString < 3) {

609 o.coordinates = buildUnnamed76();

610 }

611 buildCounterGeoJsonLineString--;

612 return o;

613 }

614

615 checkGeoJsonLineString(api.GeoJsonLineString o) {

616 buildCounterGeoJsonLineString++;

617 if (buildCounterGeoJsonLineString < 3) {

618 checkUnnamed76(o.coordinates);

619 }

620 buildCounterGeoJsonLineString--;

621 }

622

623 buildUnnamed77() {

624 var o = new core.List<api.GeoJsonPosition>();

625 o.add(buildGeoJsonPosition());

626 o.add(buildGeoJsonPosition());

627 return o;

628 }

629

630 checkUnnamed77(core.List<api.GeoJsonPosition> o) {

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

632 checkGeoJsonPosition(o[0]);

633 checkGeoJsonPosition(o[1]);

634 }

635

636 buildUnnamed78() {

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

638 o.add(buildUnnamed77());

639 o.add(buildUnnamed77());

640 return o;

641 }

642

643 checkUnnamed78(core.List<core.List<api.GeoJsonPosition>> o) {

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

645 checkUnnamed77(o[0]);

646 checkUnnamed77(o[1]);

647 }

648

649 core.int buildCounterGeoJsonMultiLineString = 0;

650 buildGeoJsonMultiLineString() {

651 var o = new api.GeoJsonMultiLineString();

652 buildCounterGeoJsonMultiLineString++;

653 if (buildCounterGeoJsonMultiLineString < 3) {

654 o.coordinates = buildUnnamed78();

655 }

656 buildCounterGeoJsonMultiLineString--;

657 return o;

658 }

659

660 checkGeoJsonMultiLineString(api.GeoJsonMultiLineString o) {

661 buildCounterGeoJsonMultiLineString++;

662 if (buildCounterGeoJsonMultiLineString < 3) {

663 checkUnnamed78(o.coordinates);

664 }

665 buildCounterGeoJsonMultiLineString--;

666 }

667

668 buildUnnamed79() {

669 var o = new core.List<api.GeoJsonPosition>();

670 o.add(buildGeoJsonPosition());

671 o.add(buildGeoJsonPosition());

672 return o;

673 }

674

675 checkUnnamed79(core.List<api.GeoJsonPosition> o) {

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

677 checkGeoJsonPosition(o[0]);

678 checkGeoJsonPosition(o[1]);

679 }

680

681 core.int buildCounterGeoJsonMultiPoint = 0;

682 buildGeoJsonMultiPoint() {

683 var o = new api.GeoJsonMultiPoint();

684 buildCounterGeoJsonMultiPoint++;

685 if (buildCounterGeoJsonMultiPoint < 3) {

686 o.coordinates = buildUnnamed79();

687 }

688 buildCounterGeoJsonMultiPoint--;

689 return o;

690 }

691

692 checkGeoJsonMultiPoint(api.GeoJsonMultiPoint o) {

693 buildCounterGeoJsonMultiPoint++;

694 if (buildCounterGeoJsonMultiPoint < 3) {

695 checkUnnamed79(o.coordinates);

696 }

697 buildCounterGeoJsonMultiPoint--;

698 }

699

700 buildUnnamed80() {

701 var o = new core.List<api.GeoJsonPosition>();

702 o.add(buildGeoJsonPosition());

703 o.add(buildGeoJsonPosition());

704 return o;

705 }

706

707 checkUnnamed80(core.List<api.GeoJsonPosition> o) {

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

709 checkGeoJsonPosition(o[0]);

710 checkGeoJsonPosition(o[1]);

711 }

712

713 buildUnnamed81() {

714 var o = new core.List<core.List<api.GeoJsonPosition>>();

715 o.add(buildUnnamed80());

716 o.add(buildUnnamed80());

717 return o;

718 }

719

720 checkUnnamed81(core.List<core.List<api.GeoJsonPosition>> o) {

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

722 checkUnnamed80(o[0]);

723 checkUnnamed80(o[1]);

724 }

725

726 buildUnnamed82() {

727 var o = new core.List<core.List<core.List<api.GeoJsonPosition>>>();

728 o.add(buildUnnamed81());

729 o.add(buildUnnamed81());

730 return o;

731 }

732

733 checkUnnamed82(core.List<core.List<core.List<api.GeoJsonPosition>>> o) {

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

735 checkUnnamed81(o[0]);

736 checkUnnamed81(o[1]);

737 }

738

739 core.int buildCounterGeoJsonMultiPolygon = 0;

740 buildGeoJsonMultiPolygon() {

741 var o = new api.GeoJsonMultiPolygon();

742 buildCounterGeoJsonMultiPolygon++;

743 if (buildCounterGeoJsonMultiPolygon < 3) {

744 o.coordinates = buildUnnamed82();

745 }

746 buildCounterGeoJsonMultiPolygon--;

747 return o;

748 }

749

750 checkGeoJsonMultiPolygon(api.GeoJsonMultiPolygon o) {

751 buildCounterGeoJsonMultiPolygon++;

752 if (buildCounterGeoJsonMultiPolygon < 3) {

753 checkUnnamed82(o.coordinates);

754 }

755 buildCounterGeoJsonMultiPolygon--;

756 }

757

758 core.int buildCounterGeoJsonPoint = 0;

759 buildGeoJsonPoint() {

760 var o = new api.GeoJsonPoint();

761 buildCounterGeoJsonPoint++;

762 if (buildCounterGeoJsonPoint < 3) {

763 o.coordinates = buildGeoJsonPosition();

764 }

765 buildCounterGeoJsonPoint--;

766 return o;

767 }

768

769 checkGeoJsonPoint(api.GeoJsonPoint o) {

770 buildCounterGeoJsonPoint++;

771 if (buildCounterGeoJsonPoint < 3) {

772 checkGeoJsonPosition(o.coordinates);

773 }

774 buildCounterGeoJsonPoint--;

775 }

776

777 buildUnnamed83() {

778 var o = new core.List<api.GeoJsonPosition>();

779 o.add(buildGeoJsonPosition());

780 o.add(buildGeoJsonPosition());

781 return o;

782 }

783

784 checkUnnamed83(core.List<api.GeoJsonPosition> o) {

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

786 checkGeoJsonPosition(o[0]);

787 checkGeoJsonPosition(o[1]);

788 }

789

790 buildUnnamed84() {

791 var o = new core.List<core.List<api.GeoJsonPosition>>();

792 o.add(buildUnnamed83());

793 o.add(buildUnnamed83());

794 return o;

795 }

796

797 checkUnnamed84(core.List<core.List<api.GeoJsonPosition>> o) {

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

799 checkUnnamed83(o[0]);

800 checkUnnamed83(o[1]);

801 }

802

803 core.int buildCounterGeoJsonPolygon = 0;

804 buildGeoJsonPolygon() {

805 var o = new api.GeoJsonPolygon();

806 buildCounterGeoJsonPolygon++;

807 if (buildCounterGeoJsonPolygon < 3) {

808 o.coordinates = buildUnnamed84();

809 }

810 buildCounterGeoJsonPolygon--;

811 return o;

812 }

813

814 checkGeoJsonPolygon(api.GeoJsonPolygon o) {

815 buildCounterGeoJsonPolygon++;

816 if (buildCounterGeoJsonPolygon < 3) {

817 checkUnnamed84(o.coordinates);

818 }

819 buildCounterGeoJsonPolygon--;

820 }

821

822 buildGeoJsonPosition() {

823 var o = new api.GeoJsonPosition();

824 o.add(42.0);

825 o.add(42.0);

826 return o;

827 }

828

829 checkGeoJsonPosition(api.GeoJsonPosition o) {

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

831 unittest.expect(o[0], unittest.equals(42.0));

832 unittest.expect(o[1], unittest.equals(42.0));

833 }

834

835 buildGeoJsonProperties() {

836 var o = new api.GeoJsonProperties();

837 o["a"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};

838 o["b"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};

839 return o;

840 }

841

842 checkGeoJsonProperties(api.GeoJsonProperties o) {

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

844 var casted2 = (o["a"]) as core.Map; unittest.expect(casted2, unittest.hasLengt h(3)); unittest.expect(casted2["list"], unittest.equals([1, 2, 3])); unittest.ex pect(casted2["bool"], unittest.equals(true)); unittest.expect(casted2["string"], unittest.equals('foo'));

845 var casted3 = (o["b"]) as core.Map; unittest.expect(casted3, unittest.hasLengt h(3)); unittest.expect(casted3["list"], unittest.equals([1, 2, 3])); unittest.ex pect(casted3["bool"], unittest.equals(true)); unittest.expect(casted3["string"], unittest.equals('foo'));

846 }

847

848 core.int buildCounterIcon = 0;

849 buildIcon() {

850 var o = new api.Icon();

851 buildCounterIcon++;

852 if (buildCounterIcon < 3) {

853 o.description = "foo";

854 o.id = "foo";

855 o.name = "foo";

856 }

857 buildCounterIcon--;

858 return o;

859 }

860

861 checkIcon(api.Icon o) {

862 buildCounterIcon++;

863 if (buildCounterIcon < 3) {

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

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

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

867 }

868 buildCounterIcon--;

869 }

870

871 core.int buildCounterIconStyle = 0;

872 buildIconStyle() {

873 var o = new api.IconStyle();

874 buildCounterIconStyle++;

875 if (buildCounterIconStyle < 3) {

876 o.id = "foo";

877 o.name = "foo";

878 o.scaledShape = buildScaledShape();

879 o.scalingFunction = buildScalingFunction();

880 }

881 buildCounterIconStyle--;

882 return o;

883 }

884

885 checkIconStyle(api.IconStyle o) {

886 buildCounterIconStyle++;

887 if (buildCounterIconStyle < 3) {

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

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

890 checkScaledShape(o.scaledShape);

891 checkScalingFunction(o.scalingFunction);

892 }

893 buildCounterIconStyle--;

894 }

895

896 buildUnnamed85() {

897 var o = new core.List<api.Icon>();

898 o.add(buildIcon());

899 o.add(buildIcon());

900 return o;

901 }

902

903 checkUnnamed85(core.List<api.Icon> o) {

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

905 checkIcon(o[0]);

906 checkIcon(o[1]);

907 }

908

909 core.int buildCounterIconsListResponse = 0;

910 buildIconsListResponse() {

911 var o = new api.IconsListResponse();

912 buildCounterIconsListResponse++;

913 if (buildCounterIconsListResponse < 3) {

914 o.icons = buildUnnamed85();

915 o.nextPageToken = "foo";

916 }

917 buildCounterIconsListResponse--;

918 return o;

919 }

920

921 checkIconsListResponse(api.IconsListResponse o) {

922 buildCounterIconsListResponse++;

923 if (buildCounterIconsListResponse < 3) {

924 checkUnnamed85(o.icons);

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

926 }

927 buildCounterIconsListResponse--;

928 }

929

930 core.int buildCounterLabelStyle = 0;

931 buildLabelStyle() {

932 var o = new api.LabelStyle();

933 buildCounterLabelStyle++;

934 if (buildCounterLabelStyle < 3) {

935 o.color = "foo";

936 o.column = "foo";

937 o.fontStyle = "foo";

938 o.fontWeight = "foo";

939 o.opacity = 42.0;

940 o.outline = buildColor();

941 o.size = 42.0;

942 }

943 buildCounterLabelStyle--;

944 return o;

945 }

946

947 checkLabelStyle(api.LabelStyle o) {

948 buildCounterLabelStyle++;

949 if (buildCounterLabelStyle < 3) {

950 unittest.expect(o.color, unittest.equals('foo'));

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

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

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

954 unittest.expect(o.opacity, unittest.equals(42.0));

955 checkColor(o.outline);

956 unittest.expect(o.size, unittest.equals(42.0));

957 }

958 buildCounterLabelStyle--;

959 }

960

961 buildLatLngBox() {

962 var o = new api.LatLngBox();

963 o.add(42.0);

964 o.add(42.0);

965 return o;

966 }

967

968 checkLatLngBox(api.LatLngBox o) {

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

970 unittest.expect(o[0], unittest.equals(42.0));

971 unittest.expect(o[1], unittest.equals(42.0));

972 }

973

974 buildUnnamed86() {

975 var o = new core.List<core.double>();

976 o.add(42.0);

977 o.add(42.0);

978 return o;

979 }

980

981 checkUnnamed86(core.List<core.double> o) {

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

983 unittest.expect(o[0], unittest.equals(42.0));

984 unittest.expect(o[1], unittest.equals(42.0));

985 }

986

987 core.int buildCounterLayer = 0;

988 buildLayer() {

989 var o = new api.Layer();

990 buildCounterLayer++;

991 if (buildCounterLayer < 3) {

992 o.bbox = buildUnnamed86();

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

994 o.creatorEmail = "foo";

995 o.datasourceType = "foo";

996 o.datasources = buildDatasources();

997 o.description = "foo";

998 o.draftAccessList = "foo";

999 o.etag = "foo";

1000 o.id = "foo";

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

1002 o.lastModifierEmail = "foo";

1003 o.layerType = "foo";

1004 o.name = "foo";

1005 o.processingStatus = "foo";

1006 o.projectId = "foo";

1007 o.publishedAccessList = "foo";

1008 o.publishingStatus = "foo";

1009 o.style = buildVectorStyle();

1010 o.tags = buildTags();

1011 o.writersCanEditPermissions = true;

1012 }

1013 buildCounterLayer--;

1014 return o;

1015 }

1016

1017 checkLayer(api.Layer o) {

1018 buildCounterLayer++;

1019 if (buildCounterLayer < 3) {

1020 checkUnnamed86(o.bbox);

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

1022 unittest.expect(o.creatorEmail, unittest.equals('foo'));

1023 unittest.expect(o.datasourceType, unittest.equals('foo'));

1024 checkDatasources(o.datasources);

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

1026 unittest.expect(o.draftAccessList, unittest.equals('foo'));

1027 unittest.expect(o.etag, unittest.equals('foo'));

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

1029 unittest.expect(o.lastModifiedTime, unittest.equals(core.DateTime.parse("200 2-02-27T14:01:02")));

1030 unittest.expect(o.lastModifierEmail, unittest.equals('foo'));

1031 unittest.expect(o.layerType, unittest.equals('foo'));

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

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

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

1035 unittest.expect(o.publishedAccessList, unittest.equals('foo'));

1036 unittest.expect(o.publishingStatus, unittest.equals('foo'));

1037 checkVectorStyle(o.style);

1038 checkTags(o.tags);

1039 unittest.expect(o.writersCanEditPermissions, unittest.isTrue);

1040 }

1041 buildCounterLayer--;

1042 }

1043

1044 buildUnnamed87() {

1045 var o = new core.List<api.Layer>();

1046 o.add(buildLayer());

1047 o.add(buildLayer());

1048 return o;

1049 }

1050

1051 checkUnnamed87(core.List<api.Layer> o) {

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

1053 checkLayer(o[0]);

1054 checkLayer(o[1]);

1055 }

1056

1057 core.int buildCounterLayersListResponse = 0;

1058 buildLayersListResponse() {

1059 var o = new api.LayersListResponse();

1060 buildCounterLayersListResponse++;

1061 if (buildCounterLayersListResponse < 3) {

1062 o.layers = buildUnnamed87();

1063 o.nextPageToken = "foo";

1064 }

1065 buildCounterLayersListResponse--;

1066 return o;

1067 }

1068

1069 checkLayersListResponse(api.LayersListResponse o) {

1070 buildCounterLayersListResponse++;

1071 if (buildCounterLayersListResponse < 3) {

1072 checkUnnamed87(o.layers);

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

1074 }

1075 buildCounterLayersListResponse--;

1076 }

1077

1078 buildUnnamed88() {

1079 var o = new core.List<core.double>();

1080 o.add(42.0);

1081 o.add(42.0);

1082 return o;

1083 }

1084

1085 checkUnnamed88(core.List<core.double> o) {

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

1087 unittest.expect(o[0], unittest.equals(42.0));

1088 unittest.expect(o[1], unittest.equals(42.0));

1089 }

1090

1091 core.int buildCounterLineStyleStroke = 0;

1092 buildLineStyleStroke() {

1093 var o = new api.LineStyleStroke();

1094 buildCounterLineStyleStroke++;

1095 if (buildCounterLineStyleStroke < 3) {

1096 o.color = "foo";

1097 o.opacity = 42.0;

1098 o.width = 42.0;

1099 }

1100 buildCounterLineStyleStroke--;

1101 return o;

1102 }

1103

1104 checkLineStyleStroke(api.LineStyleStroke o) {

1105 buildCounterLineStyleStroke++;

1106 if (buildCounterLineStyleStroke < 3) {

1107 unittest.expect(o.color, unittest.equals('foo'));

1108 unittest.expect(o.opacity, unittest.equals(42.0));

1109 unittest.expect(o.width, unittest.equals(42.0));

1110 }

1111 buildCounterLineStyleStroke--;

1112 }

1113

1114 core.int buildCounterLineStyle = 0;

1115 buildLineStyle() {

1116 var o = new api.LineStyle();

1117 buildCounterLineStyle++;

1118 if (buildCounterLineStyle < 3) {

1119 o.border = buildBorder();

1120 o.dash = buildUnnamed88();

1121 o.label = buildLabelStyle();

1122 o.stroke = buildLineStyleStroke();

1123 }

1124 buildCounterLineStyle--;

1125 return o;

1126 }

1127

1128 checkLineStyle(api.LineStyle o) {

1129 buildCounterLineStyle++;

1130 if (buildCounterLineStyle < 3) {

1131 checkBorder(o.border);

1132 checkUnnamed88(o.dash);

1133 checkLabelStyle(o.label);

1134 checkLineStyleStroke(o.stroke);

1135 }

1136 buildCounterLineStyle--;

1137 }

1138

1139 buildUnnamed89() {

1140 var o = new core.List<core.double>();

1141 o.add(42.0);

1142 o.add(42.0);

1143 return o;

1144 }

1145

1146 checkUnnamed89(core.List<core.double> o) {

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

1148 unittest.expect(o[0], unittest.equals(42.0));

1149 unittest.expect(o[1], unittest.equals(42.0));

1150 }

1151

1152 buildUnnamed90() {

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

1154 o.add("foo");

1155 o.add("foo");

1156 return o;

1157 }

1158

1159 checkUnnamed90(core.List<core.String> o) {

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

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

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

1163 }

1164

1165 core.int buildCounterMap = 0;

1166 buildMap() {

1167 var o = new api.Map();

1168 buildCounterMap++;

1169 if (buildCounterMap < 3) {

1170 o.bbox = buildUnnamed89();

1171 o.contents = buildMapContents();

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

1173 o.creatorEmail = "foo";

1174 o.defaultViewport = buildLatLngBox();

1175 o.description = "foo";

1176 o.draftAccessList = "foo";

1177 o.etag = "foo";

1178 o.id = "foo";

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

1180 o.lastModifierEmail = "foo";

1181 o.name = "foo";

1182 o.processingStatus = "foo";

1183 o.projectId = "foo";

1184 o.publishedAccessList = "foo";

1185 o.publishingStatus = "foo";

1186 o.tags = buildTags();

1187 o.versions = buildUnnamed90();

1188 o.writersCanEditPermissions = true;

1189 }

1190 buildCounterMap--;

1191 return o;

1192 }

1193

1194 checkMap(api.Map o) {

1195 buildCounterMap++;

1196 if (buildCounterMap < 3) {

1197 checkUnnamed89(o.bbox);

1198 checkMapContents(o.contents);

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

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

1201 checkLatLngBox(o.defaultViewport);

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

1203 unittest.expect(o.draftAccessList, unittest.equals('foo'));

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

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

1206 unittest.expect(o.lastModifiedTime, unittest.equals(core.DateTime.parse("200 2-02-27T14:01:02")));

1207 unittest.expect(o.lastModifierEmail, unittest.equals('foo'));

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

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

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

1211 unittest.expect(o.publishedAccessList, unittest.equals('foo'));

1212 unittest.expect(o.publishingStatus, unittest.equals('foo'));

1213 checkTags(o.tags);

1214 checkUnnamed90(o.versions);

1215 unittest.expect(o.writersCanEditPermissions, unittest.isTrue);

1216 }

1217 buildCounterMap--;

1218 }

1219

1220 buildMapContents() {

1221 var o = new api.MapContents();

1222 o.add(buildMapItem());

1223 o.add(buildMapItem());

1224 return o;

1225 }

1226

1227 checkMapContents(api.MapContents o) {

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

1229 checkMapItem(o[0]);

1230 checkMapItem(o[1]);

1231 }

1232

1233 buildUnnamed91() {

1234 var o = new core.List<api.MapItem>();

1235 o.add(buildMapItem());

1236 o.add(buildMapItem());

1237 return o;

1238 }

1239

1240 checkUnnamed91(core.List<api.MapItem> o) {

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

1242 checkMapItem(o[0]);

1243 checkMapItem(o[1]);

1244 }

1245

1246 buildUnnamed92() {

1247 var o = new core.List<core.double>();

1248 o.add(42.0);

1249 o.add(42.0);

1250 return o;

1251 }

1252

1253 checkUnnamed92(core.List<core.double> o) {

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

1255 unittest.expect(o[0], unittest.equals(42.0));

1256 unittest.expect(o[1], unittest.equals(42.0));

1257 }

1258

1259 core.int buildCounterMapFolder = 0;

1260 buildMapFolder() {

1261 var o = new api.MapFolder();

1262 buildCounterMapFolder++;

1263 if (buildCounterMapFolder < 3) {

1264 o.contents = buildUnnamed91();

1265 o.defaultViewport = buildUnnamed92();

1266 o.expandable = true;

1267 o.key = "foo";

1268 o.name = "foo";

1269 o.visibility = "foo";

1270 }

1271 buildCounterMapFolder--;

1272 return o;

1273 }

1274

1275 checkMapFolder(api.MapFolder o) {

1276 buildCounterMapFolder++;

1277 if (buildCounterMapFolder < 3) {

1278 checkUnnamed91(o.contents);

1279 checkUnnamed92(o.defaultViewport);

1280 unittest.expect(o.expandable, unittest.isTrue);

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

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

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

1284 }

1285 buildCounterMapFolder--;

1286 }

1287

1288 buildMapItem() {

1289 return buildMapFolder();

1290 }

1291

1292 checkMapItem(api.MapItem o) {

1293 checkMapFolder(api.MapFolder o) {

1294 buildCounterMapFolder++;

1295 if (buildCounterMapFolder < 3) {

1296 checkUnnamed91(o.contents);

1297 checkUnnamed92(o.defaultViewport);

1298 unittest.expect(o.expandable, unittest.isTrue);

1299 unittest.expect(o.key, unittest.equals('foo'));

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

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

1302 }

1303 buildCounterMapFolder--;

1304 }

1305

1306 (o);

1307 }

1308

1309 buildUnnamed93() {

1310 var o = new core.List<core.double>();

1311 o.add(42.0);

1312 o.add(42.0);

1313 return o;

1314 }

1315

1316 checkUnnamed93(core.List<core.double> o) {

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

1318 unittest.expect(o[0], unittest.equals(42.0));

1319 unittest.expect(o[1], unittest.equals(42.0));

1320 }

1321

1322 core.int buildCounterMapKmlLink = 0;

1323 buildMapKmlLink() {

1324 var o = new api.MapKmlLink();

1325 buildCounterMapKmlLink++;

1326 if (buildCounterMapKmlLink < 3) {

1327 o.defaultViewport = buildUnnamed93();

1328 o.kmlUrl = "foo";

1329 o.name = "foo";

1330 o.visibility = "foo";

1331 }

1332 buildCounterMapKmlLink--;

1333 return o;

1334 }

1335

1336 checkMapKmlLink(api.MapKmlLink o) {

1337 buildCounterMapKmlLink++;

1338 if (buildCounterMapKmlLink < 3) {

1339 checkUnnamed93(o.defaultViewport);

1340 unittest.expect(o.kmlUrl, unittest.equals('foo'));

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

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

1343 }

1344 buildCounterMapKmlLink--;

1345 }

1346

1347 buildUnnamed94() {

1348 var o = new core.List<core.double>();

1349 o.add(42.0);

1350 o.add(42.0);

1351 return o;

1352 }

1353

1354 checkUnnamed94(core.List<core.double> o) {

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

1356 unittest.expect(o[0], unittest.equals(42.0));

1357 unittest.expect(o[1], unittest.equals(42.0));

1358 }

1359

1360 core.int buildCounterMapLayer = 0;

1361 buildMapLayer() {

1362 var o = new api.MapLayer();

1363 buildCounterMapLayer++;

1364 if (buildCounterMapLayer < 3) {

1365 o.defaultViewport = buildUnnamed94();

1366 o.id = "foo";

1367 o.key = "foo";

1368 o.name = "foo";

1369 o.visibility = "foo";

1370 }

1371 buildCounterMapLayer--;

1372 return o;

1373 }

1374

1375 checkMapLayer(api.MapLayer o) {

1376 buildCounterMapLayer++;

1377 if (buildCounterMapLayer < 3) {

1378 checkUnnamed94(o.defaultViewport);

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

1380 unittest.expect(o.key, unittest.equals('foo'));

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

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

1383 }

1384 buildCounterMapLayer--;

1385 }

1386

1387 buildUnnamed95() {

1388 var o = new core.List<api.Map>();

1389 o.add(buildMap());

1390 o.add(buildMap());

1391 return o;

1392 }

1393

1394 checkUnnamed95(core.List<api.Map> o) {

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

1396 checkMap(o[0]);

1397 checkMap(o[1]);

1398 }

1399

1400 core.int buildCounterMapsListResponse = 0;

1401 buildMapsListResponse() {

1402 var o = new api.MapsListResponse();

1403 buildCounterMapsListResponse++;

1404 if (buildCounterMapsListResponse < 3) {

1405 o.maps = buildUnnamed95();

1406 o.nextPageToken = "foo";

1407 }

1408 buildCounterMapsListResponse--;

1409 return o;

1410 }

1411

1412 checkMapsListResponse(api.MapsListResponse o) {

1413 buildCounterMapsListResponse++;

1414 if (buildCounterMapsListResponse < 3) {

1415 checkUnnamed95(o.maps);

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

1417 }

1418 buildCounterMapsListResponse--;

1419 }

1420

1421 core.int buildCounterParent = 0;

1422 buildParent() {

1423 var o = new api.Parent();

1424 buildCounterParent++;

1425 if (buildCounterParent < 3) {

1426 o.id = "foo";

1427 }

1428 buildCounterParent--;

1429 return o;

1430 }

1431

1432 checkParent(api.Parent o) {

1433 buildCounterParent++;

1434 if (buildCounterParent < 3) {

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

1436 }

1437 buildCounterParent--;

1438 }

1439

1440 buildUnnamed96() {

1441 var o = new core.List<api.Parent>();

1442 o.add(buildParent());

1443 o.add(buildParent());

1444 return o;

1445 }

1446

1447 checkUnnamed96(core.List<api.Parent> o) {

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

1449 checkParent(o[0]);

1450 checkParent(o[1]);

1451 }

1452

1453 core.int buildCounterParentsListResponse = 0;

1454 buildParentsListResponse() {

1455 var o = new api.ParentsListResponse();

1456 buildCounterParentsListResponse++;

1457 if (buildCounterParentsListResponse < 3) {

1458 o.nextPageToken = "foo";

1459 o.parents = buildUnnamed96();

1460 }

1461 buildCounterParentsListResponse--;

1462 return o;

1463 }

1464

1465 checkParentsListResponse(api.ParentsListResponse o) {

1466 buildCounterParentsListResponse++;

1467 if (buildCounterParentsListResponse < 3) {

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

1469 checkUnnamed96(o.parents);

1470 }

1471 buildCounterParentsListResponse--;

1472 }

1473

1474 core.int buildCounterPermission = 0;

1475 buildPermission() {

1476 var o = new api.Permission();

1477 buildCounterPermission++;

1478 if (buildCounterPermission < 3) {

1479 o.discoverable = true;

1480 o.id = "foo";

1481 o.role = "foo";

1482 o.type = "foo";

1483 }

1484 buildCounterPermission--;

1485 return o;

1486 }

1487

1488 checkPermission(api.Permission o) {

1489 buildCounterPermission++;

1490 if (buildCounterPermission < 3) {

1491 unittest.expect(o.discoverable, unittest.isTrue);

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

1493 unittest.expect(o.role, unittest.equals('foo'));

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

1495 }

1496 buildCounterPermission--;

1497 }

1498

1499 buildUnnamed97() {

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

1501 o.add("foo");

1502 o.add("foo");

1503 return o;

1504 }

1505

1506 checkUnnamed97(core.List<core.String> o) {

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

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

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

1510 }

1511

1512 core.int buildCounterPermissionsBatchDeleteRequest = 0;

1513 buildPermissionsBatchDeleteRequest() {

1514 var o = new api.PermissionsBatchDeleteRequest();

1515 buildCounterPermissionsBatchDeleteRequest++;

1516 if (buildCounterPermissionsBatchDeleteRequest < 3) {

1517 o.ids = buildUnnamed97();

1518 }

1519 buildCounterPermissionsBatchDeleteRequest--;

1520 return o;

1521 }

1522

1523 checkPermissionsBatchDeleteRequest(api.PermissionsBatchDeleteRequest o) {

1524 buildCounterPermissionsBatchDeleteRequest++;

1525 if (buildCounterPermissionsBatchDeleteRequest < 3) {

1526 checkUnnamed97(o.ids);

1527 }

1528 buildCounterPermissionsBatchDeleteRequest--;

1529 }

1530

1531 core.int buildCounterPermissionsBatchDeleteResponse = 0;

1532 buildPermissionsBatchDeleteResponse() {

1533 var o = new api.PermissionsBatchDeleteResponse();

1534 buildCounterPermissionsBatchDeleteResponse++;

1535 if (buildCounterPermissionsBatchDeleteResponse < 3) {

1536 }

1537 buildCounterPermissionsBatchDeleteResponse--;

1538 return o;

1539 }

1540

1541 checkPermissionsBatchDeleteResponse(api.PermissionsBatchDeleteResponse o) {

1542 buildCounterPermissionsBatchDeleteResponse++;

1543 if (buildCounterPermissionsBatchDeleteResponse < 3) {

1544 }

1545 buildCounterPermissionsBatchDeleteResponse--;

1546 }

1547

1548 buildUnnamed98() {

1549 var o = new core.List<api.Permission>();

1550 o.add(buildPermission());

1551 o.add(buildPermission());

1552 return o;

1553 }

1554

1555 checkUnnamed98(core.List<api.Permission> o) {

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

1557 checkPermission(o[0]);

1558 checkPermission(o[1]);

1559 }

1560

1561 core.int buildCounterPermissionsBatchUpdateRequest = 0;

1562 buildPermissionsBatchUpdateRequest() {

1563 var o = new api.PermissionsBatchUpdateRequest();

1564 buildCounterPermissionsBatchUpdateRequest++;

1565 if (buildCounterPermissionsBatchUpdateRequest < 3) {

1566 o.permissions = buildUnnamed98();

1567 }

1568 buildCounterPermissionsBatchUpdateRequest--;

1569 return o;

1570 }

1571

1572 checkPermissionsBatchUpdateRequest(api.PermissionsBatchUpdateRequest o) {

1573 buildCounterPermissionsBatchUpdateRequest++;

1574 if (buildCounterPermissionsBatchUpdateRequest < 3) {

1575 checkUnnamed98(o.permissions);

1576 }

1577 buildCounterPermissionsBatchUpdateRequest--;

1578 }

1579

1580 core.int buildCounterPermissionsBatchUpdateResponse = 0;

1581 buildPermissionsBatchUpdateResponse() {

1582 var o = new api.PermissionsBatchUpdateResponse();

1583 buildCounterPermissionsBatchUpdateResponse++;

1584 if (buildCounterPermissionsBatchUpdateResponse < 3) {

1585 }

1586 buildCounterPermissionsBatchUpdateResponse--;

1587 return o;

1588 }

1589

1590 checkPermissionsBatchUpdateResponse(api.PermissionsBatchUpdateResponse o) {

1591 buildCounterPermissionsBatchUpdateResponse++;

1592 if (buildCounterPermissionsBatchUpdateResponse < 3) {

1593 }

1594 buildCounterPermissionsBatchUpdateResponse--;

1595 }

1596

1597 buildUnnamed99() {

1598 var o = new core.List<api.Permission>();

1599 o.add(buildPermission());

1600 o.add(buildPermission());

1601 return o;

1602 }

1603

1604 checkUnnamed99(core.List<api.Permission> o) {

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

1606 checkPermission(o[0]);

1607 checkPermission(o[1]);

1608 }

1609

1610 core.int buildCounterPermissionsListResponse = 0;

1611 buildPermissionsListResponse() {

1612 var o = new api.PermissionsListResponse();

1613 buildCounterPermissionsListResponse++;

1614 if (buildCounterPermissionsListResponse < 3) {

1615 o.permissions = buildUnnamed99();

1616 }

1617 buildCounterPermissionsListResponse--;

1618 return o;

1619 }

1620

1621 checkPermissionsListResponse(api.PermissionsListResponse o) {

1622 buildCounterPermissionsListResponse++;

1623 if (buildCounterPermissionsListResponse < 3) {

1624 checkUnnamed99(o.permissions);

1625 }

1626 buildCounterPermissionsListResponse--;

1627 }

1628

1629 core.int buildCounterPointStyle = 0;

1630 buildPointStyle() {

1631 var o = new api.PointStyle();

1632 buildCounterPointStyle++;

1633 if (buildCounterPointStyle < 3) {

1634 o.icon = buildIconStyle();

1635 o.label = buildLabelStyle();

1636 }

1637 buildCounterPointStyle--;

1638 return o;

1639 }

1640

1641 checkPointStyle(api.PointStyle o) {

1642 buildCounterPointStyle++;

1643 if (buildCounterPointStyle < 3) {

1644 checkIconStyle(o.icon);

1645 checkLabelStyle(o.label);

1646 }

1647 buildCounterPointStyle--;

1648 }

1649

1650 core.int buildCounterPolygonStyle = 0;

1651 buildPolygonStyle() {

1652 var o = new api.PolygonStyle();

1653 buildCounterPolygonStyle++;

1654 if (buildCounterPolygonStyle < 3) {

1655 o.fill = buildColor();

1656 o.label = buildLabelStyle();

1657 o.stroke = buildBorder();

1658 }

1659 buildCounterPolygonStyle--;

1660 return o;

1661 }

1662

1663 checkPolygonStyle(api.PolygonStyle o) {

1664 buildCounterPolygonStyle++;

1665 if (buildCounterPolygonStyle < 3) {

1666 checkColor(o.fill);

1667 checkLabelStyle(o.label);

1668 checkBorder(o.stroke);

1669 }

1670 buildCounterPolygonStyle--;

1671 }

1672

1673 core.int buildCounterProcessResponse = 0;

1674 buildProcessResponse() {

1675 var o = new api.ProcessResponse();

1676 buildCounterProcessResponse++;

1677 if (buildCounterProcessResponse < 3) {

1678 }

1679 buildCounterProcessResponse--;

1680 return o;

1681 }

1682

1683 checkProcessResponse(api.ProcessResponse o) {

1684 buildCounterProcessResponse++;

1685 if (buildCounterProcessResponse < 3) {

1686 }

1687 buildCounterProcessResponse--;

1688 }

1689

1690 core.int buildCounterProject = 0;

1691 buildProject() {

1692 var o = new api.Project();

1693 buildCounterProject++;

1694 if (buildCounterProject < 3) {

1695 o.id = "foo";

1696 o.name = "foo";

1697 }

1698 buildCounterProject--;

1699 return o;

1700 }

1701

1702 checkProject(api.Project o) {

1703 buildCounterProject++;

1704 if (buildCounterProject < 3) {

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

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

1707 }

1708 buildCounterProject--;

1709 }

1710

1711 buildUnnamed100() {

1712 var o = new core.List<api.Project>();

1713 o.add(buildProject());

1714 o.add(buildProject());

1715 return o;

1716 }

1717

1718 checkUnnamed100(core.List<api.Project> o) {

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

1720 checkProject(o[0]);

1721 checkProject(o[1]);

1722 }

1723

1724 core.int buildCounterProjectsListResponse = 0;

1725 buildProjectsListResponse() {

1726 var o = new api.ProjectsListResponse();

1727 buildCounterProjectsListResponse++;

1728 if (buildCounterProjectsListResponse < 3) {

1729 o.projects = buildUnnamed100();

1730 }

1731 buildCounterProjectsListResponse--;

1732 return o;

1733 }

1734

1735 checkProjectsListResponse(api.ProjectsListResponse o) {

1736 buildCounterProjectsListResponse++;

1737 if (buildCounterProjectsListResponse < 3) {

1738 checkUnnamed100(o.projects);

1739 }

1740 buildCounterProjectsListResponse--;

1741 }

1742

1743 core.int buildCounterPublishResponse = 0;

1744 buildPublishResponse() {

1745 var o = new api.PublishResponse();

1746 buildCounterPublishResponse++;

1747 if (buildCounterPublishResponse < 3) {

1748 }

1749 buildCounterPublishResponse--;

1750 return o;

1751 }

1752

1753 checkPublishResponse(api.PublishResponse o) {

1754 buildCounterPublishResponse++;

1755 if (buildCounterPublishResponse < 3) {

1756 }

1757 buildCounterPublishResponse--;

1758 }

1759

1760 core.int buildCounterPublishedLayer = 0;

1761 buildPublishedLayer() {

1762 var o = new api.PublishedLayer();

1763 buildCounterPublishedLayer++;

1764 if (buildCounterPublishedLayer < 3) {

1765 o.description = "foo";

1766 o.id = "foo";

1767 o.layerType = "foo";

1768 o.name = "foo";

1769 o.projectId = "foo";

1770 }

1771 buildCounterPublishedLayer--;

1772 return o;

1773 }

1774

1775 checkPublishedLayer(api.PublishedLayer o) {

1776 buildCounterPublishedLayer++;

1777 if (buildCounterPublishedLayer < 3) {

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

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

1780 unittest.expect(o.layerType, unittest.equals('foo'));

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

1782 unittest.expect(o.projectId, unittest.equals('foo'));

1783 }

1784 buildCounterPublishedLayer--;

1785 }

1786

1787 buildUnnamed101() {

1788 var o = new core.List<api.PublishedLayer>();

1789 o.add(buildPublishedLayer());

1790 o.add(buildPublishedLayer());

1791 return o;

1792 }

1793

1794 checkUnnamed101(core.List<api.PublishedLayer> o) {

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

1796 checkPublishedLayer(o[0]);

1797 checkPublishedLayer(o[1]);

1798 }

1799

1800 core.int buildCounterPublishedLayersListResponse = 0;

1801 buildPublishedLayersListResponse() {

1802 var o = new api.PublishedLayersListResponse();

1803 buildCounterPublishedLayersListResponse++;

1804 if (buildCounterPublishedLayersListResponse < 3) {

1805 o.layers = buildUnnamed101();

1806 o.nextPageToken = "foo";

1807 }

1808 buildCounterPublishedLayersListResponse--;

1809 return o;

1810 }

1811

1812 checkPublishedLayersListResponse(api.PublishedLayersListResponse o) {

1813 buildCounterPublishedLayersListResponse++;

1814 if (buildCounterPublishedLayersListResponse < 3) {

1815 checkUnnamed101(o.layers);

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

1817 }

1818 buildCounterPublishedLayersListResponse--;

1819 }

1820

1821 core.int buildCounterPublishedMap = 0;

1822 buildPublishedMap() {

1823 var o = new api.PublishedMap();

1824 buildCounterPublishedMap++;

1825 if (buildCounterPublishedMap < 3) {

1826 o.contents = buildMapContents();

1827 o.defaultViewport = buildLatLngBox();

1828 o.description = "foo";

1829 o.id = "foo";

1830 o.name = "foo";

1831 o.projectId = "foo";

1832 }

1833 buildCounterPublishedMap--;

1834 return o;

1835 }

1836

1837 checkPublishedMap(api.PublishedMap o) {

1838 buildCounterPublishedMap++;

1839 if (buildCounterPublishedMap < 3) {

1840 checkMapContents(o.contents);

1841 checkLatLngBox(o.defaultViewport);

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

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

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

1845 unittest.expect(o.projectId, unittest.equals('foo'));

1846 }

1847 buildCounterPublishedMap--;

1848 }

1849

1850 buildUnnamed102() {

1851 var o = new core.List<api.PublishedMap>();

1852 o.add(buildPublishedMap());

1853 o.add(buildPublishedMap());

1854 return o;

1855 }

1856

1857 checkUnnamed102(core.List<api.PublishedMap> o) {

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

1859 checkPublishedMap(o[0]);

1860 checkPublishedMap(o[1]);

1861 }

1862

1863 core.int buildCounterPublishedMapsListResponse = 0;

1864 buildPublishedMapsListResponse() {

1865 var o = new api.PublishedMapsListResponse();

1866 buildCounterPublishedMapsListResponse++;

1867 if (buildCounterPublishedMapsListResponse < 3) {

1868 o.maps = buildUnnamed102();

1869 o.nextPageToken = "foo";

1870 }

1871 buildCounterPublishedMapsListResponse--;

1872 return o;

1873 }

1874

1875 checkPublishedMapsListResponse(api.PublishedMapsListResponse o) {

1876 buildCounterPublishedMapsListResponse++;

1877 if (buildCounterPublishedMapsListResponse < 3) {

1878 checkUnnamed102(o.maps);

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

1880 }

1881 buildCounterPublishedMapsListResponse--;

1882 }

1883

1884 buildUnnamed103() {

1885 var o = new core.List<core.double>();

1886 o.add(42.0);

1887 o.add(42.0);

1888 return o;

1889 }

1890

1891 checkUnnamed103(core.List<core.double> o) {

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

1893 unittest.expect(o[0], unittest.equals(42.0));

1894 unittest.expect(o[1], unittest.equals(42.0));

1895 }

1896

1897 buildUnnamed104() {

1898 var o = new core.List<api.File>();

1899 o.add(buildFile());

1900 o.add(buildFile());

1901 return o;

1902 }

1903

1904 checkUnnamed104(core.List<api.File> o) {

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

1906 checkFile(o[0]);

1907 checkFile(o[1]);

1908 }

1909

1910 core.int buildCounterRaster = 0;

1911 buildRaster() {

1912 var o = new api.Raster();

1913 buildCounterRaster++;

1914 if (buildCounterRaster < 3) {

1915 o.acquisitionTime = buildAcquisitionTime();

1916 o.attribution = "foo";

1917 o.bbox = buildUnnamed103();

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

1919 o.creatorEmail = "foo";

1920 o.description = "foo";

1921 o.draftAccessList = "foo";

1922 o.etag = "foo";

1923 o.files = buildUnnamed104();

1924 o.id = "foo";

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

1926 o.lastModifierEmail = "foo";

1927 o.maskType = "foo";

1928 o.name = "foo";

1929 o.processingStatus = "foo";

1930 o.projectId = "foo";

1931 o.rasterType = "foo";

1932 o.tags = buildTags();

1933 o.writersCanEditPermissions = true;

1934 }

1935 buildCounterRaster--;

1936 return o;

1937 }

1938

1939 checkRaster(api.Raster o) {

1940 buildCounterRaster++;

1941 if (buildCounterRaster < 3) {

1942 checkAcquisitionTime(o.acquisitionTime);

1943 unittest.expect(o.attribution, unittest.equals('foo'));

1944 checkUnnamed103(o.bbox);

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

1946 unittest.expect(o.creatorEmail, unittest.equals('foo'));

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

1948 unittest.expect(o.draftAccessList, unittest.equals('foo'));

1949 unittest.expect(o.etag, unittest.equals('foo'));

1950 checkUnnamed104(o.files);

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

1952 unittest.expect(o.lastModifiedTime, unittest.equals(core.DateTime.parse("200 2-02-27T14:01:02")));

1953 unittest.expect(o.lastModifierEmail, unittest.equals('foo'));

1954 unittest.expect(o.maskType, unittest.equals('foo'));

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

1956 unittest.expect(o.processingStatus, unittest.equals('foo'));

1957 unittest.expect(o.projectId, unittest.equals('foo'));

1958 unittest.expect(o.rasterType, unittest.equals('foo'));

1959 checkTags(o.tags);

1960 unittest.expect(o.writersCanEditPermissions, unittest.isTrue);

1961 }

1962 buildCounterRaster--;

1963 }

1964

1965 buildUnnamed105() {

1966 var o = new core.List<core.double>();

1967 o.add(42.0);

1968 o.add(42.0);

1969 return o;

1970 }

1971

1972 checkUnnamed105(core.List<core.double> o) {

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

1974 unittest.expect(o[0], unittest.equals(42.0));

1975 unittest.expect(o[1], unittest.equals(42.0));

1976 }

1977

1978 core.int buildCounterRasterCollection = 0;

1979 buildRasterCollection() {

1980 var o = new api.RasterCollection();

1981 buildCounterRasterCollection++;

1982 if (buildCounterRasterCollection < 3) {

1983 o.attribution = "foo";

1984 o.bbox = buildUnnamed105();

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

1986 o.creatorEmail = "foo";

1987 o.description = "foo";

1988 o.draftAccessList = "foo";

1989 o.etag = "foo";

1990 o.id = "foo";

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

1992 o.lastModifierEmail = "foo";

1993 o.mosaic = true;

1994 o.name = "foo";

1995 o.processingStatus = "foo";

1996 o.projectId = "foo";

1997 o.rasterType = "foo";

1998 o.tags = buildTags();

1999 o.writersCanEditPermissions = true;

2000 }

2001 buildCounterRasterCollection--;

2002 return o;

2003 }

2004

2005 checkRasterCollection(api.RasterCollection o) {

2006 buildCounterRasterCollection++;

2007 if (buildCounterRasterCollection < 3) {

2008 unittest.expect(o.attribution, unittest.equals('foo'));

2009 checkUnnamed105(o.bbox);

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

2011 unittest.expect(o.creatorEmail, unittest.equals('foo'));

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

2013 unittest.expect(o.draftAccessList, unittest.equals('foo'));

2014 unittest.expect(o.etag, unittest.equals('foo'));

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

2016 unittest.expect(o.lastModifiedTime, unittest.equals(core.DateTime.parse("200 2-02-27T14:01:02")));

2017 unittest.expect(o.lastModifierEmail, unittest.equals('foo'));

2018 unittest.expect(o.mosaic, unittest.isTrue);

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

2020 unittest.expect(o.processingStatus, unittest.equals('foo'));

2021 unittest.expect(o.projectId, unittest.equals('foo'));

2022 unittest.expect(o.rasterType, unittest.equals('foo'));

2023 checkTags(o.tags);

2024 unittest.expect(o.writersCanEditPermissions, unittest.isTrue);

2025 }

2026 buildCounterRasterCollection--;

2027 }

2028

2029 buildUnnamed106() {

2030 var o = new core.List<api.RasterCollection>();

2031 o.add(buildRasterCollection());

2032 o.add(buildRasterCollection());

2033 return o;

2034 }

2035

2036 checkUnnamed106(core.List<api.RasterCollection> o) {

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

2038 checkRasterCollection(o[0]);

2039 checkRasterCollection(o[1]);

2040 }

2041

2042 core.int buildCounterRasterCollectionsListResponse = 0;

2043 buildRasterCollectionsListResponse() {

2044 var o = new api.RasterCollectionsListResponse();

2045 buildCounterRasterCollectionsListResponse++;

2046 if (buildCounterRasterCollectionsListResponse < 3) {

2047 o.nextPageToken = "foo";

2048 o.rasterCollections = buildUnnamed106();

2049 }

2050 buildCounterRasterCollectionsListResponse--;

2051 return o;

2052 }

2053

2054 checkRasterCollectionsListResponse(api.RasterCollectionsListResponse o) {

2055 buildCounterRasterCollectionsListResponse++;

2056 if (buildCounterRasterCollectionsListResponse < 3) {

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

2058 checkUnnamed106(o.rasterCollections);

2059 }

2060 buildCounterRasterCollectionsListResponse--;

2061 }

2062

2063 buildUnnamed107() {

2064 var o = new core.List<core.double>();

2065 o.add(42.0);

2066 o.add(42.0);

2067 return o;

2068 }

2069

2070 checkUnnamed107(core.List<core.double> o) {

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

2072 unittest.expect(o[0], unittest.equals(42.0));

2073 unittest.expect(o[1], unittest.equals(42.0));

2074 }

2075

2076 buildUnnamed108() {

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

2078 o.add("foo");

2079 o.add("foo");

2080 return o;

2081 }

2082

2083 checkUnnamed108(core.List<core.String> o) {

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

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

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

2087 }

2088

2089 core.int buildCounterRasterCollectionsRaster = 0;

2090 buildRasterCollectionsRaster() {

2091 var o = new api.RasterCollectionsRaster();

2092 buildCounterRasterCollectionsRaster++;

2093 if (buildCounterRasterCollectionsRaster < 3) {

2094 o.bbox = buildUnnamed107();

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

2096 o.description = "foo";

2097 o.id = "foo";

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

2099 o.name = "foo";

2100 o.projectId = "foo";

2101 o.rasterType = "foo";

2102 o.tags = buildUnnamed108();

2103 }

2104 buildCounterRasterCollectionsRaster--;

2105 return o;

2106 }

2107

2108 checkRasterCollectionsRaster(api.RasterCollectionsRaster o) {

2109 buildCounterRasterCollectionsRaster++;

2110 if (buildCounterRasterCollectionsRaster < 3) {

2111 checkUnnamed107(o.bbox);

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

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

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

2115 unittest.expect(o.lastModifiedTime, unittest.equals(core.DateTime.parse("200 2-02-27T14:01:02")));

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

2117 unittest.expect(o.projectId, unittest.equals('foo'));

2118 unittest.expect(o.rasterType, unittest.equals('foo'));

2119 checkUnnamed108(o.tags);

2120 }

2121 buildCounterRasterCollectionsRaster--;

2122 }

2123

2124 buildUnnamed109() {

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

2126 o.add("foo");

2127 o.add("foo");

2128 return o;

2129 }

2130

2131 checkUnnamed109(core.List<core.String> o) {

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

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

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

2135 }

2136

2137 core.int buildCounterRasterCollectionsRasterBatchDeleteRequest = 0;

2138 buildRasterCollectionsRasterBatchDeleteRequest() {

2139 var o = new api.RasterCollectionsRasterBatchDeleteRequest();

2140 buildCounterRasterCollectionsRasterBatchDeleteRequest++;

2141 if (buildCounterRasterCollectionsRasterBatchDeleteRequest < 3) {

2142 o.ids = buildUnnamed109();

2143 }

2144 buildCounterRasterCollectionsRasterBatchDeleteRequest--;

2145 return o;

2146 }

2147

2148 checkRasterCollectionsRasterBatchDeleteRequest(api.RasterCollectionsRasterBatchD eleteRequest o) {

2149 buildCounterRasterCollectionsRasterBatchDeleteRequest++;

2150 if (buildCounterRasterCollectionsRasterBatchDeleteRequest < 3) {

2151 checkUnnamed109(o.ids);

2152 }

2153 buildCounterRasterCollectionsRasterBatchDeleteRequest--;

2154 }

2155

2156 core.int buildCounterRasterCollectionsRastersBatchDeleteResponse = 0;

2157 buildRasterCollectionsRastersBatchDeleteResponse() {

2158 var o = new api.RasterCollectionsRastersBatchDeleteResponse();

2159 buildCounterRasterCollectionsRastersBatchDeleteResponse++;

2160 if (buildCounterRasterCollectionsRastersBatchDeleteResponse < 3) {

2161 }

2162 buildCounterRasterCollectionsRastersBatchDeleteResponse--;

2163 return o;

2164 }

2165

2166 checkRasterCollectionsRastersBatchDeleteResponse(api.RasterCollectionsRastersBat chDeleteResponse o) {

2167 buildCounterRasterCollectionsRastersBatchDeleteResponse++;

2168 if (buildCounterRasterCollectionsRastersBatchDeleteResponse < 3) {

2169 }

2170 buildCounterRasterCollectionsRastersBatchDeleteResponse--;

2171 }

2172

2173 buildUnnamed110() {

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

2175 o.add("foo");

2176 o.add("foo");

2177 return o;

2178 }

2179

2180 checkUnnamed110(core.List<core.String> o) {

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

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

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

2184 }

2185

2186 core.int buildCounterRasterCollectionsRastersBatchInsertRequest = 0;

2187 buildRasterCollectionsRastersBatchInsertRequest() {

2188 var o = new api.RasterCollectionsRastersBatchInsertRequest();

2189 buildCounterRasterCollectionsRastersBatchInsertRequest++;

2190 if (buildCounterRasterCollectionsRastersBatchInsertRequest < 3) {

2191 o.ids = buildUnnamed110();

2192 }

2193 buildCounterRasterCollectionsRastersBatchInsertRequest--;

2194 return o;

2195 }

2196

2197 checkRasterCollectionsRastersBatchInsertRequest(api.RasterCollectionsRastersBatc hInsertRequest o) {

2198 buildCounterRasterCollectionsRastersBatchInsertRequest++;

2199 if (buildCounterRasterCollectionsRastersBatchInsertRequest < 3) {

2200 checkUnnamed110(o.ids);

2201 }

2202 buildCounterRasterCollectionsRastersBatchInsertRequest--;

2203 }

2204

2205 core.int buildCounterRasterCollectionsRastersBatchInsertResponse = 0;

2206 buildRasterCollectionsRastersBatchInsertResponse() {

2207 var o = new api.RasterCollectionsRastersBatchInsertResponse();

2208 buildCounterRasterCollectionsRastersBatchInsertResponse++;

2209 if (buildCounterRasterCollectionsRastersBatchInsertResponse < 3) {

2210 }

2211 buildCounterRasterCollectionsRastersBatchInsertResponse--;

2212 return o;

2213 }

2214

2215 checkRasterCollectionsRastersBatchInsertResponse(api.RasterCollectionsRastersBat chInsertResponse o) {

2216 buildCounterRasterCollectionsRastersBatchInsertResponse++;

2217 if (buildCounterRasterCollectionsRastersBatchInsertResponse < 3) {

2218 }

2219 buildCounterRasterCollectionsRastersBatchInsertResponse--;

2220 }

2221

2222 buildUnnamed111() {

2223 var o = new core.List<api.RasterCollectionsRaster>();

2224 o.add(buildRasterCollectionsRaster());

2225 o.add(buildRasterCollectionsRaster());

2226 return o;

2227 }

2228

2229 checkUnnamed111(core.List<api.RasterCollectionsRaster> o) {

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

2231 checkRasterCollectionsRaster(o[0]);

2232 checkRasterCollectionsRaster(o[1]);

2233 }

2234

2235 core.int buildCounterRasterCollectionsRastersListResponse = 0;

2236 buildRasterCollectionsRastersListResponse() {

2237 var o = new api.RasterCollectionsRastersListResponse();

2238 buildCounterRasterCollectionsRastersListResponse++;

2239 if (buildCounterRasterCollectionsRastersListResponse < 3) {

2240 o.nextPageToken = "foo";

2241 o.rasters = buildUnnamed111();

2242 }

2243 buildCounterRasterCollectionsRastersListResponse--;

2244 return o;

2245 }

2246

2247 checkRasterCollectionsRastersListResponse(api.RasterCollectionsRastersListRespon se o) {

2248 buildCounterRasterCollectionsRastersListResponse++;

2249 if (buildCounterRasterCollectionsRastersListResponse < 3) {

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

2251 checkUnnamed111(o.rasters);

2252 }

2253 buildCounterRasterCollectionsRastersListResponse--;

2254 }

2255

2256 buildUnnamed112() {

2257 var o = new core.List<api.Raster>();

2258 o.add(buildRaster());

2259 o.add(buildRaster());

2260 return o;

2261 }

2262

2263 checkUnnamed112(core.List<api.Raster> o) {

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

2265 checkRaster(o[0]);

2266 checkRaster(o[1]);

2267 }

2268

2269 core.int buildCounterRastersListResponse = 0;

2270 buildRastersListResponse() {

2271 var o = new api.RastersListResponse();

2272 buildCounterRastersListResponse++;

2273 if (buildCounterRastersListResponse < 3) {

2274 o.nextPageToken = "foo";

2275 o.rasters = buildUnnamed112();

2276 }

2277 buildCounterRastersListResponse--;

2278 return o;

2279 }

2280

2281 checkRastersListResponse(api.RastersListResponse o) {

2282 buildCounterRastersListResponse++;

2283 if (buildCounterRastersListResponse < 3) {

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

2285 checkUnnamed112(o.rasters);

2286 }

2287 buildCounterRastersListResponse--;

2288 }

2289

2290 core.int buildCounterScaledShape = 0;

2291 buildScaledShape() {

2292 var o = new api.ScaledShape();

2293 buildCounterScaledShape++;

2294 if (buildCounterScaledShape < 3) {

2295 o.border = buildBorder();

2296 o.fill = buildColor();

2297 o.shape = "foo";

2298 }

2299 buildCounterScaledShape--;

2300 return o;

2301 }

2302

2303 checkScaledShape(api.ScaledShape o) {

2304 buildCounterScaledShape++;

2305 if (buildCounterScaledShape < 3) {

2306 checkBorder(o.border);

2307 checkColor(o.fill);

2308 unittest.expect(o.shape, unittest.equals('foo'));

2309 }

2310 buildCounterScaledShape--;

2311 }

2312

2313 core.int buildCounterScalingFunction = 0;

2314 buildScalingFunction() {

2315 var o = new api.ScalingFunction();

2316 buildCounterScalingFunction++;

2317 if (buildCounterScalingFunction < 3) {

2318 o.column = "foo";

2319 o.scalingType = "foo";

2320 o.sizeRange = buildSizeRange();

2321 o.valueRange = buildValueRange();

2322 }

2323 buildCounterScalingFunction--;

2324 return o;

2325 }

2326

2327 checkScalingFunction(api.ScalingFunction o) {

2328 buildCounterScalingFunction++;

2329 if (buildCounterScalingFunction < 3) {

2330 unittest.expect(o.column, unittest.equals('foo'));

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

2332 checkSizeRange(o.sizeRange);

2333 checkValueRange(o.valueRange);

2334 }

2335 buildCounterScalingFunction--;

2336 }

2337

2338 buildUnnamed113() {

2339 var o = new core.List<api.TableColumn>();

2340 o.add(buildTableColumn());

2341 o.add(buildTableColumn());

2342 return o;

2343 }

2344

2345 checkUnnamed113(core.List<api.TableColumn> o) {

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

2347 checkTableColumn(o[0]);

2348 checkTableColumn(o[1]);

2349 }

2350

2351 core.int buildCounterSchema = 0;

2352 buildSchema() {

2353 var o = new api.Schema();

2354 buildCounterSchema++;

2355 if (buildCounterSchema < 3) {

2356 o.columns = buildUnnamed113();

2357 o.primaryGeometry = "foo";

2358 o.primaryKey = "foo";

2359 }

2360 buildCounterSchema--;

2361 return o;

2362 }

2363

2364 checkSchema(api.Schema o) {

2365 buildCounterSchema++;

2366 if (buildCounterSchema < 3) {

2367 checkUnnamed113(o.columns);

2368 unittest.expect(o.primaryGeometry, unittest.equals('foo'));

2369 unittest.expect(o.primaryKey, unittest.equals('foo'));

2370 }

2371 buildCounterSchema--;

2372 }

2373

2374 core.int buildCounterSizeRange = 0;

2375 buildSizeRange() {

2376 var o = new api.SizeRange();

2377 buildCounterSizeRange++;

2378 if (buildCounterSizeRange < 3) {

2379 o.max = 42.0;

2380 o.min = 42.0;

2381 }

2382 buildCounterSizeRange--;

2383 return o;

2384 }

2385

2386 checkSizeRange(api.SizeRange o) {

2387 buildCounterSizeRange++;

2388 if (buildCounterSizeRange < 3) {

2389 unittest.expect(o.max, unittest.equals(42.0));

2390 unittest.expect(o.min, unittest.equals(42.0));

2391 }

2392 buildCounterSizeRange--;

2393 }

2394

2395 buildUnnamed114() {

2396 var o = new core.List<core.double>();

2397 o.add(42.0);

2398 o.add(42.0);

2399 return o;

2400 }

2401

2402 checkUnnamed114(core.List<core.double> o) {

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

2404 unittest.expect(o[0], unittest.equals(42.0));

2405 unittest.expect(o[1], unittest.equals(42.0));

2406 }

2407

2408 buildUnnamed115() {

2409 var o = new core.List<api.File>();

2410 o.add(buildFile());

2411 o.add(buildFile());

2412 return o;

2413 }

2414

2415 checkUnnamed115(core.List<api.File> o) {

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

2417 checkFile(o[0]);

2418 checkFile(o[1]);

2419 }

2420

2421 core.int buildCounterTable = 0;

2422 buildTable() {

2423 var o = new api.Table();

2424 buildCounterTable++;

2425 if (buildCounterTable < 3) {

2426 o.bbox = buildUnnamed114();

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

2428 o.creatorEmail = "foo";

2429 o.description = "foo";

2430 o.draftAccessList = "foo";

2431 o.etag = "foo";

2432 o.files = buildUnnamed115();

2433 o.id = "foo";

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

2435 o.lastModifierEmail = "foo";

2436 o.name = "foo";

2437 o.processingStatus = "foo";

2438 o.projectId = "foo";

2439 o.publishedAccessList = "foo";

2440 o.schema = buildSchema();

2441 o.sourceEncoding = "foo";

2442 o.tags = buildTags();

2443 o.writersCanEditPermissions = true;

2444 }

2445 buildCounterTable--;

2446 return o;

2447 }

2448

2449 checkTable(api.Table o) {

2450 buildCounterTable++;

2451 if (buildCounterTable < 3) {

2452 checkUnnamed114(o.bbox);

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

2454 unittest.expect(o.creatorEmail, unittest.equals('foo'));

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

2456 unittest.expect(o.draftAccessList, unittest.equals('foo'));

2457 unittest.expect(o.etag, unittest.equals('foo'));

2458 checkUnnamed115(o.files);

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

2460 unittest.expect(o.lastModifiedTime, unittest.equals(core.DateTime.parse("200 2-02-27T14:01:02")));

2461 unittest.expect(o.lastModifierEmail, unittest.equals('foo'));

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

2463 unittest.expect(o.processingStatus, unittest.equals('foo'));

2464 unittest.expect(o.projectId, unittest.equals('foo'));

2465 unittest.expect(o.publishedAccessList, unittest.equals('foo'));

2466 checkSchema(o.schema);

2467 unittest.expect(o.sourceEncoding, unittest.equals('foo'));

2468 checkTags(o.tags);

2469 unittest.expect(o.writersCanEditPermissions, unittest.isTrue);

2470 }

2471 buildCounterTable--;

2472 }

2473

2474 core.int buildCounterTableColumn = 0;

2475 buildTableColumn() {

2476 var o = new api.TableColumn();

2477 buildCounterTableColumn++;

2478 if (buildCounterTableColumn < 3) {

2479 o.name = "foo";

2480 o.type = "foo";

2481 }

2482 buildCounterTableColumn--;

2483 return o;

2484 }

2485

2486 checkTableColumn(api.TableColumn o) {

2487 buildCounterTableColumn++;

2488 if (buildCounterTableColumn < 3) {

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

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

2491 }

2492 buildCounterTableColumn--;

2493 }

2494

2495 buildUnnamed116() {

2496 var o = new core.List<api.Table>();

2497 o.add(buildTable());

2498 o.add(buildTable());

2499 return o;

2500 }

2501

2502 checkUnnamed116(core.List<api.Table> o) {

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

2504 checkTable(o[0]);

2505 checkTable(o[1]);

2506 }

2507

2508 core.int buildCounterTablesListResponse = 0;

2509 buildTablesListResponse() {

2510 var o = new api.TablesListResponse();

2511 buildCounterTablesListResponse++;

2512 if (buildCounterTablesListResponse < 3) {

2513 o.nextPageToken = "foo";

2514 o.tables = buildUnnamed116();

2515 }

2516 buildCounterTablesListResponse--;

2517 return o;

2518 }

2519

2520 checkTablesListResponse(api.TablesListResponse o) {

2521 buildCounterTablesListResponse++;

2522 if (buildCounterTablesListResponse < 3) {

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

2524 checkUnnamed116(o.tables);

2525 }

2526 buildCounterTablesListResponse--;

2527 }

2528

2529 buildTags() {

2530 var o = new api.Tags();

2531 o.add("foo");

2532 o.add("foo");

2533 return o;

2534 }

2535

2536 checkTags(api.Tags o) {

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

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

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

2540 }

2541

2542 core.int buildCounterValueRange = 0;

2543 buildValueRange() {

2544 var o = new api.ValueRange();

2545 buildCounterValueRange++;

2546 if (buildCounterValueRange < 3) {

2547 o.max = 42.0;

2548 o.min = 42.0;

2549 }

2550 buildCounterValueRange--;

2551 return o;

2552 }

2553

2554 checkValueRange(api.ValueRange o) {

2555 buildCounterValueRange++;

2556 if (buildCounterValueRange < 3) {

2557 unittest.expect(o.max, unittest.equals(42.0));

2558 unittest.expect(o.min, unittest.equals(42.0));

2559 }

2560 buildCounterValueRange--;

2561 }

2562

2563 buildUnnamed117() {

2564 var o = new core.List<api.DisplayRule>();

2565 o.add(buildDisplayRule());

2566 o.add(buildDisplayRule());

2567 return o;

2568 }

2569

2570 checkUnnamed117(core.List<api.DisplayRule> o) {

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

2572 checkDisplayRule(o[0]);

2573 checkDisplayRule(o[1]);

2574 }

2575

2576 core.int buildCounterVectorStyle = 0;

2577 buildVectorStyle() {

2578 var o = new api.VectorStyle();

2579 buildCounterVectorStyle++;

2580 if (buildCounterVectorStyle < 3) {

2581 o.displayRules = buildUnnamed117();

2582 o.featureInfo = buildFeatureInfo();

2583 o.type = "foo";

2584 }

2585 buildCounterVectorStyle--;

2586 return o;

2587 }

2588

2589 checkVectorStyle(api.VectorStyle o) {

2590 buildCounterVectorStyle++;

2591 if (buildCounterVectorStyle < 3) {

2592 checkUnnamed117(o.displayRules);

2593 checkFeatureInfo(o.featureInfo);

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

2595 }

2596 buildCounterVectorStyle--;

2597 }

2598

2599 core.int buildCounterZoomLevels = 0;

2600 buildZoomLevels() {

2601 var o = new api.ZoomLevels();

2602 buildCounterZoomLevels++;

2603 if (buildCounterZoomLevels < 3) {

2604 o.max = 42;

2605 o.min = 42;

2606 }

2607 buildCounterZoomLevels--;

2608 return o;

2609 }

2610

2611 checkZoomLevels(api.ZoomLevels o) {

2612 buildCounterZoomLevels++;

2613 if (buildCounterZoomLevels < 3) {

2614 unittest.expect(o.max, unittest.equals(42));

2615 unittest.expect(o.min, unittest.equals(42));

2616 }

2617 buildCounterZoomLevels--;

2618 }

2619

2620

2621 main() {

2622 unittest.group("obj-schema-AcquisitionTime", () {

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

2624 var o = buildAcquisitionTime();

2625 var od = new api.AcquisitionTime.fromJson(o.toJson());

2626 checkAcquisitionTime(od);

2627 });

2628 });

2629

2630

2631 unittest.group("obj-schema-Asset", () {

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

2633 var o = buildAsset();

2634 var od = new api.Asset.fromJson(o.toJson());

2635 checkAsset(od);

2636 });

2637 });

2638

2639

2640 unittest.group("obj-schema-AssetsListResponse", () {

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

2642 var o = buildAssetsListResponse();

2643 var od = new api.AssetsListResponse.fromJson(o.toJson());

2644 checkAssetsListResponse(od);

2645 });

2646 });

2647

2648

2649 unittest.group("obj-schema-Border", () {

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

2651 var o = buildBorder();

2652 var od = new api.Border.fromJson(o.toJson());

2653 checkBorder(od);

2654 });

2655 });

2656

2657

2658 unittest.group("obj-schema-Color", () {

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

2660 var o = buildColor();

2661 var od = new api.Color.fromJson(o.toJson());

2662 checkColor(od);

2663 });

2664 });

2665

2666

2667 unittest.group("obj-schema-Datasource", () {

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

2669 var o = buildDatasource();

2670 var od = new api.Datasource.fromJson(o.toJson());

2671 checkDatasource(od);

2672 });

2673 });

2674

2675

2676 unittest.group("obj-schema-Datasources", () {

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

2678 var o = buildDatasources();

2679 var od = new api.Datasources.fromJson(o.toJson());

2680 checkDatasources(od);

2681 });

2682 });

2683

2684

2685 unittest.group("obj-schema-DisplayRule", () {

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

2687 var o = buildDisplayRule();

2688 var od = new api.DisplayRule.fromJson(o.toJson());

2689 checkDisplayRule(od);

2690 });

2691 });

2692

2693

2694 unittest.group("obj-schema-Feature", () {

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

2696 var o = buildFeature();

2697 var od = new api.Feature.fromJson(o.toJson());

2698 checkFeature(od);

2699 });

2700 });

2701

2702

2703 unittest.group("obj-schema-FeatureInfo", () {

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

2705 var o = buildFeatureInfo();

2706 var od = new api.FeatureInfo.fromJson(o.toJson());

2707 checkFeatureInfo(od);

2708 });

2709 });

2710

2711

2712 unittest.group("obj-schema-FeaturesBatchDeleteRequest", () {

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

2714 var o = buildFeaturesBatchDeleteRequest();

2715 var od = new api.FeaturesBatchDeleteRequest.fromJson(o.toJson());

2716 checkFeaturesBatchDeleteRequest(od);

2717 });

2718 });

2719

2720

2721 unittest.group("obj-schema-FeaturesBatchInsertRequest", () {

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

2723 var o = buildFeaturesBatchInsertRequest();

2724 var od = new api.FeaturesBatchInsertRequest.fromJson(o.toJson());

2725 checkFeaturesBatchInsertRequest(od);

2726 });

2727 });

2728

2729

2730 unittest.group("obj-schema-FeaturesBatchPatchRequest", () {

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

2732 var o = buildFeaturesBatchPatchRequest();

2733 var od = new api.FeaturesBatchPatchRequest.fromJson(o.toJson());

2734 checkFeaturesBatchPatchRequest(od);

2735 });

2736 });

2737

2738

2739 unittest.group("obj-schema-FeaturesListResponse", () {

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

2741 var o = buildFeaturesListResponse();

2742 var od = new api.FeaturesListResponse.fromJson(o.toJson());

2743 checkFeaturesListResponse(od);

2744 });

2745 });

2746

2747

2748 unittest.group("obj-schema-File", () {

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

2750 var o = buildFile();

2751 var od = new api.File.fromJson(o.toJson());

2752 checkFile(od);

2753 });

2754 });

2755

2756

2757 unittest.group("obj-schema-Filter", () {

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

2759 var o = buildFilter();

2760 var od = new api.Filter.fromJson(o.toJson());

2761 checkFilter(od);

2762 });

2763 });

2764

2765

2766 unittest.group("obj-schema-GeoJsonGeometry", () {

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

2768 var o = buildGeoJsonGeometry();

2769 var od = new api.GeoJsonGeometry.fromJson(o.toJson());

2770 checkGeoJsonGeometry(od);

2771 });

2772 });

2773

2774

2775 unittest.group("obj-schema-GeoJsonGeometryCollection", () {

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

2777 var o = buildGeoJsonGeometryCollection();

2778 var od = new api.GeoJsonGeometryCollection.fromJson(o.toJson());

2779 checkGeoJsonGeometryCollection(od);

2780 });

2781 });

2782

2783

2784 unittest.group("obj-schema-GeoJsonLineString", () {

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

2786 var o = buildGeoJsonLineString();

2787 var od = new api.GeoJsonLineString.fromJson(o.toJson());

2788 checkGeoJsonLineString(od);

2789 });

2790 });

2791

2792

2793 unittest.group("obj-schema-GeoJsonMultiLineString", () {

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

2795 var o = buildGeoJsonMultiLineString();

2796 var od = new api.GeoJsonMultiLineString.fromJson(o.toJson());

2797 checkGeoJsonMultiLineString(od);

2798 });

2799 });

2800

2801

2802 unittest.group("obj-schema-GeoJsonMultiPoint", () {

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

2804 var o = buildGeoJsonMultiPoint();

2805 var od = new api.GeoJsonMultiPoint.fromJson(o.toJson());

2806 checkGeoJsonMultiPoint(od);

2807 });

2808 });

2809

2810

2811 unittest.group("obj-schema-GeoJsonMultiPolygon", () {

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

2813 var o = buildGeoJsonMultiPolygon();

2814 var od = new api.GeoJsonMultiPolygon.fromJson(o.toJson());

2815 checkGeoJsonMultiPolygon(od);

2816 });

2817 });

2818

2819

2820 unittest.group("obj-schema-GeoJsonPoint", () {

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

2822 var o = buildGeoJsonPoint();

2823 var od = new api.GeoJsonPoint.fromJson(o.toJson());

2824 checkGeoJsonPoint(od);

2825 });

2826 });

2827

2828

2829 unittest.group("obj-schema-GeoJsonPolygon", () {

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

2831 var o = buildGeoJsonPolygon();

2832 var od = new api.GeoJsonPolygon.fromJson(o.toJson());

2833 checkGeoJsonPolygon(od);

2834 });

2835 });

2836

2837

2838 unittest.group("obj-schema-GeoJsonPosition", () {

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

2840 var o = buildGeoJsonPosition();

2841 var od = new api.GeoJsonPosition.fromJson(o.toJson());

2842 checkGeoJsonPosition(od);

2843 });

2844 });

2845

2846

2847 unittest.group("obj-schema-GeoJsonProperties", () {

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

2849 var o = buildGeoJsonProperties();

2850 var od = new api.GeoJsonProperties.fromJson(o.toJson());

2851 checkGeoJsonProperties(od);

2852 });

2853 });

2854

2855

2856 unittest.group("obj-schema-Icon", () {

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

2858 var o = buildIcon();

2859 var od = new api.Icon.fromJson(o.toJson());

2860 checkIcon(od);

2861 });

2862 });

2863

2864

2865 unittest.group("obj-schema-IconStyle", () {

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

2867 var o = buildIconStyle();

2868 var od = new api.IconStyle.fromJson(o.toJson());

2869 checkIconStyle(od);

2870 });

2871 });

2872

2873

2874 unittest.group("obj-schema-IconsListResponse", () {

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

2876 var o = buildIconsListResponse();

2877 var od = new api.IconsListResponse.fromJson(o.toJson());

2878 checkIconsListResponse(od);

2879 });

2880 });

2881

2882

2883 unittest.group("obj-schema-LabelStyle", () {

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

2885 var o = buildLabelStyle();

2886 var od = new api.LabelStyle.fromJson(o.toJson());

2887 checkLabelStyle(od);

2888 });

2889 });

2890

2891

2892 unittest.group("obj-schema-LatLngBox", () {

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

2894 var o = buildLatLngBox();

2895 var od = new api.LatLngBox.fromJson(o.toJson());

2896 checkLatLngBox(od);

2897 });

2898 });

2899

2900

2901 unittest.group("obj-schema-Layer", () {

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

2903 var o = buildLayer();

2904 var od = new api.Layer.fromJson(o.toJson());

2905 checkLayer(od);

2906 });

2907 });

2908

2909

2910 unittest.group("obj-schema-LayersListResponse", () {

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

2912 var o = buildLayersListResponse();

2913 var od = new api.LayersListResponse.fromJson(o.toJson());

2914 checkLayersListResponse(od);

2915 });

2916 });

2917

2918

2919 unittest.group("obj-schema-LineStyleStroke", () {

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

2921 var o = buildLineStyleStroke();

2922 var od = new api.LineStyleStroke.fromJson(o.toJson());

2923 checkLineStyleStroke(od);

2924 });

2925 });

2926

2927

2928 unittest.group("obj-schema-LineStyle", () {

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

2930 var o = buildLineStyle();

2931 var od = new api.LineStyle.fromJson(o.toJson());

2932 checkLineStyle(od);

2933 });

2934 });

2935

2936

2937 unittest.group("obj-schema-Map", () {

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

2939 var o = buildMap();

2940 var od = new api.Map.fromJson(o.toJson());

2941 checkMap(od);

2942 });

2943 });

2944

2945

2946 unittest.group("obj-schema-MapContents", () {

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

2948 var o = buildMapContents();

2949 var od = new api.MapContents.fromJson(o.toJson());

2950 checkMapContents(od);

2951 });

2952 });

2953

2954

2955 unittest.group("obj-schema-MapFolder", () {

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

2957 var o = buildMapFolder();

2958 var od = new api.MapFolder.fromJson(o.toJson());

2959 checkMapFolder(od);

2960 });

2961 });

2962

2963

2964 unittest.group("obj-schema-MapItem", () {

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

2966 var o = buildMapItem();

2967 var od = new api.MapItem.fromJson(o.toJson());

2968 checkMapItem(od);

2969 });

2970 });

2971

2972

2973 unittest.group("obj-schema-MapKmlLink", () {

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

2975 var o = buildMapKmlLink();

2976 var od = new api.MapKmlLink.fromJson(o.toJson());

2977 checkMapKmlLink(od);

2978 });

2979 });

2980

2981

2982 unittest.group("obj-schema-MapLayer", () {

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

2984 var o = buildMapLayer();

2985 var od = new api.MapLayer.fromJson(o.toJson());

2986 checkMapLayer(od);

2987 });

2988 });

2989

2990

2991 unittest.group("obj-schema-MapsListResponse", () {

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

2993 var o = buildMapsListResponse();

2994 var od = new api.MapsListResponse.fromJson(o.toJson());

2995 checkMapsListResponse(od);

2996 });

2997 });

2998

2999

3000 unittest.group("obj-schema-Parent", () {

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

3002 var o = buildParent();

3003 var od = new api.Parent.fromJson(o.toJson());

3004 checkParent(od);

3005 });

3006 });

3007

3008

3009 unittest.group("obj-schema-ParentsListResponse", () {

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

3011 var o = buildParentsListResponse();

3012 var od = new api.ParentsListResponse.fromJson(o.toJson());

3013 checkParentsListResponse(od);

3014 });

3015 });

3016

3017

3018 unittest.group("obj-schema-Permission", () {

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

3020 var o = buildPermission();

3021 var od = new api.Permission.fromJson(o.toJson());

3022 checkPermission(od);

3023 });

3024 });

3025

3026

3027 unittest.group("obj-schema-PermissionsBatchDeleteRequest", () {

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

3029 var o = buildPermissionsBatchDeleteRequest();

3030 var od = new api.PermissionsBatchDeleteRequest.fromJson(o.toJson());

3031 checkPermissionsBatchDeleteRequest(od);

3032 });

3033 });

3034

3035

3036 unittest.group("obj-schema-PermissionsBatchDeleteResponse", () {

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

3038 var o = buildPermissionsBatchDeleteResponse();

3039 var od = new api.PermissionsBatchDeleteResponse.fromJson(o.toJson());

3040 checkPermissionsBatchDeleteResponse(od);

3041 });

3042 });

3043

3044

3045 unittest.group("obj-schema-PermissionsBatchUpdateRequest", () {

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

3047 var o = buildPermissionsBatchUpdateRequest();

3048 var od = new api.PermissionsBatchUpdateRequest.fromJson(o.toJson());

3049 checkPermissionsBatchUpdateRequest(od);

3050 });

3051 });

3052

3053

3054 unittest.group("obj-schema-PermissionsBatchUpdateResponse", () {

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

3056 var o = buildPermissionsBatchUpdateResponse();

3057 var od = new api.PermissionsBatchUpdateResponse.fromJson(o.toJson());

3058 checkPermissionsBatchUpdateResponse(od);

3059 });

3060 });

3061

3062

3063 unittest.group("obj-schema-PermissionsListResponse", () {

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

3065 var o = buildPermissionsListResponse();

3066 var od = new api.PermissionsListResponse.fromJson(o.toJson());

3067 checkPermissionsListResponse(od);

3068 });

3069 });

3070

3071

3072 unittest.group("obj-schema-PointStyle", () {

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

3074 var o = buildPointStyle();

3075 var od = new api.PointStyle.fromJson(o.toJson());

3076 checkPointStyle(od);

3077 });

3078 });

3079

3080

3081 unittest.group("obj-schema-PolygonStyle", () {

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

3083 var o = buildPolygonStyle();

3084 var od = new api.PolygonStyle.fromJson(o.toJson());

3085 checkPolygonStyle(od);

3086 });

3087 });

3088

3089

3090 unittest.group("obj-schema-ProcessResponse", () {

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

3092 var o = buildProcessResponse();

3093 var od = new api.ProcessResponse.fromJson(o.toJson());

3094 checkProcessResponse(od);

3095 });

3096 });

3097

3098

3099 unittest.group("obj-schema-Project", () {

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

3101 var o = buildProject();

3102 var od = new api.Project.fromJson(o.toJson());

3103 checkProject(od);

3104 });

3105 });

3106

3107

3108 unittest.group("obj-schema-ProjectsListResponse", () {

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

3110 var o = buildProjectsListResponse();

3111 var od = new api.ProjectsListResponse.fromJson(o.toJson());

3112 checkProjectsListResponse(od);

3113 });

3114 });

3115

3116

3117 unittest.group("obj-schema-PublishResponse", () {

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

3119 var o = buildPublishResponse();

3120 var od = new api.PublishResponse.fromJson(o.toJson());

3121 checkPublishResponse(od);

3122 });

3123 });

3124

3125

3126 unittest.group("obj-schema-PublishedLayer", () {

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

3128 var o = buildPublishedLayer();

3129 var od = new api.PublishedLayer.fromJson(o.toJson());

3130 checkPublishedLayer(od);

3131 });

3132 });

3133

3134

3135 unittest.group("obj-schema-PublishedLayersListResponse", () {

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

3137 var o = buildPublishedLayersListResponse();

3138 var od = new api.PublishedLayersListResponse.fromJson(o.toJson());

3139 checkPublishedLayersListResponse(od);

3140 });

3141 });

3142

3143

3144 unittest.group("obj-schema-PublishedMap", () {

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

3146 var o = buildPublishedMap();

3147 var od = new api.PublishedMap.fromJson(o.toJson());

3148 checkPublishedMap(od);

3149 });

3150 });

3151

3152

3153 unittest.group("obj-schema-PublishedMapsListResponse", () {

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

3155 var o = buildPublishedMapsListResponse();

3156 var od = new api.PublishedMapsListResponse.fromJson(o.toJson());

3157 checkPublishedMapsListResponse(od);

3158 });

3159 });

3160

3161

3162 unittest.group("obj-schema-Raster", () {

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

3164 var o = buildRaster();

3165 var od = new api.Raster.fromJson(o.toJson());

3166 checkRaster(od);

3167 });

3168 });

3169

3170

3171 unittest.group("obj-schema-RasterCollection", () {

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

3173 var o = buildRasterCollection();

3174 var od = new api.RasterCollection.fromJson(o.toJson());

3175 checkRasterCollection(od);

3176 });

3177 });

3178

3179

3180 unittest.group("obj-schema-RasterCollectionsListResponse", () {

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

3182 var o = buildRasterCollectionsListResponse();

3183 var od = new api.RasterCollectionsListResponse.fromJson(o.toJson());

3184 checkRasterCollectionsListResponse(od);

3185 });

3186 });

3187

3188

3189 unittest.group("obj-schema-RasterCollectionsRaster", () {

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

3191 var o = buildRasterCollectionsRaster();

3192 var od = new api.RasterCollectionsRaster.fromJson(o.toJson());

3193 checkRasterCollectionsRaster(od);

3194 });

3195 });

3196

3197

3198 unittest.group("obj-schema-RasterCollectionsRasterBatchDeleteRequest", () {

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

3200 var o = buildRasterCollectionsRasterBatchDeleteRequest();

3201 var od = new api.RasterCollectionsRasterBatchDeleteRequest.fromJson(o.toJs on());

3202 checkRasterCollectionsRasterBatchDeleteRequest(od);

3203 });

3204 });

3205

3206

3207 unittest.group("obj-schema-RasterCollectionsRastersBatchDeleteResponse", () {

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

3209 var o = buildRasterCollectionsRastersBatchDeleteResponse();

3210 var od = new api.RasterCollectionsRastersBatchDeleteResponse.fromJson(o.to Json());

3211 checkRasterCollectionsRastersBatchDeleteResponse(od);

3212 });

3213 });

3214

3215

3216 unittest.group("obj-schema-RasterCollectionsRastersBatchInsertRequest", () {

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

3218 var o = buildRasterCollectionsRastersBatchInsertRequest();

3219 var od = new api.RasterCollectionsRastersBatchInsertRequest.fromJson(o.toJ son());

3220 checkRasterCollectionsRastersBatchInsertRequest(od);

3221 });

3222 });

3223

3224

3225 unittest.group("obj-schema-RasterCollectionsRastersBatchInsertResponse", () {

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

3227 var o = buildRasterCollectionsRastersBatchInsertResponse();

3228 var od = new api.RasterCollectionsRastersBatchInsertResponse.fromJson(o.to Json());

3229 checkRasterCollectionsRastersBatchInsertResponse(od);

3230 });

3231 });

3232

3233

3234 unittest.group("obj-schema-RasterCollectionsRastersListResponse", () {

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

3236 var o = buildRasterCollectionsRastersListResponse();

3237 var od = new api.RasterCollectionsRastersListResponse.fromJson(o.toJson()) ;

3238 checkRasterCollectionsRastersListResponse(od);

3239 });

3240 });

3241

3242

3243 unittest.group("obj-schema-RastersListResponse", () {

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

3245 var o = buildRastersListResponse();

3246 var od = new api.RastersListResponse.fromJson(o.toJson());

3247 checkRastersListResponse(od);

3248 });

3249 });

3250

3251

3252 unittest.group("obj-schema-ScaledShape", () {

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

3254 var o = buildScaledShape();

3255 var od = new api.ScaledShape.fromJson(o.toJson());

3256 checkScaledShape(od);

3257 });

3258 });

3259

3260

3261 unittest.group("obj-schema-ScalingFunction", () {

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

3263 var o = buildScalingFunction();

3264 var od = new api.ScalingFunction.fromJson(o.toJson());

3265 checkScalingFunction(od);

3266 });

3267 });

3268

3269

3270 unittest.group("obj-schema-Schema", () {

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

3272 var o = buildSchema();

3273 var od = new api.Schema.fromJson(o.toJson());

3274 checkSchema(od);

3275 });

3276 });

3277

3278

3279 unittest.group("obj-schema-SizeRange", () {

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

3281 var o = buildSizeRange();

3282 var od = new api.SizeRange.fromJson(o.toJson());

3283 checkSizeRange(od);

3284 });

3285 });

3286

3287

3288 unittest.group("obj-schema-Table", () {

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

3290 var o = buildTable();

3291 var od = new api.Table.fromJson(o.toJson());

3292 checkTable(od);

3293 });

3294 });

3295

3296

3297 unittest.group("obj-schema-TableColumn", () {

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

3299 var o = buildTableColumn();

3300 var od = new api.TableColumn.fromJson(o.toJson());

3301 checkTableColumn(od);

3302 });

3303 });

3304

3305

3306 unittest.group("obj-schema-TablesListResponse", () {

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

3308 var o = buildTablesListResponse();

3309 var od = new api.TablesListResponse.fromJson(o.toJson());

3310 checkTablesListResponse(od);

3311 });

3312 });

3313

3314

3315 unittest.group("obj-schema-Tags", () {

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

3317 var o = buildTags();

3318 var od = new api.Tags.fromJson(o.toJson());

3319 checkTags(od);

3320 });

3321 });

3322

3323

3324 unittest.group("obj-schema-ValueRange", () {

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

3326 var o = buildValueRange();

3327 var od = new api.ValueRange.fromJson(o.toJson());

3328 checkValueRange(od);

3329 });

3330 });

3331

3332

3333 unittest.group("obj-schema-VectorStyle", () {

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

3335 var o = buildVectorStyle();

3336 var od = new api.VectorStyle.fromJson(o.toJson());

3337 checkVectorStyle(od);

3338 });

3339 });

3340

3341

3342 unittest.group("obj-schema-ZoomLevels", () {

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

3344 var o = buildZoomLevels();

3345 var od = new api.ZoomLevels.fromJson(o.toJson());

3346 checkZoomLevels(od);

3347 });

3348 });

3349

3350

3351 unittest.group("resource-AssetsResourceApi", () {

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

3353

3354 var mock = new HttpServerMock();

3355 api.AssetsResourceApi res = new api.MapsengineApi(mock).assets;

3356 var arg_id = "foo";

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

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

3359 var pathOffset = 0;

3360 var index;

3361 var subPart;

3362 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3363 pathOffset += 1;

3364 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3365 pathOffset += 14;

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

3367 pathOffset += 7;

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

3369 pathOffset = path.length;

3370 unittest.expect(subPart, unittest.equals("$arg_id"));

3371

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

3373 var queryOffset = 0;

3374 var queryMap = {};

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

3376 parseBool(n) {

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

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

3379 if (n == null) return null;

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

3381 }

3382 if (query.length > 0) {

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

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

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

3386 }

3387 }

3388

3389

3390 var h = {

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

3392 };

3393 var resp = convert.JSON.encode(buildAsset());

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

3395 }), true);

3396 res.get(arg_id).then(unittest.expectAsync(((api.Asset response) {

3397 checkAsset(response);

3398 })));

3399 });

3400

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

3402

3403 var mock = new HttpServerMock();

3404 api.AssetsResourceApi res = new api.MapsengineApi(mock).assets;

3405 var arg_bbox = "foo";

3406 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

3407 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

3408 var arg_creatorEmail = "foo";

3409 var arg_maxResults = 42;

3410 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

3411 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

3412 var arg_pageToken = "foo";

3413 var arg_projectId = "foo";

3414 var arg_role = "foo";

3415 var arg_search = "foo";

3416 var arg_tags = "foo";

3417 var arg_type = "foo";

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

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

3420 var pathOffset = 0;

3421 var index;

3422 var subPart;

3423 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3424 pathOffset += 1;

3425 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3426 pathOffset += 14;

3427 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("assets"));

3428 pathOffset += 6;

3429

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

3431 var queryOffset = 0;

3432 var queryMap = {};

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

3434 parseBool(n) {

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

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

3437 if (n == null) return null;

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

3439 }

3440 if (query.length > 0) {

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

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

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

3444 }

3445 }

3446 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

3447 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

3448 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

3449 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

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

3451 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

3452 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

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

3454 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

3455 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

3456 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

3457 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

3458 unittest.expect(queryMap["type"].first, unittest.equals(arg_type));

3459

3460

3461 var h = {

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

3463 };

3464 var resp = convert.JSON.encode(buildAssetsListResponse());

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

3466 }), true);

3467 res.list(bbox: arg_bbox, createdAfter: arg_createdAfter, createdBefore: ar g_createdBefore, creatorEmail: arg_creatorEmail, maxResults: arg_maxResults, mod ifiedAfter: arg_modifiedAfter, modifiedBefore: arg_modifiedBefore, pageToken: ar g_pageToken, projectId: arg_projectId, role: arg_role, search: arg_search, tags: arg_tags, type: arg_type).then(unittest.expectAsync(((api.AssetsListResponse re sponse) {

3468 checkAssetsListResponse(response);

3469 })));

3470 });

3471

3472 });

3473

3474

3475 unittest.group("resource-AssetsParentsResourceApi", () {

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

3477

3478 var mock = new HttpServerMock();

3479 api.AssetsParentsResourceApi res = new api.MapsengineApi(mock).assets.pare nts;

3480 var arg_id = "foo";

3481 var arg_maxResults = 42;

3482 var arg_pageToken = "foo";

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

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

3485 var pathOffset = 0;

3486 var index;

3487 var subPart;

3488 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3489 pathOffset += 1;

3490 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3491 pathOffset += 14;

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

3493 pathOffset += 7;

3494 index = path.indexOf("/parents", pathOffset);

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

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

3497 pathOffset = index;

3498 unittest.expect(subPart, unittest.equals("$arg_id"));

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

3500 pathOffset += 8;

3501

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

3503 var queryOffset = 0;

3504 var queryMap = {};

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

3506 parseBool(n) {

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

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

3509 if (n == null) return null;

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

3511 }

3512 if (query.length > 0) {

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

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

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

3516 }

3517 }

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

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

3520

3521

3522 var h = {

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

3524 };

3525 var resp = convert.JSON.encode(buildParentsListResponse());

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

3527 }), true);

3528 res.list(arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken).the n(unittest.expectAsync(((api.ParentsListResponse response) {

3529 checkParentsListResponse(response);

3530 })));

3531 });

3532

3533 });

3534

3535

3536 unittest.group("resource-AssetsPermissionsResourceApi", () {

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

3538

3539 var mock = new HttpServerMock();

3540 api.AssetsPermissionsResourceApi res = new api.MapsengineApi(mock).assets. permissions;

3541 var arg_id = "foo";

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

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

3544 var pathOffset = 0;

3545 var index;

3546 var subPart;

3547 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3548 pathOffset += 1;

3549 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3550 pathOffset += 14;

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

3552 pathOffset += 7;

3553 index = path.indexOf("/permissions", pathOffset);

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

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

3556 pathOffset = index;

3557 unittest.expect(subPart, unittest.equals("$arg_id"));

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

3559 pathOffset += 12;

3560

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

3562 var queryOffset = 0;

3563 var queryMap = {};

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

3565 parseBool(n) {

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

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

3568 if (n == null) return null;

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

3570 }

3571 if (query.length > 0) {

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

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

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

3575 }

3576 }

3577

3578

3579 var h = {

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

3581 };

3582 var resp = convert.JSON.encode(buildPermissionsListResponse());

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

3584 }), true);

3585 res.list(arg_id).then(unittest.expectAsync(((api.PermissionsListResponse r esponse) {

3586 checkPermissionsListResponse(response);

3587 })));

3588 });

3589

3590 });

3591

3592

3593 unittest.group("resource-LayersResourceApi", () {

3594 unittest.test("method--cancelProcessing", () {

3595

3596 var mock = new HttpServerMock();

3597 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3598 var arg_id = "foo";

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

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

3601 var pathOffset = 0;

3602 var index;

3603 var subPart;

3604 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3605 pathOffset += 1;

3606 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3607 pathOffset += 14;

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

3609 pathOffset += 7;

3610 index = path.indexOf("/cancelProcessing", pathOffset);

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

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

3613 pathOffset = index;

3614 unittest.expect(subPart, unittest.equals("$arg_id"));

3615 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/cancelProcessing"));

3616 pathOffset += 17;

3617

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

3619 var queryOffset = 0;

3620 var queryMap = {};

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

3622 parseBool(n) {

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

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

3625 if (n == null) return null;

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

3627 }

3628 if (query.length > 0) {

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

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

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

3632 }

3633 }

3634

3635

3636 var h = {

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

3638 };

3639 var resp = convert.JSON.encode(buildProcessResponse());

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

3641 }), true);

3642 res.cancelProcessing(arg_id).then(unittest.expectAsync(((api.ProcessRespon se response) {

3643 checkProcessResponse(response);

3644 })));

3645 });

3646

3647 unittest.test("method--create", () {

3648

3649 var mock = new HttpServerMock();

3650 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3651 var arg_request = buildLayer();

3652 var arg_process_1 = true;

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

3654 var obj = new api.Layer.fromJson(json);

3655 checkLayer(obj);

3656

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

3658 var pathOffset = 0;

3659 var index;

3660 var subPart;

3661 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3662 pathOffset += 1;

3663 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3664 pathOffset += 14;

3665 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("layers"));

3666 pathOffset += 6;

3667

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

3669 var queryOffset = 0;

3670 var queryMap = {};

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

3672 parseBool(n) {

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

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

3675 if (n == null) return null;

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

3677 }

3678 if (query.length > 0) {

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

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

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

3682 }

3683 }

3684 unittest.expect(queryMap["process"].first, unittest.equals("$arg_process _1"));

3685

3686

3687 var h = {

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

3689 };

3690 var resp = convert.JSON.encode(buildLayer());

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

3692 }), true);

3693 res.create(arg_request, process_1: arg_process_1).then(unittest.expectAsyn c(((api.Layer response) {

3694 checkLayer(response);

3695 })));

3696 });

3697

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

3699

3700 var mock = new HttpServerMock();

3701 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3702 var arg_id = "foo";

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

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

3705 var pathOffset = 0;

3706 var index;

3707 var subPart;

3708 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3709 pathOffset += 1;

3710 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3711 pathOffset += 14;

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

3713 pathOffset += 7;

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

3715 pathOffset = path.length;

3716 unittest.expect(subPart, unittest.equals("$arg_id"));

3717

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

3719 var queryOffset = 0;

3720 var queryMap = {};

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

3722 parseBool(n) {

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

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

3725 if (n == null) return null;

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

3727 }

3728 if (query.length > 0) {

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

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

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

3732 }

3733 }

3734

3735

3736 var h = {

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

3738 };

3739 var resp = "";

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

3741 }), true);

3742 res.delete(arg_id).then(unittest.expectAsync((_) {}));

3743 });

3744

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

3746

3747 var mock = new HttpServerMock();

3748 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3749 var arg_id = "foo";

3750 var arg_version = "foo";

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

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

3753 var pathOffset = 0;

3754 var index;

3755 var subPart;

3756 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3757 pathOffset += 1;

3758 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3759 pathOffset += 14;

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

3761 pathOffset += 7;

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

3763 pathOffset = path.length;

3764 unittest.expect(subPart, unittest.equals("$arg_id"));

3765

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

3767 var queryOffset = 0;

3768 var queryMap = {};

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

3770 parseBool(n) {

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

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

3773 if (n == null) return null;

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

3775 }

3776 if (query.length > 0) {

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

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

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

3780 }

3781 }

3782 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

3783

3784

3785 var h = {

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

3787 };

3788 var resp = convert.JSON.encode(buildLayer());

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

3790 }), true);

3791 res.get(arg_id, version: arg_version).then(unittest.expectAsync(((api.Laye r response) {

3792 checkLayer(response);

3793 })));

3794 });

3795

3796 unittest.test("method--getPublished", () {

3797

3798 var mock = new HttpServerMock();

3799 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3800 var arg_id = "foo";

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

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

3803 var pathOffset = 0;

3804 var index;

3805 var subPart;

3806 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3807 pathOffset += 1;

3808 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3809 pathOffset += 14;

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

3811 pathOffset += 7;

3812 index = path.indexOf("/published", pathOffset);

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

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

3815 pathOffset = index;

3816 unittest.expect(subPart, unittest.equals("$arg_id"));

3817 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/published"));

3818 pathOffset += 10;

3819

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

3821 var queryOffset = 0;

3822 var queryMap = {};

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

3824 parseBool(n) {

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

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

3827 if (n == null) return null;

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

3829 }

3830 if (query.length > 0) {

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

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

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

3834 }

3835 }

3836

3837

3838 var h = {

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

3840 };

3841 var resp = convert.JSON.encode(buildPublishedLayer());

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

3843 }), true);

3844 res.getPublished(arg_id).then(unittest.expectAsync(((api.PublishedLayer re sponse) {

3845 checkPublishedLayer(response);

3846 })));

3847 });

3848

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

3850

3851 var mock = new HttpServerMock();

3852 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3853 var arg_bbox = "foo";

3854 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

3855 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

3856 var arg_creatorEmail = "foo";

3857 var arg_maxResults = 42;

3858 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

3859 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

3860 var arg_pageToken = "foo";

3861 var arg_processingStatus = "foo";

3862 var arg_projectId = "foo";

3863 var arg_role = "foo";

3864 var arg_search = "foo";

3865 var arg_tags = "foo";

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

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

3868 var pathOffset = 0;

3869 var index;

3870 var subPart;

3871 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3872 pathOffset += 1;

3873 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3874 pathOffset += 14;

3875 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("layers"));

3876 pathOffset += 6;

3877

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

3879 var queryOffset = 0;

3880 var queryMap = {};

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

3882 parseBool(n) {

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

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

3885 if (n == null) return null;

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

3887 }

3888 if (query.length > 0) {

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

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

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

3892 }

3893 }

3894 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

3895 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

3896 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

3897 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

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

3899 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

3900 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

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

3902 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

3903 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

3904 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

3905 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

3906 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

3907

3908

3909 var h = {

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

3911 };

3912 var resp = convert.JSON.encode(buildLayersListResponse());

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

3914 }), true);

3915 res.list(bbox: arg_bbox, createdAfter: arg_createdAfter, createdBefore: ar g_createdBefore, creatorEmail: arg_creatorEmail, maxResults: arg_maxResults, mod ifiedAfter: arg_modifiedAfter, modifiedBefore: arg_modifiedBefore, pageToken: ar g_pageToken, processingStatus: arg_processingStatus, projectId: arg_projectId, r ole: arg_role, search: arg_search, tags: arg_tags).then(unittest.expectAsync(((a pi.LayersListResponse response) {

3916 checkLayersListResponse(response);

3917 })));

3918 });

3919

3920 unittest.test("method--listPublished", () {

3921

3922 var mock = new HttpServerMock();

3923 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3924 var arg_maxResults = 42;

3925 var arg_pageToken = "foo";

3926 var arg_projectId = "foo";

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

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

3929 var pathOffset = 0;

3930 var index;

3931 var subPart;

3932 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3933 pathOffset += 1;

3934 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3935 pathOffset += 14;

3936 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("layers/published"));

3937 pathOffset += 16;

3938

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

3940 var queryOffset = 0;

3941 var queryMap = {};

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

3943 parseBool(n) {

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

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

3946 if (n == null) return null;

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

3948 }

3949 if (query.length > 0) {

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

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

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

3953 }

3954 }

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

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

3957 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

3958

3959

3960 var h = {

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

3962 };

3963 var resp = convert.JSON.encode(buildPublishedLayersListResponse());

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

3965 }), true);

3966 res.listPublished(maxResults: arg_maxResults, pageToken: arg_pageToken, pr ojectId: arg_projectId).then(unittest.expectAsync(((api.PublishedLayersListRespo nse response) {

3967 checkPublishedLayersListResponse(response);

3968 })));

3969 });

3970

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

3972

3973 var mock = new HttpServerMock();

3974 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3975 var arg_request = buildLayer();

3976 var arg_id = "foo";

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

3978 var obj = new api.Layer.fromJson(json);

3979 checkLayer(obj);

3980

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

3982 var pathOffset = 0;

3983 var index;

3984 var subPart;

3985 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3986 pathOffset += 1;

3987 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

3988 pathOffset += 14;

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

3990 pathOffset += 7;

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

3992 pathOffset = path.length;

3993 unittest.expect(subPart, unittest.equals("$arg_id"));

3994

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

3996 var queryOffset = 0;

3997 var queryMap = {};

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

3999 parseBool(n) {

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

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

4002 if (n == null) return null;

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

4004 }

4005 if (query.length > 0) {

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

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

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

4009 }

4010 }

4011

4012

4013 var h = {

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

4015 };

4016 var resp = "";

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

4018 }), true);

4019 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

4020 });

4021

4022 unittest.test("method--process", () {

4023

4024 var mock = new HttpServerMock();

4025 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

4026 var arg_id = "foo";

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

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

4029 var pathOffset = 0;

4030 var index;

4031 var subPart;

4032 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4033 pathOffset += 1;

4034 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4035 pathOffset += 14;

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

4037 pathOffset += 7;

4038 index = path.indexOf("/process", pathOffset);

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

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

4041 pathOffset = index;

4042 unittest.expect(subPart, unittest.equals("$arg_id"));

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

4044 pathOffset += 8;

4045

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

4047 var queryOffset = 0;

4048 var queryMap = {};

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

4050 parseBool(n) {

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

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

4053 if (n == null) return null;

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

4055 }

4056 if (query.length > 0) {

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

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

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

4060 }

4061 }

4062

4063

4064 var h = {

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

4066 };

4067 var resp = convert.JSON.encode(buildProcessResponse());

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

4069 }), true);

4070 res.process(arg_id).then(unittest.expectAsync(((api.ProcessResponse respon se) {

4071 checkProcessResponse(response);

4072 })));

4073 });

4074

4075 unittest.test("method--publish", () {

4076

4077 var mock = new HttpServerMock();

4078 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

4079 var arg_id = "foo";

4080 var arg_force = true;

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

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

4083 var pathOffset = 0;

4084 var index;

4085 var subPart;

4086 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4087 pathOffset += 1;

4088 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4089 pathOffset += 14;

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

4091 pathOffset += 7;

4092 index = path.indexOf("/publish", pathOffset);

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

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

4095 pathOffset = index;

4096 unittest.expect(subPart, unittest.equals("$arg_id"));

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

4098 pathOffset += 8;

4099

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

4101 var queryOffset = 0;

4102 var queryMap = {};

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

4104 parseBool(n) {

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

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

4107 if (n == null) return null;

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

4109 }

4110 if (query.length > 0) {

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

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

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

4114 }

4115 }

4116 unittest.expect(queryMap["force"].first, unittest.equals("$arg_force"));

4117

4118

4119 var h = {

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

4121 };

4122 var resp = convert.JSON.encode(buildPublishResponse());

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

4124 }), true);

4125 res.publish(arg_id, force: arg_force).then(unittest.expectAsync(((api.Publ ishResponse response) {

4126 checkPublishResponse(response);

4127 })));

4128 });

4129

4130 unittest.test("method--unpublish", () {

4131

4132 var mock = new HttpServerMock();

4133 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

4134 var arg_id = "foo";

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

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

4137 var pathOffset = 0;

4138 var index;

4139 var subPart;

4140 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4141 pathOffset += 1;

4142 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4143 pathOffset += 14;

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

4145 pathOffset += 7;

4146 index = path.indexOf("/unpublish", pathOffset);

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

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

4149 pathOffset = index;

4150 unittest.expect(subPart, unittest.equals("$arg_id"));

4151 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/unpublish"));

4152 pathOffset += 10;

4153

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

4155 var queryOffset = 0;

4156 var queryMap = {};

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

4158 parseBool(n) {

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

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

4161 if (n == null) return null;

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

4163 }

4164 if (query.length > 0) {

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

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

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

4168 }

4169 }

4170

4171

4172 var h = {

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

4174 };

4175 var resp = convert.JSON.encode(buildPublishResponse());

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

4177 }), true);

4178 res.unpublish(arg_id).then(unittest.expectAsync(((api.PublishResponse resp onse) {

4179 checkPublishResponse(response);

4180 })));

4181 });

4182

4183 });

4184

4185

4186 unittest.group("resource-LayersParentsResourceApi", () {

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

4188

4189 var mock = new HttpServerMock();

4190 api.LayersParentsResourceApi res = new api.MapsengineApi(mock).layers.pare nts;

4191 var arg_id = "foo";

4192 var arg_maxResults = 42;

4193 var arg_pageToken = "foo";

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

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

4196 var pathOffset = 0;

4197 var index;

4198 var subPart;

4199 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4200 pathOffset += 1;

4201 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4202 pathOffset += 14;

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

4204 pathOffset += 7;

4205 index = path.indexOf("/parents", pathOffset);

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

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

4208 pathOffset = index;

4209 unittest.expect(subPart, unittest.equals("$arg_id"));

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

4211 pathOffset += 8;

4212

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

4214 var queryOffset = 0;

4215 var queryMap = {};

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

4217 parseBool(n) {

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

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

4220 if (n == null) return null;

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

4222 }

4223 if (query.length > 0) {

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

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

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

4227 }

4228 }

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

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

4231

4232

4233 var h = {

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

4235 };

4236 var resp = convert.JSON.encode(buildParentsListResponse());

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

4238 }), true);

4239 res.list(arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken).the n(unittest.expectAsync(((api.ParentsListResponse response) {

4240 checkParentsListResponse(response);

4241 })));

4242 });

4243

4244 });

4245

4246

4247 unittest.group("resource-LayersPermissionsResourceApi", () {

4248 unittest.test("method--batchDelete", () {

4249

4250 var mock = new HttpServerMock();

4251 api.LayersPermissionsResourceApi res = new api.MapsengineApi(mock).layers. permissions;

4252 var arg_request = buildPermissionsBatchDeleteRequest();

4253 var arg_id = "foo";

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

4255 var obj = new api.PermissionsBatchDeleteRequest.fromJson(json);

4256 checkPermissionsBatchDeleteRequest(obj);

4257

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

4259 var pathOffset = 0;

4260 var index;

4261 var subPart;

4262 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4263 pathOffset += 1;

4264 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4265 pathOffset += 14;

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

4267 pathOffset += 7;

4268 index = path.indexOf("/permissions/batchDelete", pathOffset);

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

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

4271 pathOffset = index;

4272 unittest.expect(subPart, unittest.equals("$arg_id"));

4273 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchDelete"));

4274 pathOffset += 24;

4275

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

4277 var queryOffset = 0;

4278 var queryMap = {};

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

4280 parseBool(n) {

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

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

4283 if (n == null) return null;

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

4285 }

4286 if (query.length > 0) {

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

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

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

4290 }

4291 }

4292

4293

4294 var h = {

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

4296 };

4297 var resp = convert.JSON.encode(buildPermissionsBatchDeleteResponse());

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

4299 }), true);

4300 res.batchDelete(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchDeleteResponse response) {

4301 checkPermissionsBatchDeleteResponse(response);

4302 })));

4303 });

4304

4305 unittest.test("method--batchUpdate", () {

4306

4307 var mock = new HttpServerMock();

4308 api.LayersPermissionsResourceApi res = new api.MapsengineApi(mock).layers. permissions;

4309 var arg_request = buildPermissionsBatchUpdateRequest();

4310 var arg_id = "foo";

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

4312 var obj = new api.PermissionsBatchUpdateRequest.fromJson(json);

4313 checkPermissionsBatchUpdateRequest(obj);

4314

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

4316 var pathOffset = 0;

4317 var index;

4318 var subPart;

4319 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4320 pathOffset += 1;

4321 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4322 pathOffset += 14;

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

4324 pathOffset += 7;

4325 index = path.indexOf("/permissions/batchUpdate", pathOffset);

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

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

4328 pathOffset = index;

4329 unittest.expect(subPart, unittest.equals("$arg_id"));

4330 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchUpdate"));

4331 pathOffset += 24;

4332

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

4334 var queryOffset = 0;

4335 var queryMap = {};

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

4337 parseBool(n) {

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

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

4340 if (n == null) return null;

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

4342 }

4343 if (query.length > 0) {

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

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

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

4347 }

4348 }

4349

4350

4351 var h = {

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

4353 };

4354 var resp = convert.JSON.encode(buildPermissionsBatchUpdateResponse());

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

4356 }), true);

4357 res.batchUpdate(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchUpdateResponse response) {

4358 checkPermissionsBatchUpdateResponse(response);

4359 })));

4360 });

4361

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

4363

4364 var mock = new HttpServerMock();

4365 api.LayersPermissionsResourceApi res = new api.MapsengineApi(mock).layers. permissions;

4366 var arg_id = "foo";

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

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

4369 var pathOffset = 0;

4370 var index;

4371 var subPart;

4372 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4373 pathOffset += 1;

4374 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4375 pathOffset += 14;

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

4377 pathOffset += 7;

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

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

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

4381 pathOffset = index;

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

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

4384 pathOffset += 12;

4385

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

4387 var queryOffset = 0;

4388 var queryMap = {};

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

4390 parseBool(n) {

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

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

4393 if (n == null) return null;

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

4395 }

4396 if (query.length > 0) {

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

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

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

4400 }

4401 }

4402

4403

4404 var h = {

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

4406 };

4407 var resp = convert.JSON.encode(buildPermissionsListResponse());

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

4409 }), true);

4410 res.list(arg_id).then(unittest.expectAsync(((api.PermissionsListResponse r esponse) {

4411 checkPermissionsListResponse(response);

4412 })));

4413 });

4414

4415 });

4416

4417

4418 unittest.group("resource-MapsResourceApi", () {

4419 unittest.test("method--create", () {

4420

4421 var mock = new HttpServerMock();

4422 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4423 var arg_request = buildMap();

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

4425 var obj = new api.Map.fromJson(json);

4426 checkMap(obj);

4427

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

4429 var pathOffset = 0;

4430 var index;

4431 var subPart;

4432 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4433 pathOffset += 1;

4434 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4435 pathOffset += 14;

4436 unittest.expect(path.substring(pathOffset, pathOffset + 4), unittest.equ als("maps"));

4437 pathOffset += 4;

4438

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

4440 var queryOffset = 0;

4441 var queryMap = {};

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

4443 parseBool(n) {

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

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

4446 if (n == null) return null;

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

4448 }

4449 if (query.length > 0) {

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

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

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

4453 }

4454 }

4455

4456

4457 var h = {

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

4459 };

4460 var resp = convert.JSON.encode(buildMap());

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

4462 }), true);

4463 res.create(arg_request).then(unittest.expectAsync(((api.Map response) {

4464 checkMap(response);

4465 })));

4466 });

4467

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

4469

4470 var mock = new HttpServerMock();

4471 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4472 var arg_id = "foo";

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

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

4475 var pathOffset = 0;

4476 var index;

4477 var subPart;

4478 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4479 pathOffset += 1;

4480 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4481 pathOffset += 14;

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

4483 pathOffset += 5;

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

4485 pathOffset = path.length;

4486 unittest.expect(subPart, unittest.equals("$arg_id"));

4487

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

4489 var queryOffset = 0;

4490 var queryMap = {};

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

4492 parseBool(n) {

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

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

4495 if (n == null) return null;

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

4497 }

4498 if (query.length > 0) {

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

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

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

4502 }

4503 }

4504

4505

4506 var h = {

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

4508 };

4509 var resp = "";

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

4511 }), true);

4512 res.delete(arg_id).then(unittest.expectAsync((_) {}));

4513 });

4514

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

4516

4517 var mock = new HttpServerMock();

4518 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4519 var arg_id = "foo";

4520 var arg_version = "foo";

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

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

4523 var pathOffset = 0;

4524 var index;

4525 var subPart;

4526 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4527 pathOffset += 1;

4528 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4529 pathOffset += 14;

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

4531 pathOffset += 5;

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

4533 pathOffset = path.length;

4534 unittest.expect(subPart, unittest.equals("$arg_id"));

4535

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

4537 var queryOffset = 0;

4538 var queryMap = {};

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

4540 parseBool(n) {

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

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

4543 if (n == null) return null;

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

4545 }

4546 if (query.length > 0) {

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

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

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

4550 }

4551 }

4552 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

4553

4554

4555 var h = {

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

4557 };

4558 var resp = convert.JSON.encode(buildMap());

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

4560 }), true);

4561 res.get(arg_id, version: arg_version).then(unittest.expectAsync(((api.Map response) {

4562 checkMap(response);

4563 })));

4564 });

4565

4566 unittest.test("method--getPublished", () {

4567

4568 var mock = new HttpServerMock();

4569 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4570 var arg_id = "foo";

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

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

4573 var pathOffset = 0;

4574 var index;

4575 var subPart;

4576 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4577 pathOffset += 1;

4578 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4579 pathOffset += 14;

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

4581 pathOffset += 5;

4582 index = path.indexOf("/published", pathOffset);

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

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

4585 pathOffset = index;

4586 unittest.expect(subPart, unittest.equals("$arg_id"));

4587 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/published"));

4588 pathOffset += 10;

4589

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

4591 var queryOffset = 0;

4592 var queryMap = {};

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

4594 parseBool(n) {

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

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

4597 if (n == null) return null;

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

4599 }

4600 if (query.length > 0) {

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

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

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

4604 }

4605 }

4606

4607

4608 var h = {

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

4610 };

4611 var resp = convert.JSON.encode(buildPublishedMap());

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

4613 }), true);

4614 res.getPublished(arg_id).then(unittest.expectAsync(((api.PublishedMap resp onse) {

4615 checkPublishedMap(response);

4616 })));

4617 });

4618

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

4620

4621 var mock = new HttpServerMock();

4622 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4623 var arg_bbox = "foo";

4624 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

4625 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

4626 var arg_creatorEmail = "foo";

4627 var arg_maxResults = 42;

4628 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

4629 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

4630 var arg_pageToken = "foo";

4631 var arg_processingStatus = "foo";

4632 var arg_projectId = "foo";

4633 var arg_role = "foo";

4634 var arg_search = "foo";

4635 var arg_tags = "foo";

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

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

4638 var pathOffset = 0;

4639 var index;

4640 var subPart;

4641 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4642 pathOffset += 1;

4643 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4644 pathOffset += 14;

4645 unittest.expect(path.substring(pathOffset, pathOffset + 4), unittest.equ als("maps"));

4646 pathOffset += 4;

4647

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

4649 var queryOffset = 0;

4650 var queryMap = {};

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

4652 parseBool(n) {

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

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

4655 if (n == null) return null;

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

4657 }

4658 if (query.length > 0) {

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

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

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

4662 }

4663 }

4664 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

4665 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

4666 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

4667 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

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

4669 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

4670 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

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

4672 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

4673 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

4674 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

4675 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

4676 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

4677

4678

4679 var h = {

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

4681 };

4682 var resp = convert.JSON.encode(buildMapsListResponse());

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

4684 }), true);

4685 res.list(bbox: arg_bbox, createdAfter: arg_createdAfter, createdBefore: ar g_createdBefore, creatorEmail: arg_creatorEmail, maxResults: arg_maxResults, mod ifiedAfter: arg_modifiedAfter, modifiedBefore: arg_modifiedBefore, pageToken: ar g_pageToken, processingStatus: arg_processingStatus, projectId: arg_projectId, r ole: arg_role, search: arg_search, tags: arg_tags).then(unittest.expectAsync(((a pi.MapsListResponse response) {

4686 checkMapsListResponse(response);

4687 })));

4688 });

4689

4690 unittest.test("method--listPublished", () {

4691

4692 var mock = new HttpServerMock();

4693 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4694 var arg_maxResults = 42;

4695 var arg_pageToken = "foo";

4696 var arg_projectId = "foo";

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

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

4699 var pathOffset = 0;

4700 var index;

4701 var subPart;

4702 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4703 pathOffset += 1;

4704 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4705 pathOffset += 14;

4706 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("maps/published"));

4707 pathOffset += 14;

4708

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

4710 var queryOffset = 0;

4711 var queryMap = {};

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

4713 parseBool(n) {

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

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

4716 if (n == null) return null;

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

4718 }

4719 if (query.length > 0) {

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

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

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

4723 }

4724 }

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

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

4727 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

4728

4729

4730 var h = {

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

4732 };

4733 var resp = convert.JSON.encode(buildPublishedMapsListResponse());

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

4735 }), true);

4736 res.listPublished(maxResults: arg_maxResults, pageToken: arg_pageToken, pr ojectId: arg_projectId).then(unittest.expectAsync(((api.PublishedMapsListRespons e response) {

4737 checkPublishedMapsListResponse(response);

4738 })));

4739 });

4740

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

4742

4743 var mock = new HttpServerMock();

4744 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4745 var arg_request = buildMap();

4746 var arg_id = "foo";

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

4748 var obj = new api.Map.fromJson(json);

4749 checkMap(obj);

4750

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

4752 var pathOffset = 0;

4753 var index;

4754 var subPart;

4755 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4756 pathOffset += 1;

4757 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4758 pathOffset += 14;

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

4760 pathOffset += 5;

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

4762 pathOffset = path.length;

4763 unittest.expect(subPart, unittest.equals("$arg_id"));

4764

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

4766 var queryOffset = 0;

4767 var queryMap = {};

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

4769 parseBool(n) {

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

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

4772 if (n == null) return null;

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

4774 }

4775 if (query.length > 0) {

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

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

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

4779 }

4780 }

4781

4782

4783 var h = {

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

4785 };

4786 var resp = "";

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

4788 }), true);

4789 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

4790 });

4791

4792 unittest.test("method--publish", () {

4793

4794 var mock = new HttpServerMock();

4795 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4796 var arg_id = "foo";

4797 var arg_force = true;

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

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

4800 var pathOffset = 0;

4801 var index;

4802 var subPart;

4803 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4804 pathOffset += 1;

4805 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4806 pathOffset += 14;

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

4808 pathOffset += 5;

4809 index = path.indexOf("/publish", pathOffset);

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

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

4812 pathOffset = index;

4813 unittest.expect(subPart, unittest.equals("$arg_id"));

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

4815 pathOffset += 8;

4816

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

4818 var queryOffset = 0;

4819 var queryMap = {};

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

4821 parseBool(n) {

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

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

4824 if (n == null) return null;

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

4826 }

4827 if (query.length > 0) {

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

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

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

4831 }

4832 }

4833 unittest.expect(queryMap["force"].first, unittest.equals("$arg_force"));

4834

4835

4836 var h = {

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

4838 };

4839 var resp = convert.JSON.encode(buildPublishResponse());

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

4841 }), true);

4842 res.publish(arg_id, force: arg_force).then(unittest.expectAsync(((api.Publ ishResponse response) {

4843 checkPublishResponse(response);

4844 })));

4845 });

4846

4847 unittest.test("method--unpublish", () {

4848

4849 var mock = new HttpServerMock();

4850 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4851 var arg_id = "foo";

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

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

4854 var pathOffset = 0;

4855 var index;

4856 var subPart;

4857 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4858 pathOffset += 1;

4859 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4860 pathOffset += 14;

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

4862 pathOffset += 5;

4863 index = path.indexOf("/unpublish", pathOffset);

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

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

4866 pathOffset = index;

4867 unittest.expect(subPart, unittest.equals("$arg_id"));

4868 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/unpublish"));

4869 pathOffset += 10;

4870

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

4872 var queryOffset = 0;

4873 var queryMap = {};

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

4875 parseBool(n) {

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

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

4878 if (n == null) return null;

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

4880 }

4881 if (query.length > 0) {

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

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

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

4885 }

4886 }

4887

4888

4889 var h = {

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

4891 };

4892 var resp = convert.JSON.encode(buildPublishResponse());

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

4894 }), true);

4895 res.unpublish(arg_id).then(unittest.expectAsync(((api.PublishResponse resp onse) {

4896 checkPublishResponse(response);

4897 })));

4898 });

4899

4900 });

4901

4902

4903 unittest.group("resource-MapsPermissionsResourceApi", () {

4904 unittest.test("method--batchDelete", () {

4905

4906 var mock = new HttpServerMock();

4907 api.MapsPermissionsResourceApi res = new api.MapsengineApi(mock).maps.perm issions;

4908 var arg_request = buildPermissionsBatchDeleteRequest();

4909 var arg_id = "foo";

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

4911 var obj = new api.PermissionsBatchDeleteRequest.fromJson(json);

4912 checkPermissionsBatchDeleteRequest(obj);

4913

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

4915 var pathOffset = 0;

4916 var index;

4917 var subPart;

4918 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4919 pathOffset += 1;

4920 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4921 pathOffset += 14;

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

4923 pathOffset += 5;

4924 index = path.indexOf("/permissions/batchDelete", pathOffset);

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

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

4927 pathOffset = index;

4928 unittest.expect(subPart, unittest.equals("$arg_id"));

4929 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchDelete"));

4930 pathOffset += 24;

4931

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

4933 var queryOffset = 0;

4934 var queryMap = {};

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

4936 parseBool(n) {

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

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

4939 if (n == null) return null;

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

4941 }

4942 if (query.length > 0) {

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

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

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

4946 }

4947 }

4948

4949

4950 var h = {

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

4952 };

4953 var resp = convert.JSON.encode(buildPermissionsBatchDeleteResponse());

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

4955 }), true);

4956 res.batchDelete(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchDeleteResponse response) {

4957 checkPermissionsBatchDeleteResponse(response);

4958 })));

4959 });

4960

4961 unittest.test("method--batchUpdate", () {

4962

4963 var mock = new HttpServerMock();

4964 api.MapsPermissionsResourceApi res = new api.MapsengineApi(mock).maps.perm issions;

4965 var arg_request = buildPermissionsBatchUpdateRequest();

4966 var arg_id = "foo";

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

4968 var obj = new api.PermissionsBatchUpdateRequest.fromJson(json);

4969 checkPermissionsBatchUpdateRequest(obj);

4970

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

4972 var pathOffset = 0;

4973 var index;

4974 var subPart;

4975 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4976 pathOffset += 1;

4977 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

4978 pathOffset += 14;

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

4980 pathOffset += 5;

4981 index = path.indexOf("/permissions/batchUpdate", pathOffset);

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

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

4984 pathOffset = index;

4985 unittest.expect(subPart, unittest.equals("$arg_id"));

4986 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchUpdate"));

4987 pathOffset += 24;

4988

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

4990 var queryOffset = 0;

4991 var queryMap = {};

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

4993 parseBool(n) {

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

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

4996 if (n == null) return null;

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

4998 }

4999 if (query.length > 0) {

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

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

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

5003 }

5004 }

5005

5006

5007 var h = {

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

5009 };

5010 var resp = convert.JSON.encode(buildPermissionsBatchUpdateResponse());

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

5012 }), true);

5013 res.batchUpdate(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchUpdateResponse response) {

5014 checkPermissionsBatchUpdateResponse(response);

5015 })));

5016 });

5017

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

5019

5020 var mock = new HttpServerMock();

5021 api.MapsPermissionsResourceApi res = new api.MapsengineApi(mock).maps.perm issions;

5022 var arg_id = "foo";

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

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

5025 var pathOffset = 0;

5026 var index;

5027 var subPart;

5028 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5029 pathOffset += 1;

5030 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5031 pathOffset += 14;

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

5033 pathOffset += 5;

5034 index = path.indexOf("/permissions", pathOffset);

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

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

5037 pathOffset = index;

5038 unittest.expect(subPart, unittest.equals("$arg_id"));

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

5040 pathOffset += 12;

5041

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

5043 var queryOffset = 0;

5044 var queryMap = {};

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

5046 parseBool(n) {

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

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

5049 if (n == null) return null;

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

5051 }

5052 if (query.length > 0) {

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

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

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

5056 }

5057 }

5058

5059

5060 var h = {

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

5062 };

5063 var resp = convert.JSON.encode(buildPermissionsListResponse());

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

5065 }), true);

5066 res.list(arg_id).then(unittest.expectAsync(((api.PermissionsListResponse r esponse) {

5067 checkPermissionsListResponse(response);

5068 })));

5069 });

5070

5071 });

5072

5073

5074 unittest.group("resource-ProjectsResourceApi", () {

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

5076

5077 var mock = new HttpServerMock();

5078 api.ProjectsResourceApi res = new api.MapsengineApi(mock).projects;

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

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

5081 var pathOffset = 0;

5082 var index;

5083 var subPart;

5084 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5085 pathOffset += 1;

5086 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5087 pathOffset += 14;

5088 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("projects"));

5089 pathOffset += 8;

5090

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

5092 var queryOffset = 0;

5093 var queryMap = {};

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

5095 parseBool(n) {

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

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

5098 if (n == null) return null;

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

5100 }

5101 if (query.length > 0) {

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

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

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

5105 }

5106 }

5107

5108

5109 var h = {

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

5111 };

5112 var resp = convert.JSON.encode(buildProjectsListResponse());

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

5114 }), true);

5115 res.list().then(unittest.expectAsync(((api.ProjectsListResponse response) {

5116 checkProjectsListResponse(response);

5117 })));

5118 });

5119

5120 });

5121

5122

5123 unittest.group("resource-ProjectsIconsResourceApi", () {

5124 unittest.test("method--create", () {

5125 // TODO: Implement tests for media upload;

5126 // TODO: Implement tests for media download;

5127

5128 var mock = new HttpServerMock();

5129 api.ProjectsIconsResourceApi res = new api.MapsengineApi(mock).projects.ic ons;

5130 var arg_request = buildIcon();

5131 var arg_projectId = "foo";

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

5133 var obj = new api.Icon.fromJson(json);

5134 checkIcon(obj);

5135

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

5137 var pathOffset = 0;

5138 var index;

5139 var subPart;

5140 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5141 pathOffset += 1;

5142 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5143 pathOffset += 14;

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

5145 pathOffset += 9;

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

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

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

5149 pathOffset = index;

5150 unittest.expect(subPart, unittest.equals("$arg_projectId"));

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

5152 pathOffset += 6;

5153

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

5155 var queryOffset = 0;

5156 var queryMap = {};

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

5158 parseBool(n) {

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

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

5161 if (n == null) return null;

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

5163 }

5164 if (query.length > 0) {

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

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

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

5168 }

5169 }

5170

5171

5172 var h = {

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

5174 };

5175 var resp = convert.JSON.encode(buildIcon());

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

5177 }), true);

5178 res.create(arg_request, arg_projectId).then(unittest.expectAsync(((api.Ico n response) {

5179 checkIcon(response);

5180 })));

5181 });

5182

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

5184 // TODO: Implement tests for media upload;

5185 // TODO: Implement tests for media download;

5186

5187 var mock = new HttpServerMock();

5188 api.ProjectsIconsResourceApi res = new api.MapsengineApi(mock).projects.ic ons;

5189 var arg_projectId = "foo";

5190 var arg_id = "foo";

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

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

5193 var pathOffset = 0;

5194 var index;

5195 var subPart;

5196 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5197 pathOffset += 1;

5198 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5199 pathOffset += 14;

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

5201 pathOffset += 9;

5202 index = path.indexOf("/icons/", pathOffset);

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

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

5205 pathOffset = index;

5206 unittest.expect(subPart, unittest.equals("$arg_projectId"));

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

5208 pathOffset += 7;

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

5210 pathOffset = path.length;

5211 unittest.expect(subPart, unittest.equals("$arg_id"));

5212

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

5214 var queryOffset = 0;

5215 var queryMap = {};

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

5217 parseBool(n) {

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

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

5220 if (n == null) return null;

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

5222 }

5223 if (query.length > 0) {

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

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

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

5227 }

5228 }

5229

5230

5231 var h = {

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

5233 };

5234 var resp = convert.JSON.encode(buildIcon());

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

5236 }), true);

5237 res.get(arg_projectId, arg_id).then(unittest.expectAsync(((api.Icon respon se) {

5238 checkIcon(response);

5239 })));

5240 });

5241

5242 unittest.test("method--list", () {

5243

5244 var mock = new HttpServerMock();

5245 api.ProjectsIconsResourceApi res = new api.MapsengineApi(mock).projects.ic ons;

5246 var arg_projectId = "foo";

5247 var arg_maxResults = 42;

5248 var arg_pageToken = "foo";

5249 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5250 var path = (req.url).path;

5251 var pathOffset = 0;

5252 var index;

5253 var subPart;

5254 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5255 pathOffset += 1;

5256 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5257 pathOffset += 14;

5258 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("projects/"));

5259 pathOffset += 9;

5260 index = path.indexOf("/icons", pathOffset);

5261 unittest.expect(index >= 0, unittest.isTrue);

5262 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5263 pathOffset = index;

5264 unittest.expect(subPart, unittest.equals("$arg_projectId"));

5265 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/icons"));

5266 pathOffset += 6;

5267

5268 var query = (req.url).query;

5269 var queryOffset = 0;

5270 var queryMap = {};

5271 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5272 parseBool(n) {

5273 if (n == "true") return true;

5274 if (n == "false") return false;

5275 if (n == null) return null;

5276 throw new core.ArgumentError("Invalid boolean: $n");

5277 }

5278 if (query.length > 0) {

5279 for (var part in query.split("&")) {

5280 var keyvalue = part.split("=");

5281 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5282 }

5283 }

5284 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5285 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5286

5287

5288 var h = {

5289 "content-type" : "application/json; charset=utf-8",

5290 };

5291 var resp = convert.JSON.encode(buildIconsListResponse());

5292 return new async.Future.value(stringResponse(200, h, resp));

5293 }), true);

5294 res.list(arg_projectId, maxResults: arg_maxResults, pageToken: arg_pageTok en).then(unittest.expectAsync(((api.IconsListResponse response) {

5295 checkIconsListResponse(response);

5296 })));

5297 });

5298

5299 });

5300

5301

5302 unittest.group("resource-RasterCollectionsResourceApi", () {

5303 unittest.test("method--cancelProcessing", () {

5304

5305 var mock = new HttpServerMock();

5306 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

5307 var arg_id = "foo";

5308 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5309 var path = (req.url).path;

5310 var pathOffset = 0;

5311 var index;

5312 var subPart;

5313 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5314 pathOffset += 1;

5315 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5316 pathOffset += 14;

5317 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5318 pathOffset += 18;

5319 index = path.indexOf("/cancelProcessing", pathOffset);

5320 unittest.expect(index >= 0, unittest.isTrue);

5321 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5322 pathOffset = index;

5323 unittest.expect(subPart, unittest.equals("$arg_id"));

5324 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/cancelProcessing"));

5325 pathOffset += 17;

5326

5327 var query = (req.url).query;

5328 var queryOffset = 0;

5329 var queryMap = {};

5330 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5331 parseBool(n) {

5332 if (n == "true") return true;

5333 if (n == "false") return false;

5334 if (n == null) return null;

5335 throw new core.ArgumentError("Invalid boolean: $n");

5336 }

5337 if (query.length > 0) {

5338 for (var part in query.split("&")) {

5339 var keyvalue = part.split("=");

5340 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5341 }

5342 }

5343

5344

5345 var h = {

5346 "content-type" : "application/json; charset=utf-8",

5347 };

5348 var resp = convert.JSON.encode(buildProcessResponse());

5349 return new async.Future.value(stringResponse(200, h, resp));

5350 }), true);

5351 res.cancelProcessing(arg_id).then(unittest.expectAsync(((api.ProcessRespon se response) {

5352 checkProcessResponse(response);

5353 })));

5354 });

5355

5356 unittest.test("method--create", () {

5357

5358 var mock = new HttpServerMock();

5359 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

5360 var arg_request = buildRasterCollection();

5361 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5362 var obj = new api.RasterCollection.fromJson(json);

5363 checkRasterCollection(obj);

5364

5365 var path = (req.url).path;

5366 var pathOffset = 0;

5367 var index;

5368 var subPart;

5369 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5370 pathOffset += 1;

5371 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5372 pathOffset += 14;

5373 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("rasterCollections"));

5374 pathOffset += 17;

5375

5376 var query = (req.url).query;

5377 var queryOffset = 0;

5378 var queryMap = {};

5379 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5380 parseBool(n) {

5381 if (n == "true") return true;

5382 if (n == "false") return false;

5383 if (n == null) return null;

5384 throw new core.ArgumentError("Invalid boolean: $n");

5385 }

5386 if (query.length > 0) {

5387 for (var part in query.split("&")) {

5388 var keyvalue = part.split("=");

5389 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5390 }

5391 }

5392

5393

5394 var h = {

5395 "content-type" : "application/json; charset=utf-8",

5396 };

5397 var resp = convert.JSON.encode(buildRasterCollection());

5398 return new async.Future.value(stringResponse(200, h, resp));

5399 }), true);

5400 res.create(arg_request).then(unittest.expectAsync(((api.RasterCollection r esponse) {

5401 checkRasterCollection(response);

5402 })));

5403 });

5404

5405 unittest.test("method--delete", () {

5406

5407 var mock = new HttpServerMock();

5408 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

5409 var arg_id = "foo";

5410 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5411 var path = (req.url).path;

5412 var pathOffset = 0;

5413 var index;

5414 var subPart;

5415 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5416 pathOffset += 1;

5417 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5418 pathOffset += 14;

5419 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5420 pathOffset += 18;

5421 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5422 pathOffset = path.length;

5423 unittest.expect(subPart, unittest.equals("$arg_id"));

5424

5425 var query = (req.url).query;

5426 var queryOffset = 0;

5427 var queryMap = {};

5428 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5429 parseBool(n) {

5430 if (n == "true") return true;

5431 if (n == "false") return false;

5432 if (n == null) return null;

5433 throw new core.ArgumentError("Invalid boolean: $n");

5434 }

5435 if (query.length > 0) {

5436 for (var part in query.split("&")) {

5437 var keyvalue = part.split("=");

5438 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5439 }

5440 }

5441

5442

5443 var h = {

5444 "content-type" : "application/json; charset=utf-8",

5445 };

5446 var resp = "";

5447 return new async.Future.value(stringResponse(200, h, resp));

5448 }), true);

5449 res.delete(arg_id).then(unittest.expectAsync((_) {}));

5450 });

5451

5452 unittest.test("method--get", () {

5453

5454 var mock = new HttpServerMock();

5455 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

5456 var arg_id = "foo";

5457 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5458 var path = (req.url).path;

5459 var pathOffset = 0;

5460 var index;

5461 var subPart;

5462 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5463 pathOffset += 1;

5464 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5465 pathOffset += 14;

5466 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5467 pathOffset += 18;

5468 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5469 pathOffset = path.length;

5470 unittest.expect(subPart, unittest.equals("$arg_id"));

5471

5472 var query = (req.url).query;

5473 var queryOffset = 0;

5474 var queryMap = {};

5475 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5476 parseBool(n) {

5477 if (n == "true") return true;

5478 if (n == "false") return false;

5479 if (n == null) return null;

5480 throw new core.ArgumentError("Invalid boolean: $n");

5481 }

5482 if (query.length > 0) {

5483 for (var part in query.split("&")) {

5484 var keyvalue = part.split("=");

5485 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5486 }

5487 }

5488

5489

5490 var h = {

5491 "content-type" : "application/json; charset=utf-8",

5492 };

5493 var resp = convert.JSON.encode(buildRasterCollection());

5494 return new async.Future.value(stringResponse(200, h, resp));

5495 }), true);

5496 res.get(arg_id).then(unittest.expectAsync(((api.RasterCollection response) {

5497 checkRasterCollection(response);

5498 })));

5499 });

5500

5501 unittest.test("method--list", () {

5502

5503 var mock = new HttpServerMock();

5504 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

5505 var arg_bbox = "foo";

5506 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

5507 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

5508 var arg_creatorEmail = "foo";

5509 var arg_maxResults = 42;

5510 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

5511 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

5512 var arg_pageToken = "foo";

5513 var arg_processingStatus = "foo";

5514 var arg_projectId = "foo";

5515 var arg_role = "foo";

5516 var arg_search = "foo";

5517 var arg_tags = "foo";

5518 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5519 var path = (req.url).path;

5520 var pathOffset = 0;

5521 var index;

5522 var subPart;

5523 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5524 pathOffset += 1;

5525 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5526 pathOffset += 14;

5527 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("rasterCollections"));

5528 pathOffset += 17;

5529

5530 var query = (req.url).query;

5531 var queryOffset = 0;

5532 var queryMap = {};

5533 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5534 parseBool(n) {

5535 if (n == "true") return true;

5536 if (n == "false") return false;

5537 if (n == null) return null;

5538 throw new core.ArgumentError("Invalid boolean: $n");

5539 }

5540 if (query.length > 0) {

5541 for (var part in query.split("&")) {

5542 var keyvalue = part.split("=");

5543 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5544 }

5545 }

5546 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

5547 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

5548 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

5549 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

5550 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5551 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

5552 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

5553 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5554 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

5555 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

5556 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

5557 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

5558 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

5559

5560

5561 var h = {

5562 "content-type" : "application/json; charset=utf-8",

5563 };

5564 var resp = convert.JSON.encode(buildRasterCollectionsListResponse());

5565 return new async.Future.value(stringResponse(200, h, resp));

5566 }), true);

5567 res.list(bbox: arg_bbox, createdAfter: arg_createdAfter, createdBefore: ar g_createdBefore, creatorEmail: arg_creatorEmail, maxResults: arg_maxResults, mod ifiedAfter: arg_modifiedAfter, modifiedBefore: arg_modifiedBefore, pageToken: ar g_pageToken, processingStatus: arg_processingStatus, projectId: arg_projectId, r ole: arg_role, search: arg_search, tags: arg_tags).then(unittest.expectAsync(((a pi.RasterCollectionsListResponse response) {

5568 checkRasterCollectionsListResponse(response);

5569 })));

5570 });

5571

5572 unittest.test("method--patch", () {

5573

5574 var mock = new HttpServerMock();

5575 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

5576 var arg_request = buildRasterCollection();

5577 var arg_id = "foo";

5578 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5579 var obj = new api.RasterCollection.fromJson(json);

5580 checkRasterCollection(obj);

5581

5582 var path = (req.url).path;

5583 var pathOffset = 0;

5584 var index;

5585 var subPart;

5586 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5587 pathOffset += 1;

5588 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5589 pathOffset += 14;

5590 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5591 pathOffset += 18;

5592 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5593 pathOffset = path.length;

5594 unittest.expect(subPart, unittest.equals("$arg_id"));

5595

5596 var query = (req.url).query;

5597 var queryOffset = 0;

5598 var queryMap = {};

5599 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5600 parseBool(n) {

5601 if (n == "true") return true;

5602 if (n == "false") return false;

5603 if (n == null) return null;

5604 throw new core.ArgumentError("Invalid boolean: $n");

5605 }

5606 if (query.length > 0) {

5607 for (var part in query.split("&")) {

5608 var keyvalue = part.split("=");

5609 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5610 }

5611 }

5612

5613

5614 var h = {

5615 "content-type" : "application/json; charset=utf-8",

5616 };

5617 var resp = "";

5618 return new async.Future.value(stringResponse(200, h, resp));

5619 }), true);

5620 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

5621 });

5622

5623 unittest.test("method--process", () {

5624

5625 var mock = new HttpServerMock();

5626 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

5627 var arg_id = "foo";

5628 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5629 var path = (req.url).path;

5630 var pathOffset = 0;

5631 var index;

5632 var subPart;

5633 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5634 pathOffset += 1;

5635 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5636 pathOffset += 14;

5637 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5638 pathOffset += 18;

5639 index = path.indexOf("/process", pathOffset);

5640 unittest.expect(index >= 0, unittest.isTrue);

5641 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5642 pathOffset = index;

5643 unittest.expect(subPart, unittest.equals("$arg_id"));

5644 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/process"));

5645 pathOffset += 8;

5646

5647 var query = (req.url).query;

5648 var queryOffset = 0;

5649 var queryMap = {};

5650 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5651 parseBool(n) {

5652 if (n == "true") return true;

5653 if (n == "false") return false;

5654 if (n == null) return null;

5655 throw new core.ArgumentError("Invalid boolean: $n");

5656 }

5657 if (query.length > 0) {

5658 for (var part in query.split("&")) {

5659 var keyvalue = part.split("=");

5660 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5661 }

5662 }

5663

5664

5665 var h = {

5666 "content-type" : "application/json; charset=utf-8",

5667 };

5668 var resp = convert.JSON.encode(buildProcessResponse());

5669 return new async.Future.value(stringResponse(200, h, resp));

5670 }), true);

5671 res.process(arg_id).then(unittest.expectAsync(((api.ProcessResponse respon se) {

5672 checkProcessResponse(response);

5673 })));

5674 });

5675

5676 });

5677

5678

5679 unittest.group("resource-RasterCollectionsParentsResourceApi", () {

5680 unittest.test("method--list", () {

5681

5682 var mock = new HttpServerMock();

5683 api.RasterCollectionsParentsResourceApi res = new api.MapsengineApi(mock). rasterCollections.parents;

5684 var arg_id = "foo";

5685 var arg_maxResults = 42;

5686 var arg_pageToken = "foo";

5687 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5688 var path = (req.url).path;

5689 var pathOffset = 0;

5690 var index;

5691 var subPart;

5692 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5693 pathOffset += 1;

5694 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5695 pathOffset += 14;

5696 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5697 pathOffset += 18;

5698 index = path.indexOf("/parents", pathOffset);

5699 unittest.expect(index >= 0, unittest.isTrue);

5700 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5701 pathOffset = index;

5702 unittest.expect(subPart, unittest.equals("$arg_id"));

5703 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/parents"));

5704 pathOffset += 8;

5705

5706 var query = (req.url).query;

5707 var queryOffset = 0;

5708 var queryMap = {};

5709 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5710 parseBool(n) {

5711 if (n == "true") return true;

5712 if (n == "false") return false;

5713 if (n == null) return null;

5714 throw new core.ArgumentError("Invalid boolean: $n");

5715 }

5716 if (query.length > 0) {

5717 for (var part in query.split("&")) {

5718 var keyvalue = part.split("=");

5719 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5720 }

5721 }

5722 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5723 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5724

5725

5726 var h = {

5727 "content-type" : "application/json; charset=utf-8",

5728 };

5729 var resp = convert.JSON.encode(buildParentsListResponse());

5730 return new async.Future.value(stringResponse(200, h, resp));

5731 }), true);

5732 res.list(arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken).the n(unittest.expectAsync(((api.ParentsListResponse response) {

5733 checkParentsListResponse(response);

5734 })));

5735 });

5736

5737 });

5738

5739

5740 unittest.group("resource-RasterCollectionsPermissionsResourceApi", () {

5741 unittest.test("method--batchDelete", () {

5742

5743 var mock = new HttpServerMock();

5744 api.RasterCollectionsPermissionsResourceApi res = new api.MapsengineApi(mo ck).rasterCollections.permissions;

5745 var arg_request = buildPermissionsBatchDeleteRequest();

5746 var arg_id = "foo";

5747 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5748 var obj = new api.PermissionsBatchDeleteRequest.fromJson(json);

5749 checkPermissionsBatchDeleteRequest(obj);

5750

5751 var path = (req.url).path;

5752 var pathOffset = 0;

5753 var index;

5754 var subPart;

5755 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5756 pathOffset += 1;

5757 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5758 pathOffset += 14;

5759 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5760 pathOffset += 18;

5761 index = path.indexOf("/permissions/batchDelete", pathOffset);

5762 unittest.expect(index >= 0, unittest.isTrue);

5763 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5764 pathOffset = index;

5765 unittest.expect(subPart, unittest.equals("$arg_id"));

5766 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchDelete"));

5767 pathOffset += 24;

5768

5769 var query = (req.url).query;

5770 var queryOffset = 0;

5771 var queryMap = {};

5772 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5773 parseBool(n) {

5774 if (n == "true") return true;

5775 if (n == "false") return false;

5776 if (n == null) return null;

5777 throw new core.ArgumentError("Invalid boolean: $n");

5778 }

5779 if (query.length > 0) {

5780 for (var part in query.split("&")) {

5781 var keyvalue = part.split("=");

5782 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5783 }

5784 }

5785

5786

5787 var h = {

5788 "content-type" : "application/json; charset=utf-8",

5789 };

5790 var resp = convert.JSON.encode(buildPermissionsBatchDeleteResponse());

5791 return new async.Future.value(stringResponse(200, h, resp));

5792 }), true);

5793 res.batchDelete(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchDeleteResponse response) {

5794 checkPermissionsBatchDeleteResponse(response);

5795 })));

5796 });

5797

5798 unittest.test("method--batchUpdate", () {

5799

5800 var mock = new HttpServerMock();

5801 api.RasterCollectionsPermissionsResourceApi res = new api.MapsengineApi(mo ck).rasterCollections.permissions;

5802 var arg_request = buildPermissionsBatchUpdateRequest();

5803 var arg_id = "foo";

5804 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5805 var obj = new api.PermissionsBatchUpdateRequest.fromJson(json);

5806 checkPermissionsBatchUpdateRequest(obj);

5807

5808 var path = (req.url).path;

5809 var pathOffset = 0;

5810 var index;

5811 var subPart;

5812 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5813 pathOffset += 1;

5814 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5815 pathOffset += 14;

5816 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5817 pathOffset += 18;

5818 index = path.indexOf("/permissions/batchUpdate", pathOffset);

5819 unittest.expect(index >= 0, unittest.isTrue);

5820 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5821 pathOffset = index;

5822 unittest.expect(subPart, unittest.equals("$arg_id"));

5823 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchUpdate"));

5824 pathOffset += 24;

5825

5826 var query = (req.url).query;

5827 var queryOffset = 0;

5828 var queryMap = {};

5829 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5830 parseBool(n) {

5831 if (n == "true") return true;

5832 if (n == "false") return false;

5833 if (n == null) return null;

5834 throw new core.ArgumentError("Invalid boolean: $n");

5835 }

5836 if (query.length > 0) {

5837 for (var part in query.split("&")) {

5838 var keyvalue = part.split("=");

5839 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5840 }

5841 }

5842

5843

5844 var h = {

5845 "content-type" : "application/json; charset=utf-8",

5846 };

5847 var resp = convert.JSON.encode(buildPermissionsBatchUpdateResponse());

5848 return new async.Future.value(stringResponse(200, h, resp));

5849 }), true);

5850 res.batchUpdate(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchUpdateResponse response) {

5851 checkPermissionsBatchUpdateResponse(response);

5852 })));

5853 });

5854

5855 unittest.test("method--list", () {

5856

5857 var mock = new HttpServerMock();

5858 api.RasterCollectionsPermissionsResourceApi res = new api.MapsengineApi(mo ck).rasterCollections.permissions;

5859 var arg_id = "foo";

5860 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5861 var path = (req.url).path;

5862 var pathOffset = 0;

5863 var index;

5864 var subPart;

5865 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5866 pathOffset += 1;

5867 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5868 pathOffset += 14;

5869 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5870 pathOffset += 18;

5871 index = path.indexOf("/permissions", pathOffset);

5872 unittest.expect(index >= 0, unittest.isTrue);

5873 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5874 pathOffset = index;

5875 unittest.expect(subPart, unittest.equals("$arg_id"));

5876 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/permissions"));

5877 pathOffset += 12;

5878

5879 var query = (req.url).query;

5880 var queryOffset = 0;

5881 var queryMap = {};

5882 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5883 parseBool(n) {

5884 if (n == "true") return true;

5885 if (n == "false") return false;

5886 if (n == null) return null;

5887 throw new core.ArgumentError("Invalid boolean: $n");

5888 }

5889 if (query.length > 0) {

5890 for (var part in query.split("&")) {

5891 var keyvalue = part.split("=");

5892 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5893 }

5894 }

5895

5896

5897 var h = {

5898 "content-type" : "application/json; charset=utf-8",

5899 };

5900 var resp = convert.JSON.encode(buildPermissionsListResponse());

5901 return new async.Future.value(stringResponse(200, h, resp));

5902 }), true);

5903 res.list(arg_id).then(unittest.expectAsync(((api.PermissionsListResponse r esponse) {

5904 checkPermissionsListResponse(response);

5905 })));

5906 });

5907

5908 });

5909

5910

5911 unittest.group("resource-RasterCollectionsRastersResourceApi", () {

5912 unittest.test("method--batchDelete", () {

5913

5914 var mock = new HttpServerMock();

5915 api.RasterCollectionsRastersResourceApi res = new api.MapsengineApi(mock). rasterCollections.rasters;

5916 var arg_request = buildRasterCollectionsRasterBatchDeleteRequest();

5917 var arg_id = "foo";

5918 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5919 var obj = new api.RasterCollectionsRasterBatchDeleteRequest.fromJson(jso n);

5920 checkRasterCollectionsRasterBatchDeleteRequest(obj);

5921

5922 var path = (req.url).path;

5923 var pathOffset = 0;

5924 var index;

5925 var subPart;

5926 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5927 pathOffset += 1;

5928 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5929 pathOffset += 14;

5930 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5931 pathOffset += 18;

5932 index = path.indexOf("/rasters/batchDelete", pathOffset);

5933 unittest.expect(index >= 0, unittest.isTrue);

5934 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5935 pathOffset = index;

5936 unittest.expect(subPart, unittest.equals("$arg_id"));

5937 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/rasters/batchDelete"));

5938 pathOffset += 20;

5939

5940 var query = (req.url).query;

5941 var queryOffset = 0;

5942 var queryMap = {};

5943 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5944 parseBool(n) {

5945 if (n == "true") return true;

5946 if (n == "false") return false;

5947 if (n == null) return null;

5948 throw new core.ArgumentError("Invalid boolean: $n");

5949 }

5950 if (query.length > 0) {

5951 for (var part in query.split("&")) {

5952 var keyvalue = part.split("=");

5953 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5954 }

5955 }

5956

5957

5958 var h = {

5959 "content-type" : "application/json; charset=utf-8",

5960 };

5961 var resp = convert.JSON.encode(buildRasterCollectionsRastersBatchDeleteR esponse());

5962 return new async.Future.value(stringResponse(200, h, resp));

5963 }), true);

5964 res.batchDelete(arg_request, arg_id).then(unittest.expectAsync(((api.Raste rCollectionsRastersBatchDeleteResponse response) {

5965 checkRasterCollectionsRastersBatchDeleteResponse(response);

5966 })));

5967 });

5968

5969 unittest.test("method--batchInsert", () {

5970

5971 var mock = new HttpServerMock();

5972 api.RasterCollectionsRastersResourceApi res = new api.MapsengineApi(mock). rasterCollections.rasters;

5973 var arg_request = buildRasterCollectionsRastersBatchInsertRequest();

5974 var arg_id = "foo";

5975 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5976 var obj = new api.RasterCollectionsRastersBatchInsertRequest.fromJson(js on);

5977 checkRasterCollectionsRastersBatchInsertRequest(obj);

5978

5979 var path = (req.url).path;

5980 var pathOffset = 0;

5981 var index;

5982 var subPart;

5983 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

5984 pathOffset += 1;

5985 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

5986 pathOffset += 14;

5987 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5988 pathOffset += 18;

5989 index = path.indexOf("/rasters/batchInsert", pathOffset);

5990 unittest.expect(index >= 0, unittest.isTrue);

5991 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5992 pathOffset = index;

5993 unittest.expect(subPart, unittest.equals("$arg_id"));

5994 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/rasters/batchInsert"));

5995 pathOffset += 20;

5996

5997 var query = (req.url).query;

5998 var queryOffset = 0;

5999 var queryMap = {};

6000 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6001 parseBool(n) {

6002 if (n == "true") return true;

6003 if (n == "false") return false;

6004 if (n == null) return null;

6005 throw new core.ArgumentError("Invalid boolean: $n");

6006 }

6007 if (query.length > 0) {

6008 for (var part in query.split("&")) {

6009 var keyvalue = part.split("=");

6010 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6011 }

6012 }

6013

6014

6015 var h = {

6016 "content-type" : "application/json; charset=utf-8",

6017 };

6018 var resp = convert.JSON.encode(buildRasterCollectionsRastersBatchInsertR esponse());

6019 return new async.Future.value(stringResponse(200, h, resp));

6020 }), true);

6021 res.batchInsert(arg_request, arg_id).then(unittest.expectAsync(((api.Raste rCollectionsRastersBatchInsertResponse response) {

6022 checkRasterCollectionsRastersBatchInsertResponse(response);

6023 })));

6024 });

6025

6026 unittest.test("method--list", () {

6027

6028 var mock = new HttpServerMock();

6029 api.RasterCollectionsRastersResourceApi res = new api.MapsengineApi(mock). rasterCollections.rasters;

6030 var arg_id = "foo";

6031 var arg_bbox = "foo";

6032 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

6033 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

6034 var arg_creatorEmail = "foo";

6035 var arg_maxResults = 42;

6036 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

6037 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

6038 var arg_pageToken = "foo";

6039 var arg_role = "foo";

6040 var arg_search = "foo";

6041 var arg_tags = "foo";

6042 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6043 var path = (req.url).path;

6044 var pathOffset = 0;

6045 var index;

6046 var subPart;

6047 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6048 pathOffset += 1;

6049 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6050 pathOffset += 14;

6051 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

6052 pathOffset += 18;

6053 index = path.indexOf("/rasters", pathOffset);

6054 unittest.expect(index >= 0, unittest.isTrue);

6055 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6056 pathOffset = index;

6057 unittest.expect(subPart, unittest.equals("$arg_id"));

6058 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/rasters"));

6059 pathOffset += 8;

6060

6061 var query = (req.url).query;

6062 var queryOffset = 0;

6063 var queryMap = {};

6064 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6065 parseBool(n) {

6066 if (n == "true") return true;

6067 if (n == "false") return false;

6068 if (n == null) return null;

6069 throw new core.ArgumentError("Invalid boolean: $n");

6070 }

6071 if (query.length > 0) {

6072 for (var part in query.split("&")) {

6073 var keyvalue = part.split("=");

6074 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6075 }

6076 }

6077 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

6078 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

6079 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

6080 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

6081 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6082 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

6083 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

6084 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6085 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

6086 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

6087 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

6088

6089

6090 var h = {

6091 "content-type" : "application/json; charset=utf-8",

6092 };

6093 var resp = convert.JSON.encode(buildRasterCollectionsRastersListResponse ());

6094 return new async.Future.value(stringResponse(200, h, resp));

6095 }), true);

6096 res.list(arg_id, bbox: arg_bbox, createdAfter: arg_createdAfter, createdBe fore: arg_createdBefore, creatorEmail: arg_creatorEmail, maxResults: arg_maxResu lts, modifiedAfter: arg_modifiedAfter, modifiedBefore: arg_modifiedBefore, pageT oken: arg_pageToken, role: arg_role, search: arg_search, tags: arg_tags).then(un ittest.expectAsync(((api.RasterCollectionsRastersListResponse response) {

6097 checkRasterCollectionsRastersListResponse(response);

6098 })));

6099 });

6100

6101 });

6102

6103

6104 unittest.group("resource-RastersResourceApi", () {

6105 unittest.test("method--delete", () {

6106

6107 var mock = new HttpServerMock();

6108 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

6109 var arg_id = "foo";

6110 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6111 var path = (req.url).path;

6112 var pathOffset = 0;

6113 var index;

6114 var subPart;

6115 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6116 pathOffset += 1;

6117 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6118 pathOffset += 14;

6119 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

6120 pathOffset += 8;

6121 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6122 pathOffset = path.length;

6123 unittest.expect(subPart, unittest.equals("$arg_id"));

6124

6125 var query = (req.url).query;

6126 var queryOffset = 0;

6127 var queryMap = {};

6128 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6129 parseBool(n) {

6130 if (n == "true") return true;

6131 if (n == "false") return false;

6132 if (n == null) return null;

6133 throw new core.ArgumentError("Invalid boolean: $n");

6134 }

6135 if (query.length > 0) {

6136 for (var part in query.split("&")) {

6137 var keyvalue = part.split("=");

6138 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6139 }

6140 }

6141

6142

6143 var h = {

6144 "content-type" : "application/json; charset=utf-8",

6145 };

6146 var resp = "";

6147 return new async.Future.value(stringResponse(200, h, resp));

6148 }), true);

6149 res.delete(arg_id).then(unittest.expectAsync((_) {}));

6150 });

6151

6152 unittest.test("method--get", () {

6153

6154 var mock = new HttpServerMock();

6155 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

6156 var arg_id = "foo";

6157 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6158 var path = (req.url).path;

6159 var pathOffset = 0;

6160 var index;

6161 var subPart;

6162 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6163 pathOffset += 1;

6164 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6165 pathOffset += 14;

6166 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

6167 pathOffset += 8;

6168 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6169 pathOffset = path.length;

6170 unittest.expect(subPart, unittest.equals("$arg_id"));

6171

6172 var query = (req.url).query;

6173 var queryOffset = 0;

6174 var queryMap = {};

6175 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6176 parseBool(n) {

6177 if (n == "true") return true;

6178 if (n == "false") return false;

6179 if (n == null) return null;

6180 throw new core.ArgumentError("Invalid boolean: $n");

6181 }

6182 if (query.length > 0) {

6183 for (var part in query.split("&")) {

6184 var keyvalue = part.split("=");

6185 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6186 }

6187 }

6188

6189

6190 var h = {

6191 "content-type" : "application/json; charset=utf-8",

6192 };

6193 var resp = convert.JSON.encode(buildRaster());

6194 return new async.Future.value(stringResponse(200, h, resp));

6195 }), true);

6196 res.get(arg_id).then(unittest.expectAsync(((api.Raster response) {

6197 checkRaster(response);

6198 })));

6199 });

6200

6201 unittest.test("method--list", () {

6202

6203 var mock = new HttpServerMock();

6204 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

6205 var arg_projectId = "foo";

6206 var arg_bbox = "foo";

6207 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

6208 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

6209 var arg_creatorEmail = "foo";

6210 var arg_maxResults = 42;

6211 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

6212 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

6213 var arg_pageToken = "foo";

6214 var arg_processingStatus = "foo";

6215 var arg_role = "foo";

6216 var arg_search = "foo";

6217 var arg_tags = "foo";

6218 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6219 var path = (req.url).path;

6220 var pathOffset = 0;

6221 var index;

6222 var subPart;

6223 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6224 pathOffset += 1;

6225 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6226 pathOffset += 14;

6227 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("rasters"));

6228 pathOffset += 7;

6229

6230 var query = (req.url).query;

6231 var queryOffset = 0;

6232 var queryMap = {};

6233 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6234 parseBool(n) {

6235 if (n == "true") return true;

6236 if (n == "false") return false;

6237 if (n == null) return null;

6238 throw new core.ArgumentError("Invalid boolean: $n");

6239 }

6240 if (query.length > 0) {

6241 for (var part in query.split("&")) {

6242 var keyvalue = part.split("=");

6243 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6244 }

6245 }

6246 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

6247 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

6248 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

6249 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

6250 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

6251 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6252 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

6253 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

6254 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6255 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

6256 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

6257 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

6258 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

6259

6260

6261 var h = {

6262 "content-type" : "application/json; charset=utf-8",

6263 };

6264 var resp = convert.JSON.encode(buildRastersListResponse());

6265 return new async.Future.value(stringResponse(200, h, resp));

6266 }), true);

6267 res.list(arg_projectId, bbox: arg_bbox, createdAfter: arg_createdAfter, cr eatedBefore: arg_createdBefore, creatorEmail: arg_creatorEmail, maxResults: arg_ maxResults, modifiedAfter: arg_modifiedAfter, modifiedBefore: arg_modifiedBefore , pageToken: arg_pageToken, processingStatus: arg_processingStatus, role: arg_ro le, search: arg_search, tags: arg_tags).then(unittest.expectAsync(((api.RastersL istResponse response) {

6268 checkRastersListResponse(response);

6269 })));

6270 });

6271

6272 unittest.test("method--patch", () {

6273

6274 var mock = new HttpServerMock();

6275 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

6276 var arg_request = buildRaster();

6277 var arg_id = "foo";

6278 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6279 var obj = new api.Raster.fromJson(json);

6280 checkRaster(obj);

6281

6282 var path = (req.url).path;

6283 var pathOffset = 0;

6284 var index;

6285 var subPart;

6286 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6287 pathOffset += 1;

6288 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6289 pathOffset += 14;

6290 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

6291 pathOffset += 8;

6292 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6293 pathOffset = path.length;

6294 unittest.expect(subPart, unittest.equals("$arg_id"));

6295

6296 var query = (req.url).query;

6297 var queryOffset = 0;

6298 var queryMap = {};

6299 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6300 parseBool(n) {

6301 if (n == "true") return true;

6302 if (n == "false") return false;

6303 if (n == null) return null;

6304 throw new core.ArgumentError("Invalid boolean: $n");

6305 }

6306 if (query.length > 0) {

6307 for (var part in query.split("&")) {

6308 var keyvalue = part.split("=");

6309 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6310 }

6311 }

6312

6313

6314 var h = {

6315 "content-type" : "application/json; charset=utf-8",

6316 };

6317 var resp = "";

6318 return new async.Future.value(stringResponse(200, h, resp));

6319 }), true);

6320 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

6321 });

6322

6323 unittest.test("method--process", () {

6324

6325 var mock = new HttpServerMock();

6326 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

6327 var arg_id = "foo";

6328 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6329 var path = (req.url).path;

6330 var pathOffset = 0;

6331 var index;

6332 var subPart;

6333 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6334 pathOffset += 1;

6335 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6336 pathOffset += 14;

6337 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

6338 pathOffset += 8;

6339 index = path.indexOf("/process", pathOffset);

6340 unittest.expect(index >= 0, unittest.isTrue);

6341 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6342 pathOffset = index;

6343 unittest.expect(subPart, unittest.equals("$arg_id"));

6344 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/process"));

6345 pathOffset += 8;

6346

6347 var query = (req.url).query;

6348 var queryOffset = 0;

6349 var queryMap = {};

6350 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6351 parseBool(n) {

6352 if (n == "true") return true;

6353 if (n == "false") return false;

6354 if (n == null) return null;

6355 throw new core.ArgumentError("Invalid boolean: $n");

6356 }

6357 if (query.length > 0) {

6358 for (var part in query.split("&")) {

6359 var keyvalue = part.split("=");

6360 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6361 }

6362 }

6363

6364

6365 var h = {

6366 "content-type" : "application/json; charset=utf-8",

6367 };

6368 var resp = convert.JSON.encode(buildProcessResponse());

6369 return new async.Future.value(stringResponse(200, h, resp));

6370 }), true);

6371 res.process(arg_id).then(unittest.expectAsync(((api.ProcessResponse respon se) {

6372 checkProcessResponse(response);

6373 })));

6374 });

6375

6376 unittest.test("method--upload", () {

6377

6378 var mock = new HttpServerMock();

6379 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

6380 var arg_request = buildRaster();

6381 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6382 var obj = new api.Raster.fromJson(json);

6383 checkRaster(obj);

6384

6385 var path = (req.url).path;

6386 var pathOffset = 0;

6387 var index;

6388 var subPart;

6389 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6390 pathOffset += 1;

6391 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6392 pathOffset += 14;

6393 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("rasters/upload"));

6394 pathOffset += 14;

6395

6396 var query = (req.url).query;

6397 var queryOffset = 0;

6398 var queryMap = {};

6399 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6400 parseBool(n) {

6401 if (n == "true") return true;

6402 if (n == "false") return false;

6403 if (n == null) return null;

6404 throw new core.ArgumentError("Invalid boolean: $n");

6405 }

6406 if (query.length > 0) {

6407 for (var part in query.split("&")) {

6408 var keyvalue = part.split("=");

6409 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6410 }

6411 }

6412

6413

6414 var h = {

6415 "content-type" : "application/json; charset=utf-8",

6416 };

6417 var resp = convert.JSON.encode(buildRaster());

6418 return new async.Future.value(stringResponse(200, h, resp));

6419 }), true);

6420 res.upload(arg_request).then(unittest.expectAsync(((api.Raster response) {

6421 checkRaster(response);

6422 })));

6423 });

6424

6425 });

6426

6427

6428 unittest.group("resource-RastersFilesResourceApi", () {

6429 unittest.test("method--insert", () {

6430 // TODO: Implement tests for media upload;

6431 // TODO: Implement tests for media download;

6432

6433 var mock = new HttpServerMock();

6434 api.RastersFilesResourceApi res = new api.MapsengineApi(mock).rasters.file s;

6435 var arg_id = "foo";

6436 var arg_filename = "foo";

6437 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6438 var path = (req.url).path;

6439 var pathOffset = 0;

6440 var index;

6441 var subPart;

6442 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6443 pathOffset += 1;

6444 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6445 pathOffset += 14;

6446 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

6447 pathOffset += 8;

6448 index = path.indexOf("/files", pathOffset);

6449 unittest.expect(index >= 0, unittest.isTrue);

6450 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6451 pathOffset = index;

6452 unittest.expect(subPart, unittest.equals("$arg_id"));

6453 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/files"));

6454 pathOffset += 6;

6455

6456 var query = (req.url).query;

6457 var queryOffset = 0;

6458 var queryMap = {};

6459 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6460 parseBool(n) {

6461 if (n == "true") return true;

6462 if (n == "false") return false;

6463 if (n == null) return null;

6464 throw new core.ArgumentError("Invalid boolean: $n");

6465 }

6466 if (query.length > 0) {

6467 for (var part in query.split("&")) {

6468 var keyvalue = part.split("=");

6469 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6470 }

6471 }

6472 unittest.expect(queryMap["filename"].first, unittest.equals(arg_filename ));

6473

6474

6475 var h = {

6476 "content-type" : "application/json; charset=utf-8",

6477 };

6478 var resp = "";

6479 return new async.Future.value(stringResponse(200, h, resp));

6480 }), true);

6481 res.insert(arg_id, arg_filename).then(unittest.expectAsync((_) {}));

6482 });

6483

6484 });

6485

6486

6487 unittest.group("resource-RastersParentsResourceApi", () {

6488 unittest.test("method--list", () {

6489

6490 var mock = new HttpServerMock();

6491 api.RastersParentsResourceApi res = new api.MapsengineApi(mock).rasters.pa rents;

6492 var arg_id = "foo";

6493 var arg_maxResults = 42;

6494 var arg_pageToken = "foo";

6495 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6496 var path = (req.url).path;

6497 var pathOffset = 0;

6498 var index;

6499 var subPart;

6500 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6501 pathOffset += 1;

6502 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6503 pathOffset += 14;

6504 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

6505 pathOffset += 8;

6506 index = path.indexOf("/parents", pathOffset);

6507 unittest.expect(index >= 0, unittest.isTrue);

6508 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6509 pathOffset = index;

6510 unittest.expect(subPart, unittest.equals("$arg_id"));

6511 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/parents"));

6512 pathOffset += 8;

6513

6514 var query = (req.url).query;

6515 var queryOffset = 0;

6516 var queryMap = {};

6517 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6518 parseBool(n) {

6519 if (n == "true") return true;

6520 if (n == "false") return false;

6521 if (n == null) return null;

6522 throw new core.ArgumentError("Invalid boolean: $n");

6523 }

6524 if (query.length > 0) {

6525 for (var part in query.split("&")) {

6526 var keyvalue = part.split("=");

6527 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6528 }

6529 }

6530 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6531 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6532

6533

6534 var h = {

6535 "content-type" : "application/json; charset=utf-8",

6536 };

6537 var resp = convert.JSON.encode(buildParentsListResponse());

6538 return new async.Future.value(stringResponse(200, h, resp));

6539 }), true);

6540 res.list(arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken).the n(unittest.expectAsync(((api.ParentsListResponse response) {

6541 checkParentsListResponse(response);

6542 })));

6543 });

6544

6545 });

6546

6547

6548 unittest.group("resource-RastersPermissionsResourceApi", () {

6549 unittest.test("method--batchDelete", () {

6550

6551 var mock = new HttpServerMock();

6552 api.RastersPermissionsResourceApi res = new api.MapsengineApi(mock).raster s.permissions;

6553 var arg_request = buildPermissionsBatchDeleteRequest();

6554 var arg_id = "foo";

6555 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6556 var obj = new api.PermissionsBatchDeleteRequest.fromJson(json);

6557 checkPermissionsBatchDeleteRequest(obj);

6558

6559 var path = (req.url).path;

6560 var pathOffset = 0;

6561 var index;

6562 var subPart;

6563 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6564 pathOffset += 1;

6565 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6566 pathOffset += 14;

6567 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

6568 pathOffset += 8;

6569 index = path.indexOf("/permissions/batchDelete", pathOffset);

6570 unittest.expect(index >= 0, unittest.isTrue);

6571 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6572 pathOffset = index;

6573 unittest.expect(subPart, unittest.equals("$arg_id"));

6574 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchDelete"));

6575 pathOffset += 24;

6576

6577 var query = (req.url).query;

6578 var queryOffset = 0;

6579 var queryMap = {};

6580 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6581 parseBool(n) {

6582 if (n == "true") return true;

6583 if (n == "false") return false;

6584 if (n == null) return null;

6585 throw new core.ArgumentError("Invalid boolean: $n");

6586 }

6587 if (query.length > 0) {

6588 for (var part in query.split("&")) {

6589 var keyvalue = part.split("=");

6590 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6591 }

6592 }

6593

6594

6595 var h = {

6596 "content-type" : "application/json; charset=utf-8",

6597 };

6598 var resp = convert.JSON.encode(buildPermissionsBatchDeleteResponse());

6599 return new async.Future.value(stringResponse(200, h, resp));

6600 }), true);

6601 res.batchDelete(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchDeleteResponse response) {

6602 checkPermissionsBatchDeleteResponse(response);

6603 })));

6604 });

6605

6606 unittest.test("method--batchUpdate", () {

6607

6608 var mock = new HttpServerMock();

6609 api.RastersPermissionsResourceApi res = new api.MapsengineApi(mock).raster s.permissions;

6610 var arg_request = buildPermissionsBatchUpdateRequest();

6611 var arg_id = "foo";

6612 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6613 var obj = new api.PermissionsBatchUpdateRequest.fromJson(json);

6614 checkPermissionsBatchUpdateRequest(obj);

6615

6616 var path = (req.url).path;

6617 var pathOffset = 0;

6618 var index;

6619 var subPart;

6620 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6621 pathOffset += 1;

6622 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6623 pathOffset += 14;

6624 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

6625 pathOffset += 8;

6626 index = path.indexOf("/permissions/batchUpdate", pathOffset);

6627 unittest.expect(index >= 0, unittest.isTrue);

6628 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6629 pathOffset = index;

6630 unittest.expect(subPart, unittest.equals("$arg_id"));

6631 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchUpdate"));

6632 pathOffset += 24;

6633

6634 var query = (req.url).query;

6635 var queryOffset = 0;

6636 var queryMap = {};

6637 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6638 parseBool(n) {

6639 if (n == "true") return true;

6640 if (n == "false") return false;

6641 if (n == null) return null;

6642 throw new core.ArgumentError("Invalid boolean: $n");

6643 }

6644 if (query.length > 0) {

6645 for (var part in query.split("&")) {

6646 var keyvalue = part.split("=");

6647 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6648 }

6649 }

6650

6651

6652 var h = {

6653 "content-type" : "application/json; charset=utf-8",

6654 };

6655 var resp = convert.JSON.encode(buildPermissionsBatchUpdateResponse());

6656 return new async.Future.value(stringResponse(200, h, resp));

6657 }), true);

6658 res.batchUpdate(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchUpdateResponse response) {

6659 checkPermissionsBatchUpdateResponse(response);

6660 })));

6661 });

6662

6663 unittest.test("method--list", () {

6664

6665 var mock = new HttpServerMock();

6666 api.RastersPermissionsResourceApi res = new api.MapsengineApi(mock).raster s.permissions;

6667 var arg_id = "foo";

6668 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6669 var path = (req.url).path;

6670 var pathOffset = 0;

6671 var index;

6672 var subPart;

6673 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6674 pathOffset += 1;

6675 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6676 pathOffset += 14;

6677 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

6678 pathOffset += 8;

6679 index = path.indexOf("/permissions", pathOffset);

6680 unittest.expect(index >= 0, unittest.isTrue);

6681 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6682 pathOffset = index;

6683 unittest.expect(subPart, unittest.equals("$arg_id"));

6684 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/permissions"));

6685 pathOffset += 12;

6686

6687 var query = (req.url).query;

6688 var queryOffset = 0;

6689 var queryMap = {};

6690 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6691 parseBool(n) {

6692 if (n == "true") return true;

6693 if (n == "false") return false;

6694 if (n == null) return null;

6695 throw new core.ArgumentError("Invalid boolean: $n");

6696 }

6697 if (query.length > 0) {

6698 for (var part in query.split("&")) {

6699 var keyvalue = part.split("=");

6700 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6701 }

6702 }

6703

6704

6705 var h = {

6706 "content-type" : "application/json; charset=utf-8",

6707 };

6708 var resp = convert.JSON.encode(buildPermissionsListResponse());

6709 return new async.Future.value(stringResponse(200, h, resp));

6710 }), true);

6711 res.list(arg_id).then(unittest.expectAsync(((api.PermissionsListResponse r esponse) {

6712 checkPermissionsListResponse(response);

6713 })));

6714 });

6715

6716 });

6717

6718

6719 unittest.group("resource-TablesResourceApi", () {

6720 unittest.test("method--create", () {

6721

6722 var mock = new HttpServerMock();

6723 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

6724 var arg_request = buildTable();

6725 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6726 var obj = new api.Table.fromJson(json);

6727 checkTable(obj);

6728

6729 var path = (req.url).path;

6730 var pathOffset = 0;

6731 var index;

6732 var subPart;

6733 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6734 pathOffset += 1;

6735 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6736 pathOffset += 14;

6737 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("tables"));

6738 pathOffset += 6;

6739

6740 var query = (req.url).query;

6741 var queryOffset = 0;

6742 var queryMap = {};

6743 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6744 parseBool(n) {

6745 if (n == "true") return true;

6746 if (n == "false") return false;

6747 if (n == null) return null;

6748 throw new core.ArgumentError("Invalid boolean: $n");

6749 }

6750 if (query.length > 0) {

6751 for (var part in query.split("&")) {

6752 var keyvalue = part.split("=");

6753 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6754 }

6755 }

6756

6757

6758 var h = {

6759 "content-type" : "application/json; charset=utf-8",

6760 };

6761 var resp = convert.JSON.encode(buildTable());

6762 return new async.Future.value(stringResponse(200, h, resp));

6763 }), true);

6764 res.create(arg_request).then(unittest.expectAsync(((api.Table response) {

6765 checkTable(response);

6766 })));

6767 });

6768

6769 unittest.test("method--delete", () {

6770

6771 var mock = new HttpServerMock();

6772 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

6773 var arg_id = "foo";

6774 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6775 var path = (req.url).path;

6776 var pathOffset = 0;

6777 var index;

6778 var subPart;

6779 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6780 pathOffset += 1;

6781 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6782 pathOffset += 14;

6783 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

6784 pathOffset += 7;

6785 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6786 pathOffset = path.length;

6787 unittest.expect(subPart, unittest.equals("$arg_id"));

6788

6789 var query = (req.url).query;

6790 var queryOffset = 0;

6791 var queryMap = {};

6792 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6793 parseBool(n) {

6794 if (n == "true") return true;

6795 if (n == "false") return false;

6796 if (n == null) return null;

6797 throw new core.ArgumentError("Invalid boolean: $n");

6798 }

6799 if (query.length > 0) {

6800 for (var part in query.split("&")) {

6801 var keyvalue = part.split("=");

6802 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6803 }

6804 }

6805

6806

6807 var h = {

6808 "content-type" : "application/json; charset=utf-8",

6809 };

6810 var resp = "";

6811 return new async.Future.value(stringResponse(200, h, resp));

6812 }), true);

6813 res.delete(arg_id).then(unittest.expectAsync((_) {}));

6814 });

6815

6816 unittest.test("method--get", () {

6817

6818 var mock = new HttpServerMock();

6819 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

6820 var arg_id = "foo";

6821 var arg_version = "foo";

6822 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6823 var path = (req.url).path;

6824 var pathOffset = 0;

6825 var index;

6826 var subPart;

6827 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6828 pathOffset += 1;

6829 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6830 pathOffset += 14;

6831 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

6832 pathOffset += 7;

6833 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6834 pathOffset = path.length;

6835 unittest.expect(subPart, unittest.equals("$arg_id"));

6836

6837 var query = (req.url).query;

6838 var queryOffset = 0;

6839 var queryMap = {};

6840 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6841 parseBool(n) {

6842 if (n == "true") return true;

6843 if (n == "false") return false;

6844 if (n == null) return null;

6845 throw new core.ArgumentError("Invalid boolean: $n");

6846 }

6847 if (query.length > 0) {

6848 for (var part in query.split("&")) {

6849 var keyvalue = part.split("=");

6850 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6851 }

6852 }

6853 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

6854

6855

6856 var h = {

6857 "content-type" : "application/json; charset=utf-8",

6858 };

6859 var resp = convert.JSON.encode(buildTable());

6860 return new async.Future.value(stringResponse(200, h, resp));

6861 }), true);

6862 res.get(arg_id, version: arg_version).then(unittest.expectAsync(((api.Tabl e response) {

6863 checkTable(response);

6864 })));

6865 });

6866

6867 unittest.test("method--list", () {

6868

6869 var mock = new HttpServerMock();

6870 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

6871 var arg_bbox = "foo";

6872 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

6873 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

6874 var arg_creatorEmail = "foo";

6875 var arg_maxResults = 42;

6876 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

6877 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

6878 var arg_pageToken = "foo";

6879 var arg_processingStatus = "foo";

6880 var arg_projectId = "foo";

6881 var arg_role = "foo";

6882 var arg_search = "foo";

6883 var arg_tags = "foo";

6884 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6885 var path = (req.url).path;

6886 var pathOffset = 0;

6887 var index;

6888 var subPart;

6889 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6890 pathOffset += 1;

6891 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6892 pathOffset += 14;

6893 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("tables"));

6894 pathOffset += 6;

6895

6896 var query = (req.url).query;

6897 var queryOffset = 0;

6898 var queryMap = {};

6899 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6900 parseBool(n) {

6901 if (n == "true") return true;

6902 if (n == "false") return false;

6903 if (n == null) return null;

6904 throw new core.ArgumentError("Invalid boolean: $n");

6905 }

6906 if (query.length > 0) {

6907 for (var part in query.split("&")) {

6908 var keyvalue = part.split("=");

6909 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6910 }

6911 }

6912 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

6913 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

6914 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

6915 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

6916 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6917 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

6918 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

6919 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6920 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

6921 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

6922 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

6923 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

6924 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

6925

6926

6927 var h = {

6928 "content-type" : "application/json; charset=utf-8",

6929 };

6930 var resp = convert.JSON.encode(buildTablesListResponse());

6931 return new async.Future.value(stringResponse(200, h, resp));

6932 }), true);

6933 res.list(bbox: arg_bbox, createdAfter: arg_createdAfter, createdBefore: ar g_createdBefore, creatorEmail: arg_creatorEmail, maxResults: arg_maxResults, mod ifiedAfter: arg_modifiedAfter, modifiedBefore: arg_modifiedBefore, pageToken: ar g_pageToken, processingStatus: arg_processingStatus, projectId: arg_projectId, r ole: arg_role, search: arg_search, tags: arg_tags).then(unittest.expectAsync(((a pi.TablesListResponse response) {

6934 checkTablesListResponse(response);

6935 })));

6936 });

6937

6938 unittest.test("method--patch", () {

6939

6940 var mock = new HttpServerMock();

6941 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

6942 var arg_request = buildTable();

6943 var arg_id = "foo";

6944 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6945 var obj = new api.Table.fromJson(json);

6946 checkTable(obj);

6947

6948 var path = (req.url).path;

6949 var pathOffset = 0;

6950 var index;

6951 var subPart;

6952 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

6953 pathOffset += 1;

6954 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

6955 pathOffset += 14;

6956 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

6957 pathOffset += 7;

6958 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6959 pathOffset = path.length;

6960 unittest.expect(subPart, unittest.equals("$arg_id"));

6961

6962 var query = (req.url).query;

6963 var queryOffset = 0;

6964 var queryMap = {};

6965 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6966 parseBool(n) {

6967 if (n == "true") return true;

6968 if (n == "false") return false;

6969 if (n == null) return null;

6970 throw new core.ArgumentError("Invalid boolean: $n");

6971 }

6972 if (query.length > 0) {

6973 for (var part in query.split("&")) {

6974 var keyvalue = part.split("=");

6975 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6976 }

6977 }

6978

6979

6980 var h = {

6981 "content-type" : "application/json; charset=utf-8",

6982 };

6983 var resp = "";

6984 return new async.Future.value(stringResponse(200, h, resp));

6985 }), true);

6986 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

6987 });

6988

6989 unittest.test("method--process", () {

6990

6991 var mock = new HttpServerMock();

6992 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

6993 var arg_id = "foo";

6994 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6995 var path = (req.url).path;

6996 var pathOffset = 0;

6997 var index;

6998 var subPart;

6999 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7000 pathOffset += 1;

7001 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7002 pathOffset += 14;

7003 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7004 pathOffset += 7;

7005 index = path.indexOf("/process", pathOffset);

7006 unittest.expect(index >= 0, unittest.isTrue);

7007 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7008 pathOffset = index;

7009 unittest.expect(subPart, unittest.equals("$arg_id"));

7010 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/process"));

7011 pathOffset += 8;

7012

7013 var query = (req.url).query;

7014 var queryOffset = 0;

7015 var queryMap = {};

7016 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7017 parseBool(n) {

7018 if (n == "true") return true;

7019 if (n == "false") return false;

7020 if (n == null) return null;

7021 throw new core.ArgumentError("Invalid boolean: $n");

7022 }

7023 if (query.length > 0) {

7024 for (var part in query.split("&")) {

7025 var keyvalue = part.split("=");

7026 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7027 }

7028 }

7029

7030

7031 var h = {

7032 "content-type" : "application/json; charset=utf-8",

7033 };

7034 var resp = convert.JSON.encode(buildProcessResponse());

7035 return new async.Future.value(stringResponse(200, h, resp));

7036 }), true);

7037 res.process(arg_id).then(unittest.expectAsync(((api.ProcessResponse respon se) {

7038 checkProcessResponse(response);

7039 })));

7040 });

7041

7042 unittest.test("method--upload", () {

7043

7044 var mock = new HttpServerMock();

7045 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

7046 var arg_request = buildTable();

7047 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7048 var obj = new api.Table.fromJson(json);

7049 checkTable(obj);

7050

7051 var path = (req.url).path;

7052 var pathOffset = 0;

7053 var index;

7054 var subPart;

7055 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7056 pathOffset += 1;

7057 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7058 pathOffset += 14;

7059 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("tables/upload"));

7060 pathOffset += 13;

7061

7062 var query = (req.url).query;

7063 var queryOffset = 0;

7064 var queryMap = {};

7065 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7066 parseBool(n) {

7067 if (n == "true") return true;

7068 if (n == "false") return false;

7069 if (n == null) return null;

7070 throw new core.ArgumentError("Invalid boolean: $n");

7071 }

7072 if (query.length > 0) {

7073 for (var part in query.split("&")) {

7074 var keyvalue = part.split("=");

7075 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7076 }

7077 }

7078

7079

7080 var h = {

7081 "content-type" : "application/json; charset=utf-8",

7082 };

7083 var resp = convert.JSON.encode(buildTable());

7084 return new async.Future.value(stringResponse(200, h, resp));

7085 }), true);

7086 res.upload(arg_request).then(unittest.expectAsync(((api.Table response) {

7087 checkTable(response);

7088 })));

7089 });

7090

7091 });

7092

7093

7094 unittest.group("resource-TablesFeaturesResourceApi", () {

7095 unittest.test("method--batchDelete", () {

7096

7097 var mock = new HttpServerMock();

7098 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

7099 var arg_request = buildFeaturesBatchDeleteRequest();

7100 var arg_id = "foo";

7101 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7102 var obj = new api.FeaturesBatchDeleteRequest.fromJson(json);

7103 checkFeaturesBatchDeleteRequest(obj);

7104

7105 var path = (req.url).path;

7106 var pathOffset = 0;

7107 var index;

7108 var subPart;

7109 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7110 pathOffset += 1;

7111 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7112 pathOffset += 14;

7113 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7114 pathOffset += 7;

7115 index = path.indexOf("/features/batchDelete", pathOffset);

7116 unittest.expect(index >= 0, unittest.isTrue);

7117 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7118 pathOffset = index;

7119 unittest.expect(subPart, unittest.equals("$arg_id"));

7120 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/features/batchDelete"));

7121 pathOffset += 21;

7122

7123 var query = (req.url).query;

7124 var queryOffset = 0;

7125 var queryMap = {};

7126 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7127 parseBool(n) {

7128 if (n == "true") return true;

7129 if (n == "false") return false;

7130 if (n == null) return null;

7131 throw new core.ArgumentError("Invalid boolean: $n");

7132 }

7133 if (query.length > 0) {

7134 for (var part in query.split("&")) {

7135 var keyvalue = part.split("=");

7136 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7137 }

7138 }

7139

7140

7141 var h = {

7142 "content-type" : "application/json; charset=utf-8",

7143 };

7144 var resp = "";

7145 return new async.Future.value(stringResponse(200, h, resp));

7146 }), true);

7147 res.batchDelete(arg_request, arg_id).then(unittest.expectAsync((_) {}));

7148 });

7149

7150 unittest.test("method--batchInsert", () {

7151

7152 var mock = new HttpServerMock();

7153 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

7154 var arg_request = buildFeaturesBatchInsertRequest();

7155 var arg_id = "foo";

7156 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7157 var obj = new api.FeaturesBatchInsertRequest.fromJson(json);

7158 checkFeaturesBatchInsertRequest(obj);

7159

7160 var path = (req.url).path;

7161 var pathOffset = 0;

7162 var index;

7163 var subPart;

7164 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7165 pathOffset += 1;

7166 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7167 pathOffset += 14;

7168 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7169 pathOffset += 7;

7170 index = path.indexOf("/features/batchInsert", pathOffset);

7171 unittest.expect(index >= 0, unittest.isTrue);

7172 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7173 pathOffset = index;

7174 unittest.expect(subPart, unittest.equals("$arg_id"));

7175 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/features/batchInsert"));

7176 pathOffset += 21;

7177

7178 var query = (req.url).query;

7179 var queryOffset = 0;

7180 var queryMap = {};

7181 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7182 parseBool(n) {

7183 if (n == "true") return true;

7184 if (n == "false") return false;

7185 if (n == null) return null;

7186 throw new core.ArgumentError("Invalid boolean: $n");

7187 }

7188 if (query.length > 0) {

7189 for (var part in query.split("&")) {

7190 var keyvalue = part.split("=");

7191 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7192 }

7193 }

7194

7195

7196 var h = {

7197 "content-type" : "application/json; charset=utf-8",

7198 };

7199 var resp = "";

7200 return new async.Future.value(stringResponse(200, h, resp));

7201 }), true);

7202 res.batchInsert(arg_request, arg_id).then(unittest.expectAsync((_) {}));

7203 });

7204

7205 unittest.test("method--batchPatch", () {

7206

7207 var mock = new HttpServerMock();

7208 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

7209 var arg_request = buildFeaturesBatchPatchRequest();

7210 var arg_id = "foo";

7211 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7212 var obj = new api.FeaturesBatchPatchRequest.fromJson(json);

7213 checkFeaturesBatchPatchRequest(obj);

7214

7215 var path = (req.url).path;

7216 var pathOffset = 0;

7217 var index;

7218 var subPart;

7219 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7220 pathOffset += 1;

7221 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7222 pathOffset += 14;

7223 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7224 pathOffset += 7;

7225 index = path.indexOf("/features/batchPatch", pathOffset);

7226 unittest.expect(index >= 0, unittest.isTrue);

7227 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7228 pathOffset = index;

7229 unittest.expect(subPart, unittest.equals("$arg_id"));

7230 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/features/batchPatch"));

7231 pathOffset += 20;

7232

7233 var query = (req.url).query;

7234 var queryOffset = 0;

7235 var queryMap = {};

7236 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7237 parseBool(n) {

7238 if (n == "true") return true;

7239 if (n == "false") return false;

7240 if (n == null) return null;

7241 throw new core.ArgumentError("Invalid boolean: $n");

7242 }

7243 if (query.length > 0) {

7244 for (var part in query.split("&")) {

7245 var keyvalue = part.split("=");

7246 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7247 }

7248 }

7249

7250

7251 var h = {

7252 "content-type" : "application/json; charset=utf-8",

7253 };

7254 var resp = "";

7255 return new async.Future.value(stringResponse(200, h, resp));

7256 }), true);

7257 res.batchPatch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

7258 });

7259

7260 unittest.test("method--get", () {

7261

7262 var mock = new HttpServerMock();

7263 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

7264 var arg_tableId = "foo";

7265 var arg_id = "foo";

7266 var arg_select = "foo";

7267 var arg_version = "foo";

7268 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7269 var path = (req.url).path;

7270 var pathOffset = 0;

7271 var index;

7272 var subPart;

7273 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7274 pathOffset += 1;

7275 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7276 pathOffset += 14;

7277 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7278 pathOffset += 7;

7279 index = path.indexOf("/features/", pathOffset);

7280 unittest.expect(index >= 0, unittest.isTrue);

7281 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7282 pathOffset = index;

7283 unittest.expect(subPart, unittest.equals("$arg_tableId"));

7284 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/features/"));

7285 pathOffset += 10;

7286 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

7287 pathOffset = path.length;

7288 unittest.expect(subPart, unittest.equals("$arg_id"));

7289

7290 var query = (req.url).query;

7291 var queryOffset = 0;

7292 var queryMap = {};

7293 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7294 parseBool(n) {

7295 if (n == "true") return true;

7296 if (n == "false") return false;

7297 if (n == null) return null;

7298 throw new core.ArgumentError("Invalid boolean: $n");

7299 }

7300 if (query.length > 0) {

7301 for (var part in query.split("&")) {

7302 var keyvalue = part.split("=");

7303 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7304 }

7305 }

7306 unittest.expect(queryMap["select"].first, unittest.equals(arg_select));

7307 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

7308

7309

7310 var h = {

7311 "content-type" : "application/json; charset=utf-8",

7312 };

7313 var resp = convert.JSON.encode(buildFeature());

7314 return new async.Future.value(stringResponse(200, h, resp));

7315 }), true);

7316 res.get(arg_tableId, arg_id, select: arg_select, version: arg_version).the n(unittest.expectAsync(((api.Feature response) {

7317 checkFeature(response);

7318 })));

7319 });

7320

7321 unittest.test("method--list", () {

7322

7323 var mock = new HttpServerMock();

7324 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

7325 var arg_id = "foo";

7326 var arg_include = "foo";

7327 var arg_intersects = "foo";

7328 var arg_limit = 42;

7329 var arg_maxResults = 42;

7330 var arg_orderBy = "foo";

7331 var arg_pageToken = "foo";

7332 var arg_select = "foo";

7333 var arg_version = "foo";

7334 var arg_where = "foo";

7335 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7336 var path = (req.url).path;

7337 var pathOffset = 0;

7338 var index;

7339 var subPart;

7340 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7341 pathOffset += 1;

7342 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7343 pathOffset += 14;

7344 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7345 pathOffset += 7;

7346 index = path.indexOf("/features", pathOffset);

7347 unittest.expect(index >= 0, unittest.isTrue);

7348 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7349 pathOffset = index;

7350 unittest.expect(subPart, unittest.equals("$arg_id"));

7351 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/features"));

7352 pathOffset += 9;

7353

7354 var query = (req.url).query;

7355 var queryOffset = 0;

7356 var queryMap = {};

7357 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7358 parseBool(n) {

7359 if (n == "true") return true;

7360 if (n == "false") return false;

7361 if (n == null) return null;

7362 throw new core.ArgumentError("Invalid boolean: $n");

7363 }

7364 if (query.length > 0) {

7365 for (var part in query.split("&")) {

7366 var keyvalue = part.split("=");

7367 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7368 }

7369 }

7370 unittest.expect(queryMap["include"].first, unittest.equals(arg_include)) ;

7371 unittest.expect(queryMap["intersects"].first, unittest.equals(arg_inters ects));

7372 unittest.expect(core.int.parse(queryMap["limit"].first), unittest.equals (arg_limit));

7373 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

7374 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

7375 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

7376 unittest.expect(queryMap["select"].first, unittest.equals(arg_select));

7377 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

7378 unittest.expect(queryMap["where"].first, unittest.equals(arg_where));

7379

7380

7381 var h = {

7382 "content-type" : "application/json; charset=utf-8",

7383 };

7384 var resp = convert.JSON.encode(buildFeaturesListResponse());

7385 return new async.Future.value(stringResponse(200, h, resp));

7386 }), true);

7387 res.list(arg_id, include: arg_include, intersects: arg_intersects, limit: arg_limit, maxResults: arg_maxResults, orderBy: arg_orderBy, pageToken: arg_page Token, select: arg_select, version: arg_version, where: arg_where).then(unittest .expectAsync(((api.FeaturesListResponse response) {

7388 checkFeaturesListResponse(response);

7389 })));

7390 });

7391

7392 });

7393

7394

7395 unittest.group("resource-TablesFilesResourceApi", () {

7396 unittest.test("method--insert", () {

7397 // TODO: Implement tests for media upload;

7398 // TODO: Implement tests for media download;

7399

7400 var mock = new HttpServerMock();

7401 api.TablesFilesResourceApi res = new api.MapsengineApi(mock).tables.files;

7402 var arg_id = "foo";

7403 var arg_filename = "foo";

7404 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7405 var path = (req.url).path;

7406 var pathOffset = 0;

7407 var index;

7408 var subPart;

7409 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7410 pathOffset += 1;

7411 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7412 pathOffset += 14;

7413 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7414 pathOffset += 7;

7415 index = path.indexOf("/files", pathOffset);

7416 unittest.expect(index >= 0, unittest.isTrue);

7417 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7418 pathOffset = index;

7419 unittest.expect(subPart, unittest.equals("$arg_id"));

7420 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/files"));

7421 pathOffset += 6;

7422

7423 var query = (req.url).query;

7424 var queryOffset = 0;

7425 var queryMap = {};

7426 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7427 parseBool(n) {

7428 if (n == "true") return true;

7429 if (n == "false") return false;

7430 if (n == null) return null;

7431 throw new core.ArgumentError("Invalid boolean: $n");

7432 }

7433 if (query.length > 0) {

7434 for (var part in query.split("&")) {

7435 var keyvalue = part.split("=");

7436 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7437 }

7438 }

7439 unittest.expect(queryMap["filename"].first, unittest.equals(arg_filename ));

7440

7441

7442 var h = {

7443 "content-type" : "application/json; charset=utf-8",

7444 };

7445 var resp = "";

7446 return new async.Future.value(stringResponse(200, h, resp));

7447 }), true);

7448 res.insert(arg_id, arg_filename).then(unittest.expectAsync((_) {}));

7449 });

7450

7451 });

7452

7453

7454 unittest.group("resource-TablesParentsResourceApi", () {

7455 unittest.test("method--list", () {

7456

7457 var mock = new HttpServerMock();

7458 api.TablesParentsResourceApi res = new api.MapsengineApi(mock).tables.pare nts;

7459 var arg_id = "foo";

7460 var arg_maxResults = 42;

7461 var arg_pageToken = "foo";

7462 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7463 var path = (req.url).path;

7464 var pathOffset = 0;

7465 var index;

7466 var subPart;

7467 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7468 pathOffset += 1;

7469 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7470 pathOffset += 14;

7471 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7472 pathOffset += 7;

7473 index = path.indexOf("/parents", pathOffset);

7474 unittest.expect(index >= 0, unittest.isTrue);

7475 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7476 pathOffset = index;

7477 unittest.expect(subPart, unittest.equals("$arg_id"));

7478 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/parents"));

7479 pathOffset += 8;

7480

7481 var query = (req.url).query;

7482 var queryOffset = 0;

7483 var queryMap = {};

7484 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7485 parseBool(n) {

7486 if (n == "true") return true;

7487 if (n == "false") return false;

7488 if (n == null) return null;

7489 throw new core.ArgumentError("Invalid boolean: $n");

7490 }

7491 if (query.length > 0) {

7492 for (var part in query.split("&")) {

7493 var keyvalue = part.split("=");

7494 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7495 }

7496 }

7497 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

7498 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

7499

7500

7501 var h = {

7502 "content-type" : "application/json; charset=utf-8",

7503 };

7504 var resp = convert.JSON.encode(buildParentsListResponse());

7505 return new async.Future.value(stringResponse(200, h, resp));

7506 }), true);

7507 res.list(arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken).the n(unittest.expectAsync(((api.ParentsListResponse response) {

7508 checkParentsListResponse(response);

7509 })));

7510 });

7511

7512 });

7513

7514

7515 unittest.group("resource-TablesPermissionsResourceApi", () {

7516 unittest.test("method--batchDelete", () {

7517

7518 var mock = new HttpServerMock();

7519 api.TablesPermissionsResourceApi res = new api.MapsengineApi(mock).tables. permissions;

7520 var arg_request = buildPermissionsBatchDeleteRequest();

7521 var arg_id = "foo";

7522 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7523 var obj = new api.PermissionsBatchDeleteRequest.fromJson(json);

7524 checkPermissionsBatchDeleteRequest(obj);

7525

7526 var path = (req.url).path;

7527 var pathOffset = 0;

7528 var index;

7529 var subPart;

7530 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7531 pathOffset += 1;

7532 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7533 pathOffset += 14;

7534 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7535 pathOffset += 7;

7536 index = path.indexOf("/permissions/batchDelete", pathOffset);

7537 unittest.expect(index >= 0, unittest.isTrue);

7538 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7539 pathOffset = index;

7540 unittest.expect(subPart, unittest.equals("$arg_id"));

7541 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchDelete"));

7542 pathOffset += 24;

7543

7544 var query = (req.url).query;

7545 var queryOffset = 0;

7546 var queryMap = {};

7547 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7548 parseBool(n) {

7549 if (n == "true") return true;

7550 if (n == "false") return false;

7551 if (n == null) return null;

7552 throw new core.ArgumentError("Invalid boolean: $n");

7553 }

7554 if (query.length > 0) {

7555 for (var part in query.split("&")) {

7556 var keyvalue = part.split("=");

7557 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7558 }

7559 }

7560

7561

7562 var h = {

7563 "content-type" : "application/json; charset=utf-8",

7564 };

7565 var resp = convert.JSON.encode(buildPermissionsBatchDeleteResponse());

7566 return new async.Future.value(stringResponse(200, h, resp));

7567 }), true);

7568 res.batchDelete(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchDeleteResponse response) {

7569 checkPermissionsBatchDeleteResponse(response);

7570 })));

7571 });

7572

7573 unittest.test("method--batchUpdate", () {

7574

7575 var mock = new HttpServerMock();

7576 api.TablesPermissionsResourceApi res = new api.MapsengineApi(mock).tables. permissions;

7577 var arg_request = buildPermissionsBatchUpdateRequest();

7578 var arg_id = "foo";

7579 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7580 var obj = new api.PermissionsBatchUpdateRequest.fromJson(json);

7581 checkPermissionsBatchUpdateRequest(obj);

7582

7583 var path = (req.url).path;

7584 var pathOffset = 0;

7585 var index;

7586 var subPart;

7587 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7588 pathOffset += 1;

7589 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7590 pathOffset += 14;

7591 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7592 pathOffset += 7;

7593 index = path.indexOf("/permissions/batchUpdate", pathOffset);

7594 unittest.expect(index >= 0, unittest.isTrue);

7595 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7596 pathOffset = index;

7597 unittest.expect(subPart, unittest.equals("$arg_id"));

7598 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/permissions/batchUpdate"));

7599 pathOffset += 24;

7600

7601 var query = (req.url).query;

7602 var queryOffset = 0;

7603 var queryMap = {};

7604 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7605 parseBool(n) {

7606 if (n == "true") return true;

7607 if (n == "false") return false;

7608 if (n == null) return null;

7609 throw new core.ArgumentError("Invalid boolean: $n");

7610 }

7611 if (query.length > 0) {

7612 for (var part in query.split("&")) {

7613 var keyvalue = part.split("=");

7614 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7615 }

7616 }

7617

7618

7619 var h = {

7620 "content-type" : "application/json; charset=utf-8",

7621 };

7622 var resp = convert.JSON.encode(buildPermissionsBatchUpdateResponse());

7623 return new async.Future.value(stringResponse(200, h, resp));

7624 }), true);

7625 res.batchUpdate(arg_request, arg_id).then(unittest.expectAsync(((api.Permi ssionsBatchUpdateResponse response) {

7626 checkPermissionsBatchUpdateResponse(response);

7627 })));

7628 });

7629

7630 unittest.test("method--list", () {

7631

7632 var mock = new HttpServerMock();

7633 api.TablesPermissionsResourceApi res = new api.MapsengineApi(mock).tables. permissions;

7634 var arg_id = "foo";

7635 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7636 var path = (req.url).path;

7637 var pathOffset = 0;

7638 var index;

7639 var subPart;

7640 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

7641 pathOffset += 1;

7642 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("mapsengine/v1/"));

7643 pathOffset += 14;

7644 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

7645 pathOffset += 7;

7646 index = path.indexOf("/permissions", pathOffset);

7647 unittest.expect(index >= 0, unittest.isTrue);

7648 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7649 pathOffset = index;

7650 unittest.expect(subPart, unittest.equals("$arg_id"));

7651 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/permissions"));

7652 pathOffset += 12;

7653

7654 var query = (req.url).query;

7655 var queryOffset = 0;

7656 var queryMap = {};

7657 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7658 parseBool(n) {

7659 if (n == "true") return true;

7660 if (n == "false") return false;

7661 if (n == null) return null;

7662 throw new core.ArgumentError("Invalid boolean: $n");

7663 }

7664 if (query.length > 0) {

7665 for (var part in query.split("&")) {

7666 var keyvalue = part.split("=");

7667 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7668 }

7669 }

7670

7671

7672 var h = {

7673 "content-type" : "application/json; charset=utf-8",

7674 };

7675 var resp = convert.JSON.encode(buildPermissionsListResponse());

7676 return new async.Future.value(stringResponse(200, h, resp));

7677 }), true);

7678 res.list(arg_id).then(unittest.expectAsync(((api.PermissionsListResponse r esponse) {

7679 checkPermissionsListResponse(response);

7680 })));

7681 });

7682

7683 });

7684

7685

7686 }

7687

OLD	NEW

« no previous file with comments | « generated/googleapis/test/licensing/v1_test.dart ('k') | generated/googleapis/test/mirror/v1_test.dart » ('j') | no next file with comments »