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

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

16

17

18

19 core.int buildCounterBucket = 0;

20 buildBucket() {

21 var o = new api.Bucket();

22 buildCounterBucket++;

23 if (buildCounterBucket < 3) {

24 o.color = "foo";

25 o.icon = "foo";

26 o.max = 42.0;

27 o.min = 42.0;

28 o.opacity = 42.0;

29 o.weight = 42;

30 }

31 buildCounterBucket--;

32 return o;

33 }

34

35 checkBucket(api.Bucket o) {

36 buildCounterBucket++;

37 if (buildCounterBucket < 3) {

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

39 unittest.expect(o.icon, unittest.equals('foo'));

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

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

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

43 unittest.expect(o.weight, unittest.equals(42));

44 }

45 buildCounterBucket--;

46 }

47

48 core.int buildCounterColumnBaseColumn = 0;

49 buildColumnBaseColumn() {

50 var o = new api.ColumnBaseColumn();

51 buildCounterColumnBaseColumn++;

52 if (buildCounterColumnBaseColumn < 3) {

53 o.columnId = 42;

54 o.tableIndex = 42;

55 }

56 buildCounterColumnBaseColumn--;

57 return o;

58 }

59

60 checkColumnBaseColumn(api.ColumnBaseColumn o) {

61 buildCounterColumnBaseColumn++;

62 if (buildCounterColumnBaseColumn < 3) {

63 unittest.expect(o.columnId, unittest.equals(42));

64 unittest.expect(o.tableIndex, unittest.equals(42));

65 }

66 buildCounterColumnBaseColumn--;

67 }

68

69 core.int buildCounterColumn = 0;

70 buildColumn() {

71 var o = new api.Column();

72 buildCounterColumn++;

73 if (buildCounterColumn < 3) {

74 o.baseColumn = buildColumnBaseColumn();

75 o.columnId = 42;

76 o.description = "foo";

77 o.graphPredicate = "foo";

78 o.kind = "foo";

79 o.name = "foo";

80 o.type = "foo";

81 }

82 buildCounterColumn--;

83 return o;

84 }

85

86 checkColumn(api.Column o) {

87 buildCounterColumn++;

88 if (buildCounterColumn < 3) {

89 checkColumnBaseColumn(o.baseColumn);

90 unittest.expect(o.columnId, unittest.equals(42));

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

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

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

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

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

96 }

97 buildCounterColumn--;

98 }

99

100 buildUnnamed990() {

101 var o = new core.List<api.Column>();

102 o.add(buildColumn());

103 o.add(buildColumn());

104 return o;

105 }

106

107 checkUnnamed990(core.List<api.Column> o) {

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

109 checkColumn(o[0]);

110 checkColumn(o[1]);

111 }

112

113 core.int buildCounterColumnList = 0;

114 buildColumnList() {

115 var o = new api.ColumnList();

116 buildCounterColumnList++;

117 if (buildCounterColumnList < 3) {

118 o.items = buildUnnamed990();

119 o.kind = "foo";

120 o.nextPageToken = "foo";

121 o.totalItems = 42;

122 }

123 buildCounterColumnList--;

124 return o;

125 }

126

127 checkColumnList(api.ColumnList o) {

128 buildCounterColumnList++;

129 if (buildCounterColumnList < 3) {

130 checkUnnamed990(o.items);

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

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

133 unittest.expect(o.totalItems, unittest.equals(42));

134 }

135 buildCounterColumnList--;

136 }

137

138 buildUnnamed991() {

139 var o = new core.List<core.Object>();

140 o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});

141 o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});

142 return o;

143 }

144

145 checkUnnamed991(core.List<core.Object> o) {

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

147 var casted1 = (o[0]) as core.Map; unittest.expect(casted1, unittest.hasLength( 3)); unittest.expect(casted1["list"], unittest.equals([1, 2, 3])); unittest.expe ct(casted1["bool"], unittest.equals(true)); unittest.expect(casted1["string"], u nittest.equals('foo'));

148 var casted2 = (o[1]) as core.Map; unittest.expect(casted2, unittest.hasLength( 3)); unittest.expect(casted2["list"], unittest.equals([1, 2, 3])); unittest.expe ct(casted2["bool"], unittest.equals(true)); unittest.expect(casted2["string"], u nittest.equals('foo'));

149 }

150

151 core.int buildCounterGeometry = 0;

152 buildGeometry() {

153 var o = new api.Geometry();

154 buildCounterGeometry++;

155 if (buildCounterGeometry < 3) {

156 o.geometries = buildUnnamed991();

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

158 o.type = "foo";

159 }

160 buildCounterGeometry--;

161 return o;

162 }

163

164 checkGeometry(api.Geometry o) {

165 buildCounterGeometry++;

166 if (buildCounterGeometry < 3) {

167 checkUnnamed991(o.geometries);

168 var casted3 = (o.geometry) as core.Map; unittest.expect(casted3, unittest.ha sLength(3)); unittest.expect(casted3["list"], unittest.equals([1, 2, 3])); unitt est.expect(casted3["bool"], unittest.equals(true)); unittest.expect(casted3["str ing"], unittest.equals('foo'));

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

170 }

171 buildCounterGeometry--;

172 }

173

174 core.int buildCounterImport = 0;

175 buildImport() {

176 var o = new api.Import();

177 buildCounterImport++;

178 if (buildCounterImport < 3) {

179 o.kind = "foo";

180 o.numRowsReceived = "foo";

181 }

182 buildCounterImport--;

183 return o;

184 }

185

186 checkImport(api.Import o) {

187 buildCounterImport++;

188 if (buildCounterImport < 3) {

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

190 unittest.expect(o.numRowsReceived, unittest.equals('foo'));

191 }

192 buildCounterImport--;

193 }

194

195 buildUnnamed992() {

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

197 o.add(42.0);

198 o.add(42.0);

199 return o;

200 }

201

202 checkUnnamed992(core.List<core.double> o) {

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

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

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

206 }

207

208 buildUnnamed993() {

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

210 o.add(buildUnnamed992());

211 o.add(buildUnnamed992());

212 return o;

213 }

214

215 checkUnnamed993(core.List<core.List<core.double>> o) {

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

217 checkUnnamed992(o[0]);

218 checkUnnamed992(o[1]);

219 }

220

221 core.int buildCounterLine = 0;

222 buildLine() {

223 var o = new api.Line();

224 buildCounterLine++;

225 if (buildCounterLine < 3) {

226 o.coordinates = buildUnnamed993();

227 o.type = "foo";

228 }

229 buildCounterLine--;

230 return o;

231 }

232

233 checkLine(api.Line o) {

234 buildCounterLine++;

235 if (buildCounterLine < 3) {

236 checkUnnamed993(o.coordinates);

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

238 }

239 buildCounterLine--;

240 }

241

242 core.int buildCounterLineStyle = 0;

243 buildLineStyle() {

244 var o = new api.LineStyle();

245 buildCounterLineStyle++;

246 if (buildCounterLineStyle < 3) {

247 o.strokeColor = "foo";

248 o.strokeColorStyler = buildStyleFunction();

249 o.strokeOpacity = 42.0;

250 o.strokeWeight = 42;

251 o.strokeWeightStyler = buildStyleFunction();

252 }

253 buildCounterLineStyle--;

254 return o;

255 }

256

257 checkLineStyle(api.LineStyle o) {

258 buildCounterLineStyle++;

259 if (buildCounterLineStyle < 3) {

260 unittest.expect(o.strokeColor, unittest.equals('foo'));

261 checkStyleFunction(o.strokeColorStyler);

262 unittest.expect(o.strokeOpacity, unittest.equals(42.0));

263 unittest.expect(o.strokeWeight, unittest.equals(42));

264 checkStyleFunction(o.strokeWeightStyler);

265 }

266 buildCounterLineStyle--;

267 }

268

269 buildUnnamed994() {

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

271 o.add(42.0);

272 o.add(42.0);

273 return o;

274 }

275

276 checkUnnamed994(core.List<core.double> o) {

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

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

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

280 }

281

282 core.int buildCounterPoint = 0;

283 buildPoint() {

284 var o = new api.Point();

285 buildCounterPoint++;

286 if (buildCounterPoint < 3) {

287 o.coordinates = buildUnnamed994();

288 o.type = "foo";

289 }

290 buildCounterPoint--;

291 return o;

292 }

293

294 checkPoint(api.Point o) {

295 buildCounterPoint++;

296 if (buildCounterPoint < 3) {

297 checkUnnamed994(o.coordinates);

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

299 }

300 buildCounterPoint--;

301 }

302

303 core.int buildCounterPointStyle = 0;

304 buildPointStyle() {

305 var o = new api.PointStyle();

306 buildCounterPointStyle++;

307 if (buildCounterPointStyle < 3) {

308 o.iconName = "foo";

309 o.iconStyler = buildStyleFunction();

310 }

311 buildCounterPointStyle--;

312 return o;

313 }

314

315 checkPointStyle(api.PointStyle o) {

316 buildCounterPointStyle++;

317 if (buildCounterPointStyle < 3) {

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

319 checkStyleFunction(o.iconStyler);

320 }

321 buildCounterPointStyle--;

322 }

323

324 buildUnnamed995() {

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

326 o.add(42.0);

327 o.add(42.0);

328 return o;

329 }

330

331 checkUnnamed995(core.List<core.double> o) {

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

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

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

335 }

336

337 buildUnnamed996() {

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

339 o.add(buildUnnamed995());

340 o.add(buildUnnamed995());

341 return o;

342 }

343

344 checkUnnamed996(core.List<core.List<core.double>> o) {

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

346 checkUnnamed995(o[0]);

347 checkUnnamed995(o[1]);

348 }

349

350 buildUnnamed997() {

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

352 o.add(buildUnnamed996());

353 o.add(buildUnnamed996());

354 return o;

355 }

356

357 checkUnnamed997(core.List<core.List<core.List<core.double>>> o) {

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

359 checkUnnamed996(o[0]);

360 checkUnnamed996(o[1]);

361 }

362

363 core.int buildCounterPolygon = 0;

364 buildPolygon() {

365 var o = new api.Polygon();

366 buildCounterPolygon++;

367 if (buildCounterPolygon < 3) {

368 o.coordinates = buildUnnamed997();

369 o.type = "foo";

370 }

371 buildCounterPolygon--;

372 return o;

373 }

374

375 checkPolygon(api.Polygon o) {

376 buildCounterPolygon++;

377 if (buildCounterPolygon < 3) {

378 checkUnnamed997(o.coordinates);

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

380 }

381 buildCounterPolygon--;

382 }

383

384 core.int buildCounterPolygonStyle = 0;

385 buildPolygonStyle() {

386 var o = new api.PolygonStyle();

387 buildCounterPolygonStyle++;

388 if (buildCounterPolygonStyle < 3) {

389 o.fillColor = "foo";

390 o.fillColorStyler = buildStyleFunction();

391 o.fillOpacity = 42.0;

392 o.strokeColor = "foo";

393 o.strokeColorStyler = buildStyleFunction();

394 o.strokeOpacity = 42.0;

395 o.strokeWeight = 42;

396 o.strokeWeightStyler = buildStyleFunction();

397 }

398 buildCounterPolygonStyle--;

399 return o;

400 }

401

402 checkPolygonStyle(api.PolygonStyle o) {

403 buildCounterPolygonStyle++;

404 if (buildCounterPolygonStyle < 3) {

405 unittest.expect(o.fillColor, unittest.equals('foo'));

406 checkStyleFunction(o.fillColorStyler);

407 unittest.expect(o.fillOpacity, unittest.equals(42.0));

408 unittest.expect(o.strokeColor, unittest.equals('foo'));

409 checkStyleFunction(o.strokeColorStyler);

410 unittest.expect(o.strokeOpacity, unittest.equals(42.0));

411 unittest.expect(o.strokeWeight, unittest.equals(42));

412 checkStyleFunction(o.strokeWeightStyler);

413 }

414 buildCounterPolygonStyle--;

415 }

416

417 buildUnnamed998() {

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

419 o.add("foo");

420 o.add("foo");

421 return o;

422 }

423

424 checkUnnamed998(core.List<core.String> o) {

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

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

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

428 }

429

430 buildUnnamed999() {

431 var o = new core.List<core.Object>();

432 o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});

433 o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});

434 return o;

435 }

436

437 checkUnnamed999(core.List<core.Object> o) {

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

439 var casted4 = (o[0]) as core.Map; unittest.expect(casted4, unittest.hasLength( 3)); unittest.expect(casted4["list"], unittest.equals([1, 2, 3])); unittest.expe ct(casted4["bool"], unittest.equals(true)); unittest.expect(casted4["string"], u nittest.equals('foo'));

440 var casted5 = (o[1]) as core.Map; unittest.expect(casted5, unittest.hasLength( 3)); unittest.expect(casted5["list"], unittest.equals([1, 2, 3])); unittest.expe ct(casted5["bool"], unittest.equals(true)); unittest.expect(casted5["string"], u nittest.equals('foo'));

441 }

442

443 buildUnnamed1000() {

444 var o = new core.List<core.List<core.Object>>();

445 o.add(buildUnnamed999());

446 o.add(buildUnnamed999());

447 return o;

448 }

449

450 checkUnnamed1000(core.List<core.List<core.Object>> o) {

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

452 checkUnnamed999(o[0]);

453 checkUnnamed999(o[1]);

454 }

455

456 core.int buildCounterSqlresponse = 0;

457 buildSqlresponse() {

458 var o = new api.Sqlresponse();

459 buildCounterSqlresponse++;

460 if (buildCounterSqlresponse < 3) {

461 o.columns = buildUnnamed998();

462 o.kind = "foo";

463 o.rows = buildUnnamed1000();

464 }

465 buildCounterSqlresponse--;

466 return o;

467 }

468

469 checkSqlresponse(api.Sqlresponse o) {

470 buildCounterSqlresponse++;

471 if (buildCounterSqlresponse < 3) {

472 checkUnnamed998(o.columns);

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

474 checkUnnamed1000(o.rows);

475 }

476 buildCounterSqlresponse--;

477 }

478

479 buildUnnamed1001() {

480 var o = new core.List<api.Bucket>();

481 o.add(buildBucket());

482 o.add(buildBucket());

483 return o;

484 }

485

486 checkUnnamed1001(core.List<api.Bucket> o) {

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

488 checkBucket(o[0]);

489 checkBucket(o[1]);

490 }

491

492 core.int buildCounterStyleFunctionGradientColors = 0;

493 buildStyleFunctionGradientColors() {

494 var o = new api.StyleFunctionGradientColors();

495 buildCounterStyleFunctionGradientColors++;

496 if (buildCounterStyleFunctionGradientColors < 3) {

497 o.color = "foo";

498 o.opacity = 42.0;

499 }

500 buildCounterStyleFunctionGradientColors--;

501 return o;

502 }

503

504 checkStyleFunctionGradientColors(api.StyleFunctionGradientColors o) {

505 buildCounterStyleFunctionGradientColors++;

506 if (buildCounterStyleFunctionGradientColors < 3) {

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

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

509 }

510 buildCounterStyleFunctionGradientColors--;

511 }

512

513 buildUnnamed1002() {

514 var o = new core.List<api.StyleFunctionGradientColors>();

515 o.add(buildStyleFunctionGradientColors());

516 o.add(buildStyleFunctionGradientColors());

517 return o;

518 }

519

520 checkUnnamed1002(core.List<api.StyleFunctionGradientColors> o) {

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

522 checkStyleFunctionGradientColors(o[0]);

523 checkStyleFunctionGradientColors(o[1]);

524 }

525

526 core.int buildCounterStyleFunctionGradient = 0;

527 buildStyleFunctionGradient() {

528 var o = new api.StyleFunctionGradient();

529 buildCounterStyleFunctionGradient++;

530 if (buildCounterStyleFunctionGradient < 3) {

531 o.colors = buildUnnamed1002();

532 o.max = 42.0;

533 o.min = 42.0;

534 }

535 buildCounterStyleFunctionGradient--;

536 return o;

537 }

538

539 checkStyleFunctionGradient(api.StyleFunctionGradient o) {

540 buildCounterStyleFunctionGradient++;

541 if (buildCounterStyleFunctionGradient < 3) {

542 checkUnnamed1002(o.colors);

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

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

545 }

546 buildCounterStyleFunctionGradient--;

547 }

548

549 core.int buildCounterStyleFunction = 0;

550 buildStyleFunction() {

551 var o = new api.StyleFunction();

552 buildCounterStyleFunction++;

553 if (buildCounterStyleFunction < 3) {

554 o.buckets = buildUnnamed1001();

555 o.columnName = "foo";

556 o.gradient = buildStyleFunctionGradient();

557 o.kind = "foo";

558 }

559 buildCounterStyleFunction--;

560 return o;

561 }

562

563 checkStyleFunction(api.StyleFunction o) {

564 buildCounterStyleFunction++;

565 if (buildCounterStyleFunction < 3) {

566 checkUnnamed1001(o.buckets);

567 unittest.expect(o.columnName, unittest.equals('foo'));

568 checkStyleFunctionGradient(o.gradient);

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

570 }

571 buildCounterStyleFunction--;

572 }

573

574 core.int buildCounterStyleSetting = 0;

575 buildStyleSetting() {

576 var o = new api.StyleSetting();

577 buildCounterStyleSetting++;

578 if (buildCounterStyleSetting < 3) {

579 o.kind = "foo";

580 o.markerOptions = buildPointStyle();

581 o.name = "foo";

582 o.polygonOptions = buildPolygonStyle();

583 o.polylineOptions = buildLineStyle();

584 o.styleId = 42;

585 o.tableId = "foo";

586 }

587 buildCounterStyleSetting--;

588 return o;

589 }

590

591 checkStyleSetting(api.StyleSetting o) {

592 buildCounterStyleSetting++;

593 if (buildCounterStyleSetting < 3) {

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

595 checkPointStyle(o.markerOptions);

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

597 checkPolygonStyle(o.polygonOptions);

598 checkLineStyle(o.polylineOptions);

599 unittest.expect(o.styleId, unittest.equals(42));

600 unittest.expect(o.tableId, unittest.equals('foo'));

601 }

602 buildCounterStyleSetting--;

603 }

604

605 buildUnnamed1003() {

606 var o = new core.List<api.StyleSetting>();

607 o.add(buildStyleSetting());

608 o.add(buildStyleSetting());

609 return o;

610 }

611

612 checkUnnamed1003(core.List<api.StyleSetting> o) {

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

614 checkStyleSetting(o[0]);

615 checkStyleSetting(o[1]);

616 }

617

618 core.int buildCounterStyleSettingList = 0;

619 buildStyleSettingList() {

620 var o = new api.StyleSettingList();

621 buildCounterStyleSettingList++;

622 if (buildCounterStyleSettingList < 3) {

623 o.items = buildUnnamed1003();

624 o.kind = "foo";

625 o.nextPageToken = "foo";

626 o.totalItems = 42;

627 }

628 buildCounterStyleSettingList--;

629 return o;

630 }

631

632 checkStyleSettingList(api.StyleSettingList o) {

633 buildCounterStyleSettingList++;

634 if (buildCounterStyleSettingList < 3) {

635 checkUnnamed1003(o.items);

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

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

638 unittest.expect(o.totalItems, unittest.equals(42));

639 }

640 buildCounterStyleSettingList--;

641 }

642

643 buildUnnamed1004() {

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

645 o.add("foo");

646 o.add("foo");

647 return o;

648 }

649

650 checkUnnamed1004(core.List<core.String> o) {

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

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

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

654 }

655

656 buildUnnamed1005() {

657 var o = new core.List<api.Column>();

658 o.add(buildColumn());

659 o.add(buildColumn());

660 return o;

661 }

662

663 checkUnnamed1005(core.List<api.Column> o) {

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

665 checkColumn(o[0]);

666 checkColumn(o[1]);

667 }

668

669 core.int buildCounterTable = 0;

670 buildTable() {

671 var o = new api.Table();

672 buildCounterTable++;

673 if (buildCounterTable < 3) {

674 o.attribution = "foo";

675 o.attributionLink = "foo";

676 o.baseTableIds = buildUnnamed1004();

677 o.columns = buildUnnamed1005();

678 o.description = "foo";

679 o.isExportable = true;

680 o.kind = "foo";

681 o.name = "foo";

682 o.sql = "foo";

683 o.tableId = "foo";

684 }

685 buildCounterTable--;

686 return o;

687 }

688

689 checkTable(api.Table o) {

690 buildCounterTable++;

691 if (buildCounterTable < 3) {

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

693 unittest.expect(o.attributionLink, unittest.equals('foo'));

694 checkUnnamed1004(o.baseTableIds);

695 checkUnnamed1005(o.columns);

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

697 unittest.expect(o.isExportable, unittest.isTrue);

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

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

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

701 unittest.expect(o.tableId, unittest.equals('foo'));

702 }

703 buildCounterTable--;

704 }

705

706 buildUnnamed1006() {

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

708 o.add(buildTable());

709 o.add(buildTable());

710 return o;

711 }

712

713 checkUnnamed1006(core.List<api.Table> o) {

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

715 checkTable(o[0]);

716 checkTable(o[1]);

717 }

718

719 core.int buildCounterTableList = 0;

720 buildTableList() {

721 var o = new api.TableList();

722 buildCounterTableList++;

723 if (buildCounterTableList < 3) {

724 o.items = buildUnnamed1006();

725 o.kind = "foo";

726 o.nextPageToken = "foo";

727 }

728 buildCounterTableList--;

729 return o;

730 }

731

732 checkTableList(api.TableList o) {

733 buildCounterTableList++;

734 if (buildCounterTableList < 3) {

735 checkUnnamed1006(o.items);

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

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

738 }

739 buildCounterTableList--;

740 }

741

742 core.int buildCounterTask = 0;

743 buildTask() {

744 var o = new api.Task();

745 buildCounterTask++;

746 if (buildCounterTask < 3) {

747 o.kind = "foo";

748 o.progress = "foo";

749 o.started = true;

750 o.taskId = "foo";

751 o.type = "foo";

752 }

753 buildCounterTask--;

754 return o;

755 }

756

757 checkTask(api.Task o) {

758 buildCounterTask++;

759 if (buildCounterTask < 3) {

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

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

762 unittest.expect(o.started, unittest.isTrue);

763 unittest.expect(o.taskId, unittest.equals('foo'));

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

765 }

766 buildCounterTask--;

767 }

768

769 buildUnnamed1007() {

770 var o = new core.List<api.Task>();

771 o.add(buildTask());

772 o.add(buildTask());

773 return o;

774 }

775

776 checkUnnamed1007(core.List<api.Task> o) {

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

778 checkTask(o[0]);

779 checkTask(o[1]);

780 }

781

782 core.int buildCounterTaskList = 0;

783 buildTaskList() {

784 var o = new api.TaskList();

785 buildCounterTaskList++;

786 if (buildCounterTaskList < 3) {

787 o.items = buildUnnamed1007();

788 o.kind = "foo";

789 o.nextPageToken = "foo";

790 o.totalItems = 42;

791 }

792 buildCounterTaskList--;

793 return o;

794 }

795

796 checkTaskList(api.TaskList o) {

797 buildCounterTaskList++;

798 if (buildCounterTaskList < 3) {

799 checkUnnamed1007(o.items);

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

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

802 unittest.expect(o.totalItems, unittest.equals(42));

803 }

804 buildCounterTaskList--;

805 }

806

807 buildUnnamed1008() {

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

809 o.add("foo");

810 o.add("foo");

811 return o;

812 }

813

814 checkUnnamed1008(core.List<core.String> o) {

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

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

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

818 }

819

820 core.int buildCounterTemplate = 0;

821 buildTemplate() {

822 var o = new api.Template();

823 buildCounterTemplate++;

824 if (buildCounterTemplate < 3) {

825 o.automaticColumnNames = buildUnnamed1008();

826 o.body = "foo";

827 o.kind = "foo";

828 o.name = "foo";

829 o.tableId = "foo";

830 o.templateId = 42;

831 }

832 buildCounterTemplate--;

833 return o;

834 }

835

836 checkTemplate(api.Template o) {

837 buildCounterTemplate++;

838 if (buildCounterTemplate < 3) {

839 checkUnnamed1008(o.automaticColumnNames);

840 unittest.expect(o.body, unittest.equals('foo'));

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

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

843 unittest.expect(o.tableId, unittest.equals('foo'));

844 unittest.expect(o.templateId, unittest.equals(42));

845 }

846 buildCounterTemplate--;

847 }

848

849 buildUnnamed1009() {

850 var o = new core.List<api.Template>();

851 o.add(buildTemplate());

852 o.add(buildTemplate());

853 return o;

854 }

855

856 checkUnnamed1009(core.List<api.Template> o) {

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

858 checkTemplate(o[0]);

859 checkTemplate(o[1]);

860 }

861

862 core.int buildCounterTemplateList = 0;

863 buildTemplateList() {

864 var o = new api.TemplateList();

865 buildCounterTemplateList++;

866 if (buildCounterTemplateList < 3) {

867 o.items = buildUnnamed1009();

868 o.kind = "foo";

869 o.nextPageToken = "foo";

870 o.totalItems = 42;

871 }

872 buildCounterTemplateList--;

873 return o;

874 }

875

876 checkTemplateList(api.TemplateList o) {

877 buildCounterTemplateList++;

878 if (buildCounterTemplateList < 3) {

879 checkUnnamed1009(o.items);

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

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

882 unittest.expect(o.totalItems, unittest.equals(42));

883 }

884 buildCounterTemplateList--;

885 }

886

887

888 main() {

889 unittest.group("obj-schema-Bucket", () {

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

891 var o = buildBucket();

892 var od = new api.Bucket.fromJson(o.toJson());

893 checkBucket(od);

894 });

895 });

896

897

898 unittest.group("obj-schema-ColumnBaseColumn", () {

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

900 var o = buildColumnBaseColumn();

901 var od = new api.ColumnBaseColumn.fromJson(o.toJson());

902 checkColumnBaseColumn(od);

903 });

904 });

905

906

907 unittest.group("obj-schema-Column", () {

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

909 var o = buildColumn();

910 var od = new api.Column.fromJson(o.toJson());

911 checkColumn(od);

912 });

913 });

914

915

916 unittest.group("obj-schema-ColumnList", () {

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

918 var o = buildColumnList();

919 var od = new api.ColumnList.fromJson(o.toJson());

920 checkColumnList(od);

921 });

922 });

923

924

925 unittest.group("obj-schema-Geometry", () {

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

927 var o = buildGeometry();

928 var od = new api.Geometry.fromJson(o.toJson());

929 checkGeometry(od);

930 });

931 });

932

933

934 unittest.group("obj-schema-Import", () {

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

936 var o = buildImport();

937 var od = new api.Import.fromJson(o.toJson());

938 checkImport(od);

939 });

940 });

941

942

943 unittest.group("obj-schema-Line", () {

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

945 var o = buildLine();

946 var od = new api.Line.fromJson(o.toJson());

947 checkLine(od);

948 });

949 });

950

951

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

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

954 var o = buildLineStyle();

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

956 checkLineStyle(od);

957 });

958 });

959

960

961 unittest.group("obj-schema-Point", () {

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

963 var o = buildPoint();

964 var od = new api.Point.fromJson(o.toJson());

965 checkPoint(od);

966 });

967 });

968

969

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

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

972 var o = buildPointStyle();

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

974 checkPointStyle(od);

975 });

976 });

977

978

979 unittest.group("obj-schema-Polygon", () {

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

981 var o = buildPolygon();

982 var od = new api.Polygon.fromJson(o.toJson());

983 checkPolygon(od);

984 });

985 });

986

987

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

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

990 var o = buildPolygonStyle();

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

992 checkPolygonStyle(od);

993 });

994 });

995

996

997 unittest.group("obj-schema-Sqlresponse", () {

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

999 var o = buildSqlresponse();

1000 var od = new api.Sqlresponse.fromJson(o.toJson());

1001 checkSqlresponse(od);

1002 });

1003 });

1004

1005

1006 unittest.group("obj-schema-StyleFunctionGradientColors", () {

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

1008 var o = buildStyleFunctionGradientColors();

1009 var od = new api.StyleFunctionGradientColors.fromJson(o.toJson());

1010 checkStyleFunctionGradientColors(od);

1011 });

1012 });

1013

1014

1015 unittest.group("obj-schema-StyleFunctionGradient", () {

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

1017 var o = buildStyleFunctionGradient();

1018 var od = new api.StyleFunctionGradient.fromJson(o.toJson());

1019 checkStyleFunctionGradient(od);

1020 });

1021 });

1022

1023

1024 unittest.group("obj-schema-StyleFunction", () {

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

1026 var o = buildStyleFunction();

1027 var od = new api.StyleFunction.fromJson(o.toJson());

1028 checkStyleFunction(od);

1029 });

1030 });

1031

1032

1033 unittest.group("obj-schema-StyleSetting", () {

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

1035 var o = buildStyleSetting();

1036 var od = new api.StyleSetting.fromJson(o.toJson());

1037 checkStyleSetting(od);

1038 });

1039 });

1040

1041

1042 unittest.group("obj-schema-StyleSettingList", () {

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

1044 var o = buildStyleSettingList();

1045 var od = new api.StyleSettingList.fromJson(o.toJson());

1046 checkStyleSettingList(od);

1047 });

1048 });

1049

1050

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

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

1053 var o = buildTable();

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

1055 checkTable(od);

1056 });

1057 });

1058

1059

1060 unittest.group("obj-schema-TableList", () {

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

1062 var o = buildTableList();

1063 var od = new api.TableList.fromJson(o.toJson());

1064 checkTableList(od);

1065 });

1066 });

1067

1068

1069 unittest.group("obj-schema-Task", () {

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

1071 var o = buildTask();

1072 var od = new api.Task.fromJson(o.toJson());

1073 checkTask(od);

1074 });

1075 });

1076

1077

1078 unittest.group("obj-schema-TaskList", () {

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

1080 var o = buildTaskList();

1081 var od = new api.TaskList.fromJson(o.toJson());

1082 checkTaskList(od);

1083 });

1084 });

1085

1086

1087 unittest.group("obj-schema-Template", () {

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

1089 var o = buildTemplate();

1090 var od = new api.Template.fromJson(o.toJson());

1091 checkTemplate(od);

1092 });

1093 });

1094

1095

1096 unittest.group("obj-schema-TemplateList", () {

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

1098 var o = buildTemplateList();

1099 var od = new api.TemplateList.fromJson(o.toJson());

1100 checkTemplateList(od);

1101 });

1102 });

1103

1104

1105 unittest.group("resource-ColumnResourceApi", () {

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

1107

1108 var mock = new common_test.HttpServerMock();

1109 api.ColumnResourceApi res = new api.FusiontablesApi(mock).column;

1110 var arg_tableId = "foo";

1111 var arg_columnId = "foo";

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

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

1114 var pathOffset = 0;

1115 var index;

1116 var subPart;

1117 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1118 pathOffset += 17;

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

1120 pathOffset += 7;

1121 index = path.indexOf("/columns/", pathOffset);

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

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

1124 pathOffset = index;

1125 unittest.expect(subPart, unittest.equals("$arg_tableId"));

1126 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/columns/"));

1127 pathOffset += 9;

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

1129 pathOffset = path.length;

1130 unittest.expect(subPart, unittest.equals("$arg_columnId"));

1131

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

1133 var queryOffset = 0;

1134 var queryMap = {};

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

1136 parseBool(n) {

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

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

1139 if (n == null) return null;

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

1141 }

1142 if (query.length > 0) {

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

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

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

1146 }

1147 }

1148

1149

1150 var h = {

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

1152 };

1153 var resp = "";

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

1155 }), true);

1156 res.delete(arg_tableId, arg_columnId).then(unittest.expectAsync((_) {}));

1157 });

1158

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

1160

1161 var mock = new common_test.HttpServerMock();

1162 api.ColumnResourceApi res = new api.FusiontablesApi(mock).column;

1163 var arg_tableId = "foo";

1164 var arg_columnId = "foo";

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

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

1167 var pathOffset = 0;

1168 var index;

1169 var subPart;

1170 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1171 pathOffset += 17;

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

1173 pathOffset += 7;

1174 index = path.indexOf("/columns/", pathOffset);

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

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

1177 pathOffset = index;

1178 unittest.expect(subPart, unittest.equals("$arg_tableId"));

1179 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/columns/"));

1180 pathOffset += 9;

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

1182 pathOffset = path.length;

1183 unittest.expect(subPart, unittest.equals("$arg_columnId"));

1184

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

1186 var queryOffset = 0;

1187 var queryMap = {};

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

1189 parseBool(n) {

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

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

1192 if (n == null) return null;

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

1194 }

1195 if (query.length > 0) {

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

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

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

1199 }

1200 }

1201

1202

1203 var h = {

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

1205 };

1206 var resp = convert.JSON.encode(buildColumn());

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

1208 }), true);

1209 res.get(arg_tableId, arg_columnId).then(unittest.expectAsync(((api.Column response) {

1210 checkColumn(response);

1211 })));

1212 });

1213

1214 unittest.test("method--insert", () {

1215

1216 var mock = new common_test.HttpServerMock();

1217 api.ColumnResourceApi res = new api.FusiontablesApi(mock).column;

1218 var arg_request = buildColumn();

1219 var arg_tableId = "foo";

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

1221 var obj = new api.Column.fromJson(json);

1222 checkColumn(obj);

1223

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

1225 var pathOffset = 0;

1226 var index;

1227 var subPart;

1228 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1229 pathOffset += 17;

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

1231 pathOffset += 7;

1232 index = path.indexOf("/columns", pathOffset);

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

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

1235 pathOffset = index;

1236 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

1238 pathOffset += 8;

1239

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

1241 var queryOffset = 0;

1242 var queryMap = {};

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

1244 parseBool(n) {

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

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

1247 if (n == null) return null;

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

1249 }

1250 if (query.length > 0) {

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

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

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

1254 }

1255 }

1256

1257

1258 var h = {

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

1260 };

1261 var resp = convert.JSON.encode(buildColumn());

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

1263 }), true);

1264 res.insert(arg_request, arg_tableId).then(unittest.expectAsync(((api.Colum n response) {

1265 checkColumn(response);

1266 })));

1267 });

1268

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

1270

1271 var mock = new common_test.HttpServerMock();

1272 api.ColumnResourceApi res = new api.FusiontablesApi(mock).column;

1273 var arg_tableId = "foo";

1274 var arg_maxResults = 42;

1275 var arg_pageToken = "foo";

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

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

1278 var pathOffset = 0;

1279 var index;

1280 var subPart;

1281 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1282 pathOffset += 17;

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

1284 pathOffset += 7;

1285 index = path.indexOf("/columns", pathOffset);

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

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

1288 pathOffset = index;

1289 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

1291 pathOffset += 8;

1292

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

1294 var queryOffset = 0;

1295 var queryMap = {};

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

1297 parseBool(n) {

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

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

1300 if (n == null) return null;

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

1302 }

1303 if (query.length > 0) {

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

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

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

1307 }

1308 }

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

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

1311

1312

1313 var h = {

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

1315 };

1316 var resp = convert.JSON.encode(buildColumnList());

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

1318 }), true);

1319 res.list(arg_tableId, maxResults: arg_maxResults, pageToken: arg_pageToken ).then(unittest.expectAsync(((api.ColumnList response) {

1320 checkColumnList(response);

1321 })));

1322 });

1323

1324 unittest.test("method--patch", () {

1325

1326 var mock = new common_test.HttpServerMock();

1327 api.ColumnResourceApi res = new api.FusiontablesApi(mock).column;

1328 var arg_request = buildColumn();

1329 var arg_tableId = "foo";

1330 var arg_columnId = "foo";

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

1332 var obj = new api.Column.fromJson(json);

1333 checkColumn(obj);

1334

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

1336 var pathOffset = 0;

1337 var index;

1338 var subPart;

1339 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1340 pathOffset += 17;

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

1342 pathOffset += 7;

1343 index = path.indexOf("/columns/", pathOffset);

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

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

1346 pathOffset = index;

1347 unittest.expect(subPart, unittest.equals("$arg_tableId"));

1348 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/columns/"));

1349 pathOffset += 9;

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

1351 pathOffset = path.length;

1352 unittest.expect(subPart, unittest.equals("$arg_columnId"));

1353

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

1355 var queryOffset = 0;

1356 var queryMap = {};

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

1358 parseBool(n) {

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

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

1361 if (n == null) return null;

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

1363 }

1364 if (query.length > 0) {

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

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

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

1368 }

1369 }

1370

1371

1372 var h = {

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

1374 };

1375 var resp = convert.JSON.encode(buildColumn());

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

1377 }), true);

1378 res.patch(arg_request, arg_tableId, arg_columnId).then(unittest.expectAsyn c(((api.Column response) {

1379 checkColumn(response);

1380 })));

1381 });

1382

1383 unittest.test("method--update", () {

1384

1385 var mock = new common_test.HttpServerMock();

1386 api.ColumnResourceApi res = new api.FusiontablesApi(mock).column;

1387 var arg_request = buildColumn();

1388 var arg_tableId = "foo";

1389 var arg_columnId = "foo";

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

1391 var obj = new api.Column.fromJson(json);

1392 checkColumn(obj);

1393

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

1395 var pathOffset = 0;

1396 var index;

1397 var subPart;

1398 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1399 pathOffset += 17;

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

1401 pathOffset += 7;

1402 index = path.indexOf("/columns/", pathOffset);

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

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

1405 pathOffset = index;

1406 unittest.expect(subPart, unittest.equals("$arg_tableId"));

1407 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/columns/"));

1408 pathOffset += 9;

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

1410 pathOffset = path.length;

1411 unittest.expect(subPart, unittest.equals("$arg_columnId"));

1412

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

1414 var queryOffset = 0;

1415 var queryMap = {};

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

1417 parseBool(n) {

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

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

1420 if (n == null) return null;

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

1422 }

1423 if (query.length > 0) {

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

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

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

1427 }

1428 }

1429

1430

1431 var h = {

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

1433 };

1434 var resp = convert.JSON.encode(buildColumn());

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

1436 }), true);

1437 res.update(arg_request, arg_tableId, arg_columnId).then(unittest.expectAsy nc(((api.Column response) {

1438 checkColumn(response);

1439 })));

1440 });

1441

1442 });

1443

1444

1445 unittest.group("resource-QueryResourceApi", () {

1446 unittest.test("method--sql", () {

1447 // TODO: Implement tests for media upload;

1448 // TODO: Implement tests for media download;

1449

1450 var mock = new common_test.HttpServerMock();

1451 api.QueryResourceApi res = new api.FusiontablesApi(mock).query;

1452 var arg_sql_1 = "foo";

1453 var arg_hdrs = true;

1454 var arg_typed = true;

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

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

1457 var pathOffset = 0;

1458 var index;

1459 var subPart;

1460 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1461 pathOffset += 17;

1462 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("query"));

1463 pathOffset += 5;

1464

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

1466 var queryOffset = 0;

1467 var queryMap = {};

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

1469 parseBool(n) {

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

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

1472 if (n == null) return null;

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

1474 }

1475 if (query.length > 0) {

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

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

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

1479 }

1480 }

1481 unittest.expect(queryMap["sql"].first, unittest.equals(arg_sql_1));

1482 unittest.expect(queryMap["hdrs"].first, unittest.equals("$arg_hdrs"));

1483 unittest.expect(queryMap["typed"].first, unittest.equals("$arg_typed"));

1484

1485

1486 var h = {

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

1488 };

1489 var resp = convert.JSON.encode(buildSqlresponse());

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

1491 }), true);

1492 res.sql(arg_sql_1, hdrs: arg_hdrs, typed: arg_typed).then(unittest.expectA sync(((api.Sqlresponse response) {

1493 checkSqlresponse(response);

1494 })));

1495 });

1496

1497 unittest.test("method--sqlGet", () {

1498 // TODO: Implement tests for media upload;

1499 // TODO: Implement tests for media download;

1500

1501 var mock = new common_test.HttpServerMock();

1502 api.QueryResourceApi res = new api.FusiontablesApi(mock).query;

1503 var arg_sql_1 = "foo";

1504 var arg_hdrs = true;

1505 var arg_typed = true;

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

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

1508 var pathOffset = 0;

1509 var index;

1510 var subPart;

1511 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1512 pathOffset += 17;

1513 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("query"));

1514 pathOffset += 5;

1515

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

1517 var queryOffset = 0;

1518 var queryMap = {};

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

1520 parseBool(n) {

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

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

1523 if (n == null) return null;

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

1525 }

1526 if (query.length > 0) {

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

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

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

1530 }

1531 }

1532 unittest.expect(queryMap["sql"].first, unittest.equals(arg_sql_1));

1533 unittest.expect(queryMap["hdrs"].first, unittest.equals("$arg_hdrs"));

1534 unittest.expect(queryMap["typed"].first, unittest.equals("$arg_typed"));

1535

1536

1537 var h = {

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

1539 };

1540 var resp = convert.JSON.encode(buildSqlresponse());

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

1542 }), true);

1543 res.sqlGet(arg_sql_1, hdrs: arg_hdrs, typed: arg_typed).then(unittest.expe ctAsync(((api.Sqlresponse response) {

1544 checkSqlresponse(response);

1545 })));

1546 });

1547

1548 });

1549

1550

1551 unittest.group("resource-StyleResourceApi", () {

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

1553

1554 var mock = new common_test.HttpServerMock();

1555 api.StyleResourceApi res = new api.FusiontablesApi(mock).style;

1556 var arg_tableId = "foo";

1557 var arg_styleId = 42;

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

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

1560 var pathOffset = 0;

1561 var index;

1562 var subPart;

1563 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1564 pathOffset += 17;

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

1566 pathOffset += 7;

1567 index = path.indexOf("/styles/", pathOffset);

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

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

1570 pathOffset = index;

1571 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

1573 pathOffset += 8;

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

1575 pathOffset = path.length;

1576 unittest.expect(subPart, unittest.equals("$arg_styleId"));

1577

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

1579 var queryOffset = 0;

1580 var queryMap = {};

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

1582 parseBool(n) {

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

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

1585 if (n == null) return null;

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

1587 }

1588 if (query.length > 0) {

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

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

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

1592 }

1593 }

1594

1595

1596 var h = {

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

1598 };

1599 var resp = "";

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

1601 }), true);

1602 res.delete(arg_tableId, arg_styleId).then(unittest.expectAsync((_) {}));

1603 });

1604

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

1606

1607 var mock = new common_test.HttpServerMock();

1608 api.StyleResourceApi res = new api.FusiontablesApi(mock).style;

1609 var arg_tableId = "foo";

1610 var arg_styleId = 42;

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

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

1613 var pathOffset = 0;

1614 var index;

1615 var subPart;

1616 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1617 pathOffset += 17;

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

1619 pathOffset += 7;

1620 index = path.indexOf("/styles/", pathOffset);

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

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

1623 pathOffset = index;

1624 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

1626 pathOffset += 8;

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

1628 pathOffset = path.length;

1629 unittest.expect(subPart, unittest.equals("$arg_styleId"));

1630

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

1632 var queryOffset = 0;

1633 var queryMap = {};

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

1635 parseBool(n) {

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

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

1638 if (n == null) return null;

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

1640 }

1641 if (query.length > 0) {

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

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

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

1645 }

1646 }

1647

1648

1649 var h = {

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

1651 };

1652 var resp = convert.JSON.encode(buildStyleSetting());

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

1654 }), true);

1655 res.get(arg_tableId, arg_styleId).then(unittest.expectAsync(((api.StyleSet ting response) {

1656 checkStyleSetting(response);

1657 })));

1658 });

1659

1660 unittest.test("method--insert", () {

1661

1662 var mock = new common_test.HttpServerMock();

1663 api.StyleResourceApi res = new api.FusiontablesApi(mock).style;

1664 var arg_request = buildStyleSetting();

1665 var arg_tableId = "foo";

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

1667 var obj = new api.StyleSetting.fromJson(json);

1668 checkStyleSetting(obj);

1669

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

1671 var pathOffset = 0;

1672 var index;

1673 var subPart;

1674 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1675 pathOffset += 17;

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

1677 pathOffset += 7;

1678 index = path.indexOf("/styles", pathOffset);

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

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

1681 pathOffset = index;

1682 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

1684 pathOffset += 7;

1685

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

1687 var queryOffset = 0;

1688 var queryMap = {};

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

1690 parseBool(n) {

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

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

1693 if (n == null) return null;

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

1695 }

1696 if (query.length > 0) {

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

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

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

1700 }

1701 }

1702

1703

1704 var h = {

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

1706 };

1707 var resp = convert.JSON.encode(buildStyleSetting());

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

1709 }), true);

1710 res.insert(arg_request, arg_tableId).then(unittest.expectAsync(((api.Style Setting response) {

1711 checkStyleSetting(response);

1712 })));

1713 });

1714

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

1716

1717 var mock = new common_test.HttpServerMock();

1718 api.StyleResourceApi res = new api.FusiontablesApi(mock).style;

1719 var arg_tableId = "foo";

1720 var arg_maxResults = 42;

1721 var arg_pageToken = "foo";

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

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

1724 var pathOffset = 0;

1725 var index;

1726 var subPart;

1727 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1728 pathOffset += 17;

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

1730 pathOffset += 7;

1731 index = path.indexOf("/styles", pathOffset);

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

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

1734 pathOffset = index;

1735 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

1737 pathOffset += 7;

1738

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

1740 var queryOffset = 0;

1741 var queryMap = {};

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

1743 parseBool(n) {

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

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

1746 if (n == null) return null;

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

1748 }

1749 if (query.length > 0) {

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

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

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

1753 }

1754 }

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

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

1757

1758

1759 var h = {

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

1761 };

1762 var resp = convert.JSON.encode(buildStyleSettingList());

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

1764 }), true);

1765 res.list(arg_tableId, maxResults: arg_maxResults, pageToken: arg_pageToken ).then(unittest.expectAsync(((api.StyleSettingList response) {

1766 checkStyleSettingList(response);

1767 })));

1768 });

1769

1770 unittest.test("method--patch", () {

1771

1772 var mock = new common_test.HttpServerMock();

1773 api.StyleResourceApi res = new api.FusiontablesApi(mock).style;

1774 var arg_request = buildStyleSetting();

1775 var arg_tableId = "foo";

1776 var arg_styleId = 42;

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

1778 var obj = new api.StyleSetting.fromJson(json);

1779 checkStyleSetting(obj);

1780

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

1782 var pathOffset = 0;

1783 var index;

1784 var subPart;

1785 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1786 pathOffset += 17;

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

1788 pathOffset += 7;

1789 index = path.indexOf("/styles/", pathOffset);

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

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

1792 pathOffset = index;

1793 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

1795 pathOffset += 8;

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

1797 pathOffset = path.length;

1798 unittest.expect(subPart, unittest.equals("$arg_styleId"));

1799

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

1801 var queryOffset = 0;

1802 var queryMap = {};

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

1804 parseBool(n) {

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

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

1807 if (n == null) return null;

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

1809 }

1810 if (query.length > 0) {

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

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

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

1814 }

1815 }

1816

1817

1818 var h = {

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

1820 };

1821 var resp = convert.JSON.encode(buildStyleSetting());

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

1823 }), true);

1824 res.patch(arg_request, arg_tableId, arg_styleId).then(unittest.expectAsync (((api.StyleSetting response) {

1825 checkStyleSetting(response);

1826 })));

1827 });

1828

1829 unittest.test("method--update", () {

1830

1831 var mock = new common_test.HttpServerMock();

1832 api.StyleResourceApi res = new api.FusiontablesApi(mock).style;

1833 var arg_request = buildStyleSetting();

1834 var arg_tableId = "foo";

1835 var arg_styleId = 42;

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

1837 var obj = new api.StyleSetting.fromJson(json);

1838 checkStyleSetting(obj);

1839

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

1841 var pathOffset = 0;

1842 var index;

1843 var subPart;

1844 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1845 pathOffset += 17;

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

1847 pathOffset += 7;

1848 index = path.indexOf("/styles/", pathOffset);

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

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

1851 pathOffset = index;

1852 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

1854 pathOffset += 8;

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

1856 pathOffset = path.length;

1857 unittest.expect(subPart, unittest.equals("$arg_styleId"));

1858

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

1860 var queryOffset = 0;

1861 var queryMap = {};

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

1863 parseBool(n) {

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

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

1866 if (n == null) return null;

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

1868 }

1869 if (query.length > 0) {

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

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

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

1873 }

1874 }

1875

1876

1877 var h = {

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

1879 };

1880 var resp = convert.JSON.encode(buildStyleSetting());

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

1882 }), true);

1883 res.update(arg_request, arg_tableId, arg_styleId).then(unittest.expectAsyn c(((api.StyleSetting response) {

1884 checkStyleSetting(response);

1885 })));

1886 });

1887

1888 });

1889

1890

1891 unittest.group("resource-TableResourceApi", () {

1892 unittest.test("method--copy", () {

1893

1894 var mock = new common_test.HttpServerMock();

1895 api.TableResourceApi res = new api.FusiontablesApi(mock).table;

1896 var arg_tableId = "foo";

1897 var arg_copyPresentation = true;

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

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

1900 var pathOffset = 0;

1901 var index;

1902 var subPart;

1903 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1904 pathOffset += 17;

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

1906 pathOffset += 7;

1907 index = path.indexOf("/copy", pathOffset);

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

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

1910 pathOffset = index;

1911 unittest.expect(subPart, unittest.equals("$arg_tableId"));

1912 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("/copy"));

1913 pathOffset += 5;

1914

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

1916 var queryOffset = 0;

1917 var queryMap = {};

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

1919 parseBool(n) {

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

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

1922 if (n == null) return null;

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

1924 }

1925 if (query.length > 0) {

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

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

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

1929 }

1930 }

1931 unittest.expect(queryMap["copyPresentation"].first, unittest.equals("$ar g_copyPresentation"));

1932

1933

1934 var h = {

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

1936 };

1937 var resp = convert.JSON.encode(buildTable());

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

1939 }), true);

1940 res.copy(arg_tableId, copyPresentation: arg_copyPresentation).then(unittes t.expectAsync(((api.Table response) {

1941 checkTable(response);

1942 })));

1943 });

1944

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

1946

1947 var mock = new common_test.HttpServerMock();

1948 api.TableResourceApi res = new api.FusiontablesApi(mock).table;

1949 var arg_tableId = "foo";

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

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

1952 var pathOffset = 0;

1953 var index;

1954 var subPart;

1955 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

1956 pathOffset += 17;

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

1958 pathOffset += 7;

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

1960 pathOffset = path.length;

1961 unittest.expect(subPart, unittest.equals("$arg_tableId"));

1962

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

1964 var queryOffset = 0;

1965 var queryMap = {};

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

1967 parseBool(n) {

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

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

1970 if (n == null) return null;

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

1972 }

1973 if (query.length > 0) {

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

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

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

1977 }

1978 }

1979

1980

1981 var h = {

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

1983 };

1984 var resp = "";

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

1986 }), true);

1987 res.delete(arg_tableId).then(unittest.expectAsync((_) {}));

1988 });

1989

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

1991

1992 var mock = new common_test.HttpServerMock();

1993 api.TableResourceApi res = new api.FusiontablesApi(mock).table;

1994 var arg_tableId = "foo";

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

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

1997 var pathOffset = 0;

1998 var index;

1999 var subPart;

2000 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2001 pathOffset += 17;

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

2003 pathOffset += 7;

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

2005 pathOffset = path.length;

2006 unittest.expect(subPart, unittest.equals("$arg_tableId"));

2007

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

2009 var queryOffset = 0;

2010 var queryMap = {};

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

2012 parseBool(n) {

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

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

2015 if (n == null) return null;

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

2017 }

2018 if (query.length > 0) {

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

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

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

2022 }

2023 }

2024

2025

2026 var h = {

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

2028 };

2029 var resp = convert.JSON.encode(buildTable());

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

2031 }), true);

2032 res.get(arg_tableId).then(unittest.expectAsync(((api.Table response) {

2033 checkTable(response);

2034 })));

2035 });

2036

2037 unittest.test("method--importRows", () {

2038 // TODO: Implement tests for media upload;

2039 // TODO: Implement tests for media download;

2040

2041 var mock = new common_test.HttpServerMock();

2042 api.TableResourceApi res = new api.FusiontablesApi(mock).table;

2043 var arg_tableId = "foo";

2044 var arg_delimiter = "foo";

2045 var arg_encoding = "foo";

2046 var arg_endLine = 42;

2047 var arg_isStrict = true;

2048 var arg_startLine = 42;

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

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

2051 var pathOffset = 0;

2052 var index;

2053 var subPart;

2054 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2055 pathOffset += 17;

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

2057 pathOffset += 7;

2058 index = path.indexOf("/import", pathOffset);

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

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

2061 pathOffset = index;

2062 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

2064 pathOffset += 7;

2065

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

2067 var queryOffset = 0;

2068 var queryMap = {};

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

2070 parseBool(n) {

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

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

2073 if (n == null) return null;

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

2075 }

2076 if (query.length > 0) {

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

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

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

2080 }

2081 }

2082 unittest.expect(queryMap["delimiter"].first, unittest.equals(arg_delimit er));

2083 unittest.expect(queryMap["encoding"].first, unittest.equals(arg_encoding ));

2084 unittest.expect(core.int.parse(queryMap["endLine"].first), unittest.equa ls(arg_endLine));

2085 unittest.expect(queryMap["isStrict"].first, unittest.equals("$arg_isStri ct"));

2086 unittest.expect(core.int.parse(queryMap["startLine"].first), unittest.eq uals(arg_startLine));

2087

2088

2089 var h = {

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

2091 };

2092 var resp = convert.JSON.encode(buildImport());

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

2094 }), true);

2095 res.importRows(arg_tableId, delimiter: arg_delimiter, encoding: arg_encodi ng, endLine: arg_endLine, isStrict: arg_isStrict, startLine: arg_startLine).then (unittest.expectAsync(((api.Import response) {

2096 checkImport(response);

2097 })));

2098 });

2099

2100 unittest.test("method--importTable", () {

2101 // TODO: Implement tests for media upload;

2102 // TODO: Implement tests for media download;

2103

2104 var mock = new common_test.HttpServerMock();

2105 api.TableResourceApi res = new api.FusiontablesApi(mock).table;

2106 var arg_name = "foo";

2107 var arg_delimiter = "foo";

2108 var arg_encoding = "foo";

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

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

2111 var pathOffset = 0;

2112 var index;

2113 var subPart;

2114 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2115 pathOffset += 17;

2116 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("tables/import"));

2117 pathOffset += 13;

2118

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

2120 var queryOffset = 0;

2121 var queryMap = {};

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

2123 parseBool(n) {

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

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

2126 if (n == null) return null;

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

2128 }

2129 if (query.length > 0) {

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

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

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

2133 }

2134 }

2135 unittest.expect(queryMap["name"].first, unittest.equals(arg_name));

2136 unittest.expect(queryMap["delimiter"].first, unittest.equals(arg_delimit er));

2137 unittest.expect(queryMap["encoding"].first, unittest.equals(arg_encoding ));

2138

2139

2140 var h = {

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

2142 };

2143 var resp = convert.JSON.encode(buildTable());

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

2145 }), true);

2146 res.importTable(arg_name, delimiter: arg_delimiter, encoding: arg_encoding ).then(unittest.expectAsync(((api.Table response) {

2147 checkTable(response);

2148 })));

2149 });

2150

2151 unittest.test("method--insert", () {

2152

2153 var mock = new common_test.HttpServerMock();

2154 api.TableResourceApi res = new api.FusiontablesApi(mock).table;

2155 var arg_request = buildTable();

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

2157 var obj = new api.Table.fromJson(json);

2158 checkTable(obj);

2159

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

2161 var pathOffset = 0;

2162 var index;

2163 var subPart;

2164 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2165 pathOffset += 17;

2166 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("tables"));

2167 pathOffset += 6;

2168

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

2170 var queryOffset = 0;

2171 var queryMap = {};

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

2173 parseBool(n) {

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

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

2176 if (n == null) return null;

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

2178 }

2179 if (query.length > 0) {

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

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

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

2183 }

2184 }

2185

2186

2187 var h = {

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

2189 };

2190 var resp = convert.JSON.encode(buildTable());

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

2192 }), true);

2193 res.insert(arg_request).then(unittest.expectAsync(((api.Table response) {

2194 checkTable(response);

2195 })));

2196 });

2197

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

2199

2200 var mock = new common_test.HttpServerMock();

2201 api.TableResourceApi res = new api.FusiontablesApi(mock).table;

2202 var arg_maxResults = 42;

2203 var arg_pageToken = "foo";

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

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

2206 var pathOffset = 0;

2207 var index;

2208 var subPart;

2209 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2210 pathOffset += 17;

2211 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("tables"));

2212 pathOffset += 6;

2213

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

2215 var queryOffset = 0;

2216 var queryMap = {};

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

2218 parseBool(n) {

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

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

2221 if (n == null) return null;

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

2223 }

2224 if (query.length > 0) {

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

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

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

2228 }

2229 }

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

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

2232

2233

2234 var h = {

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

2236 };

2237 var resp = convert.JSON.encode(buildTableList());

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

2239 }), true);

2240 res.list(maxResults: arg_maxResults, pageToken: arg_pageToken).then(unitte st.expectAsync(((api.TableList response) {

2241 checkTableList(response);

2242 })));

2243 });

2244

2245 unittest.test("method--patch", () {

2246

2247 var mock = new common_test.HttpServerMock();

2248 api.TableResourceApi res = new api.FusiontablesApi(mock).table;

2249 var arg_request = buildTable();

2250 var arg_tableId = "foo";

2251 var arg_replaceViewDefinition = true;

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

2253 var obj = new api.Table.fromJson(json);

2254 checkTable(obj);

2255

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

2257 var pathOffset = 0;

2258 var index;

2259 var subPart;

2260 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2261 pathOffset += 17;

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

2263 pathOffset += 7;

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

2265 pathOffset = path.length;

2266 unittest.expect(subPart, unittest.equals("$arg_tableId"));

2267

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

2269 var queryOffset = 0;

2270 var queryMap = {};

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

2272 parseBool(n) {

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

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

2275 if (n == null) return null;

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

2277 }

2278 if (query.length > 0) {

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

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

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

2282 }

2283 }

2284 unittest.expect(queryMap["replaceViewDefinition"].first, unittest.equals ("$arg_replaceViewDefinition"));

2285

2286

2287 var h = {

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

2289 };

2290 var resp = convert.JSON.encode(buildTable());

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

2292 }), true);

2293 res.patch(arg_request, arg_tableId, replaceViewDefinition: arg_replaceView Definition).then(unittest.expectAsync(((api.Table response) {

2294 checkTable(response);

2295 })));

2296 });

2297

2298 unittest.test("method--update", () {

2299

2300 var mock = new common_test.HttpServerMock();

2301 api.TableResourceApi res = new api.FusiontablesApi(mock).table;

2302 var arg_request = buildTable();

2303 var arg_tableId = "foo";

2304 var arg_replaceViewDefinition = true;

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

2306 var obj = new api.Table.fromJson(json);

2307 checkTable(obj);

2308

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

2310 var pathOffset = 0;

2311 var index;

2312 var subPart;

2313 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2314 pathOffset += 17;

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

2316 pathOffset += 7;

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

2318 pathOffset = path.length;

2319 unittest.expect(subPart, unittest.equals("$arg_tableId"));

2320

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

2322 var queryOffset = 0;

2323 var queryMap = {};

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

2325 parseBool(n) {

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

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

2328 if (n == null) return null;

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

2330 }

2331 if (query.length > 0) {

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

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

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

2335 }

2336 }

2337 unittest.expect(queryMap["replaceViewDefinition"].first, unittest.equals ("$arg_replaceViewDefinition"));

2338

2339

2340 var h = {

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

2342 };

2343 var resp = convert.JSON.encode(buildTable());

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

2345 }), true);

2346 res.update(arg_request, arg_tableId, replaceViewDefinition: arg_replaceVie wDefinition).then(unittest.expectAsync(((api.Table response) {

2347 checkTable(response);

2348 })));

2349 });

2350

2351 });

2352

2353

2354 unittest.group("resource-TaskResourceApi", () {

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

2356

2357 var mock = new common_test.HttpServerMock();

2358 api.TaskResourceApi res = new api.FusiontablesApi(mock).task;

2359 var arg_tableId = "foo";

2360 var arg_taskId = "foo";

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

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

2363 var pathOffset = 0;

2364 var index;

2365 var subPart;

2366 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2367 pathOffset += 17;

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

2369 pathOffset += 7;

2370 index = path.indexOf("/tasks/", pathOffset);

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

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

2373 pathOffset = index;

2374 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

2376 pathOffset += 7;

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

2378 pathOffset = path.length;

2379 unittest.expect(subPart, unittest.equals("$arg_taskId"));

2380

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

2382 var queryOffset = 0;

2383 var queryMap = {};

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

2385 parseBool(n) {

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

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

2388 if (n == null) return null;

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

2390 }

2391 if (query.length > 0) {

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

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

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

2395 }

2396 }

2397

2398

2399 var h = {

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

2401 };

2402 var resp = "";

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

2404 }), true);

2405 res.delete(arg_tableId, arg_taskId).then(unittest.expectAsync((_) {}));

2406 });

2407

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

2409

2410 var mock = new common_test.HttpServerMock();

2411 api.TaskResourceApi res = new api.FusiontablesApi(mock).task;

2412 var arg_tableId = "foo";

2413 var arg_taskId = "foo";

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

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

2416 var pathOffset = 0;

2417 var index;

2418 var subPart;

2419 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2420 pathOffset += 17;

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

2422 pathOffset += 7;

2423 index = path.indexOf("/tasks/", pathOffset);

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

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

2426 pathOffset = index;

2427 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

2429 pathOffset += 7;

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

2431 pathOffset = path.length;

2432 unittest.expect(subPart, unittest.equals("$arg_taskId"));

2433

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

2435 var queryOffset = 0;

2436 var queryMap = {};

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

2438 parseBool(n) {

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

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

2441 if (n == null) return null;

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

2443 }

2444 if (query.length > 0) {

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

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

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

2448 }

2449 }

2450

2451

2452 var h = {

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

2454 };

2455 var resp = convert.JSON.encode(buildTask());

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

2457 }), true);

2458 res.get(arg_tableId, arg_taskId).then(unittest.expectAsync(((api.Task resp onse) {

2459 checkTask(response);

2460 })));

2461 });

2462

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

2464

2465 var mock = new common_test.HttpServerMock();

2466 api.TaskResourceApi res = new api.FusiontablesApi(mock).task;

2467 var arg_tableId = "foo";

2468 var arg_maxResults = 42;

2469 var arg_pageToken = "foo";

2470 var arg_startIndex = 42;

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

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

2473 var pathOffset = 0;

2474 var index;

2475 var subPart;

2476 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2477 pathOffset += 17;

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

2479 pathOffset += 7;

2480 index = path.indexOf("/tasks", pathOffset);

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

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

2483 pathOffset = index;

2484 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

2486 pathOffset += 6;

2487

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

2489 var queryOffset = 0;

2490 var queryMap = {};

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

2492 parseBool(n) {

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

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

2495 if (n == null) return null;

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

2497 }

2498 if (query.length > 0) {

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

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

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

2502 }

2503 }

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

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

2506 unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.e quals(arg_startIndex));

2507

2508

2509 var h = {

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

2511 };

2512 var resp = convert.JSON.encode(buildTaskList());

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

2514 }), true);

2515 res.list(arg_tableId, maxResults: arg_maxResults, pageToken: arg_pageToken , startIndex: arg_startIndex).then(unittest.expectAsync(((api.TaskList response) {

2516 checkTaskList(response);

2517 })));

2518 });

2519

2520 });

2521

2522

2523 unittest.group("resource-TemplateResourceApi", () {

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

2525

2526 var mock = new common_test.HttpServerMock();

2527 api.TemplateResourceApi res = new api.FusiontablesApi(mock).template;

2528 var arg_tableId = "foo";

2529 var arg_templateId = 42;

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

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

2532 var pathOffset = 0;

2533 var index;

2534 var subPart;

2535 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2536 pathOffset += 17;

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

2538 pathOffset += 7;

2539 index = path.indexOf("/templates/", pathOffset);

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

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

2542 pathOffset = index;

2543 unittest.expect(subPart, unittest.equals("$arg_tableId"));

2544 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/templates/"));

2545 pathOffset += 11;

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

2547 pathOffset = path.length;

2548 unittest.expect(subPart, unittest.equals("$arg_templateId"));

2549

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

2551 var queryOffset = 0;

2552 var queryMap = {};

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

2554 parseBool(n) {

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

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

2557 if (n == null) return null;

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

2559 }

2560 if (query.length > 0) {

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

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

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

2564 }

2565 }

2566

2567

2568 var h = {

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

2570 };

2571 var resp = "";

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

2573 }), true);

2574 res.delete(arg_tableId, arg_templateId).then(unittest.expectAsync((_) {})) ;

2575 });

2576

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

2578

2579 var mock = new common_test.HttpServerMock();

2580 api.TemplateResourceApi res = new api.FusiontablesApi(mock).template;

2581 var arg_tableId = "foo";

2582 var arg_templateId = 42;

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

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

2585 var pathOffset = 0;

2586 var index;

2587 var subPart;

2588 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2589 pathOffset += 17;

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

2591 pathOffset += 7;

2592 index = path.indexOf("/templates/", pathOffset);

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

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

2595 pathOffset = index;

2596 unittest.expect(subPart, unittest.equals("$arg_tableId"));

2597 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/templates/"));

2598 pathOffset += 11;

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

2600 pathOffset = path.length;

2601 unittest.expect(subPart, unittest.equals("$arg_templateId"));

2602

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

2604 var queryOffset = 0;

2605 var queryMap = {};

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

2607 parseBool(n) {

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

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

2610 if (n == null) return null;

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

2612 }

2613 if (query.length > 0) {

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

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

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

2617 }

2618 }

2619

2620

2621 var h = {

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

2623 };

2624 var resp = convert.JSON.encode(buildTemplate());

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

2626 }), true);

2627 res.get(arg_tableId, arg_templateId).then(unittest.expectAsync(((api.Templ ate response) {

2628 checkTemplate(response);

2629 })));

2630 });

2631

2632 unittest.test("method--insert", () {

2633

2634 var mock = new common_test.HttpServerMock();

2635 api.TemplateResourceApi res = new api.FusiontablesApi(mock).template;

2636 var arg_request = buildTemplate();

2637 var arg_tableId = "foo";

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

2639 var obj = new api.Template.fromJson(json);

2640 checkTemplate(obj);

2641

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

2643 var pathOffset = 0;

2644 var index;

2645 var subPart;

2646 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2647 pathOffset += 17;

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

2649 pathOffset += 7;

2650 index = path.indexOf("/templates", pathOffset);

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

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

2653 pathOffset = index;

2654 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

2656 pathOffset += 10;

2657

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

2659 var queryOffset = 0;

2660 var queryMap = {};

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

2662 parseBool(n) {

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

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

2665 if (n == null) return null;

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

2667 }

2668 if (query.length > 0) {

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

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

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

2672 }

2673 }

2674

2675

2676 var h = {

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

2678 };

2679 var resp = convert.JSON.encode(buildTemplate());

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

2681 }), true);

2682 res.insert(arg_request, arg_tableId).then(unittest.expectAsync(((api.Templ ate response) {

2683 checkTemplate(response);

2684 })));

2685 });

2686

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

2688

2689 var mock = new common_test.HttpServerMock();

2690 api.TemplateResourceApi res = new api.FusiontablesApi(mock).template;

2691 var arg_tableId = "foo";

2692 var arg_maxResults = 42;

2693 var arg_pageToken = "foo";

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

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

2696 var pathOffset = 0;

2697 var index;

2698 var subPart;

2699 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2700 pathOffset += 17;

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

2702 pathOffset += 7;

2703 index = path.indexOf("/templates", pathOffset);

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

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

2706 pathOffset = index;

2707 unittest.expect(subPart, unittest.equals("$arg_tableId"));

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

2709 pathOffset += 10;

2710

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

2712 var queryOffset = 0;

2713 var queryMap = {};

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

2715 parseBool(n) {

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

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

2718 if (n == null) return null;

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

2720 }

2721 if (query.length > 0) {

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

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

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

2725 }

2726 }

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

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

2729

2730

2731 var h = {

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

2733 };

2734 var resp = convert.JSON.encode(buildTemplateList());

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

2736 }), true);

2737 res.list(arg_tableId, maxResults: arg_maxResults, pageToken: arg_pageToken ).then(unittest.expectAsync(((api.TemplateList response) {

2738 checkTemplateList(response);

2739 })));

2740 });

2741

2742 unittest.test("method--patch", () {

2743

2744 var mock = new common_test.HttpServerMock();

2745 api.TemplateResourceApi res = new api.FusiontablesApi(mock).template;

2746 var arg_request = buildTemplate();

2747 var arg_tableId = "foo";

2748 var arg_templateId = 42;

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

2750 var obj = new api.Template.fromJson(json);

2751 checkTemplate(obj);

2752

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

2754 var pathOffset = 0;

2755 var index;

2756 var subPart;

2757 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2758 pathOffset += 17;

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

2760 pathOffset += 7;

2761 index = path.indexOf("/templates/", pathOffset);

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

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

2764 pathOffset = index;

2765 unittest.expect(subPart, unittest.equals("$arg_tableId"));

2766 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/templates/"));

2767 pathOffset += 11;

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

2769 pathOffset = path.length;

2770 unittest.expect(subPart, unittest.equals("$arg_templateId"));

2771

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

2773 var queryOffset = 0;

2774 var queryMap = {};

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

2776 parseBool(n) {

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

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

2779 if (n == null) return null;

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

2781 }

2782 if (query.length > 0) {

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

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

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

2786 }

2787 }

2788

2789

2790 var h = {

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

2792 };

2793 var resp = convert.JSON.encode(buildTemplate());

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

2795 }), true);

2796 res.patch(arg_request, arg_tableId, arg_templateId).then(unittest.expectAs ync(((api.Template response) {

2797 checkTemplate(response);

2798 })));

2799 });

2800

2801 unittest.test("method--update", () {

2802

2803 var mock = new common_test.HttpServerMock();

2804 api.TemplateResourceApi res = new api.FusiontablesApi(mock).template;

2805 var arg_request = buildTemplate();

2806 var arg_tableId = "foo";

2807 var arg_templateId = 42;

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

2809 var obj = new api.Template.fromJson(json);

2810 checkTemplate(obj);

2811

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

2813 var pathOffset = 0;

2814 var index;

2815 var subPart;

2816 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/fusiontables/v1/"));

2817 pathOffset += 17;

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

2819 pathOffset += 7;

2820 index = path.indexOf("/templates/", pathOffset);

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

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

2823 pathOffset = index;

2824 unittest.expect(subPart, unittest.equals("$arg_tableId"));

2825 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/templates/"));

2826 pathOffset += 11;

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

2828 pathOffset = path.length;

2829 unittest.expect(subPart, unittest.equals("$arg_templateId"));

2830

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

2832 var queryOffset = 0;

2833 var queryMap = {};

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

2835 parseBool(n) {

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

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

2838 if (n == null) return null;

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

2840 }

2841 if (query.length > 0) {

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

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

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

2845 }

2846 }

2847

2848

2849 var h = {

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

2851 };

2852 var resp = convert.JSON.encode(buildTemplate());

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

2854 }), true);

2855 res.update(arg_request, arg_tableId, arg_templateId).then(unittest.expectA sync(((api.Template response) {

2856 checkTemplate(response);

2857 })));

2858 });

2859

2860 });

2861

2862

2863 }

2864

OLD	NEW

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