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

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

16

17

18

19 buildUnnamed394() {

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

21 o.add("foo");

22 o.add("foo");

23 return o;

24 }

25

26 checkUnnamed394(core.List<core.String> o) {

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

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

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

30 }

31

32 core.int buildCounterAboutAdditionalRoleInfoRoleSets = 0;

33 buildAboutAdditionalRoleInfoRoleSets() {

34 var o = new api.AboutAdditionalRoleInfoRoleSets();

35 buildCounterAboutAdditionalRoleInfoRoleSets++;

36 if (buildCounterAboutAdditionalRoleInfoRoleSets < 3) {

37 o.additionalRoles = buildUnnamed394();

38 o.primaryRole = "foo";

39 }

40 buildCounterAboutAdditionalRoleInfoRoleSets--;

41 return o;

42 }

43

44 checkAboutAdditionalRoleInfoRoleSets(api.AboutAdditionalRoleInfoRoleSets o) {

45 buildCounterAboutAdditionalRoleInfoRoleSets++;

46 if (buildCounterAboutAdditionalRoleInfoRoleSets < 3) {

47 checkUnnamed394(o.additionalRoles);

48 unittest.expect(o.primaryRole, unittest.equals('foo'));

49 }

50 buildCounterAboutAdditionalRoleInfoRoleSets--;

51 }

52

53 buildUnnamed395() {

54 var o = new core.List<api.AboutAdditionalRoleInfoRoleSets>();

55 o.add(buildAboutAdditionalRoleInfoRoleSets());

56 o.add(buildAboutAdditionalRoleInfoRoleSets());

57 return o;

58 }

59

60 checkUnnamed395(core.List<api.AboutAdditionalRoleInfoRoleSets> o) {

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

62 checkAboutAdditionalRoleInfoRoleSets(o[0]);

63 checkAboutAdditionalRoleInfoRoleSets(o[1]);

64 }

65

66 core.int buildCounterAboutAdditionalRoleInfo = 0;

67 buildAboutAdditionalRoleInfo() {

68 var o = new api.AboutAdditionalRoleInfo();

69 buildCounterAboutAdditionalRoleInfo++;

70 if (buildCounterAboutAdditionalRoleInfo < 3) {

71 o.roleSets = buildUnnamed395();

72 o.type = "foo";

73 }

74 buildCounterAboutAdditionalRoleInfo--;

75 return o;

76 }

77

78 checkAboutAdditionalRoleInfo(api.AboutAdditionalRoleInfo o) {

79 buildCounterAboutAdditionalRoleInfo++;

80 if (buildCounterAboutAdditionalRoleInfo < 3) {

81 checkUnnamed395(o.roleSets);

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

83 }

84 buildCounterAboutAdditionalRoleInfo--;

85 }

86

87 buildUnnamed396() {

88 var o = new core.List<api.AboutAdditionalRoleInfo>();

89 o.add(buildAboutAdditionalRoleInfo());

90 o.add(buildAboutAdditionalRoleInfo());

91 return o;

92 }

93

94 checkUnnamed396(core.List<api.AboutAdditionalRoleInfo> o) {

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

96 checkAboutAdditionalRoleInfo(o[0]);

97 checkAboutAdditionalRoleInfo(o[1]);

98 }

99

100 buildUnnamed397() {

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

102 o.add("foo");

103 o.add("foo");

104 return o;

105 }

106

107 checkUnnamed397(core.List<core.String> o) {

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

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

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

111 }

112

113 core.int buildCounterAboutExportFormats = 0;

114 buildAboutExportFormats() {

115 var o = new api.AboutExportFormats();

116 buildCounterAboutExportFormats++;

117 if (buildCounterAboutExportFormats < 3) {

118 o.source = "foo";

119 o.targets = buildUnnamed397();

120 }

121 buildCounterAboutExportFormats--;

122 return o;

123 }

124

125 checkAboutExportFormats(api.AboutExportFormats o) {

126 buildCounterAboutExportFormats++;

127 if (buildCounterAboutExportFormats < 3) {

128 unittest.expect(o.source, unittest.equals('foo'));

129 checkUnnamed397(o.targets);

130 }

131 buildCounterAboutExportFormats--;

132 }

133

134 buildUnnamed398() {

135 var o = new core.List<api.AboutExportFormats>();

136 o.add(buildAboutExportFormats());

137 o.add(buildAboutExportFormats());

138 return o;

139 }

140

141 checkUnnamed398(core.List<api.AboutExportFormats> o) {

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

143 checkAboutExportFormats(o[0]);

144 checkAboutExportFormats(o[1]);

145 }

146

147 core.int buildCounterAboutFeatures = 0;

148 buildAboutFeatures() {

149 var o = new api.AboutFeatures();

150 buildCounterAboutFeatures++;

151 if (buildCounterAboutFeatures < 3) {

152 o.featureName = "foo";

153 o.featureRate = 42.0;

154 }

155 buildCounterAboutFeatures--;

156 return o;

157 }

158

159 checkAboutFeatures(api.AboutFeatures o) {

160 buildCounterAboutFeatures++;

161 if (buildCounterAboutFeatures < 3) {

162 unittest.expect(o.featureName, unittest.equals('foo'));

163 unittest.expect(o.featureRate, unittest.equals(42.0));

164 }

165 buildCounterAboutFeatures--;

166 }

167

168 buildUnnamed399() {

169 var o = new core.List<api.AboutFeatures>();

170 o.add(buildAboutFeatures());

171 o.add(buildAboutFeatures());

172 return o;

173 }

174

175 checkUnnamed399(core.List<api.AboutFeatures> o) {

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

177 checkAboutFeatures(o[0]);

178 checkAboutFeatures(o[1]);

179 }

180

181 buildUnnamed400() {

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

183 o.add("foo");

184 o.add("foo");

185 return o;

186 }

187

188 checkUnnamed400(core.List<core.String> o) {

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

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

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

192 }

193

194 core.int buildCounterAboutImportFormats = 0;

195 buildAboutImportFormats() {

196 var o = new api.AboutImportFormats();

197 buildCounterAboutImportFormats++;

198 if (buildCounterAboutImportFormats < 3) {

199 o.source = "foo";

200 o.targets = buildUnnamed400();

201 }

202 buildCounterAboutImportFormats--;

203 return o;

204 }

205

206 checkAboutImportFormats(api.AboutImportFormats o) {

207 buildCounterAboutImportFormats++;

208 if (buildCounterAboutImportFormats < 3) {

209 unittest.expect(o.source, unittest.equals('foo'));

210 checkUnnamed400(o.targets);

211 }

212 buildCounterAboutImportFormats--;

213 }

214

215 buildUnnamed401() {

216 var o = new core.List<api.AboutImportFormats>();

217 o.add(buildAboutImportFormats());

218 o.add(buildAboutImportFormats());

219 return o;

220 }

221

222 checkUnnamed401(core.List<api.AboutImportFormats> o) {

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

224 checkAboutImportFormats(o[0]);

225 checkAboutImportFormats(o[1]);

226 }

227

228 core.int buildCounterAboutMaxUploadSizes = 0;

229 buildAboutMaxUploadSizes() {

230 var o = new api.AboutMaxUploadSizes();

231 buildCounterAboutMaxUploadSizes++;

232 if (buildCounterAboutMaxUploadSizes < 3) {

233 o.size = "foo";

234 o.type = "foo";

235 }

236 buildCounterAboutMaxUploadSizes--;

237 return o;

238 }

239

240 checkAboutMaxUploadSizes(api.AboutMaxUploadSizes o) {

241 buildCounterAboutMaxUploadSizes++;

242 if (buildCounterAboutMaxUploadSizes < 3) {

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

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

245 }

246 buildCounterAboutMaxUploadSizes--;

247 }

248

249 buildUnnamed402() {

250 var o = new core.List<api.AboutMaxUploadSizes>();

251 o.add(buildAboutMaxUploadSizes());

252 o.add(buildAboutMaxUploadSizes());

253 return o;

254 }

255

256 checkUnnamed402(core.List<api.AboutMaxUploadSizes> o) {

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

258 checkAboutMaxUploadSizes(o[0]);

259 checkAboutMaxUploadSizes(o[1]);

260 }

261

262 core.int buildCounterAboutQuotaBytesByService = 0;

263 buildAboutQuotaBytesByService() {

264 var o = new api.AboutQuotaBytesByService();

265 buildCounterAboutQuotaBytesByService++;

266 if (buildCounterAboutQuotaBytesByService < 3) {

267 o.bytesUsed = "foo";

268 o.serviceName = "foo";

269 }

270 buildCounterAboutQuotaBytesByService--;

271 return o;

272 }

273

274 checkAboutQuotaBytesByService(api.AboutQuotaBytesByService o) {

275 buildCounterAboutQuotaBytesByService++;

276 if (buildCounterAboutQuotaBytesByService < 3) {

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

278 unittest.expect(o.serviceName, unittest.equals('foo'));

279 }

280 buildCounterAboutQuotaBytesByService--;

281 }

282

283 buildUnnamed403() {

284 var o = new core.List<api.AboutQuotaBytesByService>();

285 o.add(buildAboutQuotaBytesByService());

286 o.add(buildAboutQuotaBytesByService());

287 return o;

288 }

289

290 checkUnnamed403(core.List<api.AboutQuotaBytesByService> o) {

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

292 checkAboutQuotaBytesByService(o[0]);

293 checkAboutQuotaBytesByService(o[1]);

294 }

295

296 core.int buildCounterAbout = 0;

297 buildAbout() {

298 var o = new api.About();

299 buildCounterAbout++;

300 if (buildCounterAbout < 3) {

301 o.additionalRoleInfo = buildUnnamed396();

302 o.domainSharingPolicy = "foo";

303 o.etag = "foo";

304 o.exportFormats = buildUnnamed398();

305 o.features = buildUnnamed399();

306 o.importFormats = buildUnnamed401();

307 o.isCurrentAppInstalled = true;

308 o.kind = "foo";

309 o.languageCode = "foo";

310 o.largestChangeId = "foo";

311 o.maxUploadSizes = buildUnnamed402();

312 o.name = "foo";

313 o.permissionId = "foo";

314 o.quotaBytesByService = buildUnnamed403();

315 o.quotaBytesTotal = "foo";

316 o.quotaBytesUsed = "foo";

317 o.quotaBytesUsedAggregate = "foo";

318 o.quotaBytesUsedInTrash = "foo";

319 o.quotaType = "foo";

320 o.remainingChangeIds = "foo";

321 o.rootFolderId = "foo";

322 o.selfLink = "foo";

323 o.user = buildUser();

324 }

325 buildCounterAbout--;

326 return o;

327 }

328

329 checkAbout(api.About o) {

330 buildCounterAbout++;

331 if (buildCounterAbout < 3) {

332 checkUnnamed396(o.additionalRoleInfo);

333 unittest.expect(o.domainSharingPolicy, unittest.equals('foo'));

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

335 checkUnnamed398(o.exportFormats);

336 checkUnnamed399(o.features);

337 checkUnnamed401(o.importFormats);

338 unittest.expect(o.isCurrentAppInstalled, unittest.isTrue);

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

340 unittest.expect(o.languageCode, unittest.equals('foo'));

341 unittest.expect(o.largestChangeId, unittest.equals('foo'));

342 checkUnnamed402(o.maxUploadSizes);

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

344 unittest.expect(o.permissionId, unittest.equals('foo'));

345 checkUnnamed403(o.quotaBytesByService);

346 unittest.expect(o.quotaBytesTotal, unittest.equals('foo'));

347 unittest.expect(o.quotaBytesUsed, unittest.equals('foo'));

348 unittest.expect(o.quotaBytesUsedAggregate, unittest.equals('foo'));

349 unittest.expect(o.quotaBytesUsedInTrash, unittest.equals('foo'));

350 unittest.expect(o.quotaType, unittest.equals('foo'));

351 unittest.expect(o.remainingChangeIds, unittest.equals('foo'));

352 unittest.expect(o.rootFolderId, unittest.equals('foo'));

353 unittest.expect(o.selfLink, unittest.equals('foo'));

354 checkUser(o.user);

355 }

356 buildCounterAbout--;

357 }

358

359 core.int buildCounterAppIcons = 0;

360 buildAppIcons() {

361 var o = new api.AppIcons();

362 buildCounterAppIcons++;

363 if (buildCounterAppIcons < 3) {

364 o.category = "foo";

365 o.iconUrl = "foo";

366 o.size = 42;

367 }

368 buildCounterAppIcons--;

369 return o;

370 }

371

372 checkAppIcons(api.AppIcons o) {

373 buildCounterAppIcons++;

374 if (buildCounterAppIcons < 3) {

375 unittest.expect(o.category, unittest.equals('foo'));

376 unittest.expect(o.iconUrl, unittest.equals('foo'));

377 unittest.expect(o.size, unittest.equals(42));

378 }

379 buildCounterAppIcons--;

380 }

381

382 buildUnnamed404() {

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

384 o.add(buildAppIcons());

385 o.add(buildAppIcons());

386 return o;

387 }

388

389 checkUnnamed404(core.List<api.AppIcons> o) {

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

391 checkAppIcons(o[0]);

392 checkAppIcons(o[1]);

393 }

394

395 buildUnnamed405() {

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

397 o.add("foo");

398 o.add("foo");

399 return o;

400 }

401

402 checkUnnamed405(core.List<core.String> o) {

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

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

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

406 }

407

408 buildUnnamed406() {

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

410 o.add("foo");

411 o.add("foo");

412 return o;

413 }

414

415 checkUnnamed406(core.List<core.String> o) {

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

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

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

419 }

420

421 buildUnnamed407() {

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

423 o.add("foo");

424 o.add("foo");

425 return o;

426 }

427

428 checkUnnamed407(core.List<core.String> o) {

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

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

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

432 }

433

434 buildUnnamed408() {

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

436 o.add("foo");

437 o.add("foo");

438 return o;

439 }

440

441 checkUnnamed408(core.List<core.String> o) {

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

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

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

445 }

446

447 core.int buildCounterApp = 0;

448 buildApp() {

449 var o = new api.App();

450 buildCounterApp++;

451 if (buildCounterApp < 3) {

452 o.authorized = true;

453 o.createInFolderTemplate = "foo";

454 o.createUrl = "foo";

455 o.hasDriveWideScope = true;

456 o.icons = buildUnnamed404();

457 o.id = "foo";

458 o.installed = true;

459 o.kind = "foo";

460 o.longDescription = "foo";

461 o.name = "foo";

462 o.objectType = "foo";

463 o.openUrlTemplate = "foo";

464 o.primaryFileExtensions = buildUnnamed405();

465 o.primaryMimeTypes = buildUnnamed406();

466 o.productId = "foo";

467 o.productUrl = "foo";

468 o.secondaryFileExtensions = buildUnnamed407();

469 o.secondaryMimeTypes = buildUnnamed408();

470 o.shortDescription = "foo";

471 o.supportsCreate = true;

472 o.supportsImport = true;

473 o.supportsMultiOpen = true;

474 o.supportsOfflineCreate = true;

475 o.useByDefault = true;

476 }

477 buildCounterApp--;

478 return o;

479 }

480

481 checkApp(api.App o) {

482 buildCounterApp++;

483 if (buildCounterApp < 3) {

484 unittest.expect(o.authorized, unittest.isTrue);

485 unittest.expect(o.createInFolderTemplate, unittest.equals('foo'));

486 unittest.expect(o.createUrl, unittest.equals('foo'));

487 unittest.expect(o.hasDriveWideScope, unittest.isTrue);

488 checkUnnamed404(o.icons);

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

490 unittest.expect(o.installed, unittest.isTrue);

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

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

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

494 unittest.expect(o.objectType, unittest.equals('foo'));

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

496 checkUnnamed405(o.primaryFileExtensions);

497 checkUnnamed406(o.primaryMimeTypes);

498 unittest.expect(o.productId, unittest.equals('foo'));

499 unittest.expect(o.productUrl, unittest.equals('foo'));

500 checkUnnamed407(o.secondaryFileExtensions);

501 checkUnnamed408(o.secondaryMimeTypes);

502 unittest.expect(o.shortDescription, unittest.equals('foo'));

503 unittest.expect(o.supportsCreate, unittest.isTrue);

504 unittest.expect(o.supportsImport, unittest.isTrue);

505 unittest.expect(o.supportsMultiOpen, unittest.isTrue);

506 unittest.expect(o.supportsOfflineCreate, unittest.isTrue);

507 unittest.expect(o.useByDefault, unittest.isTrue);

508 }

509 buildCounterApp--;

510 }

511

512 buildUnnamed409() {

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

514 o.add("foo");

515 o.add("foo");

516 return o;

517 }

518

519 checkUnnamed409(core.List<core.String> o) {

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

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

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

523 }

524

525 buildUnnamed410() {

526 var o = new core.List<api.App>();

527 o.add(buildApp());

528 o.add(buildApp());

529 return o;

530 }

531

532 checkUnnamed410(core.List<api.App> o) {

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

534 checkApp(o[0]);

535 checkApp(o[1]);

536 }

537

538 core.int buildCounterAppList = 0;

539 buildAppList() {

540 var o = new api.AppList();

541 buildCounterAppList++;

542 if (buildCounterAppList < 3) {

543 o.defaultAppIds = buildUnnamed409();

544 o.etag = "foo";

545 o.items = buildUnnamed410();

546 o.kind = "foo";

547 o.selfLink = "foo";

548 }

549 buildCounterAppList--;

550 return o;

551 }

552

553 checkAppList(api.AppList o) {

554 buildCounterAppList++;

555 if (buildCounterAppList < 3) {

556 checkUnnamed409(o.defaultAppIds);

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

558 checkUnnamed410(o.items);

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

560 unittest.expect(o.selfLink, unittest.equals('foo'));

561 }

562 buildCounterAppList--;

563 }

564

565 core.int buildCounterChange = 0;

566 buildChange() {

567 var o = new api.Change();

568 buildCounterChange++;

569 if (buildCounterChange < 3) {

570 o.deleted = true;

571 o.file = buildFile();

572 o.fileId = "foo";

573 o.id = "foo";

574 o.kind = "foo";

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

576 o.selfLink = "foo";

577 }

578 buildCounterChange--;

579 return o;

580 }

581

582 checkChange(api.Change o) {

583 buildCounterChange++;

584 if (buildCounterChange < 3) {

585 unittest.expect(o.deleted, unittest.isTrue);

586 checkFile(o.file);

587 unittest.expect(o.fileId, unittest.equals('foo'));

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

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

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

591 unittest.expect(o.selfLink, unittest.equals('foo'));

592 }

593 buildCounterChange--;

594 }

595

596 buildUnnamed411() {

597 var o = new core.List<api.Change>();

598 o.add(buildChange());

599 o.add(buildChange());

600 return o;

601 }

602

603 checkUnnamed411(core.List<api.Change> o) {

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

605 checkChange(o[0]);

606 checkChange(o[1]);

607 }

608

609 core.int buildCounterChangeList = 0;

610 buildChangeList() {

611 var o = new api.ChangeList();

612 buildCounterChangeList++;

613 if (buildCounterChangeList < 3) {

614 o.etag = "foo";

615 o.items = buildUnnamed411();

616 o.kind = "foo";

617 o.largestChangeId = "foo";

618 o.nextLink = "foo";

619 o.nextPageToken = "foo";

620 o.selfLink = "foo";

621 }

622 buildCounterChangeList--;

623 return o;

624 }

625

626 checkChangeList(api.ChangeList o) {

627 buildCounterChangeList++;

628 if (buildCounterChangeList < 3) {

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

630 checkUnnamed411(o.items);

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

632 unittest.expect(o.largestChangeId, unittest.equals('foo'));

633 unittest.expect(o.nextLink, unittest.equals('foo'));

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

635 unittest.expect(o.selfLink, unittest.equals('foo'));

636 }

637 buildCounterChangeList--;

638 }

639

640 buildUnnamed412() {

641 var o = new core.Map<core.String, core.String>();

642 o["x"] = "foo";

643 o["y"] = "foo";

644 return o;

645 }

646

647 checkUnnamed412(core.Map<core.String, core.String> o) {

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

649 unittest.expect(o["x"], unittest.equals('foo'));

650 unittest.expect(o["y"], unittest.equals('foo'));

651 }

652

653 core.int buildCounterChannel = 0;

654 buildChannel() {

655 var o = new api.Channel();

656 buildCounterChannel++;

657 if (buildCounterChannel < 3) {

658 o.address = "foo";

659 o.expiration = "foo";

660 o.id = "foo";

661 o.kind = "foo";

662 o.params = buildUnnamed412();

663 o.payload = true;

664 o.resourceId = "foo";

665 o.resourceUri = "foo";

666 o.token = "foo";

667 o.type = "foo";

668 }

669 buildCounterChannel--;

670 return o;

671 }

672

673 checkChannel(api.Channel o) {

674 buildCounterChannel++;

675 if (buildCounterChannel < 3) {

676 unittest.expect(o.address, unittest.equals('foo'));

677 unittest.expect(o.expiration, unittest.equals('foo'));

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

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

680 checkUnnamed412(o.params);

681 unittest.expect(o.payload, unittest.isTrue);

682 unittest.expect(o.resourceId, unittest.equals('foo'));

683 unittest.expect(o.resourceUri, unittest.equals('foo'));

684 unittest.expect(o.token, unittest.equals('foo'));

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

686 }

687 buildCounterChannel--;

688 }

689

690 buildUnnamed413() {

691 var o = new core.List<api.ChildReference>();

692 o.add(buildChildReference());

693 o.add(buildChildReference());

694 return o;

695 }

696

697 checkUnnamed413(core.List<api.ChildReference> o) {

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

699 checkChildReference(o[0]);

700 checkChildReference(o[1]);

701 }

702

703 core.int buildCounterChildList = 0;

704 buildChildList() {

705 var o = new api.ChildList();

706 buildCounterChildList++;

707 if (buildCounterChildList < 3) {

708 o.etag = "foo";

709 o.items = buildUnnamed413();

710 o.kind = "foo";

711 o.nextLink = "foo";

712 o.nextPageToken = "foo";

713 o.selfLink = "foo";

714 }

715 buildCounterChildList--;

716 return o;

717 }

718

719 checkChildList(api.ChildList o) {

720 buildCounterChildList++;

721 if (buildCounterChildList < 3) {

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

723 checkUnnamed413(o.items);

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

725 unittest.expect(o.nextLink, unittest.equals('foo'));

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

727 unittest.expect(o.selfLink, unittest.equals('foo'));

728 }

729 buildCounterChildList--;

730 }

731

732 core.int buildCounterChildReference = 0;

733 buildChildReference() {

734 var o = new api.ChildReference();

735 buildCounterChildReference++;

736 if (buildCounterChildReference < 3) {

737 o.childLink = "foo";

738 o.id = "foo";

739 o.kind = "foo";

740 o.selfLink = "foo";

741 }

742 buildCounterChildReference--;

743 return o;

744 }

745

746 checkChildReference(api.ChildReference o) {

747 buildCounterChildReference++;

748 if (buildCounterChildReference < 3) {

749 unittest.expect(o.childLink, unittest.equals('foo'));

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

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

752 unittest.expect(o.selfLink, unittest.equals('foo'));

753 }

754 buildCounterChildReference--;

755 }

756

757 core.int buildCounterCommentContext = 0;

758 buildCommentContext() {

759 var o = new api.CommentContext();

760 buildCounterCommentContext++;

761 if (buildCounterCommentContext < 3) {

762 o.type = "foo";

763 o.value = "foo";

764 }

765 buildCounterCommentContext--;

766 return o;

767 }

768

769 checkCommentContext(api.CommentContext o) {

770 buildCounterCommentContext++;

771 if (buildCounterCommentContext < 3) {

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

773 unittest.expect(o.value, unittest.equals('foo'));

774 }

775 buildCounterCommentContext--;

776 }

777

778 buildUnnamed414() {

779 var o = new core.List<api.CommentReply>();

780 o.add(buildCommentReply());

781 o.add(buildCommentReply());

782 return o;

783 }

784

785 checkUnnamed414(core.List<api.CommentReply> o) {

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

787 checkCommentReply(o[0]);

788 checkCommentReply(o[1]);

789 }

790

791 core.int buildCounterComment = 0;

792 buildComment() {

793 var o = new api.Comment();

794 buildCounterComment++;

795 if (buildCounterComment < 3) {

796 o.anchor = "foo";

797 o.author = buildUser();

798 o.commentId = "foo";

799 o.content = "foo";

800 o.context = buildCommentContext();

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

802 o.deleted = true;

803 o.fileId = "foo";

804 o.fileTitle = "foo";

805 o.htmlContent = "foo";

806 o.kind = "foo";

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

808 o.replies = buildUnnamed414();

809 o.selfLink = "foo";

810 o.status = "foo";

811 }

812 buildCounterComment--;

813 return o;

814 }

815

816 checkComment(api.Comment o) {

817 buildCounterComment++;

818 if (buildCounterComment < 3) {

819 unittest.expect(o.anchor, unittest.equals('foo'));

820 checkUser(o.author);

821 unittest.expect(o.commentId, unittest.equals('foo'));

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

823 checkCommentContext(o.context);

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

825 unittest.expect(o.deleted, unittest.isTrue);

826 unittest.expect(o.fileId, unittest.equals('foo'));

827 unittest.expect(o.fileTitle, unittest.equals('foo'));

828 unittest.expect(o.htmlContent, unittest.equals('foo'));

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

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

831 checkUnnamed414(o.replies);

832 unittest.expect(o.selfLink, unittest.equals('foo'));

833 unittest.expect(o.status, unittest.equals('foo'));

834 }

835 buildCounterComment--;

836 }

837

838 buildUnnamed415() {

839 var o = new core.List<api.Comment>();

840 o.add(buildComment());

841 o.add(buildComment());

842 return o;

843 }

844

845 checkUnnamed415(core.List<api.Comment> o) {

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

847 checkComment(o[0]);

848 checkComment(o[1]);

849 }

850

851 core.int buildCounterCommentList = 0;

852 buildCommentList() {

853 var o = new api.CommentList();

854 buildCounterCommentList++;

855 if (buildCounterCommentList < 3) {

856 o.items = buildUnnamed415();

857 o.kind = "foo";

858 o.nextLink = "foo";

859 o.nextPageToken = "foo";

860 o.selfLink = "foo";

861 }

862 buildCounterCommentList--;

863 return o;

864 }

865

866 checkCommentList(api.CommentList o) {

867 buildCounterCommentList++;

868 if (buildCounterCommentList < 3) {

869 checkUnnamed415(o.items);

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

871 unittest.expect(o.nextLink, unittest.equals('foo'));

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

873 unittest.expect(o.selfLink, unittest.equals('foo'));

874 }

875 buildCounterCommentList--;

876 }

877

878 core.int buildCounterCommentReply = 0;

879 buildCommentReply() {

880 var o = new api.CommentReply();

881 buildCounterCommentReply++;

882 if (buildCounterCommentReply < 3) {

883 o.author = buildUser();

884 o.content = "foo";

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

886 o.deleted = true;

887 o.htmlContent = "foo";

888 o.kind = "foo";

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

890 o.replyId = "foo";

891 o.verb = "foo";

892 }

893 buildCounterCommentReply--;

894 return o;

895 }

896

897 checkCommentReply(api.CommentReply o) {

898 buildCounterCommentReply++;

899 if (buildCounterCommentReply < 3) {

900 checkUser(o.author);

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

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

903 unittest.expect(o.deleted, unittest.isTrue);

904 unittest.expect(o.htmlContent, unittest.equals('foo'));

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

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

907 unittest.expect(o.replyId, unittest.equals('foo'));

908 unittest.expect(o.verb, unittest.equals('foo'));

909 }

910 buildCounterCommentReply--;

911 }

912

913 buildUnnamed416() {

914 var o = new core.List<api.CommentReply>();

915 o.add(buildCommentReply());

916 o.add(buildCommentReply());

917 return o;

918 }

919

920 checkUnnamed416(core.List<api.CommentReply> o) {

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

922 checkCommentReply(o[0]);

923 checkCommentReply(o[1]);

924 }

925

926 core.int buildCounterCommentReplyList = 0;

927 buildCommentReplyList() {

928 var o = new api.CommentReplyList();

929 buildCounterCommentReplyList++;

930 if (buildCounterCommentReplyList < 3) {

931 o.items = buildUnnamed416();

932 o.kind = "foo";

933 o.nextLink = "foo";

934 o.nextPageToken = "foo";

935 o.selfLink = "foo";

936 }

937 buildCounterCommentReplyList--;

938 return o;

939 }

940

941 checkCommentReplyList(api.CommentReplyList o) {

942 buildCounterCommentReplyList++;

943 if (buildCounterCommentReplyList < 3) {

944 checkUnnamed416(o.items);

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

946 unittest.expect(o.nextLink, unittest.equals('foo'));

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

948 unittest.expect(o.selfLink, unittest.equals('foo'));

949 }

950 buildCounterCommentReplyList--;

951 }

952

953 buildUnnamed417() {

954 var o = new core.Map<core.String, core.String>();

955 o["x"] = "foo";

956 o["y"] = "foo";

957 return o;

958 }

959

960 checkUnnamed417(core.Map<core.String, core.String> o) {

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

962 unittest.expect(o["x"], unittest.equals('foo'));

963 unittest.expect(o["y"], unittest.equals('foo'));

964 }

965

966 core.int buildCounterFileImageMediaMetadataLocation = 0;

967 buildFileImageMediaMetadataLocation() {

968 var o = new api.FileImageMediaMetadataLocation();

969 buildCounterFileImageMediaMetadataLocation++;

970 if (buildCounterFileImageMediaMetadataLocation < 3) {

971 o.altitude = 42.0;

972 o.latitude = 42.0;

973 o.longitude = 42.0;

974 }

975 buildCounterFileImageMediaMetadataLocation--;

976 return o;

977 }

978

979 checkFileImageMediaMetadataLocation(api.FileImageMediaMetadataLocation o) {

980 buildCounterFileImageMediaMetadataLocation++;

981 if (buildCounterFileImageMediaMetadataLocation < 3) {

982 unittest.expect(o.altitude, unittest.equals(42.0));

983 unittest.expect(o.latitude, unittest.equals(42.0));

984 unittest.expect(o.longitude, unittest.equals(42.0));

985 }

986 buildCounterFileImageMediaMetadataLocation--;

987 }

988

989 core.int buildCounterFileImageMediaMetadata = 0;

990 buildFileImageMediaMetadata() {

991 var o = new api.FileImageMediaMetadata();

992 buildCounterFileImageMediaMetadata++;

993 if (buildCounterFileImageMediaMetadata < 3) {

994 o.aperture = 42.0;

995 o.cameraMake = "foo";

996 o.cameraModel = "foo";

997 o.colorSpace = "foo";

998 o.date = "foo";

999 o.exposureBias = 42.0;

1000 o.exposureMode = "foo";

1001 o.exposureTime = 42.0;

1002 o.flashUsed = true;

1003 o.focalLength = 42.0;

1004 o.height = 42;

1005 o.isoSpeed = 42;

1006 o.lens = "foo";

1007 o.location = buildFileImageMediaMetadataLocation();

1008 o.maxApertureValue = 42.0;

1009 o.meteringMode = "foo";

1010 o.rotation = 42;

1011 o.sensor = "foo";

1012 o.subjectDistance = 42;

1013 o.whiteBalance = "foo";

1014 o.width = 42;

1015 }

1016 buildCounterFileImageMediaMetadata--;

1017 return o;

1018 }

1019

1020 checkFileImageMediaMetadata(api.FileImageMediaMetadata o) {

1021 buildCounterFileImageMediaMetadata++;

1022 if (buildCounterFileImageMediaMetadata < 3) {

1023 unittest.expect(o.aperture, unittest.equals(42.0));

1024 unittest.expect(o.cameraMake, unittest.equals('foo'));

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

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

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

1028 unittest.expect(o.exposureBias, unittest.equals(42.0));

1029 unittest.expect(o.exposureMode, unittest.equals('foo'));

1030 unittest.expect(o.exposureTime, unittest.equals(42.0));

1031 unittest.expect(o.flashUsed, unittest.isTrue);

1032 unittest.expect(o.focalLength, unittest.equals(42.0));

1033 unittest.expect(o.height, unittest.equals(42));

1034 unittest.expect(o.isoSpeed, unittest.equals(42));

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

1036 checkFileImageMediaMetadataLocation(o.location);

1037 unittest.expect(o.maxApertureValue, unittest.equals(42.0));

1038 unittest.expect(o.meteringMode, unittest.equals('foo'));

1039 unittest.expect(o.rotation, unittest.equals(42));

1040 unittest.expect(o.sensor, unittest.equals('foo'));

1041 unittest.expect(o.subjectDistance, unittest.equals(42));

1042 unittest.expect(o.whiteBalance, unittest.equals('foo'));

1043 unittest.expect(o.width, unittest.equals(42));

1044 }

1045 buildCounterFileImageMediaMetadata--;

1046 }

1047

1048 core.int buildCounterFileIndexableText = 0;

1049 buildFileIndexableText() {

1050 var o = new api.FileIndexableText();

1051 buildCounterFileIndexableText++;

1052 if (buildCounterFileIndexableText < 3) {

1053 o.text = "foo";

1054 }

1055 buildCounterFileIndexableText--;

1056 return o;

1057 }

1058

1059 checkFileIndexableText(api.FileIndexableText o) {

1060 buildCounterFileIndexableText++;

1061 if (buildCounterFileIndexableText < 3) {

1062 unittest.expect(o.text, unittest.equals('foo'));

1063 }

1064 buildCounterFileIndexableText--;

1065 }

1066

1067 core.int buildCounterFileLabels = 0;

1068 buildFileLabels() {

1069 var o = new api.FileLabels();

1070 buildCounterFileLabels++;

1071 if (buildCounterFileLabels < 3) {

1072 o.hidden = true;

1073 o.restricted = true;

1074 o.starred = true;

1075 o.trashed = true;

1076 o.viewed = true;

1077 }

1078 buildCounterFileLabels--;

1079 return o;

1080 }

1081

1082 checkFileLabels(api.FileLabels o) {

1083 buildCounterFileLabels++;

1084 if (buildCounterFileLabels < 3) {

1085 unittest.expect(o.hidden, unittest.isTrue);

1086 unittest.expect(o.restricted, unittest.isTrue);

1087 unittest.expect(o.starred, unittest.isTrue);

1088 unittest.expect(o.trashed, unittest.isTrue);

1089 unittest.expect(o.viewed, unittest.isTrue);

1090 }

1091 buildCounterFileLabels--;

1092 }

1093

1094 buildUnnamed418() {

1095 var o = new core.Map<core.String, core.String>();

1096 o["x"] = "foo";

1097 o["y"] = "foo";

1098 return o;

1099 }

1100

1101 checkUnnamed418(core.Map<core.String, core.String> o) {

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

1103 unittest.expect(o["x"], unittest.equals('foo'));

1104 unittest.expect(o["y"], unittest.equals('foo'));

1105 }

1106

1107 buildUnnamed419() {

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

1109 o.add("foo");

1110 o.add("foo");

1111 return o;

1112 }

1113

1114 checkUnnamed419(core.List<core.String> o) {

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

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

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

1118 }

1119

1120 buildUnnamed420() {

1121 var o = new core.List<api.User>();

1122 o.add(buildUser());

1123 o.add(buildUser());

1124 return o;

1125 }

1126

1127 checkUnnamed420(core.List<api.User> o) {

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

1129 checkUser(o[0]);

1130 checkUser(o[1]);

1131 }

1132

1133 buildUnnamed421() {

1134 var o = new core.List<api.ParentReference>();

1135 o.add(buildParentReference());

1136 o.add(buildParentReference());

1137 return o;

1138 }

1139

1140 checkUnnamed421(core.List<api.ParentReference> o) {

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

1142 checkParentReference(o[0]);

1143 checkParentReference(o[1]);

1144 }

1145

1146 buildUnnamed422() {

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

1148 o.add(buildPermission());

1149 o.add(buildPermission());

1150 return o;

1151 }

1152

1153 checkUnnamed422(core.List<api.Permission> o) {

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

1155 checkPermission(o[0]);

1156 checkPermission(o[1]);

1157 }

1158

1159 buildUnnamed423() {

1160 var o = new core.List<api.Property>();

1161 o.add(buildProperty());

1162 o.add(buildProperty());

1163 return o;

1164 }

1165

1166 checkUnnamed423(core.List<api.Property> o) {

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

1168 checkProperty(o[0]);

1169 checkProperty(o[1]);

1170 }

1171

1172 core.int buildCounterFileThumbnail = 0;

1173 buildFileThumbnail() {

1174 var o = new api.FileThumbnail();

1175 buildCounterFileThumbnail++;

1176 if (buildCounterFileThumbnail < 3) {

1177 o.image = "foo";

1178 o.mimeType = "foo";

1179 }

1180 buildCounterFileThumbnail--;

1181 return o;

1182 }

1183

1184 checkFileThumbnail(api.FileThumbnail o) {

1185 buildCounterFileThumbnail++;

1186 if (buildCounterFileThumbnail < 3) {

1187 unittest.expect(o.image, unittest.equals('foo'));

1188 unittest.expect(o.mimeType, unittest.equals('foo'));

1189 }

1190 buildCounterFileThumbnail--;

1191 }

1192

1193 core.int buildCounterFile = 0;

1194 buildFile() {

1195 var o = new api.File();

1196 buildCounterFile++;

1197 if (buildCounterFile < 3) {

1198 o.alternateLink = "foo";

1199 o.appDataContents = true;

1200 o.copyable = true;

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

1202 o.defaultOpenWithLink = "foo";

1203 o.description = "foo";

1204 o.downloadUrl = "foo";

1205 o.editable = true;

1206 o.embedLink = "foo";

1207 o.etag = "foo";

1208 o.explicitlyTrashed = true;

1209 o.exportLinks = buildUnnamed417();

1210 o.fileExtension = "foo";

1211 o.fileSize = "foo";

1212 o.headRevisionId = "foo";

1213 o.iconLink = "foo";

1214 o.id = "foo";

1215 o.imageMediaMetadata = buildFileImageMediaMetadata();

1216 o.indexableText = buildFileIndexableText();

1217 o.kind = "foo";

1218 o.labels = buildFileLabels();

1219 o.lastModifyingUser = buildUser();

1220 o.lastModifyingUserName = "foo";

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

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

1223 o.md5Checksum = "foo";

1224 o.mimeType = "foo";

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

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

1227 o.openWithLinks = buildUnnamed418();

1228 o.originalFilename = "foo";

1229 o.ownerNames = buildUnnamed419();

1230 o.owners = buildUnnamed420();

1231 o.parents = buildUnnamed421();

1232 o.permissions = buildUnnamed422();

1233 o.properties = buildUnnamed423();

1234 o.quotaBytesUsed = "foo";

1235 o.selfLink = "foo";

1236 o.shared = true;

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

1238 o.sharingUser = buildUser();

1239 o.thumbnail = buildFileThumbnail();

1240 o.thumbnailLink = "foo";

1241 o.title = "foo";

1242 o.userPermission = buildPermission();

1243 o.version = "foo";

1244 o.webContentLink = "foo";

1245 o.webViewLink = "foo";

1246 o.writersCanShare = true;

1247 }

1248 buildCounterFile--;

1249 return o;

1250 }

1251

1252 checkFile(api.File o) {

1253 buildCounterFile++;

1254 if (buildCounterFile < 3) {

1255 unittest.expect(o.alternateLink, unittest.equals('foo'));

1256 unittest.expect(o.appDataContents, unittest.isTrue);

1257 unittest.expect(o.copyable, unittest.isTrue);

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

1259 unittest.expect(o.defaultOpenWithLink, unittest.equals('foo'));

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

1261 unittest.expect(o.downloadUrl, unittest.equals('foo'));

1262 unittest.expect(o.editable, unittest.isTrue);

1263 unittest.expect(o.embedLink, unittest.equals('foo'));

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

1265 unittest.expect(o.explicitlyTrashed, unittest.isTrue);

1266 checkUnnamed417(o.exportLinks);

1267 unittest.expect(o.fileExtension, unittest.equals('foo'));

1268 unittest.expect(o.fileSize, unittest.equals('foo'));

1269 unittest.expect(o.headRevisionId, unittest.equals('foo'));

1270 unittest.expect(o.iconLink, unittest.equals('foo'));

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

1272 checkFileImageMediaMetadata(o.imageMediaMetadata);

1273 checkFileIndexableText(o.indexableText);

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

1275 checkFileLabels(o.labels);

1276 checkUser(o.lastModifyingUser);

1277 unittest.expect(o.lastModifyingUserName, unittest.equals('foo'));

1278 unittest.expect(o.lastViewedByMeDate, unittest.equals(core.DateTime.parse("2 002-02-27T14:01:02")));

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

1280 unittest.expect(o.md5Checksum, unittest.equals('foo'));

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

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

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

1284 checkUnnamed418(o.openWithLinks);

1285 unittest.expect(o.originalFilename, unittest.equals('foo'));

1286 checkUnnamed419(o.ownerNames);

1287 checkUnnamed420(o.owners);

1288 checkUnnamed421(o.parents);

1289 checkUnnamed422(o.permissions);

1290 checkUnnamed423(o.properties);

1291 unittest.expect(o.quotaBytesUsed, unittest.equals('foo'));

1292 unittest.expect(o.selfLink, unittest.equals('foo'));

1293 unittest.expect(o.shared, unittest.isTrue);

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

1295 checkUser(o.sharingUser);

1296 checkFileThumbnail(o.thumbnail);

1297 unittest.expect(o.thumbnailLink, unittest.equals('foo'));

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

1299 checkPermission(o.userPermission);

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

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

1302 unittest.expect(o.webViewLink, unittest.equals('foo'));

1303 unittest.expect(o.writersCanShare, unittest.isTrue);

1304 }

1305 buildCounterFile--;

1306 }

1307

1308 buildUnnamed424() {

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

1310 o.add(buildFile());

1311 o.add(buildFile());

1312 return o;

1313 }

1314

1315 checkUnnamed424(core.List<api.File> o) {

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

1317 checkFile(o[0]);

1318 checkFile(o[1]);

1319 }

1320

1321 core.int buildCounterFileList = 0;

1322 buildFileList() {

1323 var o = new api.FileList();

1324 buildCounterFileList++;

1325 if (buildCounterFileList < 3) {

1326 o.etag = "foo";

1327 o.items = buildUnnamed424();

1328 o.kind = "foo";

1329 o.nextLink = "foo";

1330 o.nextPageToken = "foo";

1331 o.selfLink = "foo";

1332 }

1333 buildCounterFileList--;

1334 return o;

1335 }

1336

1337 checkFileList(api.FileList o) {

1338 buildCounterFileList++;

1339 if (buildCounterFileList < 3) {

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

1341 checkUnnamed424(o.items);

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

1343 unittest.expect(o.nextLink, unittest.equals('foo'));

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

1345 unittest.expect(o.selfLink, unittest.equals('foo'));

1346 }

1347 buildCounterFileList--;

1348 }

1349

1350 buildUnnamed425() {

1351 var o = new core.List<api.ParentReference>();

1352 o.add(buildParentReference());

1353 o.add(buildParentReference());

1354 return o;

1355 }

1356

1357 checkUnnamed425(core.List<api.ParentReference> o) {

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

1359 checkParentReference(o[0]);

1360 checkParentReference(o[1]);

1361 }

1362

1363 core.int buildCounterParentList = 0;

1364 buildParentList() {

1365 var o = new api.ParentList();

1366 buildCounterParentList++;

1367 if (buildCounterParentList < 3) {

1368 o.etag = "foo";

1369 o.items = buildUnnamed425();

1370 o.kind = "foo";

1371 o.selfLink = "foo";

1372 }

1373 buildCounterParentList--;

1374 return o;

1375 }

1376

1377 checkParentList(api.ParentList o) {

1378 buildCounterParentList++;

1379 if (buildCounterParentList < 3) {

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

1381 checkUnnamed425(o.items);

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

1383 unittest.expect(o.selfLink, unittest.equals('foo'));

1384 }

1385 buildCounterParentList--;

1386 }

1387

1388 core.int buildCounterParentReference = 0;

1389 buildParentReference() {

1390 var o = new api.ParentReference();

1391 buildCounterParentReference++;

1392 if (buildCounterParentReference < 3) {

1393 o.id = "foo";

1394 o.isRoot = true;

1395 o.kind = "foo";

1396 o.parentLink = "foo";

1397 o.selfLink = "foo";

1398 }

1399 buildCounterParentReference--;

1400 return o;

1401 }

1402

1403 checkParentReference(api.ParentReference o) {

1404 buildCounterParentReference++;

1405 if (buildCounterParentReference < 3) {

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

1407 unittest.expect(o.isRoot, unittest.isTrue);

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

1409 unittest.expect(o.parentLink, unittest.equals('foo'));

1410 unittest.expect(o.selfLink, unittest.equals('foo'));

1411 }

1412 buildCounterParentReference--;

1413 }

1414

1415 buildUnnamed426() {

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

1417 o.add("foo");

1418 o.add("foo");

1419 return o;

1420 }

1421

1422 checkUnnamed426(core.List<core.String> o) {

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

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

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

1426 }

1427

1428 core.int buildCounterPermission = 0;

1429 buildPermission() {

1430 var o = new api.Permission();

1431 buildCounterPermission++;

1432 if (buildCounterPermission < 3) {

1433 o.additionalRoles = buildUnnamed426();

1434 o.authKey = "foo";

1435 o.domain = "foo";

1436 o.emailAddress = "foo";

1437 o.etag = "foo";

1438 o.id = "foo";

1439 o.kind = "foo";

1440 o.name = "foo";

1441 o.photoLink = "foo";

1442 o.role = "foo";

1443 o.selfLink = "foo";

1444 o.type = "foo";

1445 o.value = "foo";

1446 o.withLink = true;

1447 }

1448 buildCounterPermission--;

1449 return o;

1450 }

1451

1452 checkPermission(api.Permission o) {

1453 buildCounterPermission++;

1454 if (buildCounterPermission < 3) {

1455 checkUnnamed426(o.additionalRoles);

1456 unittest.expect(o.authKey, unittest.equals('foo'));

1457 unittest.expect(o.domain, unittest.equals('foo'));

1458 unittest.expect(o.emailAddress, unittest.equals('foo'));

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

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

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

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

1463 unittest.expect(o.photoLink, unittest.equals('foo'));

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

1465 unittest.expect(o.selfLink, unittest.equals('foo'));

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

1467 unittest.expect(o.value, unittest.equals('foo'));

1468 unittest.expect(o.withLink, unittest.isTrue);

1469 }

1470 buildCounterPermission--;

1471 }

1472

1473 core.int buildCounterPermissionId = 0;

1474 buildPermissionId() {

1475 var o = new api.PermissionId();

1476 buildCounterPermissionId++;

1477 if (buildCounterPermissionId < 3) {

1478 o.id = "foo";

1479 o.kind = "foo";

1480 }

1481 buildCounterPermissionId--;

1482 return o;

1483 }

1484

1485 checkPermissionId(api.PermissionId o) {

1486 buildCounterPermissionId++;

1487 if (buildCounterPermissionId < 3) {

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

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

1490 }

1491 buildCounterPermissionId--;

1492 }

1493

1494 buildUnnamed427() {

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

1496 o.add(buildPermission());

1497 o.add(buildPermission());

1498 return o;

1499 }

1500

1501 checkUnnamed427(core.List<api.Permission> o) {

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

1503 checkPermission(o[0]);

1504 checkPermission(o[1]);

1505 }

1506

1507 core.int buildCounterPermissionList = 0;

1508 buildPermissionList() {

1509 var o = new api.PermissionList();

1510 buildCounterPermissionList++;

1511 if (buildCounterPermissionList < 3) {

1512 o.etag = "foo";

1513 o.items = buildUnnamed427();

1514 o.kind = "foo";

1515 o.selfLink = "foo";

1516 }

1517 buildCounterPermissionList--;

1518 return o;

1519 }

1520

1521 checkPermissionList(api.PermissionList o) {

1522 buildCounterPermissionList++;

1523 if (buildCounterPermissionList < 3) {

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

1525 checkUnnamed427(o.items);

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

1527 unittest.expect(o.selfLink, unittest.equals('foo'));

1528 }

1529 buildCounterPermissionList--;

1530 }

1531

1532 core.int buildCounterProperty = 0;

1533 buildProperty() {

1534 var o = new api.Property();

1535 buildCounterProperty++;

1536 if (buildCounterProperty < 3) {

1537 o.etag = "foo";

1538 o.key = "foo";

1539 o.kind = "foo";

1540 o.selfLink = "foo";

1541 o.value = "foo";

1542 o.visibility = "foo";

1543 }

1544 buildCounterProperty--;

1545 return o;

1546 }

1547

1548 checkProperty(api.Property o) {

1549 buildCounterProperty++;

1550 if (buildCounterProperty < 3) {

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

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

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

1554 unittest.expect(o.selfLink, unittest.equals('foo'));

1555 unittest.expect(o.value, unittest.equals('foo'));

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

1557 }

1558 buildCounterProperty--;

1559 }

1560

1561 buildUnnamed428() {

1562 var o = new core.List<api.Property>();

1563 o.add(buildProperty());

1564 o.add(buildProperty());

1565 return o;

1566 }

1567

1568 checkUnnamed428(core.List<api.Property> o) {

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

1570 checkProperty(o[0]);

1571 checkProperty(o[1]);

1572 }

1573

1574 core.int buildCounterPropertyList = 0;

1575 buildPropertyList() {

1576 var o = new api.PropertyList();

1577 buildCounterPropertyList++;

1578 if (buildCounterPropertyList < 3) {

1579 o.etag = "foo";

1580 o.items = buildUnnamed428();

1581 o.kind = "foo";

1582 o.selfLink = "foo";

1583 }

1584 buildCounterPropertyList--;

1585 return o;

1586 }

1587

1588 checkPropertyList(api.PropertyList o) {

1589 buildCounterPropertyList++;

1590 if (buildCounterPropertyList < 3) {

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

1592 checkUnnamed428(o.items);

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

1594 unittest.expect(o.selfLink, unittest.equals('foo'));

1595 }

1596 buildCounterPropertyList--;

1597 }

1598

1599 buildUnnamed429() {

1600 var o = new core.Map<core.String, core.String>();

1601 o["x"] = "foo";

1602 o["y"] = "foo";

1603 return o;

1604 }

1605

1606 checkUnnamed429(core.Map<core.String, core.String> o) {

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

1608 unittest.expect(o["x"], unittest.equals('foo'));

1609 unittest.expect(o["y"], unittest.equals('foo'));

1610 }

1611

1612 core.int buildCounterRevision = 0;

1613 buildRevision() {

1614 var o = new api.Revision();

1615 buildCounterRevision++;

1616 if (buildCounterRevision < 3) {

1617 o.downloadUrl = "foo";

1618 o.etag = "foo";

1619 o.exportLinks = buildUnnamed429();

1620 o.fileSize = "foo";

1621 o.id = "foo";

1622 o.kind = "foo";

1623 o.lastModifyingUser = buildUser();

1624 o.lastModifyingUserName = "foo";

1625 o.md5Checksum = "foo";

1626 o.mimeType = "foo";

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

1628 o.originalFilename = "foo";

1629 o.pinned = true;

1630 o.publishAuto = true;

1631 o.published = true;

1632 o.publishedLink = "foo";

1633 o.publishedOutsideDomain = true;

1634 o.selfLink = "foo";

1635 }

1636 buildCounterRevision--;

1637 return o;

1638 }

1639

1640 checkRevision(api.Revision o) {

1641 buildCounterRevision++;

1642 if (buildCounterRevision < 3) {

1643 unittest.expect(o.downloadUrl, unittest.equals('foo'));

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

1645 checkUnnamed429(o.exportLinks);

1646 unittest.expect(o.fileSize, unittest.equals('foo'));

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

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

1649 checkUser(o.lastModifyingUser);

1650 unittest.expect(o.lastModifyingUserName, unittest.equals('foo'));

1651 unittest.expect(o.md5Checksum, unittest.equals('foo'));

1652 unittest.expect(o.mimeType, unittest.equals('foo'));

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

1654 unittest.expect(o.originalFilename, unittest.equals('foo'));

1655 unittest.expect(o.pinned, unittest.isTrue);

1656 unittest.expect(o.publishAuto, unittest.isTrue);

1657 unittest.expect(o.published, unittest.isTrue);

1658 unittest.expect(o.publishedLink, unittest.equals('foo'));

1659 unittest.expect(o.publishedOutsideDomain, unittest.isTrue);

1660 unittest.expect(o.selfLink, unittest.equals('foo'));

1661 }

1662 buildCounterRevision--;

1663 }

1664

1665 buildUnnamed430() {

1666 var o = new core.List<api.Revision>();

1667 o.add(buildRevision());

1668 o.add(buildRevision());

1669 return o;

1670 }

1671

1672 checkUnnamed430(core.List<api.Revision> o) {

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

1674 checkRevision(o[0]);

1675 checkRevision(o[1]);

1676 }

1677

1678 core.int buildCounterRevisionList = 0;

1679 buildRevisionList() {

1680 var o = new api.RevisionList();

1681 buildCounterRevisionList++;

1682 if (buildCounterRevisionList < 3) {

1683 o.etag = "foo";

1684 o.items = buildUnnamed430();

1685 o.kind = "foo";

1686 o.selfLink = "foo";

1687 }

1688 buildCounterRevisionList--;

1689 return o;

1690 }

1691

1692 checkRevisionList(api.RevisionList o) {

1693 buildCounterRevisionList++;

1694 if (buildCounterRevisionList < 3) {

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

1696 checkUnnamed430(o.items);

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

1698 unittest.expect(o.selfLink, unittest.equals('foo'));

1699 }

1700 buildCounterRevisionList--;

1701 }

1702

1703 core.int buildCounterUserPicture = 0;

1704 buildUserPicture() {

1705 var o = new api.UserPicture();

1706 buildCounterUserPicture++;

1707 if (buildCounterUserPicture < 3) {

1708 o.url = "foo";

1709 }

1710 buildCounterUserPicture--;

1711 return o;

1712 }

1713

1714 checkUserPicture(api.UserPicture o) {

1715 buildCounterUserPicture++;

1716 if (buildCounterUserPicture < 3) {

1717 unittest.expect(o.url, unittest.equals('foo'));

1718 }

1719 buildCounterUserPicture--;

1720 }

1721

1722 core.int buildCounterUser = 0;

1723 buildUser() {

1724 var o = new api.User();

1725 buildCounterUser++;

1726 if (buildCounterUser < 3) {

1727 o.displayName = "foo";

1728 o.emailAddress = "foo";

1729 o.isAuthenticatedUser = true;

1730 o.kind = "foo";

1731 o.permissionId = "foo";

1732 o.picture = buildUserPicture();

1733 }

1734 buildCounterUser--;

1735 return o;

1736 }

1737

1738 checkUser(api.User o) {

1739 buildCounterUser++;

1740 if (buildCounterUser < 3) {

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

1742 unittest.expect(o.emailAddress, unittest.equals('foo'));

1743 unittest.expect(o.isAuthenticatedUser, unittest.isTrue);

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

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

1746 checkUserPicture(o.picture);

1747 }

1748 buildCounterUser--;

1749 }

1750

1751

1752 main() {

1753 unittest.group("obj-schema-AboutAdditionalRoleInfoRoleSets", () {

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

1755 var o = buildAboutAdditionalRoleInfoRoleSets();

1756 var od = new api.AboutAdditionalRoleInfoRoleSets.fromJson(o.toJson());

1757 checkAboutAdditionalRoleInfoRoleSets(od);

1758 });

1759 });

1760

1761

1762 unittest.group("obj-schema-AboutAdditionalRoleInfo", () {

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

1764 var o = buildAboutAdditionalRoleInfo();

1765 var od = new api.AboutAdditionalRoleInfo.fromJson(o.toJson());

1766 checkAboutAdditionalRoleInfo(od);

1767 });

1768 });

1769

1770

1771 unittest.group("obj-schema-AboutExportFormats", () {

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

1773 var o = buildAboutExportFormats();

1774 var od = new api.AboutExportFormats.fromJson(o.toJson());

1775 checkAboutExportFormats(od);

1776 });

1777 });

1778

1779

1780 unittest.group("obj-schema-AboutFeatures", () {

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

1782 var o = buildAboutFeatures();

1783 var od = new api.AboutFeatures.fromJson(o.toJson());

1784 checkAboutFeatures(od);

1785 });

1786 });

1787

1788

1789 unittest.group("obj-schema-AboutImportFormats", () {

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

1791 var o = buildAboutImportFormats();

1792 var od = new api.AboutImportFormats.fromJson(o.toJson());

1793 checkAboutImportFormats(od);

1794 });

1795 });

1796

1797

1798 unittest.group("obj-schema-AboutMaxUploadSizes", () {

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

1800 var o = buildAboutMaxUploadSizes();

1801 var od = new api.AboutMaxUploadSizes.fromJson(o.toJson());

1802 checkAboutMaxUploadSizes(od);

1803 });

1804 });

1805

1806

1807 unittest.group("obj-schema-AboutQuotaBytesByService", () {

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

1809 var o = buildAboutQuotaBytesByService();

1810 var od = new api.AboutQuotaBytesByService.fromJson(o.toJson());

1811 checkAboutQuotaBytesByService(od);

1812 });

1813 });

1814

1815

1816 unittest.group("obj-schema-About", () {

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

1818 var o = buildAbout();

1819 var od = new api.About.fromJson(o.toJson());

1820 checkAbout(od);

1821 });

1822 });

1823

1824

1825 unittest.group("obj-schema-AppIcons", () {

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

1827 var o = buildAppIcons();

1828 var od = new api.AppIcons.fromJson(o.toJson());

1829 checkAppIcons(od);

1830 });

1831 });

1832

1833

1834 unittest.group("obj-schema-App", () {

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

1836 var o = buildApp();

1837 var od = new api.App.fromJson(o.toJson());

1838 checkApp(od);

1839 });

1840 });

1841

1842

1843 unittest.group("obj-schema-AppList", () {

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

1845 var o = buildAppList();

1846 var od = new api.AppList.fromJson(o.toJson());

1847 checkAppList(od);

1848 });

1849 });

1850

1851

1852 unittest.group("obj-schema-Change", () {

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

1854 var o = buildChange();

1855 var od = new api.Change.fromJson(o.toJson());

1856 checkChange(od);

1857 });

1858 });

1859

1860

1861 unittest.group("obj-schema-ChangeList", () {

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

1863 var o = buildChangeList();

1864 var od = new api.ChangeList.fromJson(o.toJson());

1865 checkChangeList(od);

1866 });

1867 });

1868

1869

1870 unittest.group("obj-schema-Channel", () {

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

1872 var o = buildChannel();

1873 var od = new api.Channel.fromJson(o.toJson());

1874 checkChannel(od);

1875 });

1876 });

1877

1878

1879 unittest.group("obj-schema-ChildList", () {

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

1881 var o = buildChildList();

1882 var od = new api.ChildList.fromJson(o.toJson());

1883 checkChildList(od);

1884 });

1885 });

1886

1887

1888 unittest.group("obj-schema-ChildReference", () {

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

1890 var o = buildChildReference();

1891 var od = new api.ChildReference.fromJson(o.toJson());

1892 checkChildReference(od);

1893 });

1894 });

1895

1896

1897 unittest.group("obj-schema-CommentContext", () {

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

1899 var o = buildCommentContext();

1900 var od = new api.CommentContext.fromJson(o.toJson());

1901 checkCommentContext(od);

1902 });

1903 });

1904

1905

1906 unittest.group("obj-schema-Comment", () {

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

1908 var o = buildComment();

1909 var od = new api.Comment.fromJson(o.toJson());

1910 checkComment(od);

1911 });

1912 });

1913

1914

1915 unittest.group("obj-schema-CommentList", () {

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

1917 var o = buildCommentList();

1918 var od = new api.CommentList.fromJson(o.toJson());

1919 checkCommentList(od);

1920 });

1921 });

1922

1923

1924 unittest.group("obj-schema-CommentReply", () {

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

1926 var o = buildCommentReply();

1927 var od = new api.CommentReply.fromJson(o.toJson());

1928 checkCommentReply(od);

1929 });

1930 });

1931

1932

1933 unittest.group("obj-schema-CommentReplyList", () {

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

1935 var o = buildCommentReplyList();

1936 var od = new api.CommentReplyList.fromJson(o.toJson());

1937 checkCommentReplyList(od);

1938 });

1939 });

1940

1941

1942 unittest.group("obj-schema-FileImageMediaMetadataLocation", () {

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

1944 var o = buildFileImageMediaMetadataLocation();

1945 var od = new api.FileImageMediaMetadataLocation.fromJson(o.toJson());

1946 checkFileImageMediaMetadataLocation(od);

1947 });

1948 });

1949

1950

1951 unittest.group("obj-schema-FileImageMediaMetadata", () {

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

1953 var o = buildFileImageMediaMetadata();

1954 var od = new api.FileImageMediaMetadata.fromJson(o.toJson());

1955 checkFileImageMediaMetadata(od);

1956 });

1957 });

1958

1959

1960 unittest.group("obj-schema-FileIndexableText", () {

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

1962 var o = buildFileIndexableText();

1963 var od = new api.FileIndexableText.fromJson(o.toJson());

1964 checkFileIndexableText(od);

1965 });

1966 });

1967

1968

1969 unittest.group("obj-schema-FileLabels", () {

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

1971 var o = buildFileLabels();

1972 var od = new api.FileLabels.fromJson(o.toJson());

1973 checkFileLabels(od);

1974 });

1975 });

1976

1977

1978 unittest.group("obj-schema-FileThumbnail", () {

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

1980 var o = buildFileThumbnail();

1981 var od = new api.FileThumbnail.fromJson(o.toJson());

1982 checkFileThumbnail(od);

1983 });

1984 });

1985

1986

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

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

1989 var o = buildFile();

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

1991 checkFile(od);

1992 });

1993 });

1994

1995

1996 unittest.group("obj-schema-FileList", () {

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

1998 var o = buildFileList();

1999 var od = new api.FileList.fromJson(o.toJson());

2000 checkFileList(od);

2001 });

2002 });

2003

2004

2005 unittest.group("obj-schema-ParentList", () {

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

2007 var o = buildParentList();

2008 var od = new api.ParentList.fromJson(o.toJson());

2009 checkParentList(od);

2010 });

2011 });

2012

2013

2014 unittest.group("obj-schema-ParentReference", () {

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

2016 var o = buildParentReference();

2017 var od = new api.ParentReference.fromJson(o.toJson());

2018 checkParentReference(od);

2019 });

2020 });

2021

2022

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

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

2025 var o = buildPermission();

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

2027 checkPermission(od);

2028 });

2029 });

2030

2031

2032 unittest.group("obj-schema-PermissionId", () {

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

2034 var o = buildPermissionId();

2035 var od = new api.PermissionId.fromJson(o.toJson());

2036 checkPermissionId(od);

2037 });

2038 });

2039

2040

2041 unittest.group("obj-schema-PermissionList", () {

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

2043 var o = buildPermissionList();

2044 var od = new api.PermissionList.fromJson(o.toJson());

2045 checkPermissionList(od);

2046 });

2047 });

2048

2049

2050 unittest.group("obj-schema-Property", () {

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

2052 var o = buildProperty();

2053 var od = new api.Property.fromJson(o.toJson());

2054 checkProperty(od);

2055 });

2056 });

2057

2058

2059 unittest.group("obj-schema-PropertyList", () {

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

2061 var o = buildPropertyList();

2062 var od = new api.PropertyList.fromJson(o.toJson());

2063 checkPropertyList(od);

2064 });

2065 });

2066

2067

2068 unittest.group("obj-schema-Revision", () {

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

2070 var o = buildRevision();

2071 var od = new api.Revision.fromJson(o.toJson());

2072 checkRevision(od);

2073 });

2074 });

2075

2076

2077 unittest.group("obj-schema-RevisionList", () {

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

2079 var o = buildRevisionList();

2080 var od = new api.RevisionList.fromJson(o.toJson());

2081 checkRevisionList(od);

2082 });

2083 });

2084

2085

2086 unittest.group("obj-schema-UserPicture", () {

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

2088 var o = buildUserPicture();

2089 var od = new api.UserPicture.fromJson(o.toJson());

2090 checkUserPicture(od);

2091 });

2092 });

2093

2094

2095 unittest.group("obj-schema-User", () {

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

2097 var o = buildUser();

2098 var od = new api.User.fromJson(o.toJson());

2099 checkUser(od);

2100 });

2101 });

2102

2103

2104 unittest.group("resource-AboutResourceApi", () {

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

2106

2107 var mock = new common_test.HttpServerMock();

2108 api.AboutResourceApi res = new api.DriveApi(mock).about;

2109 var arg_includeSubscribed = true;

2110 var arg_maxChangeIdCount = "foo";

2111 var arg_startChangeId = "foo";

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

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

2114 var pathOffset = 0;

2115 var index;

2116 var subPart;

2117 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2118 pathOffset += 10;

2119 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("about"));

2120 pathOffset += 5;

2121

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

2123 var queryOffset = 0;

2124 var queryMap = {};

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

2126 parseBool(n) {

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

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

2129 if (n == null) return null;

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

2131 }

2132 if (query.length > 0) {

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

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

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

2136 }

2137 }

2138 unittest.expect(queryMap["includeSubscribed"].first, unittest.equals("$a rg_includeSubscribed"));

2139 unittest.expect(queryMap["maxChangeIdCount"].first, unittest.equals(arg_ maxChangeIdCount));

2140 unittest.expect(queryMap["startChangeId"].first, unittest.equals(arg_sta rtChangeId));

2141

2142

2143 var h = {

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

2145 };

2146 var resp = convert.JSON.encode(buildAbout());

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

2148 }), true);

2149 res.get(includeSubscribed: arg_includeSubscribed, maxChangeIdCount: arg_ma xChangeIdCount, startChangeId: arg_startChangeId).then(unittest.expectAsync(((ap i.About response) {

2150 checkAbout(response);

2151 })));

2152 });

2153

2154 });

2155

2156

2157 unittest.group("resource-AppsResourceApi", () {

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

2159

2160 var mock = new common_test.HttpServerMock();

2161 api.AppsResourceApi res = new api.DriveApi(mock).apps;

2162 var arg_appId = "foo";

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

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

2165 var pathOffset = 0;

2166 var index;

2167 var subPart;

2168 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2169 pathOffset += 10;

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

2171 pathOffset += 5;

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

2173 pathOffset = path.length;

2174 unittest.expect(subPart, unittest.equals("$arg_appId"));

2175

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

2177 var queryOffset = 0;

2178 var queryMap = {};

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

2180 parseBool(n) {

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

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

2183 if (n == null) return null;

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

2185 }

2186 if (query.length > 0) {

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

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

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

2190 }

2191 }

2192

2193

2194 var h = {

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

2196 };

2197 var resp = convert.JSON.encode(buildApp());

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

2199 }), true);

2200 res.get(arg_appId).then(unittest.expectAsync(((api.App response) {

2201 checkApp(response);

2202 })));

2203 });

2204

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

2206

2207 var mock = new common_test.HttpServerMock();

2208 api.AppsResourceApi res = new api.DriveApi(mock).apps;

2209 var arg_appFilterExtensions = "foo";

2210 var arg_appFilterMimeTypes = "foo";

2211 var arg_languageCode = "foo";

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

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

2214 var pathOffset = 0;

2215 var index;

2216 var subPart;

2217 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2218 pathOffset += 10;

2219 unittest.expect(path.substring(pathOffset, pathOffset + 4), unittest.equ als("apps"));

2220 pathOffset += 4;

2221

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

2223 var queryOffset = 0;

2224 var queryMap = {};

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

2226 parseBool(n) {

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

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

2229 if (n == null) return null;

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

2231 }

2232 if (query.length > 0) {

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

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

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

2236 }

2237 }

2238 unittest.expect(queryMap["appFilterExtensions"].first, unittest.equals(a rg_appFilterExtensions));

2239 unittest.expect(queryMap["appFilterMimeTypes"].first, unittest.equals(ar g_appFilterMimeTypes));

2240 unittest.expect(queryMap["languageCode"].first, unittest.equals(arg_lang uageCode));

2241

2242

2243 var h = {

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

2245 };

2246 var resp = convert.JSON.encode(buildAppList());

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

2248 }), true);

2249 res.list(appFilterExtensions: arg_appFilterExtensions, appFilterMimeTypes: arg_appFilterMimeTypes, languageCode: arg_languageCode).then(unittest.expectAsy nc(((api.AppList response) {

2250 checkAppList(response);

2251 })));

2252 });

2253

2254 });

2255

2256

2257 unittest.group("resource-ChangesResourceApi", () {

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

2259

2260 var mock = new common_test.HttpServerMock();

2261 api.ChangesResourceApi res = new api.DriveApi(mock).changes;

2262 var arg_changeId = "foo";

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

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

2265 var pathOffset = 0;

2266 var index;

2267 var subPart;

2268 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2269 pathOffset += 10;

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

2271 pathOffset += 8;

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

2273 pathOffset = path.length;

2274 unittest.expect(subPart, unittest.equals("$arg_changeId"));

2275

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

2277 var queryOffset = 0;

2278 var queryMap = {};

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

2280 parseBool(n) {

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

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

2283 if (n == null) return null;

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

2285 }

2286 if (query.length > 0) {

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

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

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

2290 }

2291 }

2292

2293

2294 var h = {

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

2296 };

2297 var resp = convert.JSON.encode(buildChange());

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

2299 }), true);

2300 res.get(arg_changeId).then(unittest.expectAsync(((api.Change response) {

2301 checkChange(response);

2302 })));

2303 });

2304

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

2306

2307 var mock = new common_test.HttpServerMock();

2308 api.ChangesResourceApi res = new api.DriveApi(mock).changes;

2309 var arg_includeDeleted = true;

2310 var arg_includeSubscribed = true;

2311 var arg_maxResults = 42;

2312 var arg_pageToken = "foo";

2313 var arg_startChangeId = "foo";

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

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

2316 var pathOffset = 0;

2317 var index;

2318 var subPart;

2319 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2320 pathOffset += 10;

2321 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("changes"));

2322 pathOffset += 7;

2323

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

2325 var queryOffset = 0;

2326 var queryMap = {};

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

2328 parseBool(n) {

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

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

2331 if (n == null) return null;

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

2333 }

2334 if (query.length > 0) {

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

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

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

2338 }

2339 }

2340 unittest.expect(queryMap["includeDeleted"].first, unittest.equals("$arg_ includeDeleted"));

2341 unittest.expect(queryMap["includeSubscribed"].first, unittest.equals("$a rg_includeSubscribed"));

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

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

2344 unittest.expect(queryMap["startChangeId"].first, unittest.equals(arg_sta rtChangeId));

2345

2346

2347 var h = {

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

2349 };

2350 var resp = convert.JSON.encode(buildChangeList());

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

2352 }), true);

2353 res.list(includeDeleted: arg_includeDeleted, includeSubscribed: arg_includ eSubscribed, maxResults: arg_maxResults, pageToken: arg_pageToken, startChangeId : arg_startChangeId).then(unittest.expectAsync(((api.ChangeList response) {

2354 checkChangeList(response);

2355 })));

2356 });

2357

2358 unittest.test("method--watch", () {

2359

2360 var mock = new common_test.HttpServerMock();

2361 api.ChangesResourceApi res = new api.DriveApi(mock).changes;

2362 var arg_request = buildChannel();

2363 var arg_includeDeleted = true;

2364 var arg_includeSubscribed = true;

2365 var arg_maxResults = 42;

2366 var arg_pageToken = "foo";

2367 var arg_startChangeId = "foo";

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

2369 var obj = new api.Channel.fromJson(json);

2370 checkChannel(obj);

2371

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

2373 var pathOffset = 0;

2374 var index;

2375 var subPart;

2376 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2377 pathOffset += 10;

2378 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("changes/watch"));

2379 pathOffset += 13;

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 unittest.expect(queryMap["includeDeleted"].first, unittest.equals("$arg_ includeDeleted"));

2398 unittest.expect(queryMap["includeSubscribed"].first, unittest.equals("$a rg_includeSubscribed"));

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

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

2401 unittest.expect(queryMap["startChangeId"].first, unittest.equals(arg_sta rtChangeId));

2402

2403

2404 var h = {

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

2406 };

2407 var resp = convert.JSON.encode(buildChannel());

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

2409 }), true);

2410 res.watch(arg_request, includeDeleted: arg_includeDeleted, includeSubscrib ed: arg_includeSubscribed, maxResults: arg_maxResults, pageToken: arg_pageToken, startChangeId: arg_startChangeId).then(unittest.expectAsync(((api.Channel respo nse) {

2411 checkChannel(response);

2412 })));

2413 });

2414

2415 });

2416

2417

2418 unittest.group("resource-ChannelsResourceApi", () {

2419 unittest.test("method--stop", () {

2420

2421 var mock = new common_test.HttpServerMock();

2422 api.ChannelsResourceApi res = new api.DriveApi(mock).channels;

2423 var arg_request = buildChannel();

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

2425 var obj = new api.Channel.fromJson(json);

2426 checkChannel(obj);

2427

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

2429 var pathOffset = 0;

2430 var index;

2431 var subPart;

2432 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2433 pathOffset += 10;

2434 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("channels/stop"));

2435 pathOffset += 13;

2436

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

2438 var queryOffset = 0;

2439 var queryMap = {};

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

2441 parseBool(n) {

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

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

2444 if (n == null) return null;

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

2446 }

2447 if (query.length > 0) {

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

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

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

2451 }

2452 }

2453

2454

2455 var h = {

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

2457 };

2458 var resp = "";

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

2460 }), true);

2461 res.stop(arg_request).then(unittest.expectAsync((_) {}));

2462 });

2463

2464 });

2465

2466

2467 unittest.group("resource-ChildrenResourceApi", () {

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

2469

2470 var mock = new common_test.HttpServerMock();

2471 api.ChildrenResourceApi res = new api.DriveApi(mock).children;

2472 var arg_folderId = "foo";

2473 var arg_childId = "foo";

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

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

2476 var pathOffset = 0;

2477 var index;

2478 var subPart;

2479 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2480 pathOffset += 10;

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

2482 pathOffset += 6;

2483 index = path.indexOf("/children/", pathOffset);

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

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

2486 pathOffset = index;

2487 unittest.expect(subPart, unittest.equals("$arg_folderId"));

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

2489 pathOffset += 10;

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

2491 pathOffset = path.length;

2492 unittest.expect(subPart, unittest.equals("$arg_childId"));

2493

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

2495 var queryOffset = 0;

2496 var queryMap = {};

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

2498 parseBool(n) {

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

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

2501 if (n == null) return null;

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

2503 }

2504 if (query.length > 0) {

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

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

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

2508 }

2509 }

2510

2511

2512 var h = {

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

2514 };

2515 var resp = "";

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

2517 }), true);

2518 res.delete(arg_folderId, arg_childId).then(unittest.expectAsync((_) {}));

2519 });

2520

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

2522

2523 var mock = new common_test.HttpServerMock();

2524 api.ChildrenResourceApi res = new api.DriveApi(mock).children;

2525 var arg_folderId = "foo";

2526 var arg_childId = "foo";

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

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

2529 var pathOffset = 0;

2530 var index;

2531 var subPart;

2532 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2533 pathOffset += 10;

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

2535 pathOffset += 6;

2536 index = path.indexOf("/children/", pathOffset);

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

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

2539 pathOffset = index;

2540 unittest.expect(subPart, unittest.equals("$arg_folderId"));

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

2542 pathOffset += 10;

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

2544 pathOffset = path.length;

2545 unittest.expect(subPart, unittest.equals("$arg_childId"));

2546

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

2548 var queryOffset = 0;

2549 var queryMap = {};

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

2551 parseBool(n) {

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

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

2554 if (n == null) return null;

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

2556 }

2557 if (query.length > 0) {

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

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

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

2561 }

2562 }

2563

2564

2565 var h = {

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

2567 };

2568 var resp = convert.JSON.encode(buildChildReference());

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

2570 }), true);

2571 res.get(arg_folderId, arg_childId).then(unittest.expectAsync(((api.ChildRe ference response) {

2572 checkChildReference(response);

2573 })));

2574 });

2575

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

2577

2578 var mock = new common_test.HttpServerMock();

2579 api.ChildrenResourceApi res = new api.DriveApi(mock).children;

2580 var arg_request = buildChildReference();

2581 var arg_folderId = "foo";

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

2583 var obj = new api.ChildReference.fromJson(json);

2584 checkChildReference(obj);

2585

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

2587 var pathOffset = 0;

2588 var index;

2589 var subPart;

2590 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2591 pathOffset += 10;

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

2593 pathOffset += 6;

2594 index = path.indexOf("/children", pathOffset);

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

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

2597 pathOffset = index;

2598 unittest.expect(subPart, unittest.equals("$arg_folderId"));

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

2600 pathOffset += 9;

2601

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

2603 var queryOffset = 0;

2604 var queryMap = {};

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

2606 parseBool(n) {

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

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

2609 if (n == null) return null;

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

2611 }

2612 if (query.length > 0) {

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

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

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

2616 }

2617 }

2618

2619

2620 var h = {

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

2622 };

2623 var resp = convert.JSON.encode(buildChildReference());

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

2625 }), true);

2626 res.insert(arg_request, arg_folderId).then(unittest.expectAsync(((api.Chil dReference response) {

2627 checkChildReference(response);

2628 })));

2629 });

2630

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

2632

2633 var mock = new common_test.HttpServerMock();

2634 api.ChildrenResourceApi res = new api.DriveApi(mock).children;

2635 var arg_folderId = "foo";

2636 var arg_maxResults = 42;

2637 var arg_pageToken = "foo";

2638 var arg_q = "foo";

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

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

2641 var pathOffset = 0;

2642 var index;

2643 var subPart;

2644 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2645 pathOffset += 10;

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

2647 pathOffset += 6;

2648 index = path.indexOf("/children", pathOffset);

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

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

2651 pathOffset = index;

2652 unittest.expect(subPart, unittest.equals("$arg_folderId"));

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

2654 pathOffset += 9;

2655

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

2657 var queryOffset = 0;

2658 var queryMap = {};

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

2660 parseBool(n) {

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

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

2663 if (n == null) return null;

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

2665 }

2666 if (query.length > 0) {

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

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

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

2670 }

2671 }

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

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

2674 unittest.expect(queryMap["q"].first, unittest.equals(arg_q));

2675

2676

2677 var h = {

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

2679 };

2680 var resp = convert.JSON.encode(buildChildList());

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

2682 }), true);

2683 res.list(arg_folderId, maxResults: arg_maxResults, pageToken: arg_pageToke n, q: arg_q).then(unittest.expectAsync(((api.ChildList response) {

2684 checkChildList(response);

2685 })));

2686 });

2687

2688 });

2689

2690

2691 unittest.group("resource-CommentsResourceApi", () {

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

2693

2694 var mock = new common_test.HttpServerMock();

2695 api.CommentsResourceApi res = new api.DriveApi(mock).comments;

2696 var arg_fileId = "foo";

2697 var arg_commentId = "foo";

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

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

2700 var pathOffset = 0;

2701 var index;

2702 var subPart;

2703 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2704 pathOffset += 10;

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

2706 pathOffset += 6;

2707 index = path.indexOf("/comments/", pathOffset);

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

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

2710 pathOffset = index;

2711 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

2713 pathOffset += 10;

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

2715 pathOffset = path.length;

2716 unittest.expect(subPart, unittest.equals("$arg_commentId"));

2717

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

2719 var queryOffset = 0;

2720 var queryMap = {};

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

2722 parseBool(n) {

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

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

2725 if (n == null) return null;

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

2727 }

2728 if (query.length > 0) {

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

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

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

2732 }

2733 }

2734

2735

2736 var h = {

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

2738 };

2739 var resp = "";

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

2741 }), true);

2742 res.delete(arg_fileId, arg_commentId).then(unittest.expectAsync((_) {}));

2743 });

2744

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

2746

2747 var mock = new common_test.HttpServerMock();

2748 api.CommentsResourceApi res = new api.DriveApi(mock).comments;

2749 var arg_fileId = "foo";

2750 var arg_commentId = "foo";

2751 var arg_includeDeleted = true;

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

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

2754 var pathOffset = 0;

2755 var index;

2756 var subPart;

2757 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2758 pathOffset += 10;

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

2760 pathOffset += 6;

2761 index = path.indexOf("/comments/", 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_fileId"));

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

2767 pathOffset += 10;

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

2769 pathOffset = path.length;

2770 unittest.expect(subPart, unittest.equals("$arg_commentId"));

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 unittest.expect(queryMap["includeDeleted"].first, unittest.equals("$arg_ includeDeleted"));

2789

2790

2791 var h = {

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

2793 };

2794 var resp = convert.JSON.encode(buildComment());

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

2796 }), true);

2797 res.get(arg_fileId, arg_commentId, includeDeleted: arg_includeDeleted).the n(unittest.expectAsync(((api.Comment response) {

2798 checkComment(response);

2799 })));

2800 });

2801

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

2803

2804 var mock = new common_test.HttpServerMock();

2805 api.CommentsResourceApi res = new api.DriveApi(mock).comments;

2806 var arg_request = buildComment();

2807 var arg_fileId = "foo";

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

2809 var obj = new api.Comment.fromJson(json);

2810 checkComment(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 + 10), unittest.eq uals("/drive/v2/"));

2817 pathOffset += 10;

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

2819 pathOffset += 6;

2820 index = path.indexOf("/comments", 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_fileId"));

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

2826 pathOffset += 9;

2827

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

2829 var queryOffset = 0;

2830 var queryMap = {};

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

2832 parseBool(n) {

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

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

2835 if (n == null) return null;

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

2837 }

2838 if (query.length > 0) {

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

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

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

2842 }

2843 }

2844

2845

2846 var h = {

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

2848 };

2849 var resp = convert.JSON.encode(buildComment());

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

2851 }), true);

2852 res.insert(arg_request, arg_fileId).then(unittest.expectAsync(((api.Commen t response) {

2853 checkComment(response);

2854 })));

2855 });

2856

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

2858

2859 var mock = new common_test.HttpServerMock();

2860 api.CommentsResourceApi res = new api.DriveApi(mock).comments;

2861 var arg_fileId = "foo";

2862 var arg_includeDeleted = true;

2863 var arg_maxResults = 42;

2864 var arg_pageToken = "foo";

2865 var arg_updatedMin = "foo";

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

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

2868 var pathOffset = 0;

2869 var index;

2870 var subPart;

2871 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2872 pathOffset += 10;

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

2874 pathOffset += 6;

2875 index = path.indexOf("/comments", pathOffset);

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

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

2878 pathOffset = index;

2879 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

2881 pathOffset += 9;

2882

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

2884 var queryOffset = 0;

2885 var queryMap = {};

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

2887 parseBool(n) {

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

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

2890 if (n == null) return null;

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

2892 }

2893 if (query.length > 0) {

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

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

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

2897 }

2898 }

2899 unittest.expect(queryMap["includeDeleted"].first, unittest.equals("$arg_ includeDeleted"));

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

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

2902 unittest.expect(queryMap["updatedMin"].first, unittest.equals(arg_update dMin));

2903

2904

2905 var h = {

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

2907 };

2908 var resp = convert.JSON.encode(buildCommentList());

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

2910 }), true);

2911 res.list(arg_fileId, includeDeleted: arg_includeDeleted, maxResults: arg_m axResults, pageToken: arg_pageToken, updatedMin: arg_updatedMin).then(unittest.e xpectAsync(((api.CommentList response) {

2912 checkCommentList(response);

2913 })));

2914 });

2915

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

2917

2918 var mock = new common_test.HttpServerMock();

2919 api.CommentsResourceApi res = new api.DriveApi(mock).comments;

2920 var arg_request = buildComment();

2921 var arg_fileId = "foo";

2922 var arg_commentId = "foo";

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

2924 var obj = new api.Comment.fromJson(json);

2925 checkComment(obj);

2926

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

2928 var pathOffset = 0;

2929 var index;

2930 var subPart;

2931 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2932 pathOffset += 10;

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

2934 pathOffset += 6;

2935 index = path.indexOf("/comments/", pathOffset);

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

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

2938 pathOffset = index;

2939 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

2941 pathOffset += 10;

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

2943 pathOffset = path.length;

2944 unittest.expect(subPart, unittest.equals("$arg_commentId"));

2945

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

2947 var queryOffset = 0;

2948 var queryMap = {};

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

2950 parseBool(n) {

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

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

2953 if (n == null) return null;

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

2955 }

2956 if (query.length > 0) {

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

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

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

2960 }

2961 }

2962

2963

2964 var h = {

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

2966 };

2967 var resp = convert.JSON.encode(buildComment());

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

2969 }), true);

2970 res.patch(arg_request, arg_fileId, arg_commentId).then(unittest.expectAsyn c(((api.Comment response) {

2971 checkComment(response);

2972 })));

2973 });

2974

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

2976

2977 var mock = new common_test.HttpServerMock();

2978 api.CommentsResourceApi res = new api.DriveApi(mock).comments;

2979 var arg_request = buildComment();

2980 var arg_fileId = "foo";

2981 var arg_commentId = "foo";

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

2983 var obj = new api.Comment.fromJson(json);

2984 checkComment(obj);

2985

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

2987 var pathOffset = 0;

2988 var index;

2989 var subPart;

2990 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

2991 pathOffset += 10;

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

2993 pathOffset += 6;

2994 index = path.indexOf("/comments/", pathOffset);

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

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

2997 pathOffset = index;

2998 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3000 pathOffset += 10;

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

3002 pathOffset = path.length;

3003 unittest.expect(subPart, unittest.equals("$arg_commentId"));

3004

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

3006 var queryOffset = 0;

3007 var queryMap = {};

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

3009 parseBool(n) {

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

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

3012 if (n == null) return null;

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

3014 }

3015 if (query.length > 0) {

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

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

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

3019 }

3020 }

3021

3022

3023 var h = {

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

3025 };

3026 var resp = convert.JSON.encode(buildComment());

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

3028 }), true);

3029 res.update(arg_request, arg_fileId, arg_commentId).then(unittest.expectAsy nc(((api.Comment response) {

3030 checkComment(response);

3031 })));

3032 });

3033

3034 });

3035

3036

3037 unittest.group("resource-FilesResourceApi", () {

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

3039

3040 var mock = new common_test.HttpServerMock();

3041 api.FilesResourceApi res = new api.DriveApi(mock).files;

3042 var arg_request = buildFile();

3043 var arg_fileId = "foo";

3044 var arg_convert = true;

3045 var arg_ocr = true;

3046 var arg_ocrLanguage = "foo";

3047 var arg_pinned = true;

3048 var arg_timedTextLanguage = "foo";

3049 var arg_timedTextTrackName = "foo";

3050 var arg_visibility = "foo";

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

3052 var obj = new api.File.fromJson(json);

3053 checkFile(obj);

3054

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

3056 var pathOffset = 0;

3057 var index;

3058 var subPart;

3059 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3060 pathOffset += 10;

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

3062 pathOffset += 6;

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

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

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

3066 pathOffset = index;

3067 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3069 pathOffset += 5;

3070

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

3072 var queryOffset = 0;

3073 var queryMap = {};

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

3075 parseBool(n) {

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

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

3078 if (n == null) return null;

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

3080 }

3081 if (query.length > 0) {

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

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

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

3085 }

3086 }

3087 unittest.expect(queryMap["convert"].first, unittest.equals("$arg_convert "));

3088 unittest.expect(queryMap["ocr"].first, unittest.equals("$arg_ocr"));

3089 unittest.expect(queryMap["ocrLanguage"].first, unittest.equals(arg_ocrLa nguage));

3090 unittest.expect(queryMap["pinned"].first, unittest.equals("$arg_pinned") );

3091 unittest.expect(queryMap["timedTextLanguage"].first, unittest.equals(arg _timedTextLanguage));

3092 unittest.expect(queryMap["timedTextTrackName"].first, unittest.equals(ar g_timedTextTrackName));

3093 unittest.expect(queryMap["visibility"].first, unittest.equals(arg_visibi lity));

3094

3095

3096 var h = {

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

3098 };

3099 var resp = convert.JSON.encode(buildFile());

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

3101 }), true);

3102 res.copy(arg_request, arg_fileId, convert: arg_convert, ocr: arg_ocr, ocrL anguage: arg_ocrLanguage, pinned: arg_pinned, timedTextLanguage: arg_timedTextLa nguage, timedTextTrackName: arg_timedTextTrackName, visibility: arg_visibility). then(unittest.expectAsync(((api.File response) {

3103 checkFile(response);

3104 })));

3105 });

3106

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

3108

3109 var mock = new common_test.HttpServerMock();

3110 api.FilesResourceApi res = new api.DriveApi(mock).files;

3111 var arg_fileId = "foo";

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

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

3114 var pathOffset = 0;

3115 var index;

3116 var subPart;

3117 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3118 pathOffset += 10;

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

3120 pathOffset += 6;

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

3122 pathOffset = path.length;

3123 unittest.expect(subPart, unittest.equals("$arg_fileId"));

3124

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

3126 var queryOffset = 0;

3127 var queryMap = {};

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

3129 parseBool(n) {

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

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

3132 if (n == null) return null;

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

3134 }

3135 if (query.length > 0) {

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

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

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

3139 }

3140 }

3141

3142

3143 var h = {

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

3145 };

3146 var resp = "";

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

3148 }), true);

3149 res.delete(arg_fileId).then(unittest.expectAsync((_) {}));

3150 });

3151

3152 unittest.test("method--emptyTrash", () {

3153

3154 var mock = new common_test.HttpServerMock();

3155 api.FilesResourceApi res = new api.DriveApi(mock).files;

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

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

3158 var pathOffset = 0;

3159 var index;

3160 var subPart;

3161 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3162 pathOffset += 10;

3163 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("files/trash"));

3164 pathOffset += 11;

3165

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

3167 var queryOffset = 0;

3168 var queryMap = {};

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

3170 parseBool(n) {

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

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

3173 if (n == null) return null;

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

3175 }

3176 if (query.length > 0) {

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

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

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

3180 }

3181 }

3182

3183

3184 var h = {

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

3186 };

3187 var resp = "";

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

3189 }), true);

3190 res.emptyTrash().then(unittest.expectAsync((_) {}));

3191 });

3192

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

3194

3195 var mock = new common_test.HttpServerMock();

3196 api.FilesResourceApi res = new api.DriveApi(mock).files;

3197 var arg_fileId = "foo";

3198 var arg_projection = "foo";

3199 var arg_updateViewedDate = true;

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

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

3202 var pathOffset = 0;

3203 var index;

3204 var subPart;

3205 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3206 pathOffset += 10;

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

3208 pathOffset += 6;

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

3210 pathOffset = path.length;

3211 unittest.expect(subPart, unittest.equals("$arg_fileId"));

3212

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

3214 var queryOffset = 0;

3215 var queryMap = {};

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

3217 parseBool(n) {

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

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

3220 if (n == null) return null;

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

3222 }

3223 if (query.length > 0) {

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

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

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

3227 }

3228 }

3229 unittest.expect(queryMap["projection"].first, unittest.equals(arg_projec tion));

3230 unittest.expect(queryMap["updateViewedDate"].first, unittest.equals("$ar g_updateViewedDate"));

3231

3232

3233 var h = {

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

3235 };

3236 var resp = convert.JSON.encode(buildFile());

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

3238 }), true);

3239 res.get(arg_fileId, projection: arg_projection, updateViewedDate: arg_upda teViewedDate).then(unittest.expectAsync(((api.File response) {

3240 checkFile(response);

3241 })));

3242 });

3243

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

3245 // TODO: Implement tests for media upload;

3246 // TODO: Implement tests for media download;

3247

3248 var mock = new common_test.HttpServerMock();

3249 api.FilesResourceApi res = new api.DriveApi(mock).files;

3250 var arg_request = buildFile();

3251 var arg_convert = true;

3252 var arg_ocr = true;

3253 var arg_ocrLanguage = "foo";

3254 var arg_pinned = true;

3255 var arg_timedTextLanguage = "foo";

3256 var arg_timedTextTrackName = "foo";

3257 var arg_useContentAsIndexableText = true;

3258 var arg_visibility = "foo";

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

3260 var obj = new api.File.fromJson(json);

3261 checkFile(obj);

3262

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

3264 var pathOffset = 0;

3265 var index;

3266 var subPart;

3267 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3268 pathOffset += 10;

3269 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("files"));

3270 pathOffset += 5;

3271

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

3273 var queryOffset = 0;

3274 var queryMap = {};

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

3276 parseBool(n) {

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

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

3279 if (n == null) return null;

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

3281 }

3282 if (query.length > 0) {

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

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

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

3286 }

3287 }

3288 unittest.expect(queryMap["convert"].first, unittest.equals("$arg_convert "));

3289 unittest.expect(queryMap["ocr"].first, unittest.equals("$arg_ocr"));

3290 unittest.expect(queryMap["ocrLanguage"].first, unittest.equals(arg_ocrLa nguage));

3291 unittest.expect(queryMap["pinned"].first, unittest.equals("$arg_pinned") );

3292 unittest.expect(queryMap["timedTextLanguage"].first, unittest.equals(arg _timedTextLanguage));

3293 unittest.expect(queryMap["timedTextTrackName"].first, unittest.equals(ar g_timedTextTrackName));

3294 unittest.expect(queryMap["useContentAsIndexableText"].first, unittest.eq uals("$arg_useContentAsIndexableText"));

3295 unittest.expect(queryMap["visibility"].first, unittest.equals(arg_visibi lity));

3296

3297

3298 var h = {

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

3300 };

3301 var resp = convert.JSON.encode(buildFile());

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

3303 }), true);

3304 res.insert(arg_request, convert: arg_convert, ocr: arg_ocr, ocrLanguage: a rg_ocrLanguage, pinned: arg_pinned, timedTextLanguage: arg_timedTextLanguage, ti medTextTrackName: arg_timedTextTrackName, useContentAsIndexableText: arg_useCont entAsIndexableText, visibility: arg_visibility).then(unittest.expectAsync(((api. File response) {

3305 checkFile(response);

3306 })));

3307 });

3308

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

3310

3311 var mock = new common_test.HttpServerMock();

3312 api.FilesResourceApi res = new api.DriveApi(mock).files;

3313 var arg_corpus = "foo";

3314 var arg_maxResults = 42;

3315 var arg_pageToken = "foo";

3316 var arg_projection = "foo";

3317 var arg_q = "foo";

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

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

3320 var pathOffset = 0;

3321 var index;

3322 var subPart;

3323 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3324 pathOffset += 10;

3325 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("files"));

3326 pathOffset += 5;

3327

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

3329 var queryOffset = 0;

3330 var queryMap = {};

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

3332 parseBool(n) {

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

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

3335 if (n == null) return null;

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

3337 }

3338 if (query.length > 0) {

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

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

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

3342 }

3343 }

3344 unittest.expect(queryMap["corpus"].first, unittest.equals(arg_corpus));

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

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

3347 unittest.expect(queryMap["projection"].first, unittest.equals(arg_projec tion));

3348 unittest.expect(queryMap["q"].first, unittest.equals(arg_q));

3349

3350

3351 var h = {

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

3353 };

3354 var resp = convert.JSON.encode(buildFileList());

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

3356 }), true);

3357 res.list(corpus: arg_corpus, maxResults: arg_maxResults, pageToken: arg_pa geToken, projection: arg_projection, q: arg_q).then(unittest.expectAsync(((api.F ileList response) {

3358 checkFileList(response);

3359 })));

3360 });

3361

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

3363

3364 var mock = new common_test.HttpServerMock();

3365 api.FilesResourceApi res = new api.DriveApi(mock).files;

3366 var arg_request = buildFile();

3367 var arg_fileId = "foo";

3368 var arg_addParents = "foo";

3369 var arg_convert = true;

3370 var arg_newRevision = true;

3371 var arg_ocr = true;

3372 var arg_ocrLanguage = "foo";

3373 var arg_pinned = true;

3374 var arg_removeParents = "foo";

3375 var arg_setModifiedDate = true;

3376 var arg_timedTextLanguage = "foo";

3377 var arg_timedTextTrackName = "foo";

3378 var arg_updateViewedDate = true;

3379 var arg_useContentAsIndexableText = true;

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

3381 var obj = new api.File.fromJson(json);

3382 checkFile(obj);

3383

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

3385 var pathOffset = 0;

3386 var index;

3387 var subPart;

3388 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3389 pathOffset += 10;

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

3391 pathOffset += 6;

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

3393 pathOffset = path.length;

3394 unittest.expect(subPart, unittest.equals("$arg_fileId"));

3395

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

3397 var queryOffset = 0;

3398 var queryMap = {};

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

3400 parseBool(n) {

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

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

3403 if (n == null) return null;

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

3405 }

3406 if (query.length > 0) {

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

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

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

3410 }

3411 }

3412 unittest.expect(queryMap["addParents"].first, unittest.equals(arg_addPar ents));

3413 unittest.expect(queryMap["convert"].first, unittest.equals("$arg_convert "));

3414 unittest.expect(queryMap["newRevision"].first, unittest.equals("$arg_new Revision"));

3415 unittest.expect(queryMap["ocr"].first, unittest.equals("$arg_ocr"));

3416 unittest.expect(queryMap["ocrLanguage"].first, unittest.equals(arg_ocrLa nguage));

3417 unittest.expect(queryMap["pinned"].first, unittest.equals("$arg_pinned") );

3418 unittest.expect(queryMap["removeParents"].first, unittest.equals(arg_rem oveParents));

3419 unittest.expect(queryMap["setModifiedDate"].first, unittest.equals("$arg _setModifiedDate"));

3420 unittest.expect(queryMap["timedTextLanguage"].first, unittest.equals(arg _timedTextLanguage));

3421 unittest.expect(queryMap["timedTextTrackName"].first, unittest.equals(ar g_timedTextTrackName));

3422 unittest.expect(queryMap["updateViewedDate"].first, unittest.equals("$ar g_updateViewedDate"));

3423 unittest.expect(queryMap["useContentAsIndexableText"].first, unittest.eq uals("$arg_useContentAsIndexableText"));

3424

3425

3426 var h = {

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

3428 };

3429 var resp = convert.JSON.encode(buildFile());

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

3431 }), true);

3432 res.patch(arg_request, arg_fileId, addParents: arg_addParents, convert: ar g_convert, newRevision: arg_newRevision, ocr: arg_ocr, ocrLanguage: arg_ocrLangu age, pinned: arg_pinned, removeParents: arg_removeParents, setModifiedDate: arg_ setModifiedDate, timedTextLanguage: arg_timedTextLanguage, timedTextTrackName: a rg_timedTextTrackName, updateViewedDate: arg_updateViewedDate, useContentAsIndex ableText: arg_useContentAsIndexableText).then(unittest.expectAsync(((api.File re sponse) {

3433 checkFile(response);

3434 })));

3435 });

3436

3437 unittest.test("method--touch", () {

3438

3439 var mock = new common_test.HttpServerMock();

3440 api.FilesResourceApi res = new api.DriveApi(mock).files;

3441 var arg_fileId = "foo";

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

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

3444 var pathOffset = 0;

3445 var index;

3446 var subPart;

3447 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3448 pathOffset += 10;

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

3450 pathOffset += 6;

3451 index = path.indexOf("/touch", pathOffset);

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

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

3454 pathOffset = index;

3455 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3457 pathOffset += 6;

3458

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

3460 var queryOffset = 0;

3461 var queryMap = {};

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

3463 parseBool(n) {

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

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

3466 if (n == null) return null;

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

3468 }

3469 if (query.length > 0) {

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

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

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

3473 }

3474 }

3475

3476

3477 var h = {

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

3479 };

3480 var resp = convert.JSON.encode(buildFile());

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

3482 }), true);

3483 res.touch(arg_fileId).then(unittest.expectAsync(((api.File response) {

3484 checkFile(response);

3485 })));

3486 });

3487

3488 unittest.test("method--trash", () {

3489

3490 var mock = new common_test.HttpServerMock();

3491 api.FilesResourceApi res = new api.DriveApi(mock).files;

3492 var arg_fileId = "foo";

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

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

3495 var pathOffset = 0;

3496 var index;

3497 var subPart;

3498 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3499 pathOffset += 10;

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

3501 pathOffset += 6;

3502 index = path.indexOf("/trash", pathOffset);

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

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

3505 pathOffset = index;

3506 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3508 pathOffset += 6;

3509

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

3511 var queryOffset = 0;

3512 var queryMap = {};

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

3514 parseBool(n) {

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

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

3517 if (n == null) return null;

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

3519 }

3520 if (query.length > 0) {

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

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

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

3524 }

3525 }

3526

3527

3528 var h = {

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

3530 };

3531 var resp = convert.JSON.encode(buildFile());

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

3533 }), true);

3534 res.trash(arg_fileId).then(unittest.expectAsync(((api.File response) {

3535 checkFile(response);

3536 })));

3537 });

3538

3539 unittest.test("method--untrash", () {

3540

3541 var mock = new common_test.HttpServerMock();

3542 api.FilesResourceApi res = new api.DriveApi(mock).files;

3543 var arg_fileId = "foo";

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

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

3546 var pathOffset = 0;

3547 var index;

3548 var subPart;

3549 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3550 pathOffset += 10;

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

3552 pathOffset += 6;

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

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

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

3556 pathOffset = index;

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

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

3559 pathOffset += 8;

3560

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

3562 var queryOffset = 0;

3563 var queryMap = {};

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

3565 parseBool(n) {

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

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

3568 if (n == null) return null;

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

3570 }

3571 if (query.length > 0) {

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

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

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

3575 }

3576 }

3577

3578

3579 var h = {

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

3581 };

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

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

3584 }), true);

3585 res.untrash(arg_fileId).then(unittest.expectAsync(((api.File response) {

3586 checkFile(response);

3587 })));

3588 });

3589

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

3591 // TODO: Implement tests for media upload;

3592 // TODO: Implement tests for media download;

3593

3594 var mock = new common_test.HttpServerMock();

3595 api.FilesResourceApi res = new api.DriveApi(mock).files;

3596 var arg_request = buildFile();

3597 var arg_fileId = "foo";

3598 var arg_addParents = "foo";

3599 var arg_convert = true;

3600 var arg_newRevision = true;

3601 var arg_ocr = true;

3602 var arg_ocrLanguage = "foo";

3603 var arg_pinned = true;

3604 var arg_removeParents = "foo";

3605 var arg_setModifiedDate = true;

3606 var arg_timedTextLanguage = "foo";

3607 var arg_timedTextTrackName = "foo";

3608 var arg_updateViewedDate = true;

3609 var arg_useContentAsIndexableText = true;

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

3611 var obj = new api.File.fromJson(json);

3612 checkFile(obj);

3613

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

3615 var pathOffset = 0;

3616 var index;

3617 var subPart;

3618 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3619 pathOffset += 10;

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

3621 pathOffset += 6;

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

3623 pathOffset = path.length;

3624 unittest.expect(subPart, unittest.equals("$arg_fileId"));

3625

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

3627 var queryOffset = 0;

3628 var queryMap = {};

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

3630 parseBool(n) {

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

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

3633 if (n == null) return null;

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

3635 }

3636 if (query.length > 0) {

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

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

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

3640 }

3641 }

3642 unittest.expect(queryMap["addParents"].first, unittest.equals(arg_addPar ents));

3643 unittest.expect(queryMap["convert"].first, unittest.equals("$arg_convert "));

3644 unittest.expect(queryMap["newRevision"].first, unittest.equals("$arg_new Revision"));

3645 unittest.expect(queryMap["ocr"].first, unittest.equals("$arg_ocr"));

3646 unittest.expect(queryMap["ocrLanguage"].first, unittest.equals(arg_ocrLa nguage));

3647 unittest.expect(queryMap["pinned"].first, unittest.equals("$arg_pinned") );

3648 unittest.expect(queryMap["removeParents"].first, unittest.equals(arg_rem oveParents));

3649 unittest.expect(queryMap["setModifiedDate"].first, unittest.equals("$arg _setModifiedDate"));

3650 unittest.expect(queryMap["timedTextLanguage"].first, unittest.equals(arg _timedTextLanguage));

3651 unittest.expect(queryMap["timedTextTrackName"].first, unittest.equals(ar g_timedTextTrackName));

3652 unittest.expect(queryMap["updateViewedDate"].first, unittest.equals("$ar g_updateViewedDate"));

3653 unittest.expect(queryMap["useContentAsIndexableText"].first, unittest.eq uals("$arg_useContentAsIndexableText"));

3654

3655

3656 var h = {

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

3658 };

3659 var resp = convert.JSON.encode(buildFile());

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

3661 }), true);

3662 res.update(arg_request, arg_fileId, addParents: arg_addParents, convert: a rg_convert, newRevision: arg_newRevision, ocr: arg_ocr, ocrLanguage: arg_ocrLang uage, pinned: arg_pinned, removeParents: arg_removeParents, setModifiedDate: arg _setModifiedDate, timedTextLanguage: arg_timedTextLanguage, timedTextTrackName: arg_timedTextTrackName, updateViewedDate: arg_updateViewedDate, useContentAsInde xableText: arg_useContentAsIndexableText).then(unittest.expectAsync(((api.File r esponse) {

3663 checkFile(response);

3664 })));

3665 });

3666

3667 unittest.test("method--watch", () {

3668

3669 var mock = new common_test.HttpServerMock();

3670 api.FilesResourceApi res = new api.DriveApi(mock).files;

3671 var arg_request = buildChannel();

3672 var arg_fileId = "foo";

3673 var arg_projection = "foo";

3674 var arg_updateViewedDate = true;

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

3676 var obj = new api.Channel.fromJson(json);

3677 checkChannel(obj);

3678

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

3680 var pathOffset = 0;

3681 var index;

3682 var subPart;

3683 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3684 pathOffset += 10;

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

3686 pathOffset += 6;

3687 index = path.indexOf("/watch", pathOffset);

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

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

3690 pathOffset = index;

3691 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3693 pathOffset += 6;

3694

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

3696 var queryOffset = 0;

3697 var queryMap = {};

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

3699 parseBool(n) {

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

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

3702 if (n == null) return null;

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

3704 }

3705 if (query.length > 0) {

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

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

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

3709 }

3710 }

3711 unittest.expect(queryMap["projection"].first, unittest.equals(arg_projec tion));

3712 unittest.expect(queryMap["updateViewedDate"].first, unittest.equals("$ar g_updateViewedDate"));

3713

3714

3715 var h = {

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

3717 };

3718 var resp = convert.JSON.encode(buildChannel());

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

3720 }), true);

3721 res.watch(arg_request, arg_fileId, projection: arg_projection, updateViewe dDate: arg_updateViewedDate).then(unittest.expectAsync(((api.Channel response) {

3722 checkChannel(response);

3723 })));

3724 });

3725

3726 });

3727

3728

3729 unittest.group("resource-ParentsResourceApi", () {

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

3731

3732 var mock = new common_test.HttpServerMock();

3733 api.ParentsResourceApi res = new api.DriveApi(mock).parents;

3734 var arg_fileId = "foo";

3735 var arg_parentId = "foo";

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

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

3738 var pathOffset = 0;

3739 var index;

3740 var subPart;

3741 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3742 pathOffset += 10;

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

3744 pathOffset += 6;

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

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

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

3748 pathOffset = index;

3749 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3751 pathOffset += 9;

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

3753 pathOffset = path.length;

3754 unittest.expect(subPart, unittest.equals("$arg_parentId"));

3755

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

3757 var queryOffset = 0;

3758 var queryMap = {};

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

3760 parseBool(n) {

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

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

3763 if (n == null) return null;

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

3765 }

3766 if (query.length > 0) {

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

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

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

3770 }

3771 }

3772

3773

3774 var h = {

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

3776 };

3777 var resp = "";

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

3779 }), true);

3780 res.delete(arg_fileId, arg_parentId).then(unittest.expectAsync((_) {}));

3781 });

3782

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

3784

3785 var mock = new common_test.HttpServerMock();

3786 api.ParentsResourceApi res = new api.DriveApi(mock).parents;

3787 var arg_fileId = "foo";

3788 var arg_parentId = "foo";

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

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

3791 var pathOffset = 0;

3792 var index;

3793 var subPart;

3794 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3795 pathOffset += 10;

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

3797 pathOffset += 6;

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

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

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

3801 pathOffset = index;

3802 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3804 pathOffset += 9;

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

3806 pathOffset = path.length;

3807 unittest.expect(subPart, unittest.equals("$arg_parentId"));

3808

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

3810 var queryOffset = 0;

3811 var queryMap = {};

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

3813 parseBool(n) {

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

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

3816 if (n == null) return null;

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

3818 }

3819 if (query.length > 0) {

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

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

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

3823 }

3824 }

3825

3826

3827 var h = {

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

3829 };

3830 var resp = convert.JSON.encode(buildParentReference());

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

3832 }), true);

3833 res.get(arg_fileId, arg_parentId).then(unittest.expectAsync(((api.ParentRe ference response) {

3834 checkParentReference(response);

3835 })));

3836 });

3837

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

3839

3840 var mock = new common_test.HttpServerMock();

3841 api.ParentsResourceApi res = new api.DriveApi(mock).parents;

3842 var arg_request = buildParentReference();

3843 var arg_fileId = "foo";

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

3845 var obj = new api.ParentReference.fromJson(json);

3846 checkParentReference(obj);

3847

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

3849 var pathOffset = 0;

3850 var index;

3851 var subPart;

3852 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3853 pathOffset += 10;

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

3855 pathOffset += 6;

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

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

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

3859 pathOffset = index;

3860 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3862 pathOffset += 8;

3863

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

3865 var queryOffset = 0;

3866 var queryMap = {};

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

3868 parseBool(n) {

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

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

3871 if (n == null) return null;

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

3873 }

3874 if (query.length > 0) {

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

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

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

3878 }

3879 }

3880

3881

3882 var h = {

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

3884 };

3885 var resp = convert.JSON.encode(buildParentReference());

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

3887 }), true);

3888 res.insert(arg_request, arg_fileId).then(unittest.expectAsync(((api.Parent Reference response) {

3889 checkParentReference(response);

3890 })));

3891 });

3892

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

3894

3895 var mock = new common_test.HttpServerMock();

3896 api.ParentsResourceApi res = new api.DriveApi(mock).parents;

3897 var arg_fileId = "foo";

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

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

3900 var pathOffset = 0;

3901 var index;

3902 var subPart;

3903 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3904 pathOffset += 10;

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

3906 pathOffset += 6;

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

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

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

3910 pathOffset = index;

3911 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3913 pathOffset += 8;

3914

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

3916 var queryOffset = 0;

3917 var queryMap = {};

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

3919 parseBool(n) {

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

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

3922 if (n == null) return null;

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

3924 }

3925 if (query.length > 0) {

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

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

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

3929 }

3930 }

3931

3932

3933 var h = {

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

3935 };

3936 var resp = convert.JSON.encode(buildParentList());

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

3938 }), true);

3939 res.list(arg_fileId).then(unittest.expectAsync(((api.ParentList response) {

3940 checkParentList(response);

3941 })));

3942 });

3943

3944 });

3945

3946

3947 unittest.group("resource-PermissionsResourceApi", () {

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

3949

3950 var mock = new common_test.HttpServerMock();

3951 api.PermissionsResourceApi res = new api.DriveApi(mock).permissions;

3952 var arg_fileId = "foo";

3953 var arg_permissionId = "foo";

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

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

3956 var pathOffset = 0;

3957 var index;

3958 var subPart;

3959 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

3960 pathOffset += 10;

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

3962 pathOffset += 6;

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

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

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

3966 pathOffset = index;

3967 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

3969 pathOffset += 13;

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

3971 pathOffset = path.length;

3972 unittest.expect(subPart, unittest.equals("$arg_permissionId"));

3973

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

3975 var queryOffset = 0;

3976 var queryMap = {};

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

3978 parseBool(n) {

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

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

3981 if (n == null) return null;

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

3983 }

3984 if (query.length > 0) {

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

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

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

3988 }

3989 }

3990

3991

3992 var h = {

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

3994 };

3995 var resp = "";

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

3997 }), true);

3998 res.delete(arg_fileId, arg_permissionId).then(unittest.expectAsync((_) {}) );

3999 });

4000

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

4002

4003 var mock = new common_test.HttpServerMock();

4004 api.PermissionsResourceApi res = new api.DriveApi(mock).permissions;

4005 var arg_fileId = "foo";

4006 var arg_permissionId = "foo";

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

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

4009 var pathOffset = 0;

4010 var index;

4011 var subPart;

4012 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4013 pathOffset += 10;

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

4015 pathOffset += 6;

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

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

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

4019 pathOffset = index;

4020 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

4022 pathOffset += 13;

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

4024 pathOffset = path.length;

4025 unittest.expect(subPart, unittest.equals("$arg_permissionId"));

4026

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

4028 var queryOffset = 0;

4029 var queryMap = {};

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

4031 parseBool(n) {

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

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

4034 if (n == null) return null;

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

4036 }

4037 if (query.length > 0) {

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

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

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

4041 }

4042 }

4043

4044

4045 var h = {

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

4047 };

4048 var resp = convert.JSON.encode(buildPermission());

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

4050 }), true);

4051 res.get(arg_fileId, arg_permissionId).then(unittest.expectAsync(((api.Perm ission response) {

4052 checkPermission(response);

4053 })));

4054 });

4055

4056 unittest.test("method--getIdForEmail", () {

4057

4058 var mock = new common_test.HttpServerMock();

4059 api.PermissionsResourceApi res = new api.DriveApi(mock).permissions;

4060 var arg_email = "foo";

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

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

4063 var pathOffset = 0;

4064 var index;

4065 var subPart;

4066 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4067 pathOffset += 10;

4068 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("permissionIds/"));

4069 pathOffset += 14;

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

4071 pathOffset = path.length;

4072 unittest.expect(subPart, unittest.equals("$arg_email"));

4073

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

4075 var queryOffset = 0;

4076 var queryMap = {};

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

4078 parseBool(n) {

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

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

4081 if (n == null) return null;

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

4083 }

4084 if (query.length > 0) {

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

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

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

4088 }

4089 }

4090

4091

4092 var h = {

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

4094 };

4095 var resp = convert.JSON.encode(buildPermissionId());

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

4097 }), true);

4098 res.getIdForEmail(arg_email).then(unittest.expectAsync(((api.PermissionId response) {

4099 checkPermissionId(response);

4100 })));

4101 });

4102

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

4104

4105 var mock = new common_test.HttpServerMock();

4106 api.PermissionsResourceApi res = new api.DriveApi(mock).permissions;

4107 var arg_request = buildPermission();

4108 var arg_fileId = "foo";

4109 var arg_emailMessage = "foo";

4110 var arg_sendNotificationEmails = true;

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

4112 var obj = new api.Permission.fromJson(json);

4113 checkPermission(obj);

4114

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

4116 var pathOffset = 0;

4117 var index;

4118 var subPart;

4119 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4120 pathOffset += 10;

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

4122 pathOffset += 6;

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

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

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

4126 pathOffset = index;

4127 unittest.expect(subPart, unittest.equals("$arg_fileId"));

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

4129 pathOffset += 12;

4130

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

4132 var queryOffset = 0;

4133 var queryMap = {};

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

4135 parseBool(n) {

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

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

4138 if (n == null) return null;

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

4140 }

4141 if (query.length > 0) {

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

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

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

4145 }

4146 }

4147 unittest.expect(queryMap["emailMessage"].first, unittest.equals(arg_emai lMessage));

4148 unittest.expect(queryMap["sendNotificationEmails"].first, unittest.equal s("$arg_sendNotificationEmails"));

4149

4150

4151 var h = {

4152 "content-type" : "application/json; charset=utf-8",

4153 };

4154 var resp = convert.JSON.encode(buildPermission());

4155 return new async.Future.value(common_test.stringResponse(200, h, resp));

4156 }), true);

4157 res.insert(arg_request, arg_fileId, emailMessage: arg_emailMessage, sendNo tificationEmails: arg_sendNotificationEmails).then(unittest.expectAsync(((api.Pe rmission response) {

4158 checkPermission(response);

4159 })));

4160 });

4161

4162 unittest.test("method--list", () {

4163

4164 var mock = new common_test.HttpServerMock();

4165 api.PermissionsResourceApi res = new api.DriveApi(mock).permissions;

4166 var arg_fileId = "foo";

4167 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4168 var path = (req.url).path;

4169 var pathOffset = 0;

4170 var index;

4171 var subPart;

4172 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4173 pathOffset += 10;

4174 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4175 pathOffset += 6;

4176 index = path.indexOf("/permissions", pathOffset);

4177 unittest.expect(index >= 0, unittest.isTrue);

4178 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4179 pathOffset = index;

4180 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4181 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/permissions"));

4182 pathOffset += 12;

4183

4184 var query = (req.url).query;

4185 var queryOffset = 0;

4186 var queryMap = {};

4187 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4188 parseBool(n) {

4189 if (n == "true") return true;

4190 if (n == "false") return false;

4191 if (n == null) return null;

4192 throw new core.ArgumentError("Invalid boolean: $n");

4193 }

4194 if (query.length > 0) {

4195 for (var part in query.split("&")) {

4196 var keyvalue = part.split("=");

4197 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4198 }

4199 }

4200

4201

4202 var h = {

4203 "content-type" : "application/json; charset=utf-8",

4204 };

4205 var resp = convert.JSON.encode(buildPermissionList());

4206 return new async.Future.value(common_test.stringResponse(200, h, resp));

4207 }), true);

4208 res.list(arg_fileId).then(unittest.expectAsync(((api.PermissionList respon se) {

4209 checkPermissionList(response);

4210 })));

4211 });

4212

4213 unittest.test("method--patch", () {

4214

4215 var mock = new common_test.HttpServerMock();

4216 api.PermissionsResourceApi res = new api.DriveApi(mock).permissions;

4217 var arg_request = buildPermission();

4218 var arg_fileId = "foo";

4219 var arg_permissionId = "foo";

4220 var arg_transferOwnership = true;

4221 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4222 var obj = new api.Permission.fromJson(json);

4223 checkPermission(obj);

4224

4225 var path = (req.url).path;

4226 var pathOffset = 0;

4227 var index;

4228 var subPart;

4229 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4230 pathOffset += 10;

4231 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4232 pathOffset += 6;

4233 index = path.indexOf("/permissions/", pathOffset);

4234 unittest.expect(index >= 0, unittest.isTrue);

4235 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4236 pathOffset = index;

4237 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4238 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/permissions/"));

4239 pathOffset += 13;

4240 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4241 pathOffset = path.length;

4242 unittest.expect(subPart, unittest.equals("$arg_permissionId"));

4243

4244 var query = (req.url).query;

4245 var queryOffset = 0;

4246 var queryMap = {};

4247 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4248 parseBool(n) {

4249 if (n == "true") return true;

4250 if (n == "false") return false;

4251 if (n == null) return null;

4252 throw new core.ArgumentError("Invalid boolean: $n");

4253 }

4254 if (query.length > 0) {

4255 for (var part in query.split("&")) {

4256 var keyvalue = part.split("=");

4257 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4258 }

4259 }

4260 unittest.expect(queryMap["transferOwnership"].first, unittest.equals("$a rg_transferOwnership"));

4261

4262

4263 var h = {

4264 "content-type" : "application/json; charset=utf-8",

4265 };

4266 var resp = convert.JSON.encode(buildPermission());

4267 return new async.Future.value(common_test.stringResponse(200, h, resp));

4268 }), true);

4269 res.patch(arg_request, arg_fileId, arg_permissionId, transferOwnership: ar g_transferOwnership).then(unittest.expectAsync(((api.Permission response) {

4270 checkPermission(response);

4271 })));

4272 });

4273

4274 unittest.test("method--update", () {

4275

4276 var mock = new common_test.HttpServerMock();

4277 api.PermissionsResourceApi res = new api.DriveApi(mock).permissions;

4278 var arg_request = buildPermission();

4279 var arg_fileId = "foo";

4280 var arg_permissionId = "foo";

4281 var arg_transferOwnership = true;

4282 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4283 var obj = new api.Permission.fromJson(json);

4284 checkPermission(obj);

4285

4286 var path = (req.url).path;

4287 var pathOffset = 0;

4288 var index;

4289 var subPart;

4290 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4291 pathOffset += 10;

4292 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4293 pathOffset += 6;

4294 index = path.indexOf("/permissions/", pathOffset);

4295 unittest.expect(index >= 0, unittest.isTrue);

4296 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4297 pathOffset = index;

4298 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4299 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/permissions/"));

4300 pathOffset += 13;

4301 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4302 pathOffset = path.length;

4303 unittest.expect(subPart, unittest.equals("$arg_permissionId"));

4304

4305 var query = (req.url).query;

4306 var queryOffset = 0;

4307 var queryMap = {};

4308 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4309 parseBool(n) {

4310 if (n == "true") return true;

4311 if (n == "false") return false;

4312 if (n == null) return null;

4313 throw new core.ArgumentError("Invalid boolean: $n");

4314 }

4315 if (query.length > 0) {

4316 for (var part in query.split("&")) {

4317 var keyvalue = part.split("=");

4318 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4319 }

4320 }

4321 unittest.expect(queryMap["transferOwnership"].first, unittest.equals("$a rg_transferOwnership"));

4322

4323

4324 var h = {

4325 "content-type" : "application/json; charset=utf-8",

4326 };

4327 var resp = convert.JSON.encode(buildPermission());

4328 return new async.Future.value(common_test.stringResponse(200, h, resp));

4329 }), true);

4330 res.update(arg_request, arg_fileId, arg_permissionId, transferOwnership: a rg_transferOwnership).then(unittest.expectAsync(((api.Permission response) {

4331 checkPermission(response);

4332 })));

4333 });

4334

4335 });

4336

4337

4338 unittest.group("resource-PropertiesResourceApi", () {

4339 unittest.test("method--delete", () {

4340

4341 var mock = new common_test.HttpServerMock();

4342 api.PropertiesResourceApi res = new api.DriveApi(mock).properties;

4343 var arg_fileId = "foo";

4344 var arg_propertyKey = "foo";

4345 var arg_visibility = "foo";

4346 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4347 var path = (req.url).path;

4348 var pathOffset = 0;

4349 var index;

4350 var subPart;

4351 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4352 pathOffset += 10;

4353 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4354 pathOffset += 6;

4355 index = path.indexOf("/properties/", pathOffset);

4356 unittest.expect(index >= 0, unittest.isTrue);

4357 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4358 pathOffset = index;

4359 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4360 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/properties/"));

4361 pathOffset += 12;

4362 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4363 pathOffset = path.length;

4364 unittest.expect(subPart, unittest.equals("$arg_propertyKey"));

4365

4366 var query = (req.url).query;

4367 var queryOffset = 0;

4368 var queryMap = {};

4369 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4370 parseBool(n) {

4371 if (n == "true") return true;

4372 if (n == "false") return false;

4373 if (n == null) return null;

4374 throw new core.ArgumentError("Invalid boolean: $n");

4375 }

4376 if (query.length > 0) {

4377 for (var part in query.split("&")) {

4378 var keyvalue = part.split("=");

4379 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4380 }

4381 }

4382 unittest.expect(queryMap["visibility"].first, unittest.equals(arg_visibi lity));

4383

4384

4385 var h = {

4386 "content-type" : "application/json; charset=utf-8",

4387 };

4388 var resp = "";

4389 return new async.Future.value(common_test.stringResponse(200, h, resp));

4390 }), true);

4391 res.delete(arg_fileId, arg_propertyKey, visibility: arg_visibility).then(u nittest.expectAsync((_) {}));

4392 });

4393

4394 unittest.test("method--get", () {

4395

4396 var mock = new common_test.HttpServerMock();

4397 api.PropertiesResourceApi res = new api.DriveApi(mock).properties;

4398 var arg_fileId = "foo";

4399 var arg_propertyKey = "foo";

4400 var arg_visibility = "foo";

4401 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4402 var path = (req.url).path;

4403 var pathOffset = 0;

4404 var index;

4405 var subPart;

4406 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4407 pathOffset += 10;

4408 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4409 pathOffset += 6;

4410 index = path.indexOf("/properties/", pathOffset);

4411 unittest.expect(index >= 0, unittest.isTrue);

4412 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4413 pathOffset = index;

4414 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4415 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/properties/"));

4416 pathOffset += 12;

4417 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4418 pathOffset = path.length;

4419 unittest.expect(subPart, unittest.equals("$arg_propertyKey"));

4420

4421 var query = (req.url).query;

4422 var queryOffset = 0;

4423 var queryMap = {};

4424 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4425 parseBool(n) {

4426 if (n == "true") return true;

4427 if (n == "false") return false;

4428 if (n == null) return null;

4429 throw new core.ArgumentError("Invalid boolean: $n");

4430 }

4431 if (query.length > 0) {

4432 for (var part in query.split("&")) {

4433 var keyvalue = part.split("=");

4434 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4435 }

4436 }

4437 unittest.expect(queryMap["visibility"].first, unittest.equals(arg_visibi lity));

4438

4439

4440 var h = {

4441 "content-type" : "application/json; charset=utf-8",

4442 };

4443 var resp = convert.JSON.encode(buildProperty());

4444 return new async.Future.value(common_test.stringResponse(200, h, resp));

4445 }), true);

4446 res.get(arg_fileId, arg_propertyKey, visibility: arg_visibility).then(unit test.expectAsync(((api.Property response) {

4447 checkProperty(response);

4448 })));

4449 });

4450

4451 unittest.test("method--insert", () {

4452

4453 var mock = new common_test.HttpServerMock();

4454 api.PropertiesResourceApi res = new api.DriveApi(mock).properties;

4455 var arg_request = buildProperty();

4456 var arg_fileId = "foo";

4457 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4458 var obj = new api.Property.fromJson(json);

4459 checkProperty(obj);

4460

4461 var path = (req.url).path;

4462 var pathOffset = 0;

4463 var index;

4464 var subPart;

4465 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4466 pathOffset += 10;

4467 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4468 pathOffset += 6;

4469 index = path.indexOf("/properties", pathOffset);

4470 unittest.expect(index >= 0, unittest.isTrue);

4471 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4472 pathOffset = index;

4473 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4474 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/properties"));

4475 pathOffset += 11;

4476

4477 var query = (req.url).query;

4478 var queryOffset = 0;

4479 var queryMap = {};

4480 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4481 parseBool(n) {

4482 if (n == "true") return true;

4483 if (n == "false") return false;

4484 if (n == null) return null;

4485 throw new core.ArgumentError("Invalid boolean: $n");

4486 }

4487 if (query.length > 0) {

4488 for (var part in query.split("&")) {

4489 var keyvalue = part.split("=");

4490 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4491 }

4492 }

4493

4494

4495 var h = {

4496 "content-type" : "application/json; charset=utf-8",

4497 };

4498 var resp = convert.JSON.encode(buildProperty());

4499 return new async.Future.value(common_test.stringResponse(200, h, resp));

4500 }), true);

4501 res.insert(arg_request, arg_fileId).then(unittest.expectAsync(((api.Proper ty response) {

4502 checkProperty(response);

4503 })));

4504 });

4505

4506 unittest.test("method--list", () {

4507

4508 var mock = new common_test.HttpServerMock();

4509 api.PropertiesResourceApi res = new api.DriveApi(mock).properties;

4510 var arg_fileId = "foo";

4511 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4512 var path = (req.url).path;

4513 var pathOffset = 0;

4514 var index;

4515 var subPart;

4516 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4517 pathOffset += 10;

4518 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4519 pathOffset += 6;

4520 index = path.indexOf("/properties", pathOffset);

4521 unittest.expect(index >= 0, unittest.isTrue);

4522 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4523 pathOffset = index;

4524 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4525 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/properties"));

4526 pathOffset += 11;

4527

4528 var query = (req.url).query;

4529 var queryOffset = 0;

4530 var queryMap = {};

4531 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4532 parseBool(n) {

4533 if (n == "true") return true;

4534 if (n == "false") return false;

4535 if (n == null) return null;

4536 throw new core.ArgumentError("Invalid boolean: $n");

4537 }

4538 if (query.length > 0) {

4539 for (var part in query.split("&")) {

4540 var keyvalue = part.split("=");

4541 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4542 }

4543 }

4544

4545

4546 var h = {

4547 "content-type" : "application/json; charset=utf-8",

4548 };

4549 var resp = convert.JSON.encode(buildPropertyList());

4550 return new async.Future.value(common_test.stringResponse(200, h, resp));

4551 }), true);

4552 res.list(arg_fileId).then(unittest.expectAsync(((api.PropertyList response ) {

4553 checkPropertyList(response);

4554 })));

4555 });

4556

4557 unittest.test("method--patch", () {

4558

4559 var mock = new common_test.HttpServerMock();

4560 api.PropertiesResourceApi res = new api.DriveApi(mock).properties;

4561 var arg_request = buildProperty();

4562 var arg_fileId = "foo";

4563 var arg_propertyKey = "foo";

4564 var arg_visibility = "foo";

4565 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4566 var obj = new api.Property.fromJson(json);

4567 checkProperty(obj);

4568

4569 var path = (req.url).path;

4570 var pathOffset = 0;

4571 var index;

4572 var subPart;

4573 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4574 pathOffset += 10;

4575 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4576 pathOffset += 6;

4577 index = path.indexOf("/properties/", pathOffset);

4578 unittest.expect(index >= 0, unittest.isTrue);

4579 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4580 pathOffset = index;

4581 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4582 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/properties/"));

4583 pathOffset += 12;

4584 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4585 pathOffset = path.length;

4586 unittest.expect(subPart, unittest.equals("$arg_propertyKey"));

4587

4588 var query = (req.url).query;

4589 var queryOffset = 0;

4590 var queryMap = {};

4591 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4592 parseBool(n) {

4593 if (n == "true") return true;

4594 if (n == "false") return false;

4595 if (n == null) return null;

4596 throw new core.ArgumentError("Invalid boolean: $n");

4597 }

4598 if (query.length > 0) {

4599 for (var part in query.split("&")) {

4600 var keyvalue = part.split("=");

4601 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4602 }

4603 }

4604 unittest.expect(queryMap["visibility"].first, unittest.equals(arg_visibi lity));

4605

4606

4607 var h = {

4608 "content-type" : "application/json; charset=utf-8",

4609 };

4610 var resp = convert.JSON.encode(buildProperty());

4611 return new async.Future.value(common_test.stringResponse(200, h, resp));

4612 }), true);

4613 res.patch(arg_request, arg_fileId, arg_propertyKey, visibility: arg_visibi lity).then(unittest.expectAsync(((api.Property response) {

4614 checkProperty(response);

4615 })));

4616 });

4617

4618 unittest.test("method--update", () {

4619

4620 var mock = new common_test.HttpServerMock();

4621 api.PropertiesResourceApi res = new api.DriveApi(mock).properties;

4622 var arg_request = buildProperty();

4623 var arg_fileId = "foo";

4624 var arg_propertyKey = "foo";

4625 var arg_visibility = "foo";

4626 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4627 var obj = new api.Property.fromJson(json);

4628 checkProperty(obj);

4629

4630 var path = (req.url).path;

4631 var pathOffset = 0;

4632 var index;

4633 var subPart;

4634 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4635 pathOffset += 10;

4636 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4637 pathOffset += 6;

4638 index = path.indexOf("/properties/", pathOffset);

4639 unittest.expect(index >= 0, unittest.isTrue);

4640 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4641 pathOffset = index;

4642 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4643 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/properties/"));

4644 pathOffset += 12;

4645 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4646 pathOffset = path.length;

4647 unittest.expect(subPart, unittest.equals("$arg_propertyKey"));

4648

4649 var query = (req.url).query;

4650 var queryOffset = 0;

4651 var queryMap = {};

4652 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4653 parseBool(n) {

4654 if (n == "true") return true;

4655 if (n == "false") return false;

4656 if (n == null) return null;

4657 throw new core.ArgumentError("Invalid boolean: $n");

4658 }

4659 if (query.length > 0) {

4660 for (var part in query.split("&")) {

4661 var keyvalue = part.split("=");

4662 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4663 }

4664 }

4665 unittest.expect(queryMap["visibility"].first, unittest.equals(arg_visibi lity));

4666

4667

4668 var h = {

4669 "content-type" : "application/json; charset=utf-8",

4670 };

4671 var resp = convert.JSON.encode(buildProperty());

4672 return new async.Future.value(common_test.stringResponse(200, h, resp));

4673 }), true);

4674 res.update(arg_request, arg_fileId, arg_propertyKey, visibility: arg_visib ility).then(unittest.expectAsync(((api.Property response) {

4675 checkProperty(response);

4676 })));

4677 });

4678

4679 });

4680

4681

4682 unittest.group("resource-RealtimeResourceApi", () {

4683 unittest.test("method--get", () {

4684 // TODO: Implement tests for media upload;

4685 // TODO: Implement tests for media download;

4686

4687 var mock = new common_test.HttpServerMock();

4688 api.RealtimeResourceApi res = new api.DriveApi(mock).realtime;

4689 var arg_fileId = "foo";

4690 var arg_revision = 42;

4691 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4692 var path = (req.url).path;

4693 var pathOffset = 0;

4694 var index;

4695 var subPart;

4696 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4697 pathOffset += 10;

4698 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4699 pathOffset += 6;

4700 index = path.indexOf("/realtime", pathOffset);

4701 unittest.expect(index >= 0, unittest.isTrue);

4702 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4703 pathOffset = index;

4704 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4705 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/realtime"));

4706 pathOffset += 9;

4707

4708 var query = (req.url).query;

4709 var queryOffset = 0;

4710 var queryMap = {};

4711 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4712 parseBool(n) {

4713 if (n == "true") return true;

4714 if (n == "false") return false;

4715 if (n == null) return null;

4716 throw new core.ArgumentError("Invalid boolean: $n");

4717 }

4718 if (query.length > 0) {

4719 for (var part in query.split("&")) {

4720 var keyvalue = part.split("=");

4721 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4722 }

4723 }

4724 unittest.expect(core.int.parse(queryMap["revision"].first), unittest.equ als(arg_revision));

4725

4726

4727 var h = {

4728 "content-type" : "application/json; charset=utf-8",

4729 };

4730 var resp = "";

4731 return new async.Future.value(common_test.stringResponse(200, h, resp));

4732 }), true);

4733 res.get(arg_fileId, revision: arg_revision).then(unittest.expectAsync((_) {}));

4734 });

4735

4736 unittest.test("method--update", () {

4737 // TODO: Implement tests for media upload;

4738 // TODO: Implement tests for media download;

4739

4740 var mock = new common_test.HttpServerMock();

4741 api.RealtimeResourceApi res = new api.DriveApi(mock).realtime;

4742 var arg_fileId = "foo";

4743 var arg_baseRevision = "foo";

4744 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4745 var path = (req.url).path;

4746 var pathOffset = 0;

4747 var index;

4748 var subPart;

4749 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4750 pathOffset += 10;

4751 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4752 pathOffset += 6;

4753 index = path.indexOf("/realtime", pathOffset);

4754 unittest.expect(index >= 0, unittest.isTrue);

4755 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4756 pathOffset = index;

4757 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4758 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/realtime"));

4759 pathOffset += 9;

4760

4761 var query = (req.url).query;

4762 var queryOffset = 0;

4763 var queryMap = {};

4764 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4765 parseBool(n) {

4766 if (n == "true") return true;

4767 if (n == "false") return false;

4768 if (n == null) return null;

4769 throw new core.ArgumentError("Invalid boolean: $n");

4770 }

4771 if (query.length > 0) {

4772 for (var part in query.split("&")) {

4773 var keyvalue = part.split("=");

4774 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4775 }

4776 }

4777 unittest.expect(queryMap["baseRevision"].first, unittest.equals(arg_base Revision));

4778

4779

4780 var h = {

4781 "content-type" : "application/json; charset=utf-8",

4782 };

4783 var resp = "";

4784 return new async.Future.value(common_test.stringResponse(200, h, resp));

4785 }), true);

4786 res.update(arg_fileId, baseRevision: arg_baseRevision).then(unittest.expec tAsync((_) {}));

4787 });

4788

4789 });

4790

4791

4792 unittest.group("resource-RepliesResourceApi", () {

4793 unittest.test("method--delete", () {

4794

4795 var mock = new common_test.HttpServerMock();

4796 api.RepliesResourceApi res = new api.DriveApi(mock).replies;

4797 var arg_fileId = "foo";

4798 var arg_commentId = "foo";

4799 var arg_replyId = "foo";

4800 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4801 var path = (req.url).path;

4802 var pathOffset = 0;

4803 var index;

4804 var subPart;

4805 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4806 pathOffset += 10;

4807 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4808 pathOffset += 6;

4809 index = path.indexOf("/comments/", pathOffset);

4810 unittest.expect(index >= 0, unittest.isTrue);

4811 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4812 pathOffset = index;

4813 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4814 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/comments/"));

4815 pathOffset += 10;

4816 index = path.indexOf("/replies/", pathOffset);

4817 unittest.expect(index >= 0, unittest.isTrue);

4818 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4819 pathOffset = index;

4820 unittest.expect(subPart, unittest.equals("$arg_commentId"));

4821 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/replies/"));

4822 pathOffset += 9;

4823 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4824 pathOffset = path.length;

4825 unittest.expect(subPart, unittest.equals("$arg_replyId"));

4826

4827 var query = (req.url).query;

4828 var queryOffset = 0;

4829 var queryMap = {};

4830 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4831 parseBool(n) {

4832 if (n == "true") return true;

4833 if (n == "false") return false;

4834 if (n == null) return null;

4835 throw new core.ArgumentError("Invalid boolean: $n");

4836 }

4837 if (query.length > 0) {

4838 for (var part in query.split("&")) {

4839 var keyvalue = part.split("=");

4840 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4841 }

4842 }

4843

4844

4845 var h = {

4846 "content-type" : "application/json; charset=utf-8",

4847 };

4848 var resp = "";

4849 return new async.Future.value(common_test.stringResponse(200, h, resp));

4850 }), true);

4851 res.delete(arg_fileId, arg_commentId, arg_replyId).then(unittest.expectAsy nc((_) {}));

4852 });

4853

4854 unittest.test("method--get", () {

4855

4856 var mock = new common_test.HttpServerMock();

4857 api.RepliesResourceApi res = new api.DriveApi(mock).replies;

4858 var arg_fileId = "foo";

4859 var arg_commentId = "foo";

4860 var arg_replyId = "foo";

4861 var arg_includeDeleted = true;

4862 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4863 var path = (req.url).path;

4864 var pathOffset = 0;

4865 var index;

4866 var subPart;

4867 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4868 pathOffset += 10;

4869 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4870 pathOffset += 6;

4871 index = path.indexOf("/comments/", pathOffset);

4872 unittest.expect(index >= 0, unittest.isTrue);

4873 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4874 pathOffset = index;

4875 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4876 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/comments/"));

4877 pathOffset += 10;

4878 index = path.indexOf("/replies/", pathOffset);

4879 unittest.expect(index >= 0, unittest.isTrue);

4880 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4881 pathOffset = index;

4882 unittest.expect(subPart, unittest.equals("$arg_commentId"));

4883 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/replies/"));

4884 pathOffset += 9;

4885 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4886 pathOffset = path.length;

4887 unittest.expect(subPart, unittest.equals("$arg_replyId"));

4888

4889 var query = (req.url).query;

4890 var queryOffset = 0;

4891 var queryMap = {};

4892 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4893 parseBool(n) {

4894 if (n == "true") return true;

4895 if (n == "false") return false;

4896 if (n == null) return null;

4897 throw new core.ArgumentError("Invalid boolean: $n");

4898 }

4899 if (query.length > 0) {

4900 for (var part in query.split("&")) {

4901 var keyvalue = part.split("=");

4902 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4903 }

4904 }

4905 unittest.expect(queryMap["includeDeleted"].first, unittest.equals("$arg_ includeDeleted"));

4906

4907

4908 var h = {

4909 "content-type" : "application/json; charset=utf-8",

4910 };

4911 var resp = convert.JSON.encode(buildCommentReply());

4912 return new async.Future.value(common_test.stringResponse(200, h, resp));

4913 }), true);

4914 res.get(arg_fileId, arg_commentId, arg_replyId, includeDeleted: arg_includ eDeleted).then(unittest.expectAsync(((api.CommentReply response) {

4915 checkCommentReply(response);

4916 })));

4917 });

4918

4919 unittest.test("method--insert", () {

4920

4921 var mock = new common_test.HttpServerMock();

4922 api.RepliesResourceApi res = new api.DriveApi(mock).replies;

4923 var arg_request = buildCommentReply();

4924 var arg_fileId = "foo";

4925 var arg_commentId = "foo";

4926 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4927 var obj = new api.CommentReply.fromJson(json);

4928 checkCommentReply(obj);

4929

4930 var path = (req.url).path;

4931 var pathOffset = 0;

4932 var index;

4933 var subPart;

4934 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4935 pathOffset += 10;

4936 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4937 pathOffset += 6;

4938 index = path.indexOf("/comments/", pathOffset);

4939 unittest.expect(index >= 0, unittest.isTrue);

4940 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4941 pathOffset = index;

4942 unittest.expect(subPart, unittest.equals("$arg_fileId"));

4943 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/comments/"));

4944 pathOffset += 10;

4945 index = path.indexOf("/replies", pathOffset);

4946 unittest.expect(index >= 0, unittest.isTrue);

4947 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4948 pathOffset = index;

4949 unittest.expect(subPart, unittest.equals("$arg_commentId"));

4950 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/replies"));

4951 pathOffset += 8;

4952

4953 var query = (req.url).query;

4954 var queryOffset = 0;

4955 var queryMap = {};

4956 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4957 parseBool(n) {

4958 if (n == "true") return true;

4959 if (n == "false") return false;

4960 if (n == null) return null;

4961 throw new core.ArgumentError("Invalid boolean: $n");

4962 }

4963 if (query.length > 0) {

4964 for (var part in query.split("&")) {

4965 var keyvalue = part.split("=");

4966 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4967 }

4968 }

4969

4970

4971 var h = {

4972 "content-type" : "application/json; charset=utf-8",

4973 };

4974 var resp = convert.JSON.encode(buildCommentReply());

4975 return new async.Future.value(common_test.stringResponse(200, h, resp));

4976 }), true);

4977 res.insert(arg_request, arg_fileId, arg_commentId).then(unittest.expectAsy nc(((api.CommentReply response) {

4978 checkCommentReply(response);

4979 })));

4980 });

4981

4982 unittest.test("method--list", () {

4983

4984 var mock = new common_test.HttpServerMock();

4985 api.RepliesResourceApi res = new api.DriveApi(mock).replies;

4986 var arg_fileId = "foo";

4987 var arg_commentId = "foo";

4988 var arg_includeDeleted = true;

4989 var arg_maxResults = 42;

4990 var arg_pageToken = "foo";

4991 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4992 var path = (req.url).path;

4993 var pathOffset = 0;

4994 var index;

4995 var subPart;

4996 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

4997 pathOffset += 10;

4998 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

4999 pathOffset += 6;

5000 index = path.indexOf("/comments/", pathOffset);

5001 unittest.expect(index >= 0, unittest.isTrue);

5002 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5003 pathOffset = index;

5004 unittest.expect(subPart, unittest.equals("$arg_fileId"));

5005 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/comments/"));

5006 pathOffset += 10;

5007 index = path.indexOf("/replies", pathOffset);

5008 unittest.expect(index >= 0, unittest.isTrue);

5009 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5010 pathOffset = index;

5011 unittest.expect(subPart, unittest.equals("$arg_commentId"));

5012 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/replies"));

5013 pathOffset += 8;

5014

5015 var query = (req.url).query;

5016 var queryOffset = 0;

5017 var queryMap = {};

5018 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5019 parseBool(n) {

5020 if (n == "true") return true;

5021 if (n == "false") return false;

5022 if (n == null) return null;

5023 throw new core.ArgumentError("Invalid boolean: $n");

5024 }

5025 if (query.length > 0) {

5026 for (var part in query.split("&")) {

5027 var keyvalue = part.split("=");

5028 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5029 }

5030 }

5031 unittest.expect(queryMap["includeDeleted"].first, unittest.equals("$arg_ includeDeleted"));

5032 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

5033 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

5034

5035

5036 var h = {

5037 "content-type" : "application/json; charset=utf-8",

5038 };

5039 var resp = convert.JSON.encode(buildCommentReplyList());

5040 return new async.Future.value(common_test.stringResponse(200, h, resp));

5041 }), true);

5042 res.list(arg_fileId, arg_commentId, includeDeleted: arg_includeDeleted, ma xResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync((( api.CommentReplyList response) {

5043 checkCommentReplyList(response);

5044 })));

5045 });

5046

5047 unittest.test("method--patch", () {

5048

5049 var mock = new common_test.HttpServerMock();

5050 api.RepliesResourceApi res = new api.DriveApi(mock).replies;

5051 var arg_request = buildCommentReply();

5052 var arg_fileId = "foo";

5053 var arg_commentId = "foo";

5054 var arg_replyId = "foo";

5055 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5056 var obj = new api.CommentReply.fromJson(json);

5057 checkCommentReply(obj);

5058

5059 var path = (req.url).path;

5060 var pathOffset = 0;

5061 var index;

5062 var subPart;

5063 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

5064 pathOffset += 10;

5065 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

5066 pathOffset += 6;

5067 index = path.indexOf("/comments/", pathOffset);

5068 unittest.expect(index >= 0, unittest.isTrue);

5069 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5070 pathOffset = index;

5071 unittest.expect(subPart, unittest.equals("$arg_fileId"));

5072 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/comments/"));

5073 pathOffset += 10;

5074 index = path.indexOf("/replies/", pathOffset);

5075 unittest.expect(index >= 0, unittest.isTrue);

5076 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5077 pathOffset = index;

5078 unittest.expect(subPart, unittest.equals("$arg_commentId"));

5079 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/replies/"));

5080 pathOffset += 9;

5081 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5082 pathOffset = path.length;

5083 unittest.expect(subPart, unittest.equals("$arg_replyId"));

5084

5085 var query = (req.url).query;

5086 var queryOffset = 0;

5087 var queryMap = {};

5088 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5089 parseBool(n) {

5090 if (n == "true") return true;

5091 if (n == "false") return false;

5092 if (n == null) return null;

5093 throw new core.ArgumentError("Invalid boolean: $n");

5094 }

5095 if (query.length > 0) {

5096 for (var part in query.split("&")) {

5097 var keyvalue = part.split("=");

5098 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5099 }

5100 }

5101

5102

5103 var h = {

5104 "content-type" : "application/json; charset=utf-8",

5105 };

5106 var resp = convert.JSON.encode(buildCommentReply());

5107 return new async.Future.value(common_test.stringResponse(200, h, resp));

5108 }), true);

5109 res.patch(arg_request, arg_fileId, arg_commentId, arg_replyId).then(unitte st.expectAsync(((api.CommentReply response) {

5110 checkCommentReply(response);

5111 })));

5112 });

5113

5114 unittest.test("method--update", () {

5115

5116 var mock = new common_test.HttpServerMock();

5117 api.RepliesResourceApi res = new api.DriveApi(mock).replies;

5118 var arg_request = buildCommentReply();

5119 var arg_fileId = "foo";

5120 var arg_commentId = "foo";

5121 var arg_replyId = "foo";

5122 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5123 var obj = new api.CommentReply.fromJson(json);

5124 checkCommentReply(obj);

5125

5126 var path = (req.url).path;

5127 var pathOffset = 0;

5128 var index;

5129 var subPart;

5130 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

5131 pathOffset += 10;

5132 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

5133 pathOffset += 6;

5134 index = path.indexOf("/comments/", pathOffset);

5135 unittest.expect(index >= 0, unittest.isTrue);

5136 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5137 pathOffset = index;

5138 unittest.expect(subPart, unittest.equals("$arg_fileId"));

5139 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/comments/"));

5140 pathOffset += 10;

5141 index = path.indexOf("/replies/", pathOffset);

5142 unittest.expect(index >= 0, unittest.isTrue);

5143 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5144 pathOffset = index;

5145 unittest.expect(subPart, unittest.equals("$arg_commentId"));

5146 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/replies/"));

5147 pathOffset += 9;

5148 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5149 pathOffset = path.length;

5150 unittest.expect(subPart, unittest.equals("$arg_replyId"));

5151

5152 var query = (req.url).query;

5153 var queryOffset = 0;

5154 var queryMap = {};

5155 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5156 parseBool(n) {

5157 if (n == "true") return true;

5158 if (n == "false") return false;

5159 if (n == null) return null;

5160 throw new core.ArgumentError("Invalid boolean: $n");

5161 }

5162 if (query.length > 0) {

5163 for (var part in query.split("&")) {

5164 var keyvalue = part.split("=");

5165 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5166 }

5167 }

5168

5169

5170 var h = {

5171 "content-type" : "application/json; charset=utf-8",

5172 };

5173 var resp = convert.JSON.encode(buildCommentReply());

5174 return new async.Future.value(common_test.stringResponse(200, h, resp));

5175 }), true);

5176 res.update(arg_request, arg_fileId, arg_commentId, arg_replyId).then(unitt est.expectAsync(((api.CommentReply response) {

5177 checkCommentReply(response);

5178 })));

5179 });

5180

5181 });

5182

5183

5184 unittest.group("resource-RevisionsResourceApi", () {

5185 unittest.test("method--delete", () {

5186

5187 var mock = new common_test.HttpServerMock();

5188 api.RevisionsResourceApi res = new api.DriveApi(mock).revisions;

5189 var arg_fileId = "foo";

5190 var arg_revisionId = "foo";

5191 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5192 var path = (req.url).path;

5193 var pathOffset = 0;

5194 var index;

5195 var subPart;

5196 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

5197 pathOffset += 10;

5198 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

5199 pathOffset += 6;

5200 index = path.indexOf("/revisions/", pathOffset);

5201 unittest.expect(index >= 0, unittest.isTrue);

5202 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5203 pathOffset = index;

5204 unittest.expect(subPart, unittest.equals("$arg_fileId"));

5205 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/revisions/"));

5206 pathOffset += 11;

5207 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5208 pathOffset = path.length;

5209 unittest.expect(subPart, unittest.equals("$arg_revisionId"));

5210

5211 var query = (req.url).query;

5212 var queryOffset = 0;

5213 var queryMap = {};

5214 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5215 parseBool(n) {

5216 if (n == "true") return true;

5217 if (n == "false") return false;

5218 if (n == null) return null;

5219 throw new core.ArgumentError("Invalid boolean: $n");

5220 }

5221 if (query.length > 0) {

5222 for (var part in query.split("&")) {

5223 var keyvalue = part.split("=");

5224 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5225 }

5226 }

5227

5228

5229 var h = {

5230 "content-type" : "application/json; charset=utf-8",

5231 };

5232 var resp = "";

5233 return new async.Future.value(common_test.stringResponse(200, h, resp));

5234 }), true);

5235 res.delete(arg_fileId, arg_revisionId).then(unittest.expectAsync((_) {}));

5236 });

5237

5238 unittest.test("method--get", () {

5239

5240 var mock = new common_test.HttpServerMock();

5241 api.RevisionsResourceApi res = new api.DriveApi(mock).revisions;

5242 var arg_fileId = "foo";

5243 var arg_revisionId = "foo";

5244 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5245 var path = (req.url).path;

5246 var pathOffset = 0;

5247 var index;

5248 var subPart;

5249 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

5250 pathOffset += 10;

5251 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

5252 pathOffset += 6;

5253 index = path.indexOf("/revisions/", pathOffset);

5254 unittest.expect(index >= 0, unittest.isTrue);

5255 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5256 pathOffset = index;

5257 unittest.expect(subPart, unittest.equals("$arg_fileId"));

5258 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/revisions/"));

5259 pathOffset += 11;

5260 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5261 pathOffset = path.length;

5262 unittest.expect(subPart, unittest.equals("$arg_revisionId"));

5263

5264 var query = (req.url).query;

5265 var queryOffset = 0;

5266 var queryMap = {};

5267 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5268 parseBool(n) {

5269 if (n == "true") return true;

5270 if (n == "false") return false;

5271 if (n == null) return null;

5272 throw new core.ArgumentError("Invalid boolean: $n");

5273 }

5274 if (query.length > 0) {

5275 for (var part in query.split("&")) {

5276 var keyvalue = part.split("=");

5277 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5278 }

5279 }

5280

5281

5282 var h = {

5283 "content-type" : "application/json; charset=utf-8",

5284 };

5285 var resp = convert.JSON.encode(buildRevision());

5286 return new async.Future.value(common_test.stringResponse(200, h, resp));

5287 }), true);

5288 res.get(arg_fileId, arg_revisionId).then(unittest.expectAsync(((api.Revisi on response) {

5289 checkRevision(response);

5290 })));

5291 });

5292

5293 unittest.test("method--list", () {

5294

5295 var mock = new common_test.HttpServerMock();

5296 api.RevisionsResourceApi res = new api.DriveApi(mock).revisions;

5297 var arg_fileId = "foo";

5298 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5299 var path = (req.url).path;

5300 var pathOffset = 0;

5301 var index;

5302 var subPart;

5303 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

5304 pathOffset += 10;

5305 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

5306 pathOffset += 6;

5307 index = path.indexOf("/revisions", pathOffset);

5308 unittest.expect(index >= 0, unittest.isTrue);

5309 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5310 pathOffset = index;

5311 unittest.expect(subPart, unittest.equals("$arg_fileId"));

5312 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/revisions"));

5313 pathOffset += 10;

5314

5315 var query = (req.url).query;

5316 var queryOffset = 0;

5317 var queryMap = {};

5318 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5319 parseBool(n) {

5320 if (n == "true") return true;

5321 if (n == "false") return false;

5322 if (n == null) return null;

5323 throw new core.ArgumentError("Invalid boolean: $n");

5324 }

5325 if (query.length > 0) {

5326 for (var part in query.split("&")) {

5327 var keyvalue = part.split("=");

5328 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5329 }

5330 }

5331

5332

5333 var h = {

5334 "content-type" : "application/json; charset=utf-8",

5335 };

5336 var resp = convert.JSON.encode(buildRevisionList());

5337 return new async.Future.value(common_test.stringResponse(200, h, resp));

5338 }), true);

5339 res.list(arg_fileId).then(unittest.expectAsync(((api.RevisionList response ) {

5340 checkRevisionList(response);

5341 })));

5342 });

5343

5344 unittest.test("method--patch", () {

5345

5346 var mock = new common_test.HttpServerMock();

5347 api.RevisionsResourceApi res = new api.DriveApi(mock).revisions;

5348 var arg_request = buildRevision();

5349 var arg_fileId = "foo";

5350 var arg_revisionId = "foo";

5351 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5352 var obj = new api.Revision.fromJson(json);

5353 checkRevision(obj);

5354

5355 var path = (req.url).path;

5356 var pathOffset = 0;

5357 var index;

5358 var subPart;

5359 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

5360 pathOffset += 10;

5361 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

5362 pathOffset += 6;

5363 index = path.indexOf("/revisions/", pathOffset);

5364 unittest.expect(index >= 0, unittest.isTrue);

5365 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5366 pathOffset = index;

5367 unittest.expect(subPart, unittest.equals("$arg_fileId"));

5368 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/revisions/"));

5369 pathOffset += 11;

5370 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5371 pathOffset = path.length;

5372 unittest.expect(subPart, unittest.equals("$arg_revisionId"));

5373

5374 var query = (req.url).query;

5375 var queryOffset = 0;

5376 var queryMap = {};

5377 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5378 parseBool(n) {

5379 if (n == "true") return true;

5380 if (n == "false") return false;

5381 if (n == null) return null;

5382 throw new core.ArgumentError("Invalid boolean: $n");

5383 }

5384 if (query.length > 0) {

5385 for (var part in query.split("&")) {

5386 var keyvalue = part.split("=");

5387 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5388 }

5389 }

5390

5391

5392 var h = {

5393 "content-type" : "application/json; charset=utf-8",

5394 };

5395 var resp = convert.JSON.encode(buildRevision());

5396 return new async.Future.value(common_test.stringResponse(200, h, resp));

5397 }), true);

5398 res.patch(arg_request, arg_fileId, arg_revisionId).then(unittest.expectAsy nc(((api.Revision response) {

5399 checkRevision(response);

5400 })));

5401 });

5402

5403 unittest.test("method--update", () {

5404

5405 var mock = new common_test.HttpServerMock();

5406 api.RevisionsResourceApi res = new api.DriveApi(mock).revisions;

5407 var arg_request = buildRevision();

5408 var arg_fileId = "foo";

5409 var arg_revisionId = "foo";

5410 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5411 var obj = new api.Revision.fromJson(json);

5412 checkRevision(obj);

5413

5414 var path = (req.url).path;

5415 var pathOffset = 0;

5416 var index;

5417 var subPart;

5418 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/drive/v2/"));

5419 pathOffset += 10;

5420 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("files/"));

5421 pathOffset += 6;

5422 index = path.indexOf("/revisions/", pathOffset);

5423 unittest.expect(index >= 0, unittest.isTrue);

5424 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5425 pathOffset = index;

5426 unittest.expect(subPart, unittest.equals("$arg_fileId"));

5427 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/revisions/"));

5428 pathOffset += 11;

5429 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

5430 pathOffset = path.length;

5431 unittest.expect(subPart, unittest.equals("$arg_revisionId"));

5432

5433 var query = (req.url).query;

5434 var queryOffset = 0;

5435 var queryMap = {};

5436 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5437 parseBool(n) {

5438 if (n == "true") return true;

5439 if (n == "false") return false;

5440 if (n == null) return null;

5441 throw new core.ArgumentError("Invalid boolean: $n");

5442 }

5443 if (query.length > 0) {

5444 for (var part in query.split("&")) {

5445 var keyvalue = part.split("=");

5446 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5447 }

5448 }

5449

5450

5451 var h = {

5452 "content-type" : "application/json; charset=utf-8",

5453 };

5454 var resp = convert.JSON.encode(buildRevision());

5455 return new async.Future.value(common_test.stringResponse(200, h, resp));

5456 }), true);

5457 res.update(arg_request, arg_fileId, arg_revisionId).then(unittest.expectAs ync(((api.Revision response) {

5458 checkRevision(response);

5459 })));

5460 });

5461

5462 });

5463

5464

5465 }

5466

OLD	NEW

« no previous file with comments | « generated/googleapis/test/doubleclicksearch/v2_test.dart ('k') | generated/googleapis/test/drive/v2_test.dart » ('j') | no next file with comments »