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

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

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

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

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

Jump to:

View unified diff | Download patch

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

2

3 import "dart:core" as core;

4 import "dart:collection" as collection;

5 import "dart:async" as async;

6 import "dart:convert" as convert;

7

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

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

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

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

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

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

14

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

16

17

18

19 core.int buildCounterDraft = 0;

20 buildDraft() {

21 var o = new api.Draft();

22 buildCounterDraft++;

23 if (buildCounterDraft < 3) {

24 o.id = "foo";

25 o.message = buildMessage();

26 }

27 buildCounterDraft--;

28 return o;

29 }

30

31 checkDraft(api.Draft o) {

32 buildCounterDraft++;

33 if (buildCounterDraft < 3) {

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

35 checkMessage(o.message);

36 }

37 buildCounterDraft--;

38 }

39

40 buildUnnamed187() {

41 var o = new core.List<api.Message>();

42 o.add(buildMessage());

43 o.add(buildMessage());

44 return o;

45 }

46

47 checkUnnamed187(core.List<api.Message> o) {

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

49 checkMessage(o[0]);

50 checkMessage(o[1]);

51 }

52

53 core.int buildCounterHistory = 0;

54 buildHistory() {

55 var o = new api.History();

56 buildCounterHistory++;

57 if (buildCounterHistory < 3) {

58 o.id = "foo";

59 o.messages = buildUnnamed187();

60 }

61 buildCounterHistory--;

62 return o;

63 }

64

65 checkHistory(api.History o) {

66 buildCounterHistory++;

67 if (buildCounterHistory < 3) {

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

69 checkUnnamed187(o.messages);

70 }

71 buildCounterHistory--;

72 }

73

74 core.int buildCounterLabel = 0;

75 buildLabel() {

76 var o = new api.Label();

77 buildCounterLabel++;

78 if (buildCounterLabel < 3) {

79 o.id = "foo";

80 o.labelListVisibility = "foo";

81 o.messageListVisibility = "foo";

82 o.name = "foo";

83 o.type = "foo";

84 }

85 buildCounterLabel--;

86 return o;

87 }

88

89 checkLabel(api.Label o) {

90 buildCounterLabel++;

91 if (buildCounterLabel < 3) {

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

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

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

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

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

97 }

98 buildCounterLabel--;

99 }

100

101 buildUnnamed188() {

102 var o = new core.List<api.Draft>();

103 o.add(buildDraft());

104 o.add(buildDraft());

105 return o;

106 }

107

108 checkUnnamed188(core.List<api.Draft> o) {

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

110 checkDraft(o[0]);

111 checkDraft(o[1]);

112 }

113

114 core.int buildCounterListDraftsResponse = 0;

115 buildListDraftsResponse() {

116 var o = new api.ListDraftsResponse();

117 buildCounterListDraftsResponse++;

118 if (buildCounterListDraftsResponse < 3) {

119 o.drafts = buildUnnamed188();

120 o.nextPageToken = "foo";

121 o.resultSizeEstimate = 42;

122 }

123 buildCounterListDraftsResponse--;

124 return o;

125 }

126

127 checkListDraftsResponse(api.ListDraftsResponse o) {

128 buildCounterListDraftsResponse++;

129 if (buildCounterListDraftsResponse < 3) {

130 checkUnnamed188(o.drafts);

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

132 unittest.expect(o.resultSizeEstimate, unittest.equals(42));

133 }

134 buildCounterListDraftsResponse--;

135 }

136

137 buildUnnamed189() {

138 var o = new core.List<api.History>();

139 o.add(buildHistory());

140 o.add(buildHistory());

141 return o;

142 }

143

144 checkUnnamed189(core.List<api.History> o) {

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

146 checkHistory(o[0]);

147 checkHistory(o[1]);

148 }

149

150 core.int buildCounterListHistoryResponse = 0;

151 buildListHistoryResponse() {

152 var o = new api.ListHistoryResponse();

153 buildCounterListHistoryResponse++;

154 if (buildCounterListHistoryResponse < 3) {

155 o.history = buildUnnamed189();

156 o.historyId = "foo";

157 o.nextPageToken = "foo";

158 }

159 buildCounterListHistoryResponse--;

160 return o;

161 }

162

163 checkListHistoryResponse(api.ListHistoryResponse o) {

164 buildCounterListHistoryResponse++;

165 if (buildCounterListHistoryResponse < 3) {

166 checkUnnamed189(o.history);

167 unittest.expect(o.historyId, unittest.equals('foo'));

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

169 }

170 buildCounterListHistoryResponse--;

171 }

172

173 buildUnnamed190() {

174 var o = new core.List<api.Label>();

175 o.add(buildLabel());

176 o.add(buildLabel());

177 return o;

178 }

179

180 checkUnnamed190(core.List<api.Label> o) {

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

182 checkLabel(o[0]);

183 checkLabel(o[1]);

184 }

185

186 core.int buildCounterListLabelsResponse = 0;

187 buildListLabelsResponse() {

188 var o = new api.ListLabelsResponse();

189 buildCounterListLabelsResponse++;

190 if (buildCounterListLabelsResponse < 3) {

191 o.labels = buildUnnamed190();

192 }

193 buildCounterListLabelsResponse--;

194 return o;

195 }

196

197 checkListLabelsResponse(api.ListLabelsResponse o) {

198 buildCounterListLabelsResponse++;

199 if (buildCounterListLabelsResponse < 3) {

200 checkUnnamed190(o.labels);

201 }

202 buildCounterListLabelsResponse--;

203 }

204

205 buildUnnamed191() {

206 var o = new core.List<api.Message>();

207 o.add(buildMessage());

208 o.add(buildMessage());

209 return o;

210 }

211

212 checkUnnamed191(core.List<api.Message> o) {

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

214 checkMessage(o[0]);

215 checkMessage(o[1]);

216 }

217

218 core.int buildCounterListMessagesResponse = 0;

219 buildListMessagesResponse() {

220 var o = new api.ListMessagesResponse();

221 buildCounterListMessagesResponse++;

222 if (buildCounterListMessagesResponse < 3) {

223 o.messages = buildUnnamed191();

224 o.nextPageToken = "foo";

225 o.resultSizeEstimate = 42;

226 }

227 buildCounterListMessagesResponse--;

228 return o;

229 }

230

231 checkListMessagesResponse(api.ListMessagesResponse o) {

232 buildCounterListMessagesResponse++;

233 if (buildCounterListMessagesResponse < 3) {

234 checkUnnamed191(o.messages);

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

236 unittest.expect(o.resultSizeEstimate, unittest.equals(42));

237 }

238 buildCounterListMessagesResponse--;

239 }

240

241 buildUnnamed192() {

242 var o = new core.List<api.Thread>();

243 o.add(buildThread());

244 o.add(buildThread());

245 return o;

246 }

247

248 checkUnnamed192(core.List<api.Thread> o) {

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

250 checkThread(o[0]);

251 checkThread(o[1]);

252 }

253

254 core.int buildCounterListThreadsResponse = 0;

255 buildListThreadsResponse() {

256 var o = new api.ListThreadsResponse();

257 buildCounterListThreadsResponse++;

258 if (buildCounterListThreadsResponse < 3) {

259 o.nextPageToken = "foo";

260 o.resultSizeEstimate = 42;

261 o.threads = buildUnnamed192();

262 }

263 buildCounterListThreadsResponse--;

264 return o;

265 }

266

267 checkListThreadsResponse(api.ListThreadsResponse o) {

268 buildCounterListThreadsResponse++;

269 if (buildCounterListThreadsResponse < 3) {

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

271 unittest.expect(o.resultSizeEstimate, unittest.equals(42));

272 checkUnnamed192(o.threads);

273 }

274 buildCounterListThreadsResponse--;

275 }

276

277 buildUnnamed193() {

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

279 o.add("foo");

280 o.add("foo");

281 return o;

282 }

283

284 checkUnnamed193(core.List<core.String> o) {

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

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

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

288 }

289

290 core.int buildCounterMessage = 0;

291 buildMessage() {

292 var o = new api.Message();

293 buildCounterMessage++;

294 if (buildCounterMessage < 3) {

295 o.historyId = "foo";

296 o.id = "foo";

297 o.labelIds = buildUnnamed193();

298 o.payload = buildMessagePart();

299 o.raw = "foo";

300 o.sizeEstimate = 42;

301 o.snippet = "foo";

302 o.threadId = "foo";

303 }

304 buildCounterMessage--;

305 return o;

306 }

307

308 checkMessage(api.Message o) {

309 buildCounterMessage++;

310 if (buildCounterMessage < 3) {

311 unittest.expect(o.historyId, unittest.equals('foo'));

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

313 checkUnnamed193(o.labelIds);

314 checkMessagePart(o.payload);

315 unittest.expect(o.raw, unittest.equals('foo'));

316 unittest.expect(o.sizeEstimate, unittest.equals(42));

317 unittest.expect(o.snippet, unittest.equals('foo'));

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

319 }

320 buildCounterMessage--;

321 }

322

323 buildUnnamed194() {

324 var o = new core.List<api.MessagePartHeader>();

325 o.add(buildMessagePartHeader());

326 o.add(buildMessagePartHeader());

327 return o;

328 }

329

330 checkUnnamed194(core.List<api.MessagePartHeader> o) {

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

332 checkMessagePartHeader(o[0]);

333 checkMessagePartHeader(o[1]);

334 }

335

336 buildUnnamed195() {

337 var o = new core.List<api.MessagePart>();

338 o.add(buildMessagePart());

339 o.add(buildMessagePart());

340 return o;

341 }

342

343 checkUnnamed195(core.List<api.MessagePart> o) {

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

345 checkMessagePart(o[0]);

346 checkMessagePart(o[1]);

347 }

348

349 core.int buildCounterMessagePart = 0;

350 buildMessagePart() {

351 var o = new api.MessagePart();

352 buildCounterMessagePart++;

353 if (buildCounterMessagePart < 3) {

354 o.body = buildMessagePartBody();

355 o.filename = "foo";

356 o.headers = buildUnnamed194();

357 o.mimeType = "foo";

358 o.partId = "foo";

359 o.parts = buildUnnamed195();

360 }

361 buildCounterMessagePart--;

362 return o;

363 }

364

365 checkMessagePart(api.MessagePart o) {

366 buildCounterMessagePart++;

367 if (buildCounterMessagePart < 3) {

368 checkMessagePartBody(o.body);

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

370 checkUnnamed194(o.headers);

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

372 unittest.expect(o.partId, unittest.equals('foo'));

373 checkUnnamed195(o.parts);

374 }

375 buildCounterMessagePart--;

376 }

377

378 core.int buildCounterMessagePartBody = 0;

379 buildMessagePartBody() {

380 var o = new api.MessagePartBody();

381 buildCounterMessagePartBody++;

382 if (buildCounterMessagePartBody < 3) {

383 o.attachmentId = "foo";

384 o.data = "foo";

385 o.size = 42;

386 }

387 buildCounterMessagePartBody--;

388 return o;

389 }

390

391 checkMessagePartBody(api.MessagePartBody o) {

392 buildCounterMessagePartBody++;

393 if (buildCounterMessagePartBody < 3) {

394 unittest.expect(o.attachmentId, unittest.equals('foo'));

395 unittest.expect(o.data, unittest.equals('foo'));

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

397 }

398 buildCounterMessagePartBody--;

399 }

400

401 core.int buildCounterMessagePartHeader = 0;

402 buildMessagePartHeader() {

403 var o = new api.MessagePartHeader();

404 buildCounterMessagePartHeader++;

405 if (buildCounterMessagePartHeader < 3) {

406 o.name = "foo";

407 o.value = "foo";

408 }

409 buildCounterMessagePartHeader--;

410 return o;

411 }

412

413 checkMessagePartHeader(api.MessagePartHeader o) {

414 buildCounterMessagePartHeader++;

415 if (buildCounterMessagePartHeader < 3) {

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

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

418 }

419 buildCounterMessagePartHeader--;

420 }

421

422 buildUnnamed196() {

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

424 o.add("foo");

425 o.add("foo");

426 return o;

427 }

428

429 checkUnnamed196(core.List<core.String> o) {

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

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

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

433 }

434

435 buildUnnamed197() {

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

437 o.add("foo");

438 o.add("foo");

439 return o;

440 }

441

442 checkUnnamed197(core.List<core.String> o) {

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

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

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

446 }

447

448 core.int buildCounterModifyMessageRequest = 0;

449 buildModifyMessageRequest() {

450 var o = new api.ModifyMessageRequest();

451 buildCounterModifyMessageRequest++;

452 if (buildCounterModifyMessageRequest < 3) {

453 o.addLabelIds = buildUnnamed196();

454 o.removeLabelIds = buildUnnamed197();

455 }

456 buildCounterModifyMessageRequest--;

457 return o;

458 }

459

460 checkModifyMessageRequest(api.ModifyMessageRequest o) {

461 buildCounterModifyMessageRequest++;

462 if (buildCounterModifyMessageRequest < 3) {

463 checkUnnamed196(o.addLabelIds);

464 checkUnnamed197(o.removeLabelIds);

465 }

466 buildCounterModifyMessageRequest--;

467 }

468

469 buildUnnamed198() {

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

471 o.add("foo");

472 o.add("foo");

473 return o;

474 }

475

476 checkUnnamed198(core.List<core.String> o) {

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

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

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

480 }

481

482 buildUnnamed199() {

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

484 o.add("foo");

485 o.add("foo");

486 return o;

487 }

488

489 checkUnnamed199(core.List<core.String> o) {

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

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

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

493 }

494

495 core.int buildCounterModifyThreadRequest = 0;

496 buildModifyThreadRequest() {

497 var o = new api.ModifyThreadRequest();

498 buildCounterModifyThreadRequest++;

499 if (buildCounterModifyThreadRequest < 3) {

500 o.addLabelIds = buildUnnamed198();

501 o.removeLabelIds = buildUnnamed199();

502 }

503 buildCounterModifyThreadRequest--;

504 return o;

505 }

506

507 checkModifyThreadRequest(api.ModifyThreadRequest o) {

508 buildCounterModifyThreadRequest++;

509 if (buildCounterModifyThreadRequest < 3) {

510 checkUnnamed198(o.addLabelIds);

511 checkUnnamed199(o.removeLabelIds);

512 }

513 buildCounterModifyThreadRequest--;

514 }

515

516 buildUnnamed200() {

517 var o = new core.List<api.Message>();

518 o.add(buildMessage());

519 o.add(buildMessage());

520 return o;

521 }

522

523 checkUnnamed200(core.List<api.Message> o) {

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

525 checkMessage(o[0]);

526 checkMessage(o[1]);

527 }

528

529 core.int buildCounterThread = 0;

530 buildThread() {

531 var o = new api.Thread();

532 buildCounterThread++;

533 if (buildCounterThread < 3) {

534 o.historyId = "foo";

535 o.id = "foo";

536 o.messages = buildUnnamed200();

537 o.snippet = "foo";

538 }

539 buildCounterThread--;

540 return o;

541 }

542

543 checkThread(api.Thread o) {

544 buildCounterThread++;

545 if (buildCounterThread < 3) {

546 unittest.expect(o.historyId, unittest.equals('foo'));

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

548 checkUnnamed200(o.messages);

549 unittest.expect(o.snippet, unittest.equals('foo'));

550 }

551 buildCounterThread--;

552 }

553

554 buildUnnamed201() {

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

556 o.add("foo");

557 o.add("foo");

558 return o;

559 }

560

561 checkUnnamed201(core.List<core.String> o) {

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

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

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

565 }

566

567 buildUnnamed202() {

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

569 o.add("foo");

570 o.add("foo");

571 return o;

572 }

573

574 checkUnnamed202(core.List<core.String> o) {

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

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

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

578 }

579

580 buildUnnamed203() {

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

582 o.add("foo");

583 o.add("foo");

584 return o;

585 }

586

587 checkUnnamed203(core.List<core.String> o) {

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

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

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

591 }

592

593

594 main() {

595 unittest.group("obj-schema-Draft", () {

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

597 var o = buildDraft();

598 var od = new api.Draft.fromJson(o.toJson());

599 checkDraft(od);

600 });

601 });

602

603

604 unittest.group("obj-schema-History", () {

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

606 var o = buildHistory();

607 var od = new api.History.fromJson(o.toJson());

608 checkHistory(od);

609 });

610 });

611

612

613 unittest.group("obj-schema-Label", () {

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

615 var o = buildLabel();

616 var od = new api.Label.fromJson(o.toJson());

617 checkLabel(od);

618 });

619 });

620

621

622 unittest.group("obj-schema-ListDraftsResponse", () {

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

624 var o = buildListDraftsResponse();

625 var od = new api.ListDraftsResponse.fromJson(o.toJson());

626 checkListDraftsResponse(od);

627 });

628 });

629

630

631 unittest.group("obj-schema-ListHistoryResponse", () {

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

633 var o = buildListHistoryResponse();

634 var od = new api.ListHistoryResponse.fromJson(o.toJson());

635 checkListHistoryResponse(od);

636 });

637 });

638

639

640 unittest.group("obj-schema-ListLabelsResponse", () {

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

642 var o = buildListLabelsResponse();

643 var od = new api.ListLabelsResponse.fromJson(o.toJson());

644 checkListLabelsResponse(od);

645 });

646 });

647

648

649 unittest.group("obj-schema-ListMessagesResponse", () {

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

651 var o = buildListMessagesResponse();

652 var od = new api.ListMessagesResponse.fromJson(o.toJson());

653 checkListMessagesResponse(od);

654 });

655 });

656

657

658 unittest.group("obj-schema-ListThreadsResponse", () {

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

660 var o = buildListThreadsResponse();

661 var od = new api.ListThreadsResponse.fromJson(o.toJson());

662 checkListThreadsResponse(od);

663 });

664 });

665

666

667 unittest.group("obj-schema-Message", () {

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

669 var o = buildMessage();

670 var od = new api.Message.fromJson(o.toJson());

671 checkMessage(od);

672 });

673 });

674

675

676 unittest.group("obj-schema-MessagePart", () {

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

678 var o = buildMessagePart();

679 var od = new api.MessagePart.fromJson(o.toJson());

680 checkMessagePart(od);

681 });

682 });

683

684

685 unittest.group("obj-schema-MessagePartBody", () {

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

687 var o = buildMessagePartBody();

688 var od = new api.MessagePartBody.fromJson(o.toJson());

689 checkMessagePartBody(od);

690 });

691 });

692

693

694 unittest.group("obj-schema-MessagePartHeader", () {

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

696 var o = buildMessagePartHeader();

697 var od = new api.MessagePartHeader.fromJson(o.toJson());

698 checkMessagePartHeader(od);

699 });

700 });

701

702

703 unittest.group("obj-schema-ModifyMessageRequest", () {

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

705 var o = buildModifyMessageRequest();

706 var od = new api.ModifyMessageRequest.fromJson(o.toJson());

707 checkModifyMessageRequest(od);

708 });

709 });

710

711

712 unittest.group("obj-schema-ModifyThreadRequest", () {

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

714 var o = buildModifyThreadRequest();

715 var od = new api.ModifyThreadRequest.fromJson(o.toJson());

716 checkModifyThreadRequest(od);

717 });

718 });

719

720

721 unittest.group("obj-schema-Thread", () {

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

723 var o = buildThread();

724 var od = new api.Thread.fromJson(o.toJson());

725 checkThread(od);

726 });

727 });

728

729

730 unittest.group("resource-UsersDraftsResourceApi", () {

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

732 // TODO: Implement tests for media upload;

733 // TODO: Implement tests for media download;

734

735 var mock = new common_test.HttpServerMock();

736 api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;

737 var arg_request = buildDraft();

738 var arg_userId = "foo";

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

740 var obj = new api.Draft.fromJson(json);

741 checkDraft(obj);

742

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

744 var pathOffset = 0;

745 var index;

746 var subPart;

747 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

748 pathOffset += 16;

749 index = path.indexOf("/drafts", pathOffset);

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

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

752 pathOffset = index;

753 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

755 pathOffset += 7;

756

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

758 var queryOffset = 0;

759 var queryMap = {};

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

761 parseBool(n) {

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

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

764 if (n == null) return null;

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

766 }

767 if (query.length > 0) {

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

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

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

771 }

772 }

773

774

775 var h = {

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

777 };

778 var resp = convert.JSON.encode(buildDraft());

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

780 }), true);

781 res.create(arg_request, arg_userId).then(unittest.expectAsync(((api.Draft response) {

782 checkDraft(response);

783 })));

784 });

785

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

787

788 var mock = new common_test.HttpServerMock();

789 api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;

790 var arg_userId = "foo";

791 var arg_id = "foo";

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

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

794 var pathOffset = 0;

795 var index;

796 var subPart;

797 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

798 pathOffset += 16;

799 index = path.indexOf("/drafts/", pathOffset);

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

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

802 pathOffset = index;

803 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

805 pathOffset += 8;

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

807 pathOffset = path.length;

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

809

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

811 var queryOffset = 0;

812 var queryMap = {};

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

814 parseBool(n) {

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

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

817 if (n == null) return null;

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

819 }

820 if (query.length > 0) {

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

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

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

824 }

825 }

826

827

828 var h = {

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

830 };

831 var resp = "";

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

833 }), true);

834 res.delete(arg_userId, arg_id).then(unittest.expectAsync((_) {}));

835 });

836

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

838

839 var mock = new common_test.HttpServerMock();

840 api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;

841 var arg_userId = "foo";

842 var arg_id = "foo";

843 var arg_format = "foo";

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

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

846 var pathOffset = 0;

847 var index;

848 var subPart;

849 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

850 pathOffset += 16;

851 index = path.indexOf("/drafts/", pathOffset);

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

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

854 pathOffset = index;

855 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

857 pathOffset += 8;

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

859 pathOffset = path.length;

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

861

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

863 var queryOffset = 0;

864 var queryMap = {};

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

866 parseBool(n) {

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

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

869 if (n == null) return null;

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

871 }

872 if (query.length > 0) {

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

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

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

876 }

877 }

878 unittest.expect(queryMap["format"].first, unittest.equals(arg_format));

879

880

881 var h = {

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

883 };

884 var resp = convert.JSON.encode(buildDraft());

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

886 }), true);

887 res.get(arg_userId, arg_id, format: arg_format).then(unittest.expectAsync( ((api.Draft response) {

888 checkDraft(response);

889 })));

890 });

891

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

893

894 var mock = new common_test.HttpServerMock();

895 api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;

896 var arg_userId = "foo";

897 var arg_maxResults = 42;

898 var arg_pageToken = "foo";

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

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

901 var pathOffset = 0;

902 var index;

903 var subPart;

904 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

905 pathOffset += 16;

906 index = path.indexOf("/drafts", pathOffset);

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

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

909 pathOffset = index;

910 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

912 pathOffset += 7;

913

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

915 var queryOffset = 0;

916 var queryMap = {};

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

918 parseBool(n) {

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

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

921 if (n == null) return null;

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

923 }

924 if (query.length > 0) {

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

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

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

928 }

929 }

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

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

932

933

934 var h = {

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

936 };

937 var resp = convert.JSON.encode(buildListDraftsResponse());

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

939 }), true);

940 res.list(arg_userId, maxResults: arg_maxResults, pageToken: arg_pageToken) .then(unittest.expectAsync(((api.ListDraftsResponse response) {

941 checkListDraftsResponse(response);

942 })));

943 });

944

945 unittest.test("method--send", () {

946 // TODO: Implement tests for media upload;

947 // TODO: Implement tests for media download;

948

949 var mock = new common_test.HttpServerMock();

950 api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;

951 var arg_request = buildDraft();

952 var arg_userId = "foo";

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

954 var obj = new api.Draft.fromJson(json);

955 checkDraft(obj);

956

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

958 var pathOffset = 0;

959 var index;

960 var subPart;

961 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

962 pathOffset += 16;

963 index = path.indexOf("/drafts/send", pathOffset);

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

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

966 pathOffset = index;

967 unittest.expect(subPart, unittest.equals("$arg_userId"));

968 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/drafts/send"));

969 pathOffset += 12;

970

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

972 var queryOffset = 0;

973 var queryMap = {};

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

975 parseBool(n) {

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

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

978 if (n == null) return null;

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

980 }

981 if (query.length > 0) {

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

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

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

985 }

986 }

987

988

989 var h = {

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

991 };

992 var resp = convert.JSON.encode(buildMessage());

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

994 }), true);

995 res.send(arg_request, arg_userId).then(unittest.expectAsync(((api.Message response) {

996 checkMessage(response);

997 })));

998 });

999

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

1001 // TODO: Implement tests for media upload;

1002 // TODO: Implement tests for media download;

1003

1004 var mock = new common_test.HttpServerMock();

1005 api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;

1006 var arg_request = buildDraft();

1007 var arg_userId = "foo";

1008 var arg_id = "foo";

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

1010 var obj = new api.Draft.fromJson(json);

1011 checkDraft(obj);

1012

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

1014 var pathOffset = 0;

1015 var index;

1016 var subPart;

1017 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1018 pathOffset += 16;

1019 index = path.indexOf("/drafts/", pathOffset);

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

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

1022 pathOffset = index;

1023 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1025 pathOffset += 8;

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

1027 pathOffset = path.length;

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

1029

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

1031 var queryOffset = 0;

1032 var queryMap = {};

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

1034 parseBool(n) {

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

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

1037 if (n == null) return null;

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

1039 }

1040 if (query.length > 0) {

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

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

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

1044 }

1045 }

1046

1047

1048 var h = {

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

1050 };

1051 var resp = convert.JSON.encode(buildDraft());

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

1053 }), true);

1054 res.update(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((ap i.Draft response) {

1055 checkDraft(response);

1056 })));

1057 });

1058

1059 });

1060

1061

1062 unittest.group("resource-UsersHistoryResourceApi", () {

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

1064

1065 var mock = new common_test.HttpServerMock();

1066 api.UsersHistoryResourceApi res = new api.GmailApi(mock).users.history;

1067 var arg_userId = "foo";

1068 var arg_labelId = "foo";

1069 var arg_maxResults = 42;

1070 var arg_pageToken = "foo";

1071 var arg_startHistoryId = "foo";

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

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

1074 var pathOffset = 0;

1075 var index;

1076 var subPart;

1077 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1078 pathOffset += 16;

1079 index = path.indexOf("/history", pathOffset);

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

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

1082 pathOffset = index;

1083 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1085 pathOffset += 8;

1086

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

1088 var queryOffset = 0;

1089 var queryMap = {};

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

1091 parseBool(n) {

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

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

1094 if (n == null) return null;

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

1096 }

1097 if (query.length > 0) {

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

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

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

1101 }

1102 }

1103 unittest.expect(queryMap["labelId"].first, unittest.equals(arg_labelId)) ;

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

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

1106 unittest.expect(queryMap["startHistoryId"].first, unittest.equals(arg_st artHistoryId));

1107

1108

1109 var h = {

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

1111 };

1112 var resp = convert.JSON.encode(buildListHistoryResponse());

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

1114 }), true);

1115 res.list(arg_userId, labelId: arg_labelId, maxResults: arg_maxResults, pag eToken: arg_pageToken, startHistoryId: arg_startHistoryId).then(unittest.expectA sync(((api.ListHistoryResponse response) {

1116 checkListHistoryResponse(response);

1117 })));

1118 });

1119

1120 });

1121

1122

1123 unittest.group("resource-UsersLabelsResourceApi", () {

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

1125

1126 var mock = new common_test.HttpServerMock();

1127 api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;

1128 var arg_request = buildLabel();

1129 var arg_userId = "foo";

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

1131 var obj = new api.Label.fromJson(json);

1132 checkLabel(obj);

1133

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

1135 var pathOffset = 0;

1136 var index;

1137 var subPart;

1138 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1139 pathOffset += 16;

1140 index = path.indexOf("/labels", pathOffset);

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

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

1143 pathOffset = index;

1144 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1146 pathOffset += 7;

1147

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

1149 var queryOffset = 0;

1150 var queryMap = {};

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

1152 parseBool(n) {

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

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

1155 if (n == null) return null;

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

1157 }

1158 if (query.length > 0) {

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

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

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

1162 }

1163 }

1164

1165

1166 var h = {

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

1168 };

1169 var resp = convert.JSON.encode(buildLabel());

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

1171 }), true);

1172 res.create(arg_request, arg_userId).then(unittest.expectAsync(((api.Label response) {

1173 checkLabel(response);

1174 })));

1175 });

1176

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

1178

1179 var mock = new common_test.HttpServerMock();

1180 api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;

1181 var arg_userId = "foo";

1182 var arg_id = "foo";

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

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

1185 var pathOffset = 0;

1186 var index;

1187 var subPart;

1188 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1189 pathOffset += 16;

1190 index = path.indexOf("/labels/", pathOffset);

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

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

1193 pathOffset = index;

1194 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1196 pathOffset += 8;

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

1198 pathOffset = path.length;

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

1200

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

1202 var queryOffset = 0;

1203 var queryMap = {};

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

1205 parseBool(n) {

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

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

1208 if (n == null) return null;

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

1210 }

1211 if (query.length > 0) {

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

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

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

1215 }

1216 }

1217

1218

1219 var h = {

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

1221 };

1222 var resp = "";

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

1224 }), true);

1225 res.delete(arg_userId, arg_id).then(unittest.expectAsync((_) {}));

1226 });

1227

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

1229

1230 var mock = new common_test.HttpServerMock();

1231 api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;

1232 var arg_userId = "foo";

1233 var arg_id = "foo";

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

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

1236 var pathOffset = 0;

1237 var index;

1238 var subPart;

1239 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1240 pathOffset += 16;

1241 index = path.indexOf("/labels/", pathOffset);

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

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

1244 pathOffset = index;

1245 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1247 pathOffset += 8;

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

1249 pathOffset = path.length;

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

1251

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

1253 var queryOffset = 0;

1254 var queryMap = {};

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

1256 parseBool(n) {

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

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

1259 if (n == null) return null;

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

1261 }

1262 if (query.length > 0) {

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

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

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

1266 }

1267 }

1268

1269

1270 var h = {

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

1272 };

1273 var resp = convert.JSON.encode(buildLabel());

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

1275 }), true);

1276 res.get(arg_userId, arg_id).then(unittest.expectAsync(((api.Label response ) {

1277 checkLabel(response);

1278 })));

1279 });

1280

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

1282

1283 var mock = new common_test.HttpServerMock();

1284 api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;

1285 var arg_userId = "foo";

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

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

1288 var pathOffset = 0;

1289 var index;

1290 var subPart;

1291 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1292 pathOffset += 16;

1293 index = path.indexOf("/labels", pathOffset);

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

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

1296 pathOffset = index;

1297 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1299 pathOffset += 7;

1300

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

1302 var queryOffset = 0;

1303 var queryMap = {};

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

1305 parseBool(n) {

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

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

1308 if (n == null) return null;

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

1310 }

1311 if (query.length > 0) {

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

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

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

1315 }

1316 }

1317

1318

1319 var h = {

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

1321 };

1322 var resp = convert.JSON.encode(buildListLabelsResponse());

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

1324 }), true);

1325 res.list(arg_userId).then(unittest.expectAsync(((api.ListLabelsResponse re sponse) {

1326 checkListLabelsResponse(response);

1327 })));

1328 });

1329

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

1331

1332 var mock = new common_test.HttpServerMock();

1333 api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;

1334 var arg_request = buildLabel();

1335 var arg_userId = "foo";

1336 var arg_id = "foo";

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

1338 var obj = new api.Label.fromJson(json);

1339 checkLabel(obj);

1340

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

1342 var pathOffset = 0;

1343 var index;

1344 var subPart;

1345 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1346 pathOffset += 16;

1347 index = path.indexOf("/labels/", pathOffset);

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

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

1350 pathOffset = index;

1351 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1353 pathOffset += 8;

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

1355 pathOffset = path.length;

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

1357

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

1359 var queryOffset = 0;

1360 var queryMap = {};

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

1362 parseBool(n) {

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

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

1365 if (n == null) return null;

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

1367 }

1368 if (query.length > 0) {

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

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

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

1372 }

1373 }

1374

1375

1376 var h = {

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

1378 };

1379 var resp = convert.JSON.encode(buildLabel());

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

1381 }), true);

1382 res.patch(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((api .Label response) {

1383 checkLabel(response);

1384 })));

1385 });

1386

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

1388

1389 var mock = new common_test.HttpServerMock();

1390 api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;

1391 var arg_request = buildLabel();

1392 var arg_userId = "foo";

1393 var arg_id = "foo";

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

1395 var obj = new api.Label.fromJson(json);

1396 checkLabel(obj);

1397

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

1399 var pathOffset = 0;

1400 var index;

1401 var subPart;

1402 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1403 pathOffset += 16;

1404 index = path.indexOf("/labels/", pathOffset);

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

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

1407 pathOffset = index;

1408 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1410 pathOffset += 8;

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

1412 pathOffset = path.length;

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

1414

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

1416 var queryOffset = 0;

1417 var queryMap = {};

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

1419 parseBool(n) {

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

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

1422 if (n == null) return null;

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

1424 }

1425 if (query.length > 0) {

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

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

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

1429 }

1430 }

1431

1432

1433 var h = {

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

1435 };

1436 var resp = convert.JSON.encode(buildLabel());

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

1438 }), true);

1439 res.update(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((ap i.Label response) {

1440 checkLabel(response);

1441 })));

1442 });

1443

1444 });

1445

1446

1447 unittest.group("resource-UsersMessagesResourceApi", () {

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

1449

1450 var mock = new common_test.HttpServerMock();

1451 api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;

1452 var arg_userId = "foo";

1453 var arg_id = "foo";

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

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

1456 var pathOffset = 0;

1457 var index;

1458 var subPart;

1459 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1460 pathOffset += 16;

1461 index = path.indexOf("/messages/", pathOffset);

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

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

1464 pathOffset = index;

1465 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1467 pathOffset += 10;

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

1469 pathOffset = path.length;

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

1471

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

1473 var queryOffset = 0;

1474 var queryMap = {};

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

1476 parseBool(n) {

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

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

1479 if (n == null) return null;

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

1481 }

1482 if (query.length > 0) {

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

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

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

1486 }

1487 }

1488

1489

1490 var h = {

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

1492 };

1493 var resp = "";

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

1495 }), true);

1496 res.delete(arg_userId, arg_id).then(unittest.expectAsync((_) {}));

1497 });

1498

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

1500

1501 var mock = new common_test.HttpServerMock();

1502 api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;

1503 var arg_userId = "foo";

1504 var arg_id = "foo";

1505 var arg_format = "foo";

1506 var arg_metadataHeaders = buildUnnamed201();

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

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

1509 var pathOffset = 0;

1510 var index;

1511 var subPart;

1512 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1513 pathOffset += 16;

1514 index = path.indexOf("/messages/", pathOffset);

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

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

1517 pathOffset = index;

1518 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1520 pathOffset += 10;

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

1522 pathOffset = path.length;

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

1524

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

1526 var queryOffset = 0;

1527 var queryMap = {};

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

1529 parseBool(n) {

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

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

1532 if (n == null) return null;

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

1534 }

1535 if (query.length > 0) {

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

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

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

1539 }

1540 }

1541 unittest.expect(queryMap["format"].first, unittest.equals(arg_format));

1542 unittest.expect(queryMap["metadataHeaders"], unittest.equals(arg_metadat aHeaders));

1543

1544

1545 var h = {

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

1547 };

1548 var resp = convert.JSON.encode(buildMessage());

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

1550 }), true);

1551 res.get(arg_userId, arg_id, format: arg_format, metadataHeaders: arg_metad ataHeaders).then(unittest.expectAsync(((api.Message response) {

1552 checkMessage(response);

1553 })));

1554 });

1555

1556 unittest.test("method--import", () {

1557 // TODO: Implement tests for media upload;

1558 // TODO: Implement tests for media download;

1559

1560 var mock = new common_test.HttpServerMock();

1561 api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;

1562 var arg_request = buildMessage();

1563 var arg_userId = "foo";

1564 var arg_internalDateSource = "foo";

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

1566 var obj = new api.Message.fromJson(json);

1567 checkMessage(obj);

1568

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

1570 var pathOffset = 0;

1571 var index;

1572 var subPart;

1573 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1574 pathOffset += 16;

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

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

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

1578 pathOffset = index;

1579 unittest.expect(subPart, unittest.equals("$arg_userId"));

1580 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/messages/import"));

1581 pathOffset += 16;

1582

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

1584 var queryOffset = 0;

1585 var queryMap = {};

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

1587 parseBool(n) {

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

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

1590 if (n == null) return null;

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

1592 }

1593 if (query.length > 0) {

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

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

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

1597 }

1598 }

1599 unittest.expect(queryMap["internalDateSource"].first, unittest.equals(ar g_internalDateSource));

1600

1601

1602 var h = {

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

1604 };

1605 var resp = convert.JSON.encode(buildMessage());

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

1607 }), true);

1608 res.import(arg_request, arg_userId, internalDateSource: arg_internalDateSo urce).then(unittest.expectAsync(((api.Message response) {

1609 checkMessage(response);

1610 })));

1611 });

1612

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

1614 // TODO: Implement tests for media upload;

1615 // TODO: Implement tests for media download;

1616

1617 var mock = new common_test.HttpServerMock();

1618 api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;

1619 var arg_request = buildMessage();

1620 var arg_userId = "foo";

1621 var arg_internalDateSource = "foo";

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

1623 var obj = new api.Message.fromJson(json);

1624 checkMessage(obj);

1625

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

1627 var pathOffset = 0;

1628 var index;

1629 var subPart;

1630 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1631 pathOffset += 16;

1632 index = path.indexOf("/messages", pathOffset);

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

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

1635 pathOffset = index;

1636 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1638 pathOffset += 9;

1639

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

1641 var queryOffset = 0;

1642 var queryMap = {};

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

1644 parseBool(n) {

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

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

1647 if (n == null) return null;

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

1649 }

1650 if (query.length > 0) {

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

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

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

1654 }

1655 }

1656 unittest.expect(queryMap["internalDateSource"].first, unittest.equals(ar g_internalDateSource));

1657

1658

1659 var h = {

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

1661 };

1662 var resp = convert.JSON.encode(buildMessage());

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

1664 }), true);

1665 res.insert(arg_request, arg_userId, internalDateSource: arg_internalDateSo urce).then(unittest.expectAsync(((api.Message response) {

1666 checkMessage(response);

1667 })));

1668 });

1669

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

1671

1672 var mock = new common_test.HttpServerMock();

1673 api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;

1674 var arg_userId = "foo";

1675 var arg_includeSpamTrash = true;

1676 var arg_labelIds = buildUnnamed202();

1677 var arg_maxResults = 42;

1678 var arg_pageToken = "foo";

1679 var arg_q = "foo";

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

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

1682 var pathOffset = 0;

1683 var index;

1684 var subPart;

1685 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1686 pathOffset += 16;

1687 index = path.indexOf("/messages", pathOffset);

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

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

1690 pathOffset = index;

1691 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1693 pathOffset += 9;

1694

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

1696 var queryOffset = 0;

1697 var queryMap = {};

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

1699 parseBool(n) {

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

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

1702 if (n == null) return null;

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

1704 }

1705 if (query.length > 0) {

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

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

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

1709 }

1710 }

1711 unittest.expect(queryMap["includeSpamTrash"].first, unittest.equals("$ar g_includeSpamTrash"));

1712 unittest.expect(queryMap["labelIds"], unittest.equals(arg_labelIds));

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

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

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

1716

1717

1718 var h = {

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

1720 };

1721 var resp = convert.JSON.encode(buildListMessagesResponse());

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

1723 }), true);

1724 res.list(arg_userId, includeSpamTrash: arg_includeSpamTrash, labelIds: arg _labelIds, maxResults: arg_maxResults, pageToken: arg_pageToken, q: arg_q).then( unittest.expectAsync(((api.ListMessagesResponse response) {

1725 checkListMessagesResponse(response);

1726 })));

1727 });

1728

1729 unittest.test("method--modify", () {

1730

1731 var mock = new common_test.HttpServerMock();

1732 api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;

1733 var arg_request = buildModifyMessageRequest();

1734 var arg_userId = "foo";

1735 var arg_id = "foo";

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

1737 var obj = new api.ModifyMessageRequest.fromJson(json);

1738 checkModifyMessageRequest(obj);

1739

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

1741 var pathOffset = 0;

1742 var index;

1743 var subPart;

1744 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1745 pathOffset += 16;

1746 index = path.indexOf("/messages/", pathOffset);

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

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

1749 pathOffset = index;

1750 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1752 pathOffset += 10;

1753 index = path.indexOf("/modify", pathOffset);

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

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

1756 pathOffset = index;

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

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

1759 pathOffset += 7;

1760

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

1762 var queryOffset = 0;

1763 var queryMap = {};

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

1765 parseBool(n) {

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

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

1768 if (n == null) return null;

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

1770 }

1771 if (query.length > 0) {

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

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

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

1775 }

1776 }

1777

1778

1779 var h = {

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

1781 };

1782 var resp = convert.JSON.encode(buildMessage());

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

1784 }), true);

1785 res.modify(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((ap i.Message response) {

1786 checkMessage(response);

1787 })));

1788 });

1789

1790 unittest.test("method--send", () {

1791 // TODO: Implement tests for media upload;

1792 // TODO: Implement tests for media download;

1793

1794 var mock = new common_test.HttpServerMock();

1795 api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;

1796 var arg_request = buildMessage();

1797 var arg_userId = "foo";

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

1799 var obj = new api.Message.fromJson(json);

1800 checkMessage(obj);

1801

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

1803 var pathOffset = 0;

1804 var index;

1805 var subPart;

1806 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1807 pathOffset += 16;

1808 index = path.indexOf("/messages/send", pathOffset);

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

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

1811 pathOffset = index;

1812 unittest.expect(subPart, unittest.equals("$arg_userId"));

1813 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/messages/send"));

1814 pathOffset += 14;

1815

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

1817 var queryOffset = 0;

1818 var queryMap = {};

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

1820 parseBool(n) {

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

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

1823 if (n == null) return null;

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

1825 }

1826 if (query.length > 0) {

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

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

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

1830 }

1831 }

1832

1833

1834 var h = {

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

1836 };

1837 var resp = convert.JSON.encode(buildMessage());

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

1839 }), true);

1840 res.send(arg_request, arg_userId).then(unittest.expectAsync(((api.Message response) {

1841 checkMessage(response);

1842 })));

1843 });

1844

1845 unittest.test("method--trash", () {

1846

1847 var mock = new common_test.HttpServerMock();

1848 api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;

1849 var arg_userId = "foo";

1850 var arg_id = "foo";

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

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

1853 var pathOffset = 0;

1854 var index;

1855 var subPart;

1856 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1857 pathOffset += 16;

1858 index = path.indexOf("/messages/", pathOffset);

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

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

1861 pathOffset = index;

1862 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1864 pathOffset += 10;

1865 index = path.indexOf("/trash", pathOffset);

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

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

1868 pathOffset = index;

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

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

1871 pathOffset += 6;

1872

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

1874 var queryOffset = 0;

1875 var queryMap = {};

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

1877 parseBool(n) {

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

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

1880 if (n == null) return null;

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

1882 }

1883 if (query.length > 0) {

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

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

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

1887 }

1888 }

1889

1890

1891 var h = {

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

1893 };

1894 var resp = convert.JSON.encode(buildMessage());

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

1896 }), true);

1897 res.trash(arg_userId, arg_id).then(unittest.expectAsync(((api.Message resp onse) {

1898 checkMessage(response);

1899 })));

1900 });

1901

1902 unittest.test("method--untrash", () {

1903

1904 var mock = new common_test.HttpServerMock();

1905 api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;

1906 var arg_userId = "foo";

1907 var arg_id = "foo";

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

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

1910 var pathOffset = 0;

1911 var index;

1912 var subPart;

1913 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1914 pathOffset += 16;

1915 index = path.indexOf("/messages/", pathOffset);

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

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

1918 pathOffset = index;

1919 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1921 pathOffset += 10;

1922 index = path.indexOf("/untrash", pathOffset);

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

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

1925 pathOffset = index;

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

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

1928 pathOffset += 8;

1929

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

1931 var queryOffset = 0;

1932 var queryMap = {};

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

1934 parseBool(n) {

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

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

1937 if (n == null) return null;

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

1939 }

1940 if (query.length > 0) {

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

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

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

1944 }

1945 }

1946

1947

1948 var h = {

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

1950 };

1951 var resp = convert.JSON.encode(buildMessage());

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

1953 }), true);

1954 res.untrash(arg_userId, arg_id).then(unittest.expectAsync(((api.Message re sponse) {

1955 checkMessage(response);

1956 })));

1957 });

1958

1959 });

1960

1961

1962 unittest.group("resource-UsersMessagesAttachmentsResourceApi", () {

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

1964

1965 var mock = new common_test.HttpServerMock();

1966 api.UsersMessagesAttachmentsResourceApi res = new api.GmailApi(mock).users .messages.attachments;

1967 var arg_userId = "foo";

1968 var arg_messageId = "foo";

1969 var arg_id = "foo";

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

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

1972 var pathOffset = 0;

1973 var index;

1974 var subPart;

1975 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

1976 pathOffset += 16;

1977 index = path.indexOf("/messages/", pathOffset);

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

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

1980 pathOffset = index;

1981 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

1983 pathOffset += 10;

1984 index = path.indexOf("/attachments/", pathOffset);

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

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

1987 pathOffset = index;

1988 unittest.expect(subPart, unittest.equals("$arg_messageId"));

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

1990 pathOffset += 13;

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

1992 pathOffset = path.length;

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

1994

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

1996 var queryOffset = 0;

1997 var queryMap = {};

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

1999 parseBool(n) {

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

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

2002 if (n == null) return null;

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

2004 }

2005 if (query.length > 0) {

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

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

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

2009 }

2010 }

2011

2012

2013 var h = {

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

2015 };

2016 var resp = convert.JSON.encode(buildMessagePartBody());

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

2018 }), true);

2019 res.get(arg_userId, arg_messageId, arg_id).then(unittest.expectAsync(((api .MessagePartBody response) {

2020 checkMessagePartBody(response);

2021 })));

2022 });

2023

2024 });

2025

2026

2027 unittest.group("resource-UsersThreadsResourceApi", () {

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

2029

2030 var mock = new common_test.HttpServerMock();

2031 api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;

2032 var arg_userId = "foo";

2033 var arg_id = "foo";

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

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

2036 var pathOffset = 0;

2037 var index;

2038 var subPart;

2039 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

2040 pathOffset += 16;

2041 index = path.indexOf("/threads/", pathOffset);

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

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

2044 pathOffset = index;

2045 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

2047 pathOffset += 9;

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

2049 pathOffset = path.length;

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

2051

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

2053 var queryOffset = 0;

2054 var queryMap = {};

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

2056 parseBool(n) {

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

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

2059 if (n == null) return null;

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

2061 }

2062 if (query.length > 0) {

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

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

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

2066 }

2067 }

2068

2069

2070 var h = {

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

2072 };

2073 var resp = "";

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

2075 }), true);

2076 res.delete(arg_userId, arg_id).then(unittest.expectAsync((_) {}));

2077 });

2078

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

2080

2081 var mock = new common_test.HttpServerMock();

2082 api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;

2083 var arg_userId = "foo";

2084 var arg_id = "foo";

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

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

2087 var pathOffset = 0;

2088 var index;

2089 var subPart;

2090 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

2091 pathOffset += 16;

2092 index = path.indexOf("/threads/", pathOffset);

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

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

2095 pathOffset = index;

2096 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

2098 pathOffset += 9;

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

2100 pathOffset = path.length;

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

2102

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

2104 var queryOffset = 0;

2105 var queryMap = {};

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

2107 parseBool(n) {

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

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

2110 if (n == null) return null;

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

2112 }

2113 if (query.length > 0) {

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

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

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

2117 }

2118 }

2119

2120

2121 var h = {

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

2123 };

2124 var resp = convert.JSON.encode(buildThread());

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

2126 }), true);

2127 res.get(arg_userId, arg_id).then(unittest.expectAsync(((api.Thread respons e) {

2128 checkThread(response);

2129 })));

2130 });

2131

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

2133

2134 var mock = new common_test.HttpServerMock();

2135 api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;

2136 var arg_userId = "foo";

2137 var arg_includeSpamTrash = true;

2138 var arg_labelIds = buildUnnamed203();

2139 var arg_maxResults = 42;

2140 var arg_pageToken = "foo";

2141 var arg_q = "foo";

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

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

2144 var pathOffset = 0;

2145 var index;

2146 var subPart;

2147 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

2148 pathOffset += 16;

2149 index = path.indexOf("/threads", pathOffset);

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

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

2152 pathOffset = index;

2153 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

2155 pathOffset += 8;

2156

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

2158 var queryOffset = 0;

2159 var queryMap = {};

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

2161 parseBool(n) {

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

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

2164 if (n == null) return null;

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

2166 }

2167 if (query.length > 0) {

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

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

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

2171 }

2172 }

2173 unittest.expect(queryMap["includeSpamTrash"].first, unittest.equals("$ar g_includeSpamTrash"));

2174 unittest.expect(queryMap["labelIds"], unittest.equals(arg_labelIds));

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

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

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

2178

2179

2180 var h = {

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

2182 };

2183 var resp = convert.JSON.encode(buildListThreadsResponse());

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

2185 }), true);

2186 res.list(arg_userId, includeSpamTrash: arg_includeSpamTrash, labelIds: arg _labelIds, maxResults: arg_maxResults, pageToken: arg_pageToken, q: arg_q).then( unittest.expectAsync(((api.ListThreadsResponse response) {

2187 checkListThreadsResponse(response);

2188 })));

2189 });

2190

2191 unittest.test("method--modify", () {

2192

2193 var mock = new common_test.HttpServerMock();

2194 api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;

2195 var arg_request = buildModifyThreadRequest();

2196 var arg_userId = "foo";

2197 var arg_id = "foo";

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

2199 var obj = new api.ModifyThreadRequest.fromJson(json);

2200 checkModifyThreadRequest(obj);

2201

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

2203 var pathOffset = 0;

2204 var index;

2205 var subPart;

2206 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

2207 pathOffset += 16;

2208 index = path.indexOf("/threads/", pathOffset);

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

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

2211 pathOffset = index;

2212 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

2214 pathOffset += 9;

2215 index = path.indexOf("/modify", pathOffset);

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

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

2218 pathOffset = index;

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

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

2221 pathOffset += 7;

2222

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

2224 var queryOffset = 0;

2225 var queryMap = {};

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

2227 parseBool(n) {

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

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

2230 if (n == null) return null;

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

2232 }

2233 if (query.length > 0) {

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

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

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

2237 }

2238 }

2239

2240

2241 var h = {

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

2243 };

2244 var resp = convert.JSON.encode(buildThread());

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

2246 }), true);

2247 res.modify(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((ap i.Thread response) {

2248 checkThread(response);

2249 })));

2250 });

2251

2252 unittest.test("method--trash", () {

2253

2254 var mock = new common_test.HttpServerMock();

2255 api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;

2256 var arg_userId = "foo";

2257 var arg_id = "foo";

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

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

2260 var pathOffset = 0;

2261 var index;

2262 var subPart;

2263 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

2264 pathOffset += 16;

2265 index = path.indexOf("/threads/", pathOffset);

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

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

2268 pathOffset = index;

2269 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

2271 pathOffset += 9;

2272 index = path.indexOf("/trash", pathOffset);

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

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

2275 pathOffset = index;

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

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

2278 pathOffset += 6;

2279

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

2281 var queryOffset = 0;

2282 var queryMap = {};

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

2284 parseBool(n) {

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

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

2287 if (n == null) return null;

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

2289 }

2290 if (query.length > 0) {

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

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

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

2294 }

2295 }

2296

2297

2298 var h = {

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

2300 };

2301 var resp = convert.JSON.encode(buildThread());

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

2303 }), true);

2304 res.trash(arg_userId, arg_id).then(unittest.expectAsync(((api.Thread respo nse) {

2305 checkThread(response);

2306 })));

2307 });

2308

2309 unittest.test("method--untrash", () {

2310

2311 var mock = new common_test.HttpServerMock();

2312 api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;

2313 var arg_userId = "foo";

2314 var arg_id = "foo";

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

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

2317 var pathOffset = 0;

2318 var index;

2319 var subPart;

2320 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/gmail/v1/users/"));

2321 pathOffset += 16;

2322 index = path.indexOf("/threads/", pathOffset);

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

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

2325 pathOffset = index;

2326 unittest.expect(subPart, unittest.equals("$arg_userId"));

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

2328 pathOffset += 9;

2329 index = path.indexOf("/untrash", pathOffset);

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

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

2332 pathOffset = index;

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

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

2335 pathOffset += 8;

2336

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

2338 var queryOffset = 0;

2339 var queryMap = {};

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

2341 parseBool(n) {

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

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

2344 if (n == null) return null;

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

2346 }

2347 if (query.length > 0) {

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

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

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

2351 }

2352 }

2353

2354

2355 var h = {

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

2357 };

2358 var resp = convert.JSON.encode(buildThread());

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

2360 }), true);

2361 res.untrash(arg_userId, arg_id).then(unittest.expectAsync(((api.Thread res ponse) {

2362 checkThread(response);

2363 })));

2364 });

2365

2366 });

2367

2368

2369 }

2370

OLD	NEW

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