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

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

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

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

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

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 library googleapis.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 import 'package:googleapis/common/common.dart' as common;

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

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

14

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

16

17

18

19 core.int buildCounterAcquisitionTime = 0;

20 buildAcquisitionTime() {

21 var o = new api.AcquisitionTime();

22 buildCounterAcquisitionTime++;

23 if (buildCounterAcquisitionTime < 3) {

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

25 o.precision = "foo";

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

27 }

28 buildCounterAcquisitionTime--;

29 return o;

30 }

31

32 checkAcquisitionTime(api.AcquisitionTime o) {

33 buildCounterAcquisitionTime++;

34 if (buildCounterAcquisitionTime < 3) {

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

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

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

38 }

39 buildCounterAcquisitionTime--;

40 }

41

42 buildUnnamed91() {

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

44 o.add(42.0);

45 o.add(42.0);

46 return o;

47 }

48

49 checkUnnamed91(core.List<core.double> o) {

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

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

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

53 }

54

55 buildUnnamed92() {

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

57 o.add("foo");

58 o.add("foo");

59 return o;

60 }

61

62 checkUnnamed92(core.List<core.String> o) {

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

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

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

66 }

67

68 core.int buildCounterAsset = 0;

69 buildAsset() {

70 var o = new api.Asset();

71 buildCounterAsset++;

72 if (buildCounterAsset < 3) {

73 o.bbox = buildUnnamed91();

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

75 o.description = "foo";

76 o.etag = "foo";

77 o.id = "foo";

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

79 o.name = "foo";

80 o.projectId = "foo";

81 o.resource = "foo";

82 o.tags = buildUnnamed92();

83 o.type = "foo";

84 }

85 buildCounterAsset--;

86 return o;

87 }

88

89 checkAsset(api.Asset o) {

90 buildCounterAsset++;

91 if (buildCounterAsset < 3) {

92 checkUnnamed91(o.bbox);

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

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

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

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

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

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

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

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

101 checkUnnamed92(o.tags);

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

103 }

104 buildCounterAsset--;

105 }

106

107 buildUnnamed93() {

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

109 o.add(buildAsset());

110 o.add(buildAsset());

111 return o;

112 }

113

114 checkUnnamed93(core.List<api.Asset> o) {

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

116 checkAsset(o[0]);

117 checkAsset(o[1]);

118 }

119

120 core.int buildCounterAssetsListResponse = 0;

121 buildAssetsListResponse() {

122 var o = new api.AssetsListResponse();

123 buildCounterAssetsListResponse++;

124 if (buildCounterAssetsListResponse < 3) {

125 o.assets = buildUnnamed93();

126 o.nextPageToken = "foo";

127 }

128 buildCounterAssetsListResponse--;

129 return o;

130 }

131

132 checkAssetsListResponse(api.AssetsListResponse o) {

133 buildCounterAssetsListResponse++;

134 if (buildCounterAssetsListResponse < 3) {

135 checkUnnamed93(o.assets);

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

137 }

138 buildCounterAssetsListResponse--;

139 }

140

141 core.int buildCounterBorder = 0;

142 buildBorder() {

143 var o = new api.Border();

144 buildCounterBorder++;

145 if (buildCounterBorder < 3) {

146 o.color = "foo";

147 o.opacity = 42.0;

148 o.width = 42.0;

149 }

150 buildCounterBorder--;

151 return o;

152 }

153

154 checkBorder(api.Border o) {

155 buildCounterBorder++;

156 if (buildCounterBorder < 3) {

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

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

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

160 }

161 buildCounterBorder--;

162 }

163

164 core.int buildCounterColor = 0;

165 buildColor() {

166 var o = new api.Color();

167 buildCounterColor++;

168 if (buildCounterColor < 3) {

169 o.color = "foo";

170 o.opacity = 42.0;

171 }

172 buildCounterColor--;

173 return o;

174 }

175

176 checkColor(api.Color o) {

177 buildCounterColor++;

178 if (buildCounterColor < 3) {

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

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

181 }

182 buildCounterColor--;

183 }

184

185 core.int buildCounterDatasource = 0;

186 buildDatasource() {

187 var o = new api.Datasource();

188 buildCounterDatasource++;

189 if (buildCounterDatasource < 3) {

190 o.id = "foo";

191 }

192 buildCounterDatasource--;

193 return o;

194 }

195

196 checkDatasource(api.Datasource o) {

197 buildCounterDatasource++;

198 if (buildCounterDatasource < 3) {

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

200 }

201 buildCounterDatasource--;

202 }

203

204 buildDatasources() {

205 var o = new api.Datasources();

206 o.add(buildDatasource());

207 o.add(buildDatasource());

208 return o;

209 }

210

211 checkDatasources(api.Datasources o) {

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

213 checkDatasource(o[0]);

214 checkDatasource(o[1]);

215 }

216

217 buildUnnamed94() {

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

219 o.add(buildFilter());

220 o.add(buildFilter());

221 return o;

222 }

223

224 checkUnnamed94(core.List<api.Filter> o) {

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

226 checkFilter(o[0]);

227 checkFilter(o[1]);

228 }

229

230 core.int buildCounterDisplayRule = 0;

231 buildDisplayRule() {

232 var o = new api.DisplayRule();

233 buildCounterDisplayRule++;

234 if (buildCounterDisplayRule < 3) {

235 o.filters = buildUnnamed94();

236 o.lineOptions = buildLineStyle();

237 o.name = "foo";

238 o.pointOptions = buildPointStyle();

239 o.polygonOptions = buildPolygonStyle();

240 o.zoomLevels = buildZoomLevels();

241 }

242 buildCounterDisplayRule--;

243 return o;

244 }

245

246 checkDisplayRule(api.DisplayRule o) {

247 buildCounterDisplayRule++;

248 if (buildCounterDisplayRule < 3) {

249 checkUnnamed94(o.filters);

250 checkLineStyle(o.lineOptions);

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

252 checkPointStyle(o.pointOptions);

253 checkPolygonStyle(o.polygonOptions);

254 checkZoomLevels(o.zoomLevels);

255 }

256 buildCounterDisplayRule--;

257 }

258

259 core.int buildCounterFeature = 0;

260 buildFeature() {

261 var o = new api.Feature();

262 buildCounterFeature++;

263 if (buildCounterFeature < 3) {

264 o.geometry = buildGeoJsonGeometry();

265 o.properties = buildGeoJsonProperties();

266 o.type = "foo";

267 }

268 buildCounterFeature--;

269 return o;

270 }

271

272 checkFeature(api.Feature o) {

273 buildCounterFeature++;

274 if (buildCounterFeature < 3) {

275 checkGeoJsonGeometry(o.geometry);

276 checkGeoJsonProperties(o.properties);

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

278 }

279 buildCounterFeature--;

280 }

281

282 core.int buildCounterFeatureInfo = 0;

283 buildFeatureInfo() {

284 var o = new api.FeatureInfo();

285 buildCounterFeatureInfo++;

286 if (buildCounterFeatureInfo < 3) {

287 o.content = "foo";

288 }

289 buildCounterFeatureInfo--;

290 return o;

291 }

292

293 checkFeatureInfo(api.FeatureInfo o) {

294 buildCounterFeatureInfo++;

295 if (buildCounterFeatureInfo < 3) {

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

297 }

298 buildCounterFeatureInfo--;

299 }

300

301 buildUnnamed95() {

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

303 o.add("foo");

304 o.add("foo");

305 return o;

306 }

307

308 checkUnnamed95(core.List<core.String> o) {

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

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

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

312 }

313

314 buildUnnamed96() {

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

316 o.add("foo");

317 o.add("foo");

318 return o;

319 }

320

321 checkUnnamed96(core.List<core.String> o) {

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

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

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

325 }

326

327 core.int buildCounterFeaturesBatchDeleteRequest = 0;

328 buildFeaturesBatchDeleteRequest() {

329 var o = new api.FeaturesBatchDeleteRequest();

330 buildCounterFeaturesBatchDeleteRequest++;

331 if (buildCounterFeaturesBatchDeleteRequest < 3) {

332 o.gxIds = buildUnnamed95();

333 o.primaryKeys = buildUnnamed96();

334 }

335 buildCounterFeaturesBatchDeleteRequest--;

336 return o;

337 }

338

339 checkFeaturesBatchDeleteRequest(api.FeaturesBatchDeleteRequest o) {

340 buildCounterFeaturesBatchDeleteRequest++;

341 if (buildCounterFeaturesBatchDeleteRequest < 3) {

342 checkUnnamed95(o.gxIds);

343 checkUnnamed96(o.primaryKeys);

344 }

345 buildCounterFeaturesBatchDeleteRequest--;

346 }

347

348 buildUnnamed97() {

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

350 o.add(buildFeature());

351 o.add(buildFeature());

352 return o;

353 }

354

355 checkUnnamed97(core.List<api.Feature> o) {

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

357 checkFeature(o[0]);

358 checkFeature(o[1]);

359 }

360

361 core.int buildCounterFeaturesBatchInsertRequest = 0;

362 buildFeaturesBatchInsertRequest() {

363 var o = new api.FeaturesBatchInsertRequest();

364 buildCounterFeaturesBatchInsertRequest++;

365 if (buildCounterFeaturesBatchInsertRequest < 3) {

366 o.features = buildUnnamed97();

367 o.normalizeGeometries = true;

368 }

369 buildCounterFeaturesBatchInsertRequest--;

370 return o;

371 }

372

373 checkFeaturesBatchInsertRequest(api.FeaturesBatchInsertRequest o) {

374 buildCounterFeaturesBatchInsertRequest++;

375 if (buildCounterFeaturesBatchInsertRequest < 3) {

376 checkUnnamed97(o.features);

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

378 }

379 buildCounterFeaturesBatchInsertRequest--;

380 }

381

382 buildUnnamed98() {

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

384 o.add(buildFeature());

385 o.add(buildFeature());

386 return o;

387 }

388

389 checkUnnamed98(core.List<api.Feature> o) {

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

391 checkFeature(o[0]);

392 checkFeature(o[1]);

393 }

394

395 core.int buildCounterFeaturesBatchPatchRequest = 0;

396 buildFeaturesBatchPatchRequest() {

397 var o = new api.FeaturesBatchPatchRequest();

398 buildCounterFeaturesBatchPatchRequest++;

399 if (buildCounterFeaturesBatchPatchRequest < 3) {

400 o.features = buildUnnamed98();

401 o.normalizeGeometries = true;

402 }

403 buildCounterFeaturesBatchPatchRequest--;

404 return o;

405 }

406

407 checkFeaturesBatchPatchRequest(api.FeaturesBatchPatchRequest o) {

408 buildCounterFeaturesBatchPatchRequest++;

409 if (buildCounterFeaturesBatchPatchRequest < 3) {

410 checkUnnamed98(o.features);

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

412 }

413 buildCounterFeaturesBatchPatchRequest--;

414 }

415

416 buildUnnamed99() {

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

418 o.add(buildFeature());

419 o.add(buildFeature());

420 return o;

421 }

422

423 checkUnnamed99(core.List<api.Feature> o) {

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

425 checkFeature(o[0]);

426 checkFeature(o[1]);

427 }

428

429 core.int buildCounterFeaturesListResponse = 0;

430 buildFeaturesListResponse() {

431 var o = new api.FeaturesListResponse();

432 buildCounterFeaturesListResponse++;

433 if (buildCounterFeaturesListResponse < 3) {

434 o.allowedQueriesPerSecond = 42.0;

435 o.features = buildUnnamed99();

436 o.nextPageToken = "foo";

437 o.schema = buildSchema();

438 o.type = "foo";

439 }

440 buildCounterFeaturesListResponse--;

441 return o;

442 }

443

444 checkFeaturesListResponse(api.FeaturesListResponse o) {

445 buildCounterFeaturesListResponse++;

446 if (buildCounterFeaturesListResponse < 3) {

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

448 checkUnnamed99(o.features);

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

450 checkSchema(o.schema);

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

452 }

453 buildCounterFeaturesListResponse--;

454 }

455

456 core.int buildCounterFile = 0;

457 buildFile() {

458 var o = new api.File();

459 buildCounterFile++;

460 if (buildCounterFile < 3) {

461 o.filename = "foo";

462 o.size = "foo";

463 o.uploadStatus = "foo";

464 }

465 buildCounterFile--;

466 return o;

467 }

468

469 checkFile(api.File o) {

470 buildCounterFile++;

471 if (buildCounterFile < 3) {

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

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

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

475 }

476 buildCounterFile--;

477 }

478

479 core.int buildCounterFilter = 0;

480 buildFilter() {

481 var o = new api.Filter();

482 buildCounterFilter++;

483 if (buildCounterFilter < 3) {

484 o.column = "foo";

485 o.operator = "foo";

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

487 }

488 buildCounterFilter--;

489 return o;

490 }

491

492 checkFilter(api.Filter o) {

493 buildCounterFilter++;

494 if (buildCounterFilter < 3) {

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

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

497 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'));

498 }

499 buildCounterFilter--;

500 }

501

502 buildGeoJsonGeometry() {

503 return buildGeoJsonGeometryCollection();

504 }

505

506 checkGeoJsonGeometry(api.GeoJsonGeometry o) {

507 checkGeoJsonGeometryCollection(api.GeoJsonGeometryCollection o) {

508 buildCounterGeoJsonGeometryCollection++;

509 if (buildCounterGeoJsonGeometryCollection < 3) {

510 checkUnnamed100(o.geometries);

511 }

512 buildCounterGeoJsonGeometryCollection--;

513 }

514

515 (o);

516 }

517

518 buildUnnamed100() {

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

520 o.add(buildGeoJsonGeometry());

521 o.add(buildGeoJsonGeometry());

522 return o;

523 }

524

525 checkUnnamed100(core.List<api.GeoJsonGeometry> o) {

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

527 checkGeoJsonGeometry(o[0]);

528 checkGeoJsonGeometry(o[1]);

529 }

530

531 core.int buildCounterGeoJsonGeometryCollection = 0;

532 buildGeoJsonGeometryCollection() {

533 var o = new api.GeoJsonGeometryCollection();

534 buildCounterGeoJsonGeometryCollection++;

535 if (buildCounterGeoJsonGeometryCollection < 3) {

536 o.geometries = buildUnnamed100();

537 }

538 buildCounterGeoJsonGeometryCollection--;

539 return o;

540 }

541

542 checkGeoJsonGeometryCollection(api.GeoJsonGeometryCollection o) {

543 buildCounterGeoJsonGeometryCollection++;

544 if (buildCounterGeoJsonGeometryCollection < 3) {

545 checkUnnamed100(o.geometries);

546 }

547 buildCounterGeoJsonGeometryCollection--;

548 }

549

550 buildUnnamed101() {

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

552 o.add(buildGeoJsonPosition());

553 o.add(buildGeoJsonPosition());

554 return o;

555 }

556

557 checkUnnamed101(core.List<api.GeoJsonPosition> o) {

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

559 checkGeoJsonPosition(o[0]);

560 checkGeoJsonPosition(o[1]);

561 }

562

563 core.int buildCounterGeoJsonLineString = 0;

564 buildGeoJsonLineString() {

565 var o = new api.GeoJsonLineString();

566 buildCounterGeoJsonLineString++;

567 if (buildCounterGeoJsonLineString < 3) {

568 o.coordinates = buildUnnamed101();

569 }

570 buildCounterGeoJsonLineString--;

571 return o;

572 }

573

574 checkGeoJsonLineString(api.GeoJsonLineString o) {

575 buildCounterGeoJsonLineString++;

576 if (buildCounterGeoJsonLineString < 3) {

577 checkUnnamed101(o.coordinates);

578 }

579 buildCounterGeoJsonLineString--;

580 }

581

582 buildUnnamed102() {

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

584 o.add(buildGeoJsonPosition());

585 o.add(buildGeoJsonPosition());

586 return o;

587 }

588

589 checkUnnamed102(core.List<api.GeoJsonPosition> o) {

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

591 checkGeoJsonPosition(o[0]);

592 checkGeoJsonPosition(o[1]);

593 }

594

595 buildUnnamed103() {

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

597 o.add(buildUnnamed102());

598 o.add(buildUnnamed102());

599 return o;

600 }

601

602 checkUnnamed103(core.List<core.List<api.GeoJsonPosition>> o) {

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

604 checkUnnamed102(o[0]);

605 checkUnnamed102(o[1]);

606 }

607

608 core.int buildCounterGeoJsonMultiLineString = 0;

609 buildGeoJsonMultiLineString() {

610 var o = new api.GeoJsonMultiLineString();

611 buildCounterGeoJsonMultiLineString++;

612 if (buildCounterGeoJsonMultiLineString < 3) {

613 o.coordinates = buildUnnamed103();

614 }

615 buildCounterGeoJsonMultiLineString--;

616 return o;

617 }

618

619 checkGeoJsonMultiLineString(api.GeoJsonMultiLineString o) {

620 buildCounterGeoJsonMultiLineString++;

621 if (buildCounterGeoJsonMultiLineString < 3) {

622 checkUnnamed103(o.coordinates);

623 }

624 buildCounterGeoJsonMultiLineString--;

625 }

626

627 buildUnnamed104() {

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

629 o.add(buildGeoJsonPosition());

630 o.add(buildGeoJsonPosition());

631 return o;

632 }

633

634 checkUnnamed104(core.List<api.GeoJsonPosition> o) {

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

636 checkGeoJsonPosition(o[0]);

637 checkGeoJsonPosition(o[1]);

638 }

639

640 core.int buildCounterGeoJsonMultiPoint = 0;

641 buildGeoJsonMultiPoint() {

642 var o = new api.GeoJsonMultiPoint();

643 buildCounterGeoJsonMultiPoint++;

644 if (buildCounterGeoJsonMultiPoint < 3) {

645 o.coordinates = buildUnnamed104();

646 }

647 buildCounterGeoJsonMultiPoint--;

648 return o;

649 }

650

651 checkGeoJsonMultiPoint(api.GeoJsonMultiPoint o) {

652 buildCounterGeoJsonMultiPoint++;

653 if (buildCounterGeoJsonMultiPoint < 3) {

654 checkUnnamed104(o.coordinates);

655 }

656 buildCounterGeoJsonMultiPoint--;

657 }

658

659 buildUnnamed105() {

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

661 o.add(buildGeoJsonPosition());

662 o.add(buildGeoJsonPosition());

663 return o;

664 }

665

666 checkUnnamed105(core.List<api.GeoJsonPosition> o) {

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

668 checkGeoJsonPosition(o[0]);

669 checkGeoJsonPosition(o[1]);

670 }

671

672 buildUnnamed106() {

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

674 o.add(buildUnnamed105());

675 o.add(buildUnnamed105());

676 return o;

677 }

678

679 checkUnnamed106(core.List<core.List<api.GeoJsonPosition>> o) {

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

681 checkUnnamed105(o[0]);

682 checkUnnamed105(o[1]);

683 }

684

685 buildUnnamed107() {

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

687 o.add(buildUnnamed106());

688 o.add(buildUnnamed106());

689 return o;

690 }

691

692 checkUnnamed107(core.List<core.List<core.List<api.GeoJsonPosition>>> o) {

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

694 checkUnnamed106(o[0]);

695 checkUnnamed106(o[1]);

696 }

697

698 core.int buildCounterGeoJsonMultiPolygon = 0;

699 buildGeoJsonMultiPolygon() {

700 var o = new api.GeoJsonMultiPolygon();

701 buildCounterGeoJsonMultiPolygon++;

702 if (buildCounterGeoJsonMultiPolygon < 3) {

703 o.coordinates = buildUnnamed107();

704 }

705 buildCounterGeoJsonMultiPolygon--;

706 return o;

707 }

708

709 checkGeoJsonMultiPolygon(api.GeoJsonMultiPolygon o) {

710 buildCounterGeoJsonMultiPolygon++;

711 if (buildCounterGeoJsonMultiPolygon < 3) {

712 checkUnnamed107(o.coordinates);

713 }

714 buildCounterGeoJsonMultiPolygon--;

715 }

716

717 core.int buildCounterGeoJsonPoint = 0;

718 buildGeoJsonPoint() {

719 var o = new api.GeoJsonPoint();

720 buildCounterGeoJsonPoint++;

721 if (buildCounterGeoJsonPoint < 3) {

722 o.coordinates = buildGeoJsonPosition();

723 }

724 buildCounterGeoJsonPoint--;

725 return o;

726 }

727

728 checkGeoJsonPoint(api.GeoJsonPoint o) {

729 buildCounterGeoJsonPoint++;

730 if (buildCounterGeoJsonPoint < 3) {

731 checkGeoJsonPosition(o.coordinates);

732 }

733 buildCounterGeoJsonPoint--;

734 }

735

736 buildUnnamed108() {

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

738 o.add(buildGeoJsonPosition());

739 o.add(buildGeoJsonPosition());

740 return o;

741 }

742

743 checkUnnamed108(core.List<api.GeoJsonPosition> o) {

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

745 checkGeoJsonPosition(o[0]);

746 checkGeoJsonPosition(o[1]);

747 }

748

749 buildUnnamed109() {

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

751 o.add(buildUnnamed108());

752 o.add(buildUnnamed108());

753 return o;

754 }

755

756 checkUnnamed109(core.List<core.List<api.GeoJsonPosition>> o) {

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

758 checkUnnamed108(o[0]);

759 checkUnnamed108(o[1]);

760 }

761

762 core.int buildCounterGeoJsonPolygon = 0;

763 buildGeoJsonPolygon() {

764 var o = new api.GeoJsonPolygon();

765 buildCounterGeoJsonPolygon++;

766 if (buildCounterGeoJsonPolygon < 3) {

767 o.coordinates = buildUnnamed109();

768 }

769 buildCounterGeoJsonPolygon--;

770 return o;

771 }

772

773 checkGeoJsonPolygon(api.GeoJsonPolygon o) {

774 buildCounterGeoJsonPolygon++;

775 if (buildCounterGeoJsonPolygon < 3) {

776 checkUnnamed109(o.coordinates);

777 }

778 buildCounterGeoJsonPolygon--;

779 }

780

781 buildGeoJsonPosition() {

782 var o = new api.GeoJsonPosition();

783 o.add(42.0);

784 o.add(42.0);

785 return o;

786 }

787

788 checkGeoJsonPosition(api.GeoJsonPosition o) {

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

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

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

792 }

793

794 buildGeoJsonProperties() {

795 var o = new api.GeoJsonProperties();

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

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

798 return o;

799 }

800

801 checkGeoJsonProperties(api.GeoJsonProperties o) {

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

803 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'));

804 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'));

805 }

806

807 core.int buildCounterIcon = 0;

808 buildIcon() {

809 var o = new api.Icon();

810 buildCounterIcon++;

811 if (buildCounterIcon < 3) {

812 o.description = "foo";

813 o.id = "foo";

814 o.name = "foo";

815 }

816 buildCounterIcon--;

817 return o;

818 }

819

820 checkIcon(api.Icon o) {

821 buildCounterIcon++;

822 if (buildCounterIcon < 3) {

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

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

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

826 }

827 buildCounterIcon--;

828 }

829

830 core.int buildCounterIconStyle = 0;

831 buildIconStyle() {

832 var o = new api.IconStyle();

833 buildCounterIconStyle++;

834 if (buildCounterIconStyle < 3) {

835 o.id = "foo";

836 o.name = "foo";

837 o.scaledShape = buildScaledShape();

838 o.scalingFunction = buildScalingFunction();

839 }

840 buildCounterIconStyle--;

841 return o;

842 }

843

844 checkIconStyle(api.IconStyle o) {

845 buildCounterIconStyle++;

846 if (buildCounterIconStyle < 3) {

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

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

849 checkScaledShape(o.scaledShape);

850 checkScalingFunction(o.scalingFunction);

851 }

852 buildCounterIconStyle--;

853 }

854

855 buildUnnamed110() {

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

857 o.add(buildIcon());

858 o.add(buildIcon());

859 return o;

860 }

861

862 checkUnnamed110(core.List<api.Icon> o) {

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

864 checkIcon(o[0]);

865 checkIcon(o[1]);

866 }

867

868 core.int buildCounterIconsListResponse = 0;

869 buildIconsListResponse() {

870 var o = new api.IconsListResponse();

871 buildCounterIconsListResponse++;

872 if (buildCounterIconsListResponse < 3) {

873 o.icons = buildUnnamed110();

874 o.nextPageToken = "foo";

875 }

876 buildCounterIconsListResponse--;

877 return o;

878 }

879

880 checkIconsListResponse(api.IconsListResponse o) {

881 buildCounterIconsListResponse++;

882 if (buildCounterIconsListResponse < 3) {

883 checkUnnamed110(o.icons);

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

885 }

886 buildCounterIconsListResponse--;

887 }

888

889 core.int buildCounterLabelStyle = 0;

890 buildLabelStyle() {

891 var o = new api.LabelStyle();

892 buildCounterLabelStyle++;

893 if (buildCounterLabelStyle < 3) {

894 o.color = "foo";

895 o.column = "foo";

896 o.fontStyle = "foo";

897 o.fontWeight = "foo";

898 o.opacity = 42.0;

899 o.outline = buildColor();

900 o.size = 42.0;

901 }

902 buildCounterLabelStyle--;

903 return o;

904 }

905

906 checkLabelStyle(api.LabelStyle o) {

907 buildCounterLabelStyle++;

908 if (buildCounterLabelStyle < 3) {

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

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

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

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

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

914 checkColor(o.outline);

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

916 }

917 buildCounterLabelStyle--;

918 }

919

920 buildLatLngBox() {

921 var o = new api.LatLngBox();

922 o.add(42.0);

923 o.add(42.0);

924 return o;

925 }

926

927 checkLatLngBox(api.LatLngBox o) {

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

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

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

931 }

932

933 buildUnnamed111() {

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

935 o.add(42.0);

936 o.add(42.0);

937 return o;

938 }

939

940 checkUnnamed111(core.List<core.double> o) {

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

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

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

944 }

945

946 core.int buildCounterLayer = 0;

947 buildLayer() {

948 var o = new api.Layer();

949 buildCounterLayer++;

950 if (buildCounterLayer < 3) {

951 o.bbox = buildUnnamed111();

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

953 o.datasourceType = "foo";

954 o.datasources = buildDatasources();

955 o.description = "foo";

956 o.draftAccessList = "foo";

957 o.etag = "foo";

958 o.id = "foo";

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

960 o.layerType = "foo";

961 o.name = "foo";

962 o.processingStatus = "foo";

963 o.projectId = "foo";

964 o.publishedAccessList = "foo";

965 o.publishingStatus = "foo";

966 o.style = buildVectorStyle();

967 o.tags = buildTags();

968 }

969 buildCounterLayer--;

970 return o;

971 }

972

973 checkLayer(api.Layer o) {

974 buildCounterLayer++;

975 if (buildCounterLayer < 3) {

976 checkUnnamed111(o.bbox);

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

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

979 checkDatasources(o.datasources);

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

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

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

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

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

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

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

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

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

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

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

991 checkVectorStyle(o.style);

992 checkTags(o.tags);

993 }

994 buildCounterLayer--;

995 }

996

997 buildUnnamed112() {

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

999 o.add(buildLayer());

1000 o.add(buildLayer());

1001 return o;

1002 }

1003

1004 checkUnnamed112(core.List<api.Layer> o) {

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

1006 checkLayer(o[0]);

1007 checkLayer(o[1]);

1008 }

1009

1010 core.int buildCounterLayersListResponse = 0;

1011 buildLayersListResponse() {

1012 var o = new api.LayersListResponse();

1013 buildCounterLayersListResponse++;

1014 if (buildCounterLayersListResponse < 3) {

1015 o.layers = buildUnnamed112();

1016 o.nextPageToken = "foo";

1017 }

1018 buildCounterLayersListResponse--;

1019 return o;

1020 }

1021

1022 checkLayersListResponse(api.LayersListResponse o) {

1023 buildCounterLayersListResponse++;

1024 if (buildCounterLayersListResponse < 3) {

1025 checkUnnamed112(o.layers);

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

1027 }

1028 buildCounterLayersListResponse--;

1029 }

1030

1031 buildUnnamed113() {

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

1033 o.add(42.0);

1034 o.add(42.0);

1035 return o;

1036 }

1037

1038 checkUnnamed113(core.List<core.double> o) {

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

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

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

1042 }

1043

1044 core.int buildCounterLineStyleStroke = 0;

1045 buildLineStyleStroke() {

1046 var o = new api.LineStyleStroke();

1047 buildCounterLineStyleStroke++;

1048 if (buildCounterLineStyleStroke < 3) {

1049 o.color = "foo";

1050 o.opacity = 42.0;

1051 o.width = 42.0;

1052 }

1053 buildCounterLineStyleStroke--;

1054 return o;

1055 }

1056

1057 checkLineStyleStroke(api.LineStyleStroke o) {

1058 buildCounterLineStyleStroke++;

1059 if (buildCounterLineStyleStroke < 3) {

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

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

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

1063 }

1064 buildCounterLineStyleStroke--;

1065 }

1066

1067 core.int buildCounterLineStyle = 0;

1068 buildLineStyle() {

1069 var o = new api.LineStyle();

1070 buildCounterLineStyle++;

1071 if (buildCounterLineStyle < 3) {

1072 o.border = buildBorder();

1073 o.dash = buildUnnamed113();

1074 o.label = buildLabelStyle();

1075 o.stroke = buildLineStyleStroke();

1076 }

1077 buildCounterLineStyle--;

1078 return o;

1079 }

1080

1081 checkLineStyle(api.LineStyle o) {

1082 buildCounterLineStyle++;

1083 if (buildCounterLineStyle < 3) {

1084 checkBorder(o.border);

1085 checkUnnamed113(o.dash);

1086 checkLabelStyle(o.label);

1087 checkLineStyleStroke(o.stroke);

1088 }

1089 buildCounterLineStyle--;

1090 }

1091

1092 buildUnnamed114() {

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

1094 o.add(42.0);

1095 o.add(42.0);

1096 return o;

1097 }

1098

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

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

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

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

1103 }

1104

1105 buildUnnamed115() {

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

1107 o.add("foo");

1108 o.add("foo");

1109 return o;

1110 }

1111

1112 checkUnnamed115(core.List<core.String> o) {

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

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

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

1116 }

1117

1118 core.int buildCounterMap = 0;

1119 buildMap() {

1120 var o = new api.Map();

1121 buildCounterMap++;

1122 if (buildCounterMap < 3) {

1123 o.bbox = buildUnnamed114();

1124 o.contents = buildMapContents();

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

1126 o.defaultViewport = buildLatLngBox();

1127 o.description = "foo";

1128 o.draftAccessList = "foo";

1129 o.etag = "foo";

1130 o.id = "foo";

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

1132 o.name = "foo";

1133 o.processingStatus = "foo";

1134 o.projectId = "foo";

1135 o.publishedAccessList = "foo";

1136 o.publishingStatus = "foo";

1137 o.tags = buildTags();

1138 o.versions = buildUnnamed115();

1139 }

1140 buildCounterMap--;

1141 return o;

1142 }

1143

1144 checkMap(api.Map o) {

1145 buildCounterMap++;

1146 if (buildCounterMap < 3) {

1147 checkUnnamed114(o.bbox);

1148 checkMapContents(o.contents);

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

1150 checkLatLngBox(o.defaultViewport);

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

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

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

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

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

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

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

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

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

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

1161 checkTags(o.tags);

1162 checkUnnamed115(o.versions);

1163 }

1164 buildCounterMap--;

1165 }

1166

1167 buildMapContents() {

1168 var o = new api.MapContents();

1169 o.add(buildMapItem());

1170 o.add(buildMapItem());

1171 return o;

1172 }

1173

1174 checkMapContents(api.MapContents o) {

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

1176 checkMapItem(o[0]);

1177 checkMapItem(o[1]);

1178 }

1179

1180 buildUnnamed116() {

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

1182 o.add(buildMapItem());

1183 o.add(buildMapItem());

1184 return o;

1185 }

1186

1187 checkUnnamed116(core.List<api.MapItem> o) {

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

1189 checkMapItem(o[0]);

1190 checkMapItem(o[1]);

1191 }

1192

1193 buildUnnamed117() {

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

1195 o.add(42.0);

1196 o.add(42.0);

1197 return o;

1198 }

1199

1200 checkUnnamed117(core.List<core.double> o) {

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

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

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

1204 }

1205

1206 core.int buildCounterMapFolder = 0;

1207 buildMapFolder() {

1208 var o = new api.MapFolder();

1209 buildCounterMapFolder++;

1210 if (buildCounterMapFolder < 3) {

1211 o.contents = buildUnnamed116();

1212 o.defaultViewport = buildUnnamed117();

1213 o.expandable = true;

1214 o.key = "foo";

1215 o.name = "foo";

1216 o.visibility = "foo";

1217 }

1218 buildCounterMapFolder--;

1219 return o;

1220 }

1221

1222 checkMapFolder(api.MapFolder o) {

1223 buildCounterMapFolder++;

1224 if (buildCounterMapFolder < 3) {

1225 checkUnnamed116(o.contents);

1226 checkUnnamed117(o.defaultViewport);

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

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

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

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

1231 }

1232 buildCounterMapFolder--;

1233 }

1234

1235 buildMapItem() {

1236 return buildMapFolder();

1237 }

1238

1239 checkMapItem(api.MapItem o) {

1240 checkMapFolder(api.MapFolder o) {

1241 buildCounterMapFolder++;

1242 if (buildCounterMapFolder < 3) {

1243 checkUnnamed116(o.contents);

1244 checkUnnamed117(o.defaultViewport);

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

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

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

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

1249 }

1250 buildCounterMapFolder--;

1251 }

1252

1253 (o);

1254 }

1255

1256 buildUnnamed118() {

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

1258 o.add(42.0);

1259 o.add(42.0);

1260 return o;

1261 }

1262

1263 checkUnnamed118(core.List<core.double> o) {

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

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

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

1267 }

1268

1269 core.int buildCounterMapKmlLink = 0;

1270 buildMapKmlLink() {

1271 var o = new api.MapKmlLink();

1272 buildCounterMapKmlLink++;

1273 if (buildCounterMapKmlLink < 3) {

1274 o.defaultViewport = buildUnnamed118();

1275 o.kmlUrl = "foo";

1276 o.name = "foo";

1277 o.visibility = "foo";

1278 }

1279 buildCounterMapKmlLink--;

1280 return o;

1281 }

1282

1283 checkMapKmlLink(api.MapKmlLink o) {

1284 buildCounterMapKmlLink++;

1285 if (buildCounterMapKmlLink < 3) {

1286 checkUnnamed118(o.defaultViewport);

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

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

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

1290 }

1291 buildCounterMapKmlLink--;

1292 }

1293

1294 buildUnnamed119() {

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

1296 o.add(42.0);

1297 o.add(42.0);

1298 return o;

1299 }

1300

1301 checkUnnamed119(core.List<core.double> o) {

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

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

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

1305 }

1306

1307 core.int buildCounterMapLayer = 0;

1308 buildMapLayer() {

1309 var o = new api.MapLayer();

1310 buildCounterMapLayer++;

1311 if (buildCounterMapLayer < 3) {

1312 o.defaultViewport = buildUnnamed119();

1313 o.id = "foo";

1314 o.key = "foo";

1315 o.name = "foo";

1316 o.visibility = "foo";

1317 }

1318 buildCounterMapLayer--;

1319 return o;

1320 }

1321

1322 checkMapLayer(api.MapLayer o) {

1323 buildCounterMapLayer++;

1324 if (buildCounterMapLayer < 3) {

1325 checkUnnamed119(o.defaultViewport);

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

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

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

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

1330 }

1331 buildCounterMapLayer--;

1332 }

1333

1334 buildUnnamed120() {

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

1336 o.add(buildMap());

1337 o.add(buildMap());

1338 return o;

1339 }

1340

1341 checkUnnamed120(core.List<api.Map> o) {

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

1343 checkMap(o[0]);

1344 checkMap(o[1]);

1345 }

1346

1347 core.int buildCounterMapsListResponse = 0;

1348 buildMapsListResponse() {

1349 var o = new api.MapsListResponse();

1350 buildCounterMapsListResponse++;

1351 if (buildCounterMapsListResponse < 3) {

1352 o.maps = buildUnnamed120();

1353 o.nextPageToken = "foo";

1354 }

1355 buildCounterMapsListResponse--;

1356 return o;

1357 }

1358

1359 checkMapsListResponse(api.MapsListResponse o) {

1360 buildCounterMapsListResponse++;

1361 if (buildCounterMapsListResponse < 3) {

1362 checkUnnamed120(o.maps);

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

1364 }

1365 buildCounterMapsListResponse--;

1366 }

1367

1368 core.int buildCounterParent = 0;

1369 buildParent() {

1370 var o = new api.Parent();

1371 buildCounterParent++;

1372 if (buildCounterParent < 3) {

1373 o.id = "foo";

1374 }

1375 buildCounterParent--;

1376 return o;

1377 }

1378

1379 checkParent(api.Parent o) {

1380 buildCounterParent++;

1381 if (buildCounterParent < 3) {

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

1383 }

1384 buildCounterParent--;

1385 }

1386

1387 buildUnnamed121() {

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

1389 o.add(buildParent());

1390 o.add(buildParent());

1391 return o;

1392 }

1393

1394 checkUnnamed121(core.List<api.Parent> o) {

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

1396 checkParent(o[0]);

1397 checkParent(o[1]);

1398 }

1399

1400 core.int buildCounterParentsListResponse = 0;

1401 buildParentsListResponse() {

1402 var o = new api.ParentsListResponse();

1403 buildCounterParentsListResponse++;

1404 if (buildCounterParentsListResponse < 3) {

1405 o.nextPageToken = "foo";

1406 o.parents = buildUnnamed121();

1407 }

1408 buildCounterParentsListResponse--;

1409 return o;

1410 }

1411

1412 checkParentsListResponse(api.ParentsListResponse o) {

1413 buildCounterParentsListResponse++;

1414 if (buildCounterParentsListResponse < 3) {

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

1416 checkUnnamed121(o.parents);

1417 }

1418 buildCounterParentsListResponse--;

1419 }

1420

1421 core.int buildCounterPointStyle = 0;

1422 buildPointStyle() {

1423 var o = new api.PointStyle();

1424 buildCounterPointStyle++;

1425 if (buildCounterPointStyle < 3) {

1426 o.icon = buildIconStyle();

1427 o.label = buildLabelStyle();

1428 }

1429 buildCounterPointStyle--;

1430 return o;

1431 }

1432

1433 checkPointStyle(api.PointStyle o) {

1434 buildCounterPointStyle++;

1435 if (buildCounterPointStyle < 3) {

1436 checkIconStyle(o.icon);

1437 checkLabelStyle(o.label);

1438 }

1439 buildCounterPointStyle--;

1440 }

1441

1442 core.int buildCounterPolygonStyle = 0;

1443 buildPolygonStyle() {

1444 var o = new api.PolygonStyle();

1445 buildCounterPolygonStyle++;

1446 if (buildCounterPolygonStyle < 3) {

1447 o.fill = buildColor();

1448 o.stroke = buildBorder();

1449 }

1450 buildCounterPolygonStyle--;

1451 return o;

1452 }

1453

1454 checkPolygonStyle(api.PolygonStyle o) {

1455 buildCounterPolygonStyle++;

1456 if (buildCounterPolygonStyle < 3) {

1457 checkColor(o.fill);

1458 checkBorder(o.stroke);

1459 }

1460 buildCounterPolygonStyle--;

1461 }

1462

1463 core.int buildCounterProcessResponse = 0;

1464 buildProcessResponse() {

1465 var o = new api.ProcessResponse();

1466 buildCounterProcessResponse++;

1467 if (buildCounterProcessResponse < 3) {

1468 }

1469 buildCounterProcessResponse--;

1470 return o;

1471 }

1472

1473 checkProcessResponse(api.ProcessResponse o) {

1474 buildCounterProcessResponse++;

1475 if (buildCounterProcessResponse < 3) {

1476 }

1477 buildCounterProcessResponse--;

1478 }

1479

1480 core.int buildCounterProject = 0;

1481 buildProject() {

1482 var o = new api.Project();

1483 buildCounterProject++;

1484 if (buildCounterProject < 3) {

1485 o.id = "foo";

1486 o.name = "foo";

1487 }

1488 buildCounterProject--;

1489 return o;

1490 }

1491

1492 checkProject(api.Project o) {

1493 buildCounterProject++;

1494 if (buildCounterProject < 3) {

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

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

1497 }

1498 buildCounterProject--;

1499 }

1500

1501 buildUnnamed122() {

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

1503 o.add(buildProject());

1504 o.add(buildProject());

1505 return o;

1506 }

1507

1508 checkUnnamed122(core.List<api.Project> o) {

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

1510 checkProject(o[0]);

1511 checkProject(o[1]);

1512 }

1513

1514 core.int buildCounterProjectsListResponse = 0;

1515 buildProjectsListResponse() {

1516 var o = new api.ProjectsListResponse();

1517 buildCounterProjectsListResponse++;

1518 if (buildCounterProjectsListResponse < 3) {

1519 o.projects = buildUnnamed122();

1520 }

1521 buildCounterProjectsListResponse--;

1522 return o;

1523 }

1524

1525 checkProjectsListResponse(api.ProjectsListResponse o) {

1526 buildCounterProjectsListResponse++;

1527 if (buildCounterProjectsListResponse < 3) {

1528 checkUnnamed122(o.projects);

1529 }

1530 buildCounterProjectsListResponse--;

1531 }

1532

1533 core.int buildCounterPublishResponse = 0;

1534 buildPublishResponse() {

1535 var o = new api.PublishResponse();

1536 buildCounterPublishResponse++;

1537 if (buildCounterPublishResponse < 3) {

1538 }

1539 buildCounterPublishResponse--;

1540 return o;

1541 }

1542

1543 checkPublishResponse(api.PublishResponse o) {

1544 buildCounterPublishResponse++;

1545 if (buildCounterPublishResponse < 3) {

1546 }

1547 buildCounterPublishResponse--;

1548 }

1549

1550 core.int buildCounterPublishedLayer = 0;

1551 buildPublishedLayer() {

1552 var o = new api.PublishedLayer();

1553 buildCounterPublishedLayer++;

1554 if (buildCounterPublishedLayer < 3) {

1555 o.description = "foo";

1556 o.etag = "foo";

1557 o.id = "foo";

1558 o.layerType = "foo";

1559 o.name = "foo";

1560 o.projectId = "foo";

1561 }

1562 buildCounterPublishedLayer--;

1563 return o;

1564 }

1565

1566 checkPublishedLayer(api.PublishedLayer o) {

1567 buildCounterPublishedLayer++;

1568 if (buildCounterPublishedLayer < 3) {

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

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

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

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

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

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

1575 }

1576 buildCounterPublishedLayer--;

1577 }

1578

1579 buildUnnamed123() {

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

1581 o.add(buildPublishedLayer());

1582 o.add(buildPublishedLayer());

1583 return o;

1584 }

1585

1586 checkUnnamed123(core.List<api.PublishedLayer> o) {

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

1588 checkPublishedLayer(o[0]);

1589 checkPublishedLayer(o[1]);

1590 }

1591

1592 core.int buildCounterPublishedLayersListResponse = 0;

1593 buildPublishedLayersListResponse() {

1594 var o = new api.PublishedLayersListResponse();

1595 buildCounterPublishedLayersListResponse++;

1596 if (buildCounterPublishedLayersListResponse < 3) {

1597 o.layers = buildUnnamed123();

1598 o.nextPageToken = "foo";

1599 }

1600 buildCounterPublishedLayersListResponse--;

1601 return o;

1602 }

1603

1604 checkPublishedLayersListResponse(api.PublishedLayersListResponse o) {

1605 buildCounterPublishedLayersListResponse++;

1606 if (buildCounterPublishedLayersListResponse < 3) {

1607 checkUnnamed123(o.layers);

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

1609 }

1610 buildCounterPublishedLayersListResponse--;

1611 }

1612

1613 core.int buildCounterPublishedMap = 0;

1614 buildPublishedMap() {

1615 var o = new api.PublishedMap();

1616 buildCounterPublishedMap++;

1617 if (buildCounterPublishedMap < 3) {

1618 o.contents = buildMapContents();

1619 o.defaultViewport = buildLatLngBox();

1620 o.description = "foo";

1621 o.etag = "foo";

1622 o.id = "foo";

1623 o.name = "foo";

1624 o.projectId = "foo";

1625 }

1626 buildCounterPublishedMap--;

1627 return o;

1628 }

1629

1630 checkPublishedMap(api.PublishedMap o) {

1631 buildCounterPublishedMap++;

1632 if (buildCounterPublishedMap < 3) {

1633 checkMapContents(o.contents);

1634 checkLatLngBox(o.defaultViewport);

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

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

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

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

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

1640 }

1641 buildCounterPublishedMap--;

1642 }

1643

1644 buildUnnamed124() {

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

1646 o.add(buildPublishedMap());

1647 o.add(buildPublishedMap());

1648 return o;

1649 }

1650

1651 checkUnnamed124(core.List<api.PublishedMap> o) {

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

1653 checkPublishedMap(o[0]);

1654 checkPublishedMap(o[1]);

1655 }

1656

1657 core.int buildCounterPublishedMapsListResponse = 0;

1658 buildPublishedMapsListResponse() {

1659 var o = new api.PublishedMapsListResponse();

1660 buildCounterPublishedMapsListResponse++;

1661 if (buildCounterPublishedMapsListResponse < 3) {

1662 o.maps = buildUnnamed124();

1663 o.nextPageToken = "foo";

1664 }

1665 buildCounterPublishedMapsListResponse--;

1666 return o;

1667 }

1668

1669 checkPublishedMapsListResponse(api.PublishedMapsListResponse o) {

1670 buildCounterPublishedMapsListResponse++;

1671 if (buildCounterPublishedMapsListResponse < 3) {

1672 checkUnnamed124(o.maps);

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

1674 }

1675 buildCounterPublishedMapsListResponse--;

1676 }

1677

1678 buildUnnamed125() {

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

1680 o.add(42.0);

1681 o.add(42.0);

1682 return o;

1683 }

1684

1685 checkUnnamed125(core.List<core.double> o) {

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

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

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

1689 }

1690

1691 buildUnnamed126() {

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

1693 o.add(buildFile());

1694 o.add(buildFile());

1695 return o;

1696 }

1697

1698 checkUnnamed126(core.List<api.File> o) {

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

1700 checkFile(o[0]);

1701 checkFile(o[1]);

1702 }

1703

1704 core.int buildCounterRaster = 0;

1705 buildRaster() {

1706 var o = new api.Raster();

1707 buildCounterRaster++;

1708 if (buildCounterRaster < 3) {

1709 o.acquisitionTime = buildAcquisitionTime();

1710 o.attribution = "foo";

1711 o.bbox = buildUnnamed125();

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

1713 o.description = "foo";

1714 o.draftAccessList = "foo";

1715 o.etag = "foo";

1716 o.files = buildUnnamed126();

1717 o.id = "foo";

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

1719 o.maskType = "foo";

1720 o.name = "foo";

1721 o.processingStatus = "foo";

1722 o.projectId = "foo";

1723 o.rasterType = "foo";

1724 o.tags = buildTags();

1725 }

1726 buildCounterRaster--;

1727 return o;

1728 }

1729

1730 checkRaster(api.Raster o) {

1731 buildCounterRaster++;

1732 if (buildCounterRaster < 3) {

1733 checkAcquisitionTime(o.acquisitionTime);

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

1735 checkUnnamed125(o.bbox);

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

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

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

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

1740 checkUnnamed126(o.files);

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

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

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

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

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

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

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

1748 checkTags(o.tags);

1749 }

1750 buildCounterRaster--;

1751 }

1752

1753 buildUnnamed127() {

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

1755 o.add(42.0);

1756 o.add(42.0);

1757 return o;

1758 }

1759

1760 checkUnnamed127(core.List<core.double> o) {

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

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

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

1764 }

1765

1766 core.int buildCounterRasterCollection = 0;

1767 buildRasterCollection() {

1768 var o = new api.RasterCollection();

1769 buildCounterRasterCollection++;

1770 if (buildCounterRasterCollection < 3) {

1771 o.attribution = "foo";

1772 o.bbox = buildUnnamed127();

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

1774 o.description = "foo";

1775 o.draftAccessList = "foo";

1776 o.etag = "foo";

1777 o.id = "foo";

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

1779 o.mosaic = true;

1780 o.name = "foo";

1781 o.processingStatus = "foo";

1782 o.projectId = "foo";

1783 o.rasterType = "foo";

1784 o.tags = buildTags();

1785 }

1786 buildCounterRasterCollection--;

1787 return o;

1788 }

1789

1790 checkRasterCollection(api.RasterCollection o) {

1791 buildCounterRasterCollection++;

1792 if (buildCounterRasterCollection < 3) {

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

1794 checkUnnamed127(o.bbox);

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

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

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

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

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

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

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

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

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

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

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

1806 checkTags(o.tags);

1807 }

1808 buildCounterRasterCollection--;

1809 }

1810

1811 buildUnnamed128() {

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

1813 o.add(buildRasterCollection());

1814 o.add(buildRasterCollection());

1815 return o;

1816 }

1817

1818 checkUnnamed128(core.List<api.RasterCollection> o) {

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

1820 checkRasterCollection(o[0]);

1821 checkRasterCollection(o[1]);

1822 }

1823

1824 core.int buildCounterRasterCollectionsListResponse = 0;

1825 buildRasterCollectionsListResponse() {

1826 var o = new api.RasterCollectionsListResponse();

1827 buildCounterRasterCollectionsListResponse++;

1828 if (buildCounterRasterCollectionsListResponse < 3) {

1829 o.nextPageToken = "foo";

1830 o.rasterCollections = buildUnnamed128();

1831 }

1832 buildCounterRasterCollectionsListResponse--;

1833 return o;

1834 }

1835

1836 checkRasterCollectionsListResponse(api.RasterCollectionsListResponse o) {

1837 buildCounterRasterCollectionsListResponse++;

1838 if (buildCounterRasterCollectionsListResponse < 3) {

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

1840 checkUnnamed128(o.rasterCollections);

1841 }

1842 buildCounterRasterCollectionsListResponse--;

1843 }

1844

1845 buildUnnamed129() {

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

1847 o.add(42.0);

1848 o.add(42.0);

1849 return o;

1850 }

1851

1852 checkUnnamed129(core.List<core.double> o) {

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

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

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

1856 }

1857

1858 buildUnnamed130() {

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

1860 o.add("foo");

1861 o.add("foo");

1862 return o;

1863 }

1864

1865 checkUnnamed130(core.List<core.String> o) {

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

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

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

1869 }

1870

1871 core.int buildCounterRasterCollectionsRaster = 0;

1872 buildRasterCollectionsRaster() {

1873 var o = new api.RasterCollectionsRaster();

1874 buildCounterRasterCollectionsRaster++;

1875 if (buildCounterRasterCollectionsRaster < 3) {

1876 o.bbox = buildUnnamed129();

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

1878 o.description = "foo";

1879 o.id = "foo";

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

1881 o.name = "foo";

1882 o.projectId = "foo";

1883 o.rasterType = "foo";

1884 o.tags = buildUnnamed130();

1885 }

1886 buildCounterRasterCollectionsRaster--;

1887 return o;

1888 }

1889

1890 checkRasterCollectionsRaster(api.RasterCollectionsRaster o) {

1891 buildCounterRasterCollectionsRaster++;

1892 if (buildCounterRasterCollectionsRaster < 3) {

1893 checkUnnamed129(o.bbox);

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

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

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

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

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

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

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

1901 checkUnnamed130(o.tags);

1902 }

1903 buildCounterRasterCollectionsRaster--;

1904 }

1905

1906 buildUnnamed131() {

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

1908 o.add("foo");

1909 o.add("foo");

1910 return o;

1911 }

1912

1913 checkUnnamed131(core.List<core.String> o) {

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

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

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

1917 }

1918

1919 core.int buildCounterRasterCollectionsRasterBatchDeleteRequest = 0;

1920 buildRasterCollectionsRasterBatchDeleteRequest() {

1921 var o = new api.RasterCollectionsRasterBatchDeleteRequest();

1922 buildCounterRasterCollectionsRasterBatchDeleteRequest++;

1923 if (buildCounterRasterCollectionsRasterBatchDeleteRequest < 3) {

1924 o.ids = buildUnnamed131();

1925 }

1926 buildCounterRasterCollectionsRasterBatchDeleteRequest--;

1927 return o;

1928 }

1929

1930 checkRasterCollectionsRasterBatchDeleteRequest(api.RasterCollectionsRasterBatchD eleteRequest o) {

1931 buildCounterRasterCollectionsRasterBatchDeleteRequest++;

1932 if (buildCounterRasterCollectionsRasterBatchDeleteRequest < 3) {

1933 checkUnnamed131(o.ids);

1934 }

1935 buildCounterRasterCollectionsRasterBatchDeleteRequest--;

1936 }

1937

1938 core.int buildCounterRasterCollectionsRastersBatchDeleteResponse = 0;

1939 buildRasterCollectionsRastersBatchDeleteResponse() {

1940 var o = new api.RasterCollectionsRastersBatchDeleteResponse();

1941 buildCounterRasterCollectionsRastersBatchDeleteResponse++;

1942 if (buildCounterRasterCollectionsRastersBatchDeleteResponse < 3) {

1943 }

1944 buildCounterRasterCollectionsRastersBatchDeleteResponse--;

1945 return o;

1946 }

1947

1948 checkRasterCollectionsRastersBatchDeleteResponse(api.RasterCollectionsRastersBat chDeleteResponse o) {

1949 buildCounterRasterCollectionsRastersBatchDeleteResponse++;

1950 if (buildCounterRasterCollectionsRastersBatchDeleteResponse < 3) {

1951 }

1952 buildCounterRasterCollectionsRastersBatchDeleteResponse--;

1953 }

1954

1955 buildUnnamed132() {

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

1957 o.add("foo");

1958 o.add("foo");

1959 return o;

1960 }

1961

1962 checkUnnamed132(core.List<core.String> o) {

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

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

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

1966 }

1967

1968 core.int buildCounterRasterCollectionsRastersBatchInsertRequest = 0;

1969 buildRasterCollectionsRastersBatchInsertRequest() {

1970 var o = new api.RasterCollectionsRastersBatchInsertRequest();

1971 buildCounterRasterCollectionsRastersBatchInsertRequest++;

1972 if (buildCounterRasterCollectionsRastersBatchInsertRequest < 3) {

1973 o.ids = buildUnnamed132();

1974 }

1975 buildCounterRasterCollectionsRastersBatchInsertRequest--;

1976 return o;

1977 }

1978

1979 checkRasterCollectionsRastersBatchInsertRequest(api.RasterCollectionsRastersBatc hInsertRequest o) {

1980 buildCounterRasterCollectionsRastersBatchInsertRequest++;

1981 if (buildCounterRasterCollectionsRastersBatchInsertRequest < 3) {

1982 checkUnnamed132(o.ids);

1983 }

1984 buildCounterRasterCollectionsRastersBatchInsertRequest--;

1985 }

1986

1987 core.int buildCounterRasterCollectionsRastersBatchInsertResponse = 0;

1988 buildRasterCollectionsRastersBatchInsertResponse() {

1989 var o = new api.RasterCollectionsRastersBatchInsertResponse();

1990 buildCounterRasterCollectionsRastersBatchInsertResponse++;

1991 if (buildCounterRasterCollectionsRastersBatchInsertResponse < 3) {

1992 }

1993 buildCounterRasterCollectionsRastersBatchInsertResponse--;

1994 return o;

1995 }

1996

1997 checkRasterCollectionsRastersBatchInsertResponse(api.RasterCollectionsRastersBat chInsertResponse o) {

1998 buildCounterRasterCollectionsRastersBatchInsertResponse++;

1999 if (buildCounterRasterCollectionsRastersBatchInsertResponse < 3) {

2000 }

2001 buildCounterRasterCollectionsRastersBatchInsertResponse--;

2002 }

2003

2004 buildUnnamed133() {

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

2006 o.add(buildRasterCollectionsRaster());

2007 o.add(buildRasterCollectionsRaster());

2008 return o;

2009 }

2010

2011 checkUnnamed133(core.List<api.RasterCollectionsRaster> o) {

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

2013 checkRasterCollectionsRaster(o[0]);

2014 checkRasterCollectionsRaster(o[1]);

2015 }

2016

2017 core.int buildCounterRasterCollectionsRastersListResponse = 0;

2018 buildRasterCollectionsRastersListResponse() {

2019 var o = new api.RasterCollectionsRastersListResponse();

2020 buildCounterRasterCollectionsRastersListResponse++;

2021 if (buildCounterRasterCollectionsRastersListResponse < 3) {

2022 o.nextPageToken = "foo";

2023 o.rasters = buildUnnamed133();

2024 }

2025 buildCounterRasterCollectionsRastersListResponse--;

2026 return o;

2027 }

2028

2029 checkRasterCollectionsRastersListResponse(api.RasterCollectionsRastersListRespon se o) {

2030 buildCounterRasterCollectionsRastersListResponse++;

2031 if (buildCounterRasterCollectionsRastersListResponse < 3) {

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

2033 checkUnnamed133(o.rasters);

2034 }

2035 buildCounterRasterCollectionsRastersListResponse--;

2036 }

2037

2038 buildUnnamed134() {

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

2040 o.add(buildRaster());

2041 o.add(buildRaster());

2042 return o;

2043 }

2044

2045 checkUnnamed134(core.List<api.Raster> o) {

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

2047 checkRaster(o[0]);

2048 checkRaster(o[1]);

2049 }

2050

2051 core.int buildCounterRastersListResponse = 0;

2052 buildRastersListResponse() {

2053 var o = new api.RastersListResponse();

2054 buildCounterRastersListResponse++;

2055 if (buildCounterRastersListResponse < 3) {

2056 o.nextPageToken = "foo";

2057 o.rasters = buildUnnamed134();

2058 }

2059 buildCounterRastersListResponse--;

2060 return o;

2061 }

2062

2063 checkRastersListResponse(api.RastersListResponse o) {

2064 buildCounterRastersListResponse++;

2065 if (buildCounterRastersListResponse < 3) {

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

2067 checkUnnamed134(o.rasters);

2068 }

2069 buildCounterRastersListResponse--;

2070 }

2071

2072 core.int buildCounterScaledShape = 0;

2073 buildScaledShape() {

2074 var o = new api.ScaledShape();

2075 buildCounterScaledShape++;

2076 if (buildCounterScaledShape < 3) {

2077 o.border = buildBorder();

2078 o.fill = buildColor();

2079 o.shape = "foo";

2080 }

2081 buildCounterScaledShape--;

2082 return o;

2083 }

2084

2085 checkScaledShape(api.ScaledShape o) {

2086 buildCounterScaledShape++;

2087 if (buildCounterScaledShape < 3) {

2088 checkBorder(o.border);

2089 checkColor(o.fill);

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

2091 }

2092 buildCounterScaledShape--;

2093 }

2094

2095 core.int buildCounterScalingFunction = 0;

2096 buildScalingFunction() {

2097 var o = new api.ScalingFunction();

2098 buildCounterScalingFunction++;

2099 if (buildCounterScalingFunction < 3) {

2100 o.column = "foo";

2101 o.scalingType = "foo";

2102 o.sizeRange = buildSizeRange();

2103 o.valueRange = buildValueRange();

2104 }

2105 buildCounterScalingFunction--;

2106 return o;

2107 }

2108

2109 checkScalingFunction(api.ScalingFunction o) {

2110 buildCounterScalingFunction++;

2111 if (buildCounterScalingFunction < 3) {

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

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

2114 checkSizeRange(o.sizeRange);

2115 checkValueRange(o.valueRange);

2116 }

2117 buildCounterScalingFunction--;

2118 }

2119

2120 buildUnnamed135() {

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

2122 o.add(buildTableColumn());

2123 o.add(buildTableColumn());

2124 return o;

2125 }

2126

2127 checkUnnamed135(core.List<api.TableColumn> o) {

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

2129 checkTableColumn(o[0]);

2130 checkTableColumn(o[1]);

2131 }

2132

2133 core.int buildCounterSchema = 0;

2134 buildSchema() {

2135 var o = new api.Schema();

2136 buildCounterSchema++;

2137 if (buildCounterSchema < 3) {

2138 o.columns = buildUnnamed135();

2139 o.primaryGeometry = "foo";

2140 o.primaryKey = "foo";

2141 }

2142 buildCounterSchema--;

2143 return o;

2144 }

2145

2146 checkSchema(api.Schema o) {

2147 buildCounterSchema++;

2148 if (buildCounterSchema < 3) {

2149 checkUnnamed135(o.columns);

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

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

2152 }

2153 buildCounterSchema--;

2154 }

2155

2156 core.int buildCounterSizeRange = 0;

2157 buildSizeRange() {

2158 var o = new api.SizeRange();

2159 buildCounterSizeRange++;

2160 if (buildCounterSizeRange < 3) {

2161 o.max = 42.0;

2162 o.min = 42.0;

2163 }

2164 buildCounterSizeRange--;

2165 return o;

2166 }

2167

2168 checkSizeRange(api.SizeRange o) {

2169 buildCounterSizeRange++;

2170 if (buildCounterSizeRange < 3) {

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

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

2173 }

2174 buildCounterSizeRange--;

2175 }

2176

2177 buildUnnamed136() {

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

2179 o.add(42.0);

2180 o.add(42.0);

2181 return o;

2182 }

2183

2184 checkUnnamed136(core.List<core.double> o) {

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

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

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

2188 }

2189

2190 buildUnnamed137() {

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

2192 o.add(buildFile());

2193 o.add(buildFile());

2194 return o;

2195 }

2196

2197 checkUnnamed137(core.List<api.File> o) {

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

2199 checkFile(o[0]);

2200 checkFile(o[1]);

2201 }

2202

2203 core.int buildCounterTable = 0;

2204 buildTable() {

2205 var o = new api.Table();

2206 buildCounterTable++;

2207 if (buildCounterTable < 3) {

2208 o.bbox = buildUnnamed136();

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

2210 o.description = "foo";

2211 o.draftAccessList = "foo";

2212 o.etag = "foo";

2213 o.files = buildUnnamed137();

2214 o.id = "foo";

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

2216 o.name = "foo";

2217 o.processingStatus = "foo";

2218 o.projectId = "foo";

2219 o.publishedAccessList = "foo";

2220 o.schema = buildSchema();

2221 o.sourceEncoding = "foo";

2222 o.tags = buildTags();

2223 }

2224 buildCounterTable--;

2225 return o;

2226 }

2227

2228 checkTable(api.Table o) {

2229 buildCounterTable++;

2230 if (buildCounterTable < 3) {

2231 checkUnnamed136(o.bbox);

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

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

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

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

2236 checkUnnamed137(o.files);

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

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

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

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

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

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

2243 checkSchema(o.schema);

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

2245 checkTags(o.tags);

2246 }

2247 buildCounterTable--;

2248 }

2249

2250 core.int buildCounterTableColumn = 0;

2251 buildTableColumn() {

2252 var o = new api.TableColumn();

2253 buildCounterTableColumn++;

2254 if (buildCounterTableColumn < 3) {

2255 o.name = "foo";

2256 o.type = "foo";

2257 }

2258 buildCounterTableColumn--;

2259 return o;

2260 }

2261

2262 checkTableColumn(api.TableColumn o) {

2263 buildCounterTableColumn++;

2264 if (buildCounterTableColumn < 3) {

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

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

2267 }

2268 buildCounterTableColumn--;

2269 }

2270

2271 buildUnnamed138() {

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

2273 o.add(buildTable());

2274 o.add(buildTable());

2275 return o;

2276 }

2277

2278 checkUnnamed138(core.List<api.Table> o) {

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

2280 checkTable(o[0]);

2281 checkTable(o[1]);

2282 }

2283

2284 core.int buildCounterTablesListResponse = 0;

2285 buildTablesListResponse() {

2286 var o = new api.TablesListResponse();

2287 buildCounterTablesListResponse++;

2288 if (buildCounterTablesListResponse < 3) {

2289 o.nextPageToken = "foo";

2290 o.tables = buildUnnamed138();

2291 }

2292 buildCounterTablesListResponse--;

2293 return o;

2294 }

2295

2296 checkTablesListResponse(api.TablesListResponse o) {

2297 buildCounterTablesListResponse++;

2298 if (buildCounterTablesListResponse < 3) {

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

2300 checkUnnamed138(o.tables);

2301 }

2302 buildCounterTablesListResponse--;

2303 }

2304

2305 buildTags() {

2306 var o = new api.Tags();

2307 o.add("foo");

2308 o.add("foo");

2309 return o;

2310 }

2311

2312 checkTags(api.Tags o) {

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

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

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

2316 }

2317

2318 core.int buildCounterValueRange = 0;

2319 buildValueRange() {

2320 var o = new api.ValueRange();

2321 buildCounterValueRange++;

2322 if (buildCounterValueRange < 3) {

2323 o.max = 42.0;

2324 o.min = 42.0;

2325 }

2326 buildCounterValueRange--;

2327 return o;

2328 }

2329

2330 checkValueRange(api.ValueRange o) {

2331 buildCounterValueRange++;

2332 if (buildCounterValueRange < 3) {

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

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

2335 }

2336 buildCounterValueRange--;

2337 }

2338

2339 buildUnnamed139() {

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

2341 o.add(buildDisplayRule());

2342 o.add(buildDisplayRule());

2343 return o;

2344 }

2345

2346 checkUnnamed139(core.List<api.DisplayRule> o) {

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

2348 checkDisplayRule(o[0]);

2349 checkDisplayRule(o[1]);

2350 }

2351

2352 core.int buildCounterVectorStyle = 0;

2353 buildVectorStyle() {

2354 var o = new api.VectorStyle();

2355 buildCounterVectorStyle++;

2356 if (buildCounterVectorStyle < 3) {

2357 o.displayRules = buildUnnamed139();

2358 o.featureInfo = buildFeatureInfo();

2359 o.type = "foo";

2360 }

2361 buildCounterVectorStyle--;

2362 return o;

2363 }

2364

2365 checkVectorStyle(api.VectorStyle o) {

2366 buildCounterVectorStyle++;

2367 if (buildCounterVectorStyle < 3) {

2368 checkUnnamed139(o.displayRules);

2369 checkFeatureInfo(o.featureInfo);

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

2371 }

2372 buildCounterVectorStyle--;

2373 }

2374

2375 core.int buildCounterZoomLevels = 0;

2376 buildZoomLevels() {

2377 var o = new api.ZoomLevels();

2378 buildCounterZoomLevels++;

2379 if (buildCounterZoomLevels < 3) {

2380 o.max = 42;

2381 o.min = 42;

2382 }

2383 buildCounterZoomLevels--;

2384 return o;

2385 }

2386

2387 checkZoomLevels(api.ZoomLevels o) {

2388 buildCounterZoomLevels++;

2389 if (buildCounterZoomLevels < 3) {

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

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

2392 }

2393 buildCounterZoomLevels--;

2394 }

2395

2396

2397 main() {

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

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

2400 var o = buildAcquisitionTime();

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

2402 checkAcquisitionTime(od);

2403 });

2404 });

2405

2406

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

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

2409 var o = buildAsset();

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

2411 checkAsset(od);

2412 });

2413 });

2414

2415

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

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

2418 var o = buildAssetsListResponse();

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

2420 checkAssetsListResponse(od);

2421 });

2422 });

2423

2424

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

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

2427 var o = buildBorder();

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

2429 checkBorder(od);

2430 });

2431 });

2432

2433

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

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

2436 var o = buildColor();

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

2438 checkColor(od);

2439 });

2440 });

2441

2442

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

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

2445 var o = buildDatasource();

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

2447 checkDatasource(od);

2448 });

2449 });

2450

2451

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

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

2454 var o = buildDatasources();

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

2456 checkDatasources(od);

2457 });

2458 });

2459

2460

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

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

2463 var o = buildDisplayRule();

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

2465 checkDisplayRule(od);

2466 });

2467 });

2468

2469

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

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

2472 var o = buildFeature();

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

2474 checkFeature(od);

2475 });

2476 });

2477

2478

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

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

2481 var o = buildFeatureInfo();

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

2483 checkFeatureInfo(od);

2484 });

2485 });

2486

2487

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

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

2490 var o = buildFeaturesBatchDeleteRequest();

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

2492 checkFeaturesBatchDeleteRequest(od);

2493 });

2494 });

2495

2496

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

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

2499 var o = buildFeaturesBatchInsertRequest();

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

2501 checkFeaturesBatchInsertRequest(od);

2502 });

2503 });

2504

2505

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

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

2508 var o = buildFeaturesBatchPatchRequest();

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

2510 checkFeaturesBatchPatchRequest(od);

2511 });

2512 });

2513

2514

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

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

2517 var o = buildFeaturesListResponse();

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

2519 checkFeaturesListResponse(od);

2520 });

2521 });

2522

2523

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

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

2526 var o = buildFile();

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

2528 checkFile(od);

2529 });

2530 });

2531

2532

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

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

2535 var o = buildFilter();

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

2537 checkFilter(od);

2538 });

2539 });

2540

2541

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

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

2544 var o = buildGeoJsonGeometry();

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

2546 checkGeoJsonGeometry(od);

2547 });

2548 });

2549

2550

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

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

2553 var o = buildGeoJsonGeometryCollection();

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

2555 checkGeoJsonGeometryCollection(od);

2556 });

2557 });

2558

2559

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

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

2562 var o = buildGeoJsonLineString();

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

2564 checkGeoJsonLineString(od);

2565 });

2566 });

2567

2568

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

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

2571 var o = buildGeoJsonMultiLineString();

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

2573 checkGeoJsonMultiLineString(od);

2574 });

2575 });

2576

2577

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

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

2580 var o = buildGeoJsonMultiPoint();

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

2582 checkGeoJsonMultiPoint(od);

2583 });

2584 });

2585

2586

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

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

2589 var o = buildGeoJsonMultiPolygon();

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

2591 checkGeoJsonMultiPolygon(od);

2592 });

2593 });

2594

2595

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

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

2598 var o = buildGeoJsonPoint();

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

2600 checkGeoJsonPoint(od);

2601 });

2602 });

2603

2604

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

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

2607 var o = buildGeoJsonPolygon();

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

2609 checkGeoJsonPolygon(od);

2610 });

2611 });

2612

2613

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

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

2616 var o = buildGeoJsonPosition();

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

2618 checkGeoJsonPosition(od);

2619 });

2620 });

2621

2622

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

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

2625 var o = buildGeoJsonProperties();

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

2627 checkGeoJsonProperties(od);

2628 });

2629 });

2630

2631

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

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

2634 var o = buildIcon();

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

2636 checkIcon(od);

2637 });

2638 });

2639

2640

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

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

2643 var o = buildIconStyle();

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

2645 checkIconStyle(od);

2646 });

2647 });

2648

2649

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

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

2652 var o = buildIconsListResponse();

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

2654 checkIconsListResponse(od);

2655 });

2656 });

2657

2658

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

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

2661 var o = buildLabelStyle();

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

2663 checkLabelStyle(od);

2664 });

2665 });

2666

2667

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

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

2670 var o = buildLatLngBox();

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

2672 checkLatLngBox(od);

2673 });

2674 });

2675

2676

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

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

2679 var o = buildLayer();

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

2681 checkLayer(od);

2682 });

2683 });

2684

2685

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

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

2688 var o = buildLayersListResponse();

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

2690 checkLayersListResponse(od);

2691 });

2692 });

2693

2694

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

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

2697 var o = buildLineStyleStroke();

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

2699 checkLineStyleStroke(od);

2700 });

2701 });

2702

2703

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

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

2706 var o = buildLineStyle();

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

2708 checkLineStyle(od);

2709 });

2710 });

2711

2712

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

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

2715 var o = buildMap();

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

2717 checkMap(od);

2718 });

2719 });

2720

2721

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

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

2724 var o = buildMapContents();

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

2726 checkMapContents(od);

2727 });

2728 });

2729

2730

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

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

2733 var o = buildMapFolder();

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

2735 checkMapFolder(od);

2736 });

2737 });

2738

2739

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

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

2742 var o = buildMapItem();

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

2744 checkMapItem(od);

2745 });

2746 });

2747

2748

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

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

2751 var o = buildMapKmlLink();

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

2753 checkMapKmlLink(od);

2754 });

2755 });

2756

2757

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

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

2760 var o = buildMapLayer();

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

2762 checkMapLayer(od);

2763 });

2764 });

2765

2766

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

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

2769 var o = buildMapsListResponse();

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

2771 checkMapsListResponse(od);

2772 });

2773 });

2774

2775

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

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

2778 var o = buildParent();

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

2780 checkParent(od);

2781 });

2782 });

2783

2784

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

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

2787 var o = buildParentsListResponse();

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

2789 checkParentsListResponse(od);

2790 });

2791 });

2792

2793

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

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

2796 var o = buildPointStyle();

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

2798 checkPointStyle(od);

2799 });

2800 });

2801

2802

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

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

2805 var o = buildPolygonStyle();

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

2807 checkPolygonStyle(od);

2808 });

2809 });

2810

2811

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

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

2814 var o = buildProcessResponse();

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

2816 checkProcessResponse(od);

2817 });

2818 });

2819

2820

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

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

2823 var o = buildProject();

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

2825 checkProject(od);

2826 });

2827 });

2828

2829

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

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

2832 var o = buildProjectsListResponse();

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

2834 checkProjectsListResponse(od);

2835 });

2836 });

2837

2838

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

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

2841 var o = buildPublishResponse();

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

2843 checkPublishResponse(od);

2844 });

2845 });

2846

2847

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

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

2850 var o = buildPublishedLayer();

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

2852 checkPublishedLayer(od);

2853 });

2854 });

2855

2856

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

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

2859 var o = buildPublishedLayersListResponse();

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

2861 checkPublishedLayersListResponse(od);

2862 });

2863 });

2864

2865

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

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

2868 var o = buildPublishedMap();

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

2870 checkPublishedMap(od);

2871 });

2872 });

2873

2874

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

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

2877 var o = buildPublishedMapsListResponse();

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

2879 checkPublishedMapsListResponse(od);

2880 });

2881 });

2882

2883

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

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

2886 var o = buildRaster();

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

2888 checkRaster(od);

2889 });

2890 });

2891

2892

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

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

2895 var o = buildRasterCollection();

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

2897 checkRasterCollection(od);

2898 });

2899 });

2900

2901

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

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

2904 var o = buildRasterCollectionsListResponse();

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

2906 checkRasterCollectionsListResponse(od);

2907 });

2908 });

2909

2910

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

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

2913 var o = buildRasterCollectionsRaster();

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

2915 checkRasterCollectionsRaster(od);

2916 });

2917 });

2918

2919

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

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

2922 var o = buildRasterCollectionsRasterBatchDeleteRequest();

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

2924 checkRasterCollectionsRasterBatchDeleteRequest(od);

2925 });

2926 });

2927

2928

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

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

2931 var o = buildRasterCollectionsRastersBatchDeleteResponse();

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

2933 checkRasterCollectionsRastersBatchDeleteResponse(od);

2934 });

2935 });

2936

2937

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

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

2940 var o = buildRasterCollectionsRastersBatchInsertRequest();

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

2942 checkRasterCollectionsRastersBatchInsertRequest(od);

2943 });

2944 });

2945

2946

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

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

2949 var o = buildRasterCollectionsRastersBatchInsertResponse();

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

2951 checkRasterCollectionsRastersBatchInsertResponse(od);

2952 });

2953 });

2954

2955

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

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

2958 var o = buildRasterCollectionsRastersListResponse();

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

2960 checkRasterCollectionsRastersListResponse(od);

2961 });

2962 });

2963

2964

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

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

2967 var o = buildRastersListResponse();

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

2969 checkRastersListResponse(od);

2970 });

2971 });

2972

2973

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

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

2976 var o = buildScaledShape();

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

2978 checkScaledShape(od);

2979 });

2980 });

2981

2982

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

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

2985 var o = buildScalingFunction();

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

2987 checkScalingFunction(od);

2988 });

2989 });

2990

2991

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

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

2994 var o = buildSchema();

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

2996 checkSchema(od);

2997 });

2998 });

2999

3000

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

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

3003 var o = buildSizeRange();

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

3005 checkSizeRange(od);

3006 });

3007 });

3008

3009

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

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

3012 var o = buildTable();

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

3014 checkTable(od);

3015 });

3016 });

3017

3018

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

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

3021 var o = buildTableColumn();

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

3023 checkTableColumn(od);

3024 });

3025 });

3026

3027

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

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

3030 var o = buildTablesListResponse();

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

3032 checkTablesListResponse(od);

3033 });

3034 });

3035

3036

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

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

3039 var o = buildTags();

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

3041 checkTags(od);

3042 });

3043 });

3044

3045

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

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

3048 var o = buildValueRange();

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

3050 checkValueRange(od);

3051 });

3052 });

3053

3054

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

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

3057 var o = buildVectorStyle();

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

3059 checkVectorStyle(od);

3060 });

3061 });

3062

3063

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

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

3066 var o = buildZoomLevels();

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

3068 checkZoomLevels(od);

3069 });

3070 });

3071

3072

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

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

3075

3076 var mock = new common_test.HttpServerMock();

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

3078 var arg_id = "foo";

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

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

3081 var pathOffset = 0;

3082 var index;

3083 var subPart;

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

3085 pathOffset += 15;

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

3087 pathOffset += 7;

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

3089 pathOffset = path.length;

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

3091

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

3093 var queryOffset = 0;

3094 var queryMap = {};

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

3096 parseBool(n) {

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

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

3099 if (n == null) return null;

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

3101 }

3102 if (query.length > 0) {

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

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

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

3106 }

3107 }

3108

3109

3110 var h = {

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

3112 };

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

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

3115 }), true);

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

3117 checkAsset(response);

3118 })));

3119 });

3120

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

3122

3123 var mock = new common_test.HttpServerMock();

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

3125 var arg_bbox = "foo";

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

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

3128 var arg_creatorEmail = "foo";

3129 var arg_maxResults = 42;

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

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

3132 var arg_pageToken = "foo";

3133 var arg_projectId = "foo";

3134 var arg_role = "foo";

3135 var arg_search = "foo";

3136 var arg_tags = "foo";

3137 var arg_type = "foo";

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

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

3140 var pathOffset = 0;

3141 var index;

3142 var subPart;

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

3144 pathOffset += 15;

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

3146 pathOffset += 6;

3147

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

3149 var queryOffset = 0;

3150 var queryMap = {};

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

3152 parseBool(n) {

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

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

3155 if (n == null) return null;

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

3157 }

3158 if (query.length > 0) {

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

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

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

3162 }

3163 }

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

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

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

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

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

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

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

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

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

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

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

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

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

3177

3178

3179 var h = {

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

3181 };

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

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

3184 }), true);

3185 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) {

3186 checkAssetsListResponse(response);

3187 })));

3188 });

3189

3190 });

3191

3192

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

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

3195

3196 var mock = new common_test.HttpServerMock();

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

3198 var arg_id = "foo";

3199 var arg_maxResults = 42;

3200 var arg_pageToken = "foo";

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

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

3203 var pathOffset = 0;

3204 var index;

3205 var subPart;

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

3207 pathOffset += 15;

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

3209 pathOffset += 7;

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

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

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

3213 pathOffset = index;

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

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

3216 pathOffset += 8;

3217

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

3219 var queryOffset = 0;

3220 var queryMap = {};

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

3222 parseBool(n) {

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

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

3225 if (n == null) return null;

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

3227 }

3228 if (query.length > 0) {

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

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

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

3232 }

3233 }

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

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

3236

3237

3238 var h = {

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

3240 };

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

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

3243 }), true);

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

3245 checkParentsListResponse(response);

3246 })));

3247 });

3248

3249 });

3250

3251

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

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

3254

3255 var mock = new common_test.HttpServerMock();

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

3257 var arg_id = "foo";

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

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

3260 var pathOffset = 0;

3261 var index;

3262 var subPart;

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

3264 pathOffset += 15;

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

3266 pathOffset += 7;

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

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

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

3270 pathOffset = index;

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

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

3273 pathOffset += 17;

3274

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

3276 var queryOffset = 0;

3277 var queryMap = {};

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

3279 parseBool(n) {

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

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

3282 if (n == null) return null;

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

3284 }

3285 if (query.length > 0) {

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

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

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

3289 }

3290 }

3291

3292

3293 var h = {

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

3295 };

3296 var resp = convert.JSON.encode(buildProcessResponse());

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

3298 }), true);

3299 res.cancelProcessing(arg_id).then(unittest.expectAsync(((api.ProcessRespon se response) {

3300 checkProcessResponse(response);

3301 })));

3302 });

3303

3304 unittest.test("method--create", () {

3305

3306 var mock = new common_test.HttpServerMock();

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

3308 var arg_request = buildLayer();

3309 var arg_process_1 = true;

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

3311 var obj = new api.Layer.fromJson(json);

3312 checkLayer(obj);

3313

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

3315 var pathOffset = 0;

3316 var index;

3317 var subPart;

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

3319 pathOffset += 15;

3320 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("layers"));

3321 pathOffset += 6;

3322

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

3324 var queryOffset = 0;

3325 var queryMap = {};

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

3327 parseBool(n) {

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

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

3330 if (n == null) return null;

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

3332 }

3333 if (query.length > 0) {

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

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

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

3337 }

3338 }

3339 unittest.expect(queryMap["process"].first, unittest.equals("$arg_process _1"));

3340

3341

3342 var h = {

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

3344 };

3345 var resp = convert.JSON.encode(buildLayer());

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

3347 }), true);

3348 res.create(arg_request, process_1: arg_process_1).then(unittest.expectAsyn c(((api.Layer response) {

3349 checkLayer(response);

3350 })));

3351 });

3352

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

3354

3355 var mock = new common_test.HttpServerMock();

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

3357 var arg_id = "foo";

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

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

3360 var pathOffset = 0;

3361 var index;

3362 var subPart;

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

3364 pathOffset += 15;

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

3366 pathOffset += 7;

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

3368 pathOffset = path.length;

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

3370

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

3372 var queryOffset = 0;

3373 var queryMap = {};

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

3375 parseBool(n) {

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

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

3378 if (n == null) return null;

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

3380 }

3381 if (query.length > 0) {

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

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

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

3385 }

3386 }

3387

3388

3389 var h = {

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

3391 };

3392 var resp = "";

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

3394 }), true);

3395 res.delete(arg_id).then(unittest.expectAsync((_) {}));

3396 });

3397

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

3399

3400 var mock = new common_test.HttpServerMock();

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

3402 var arg_id = "foo";

3403 var arg_version = "foo";

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

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

3406 var pathOffset = 0;

3407 var index;

3408 var subPart;

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

3410 pathOffset += 15;

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

3412 pathOffset += 7;

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

3414 pathOffset = path.length;

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

3416

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

3418 var queryOffset = 0;

3419 var queryMap = {};

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

3421 parseBool(n) {

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

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

3424 if (n == null) return null;

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

3426 }

3427 if (query.length > 0) {

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

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

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

3431 }

3432 }

3433 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

3434

3435

3436 var h = {

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

3438 };

3439 var resp = convert.JSON.encode(buildLayer());

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

3441 }), true);

3442 res.get(arg_id, version: arg_version).then(unittest.expectAsync(((api.Laye r response) {

3443 checkLayer(response);

3444 })));

3445 });

3446

3447 unittest.test("method--getPublished", () {

3448

3449 var mock = new common_test.HttpServerMock();

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

3451 var arg_id = "foo";

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

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

3454 var pathOffset = 0;

3455 var index;

3456 var subPart;

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

3458 pathOffset += 15;

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

3460 pathOffset += 7;

3461 index = path.indexOf("/published", pathOffset);

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

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

3464 pathOffset = index;

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

3466 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/published"));

3467 pathOffset += 10;

3468

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

3470 var queryOffset = 0;

3471 var queryMap = {};

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

3473 parseBool(n) {

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

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

3476 if (n == null) return null;

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

3478 }

3479 if (query.length > 0) {

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

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

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

3483 }

3484 }

3485

3486

3487 var h = {

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

3489 };

3490 var resp = convert.JSON.encode(buildPublishedLayer());

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

3492 }), true);

3493 res.getPublished(arg_id).then(unittest.expectAsync(((api.PublishedLayer re sponse) {

3494 checkPublishedLayer(response);

3495 })));

3496 });

3497

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

3499

3500 var mock = new common_test.HttpServerMock();

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

3502 var arg_bbox = "foo";

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

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

3505 var arg_creatorEmail = "foo";

3506 var arg_maxResults = 42;

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

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

3509 var arg_pageToken = "foo";

3510 var arg_processingStatus = "foo";

3511 var arg_projectId = "foo";

3512 var arg_role = "foo";

3513 var arg_search = "foo";

3514 var arg_tags = "foo";

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

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

3517 var pathOffset = 0;

3518 var index;

3519 var subPart;

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

3521 pathOffset += 15;

3522 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("layers"));

3523 pathOffset += 6;

3524

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

3526 var queryOffset = 0;

3527 var queryMap = {};

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

3529 parseBool(n) {

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

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

3532 if (n == null) return null;

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

3534 }

3535 if (query.length > 0) {

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

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

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

3539 }

3540 }

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

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

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

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

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

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

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

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

3549 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

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

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

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

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

3554

3555

3556 var h = {

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

3558 };

3559 var resp = convert.JSON.encode(buildLayersListResponse());

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

3561 }), true);

3562 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) {

3563 checkLayersListResponse(response);

3564 })));

3565 });

3566

3567 unittest.test("method--listPublished", () {

3568

3569 var mock = new common_test.HttpServerMock();

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

3571 var arg_maxResults = 42;

3572 var arg_pageToken = "foo";

3573 var arg_projectId = "foo";

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

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

3576 var pathOffset = 0;

3577 var index;

3578 var subPart;

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

3580 pathOffset += 15;

3581 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("layers/published"));

3582 pathOffset += 16;

3583

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

3585 var queryOffset = 0;

3586 var queryMap = {};

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

3588 parseBool(n) {

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

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

3591 if (n == null) return null;

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

3593 }

3594 if (query.length > 0) {

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

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

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

3598 }

3599 }

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

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

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

3603

3604

3605 var h = {

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

3607 };

3608 var resp = convert.JSON.encode(buildPublishedLayersListResponse());

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

3610 }), true);

3611 res.listPublished(maxResults: arg_maxResults, pageToken: arg_pageToken, pr ojectId: arg_projectId).then(unittest.expectAsync(((api.PublishedLayersListRespo nse response) {

3612 checkPublishedLayersListResponse(response);

3613 })));

3614 });

3615

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

3617

3618 var mock = new common_test.HttpServerMock();

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

3620 var arg_request = buildLayer();

3621 var arg_id = "foo";

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

3623 var obj = new api.Layer.fromJson(json);

3624 checkLayer(obj);

3625

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

3627 var pathOffset = 0;

3628 var index;

3629 var subPart;

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

3631 pathOffset += 15;

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

3633 pathOffset += 7;

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

3635 pathOffset = path.length;

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

3637

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

3639 var queryOffset = 0;

3640 var queryMap = {};

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

3642 parseBool(n) {

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

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

3645 if (n == null) return null;

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

3647 }

3648 if (query.length > 0) {

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

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

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

3652 }

3653 }

3654

3655

3656 var h = {

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

3658 };

3659 var resp = "";

3660 return new async.Future.value(common_test.stringResponse(200, h, resp));

3661 }), true);

3662 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

3663 });

3664

3665 unittest.test("method--process", () {

3666

3667 var mock = new common_test.HttpServerMock();

3668 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3669 var arg_id = "foo";

3670 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3671 var path = (req.url).path;

3672 var pathOffset = 0;

3673 var index;

3674 var subPart;

3675 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

3676 pathOffset += 15;

3677 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("layers/"));

3678 pathOffset += 7;

3679 index = path.indexOf("/process", pathOffset);

3680 unittest.expect(index >= 0, unittest.isTrue);

3681 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3682 pathOffset = index;

3683 unittest.expect(subPart, unittest.equals("$arg_id"));

3684 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/process"));

3685 pathOffset += 8;

3686

3687 var query = (req.url).query;

3688 var queryOffset = 0;

3689 var queryMap = {};

3690 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3691 parseBool(n) {

3692 if (n == "true") return true;

3693 if (n == "false") return false;

3694 if (n == null) return null;

3695 throw new core.ArgumentError("Invalid boolean: $n");

3696 }

3697 if (query.length > 0) {

3698 for (var part in query.split("&")) {

3699 var keyvalue = part.split("=");

3700 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3701 }

3702 }

3703

3704

3705 var h = {

3706 "content-type" : "application/json; charset=utf-8",

3707 };

3708 var resp = convert.JSON.encode(buildProcessResponse());

3709 return new async.Future.value(common_test.stringResponse(200, h, resp));

3710 }), true);

3711 res.process(arg_id).then(unittest.expectAsync(((api.ProcessResponse respon se) {

3712 checkProcessResponse(response);

3713 })));

3714 });

3715

3716 unittest.test("method--publish", () {

3717

3718 var mock = new common_test.HttpServerMock();

3719 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3720 var arg_id = "foo";

3721 var arg_force = true;

3722 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3723 var path = (req.url).path;

3724 var pathOffset = 0;

3725 var index;

3726 var subPart;

3727 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

3728 pathOffset += 15;

3729 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("layers/"));

3730 pathOffset += 7;

3731 index = path.indexOf("/publish", pathOffset);

3732 unittest.expect(index >= 0, unittest.isTrue);

3733 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3734 pathOffset = index;

3735 unittest.expect(subPart, unittest.equals("$arg_id"));

3736 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/publish"));

3737 pathOffset += 8;

3738

3739 var query = (req.url).query;

3740 var queryOffset = 0;

3741 var queryMap = {};

3742 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3743 parseBool(n) {

3744 if (n == "true") return true;

3745 if (n == "false") return false;

3746 if (n == null) return null;

3747 throw new core.ArgumentError("Invalid boolean: $n");

3748 }

3749 if (query.length > 0) {

3750 for (var part in query.split("&")) {

3751 var keyvalue = part.split("=");

3752 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3753 }

3754 }

3755 unittest.expect(queryMap["force"].first, unittest.equals("$arg_force"));

3756

3757

3758 var h = {

3759 "content-type" : "application/json; charset=utf-8",

3760 };

3761 var resp = convert.JSON.encode(buildPublishResponse());

3762 return new async.Future.value(common_test.stringResponse(200, h, resp));

3763 }), true);

3764 res.publish(arg_id, force: arg_force).then(unittest.expectAsync(((api.Publ ishResponse response) {

3765 checkPublishResponse(response);

3766 })));

3767 });

3768

3769 unittest.test("method--unpublish", () {

3770

3771 var mock = new common_test.HttpServerMock();

3772 api.LayersResourceApi res = new api.MapsengineApi(mock).layers;

3773 var arg_id = "foo";

3774 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3775 var path = (req.url).path;

3776 var pathOffset = 0;

3777 var index;

3778 var subPart;

3779 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

3780 pathOffset += 15;

3781 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("layers/"));

3782 pathOffset += 7;

3783 index = path.indexOf("/unpublish", pathOffset);

3784 unittest.expect(index >= 0, unittest.isTrue);

3785 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3786 pathOffset = index;

3787 unittest.expect(subPart, unittest.equals("$arg_id"));

3788 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/unpublish"));

3789 pathOffset += 10;

3790

3791 var query = (req.url).query;

3792 var queryOffset = 0;

3793 var queryMap = {};

3794 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3795 parseBool(n) {

3796 if (n == "true") return true;

3797 if (n == "false") return false;

3798 if (n == null) return null;

3799 throw new core.ArgumentError("Invalid boolean: $n");

3800 }

3801 if (query.length > 0) {

3802 for (var part in query.split("&")) {

3803 var keyvalue = part.split("=");

3804 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3805 }

3806 }

3807

3808

3809 var h = {

3810 "content-type" : "application/json; charset=utf-8",

3811 };

3812 var resp = convert.JSON.encode(buildPublishResponse());

3813 return new async.Future.value(common_test.stringResponse(200, h, resp));

3814 }), true);

3815 res.unpublish(arg_id).then(unittest.expectAsync(((api.PublishResponse resp onse) {

3816 checkPublishResponse(response);

3817 })));

3818 });

3819

3820 });

3821

3822

3823 unittest.group("resource-LayersParentsResourceApi", () {

3824 unittest.test("method--list", () {

3825

3826 var mock = new common_test.HttpServerMock();

3827 api.LayersParentsResourceApi res = new api.MapsengineApi(mock).layers.pare nts;

3828 var arg_id = "foo";

3829 var arg_maxResults = 42;

3830 var arg_pageToken = "foo";

3831 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3832 var path = (req.url).path;

3833 var pathOffset = 0;

3834 var index;

3835 var subPart;

3836 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

3837 pathOffset += 15;

3838 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("layers/"));

3839 pathOffset += 7;

3840 index = path.indexOf("/parents", pathOffset);

3841 unittest.expect(index >= 0, unittest.isTrue);

3842 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3843 pathOffset = index;

3844 unittest.expect(subPart, unittest.equals("$arg_id"));

3845 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/parents"));

3846 pathOffset += 8;

3847

3848 var query = (req.url).query;

3849 var queryOffset = 0;

3850 var queryMap = {};

3851 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3852 parseBool(n) {

3853 if (n == "true") return true;

3854 if (n == "false") return false;

3855 if (n == null) return null;

3856 throw new core.ArgumentError("Invalid boolean: $n");

3857 }

3858 if (query.length > 0) {

3859 for (var part in query.split("&")) {

3860 var keyvalue = part.split("=");

3861 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3862 }

3863 }

3864 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3865 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3866

3867

3868 var h = {

3869 "content-type" : "application/json; charset=utf-8",

3870 };

3871 var resp = convert.JSON.encode(buildParentsListResponse());

3872 return new async.Future.value(common_test.stringResponse(200, h, resp));

3873 }), true);

3874 res.list(arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken).the n(unittest.expectAsync(((api.ParentsListResponse response) {

3875 checkParentsListResponse(response);

3876 })));

3877 });

3878

3879 });

3880

3881

3882 unittest.group("resource-MapsResourceApi", () {

3883 unittest.test("method--create", () {

3884

3885 var mock = new common_test.HttpServerMock();

3886 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

3887 var arg_request = buildMap();

3888 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3889 var obj = new api.Map.fromJson(json);

3890 checkMap(obj);

3891

3892 var path = (req.url).path;

3893 var pathOffset = 0;

3894 var index;

3895 var subPart;

3896 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

3897 pathOffset += 15;

3898 unittest.expect(path.substring(pathOffset, pathOffset + 4), unittest.equ als("maps"));

3899 pathOffset += 4;

3900

3901 var query = (req.url).query;

3902 var queryOffset = 0;

3903 var queryMap = {};

3904 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3905 parseBool(n) {

3906 if (n == "true") return true;

3907 if (n == "false") return false;

3908 if (n == null) return null;

3909 throw new core.ArgumentError("Invalid boolean: $n");

3910 }

3911 if (query.length > 0) {

3912 for (var part in query.split("&")) {

3913 var keyvalue = part.split("=");

3914 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3915 }

3916 }

3917

3918

3919 var h = {

3920 "content-type" : "application/json; charset=utf-8",

3921 };

3922 var resp = convert.JSON.encode(buildMap());

3923 return new async.Future.value(common_test.stringResponse(200, h, resp));

3924 }), true);

3925 res.create(arg_request).then(unittest.expectAsync(((api.Map response) {

3926 checkMap(response);

3927 })));

3928 });

3929

3930 unittest.test("method--delete", () {

3931

3932 var mock = new common_test.HttpServerMock();

3933 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

3934 var arg_id = "foo";

3935 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3936 var path = (req.url).path;

3937 var pathOffset = 0;

3938 var index;

3939 var subPart;

3940 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

3941 pathOffset += 15;

3942 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("maps/"));

3943 pathOffset += 5;

3944 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3945 pathOffset = path.length;

3946 unittest.expect(subPart, unittest.equals("$arg_id"));

3947

3948 var query = (req.url).query;

3949 var queryOffset = 0;

3950 var queryMap = {};

3951 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3952 parseBool(n) {

3953 if (n == "true") return true;

3954 if (n == "false") return false;

3955 if (n == null) return null;

3956 throw new core.ArgumentError("Invalid boolean: $n");

3957 }

3958 if (query.length > 0) {

3959 for (var part in query.split("&")) {

3960 var keyvalue = part.split("=");

3961 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3962 }

3963 }

3964

3965

3966 var h = {

3967 "content-type" : "application/json; charset=utf-8",

3968 };

3969 var resp = "";

3970 return new async.Future.value(common_test.stringResponse(200, h, resp));

3971 }), true);

3972 res.delete(arg_id).then(unittest.expectAsync((_) {}));

3973 });

3974

3975 unittest.test("method--get", () {

3976

3977 var mock = new common_test.HttpServerMock();

3978 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

3979 var arg_id = "foo";

3980 var arg_version = "foo";

3981 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3982 var path = (req.url).path;

3983 var pathOffset = 0;

3984 var index;

3985 var subPart;

3986 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

3987 pathOffset += 15;

3988 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("maps/"));

3989 pathOffset += 5;

3990 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3991 pathOffset = path.length;

3992 unittest.expect(subPart, unittest.equals("$arg_id"));

3993

3994 var query = (req.url).query;

3995 var queryOffset = 0;

3996 var queryMap = {};

3997 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3998 parseBool(n) {

3999 if (n == "true") return true;

4000 if (n == "false") return false;

4001 if (n == null) return null;

4002 throw new core.ArgumentError("Invalid boolean: $n");

4003 }

4004 if (query.length > 0) {

4005 for (var part in query.split("&")) {

4006 var keyvalue = part.split("=");

4007 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4008 }

4009 }

4010 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

4011

4012

4013 var h = {

4014 "content-type" : "application/json; charset=utf-8",

4015 };

4016 var resp = convert.JSON.encode(buildMap());

4017 return new async.Future.value(common_test.stringResponse(200, h, resp));

4018 }), true);

4019 res.get(arg_id, version: arg_version).then(unittest.expectAsync(((api.Map response) {

4020 checkMap(response);

4021 })));

4022 });

4023

4024 unittest.test("method--getPublished", () {

4025

4026 var mock = new common_test.HttpServerMock();

4027 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4028 var arg_id = "foo";

4029 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4030 var path = (req.url).path;

4031 var pathOffset = 0;

4032 var index;

4033 var subPart;

4034 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4035 pathOffset += 15;

4036 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("maps/"));

4037 pathOffset += 5;

4038 index = path.indexOf("/published", 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 + 10), unittest.eq uals("/published"));

4044 pathOffset += 10;

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(buildPublishedMap());

4068 return new async.Future.value(common_test.stringResponse(200, h, resp));

4069 }), true);

4070 res.getPublished(arg_id).then(unittest.expectAsync(((api.PublishedMap resp onse) {

4071 checkPublishedMap(response);

4072 })));

4073 });

4074

4075 unittest.test("method--list", () {

4076

4077 var mock = new common_test.HttpServerMock();

4078 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4079 var arg_bbox = "foo";

4080 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

4081 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

4082 var arg_creatorEmail = "foo";

4083 var arg_maxResults = 42;

4084 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

4085 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

4086 var arg_pageToken = "foo";

4087 var arg_processingStatus = "foo";

4088 var arg_projectId = "foo";

4089 var arg_role = "foo";

4090 var arg_search = "foo";

4091 var arg_tags = "foo";

4092 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4093 var path = (req.url).path;

4094 var pathOffset = 0;

4095 var index;

4096 var subPart;

4097 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4098 pathOffset += 15;

4099 unittest.expect(path.substring(pathOffset, pathOffset + 4), unittest.equ als("maps"));

4100 pathOffset += 4;

4101

4102 var query = (req.url).query;

4103 var queryOffset = 0;

4104 var queryMap = {};

4105 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4106 parseBool(n) {

4107 if (n == "true") return true;

4108 if (n == "false") return false;

4109 if (n == null) return null;

4110 throw new core.ArgumentError("Invalid boolean: $n");

4111 }

4112 if (query.length > 0) {

4113 for (var part in query.split("&")) {

4114 var keyvalue = part.split("=");

4115 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4116 }

4117 }

4118 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

4119 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

4120 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

4121 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

4122 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

4123 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

4124 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

4125 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

4126 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

4127 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

4128 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

4129 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

4130 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

4131

4132

4133 var h = {

4134 "content-type" : "application/json; charset=utf-8",

4135 };

4136 var resp = convert.JSON.encode(buildMapsListResponse());

4137 return new async.Future.value(common_test.stringResponse(200, h, resp));

4138 }), true);

4139 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) {

4140 checkMapsListResponse(response);

4141 })));

4142 });

4143

4144 unittest.test("method--listPublished", () {

4145

4146 var mock = new common_test.HttpServerMock();

4147 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4148 var arg_maxResults = 42;

4149 var arg_pageToken = "foo";

4150 var arg_projectId = "foo";

4151 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4152 var path = (req.url).path;

4153 var pathOffset = 0;

4154 var index;

4155 var subPart;

4156 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4157 pathOffset += 15;

4158 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("maps/published"));

4159 pathOffset += 14;

4160

4161 var query = (req.url).query;

4162 var queryOffset = 0;

4163 var queryMap = {};

4164 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4165 parseBool(n) {

4166 if (n == "true") return true;

4167 if (n == "false") return false;

4168 if (n == null) return null;

4169 throw new core.ArgumentError("Invalid boolean: $n");

4170 }

4171 if (query.length > 0) {

4172 for (var part in query.split("&")) {

4173 var keyvalue = part.split("=");

4174 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4175 }

4176 }

4177 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

4178 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

4179 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

4180

4181

4182 var h = {

4183 "content-type" : "application/json; charset=utf-8",

4184 };

4185 var resp = convert.JSON.encode(buildPublishedMapsListResponse());

4186 return new async.Future.value(common_test.stringResponse(200, h, resp));

4187 }), true);

4188 res.listPublished(maxResults: arg_maxResults, pageToken: arg_pageToken, pr ojectId: arg_projectId).then(unittest.expectAsync(((api.PublishedMapsListRespons e response) {

4189 checkPublishedMapsListResponse(response);

4190 })));

4191 });

4192

4193 unittest.test("method--patch", () {

4194

4195 var mock = new common_test.HttpServerMock();

4196 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4197 var arg_request = buildMap();

4198 var arg_id = "foo";

4199 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4200 var obj = new api.Map.fromJson(json);

4201 checkMap(obj);

4202

4203 var path = (req.url).path;

4204 var pathOffset = 0;

4205 var index;

4206 var subPart;

4207 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4208 pathOffset += 15;

4209 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("maps/"));

4210 pathOffset += 5;

4211 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4212 pathOffset = path.length;

4213 unittest.expect(subPart, unittest.equals("$arg_id"));

4214

4215 var query = (req.url).query;

4216 var queryOffset = 0;

4217 var queryMap = {};

4218 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4219 parseBool(n) {

4220 if (n == "true") return true;

4221 if (n == "false") return false;

4222 if (n == null) return null;

4223 throw new core.ArgumentError("Invalid boolean: $n");

4224 }

4225 if (query.length > 0) {

4226 for (var part in query.split("&")) {

4227 var keyvalue = part.split("=");

4228 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4229 }

4230 }

4231

4232

4233 var h = {

4234 "content-type" : "application/json; charset=utf-8",

4235 };

4236 var resp = "";

4237 return new async.Future.value(common_test.stringResponse(200, h, resp));

4238 }), true);

4239 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

4240 });

4241

4242 unittest.test("method--publish", () {

4243

4244 var mock = new common_test.HttpServerMock();

4245 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4246 var arg_id = "foo";

4247 var arg_force = true;

4248 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4249 var path = (req.url).path;

4250 var pathOffset = 0;

4251 var index;

4252 var subPart;

4253 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4254 pathOffset += 15;

4255 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("maps/"));

4256 pathOffset += 5;

4257 index = path.indexOf("/publish", pathOffset);

4258 unittest.expect(index >= 0, unittest.isTrue);

4259 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4260 pathOffset = index;

4261 unittest.expect(subPart, unittest.equals("$arg_id"));

4262 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/publish"));

4263 pathOffset += 8;

4264

4265 var query = (req.url).query;

4266 var queryOffset = 0;

4267 var queryMap = {};

4268 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4269 parseBool(n) {

4270 if (n == "true") return true;

4271 if (n == "false") return false;

4272 if (n == null) return null;

4273 throw new core.ArgumentError("Invalid boolean: $n");

4274 }

4275 if (query.length > 0) {

4276 for (var part in query.split("&")) {

4277 var keyvalue = part.split("=");

4278 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4279 }

4280 }

4281 unittest.expect(queryMap["force"].first, unittest.equals("$arg_force"));

4282

4283

4284 var h = {

4285 "content-type" : "application/json; charset=utf-8",

4286 };

4287 var resp = convert.JSON.encode(buildPublishResponse());

4288 return new async.Future.value(common_test.stringResponse(200, h, resp));

4289 }), true);

4290 res.publish(arg_id, force: arg_force).then(unittest.expectAsync(((api.Publ ishResponse response) {

4291 checkPublishResponse(response);

4292 })));

4293 });

4294

4295 unittest.test("method--unpublish", () {

4296

4297 var mock = new common_test.HttpServerMock();

4298 api.MapsResourceApi res = new api.MapsengineApi(mock).maps;

4299 var arg_id = "foo";

4300 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4301 var path = (req.url).path;

4302 var pathOffset = 0;

4303 var index;

4304 var subPart;

4305 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4306 pathOffset += 15;

4307 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("maps/"));

4308 pathOffset += 5;

4309 index = path.indexOf("/unpublish", pathOffset);

4310 unittest.expect(index >= 0, unittest.isTrue);

4311 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4312 pathOffset = index;

4313 unittest.expect(subPart, unittest.equals("$arg_id"));

4314 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/unpublish"));

4315 pathOffset += 10;

4316

4317 var query = (req.url).query;

4318 var queryOffset = 0;

4319 var queryMap = {};

4320 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4321 parseBool(n) {

4322 if (n == "true") return true;

4323 if (n == "false") return false;

4324 if (n == null) return null;

4325 throw new core.ArgumentError("Invalid boolean: $n");

4326 }

4327 if (query.length > 0) {

4328 for (var part in query.split("&")) {

4329 var keyvalue = part.split("=");

4330 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4331 }

4332 }

4333

4334

4335 var h = {

4336 "content-type" : "application/json; charset=utf-8",

4337 };

4338 var resp = convert.JSON.encode(buildPublishResponse());

4339 return new async.Future.value(common_test.stringResponse(200, h, resp));

4340 }), true);

4341 res.unpublish(arg_id).then(unittest.expectAsync(((api.PublishResponse resp onse) {

4342 checkPublishResponse(response);

4343 })));

4344 });

4345

4346 });

4347

4348

4349 unittest.group("resource-ProjectsResourceApi", () {

4350 unittest.test("method--list", () {

4351

4352 var mock = new common_test.HttpServerMock();

4353 api.ProjectsResourceApi res = new api.MapsengineApi(mock).projects;

4354 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4355 var path = (req.url).path;

4356 var pathOffset = 0;

4357 var index;

4358 var subPart;

4359 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4360 pathOffset += 15;

4361 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("projects"));

4362 pathOffset += 8;

4363

4364 var query = (req.url).query;

4365 var queryOffset = 0;

4366 var queryMap = {};

4367 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4368 parseBool(n) {

4369 if (n == "true") return true;

4370 if (n == "false") return false;

4371 if (n == null) return null;

4372 throw new core.ArgumentError("Invalid boolean: $n");

4373 }

4374 if (query.length > 0) {

4375 for (var part in query.split("&")) {

4376 var keyvalue = part.split("=");

4377 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4378 }

4379 }

4380

4381

4382 var h = {

4383 "content-type" : "application/json; charset=utf-8",

4384 };

4385 var resp = convert.JSON.encode(buildProjectsListResponse());

4386 return new async.Future.value(common_test.stringResponse(200, h, resp));

4387 }), true);

4388 res.list().then(unittest.expectAsync(((api.ProjectsListResponse response) {

4389 checkProjectsListResponse(response);

4390 })));

4391 });

4392

4393 });

4394

4395

4396 unittest.group("resource-ProjectsIconsResourceApi", () {

4397 unittest.test("method--create", () {

4398 // TODO: Implement tests for media upload;

4399 // TODO: Implement tests for media download;

4400

4401 var mock = new common_test.HttpServerMock();

4402 api.ProjectsIconsResourceApi res = new api.MapsengineApi(mock).projects.ic ons;

4403 var arg_request = buildIcon();

4404 var arg_projectId = "foo";

4405 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4406 var obj = new api.Icon.fromJson(json);

4407 checkIcon(obj);

4408

4409 var path = (req.url).path;

4410 var pathOffset = 0;

4411 var index;

4412 var subPart;

4413 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4414 pathOffset += 15;

4415 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("projects/"));

4416 pathOffset += 9;

4417 index = path.indexOf("/icons", pathOffset);

4418 unittest.expect(index >= 0, unittest.isTrue);

4419 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4420 pathOffset = index;

4421 unittest.expect(subPart, unittest.equals("$arg_projectId"));

4422 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/icons"));

4423 pathOffset += 6;

4424

4425 var query = (req.url).query;

4426 var queryOffset = 0;

4427 var queryMap = {};

4428 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4429 parseBool(n) {

4430 if (n == "true") return true;

4431 if (n == "false") return false;

4432 if (n == null) return null;

4433 throw new core.ArgumentError("Invalid boolean: $n");

4434 }

4435 if (query.length > 0) {

4436 for (var part in query.split("&")) {

4437 var keyvalue = part.split("=");

4438 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4439 }

4440 }

4441

4442

4443 var h = {

4444 "content-type" : "application/json; charset=utf-8",

4445 };

4446 var resp = convert.JSON.encode(buildIcon());

4447 return new async.Future.value(common_test.stringResponse(200, h, resp));

4448 }), true);

4449 res.create(arg_request, arg_projectId).then(unittest.expectAsync(((api.Ico n response) {

4450 checkIcon(response);

4451 })));

4452 });

4453

4454 unittest.test("method--get", () {

4455 // TODO: Implement tests for media upload;

4456 // TODO: Implement tests for media download;

4457

4458 var mock = new common_test.HttpServerMock();

4459 api.ProjectsIconsResourceApi res = new api.MapsengineApi(mock).projects.ic ons;

4460 var arg_projectId = "foo";

4461 var arg_id = "foo";

4462 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4463 var path = (req.url).path;

4464 var pathOffset = 0;

4465 var index;

4466 var subPart;

4467 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4468 pathOffset += 15;

4469 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("projects/"));

4470 pathOffset += 9;

4471 index = path.indexOf("/icons/", pathOffset);

4472 unittest.expect(index >= 0, unittest.isTrue);

4473 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4474 pathOffset = index;

4475 unittest.expect(subPart, unittest.equals("$arg_projectId"));

4476 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/icons/"));

4477 pathOffset += 7;

4478 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4479 pathOffset = path.length;

4480 unittest.expect(subPart, unittest.equals("$arg_id"));

4481

4482 var query = (req.url).query;

4483 var queryOffset = 0;

4484 var queryMap = {};

4485 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4486 parseBool(n) {

4487 if (n == "true") return true;

4488 if (n == "false") return false;

4489 if (n == null) return null;

4490 throw new core.ArgumentError("Invalid boolean: $n");

4491 }

4492 if (query.length > 0) {

4493 for (var part in query.split("&")) {

4494 var keyvalue = part.split("=");

4495 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4496 }

4497 }

4498

4499

4500 var h = {

4501 "content-type" : "application/json; charset=utf-8",

4502 };

4503 var resp = convert.JSON.encode(buildIcon());

4504 return new async.Future.value(common_test.stringResponse(200, h, resp));

4505 }), true);

4506 res.get(arg_projectId, arg_id).then(unittest.expectAsync(((api.Icon respon se) {

4507 checkIcon(response);

4508 })));

4509 });

4510

4511 unittest.test("method--list", () {

4512

4513 var mock = new common_test.HttpServerMock();

4514 api.ProjectsIconsResourceApi res = new api.MapsengineApi(mock).projects.ic ons;

4515 var arg_projectId = "foo";

4516 var arg_maxResults = 42;

4517 var arg_pageToken = "foo";

4518 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4519 var path = (req.url).path;

4520 var pathOffset = 0;

4521 var index;

4522 var subPart;

4523 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4524 pathOffset += 15;

4525 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("projects/"));

4526 pathOffset += 9;

4527 index = path.indexOf("/icons", pathOffset);

4528 unittest.expect(index >= 0, unittest.isTrue);

4529 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4530 pathOffset = index;

4531 unittest.expect(subPart, unittest.equals("$arg_projectId"));

4532 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/icons"));

4533 pathOffset += 6;

4534

4535 var query = (req.url).query;

4536 var queryOffset = 0;

4537 var queryMap = {};

4538 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4539 parseBool(n) {

4540 if (n == "true") return true;

4541 if (n == "false") return false;

4542 if (n == null) return null;

4543 throw new core.ArgumentError("Invalid boolean: $n");

4544 }

4545 if (query.length > 0) {

4546 for (var part in query.split("&")) {

4547 var keyvalue = part.split("=");

4548 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4549 }

4550 }

4551 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

4552 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

4553

4554

4555 var h = {

4556 "content-type" : "application/json; charset=utf-8",

4557 };

4558 var resp = convert.JSON.encode(buildIconsListResponse());

4559 return new async.Future.value(common_test.stringResponse(200, h, resp));

4560 }), true);

4561 res.list(arg_projectId, maxResults: arg_maxResults, pageToken: arg_pageTok en).then(unittest.expectAsync(((api.IconsListResponse response) {

4562 checkIconsListResponse(response);

4563 })));

4564 });

4565

4566 });

4567

4568

4569 unittest.group("resource-RasterCollectionsResourceApi", () {

4570 unittest.test("method--cancelProcessing", () {

4571

4572 var mock = new common_test.HttpServerMock();

4573 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

4574 var arg_id = "foo";

4575 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4576 var path = (req.url).path;

4577 var pathOffset = 0;

4578 var index;

4579 var subPart;

4580 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4581 pathOffset += 15;

4582 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

4583 pathOffset += 18;

4584 index = path.indexOf("/cancelProcessing", pathOffset);

4585 unittest.expect(index >= 0, unittest.isTrue);

4586 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4587 pathOffset = index;

4588 unittest.expect(subPart, unittest.equals("$arg_id"));

4589 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/cancelProcessing"));

4590 pathOffset += 17;

4591

4592 var query = (req.url).query;

4593 var queryOffset = 0;

4594 var queryMap = {};

4595 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4596 parseBool(n) {

4597 if (n == "true") return true;

4598 if (n == "false") return false;

4599 if (n == null) return null;

4600 throw new core.ArgumentError("Invalid boolean: $n");

4601 }

4602 if (query.length > 0) {

4603 for (var part in query.split("&")) {

4604 var keyvalue = part.split("=");

4605 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4606 }

4607 }

4608

4609

4610 var h = {

4611 "content-type" : "application/json; charset=utf-8",

4612 };

4613 var resp = convert.JSON.encode(buildProcessResponse());

4614 return new async.Future.value(common_test.stringResponse(200, h, resp));

4615 }), true);

4616 res.cancelProcessing(arg_id).then(unittest.expectAsync(((api.ProcessRespon se response) {

4617 checkProcessResponse(response);

4618 })));

4619 });

4620

4621 unittest.test("method--create", () {

4622

4623 var mock = new common_test.HttpServerMock();

4624 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

4625 var arg_request = buildRasterCollection();

4626 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4627 var obj = new api.RasterCollection.fromJson(json);

4628 checkRasterCollection(obj);

4629

4630 var path = (req.url).path;

4631 var pathOffset = 0;

4632 var index;

4633 var subPart;

4634 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4635 pathOffset += 15;

4636 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("rasterCollections"));

4637 pathOffset += 17;

4638

4639 var query = (req.url).query;

4640 var queryOffset = 0;

4641 var queryMap = {};

4642 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4643 parseBool(n) {

4644 if (n == "true") return true;

4645 if (n == "false") return false;

4646 if (n == null) return null;

4647 throw new core.ArgumentError("Invalid boolean: $n");

4648 }

4649 if (query.length > 0) {

4650 for (var part in query.split("&")) {

4651 var keyvalue = part.split("=");

4652 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4653 }

4654 }

4655

4656

4657 var h = {

4658 "content-type" : "application/json; charset=utf-8",

4659 };

4660 var resp = convert.JSON.encode(buildRasterCollection());

4661 return new async.Future.value(common_test.stringResponse(200, h, resp));

4662 }), true);

4663 res.create(arg_request).then(unittest.expectAsync(((api.RasterCollection r esponse) {

4664 checkRasterCollection(response);

4665 })));

4666 });

4667

4668 unittest.test("method--delete", () {

4669

4670 var mock = new common_test.HttpServerMock();

4671 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

4672 var arg_id = "foo";

4673 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4674 var path = (req.url).path;

4675 var pathOffset = 0;

4676 var index;

4677 var subPart;

4678 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4679 pathOffset += 15;

4680 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

4681 pathOffset += 18;

4682 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4683 pathOffset = path.length;

4684 unittest.expect(subPart, unittest.equals("$arg_id"));

4685

4686 var query = (req.url).query;

4687 var queryOffset = 0;

4688 var queryMap = {};

4689 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4690 parseBool(n) {

4691 if (n == "true") return true;

4692 if (n == "false") return false;

4693 if (n == null) return null;

4694 throw new core.ArgumentError("Invalid boolean: $n");

4695 }

4696 if (query.length > 0) {

4697 for (var part in query.split("&")) {

4698 var keyvalue = part.split("=");

4699 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4700 }

4701 }

4702

4703

4704 var h = {

4705 "content-type" : "application/json; charset=utf-8",

4706 };

4707 var resp = "";

4708 return new async.Future.value(common_test.stringResponse(200, h, resp));

4709 }), true);

4710 res.delete(arg_id).then(unittest.expectAsync((_) {}));

4711 });

4712

4713 unittest.test("method--get", () {

4714

4715 var mock = new common_test.HttpServerMock();

4716 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

4717 var arg_id = "foo";

4718 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4719 var path = (req.url).path;

4720 var pathOffset = 0;

4721 var index;

4722 var subPart;

4723 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4724 pathOffset += 15;

4725 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

4726 pathOffset += 18;

4727 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4728 pathOffset = path.length;

4729 unittest.expect(subPart, unittest.equals("$arg_id"));

4730

4731 var query = (req.url).query;

4732 var queryOffset = 0;

4733 var queryMap = {};

4734 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4735 parseBool(n) {

4736 if (n == "true") return true;

4737 if (n == "false") return false;

4738 if (n == null) return null;

4739 throw new core.ArgumentError("Invalid boolean: $n");

4740 }

4741 if (query.length > 0) {

4742 for (var part in query.split("&")) {

4743 var keyvalue = part.split("=");

4744 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4745 }

4746 }

4747

4748

4749 var h = {

4750 "content-type" : "application/json; charset=utf-8",

4751 };

4752 var resp = convert.JSON.encode(buildRasterCollection());

4753 return new async.Future.value(common_test.stringResponse(200, h, resp));

4754 }), true);

4755 res.get(arg_id).then(unittest.expectAsync(((api.RasterCollection response) {

4756 checkRasterCollection(response);

4757 })));

4758 });

4759

4760 unittest.test("method--list", () {

4761

4762 var mock = new common_test.HttpServerMock();

4763 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

4764 var arg_bbox = "foo";

4765 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

4766 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

4767 var arg_creatorEmail = "foo";

4768 var arg_maxResults = 42;

4769 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

4770 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

4771 var arg_pageToken = "foo";

4772 var arg_processingStatus = "foo";

4773 var arg_projectId = "foo";

4774 var arg_role = "foo";

4775 var arg_search = "foo";

4776 var arg_tags = "foo";

4777 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4778 var path = (req.url).path;

4779 var pathOffset = 0;

4780 var index;

4781 var subPart;

4782 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4783 pathOffset += 15;

4784 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("rasterCollections"));

4785 pathOffset += 17;

4786

4787 var query = (req.url).query;

4788 var queryOffset = 0;

4789 var queryMap = {};

4790 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4791 parseBool(n) {

4792 if (n == "true") return true;

4793 if (n == "false") return false;

4794 if (n == null) return null;

4795 throw new core.ArgumentError("Invalid boolean: $n");

4796 }

4797 if (query.length > 0) {

4798 for (var part in query.split("&")) {

4799 var keyvalue = part.split("=");

4800 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4801 }

4802 }

4803 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

4804 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

4805 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

4806 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

4807 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

4808 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

4809 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

4810 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

4811 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

4812 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

4813 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

4814 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

4815 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

4816

4817

4818 var h = {

4819 "content-type" : "application/json; charset=utf-8",

4820 };

4821 var resp = convert.JSON.encode(buildRasterCollectionsListResponse());

4822 return new async.Future.value(common_test.stringResponse(200, h, resp));

4823 }), true);

4824 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) {

4825 checkRasterCollectionsListResponse(response);

4826 })));

4827 });

4828

4829 unittest.test("method--patch", () {

4830

4831 var mock = new common_test.HttpServerMock();

4832 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

4833 var arg_request = buildRasterCollection();

4834 var arg_id = "foo";

4835 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4836 var obj = new api.RasterCollection.fromJson(json);

4837 checkRasterCollection(obj);

4838

4839 var path = (req.url).path;

4840 var pathOffset = 0;

4841 var index;

4842 var subPart;

4843 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4844 pathOffset += 15;

4845 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

4846 pathOffset += 18;

4847 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4848 pathOffset = path.length;

4849 unittest.expect(subPart, unittest.equals("$arg_id"));

4850

4851 var query = (req.url).query;

4852 var queryOffset = 0;

4853 var queryMap = {};

4854 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4855 parseBool(n) {

4856 if (n == "true") return true;

4857 if (n == "false") return false;

4858 if (n == null) return null;

4859 throw new core.ArgumentError("Invalid boolean: $n");

4860 }

4861 if (query.length > 0) {

4862 for (var part in query.split("&")) {

4863 var keyvalue = part.split("=");

4864 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4865 }

4866 }

4867

4868

4869 var h = {

4870 "content-type" : "application/json; charset=utf-8",

4871 };

4872 var resp = "";

4873 return new async.Future.value(common_test.stringResponse(200, h, resp));

4874 }), true);

4875 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

4876 });

4877

4878 unittest.test("method--process", () {

4879

4880 var mock = new common_test.HttpServerMock();

4881 api.RasterCollectionsResourceApi res = new api.MapsengineApi(mock).rasterC ollections;

4882 var arg_id = "foo";

4883 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4884 var path = (req.url).path;

4885 var pathOffset = 0;

4886 var index;

4887 var subPart;

4888 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4889 pathOffset += 15;

4890 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

4891 pathOffset += 18;

4892 index = path.indexOf("/process", pathOffset);

4893 unittest.expect(index >= 0, unittest.isTrue);

4894 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4895 pathOffset = index;

4896 unittest.expect(subPart, unittest.equals("$arg_id"));

4897 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/process"));

4898 pathOffset += 8;

4899

4900 var query = (req.url).query;

4901 var queryOffset = 0;

4902 var queryMap = {};

4903 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4904 parseBool(n) {

4905 if (n == "true") return true;

4906 if (n == "false") return false;

4907 if (n == null) return null;

4908 throw new core.ArgumentError("Invalid boolean: $n");

4909 }

4910 if (query.length > 0) {

4911 for (var part in query.split("&")) {

4912 var keyvalue = part.split("=");

4913 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4914 }

4915 }

4916

4917

4918 var h = {

4919 "content-type" : "application/json; charset=utf-8",

4920 };

4921 var resp = convert.JSON.encode(buildProcessResponse());

4922 return new async.Future.value(common_test.stringResponse(200, h, resp));

4923 }), true);

4924 res.process(arg_id).then(unittest.expectAsync(((api.ProcessResponse respon se) {

4925 checkProcessResponse(response);

4926 })));

4927 });

4928

4929 });

4930

4931

4932 unittest.group("resource-RasterCollectionsParentsResourceApi", () {

4933 unittest.test("method--list", () {

4934

4935 var mock = new common_test.HttpServerMock();

4936 api.RasterCollectionsParentsResourceApi res = new api.MapsengineApi(mock). rasterCollections.parents;

4937 var arg_id = "foo";

4938 var arg_maxResults = 42;

4939 var arg_pageToken = "foo";

4940 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4941 var path = (req.url).path;

4942 var pathOffset = 0;

4943 var index;

4944 var subPart;

4945 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

4946 pathOffset += 15;

4947 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

4948 pathOffset += 18;

4949 index = path.indexOf("/parents", pathOffset);

4950 unittest.expect(index >= 0, unittest.isTrue);

4951 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4952 pathOffset = index;

4953 unittest.expect(subPart, unittest.equals("$arg_id"));

4954 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/parents"));

4955 pathOffset += 8;

4956

4957 var query = (req.url).query;

4958 var queryOffset = 0;

4959 var queryMap = {};

4960 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4961 parseBool(n) {

4962 if (n == "true") return true;

4963 if (n == "false") return false;

4964 if (n == null) return null;

4965 throw new core.ArgumentError("Invalid boolean: $n");

4966 }

4967 if (query.length > 0) {

4968 for (var part in query.split("&")) {

4969 var keyvalue = part.split("=");

4970 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4971 }

4972 }

4973 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

4974 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

4975

4976

4977 var h = {

4978 "content-type" : "application/json; charset=utf-8",

4979 };

4980 var resp = convert.JSON.encode(buildParentsListResponse());

4981 return new async.Future.value(common_test.stringResponse(200, h, resp));

4982 }), true);

4983 res.list(arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken).the n(unittest.expectAsync(((api.ParentsListResponse response) {

4984 checkParentsListResponse(response);

4985 })));

4986 });

4987

4988 });

4989

4990

4991 unittest.group("resource-RasterCollectionsRastersResourceApi", () {

4992 unittest.test("method--batchDelete", () {

4993

4994 var mock = new common_test.HttpServerMock();

4995 api.RasterCollectionsRastersResourceApi res = new api.MapsengineApi(mock). rasterCollections.rasters;

4996 var arg_request = buildRasterCollectionsRasterBatchDeleteRequest();

4997 var arg_id = "foo";

4998 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4999 var obj = new api.RasterCollectionsRasterBatchDeleteRequest.fromJson(jso n);

5000 checkRasterCollectionsRasterBatchDeleteRequest(obj);

5001

5002 var path = (req.url).path;

5003 var pathOffset = 0;

5004 var index;

5005 var subPart;

5006 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5007 pathOffset += 15;

5008 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5009 pathOffset += 18;

5010 index = path.indexOf("/rasters/batchDelete", pathOffset);

5011 unittest.expect(index >= 0, unittest.isTrue);

5012 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5013 pathOffset = index;

5014 unittest.expect(subPart, unittest.equals("$arg_id"));

5015 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/rasters/batchDelete"));

5016 pathOffset += 20;

5017

5018 var query = (req.url).query;

5019 var queryOffset = 0;

5020 var queryMap = {};

5021 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5022 parseBool(n) {

5023 if (n == "true") return true;

5024 if (n == "false") return false;

5025 if (n == null) return null;

5026 throw new core.ArgumentError("Invalid boolean: $n");

5027 }

5028 if (query.length > 0) {

5029 for (var part in query.split("&")) {

5030 var keyvalue = part.split("=");

5031 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5032 }

5033 }

5034

5035

5036 var h = {

5037 "content-type" : "application/json; charset=utf-8",

5038 };

5039 var resp = convert.JSON.encode(buildRasterCollectionsRastersBatchDeleteR esponse());

5040 return new async.Future.value(common_test.stringResponse(200, h, resp));

5041 }), true);

5042 res.batchDelete(arg_request, arg_id).then(unittest.expectAsync(((api.Raste rCollectionsRastersBatchDeleteResponse response) {

5043 checkRasterCollectionsRastersBatchDeleteResponse(response);

5044 })));

5045 });

5046

5047 unittest.test("method--batchInsert", () {

5048

5049 var mock = new common_test.HttpServerMock();

5050 api.RasterCollectionsRastersResourceApi res = new api.MapsengineApi(mock). rasterCollections.rasters;

5051 var arg_request = buildRasterCollectionsRastersBatchInsertRequest();

5052 var arg_id = "foo";

5053 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5054 var obj = new api.RasterCollectionsRastersBatchInsertRequest.fromJson(js on);

5055 checkRasterCollectionsRastersBatchInsertRequest(obj);

5056

5057 var path = (req.url).path;

5058 var pathOffset = 0;

5059 var index;

5060 var subPart;

5061 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5062 pathOffset += 15;

5063 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5064 pathOffset += 18;

5065 index = path.indexOf("/rasters/batchInsert", pathOffset);

5066 unittest.expect(index >= 0, unittest.isTrue);

5067 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5068 pathOffset = index;

5069 unittest.expect(subPart, unittest.equals("$arg_id"));

5070 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/rasters/batchInsert"));

5071 pathOffset += 20;

5072

5073 var query = (req.url).query;

5074 var queryOffset = 0;

5075 var queryMap = {};

5076 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5077 parseBool(n) {

5078 if (n == "true") return true;

5079 if (n == "false") return false;

5080 if (n == null) return null;

5081 throw new core.ArgumentError("Invalid boolean: $n");

5082 }

5083 if (query.length > 0) {

5084 for (var part in query.split("&")) {

5085 var keyvalue = part.split("=");

5086 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5087 }

5088 }

5089

5090

5091 var h = {

5092 "content-type" : "application/json; charset=utf-8",

5093 };

5094 var resp = convert.JSON.encode(buildRasterCollectionsRastersBatchInsertR esponse());

5095 return new async.Future.value(common_test.stringResponse(200, h, resp));

5096 }), true);

5097 res.batchInsert(arg_request, arg_id).then(unittest.expectAsync(((api.Raste rCollectionsRastersBatchInsertResponse response) {

5098 checkRasterCollectionsRastersBatchInsertResponse(response);

5099 })));

5100 });

5101

5102 unittest.test("method--list", () {

5103

5104 var mock = new common_test.HttpServerMock();

5105 api.RasterCollectionsRastersResourceApi res = new api.MapsengineApi(mock). rasterCollections.rasters;

5106 var arg_id = "foo";

5107 var arg_bbox = "foo";

5108 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

5109 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

5110 var arg_creatorEmail = "foo";

5111 var arg_maxResults = 42;

5112 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

5113 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

5114 var arg_pageToken = "foo";

5115 var arg_role = "foo";

5116 var arg_search = "foo";

5117 var arg_tags = "foo";

5118 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5119 var path = (req.url).path;

5120 var pathOffset = 0;

5121 var index;

5122 var subPart;

5123 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5124 pathOffset += 15;

5125 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("rasterCollections/"));

5126 pathOffset += 18;

5127 index = path.indexOf("/rasters", pathOffset);

5128 unittest.expect(index >= 0, unittest.isTrue);

5129 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5130 pathOffset = index;

5131 unittest.expect(subPart, unittest.equals("$arg_id"));

5132 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/rasters"));

5133 pathOffset += 8;

5134

5135 var query = (req.url).query;

5136 var queryOffset = 0;

5137 var queryMap = {};

5138 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5139 parseBool(n) {

5140 if (n == "true") return true;

5141 if (n == "false") return false;

5142 if (n == null) return null;

5143 throw new core.ArgumentError("Invalid boolean: $n");

5144 }

5145 if (query.length > 0) {

5146 for (var part in query.split("&")) {

5147 var keyvalue = part.split("=");

5148 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5149 }

5150 }

5151 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

5152 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

5153 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

5154 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

5155 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5156 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

5157 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

5158 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5159 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

5160 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

5161 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

5162

5163

5164 var h = {

5165 "content-type" : "application/json; charset=utf-8",

5166 };

5167 var resp = convert.JSON.encode(buildRasterCollectionsRastersListResponse ());

5168 return new async.Future.value(common_test.stringResponse(200, h, resp));

5169 }), true);

5170 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) {

5171 checkRasterCollectionsRastersListResponse(response);

5172 })));

5173 });

5174

5175 });

5176

5177

5178 unittest.group("resource-RastersResourceApi", () {

5179 unittest.test("method--delete", () {

5180

5181 var mock = new common_test.HttpServerMock();

5182 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

5183 var arg_id = "foo";

5184 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5185 var path = (req.url).path;

5186 var pathOffset = 0;

5187 var index;

5188 var subPart;

5189 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5190 pathOffset += 15;

5191 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

5192 pathOffset += 8;

5193 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5194 pathOffset = path.length;

5195 unittest.expect(subPart, unittest.equals("$arg_id"));

5196

5197 var query = (req.url).query;

5198 var queryOffset = 0;

5199 var queryMap = {};

5200 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5201 parseBool(n) {

5202 if (n == "true") return true;

5203 if (n == "false") return false;

5204 if (n == null) return null;

5205 throw new core.ArgumentError("Invalid boolean: $n");

5206 }

5207 if (query.length > 0) {

5208 for (var part in query.split("&")) {

5209 var keyvalue = part.split("=");

5210 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5211 }

5212 }

5213

5214

5215 var h = {

5216 "content-type" : "application/json; charset=utf-8",

5217 };

5218 var resp = "";

5219 return new async.Future.value(common_test.stringResponse(200, h, resp));

5220 }), true);

5221 res.delete(arg_id).then(unittest.expectAsync((_) {}));

5222 });

5223

5224 unittest.test("method--get", () {

5225

5226 var mock = new common_test.HttpServerMock();

5227 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

5228 var arg_id = "foo";

5229 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5230 var path = (req.url).path;

5231 var pathOffset = 0;

5232 var index;

5233 var subPart;

5234 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5235 pathOffset += 15;

5236 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

5237 pathOffset += 8;

5238 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5239 pathOffset = path.length;

5240 unittest.expect(subPart, unittest.equals("$arg_id"));

5241

5242 var query = (req.url).query;

5243 var queryOffset = 0;

5244 var queryMap = {};

5245 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5246 parseBool(n) {

5247 if (n == "true") return true;

5248 if (n == "false") return false;

5249 if (n == null) return null;

5250 throw new core.ArgumentError("Invalid boolean: $n");

5251 }

5252 if (query.length > 0) {

5253 for (var part in query.split("&")) {

5254 var keyvalue = part.split("=");

5255 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5256 }

5257 }

5258

5259

5260 var h = {

5261 "content-type" : "application/json; charset=utf-8",

5262 };

5263 var resp = convert.JSON.encode(buildRaster());

5264 return new async.Future.value(common_test.stringResponse(200, h, resp));

5265 }), true);

5266 res.get(arg_id).then(unittest.expectAsync(((api.Raster response) {

5267 checkRaster(response);

5268 })));

5269 });

5270

5271 unittest.test("method--list", () {

5272

5273 var mock = new common_test.HttpServerMock();

5274 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

5275 var arg_projectId = "foo";

5276 var arg_bbox = "foo";

5277 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

5278 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

5279 var arg_creatorEmail = "foo";

5280 var arg_maxResults = 42;

5281 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

5282 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

5283 var arg_pageToken = "foo";

5284 var arg_processingStatus = "foo";

5285 var arg_role = "foo";

5286 var arg_search = "foo";

5287 var arg_tags = "foo";

5288 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5289 var path = (req.url).path;

5290 var pathOffset = 0;

5291 var index;

5292 var subPart;

5293 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5294 pathOffset += 15;

5295 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("rasters"));

5296 pathOffset += 7;

5297

5298 var query = (req.url).query;

5299 var queryOffset = 0;

5300 var queryMap = {};

5301 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5302 parseBool(n) {

5303 if (n == "true") return true;

5304 if (n == "false") return false;

5305 if (n == null) return null;

5306 throw new core.ArgumentError("Invalid boolean: $n");

5307 }

5308 if (query.length > 0) {

5309 for (var part in query.split("&")) {

5310 var keyvalue = part.split("=");

5311 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5312 }

5313 }

5314 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

5315 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

5316 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

5317 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

5318 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

5319 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5320 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

5321 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

5322 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5323 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

5324 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

5325 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

5326 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

5327

5328

5329 var h = {

5330 "content-type" : "application/json; charset=utf-8",

5331 };

5332 var resp = convert.JSON.encode(buildRastersListResponse());

5333 return new async.Future.value(common_test.stringResponse(200, h, resp));

5334 }), true);

5335 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) {

5336 checkRastersListResponse(response);

5337 })));

5338 });

5339

5340 unittest.test("method--patch", () {

5341

5342 var mock = new common_test.HttpServerMock();

5343 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

5344 var arg_request = buildRaster();

5345 var arg_id = "foo";

5346 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5347 var obj = new api.Raster.fromJson(json);

5348 checkRaster(obj);

5349

5350 var path = (req.url).path;

5351 var pathOffset = 0;

5352 var index;

5353 var subPart;

5354 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5355 pathOffset += 15;

5356 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

5357 pathOffset += 8;

5358 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5359 pathOffset = path.length;

5360 unittest.expect(subPart, unittest.equals("$arg_id"));

5361

5362 var query = (req.url).query;

5363 var queryOffset = 0;

5364 var queryMap = {};

5365 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5366 parseBool(n) {

5367 if (n == "true") return true;

5368 if (n == "false") return false;

5369 if (n == null) return null;

5370 throw new core.ArgumentError("Invalid boolean: $n");

5371 }

5372 if (query.length > 0) {

5373 for (var part in query.split("&")) {

5374 var keyvalue = part.split("=");

5375 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5376 }

5377 }

5378

5379

5380 var h = {

5381 "content-type" : "application/json; charset=utf-8",

5382 };

5383 var resp = "";

5384 return new async.Future.value(common_test.stringResponse(200, h, resp));

5385 }), true);

5386 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

5387 });

5388

5389 unittest.test("method--process", () {

5390

5391 var mock = new common_test.HttpServerMock();

5392 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

5393 var arg_id = "foo";

5394 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5395 var path = (req.url).path;

5396 var pathOffset = 0;

5397 var index;

5398 var subPart;

5399 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5400 pathOffset += 15;

5401 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

5402 pathOffset += 8;

5403 index = path.indexOf("/process", pathOffset);

5404 unittest.expect(index >= 0, unittest.isTrue);

5405 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5406 pathOffset = index;

5407 unittest.expect(subPart, unittest.equals("$arg_id"));

5408 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/process"));

5409 pathOffset += 8;

5410

5411 var query = (req.url).query;

5412 var queryOffset = 0;

5413 var queryMap = {};

5414 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5415 parseBool(n) {

5416 if (n == "true") return true;

5417 if (n == "false") return false;

5418 if (n == null) return null;

5419 throw new core.ArgumentError("Invalid boolean: $n");

5420 }

5421 if (query.length > 0) {

5422 for (var part in query.split("&")) {

5423 var keyvalue = part.split("=");

5424 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5425 }

5426 }

5427

5428

5429 var h = {

5430 "content-type" : "application/json; charset=utf-8",

5431 };

5432 var resp = convert.JSON.encode(buildProcessResponse());

5433 return new async.Future.value(common_test.stringResponse(200, h, resp));

5434 }), true);

5435 res.process(arg_id).then(unittest.expectAsync(((api.ProcessResponse respon se) {

5436 checkProcessResponse(response);

5437 })));

5438 });

5439

5440 unittest.test("method--upload", () {

5441

5442 var mock = new common_test.HttpServerMock();

5443 api.RastersResourceApi res = new api.MapsengineApi(mock).rasters;

5444 var arg_request = buildRaster();

5445 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5446 var obj = new api.Raster.fromJson(json);

5447 checkRaster(obj);

5448

5449 var path = (req.url).path;

5450 var pathOffset = 0;

5451 var index;

5452 var subPart;

5453 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5454 pathOffset += 15;

5455 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("rasters/upload"));

5456 pathOffset += 14;

5457

5458 var query = (req.url).query;

5459 var queryOffset = 0;

5460 var queryMap = {};

5461 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5462 parseBool(n) {

5463 if (n == "true") return true;

5464 if (n == "false") return false;

5465 if (n == null) return null;

5466 throw new core.ArgumentError("Invalid boolean: $n");

5467 }

5468 if (query.length > 0) {

5469 for (var part in query.split("&")) {

5470 var keyvalue = part.split("=");

5471 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5472 }

5473 }

5474

5475

5476 var h = {

5477 "content-type" : "application/json; charset=utf-8",

5478 };

5479 var resp = convert.JSON.encode(buildRaster());

5480 return new async.Future.value(common_test.stringResponse(200, h, resp));

5481 }), true);

5482 res.upload(arg_request).then(unittest.expectAsync(((api.Raster response) {

5483 checkRaster(response);

5484 })));

5485 });

5486

5487 });

5488

5489

5490 unittest.group("resource-RastersFilesResourceApi", () {

5491 unittest.test("method--insert", () {

5492 // TODO: Implement tests for media upload;

5493 // TODO: Implement tests for media download;

5494

5495 var mock = new common_test.HttpServerMock();

5496 api.RastersFilesResourceApi res = new api.MapsengineApi(mock).rasters.file s;

5497 var arg_id = "foo";

5498 var arg_filename = "foo";

5499 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5500 var path = (req.url).path;

5501 var pathOffset = 0;

5502 var index;

5503 var subPart;

5504 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5505 pathOffset += 15;

5506 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

5507 pathOffset += 8;

5508 index = path.indexOf("/files", pathOffset);

5509 unittest.expect(index >= 0, unittest.isTrue);

5510 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5511 pathOffset = index;

5512 unittest.expect(subPart, unittest.equals("$arg_id"));

5513 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/files"));

5514 pathOffset += 6;

5515

5516 var query = (req.url).query;

5517 var queryOffset = 0;

5518 var queryMap = {};

5519 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5520 parseBool(n) {

5521 if (n == "true") return true;

5522 if (n == "false") return false;

5523 if (n == null) return null;

5524 throw new core.ArgumentError("Invalid boolean: $n");

5525 }

5526 if (query.length > 0) {

5527 for (var part in query.split("&")) {

5528 var keyvalue = part.split("=");

5529 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5530 }

5531 }

5532 unittest.expect(queryMap["filename"].first, unittest.equals(arg_filename ));

5533

5534

5535 var h = {

5536 "content-type" : "application/json; charset=utf-8",

5537 };

5538 var resp = "";

5539 return new async.Future.value(common_test.stringResponse(200, h, resp));

5540 }), true);

5541 res.insert(arg_id, arg_filename).then(unittest.expectAsync((_) {}));

5542 });

5543

5544 });

5545

5546

5547 unittest.group("resource-RastersParentsResourceApi", () {

5548 unittest.test("method--list", () {

5549

5550 var mock = new common_test.HttpServerMock();

5551 api.RastersParentsResourceApi res = new api.MapsengineApi(mock).rasters.pa rents;

5552 var arg_id = "foo";

5553 var arg_maxResults = 42;

5554 var arg_pageToken = "foo";

5555 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5556 var path = (req.url).path;

5557 var pathOffset = 0;

5558 var index;

5559 var subPart;

5560 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5561 pathOffset += 15;

5562 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("rasters/"));

5563 pathOffset += 8;

5564 index = path.indexOf("/parents", pathOffset);

5565 unittest.expect(index >= 0, unittest.isTrue);

5566 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5567 pathOffset = index;

5568 unittest.expect(subPart, unittest.equals("$arg_id"));

5569 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/parents"));

5570 pathOffset += 8;

5571

5572 var query = (req.url).query;

5573 var queryOffset = 0;

5574 var queryMap = {};

5575 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5576 parseBool(n) {

5577 if (n == "true") return true;

5578 if (n == "false") return false;

5579 if (n == null) return null;

5580 throw new core.ArgumentError("Invalid boolean: $n");

5581 }

5582 if (query.length > 0) {

5583 for (var part in query.split("&")) {

5584 var keyvalue = part.split("=");

5585 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5586 }

5587 }

5588 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5589 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5590

5591

5592 var h = {

5593 "content-type" : "application/json; charset=utf-8",

5594 };

5595 var resp = convert.JSON.encode(buildParentsListResponse());

5596 return new async.Future.value(common_test.stringResponse(200, h, resp));

5597 }), true);

5598 res.list(arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken).the n(unittest.expectAsync(((api.ParentsListResponse response) {

5599 checkParentsListResponse(response);

5600 })));

5601 });

5602

5603 });

5604

5605

5606 unittest.group("resource-TablesResourceApi", () {

5607 unittest.test("method--create", () {

5608

5609 var mock = new common_test.HttpServerMock();

5610 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

5611 var arg_request = buildTable();

5612 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5613 var obj = new api.Table.fromJson(json);

5614 checkTable(obj);

5615

5616 var path = (req.url).path;

5617 var pathOffset = 0;

5618 var index;

5619 var subPart;

5620 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5621 pathOffset += 15;

5622 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("tables"));

5623 pathOffset += 6;

5624

5625 var query = (req.url).query;

5626 var queryOffset = 0;

5627 var queryMap = {};

5628 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5629 parseBool(n) {

5630 if (n == "true") return true;

5631 if (n == "false") return false;

5632 if (n == null) return null;

5633 throw new core.ArgumentError("Invalid boolean: $n");

5634 }

5635 if (query.length > 0) {

5636 for (var part in query.split("&")) {

5637 var keyvalue = part.split("=");

5638 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5639 }

5640 }

5641

5642

5643 var h = {

5644 "content-type" : "application/json; charset=utf-8",

5645 };

5646 var resp = convert.JSON.encode(buildTable());

5647 return new async.Future.value(common_test.stringResponse(200, h, resp));

5648 }), true);

5649 res.create(arg_request).then(unittest.expectAsync(((api.Table response) {

5650 checkTable(response);

5651 })));

5652 });

5653

5654 unittest.test("method--delete", () {

5655

5656 var mock = new common_test.HttpServerMock();

5657 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

5658 var arg_id = "foo";

5659 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5660 var path = (req.url).path;

5661 var pathOffset = 0;

5662 var index;

5663 var subPart;

5664 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5665 pathOffset += 15;

5666 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

5667 pathOffset += 7;

5668 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5669 pathOffset = path.length;

5670 unittest.expect(subPart, unittest.equals("$arg_id"));

5671

5672 var query = (req.url).query;

5673 var queryOffset = 0;

5674 var queryMap = {};

5675 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5676 parseBool(n) {

5677 if (n == "true") return true;

5678 if (n == "false") return false;

5679 if (n == null) return null;

5680 throw new core.ArgumentError("Invalid boolean: $n");

5681 }

5682 if (query.length > 0) {

5683 for (var part in query.split("&")) {

5684 var keyvalue = part.split("=");

5685 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5686 }

5687 }

5688

5689

5690 var h = {

5691 "content-type" : "application/json; charset=utf-8",

5692 };

5693 var resp = "";

5694 return new async.Future.value(common_test.stringResponse(200, h, resp));

5695 }), true);

5696 res.delete(arg_id).then(unittest.expectAsync((_) {}));

5697 });

5698

5699 unittest.test("method--get", () {

5700

5701 var mock = new common_test.HttpServerMock();

5702 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

5703 var arg_id = "foo";

5704 var arg_version = "foo";

5705 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5706 var path = (req.url).path;

5707 var pathOffset = 0;

5708 var index;

5709 var subPart;

5710 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5711 pathOffset += 15;

5712 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

5713 pathOffset += 7;

5714 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5715 pathOffset = path.length;

5716 unittest.expect(subPart, unittest.equals("$arg_id"));

5717

5718 var query = (req.url).query;

5719 var queryOffset = 0;

5720 var queryMap = {};

5721 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5722 parseBool(n) {

5723 if (n == "true") return true;

5724 if (n == "false") return false;

5725 if (n == null) return null;

5726 throw new core.ArgumentError("Invalid boolean: $n");

5727 }

5728 if (query.length > 0) {

5729 for (var part in query.split("&")) {

5730 var keyvalue = part.split("=");

5731 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5732 }

5733 }

5734 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

5735

5736

5737 var h = {

5738 "content-type" : "application/json; charset=utf-8",

5739 };

5740 var resp = convert.JSON.encode(buildTable());

5741 return new async.Future.value(common_test.stringResponse(200, h, resp));

5742 }), true);

5743 res.get(arg_id, version: arg_version).then(unittest.expectAsync(((api.Tabl e response) {

5744 checkTable(response);

5745 })));

5746 });

5747

5748 unittest.test("method--list", () {

5749

5750 var mock = new common_test.HttpServerMock();

5751 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

5752 var arg_bbox = "foo";

5753 var arg_createdAfter = core.DateTime.parse("2002-02-27T14:01:02");

5754 var arg_createdBefore = core.DateTime.parse("2002-02-27T14:01:02");

5755 var arg_creatorEmail = "foo";

5756 var arg_maxResults = 42;

5757 var arg_modifiedAfter = core.DateTime.parse("2002-02-27T14:01:02");

5758 var arg_modifiedBefore = core.DateTime.parse("2002-02-27T14:01:02");

5759 var arg_pageToken = "foo";

5760 var arg_processingStatus = "foo";

5761 var arg_projectId = "foo";

5762 var arg_role = "foo";

5763 var arg_search = "foo";

5764 var arg_tags = "foo";

5765 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5766 var path = (req.url).path;

5767 var pathOffset = 0;

5768 var index;

5769 var subPart;

5770 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5771 pathOffset += 15;

5772 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("tables"));

5773 pathOffset += 6;

5774

5775 var query = (req.url).query;

5776 var queryOffset = 0;

5777 var queryMap = {};

5778 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5779 parseBool(n) {

5780 if (n == "true") return true;

5781 if (n == "false") return false;

5782 if (n == null) return null;

5783 throw new core.ArgumentError("Invalid boolean: $n");

5784 }

5785 if (query.length > 0) {

5786 for (var part in query.split("&")) {

5787 var keyvalue = part.split("=");

5788 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5789 }

5790 }

5791 unittest.expect(queryMap["bbox"].first, unittest.equals(arg_bbox));

5792 unittest.expect(core.DateTime.parse(queryMap["createdAfter"].first), uni ttest.equals(arg_createdAfter));

5793 unittest.expect(core.DateTime.parse(queryMap["createdBefore"].first), un ittest.equals(arg_createdBefore));

5794 unittest.expect(queryMap["creatorEmail"].first, unittest.equals(arg_crea torEmail));

5795 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5796 unittest.expect(core.DateTime.parse(queryMap["modifiedAfter"].first), un ittest.equals(arg_modifiedAfter));

5797 unittest.expect(core.DateTime.parse(queryMap["modifiedBefore"].first), u nittest.equals(arg_modifiedBefore));

5798 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5799 unittest.expect(queryMap["processingStatus"].first, unittest.equals(arg_ processingStatus));

5800 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

5801 unittest.expect(queryMap["role"].first, unittest.equals(arg_role));

5802 unittest.expect(queryMap["search"].first, unittest.equals(arg_search));

5803 unittest.expect(queryMap["tags"].first, unittest.equals(arg_tags));

5804

5805

5806 var h = {

5807 "content-type" : "application/json; charset=utf-8",

5808 };

5809 var resp = convert.JSON.encode(buildTablesListResponse());

5810 return new async.Future.value(common_test.stringResponse(200, h, resp));

5811 }), true);

5812 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) {

5813 checkTablesListResponse(response);

5814 })));

5815 });

5816

5817 unittest.test("method--patch", () {

5818

5819 var mock = new common_test.HttpServerMock();

5820 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

5821 var arg_request = buildTable();

5822 var arg_id = "foo";

5823 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5824 var obj = new api.Table.fromJson(json);

5825 checkTable(obj);

5826

5827 var path = (req.url).path;

5828 var pathOffset = 0;

5829 var index;

5830 var subPart;

5831 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5832 pathOffset += 15;

5833 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

5834 pathOffset += 7;

5835 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5836 pathOffset = path.length;

5837 unittest.expect(subPart, unittest.equals("$arg_id"));

5838

5839 var query = (req.url).query;

5840 var queryOffset = 0;

5841 var queryMap = {};

5842 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5843 parseBool(n) {

5844 if (n == "true") return true;

5845 if (n == "false") return false;

5846 if (n == null) return null;

5847 throw new core.ArgumentError("Invalid boolean: $n");

5848 }

5849 if (query.length > 0) {

5850 for (var part in query.split("&")) {

5851 var keyvalue = part.split("=");

5852 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5853 }

5854 }

5855

5856

5857 var h = {

5858 "content-type" : "application/json; charset=utf-8",

5859 };

5860 var resp = "";

5861 return new async.Future.value(common_test.stringResponse(200, h, resp));

5862 }), true);

5863 res.patch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

5864 });

5865

5866 unittest.test("method--process", () {

5867

5868 var mock = new common_test.HttpServerMock();

5869 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

5870 var arg_id = "foo";

5871 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5872 var path = (req.url).path;

5873 var pathOffset = 0;

5874 var index;

5875 var subPart;

5876 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5877 pathOffset += 15;

5878 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

5879 pathOffset += 7;

5880 index = path.indexOf("/process", pathOffset);

5881 unittest.expect(index >= 0, unittest.isTrue);

5882 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5883 pathOffset = index;

5884 unittest.expect(subPart, unittest.equals("$arg_id"));

5885 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/process"));

5886 pathOffset += 8;

5887

5888 var query = (req.url).query;

5889 var queryOffset = 0;

5890 var queryMap = {};

5891 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5892 parseBool(n) {

5893 if (n == "true") return true;

5894 if (n == "false") return false;

5895 if (n == null) return null;

5896 throw new core.ArgumentError("Invalid boolean: $n");

5897 }

5898 if (query.length > 0) {

5899 for (var part in query.split("&")) {

5900 var keyvalue = part.split("=");

5901 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5902 }

5903 }

5904

5905

5906 var h = {

5907 "content-type" : "application/json; charset=utf-8",

5908 };

5909 var resp = convert.JSON.encode(buildProcessResponse());

5910 return new async.Future.value(common_test.stringResponse(200, h, resp));

5911 }), true);

5912 res.process(arg_id).then(unittest.expectAsync(((api.ProcessResponse respon se) {

5913 checkProcessResponse(response);

5914 })));

5915 });

5916

5917 unittest.test("method--upload", () {

5918

5919 var mock = new common_test.HttpServerMock();

5920 api.TablesResourceApi res = new api.MapsengineApi(mock).tables;

5921 var arg_request = buildTable();

5922 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5923 var obj = new api.Table.fromJson(json);

5924 checkTable(obj);

5925

5926 var path = (req.url).path;

5927 var pathOffset = 0;

5928 var index;

5929 var subPart;

5930 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5931 pathOffset += 15;

5932 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("tables/upload"));

5933 pathOffset += 13;

5934

5935 var query = (req.url).query;

5936 var queryOffset = 0;

5937 var queryMap = {};

5938 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5939 parseBool(n) {

5940 if (n == "true") return true;

5941 if (n == "false") return false;

5942 if (n == null) return null;

5943 throw new core.ArgumentError("Invalid boolean: $n");

5944 }

5945 if (query.length > 0) {

5946 for (var part in query.split("&")) {

5947 var keyvalue = part.split("=");

5948 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5949 }

5950 }

5951

5952

5953 var h = {

5954 "content-type" : "application/json; charset=utf-8",

5955 };

5956 var resp = convert.JSON.encode(buildTable());

5957 return new async.Future.value(common_test.stringResponse(200, h, resp));

5958 }), true);

5959 res.upload(arg_request).then(unittest.expectAsync(((api.Table response) {

5960 checkTable(response);

5961 })));

5962 });

5963

5964 });

5965

5966

5967 unittest.group("resource-TablesFeaturesResourceApi", () {

5968 unittest.test("method--batchDelete", () {

5969

5970 var mock = new common_test.HttpServerMock();

5971 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

5972 var arg_request = buildFeaturesBatchDeleteRequest();

5973 var arg_id = "foo";

5974 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5975 var obj = new api.FeaturesBatchDeleteRequest.fromJson(json);

5976 checkFeaturesBatchDeleteRequest(obj);

5977

5978 var path = (req.url).path;

5979 var pathOffset = 0;

5980 var index;

5981 var subPart;

5982 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

5983 pathOffset += 15;

5984 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

5985 pathOffset += 7;

5986 index = path.indexOf("/features/batchDelete", pathOffset);

5987 unittest.expect(index >= 0, unittest.isTrue);

5988 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5989 pathOffset = index;

5990 unittest.expect(subPart, unittest.equals("$arg_id"));

5991 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/features/batchDelete"));

5992 pathOffset += 21;

5993

5994 var query = (req.url).query;

5995 var queryOffset = 0;

5996 var queryMap = {};

5997 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5998 parseBool(n) {

5999 if (n == "true") return true;

6000 if (n == "false") return false;

6001 if (n == null) return null;

6002 throw new core.ArgumentError("Invalid boolean: $n");

6003 }

6004 if (query.length > 0) {

6005 for (var part in query.split("&")) {

6006 var keyvalue = part.split("=");

6007 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6008 }

6009 }

6010

6011

6012 var h = {

6013 "content-type" : "application/json; charset=utf-8",

6014 };

6015 var resp = "";

6016 return new async.Future.value(common_test.stringResponse(200, h, resp));

6017 }), true);

6018 res.batchDelete(arg_request, arg_id).then(unittest.expectAsync((_) {}));

6019 });

6020

6021 unittest.test("method--batchInsert", () {

6022

6023 var mock = new common_test.HttpServerMock();

6024 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

6025 var arg_request = buildFeaturesBatchInsertRequest();

6026 var arg_id = "foo";

6027 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6028 var obj = new api.FeaturesBatchInsertRequest.fromJson(json);

6029 checkFeaturesBatchInsertRequest(obj);

6030

6031 var path = (req.url).path;

6032 var pathOffset = 0;

6033 var index;

6034 var subPart;

6035 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

6036 pathOffset += 15;

6037 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

6038 pathOffset += 7;

6039 index = path.indexOf("/features/batchInsert", pathOffset);

6040 unittest.expect(index >= 0, unittest.isTrue);

6041 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6042 pathOffset = index;

6043 unittest.expect(subPart, unittest.equals("$arg_id"));

6044 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/features/batchInsert"));

6045 pathOffset += 21;

6046

6047 var query = (req.url).query;

6048 var queryOffset = 0;

6049 var queryMap = {};

6050 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6051 parseBool(n) {

6052 if (n == "true") return true;

6053 if (n == "false") return false;

6054 if (n == null) return null;

6055 throw new core.ArgumentError("Invalid boolean: $n");

6056 }

6057 if (query.length > 0) {

6058 for (var part in query.split("&")) {

6059 var keyvalue = part.split("=");

6060 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6061 }

6062 }

6063

6064

6065 var h = {

6066 "content-type" : "application/json; charset=utf-8",

6067 };

6068 var resp = "";

6069 return new async.Future.value(common_test.stringResponse(200, h, resp));

6070 }), true);

6071 res.batchInsert(arg_request, arg_id).then(unittest.expectAsync((_) {}));

6072 });

6073

6074 unittest.test("method--batchPatch", () {

6075

6076 var mock = new common_test.HttpServerMock();

6077 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

6078 var arg_request = buildFeaturesBatchPatchRequest();

6079 var arg_id = "foo";

6080 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6081 var obj = new api.FeaturesBatchPatchRequest.fromJson(json);

6082 checkFeaturesBatchPatchRequest(obj);

6083

6084 var path = (req.url).path;

6085 var pathOffset = 0;

6086 var index;

6087 var subPart;

6088 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

6089 pathOffset += 15;

6090 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

6091 pathOffset += 7;

6092 index = path.indexOf("/features/batchPatch", pathOffset);

6093 unittest.expect(index >= 0, unittest.isTrue);

6094 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6095 pathOffset = index;

6096 unittest.expect(subPart, unittest.equals("$arg_id"));

6097 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/features/batchPatch"));

6098 pathOffset += 20;

6099

6100 var query = (req.url).query;

6101 var queryOffset = 0;

6102 var queryMap = {};

6103 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6104 parseBool(n) {

6105 if (n == "true") return true;

6106 if (n == "false") return false;

6107 if (n == null) return null;

6108 throw new core.ArgumentError("Invalid boolean: $n");

6109 }

6110 if (query.length > 0) {

6111 for (var part in query.split("&")) {

6112 var keyvalue = part.split("=");

6113 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6114 }

6115 }

6116

6117

6118 var h = {

6119 "content-type" : "application/json; charset=utf-8",

6120 };

6121 var resp = "";

6122 return new async.Future.value(common_test.stringResponse(200, h, resp));

6123 }), true);

6124 res.batchPatch(arg_request, arg_id).then(unittest.expectAsync((_) {}));

6125 });

6126

6127 unittest.test("method--get", () {

6128

6129 var mock = new common_test.HttpServerMock();

6130 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

6131 var arg_tableId = "foo";

6132 var arg_id = "foo";

6133 var arg_select = "foo";

6134 var arg_version = "foo";

6135 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6136 var path = (req.url).path;

6137 var pathOffset = 0;

6138 var index;

6139 var subPart;

6140 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

6141 pathOffset += 15;

6142 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

6143 pathOffset += 7;

6144 index = path.indexOf("/features/", pathOffset);

6145 unittest.expect(index >= 0, unittest.isTrue);

6146 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6147 pathOffset = index;

6148 unittest.expect(subPart, unittest.equals("$arg_tableId"));

6149 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/features/"));

6150 pathOffset += 10;

6151 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6152 pathOffset = path.length;

6153 unittest.expect(subPart, unittest.equals("$arg_id"));

6154

6155 var query = (req.url).query;

6156 var queryOffset = 0;

6157 var queryMap = {};

6158 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6159 parseBool(n) {

6160 if (n == "true") return true;

6161 if (n == "false") return false;

6162 if (n == null) return null;

6163 throw new core.ArgumentError("Invalid boolean: $n");

6164 }

6165 if (query.length > 0) {

6166 for (var part in query.split("&")) {

6167 var keyvalue = part.split("=");

6168 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6169 }

6170 }

6171 unittest.expect(queryMap["select"].first, unittest.equals(arg_select));

6172 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

6173

6174

6175 var h = {

6176 "content-type" : "application/json; charset=utf-8",

6177 };

6178 var resp = convert.JSON.encode(buildFeature());

6179 return new async.Future.value(common_test.stringResponse(200, h, resp));

6180 }), true);

6181 res.get(arg_tableId, arg_id, select: arg_select, version: arg_version).the n(unittest.expectAsync(((api.Feature response) {

6182 checkFeature(response);

6183 })));

6184 });

6185

6186 unittest.test("method--list", () {

6187

6188 var mock = new common_test.HttpServerMock();

6189 api.TablesFeaturesResourceApi res = new api.MapsengineApi(mock).tables.fea tures;

6190 var arg_id = "foo";

6191 var arg_include = "foo";

6192 var arg_intersects = "foo";

6193 var arg_limit = 42;

6194 var arg_maxResults = 42;

6195 var arg_orderBy = "foo";

6196 var arg_pageToken = "foo";

6197 var arg_select = "foo";

6198 var arg_version = "foo";

6199 var arg_where = "foo";

6200 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6201 var path = (req.url).path;

6202 var pathOffset = 0;

6203 var index;

6204 var subPart;

6205 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

6206 pathOffset += 15;

6207 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

6208 pathOffset += 7;

6209 index = path.indexOf("/features", pathOffset);

6210 unittest.expect(index >= 0, unittest.isTrue);

6211 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6212 pathOffset = index;

6213 unittest.expect(subPart, unittest.equals("$arg_id"));

6214 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/features"));

6215 pathOffset += 9;

6216

6217 var query = (req.url).query;

6218 var queryOffset = 0;

6219 var queryMap = {};

6220 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6221 parseBool(n) {

6222 if (n == "true") return true;

6223 if (n == "false") return false;

6224 if (n == null) return null;

6225 throw new core.ArgumentError("Invalid boolean: $n");

6226 }

6227 if (query.length > 0) {

6228 for (var part in query.split("&")) {

6229 var keyvalue = part.split("=");

6230 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6231 }

6232 }

6233 unittest.expect(queryMap["include"].first, unittest.equals(arg_include)) ;

6234 unittest.expect(queryMap["intersects"].first, unittest.equals(arg_inters ects));

6235 unittest.expect(core.int.parse(queryMap["limit"].first), unittest.equals (arg_limit));

6236 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6237 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

6238 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6239 unittest.expect(queryMap["select"].first, unittest.equals(arg_select));

6240 unittest.expect(queryMap["version"].first, unittest.equals(arg_version)) ;

6241 unittest.expect(queryMap["where"].first, unittest.equals(arg_where));

6242

6243

6244 var h = {

6245 "content-type" : "application/json; charset=utf-8",

6246 };

6247 var resp = convert.JSON.encode(buildFeaturesListResponse());

6248 return new async.Future.value(common_test.stringResponse(200, h, resp));

6249 }), true);

6250 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) {

6251 checkFeaturesListResponse(response);

6252 })));

6253 });

6254

6255 });

6256

6257

6258 unittest.group("resource-TablesFilesResourceApi", () {

6259 unittest.test("method--insert", () {

6260 // TODO: Implement tests for media upload;

6261 // TODO: Implement tests for media download;

6262

6263 var mock = new common_test.HttpServerMock();

6264 api.TablesFilesResourceApi res = new api.MapsengineApi(mock).tables.files;

6265 var arg_id = "foo";

6266 var arg_filename = "foo";

6267 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6268 var path = (req.url).path;

6269 var pathOffset = 0;

6270 var index;

6271 var subPart;

6272 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

6273 pathOffset += 15;

6274 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

6275 pathOffset += 7;

6276 index = path.indexOf("/files", pathOffset);

6277 unittest.expect(index >= 0, unittest.isTrue);

6278 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6279 pathOffset = index;

6280 unittest.expect(subPart, unittest.equals("$arg_id"));

6281 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/files"));

6282 pathOffset += 6;

6283

6284 var query = (req.url).query;

6285 var queryOffset = 0;

6286 var queryMap = {};

6287 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6288 parseBool(n) {

6289 if (n == "true") return true;

6290 if (n == "false") return false;

6291 if (n == null) return null;

6292 throw new core.ArgumentError("Invalid boolean: $n");

6293 }

6294 if (query.length > 0) {

6295 for (var part in query.split("&")) {

6296 var keyvalue = part.split("=");

6297 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6298 }

6299 }

6300 unittest.expect(queryMap["filename"].first, unittest.equals(arg_filename ));

6301

6302

6303 var h = {

6304 "content-type" : "application/json; charset=utf-8",

6305 };

6306 var resp = "";

6307 return new async.Future.value(common_test.stringResponse(200, h, resp));

6308 }), true);

6309 res.insert(arg_id, arg_filename).then(unittest.expectAsync((_) {}));

6310 });

6311

6312 });

6313

6314

6315 unittest.group("resource-TablesParentsResourceApi", () {

6316 unittest.test("method--list", () {

6317

6318 var mock = new common_test.HttpServerMock();

6319 api.TablesParentsResourceApi res = new api.MapsengineApi(mock).tables.pare nts;

6320 var arg_id = "foo";

6321 var arg_maxResults = 42;

6322 var arg_pageToken = "foo";

6323 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6324 var path = (req.url).path;

6325 var pathOffset = 0;

6326 var index;

6327 var subPart;

6328 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/mapsengine/v1/"));

6329 pathOffset += 15;

6330 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("tables/"));

6331 pathOffset += 7;

6332 index = path.indexOf("/parents", pathOffset);

6333 unittest.expect(index >= 0, unittest.isTrue);

6334 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6335 pathOffset = index;

6336 unittest.expect(subPart, unittest.equals("$arg_id"));

6337 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/parents"));

6338 pathOffset += 8;

6339

6340 var query = (req.url).query;

6341 var queryOffset = 0;

6342 var queryMap = {};

6343 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6344 parseBool(n) {

6345 if (n == "true") return true;

6346 if (n == "false") return false;

6347 if (n == null) return null;

6348 throw new core.ArgumentError("Invalid boolean: $n");

6349 }

6350 if (query.length > 0) {

6351 for (var part in query.split("&")) {

6352 var keyvalue = part.split("=");

6353 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6354 }

6355 }

6356 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6357 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6358

6359

6360 var h = {

6361 "content-type" : "application/json; charset=utf-8",

6362 };

6363 var resp = convert.JSON.encode(buildParentsListResponse());

6364 return new async.Future.value(common_test.stringResponse(200, h, resp));

6365 }), true);

6366 res.list(arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken).the n(unittest.expectAsync(((api.ParentsListResponse response) {

6367 checkParentsListResponse(response);

6368 })));

6369 });

6370

6371 });

6372

6373

6374 }

6375

OLD	NEW

« no previous file with comments | « generated/googleapis/test/licensing/v1_test.dart ('k') | generated/googleapis/test/mapsengine/v1_test.dart » ('j') | no next file with comments »