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

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

16

17

18

19 buildUnnamed664() {

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

21 o.add(buildAclRule());

22 o.add(buildAclRule());

23 return o;

24 }

25

26 checkUnnamed664(core.List<api.AclRule> o) {

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

28 checkAclRule(o[0]);

29 checkAclRule(o[1]);

30 }

31

32 core.int buildCounterAcl = 0;

33 buildAcl() {

34 var o = new api.Acl();

35 buildCounterAcl++;

36 if (buildCounterAcl < 3) {

37 o.etag = "foo";

38 o.items = buildUnnamed664();

39 o.kind = "foo";

40 o.nextPageToken = "foo";

41 o.nextSyncToken = "foo";

42 }

43 buildCounterAcl--;

44 return o;

45 }

46

47 checkAcl(api.Acl o) {

48 buildCounterAcl++;

49 if (buildCounterAcl < 3) {

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

51 checkUnnamed664(o.items);

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

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

54 unittest.expect(o.nextSyncToken, unittest.equals('foo'));

55 }

56 buildCounterAcl--;

57 }

58

59 core.int buildCounterAclRuleScope = 0;

60 buildAclRuleScope() {

61 var o = new api.AclRuleScope();

62 buildCounterAclRuleScope++;

63 if (buildCounterAclRuleScope < 3) {

64 o.type = "foo";

65 o.value = "foo";

66 }

67 buildCounterAclRuleScope--;

68 return o;

69 }

70

71 checkAclRuleScope(api.AclRuleScope o) {

72 buildCounterAclRuleScope++;

73 if (buildCounterAclRuleScope < 3) {

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

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

76 }

77 buildCounterAclRuleScope--;

78 }

79

80 core.int buildCounterAclRule = 0;

81 buildAclRule() {

82 var o = new api.AclRule();

83 buildCounterAclRule++;

84 if (buildCounterAclRule < 3) {

85 o.etag = "foo";

86 o.id = "foo";

87 o.kind = "foo";

88 o.role = "foo";

89 o.scope = buildAclRuleScope();

90 }

91 buildCounterAclRule--;

92 return o;

93 }

94

95 checkAclRule(api.AclRule o) {

96 buildCounterAclRule++;

97 if (buildCounterAclRule < 3) {

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

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

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

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

102 checkAclRuleScope(o.scope);

103 }

104 buildCounterAclRule--;

105 }

106

107 core.int buildCounterCalendar = 0;

108 buildCalendar() {

109 var o = new api.Calendar();

110 buildCounterCalendar++;

111 if (buildCounterCalendar < 3) {

112 o.description = "foo";

113 o.etag = "foo";

114 o.id = "foo";

115 o.kind = "foo";

116 o.location = "foo";

117 o.summary = "foo";

118 o.timeZone = "foo";

119 }

120 buildCounterCalendar--;

121 return o;

122 }

123

124 checkCalendar(api.Calendar o) {

125 buildCounterCalendar++;

126 if (buildCounterCalendar < 3) {

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

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

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

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

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

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

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

134 }

135 buildCounterCalendar--;

136 }

137

138 buildUnnamed665() {

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

140 o.add(buildCalendarListEntry());

141 o.add(buildCalendarListEntry());

142 return o;

143 }

144

145 checkUnnamed665(core.List<api.CalendarListEntry> o) {

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

147 checkCalendarListEntry(o[0]);

148 checkCalendarListEntry(o[1]);

149 }

150

151 core.int buildCounterCalendarList = 0;

152 buildCalendarList() {

153 var o = new api.CalendarList();

154 buildCounterCalendarList++;

155 if (buildCounterCalendarList < 3) {

156 o.etag = "foo";

157 o.items = buildUnnamed665();

158 o.kind = "foo";

159 o.nextPageToken = "foo";

160 o.nextSyncToken = "foo";

161 }

162 buildCounterCalendarList--;

163 return o;

164 }

165

166 checkCalendarList(api.CalendarList o) {

167 buildCounterCalendarList++;

168 if (buildCounterCalendarList < 3) {

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

170 checkUnnamed665(o.items);

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

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

173 unittest.expect(o.nextSyncToken, unittest.equals('foo'));

174 }

175 buildCounterCalendarList--;

176 }

177

178 buildUnnamed666() {

179 var o = new core.List<api.EventReminder>();

180 o.add(buildEventReminder());

181 o.add(buildEventReminder());

182 return o;

183 }

184

185 checkUnnamed666(core.List<api.EventReminder> o) {

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

187 checkEventReminder(o[0]);

188 checkEventReminder(o[1]);

189 }

190

191 buildUnnamed667() {

192 var o = new core.List<api.CalendarNotification>();

193 o.add(buildCalendarNotification());

194 o.add(buildCalendarNotification());

195 return o;

196 }

197

198 checkUnnamed667(core.List<api.CalendarNotification> o) {

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

200 checkCalendarNotification(o[0]);

201 checkCalendarNotification(o[1]);

202 }

203

204 core.int buildCounterCalendarListEntryNotificationSettings = 0;

205 buildCalendarListEntryNotificationSettings() {

206 var o = new api.CalendarListEntryNotificationSettings();

207 buildCounterCalendarListEntryNotificationSettings++;

208 if (buildCounterCalendarListEntryNotificationSettings < 3) {

209 o.notifications = buildUnnamed667();

210 }

211 buildCounterCalendarListEntryNotificationSettings--;

212 return o;

213 }

214

215 checkCalendarListEntryNotificationSettings(api.CalendarListEntryNotificationSett ings o) {

216 buildCounterCalendarListEntryNotificationSettings++;

217 if (buildCounterCalendarListEntryNotificationSettings < 3) {

218 checkUnnamed667(o.notifications);

219 }

220 buildCounterCalendarListEntryNotificationSettings--;

221 }

222

223 core.int buildCounterCalendarListEntry = 0;

224 buildCalendarListEntry() {

225 var o = new api.CalendarListEntry();

226 buildCounterCalendarListEntry++;

227 if (buildCounterCalendarListEntry < 3) {

228 o.accessRole = "foo";

229 o.backgroundColor = "foo";

230 o.colorId = "foo";

231 o.defaultReminders = buildUnnamed666();

232 o.deleted = true;

233 o.description = "foo";

234 o.etag = "foo";

235 o.foregroundColor = "foo";

236 o.hidden = true;

237 o.id = "foo";

238 o.kind = "foo";

239 o.location = "foo";

240 o.notificationSettings = buildCalendarListEntryNotificationSettings();

241 o.primary = true;

242 o.selected = true;

243 o.summary = "foo";

244 o.summaryOverride = "foo";

245 o.timeZone = "foo";

246 }

247 buildCounterCalendarListEntry--;

248 return o;

249 }

250

251 checkCalendarListEntry(api.CalendarListEntry o) {

252 buildCounterCalendarListEntry++;

253 if (buildCounterCalendarListEntry < 3) {

254 unittest.expect(o.accessRole, unittest.equals('foo'));

255 unittest.expect(o.backgroundColor, unittest.equals('foo'));

256 unittest.expect(o.colorId, unittest.equals('foo'));

257 checkUnnamed666(o.defaultReminders);

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

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

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

261 unittest.expect(o.foregroundColor, unittest.equals('foo'));

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

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

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

265 unittest.expect(o.location, unittest.equals('foo'));

266 checkCalendarListEntryNotificationSettings(o.notificationSettings);

267 unittest.expect(o.primary, unittest.isTrue);

268 unittest.expect(o.selected, unittest.isTrue);

269 unittest.expect(o.summary, unittest.equals('foo'));

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

271 unittest.expect(o.timeZone, unittest.equals('foo'));

272 }

273 buildCounterCalendarListEntry--;

274 }

275

276 core.int buildCounterCalendarNotification = 0;

277 buildCalendarNotification() {

278 var o = new api.CalendarNotification();

279 buildCounterCalendarNotification++;

280 if (buildCounterCalendarNotification < 3) {

281 o.method = "foo";

282 o.type = "foo";

283 }

284 buildCounterCalendarNotification--;

285 return o;

286 }

287

288 checkCalendarNotification(api.CalendarNotification o) {

289 buildCounterCalendarNotification++;

290 if (buildCounterCalendarNotification < 3) {

291 unittest.expect(o.method, unittest.equals('foo'));

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

293 }

294 buildCounterCalendarNotification--;

295 }

296

297 buildUnnamed668() {

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

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

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

301 return o;

302 }

303

304 checkUnnamed668(core.Map<core.String, core.String> o) {

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

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

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

308 }

309

310 core.int buildCounterChannel = 0;

311 buildChannel() {

312 var o = new api.Channel();

313 buildCounterChannel++;

314 if (buildCounterChannel < 3) {

315 o.address = "foo";

316 o.expiration = "foo";

317 o.id = "foo";

318 o.kind = "foo";

319 o.params = buildUnnamed668();

320 o.payload = true;

321 o.resourceId = "foo";

322 o.resourceUri = "foo";

323 o.token = "foo";

324 o.type = "foo";

325 }

326 buildCounterChannel--;

327 return o;

328 }

329

330 checkChannel(api.Channel o) {

331 buildCounterChannel++;

332 if (buildCounterChannel < 3) {

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

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

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

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

337 checkUnnamed668(o.params);

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

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

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

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

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

343 }

344 buildCounterChannel--;

345 }

346

347 core.int buildCounterColorDefinition = 0;

348 buildColorDefinition() {

349 var o = new api.ColorDefinition();

350 buildCounterColorDefinition++;

351 if (buildCounterColorDefinition < 3) {

352 o.background = "foo";

353 o.foreground = "foo";

354 }

355 buildCounterColorDefinition--;

356 return o;

357 }

358

359 checkColorDefinition(api.ColorDefinition o) {

360 buildCounterColorDefinition++;

361 if (buildCounterColorDefinition < 3) {

362 unittest.expect(o.background, unittest.equals('foo'));

363 unittest.expect(o.foreground, unittest.equals('foo'));

364 }

365 buildCounterColorDefinition--;

366 }

367

368 buildUnnamed669() {

369 var o = new core.Map<core.String, api.ColorDefinition>();

370 o["x"] = buildColorDefinition();

371 o["y"] = buildColorDefinition();

372 return o;

373 }

374

375 checkUnnamed669(core.Map<core.String, api.ColorDefinition> o) {

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

377 checkColorDefinition(o["x"]);

378 checkColorDefinition(o["y"]);

379 }

380

381 buildUnnamed670() {

382 var o = new core.Map<core.String, api.ColorDefinition>();

383 o["x"] = buildColorDefinition();

384 o["y"] = buildColorDefinition();

385 return o;

386 }

387

388 checkUnnamed670(core.Map<core.String, api.ColorDefinition> o) {

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

390 checkColorDefinition(o["x"]);

391 checkColorDefinition(o["y"]);

392 }

393

394 core.int buildCounterColors = 0;

395 buildColors() {

396 var o = new api.Colors();

397 buildCounterColors++;

398 if (buildCounterColors < 3) {

399 o.calendar = buildUnnamed669();

400 o.event = buildUnnamed670();

401 o.kind = "foo";

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

403 }

404 buildCounterColors--;

405 return o;

406 }

407

408 checkColors(api.Colors o) {

409 buildCounterColors++;

410 if (buildCounterColors < 3) {

411 checkUnnamed669(o.calendar);

412 checkUnnamed670(o.event);

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

414 unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T1 4:01:02")));

415 }

416 buildCounterColors--;

417 }

418

419 core.int buildCounterError = 0;

420 buildError() {

421 var o = new api.Error();

422 buildCounterError++;

423 if (buildCounterError < 3) {

424 o.domain = "foo";

425 o.reason = "foo";

426 }

427 buildCounterError--;

428 return o;

429 }

430

431 checkError(api.Error o) {

432 buildCounterError++;

433 if (buildCounterError < 3) {

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

435 unittest.expect(o.reason, unittest.equals('foo'));

436 }

437 buildCounterError--;

438 }

439

440 buildUnnamed671() {

441 var o = new core.List<api.EventAttendee>();

442 o.add(buildEventAttendee());

443 o.add(buildEventAttendee());

444 return o;

445 }

446

447 checkUnnamed671(core.List<api.EventAttendee> o) {

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

449 checkEventAttendee(o[0]);

450 checkEventAttendee(o[1]);

451 }

452

453 core.int buildCounterEventCreator = 0;

454 buildEventCreator() {

455 var o = new api.EventCreator();

456 buildCounterEventCreator++;

457 if (buildCounterEventCreator < 3) {

458 o.displayName = "foo";

459 o.email = "foo";

460 o.id = "foo";

461 o.self = true;

462 }

463 buildCounterEventCreator--;

464 return o;

465 }

466

467 checkEventCreator(api.EventCreator o) {

468 buildCounterEventCreator++;

469 if (buildCounterEventCreator < 3) {

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

471 unittest.expect(o.email, unittest.equals('foo'));

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

473 unittest.expect(o.self, unittest.isTrue);

474 }

475 buildCounterEventCreator--;

476 }

477

478 buildUnnamed672() {

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

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

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

482 return o;

483 }

484

485 checkUnnamed672(core.Map<core.String, core.String> o) {

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

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

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

489 }

490

491 buildUnnamed673() {

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

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

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

495 return o;

496 }

497

498 checkUnnamed673(core.Map<core.String, core.String> o) {

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

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

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

502 }

503

504 core.int buildCounterEventExtendedProperties = 0;

505 buildEventExtendedProperties() {

506 var o = new api.EventExtendedProperties();

507 buildCounterEventExtendedProperties++;

508 if (buildCounterEventExtendedProperties < 3) {

509 o.private = buildUnnamed672();

510 o.shared = buildUnnamed673();

511 }

512 buildCounterEventExtendedProperties--;

513 return o;

514 }

515

516 checkEventExtendedProperties(api.EventExtendedProperties o) {

517 buildCounterEventExtendedProperties++;

518 if (buildCounterEventExtendedProperties < 3) {

519 checkUnnamed672(o.private);

520 checkUnnamed673(o.shared);

521 }

522 buildCounterEventExtendedProperties--;

523 }

524

525 buildUnnamed674() {

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

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

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

529 return o;

530 }

531

532 checkUnnamed674(core.Map<core.String, core.String> o) {

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

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

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

536 }

537

538 core.int buildCounterEventGadget = 0;

539 buildEventGadget() {

540 var o = new api.EventGadget();

541 buildCounterEventGadget++;

542 if (buildCounterEventGadget < 3) {

543 o.display = "foo";

544 o.height = 42;

545 o.iconLink = "foo";

546 o.link = "foo";

547 o.preferences = buildUnnamed674();

548 o.title = "foo";

549 o.type = "foo";

550 o.width = 42;

551 }

552 buildCounterEventGadget--;

553 return o;

554 }

555

556 checkEventGadget(api.EventGadget o) {

557 buildCounterEventGadget++;

558 if (buildCounterEventGadget < 3) {

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

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

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

562 unittest.expect(o.link, unittest.equals('foo'));

563 checkUnnamed674(o.preferences);

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

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

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

567 }

568 buildCounterEventGadget--;

569 }

570

571 core.int buildCounterEventOrganizer = 0;

572 buildEventOrganizer() {

573 var o = new api.EventOrganizer();

574 buildCounterEventOrganizer++;

575 if (buildCounterEventOrganizer < 3) {

576 o.displayName = "foo";

577 o.email = "foo";

578 o.id = "foo";

579 o.self = true;

580 }

581 buildCounterEventOrganizer--;

582 return o;

583 }

584

585 checkEventOrganizer(api.EventOrganizer o) {

586 buildCounterEventOrganizer++;

587 if (buildCounterEventOrganizer < 3) {

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

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

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

591 unittest.expect(o.self, unittest.isTrue);

592 }

593 buildCounterEventOrganizer--;

594 }

595

596 buildUnnamed675() {

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

598 o.add("foo");

599 o.add("foo");

600 return o;

601 }

602

603 checkUnnamed675(core.List<core.String> o) {

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

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

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

607 }

608

609 buildUnnamed676() {

610 var o = new core.List<api.EventReminder>();

611 o.add(buildEventReminder());

612 o.add(buildEventReminder());

613 return o;

614 }

615

616 checkUnnamed676(core.List<api.EventReminder> o) {

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

618 checkEventReminder(o[0]);

619 checkEventReminder(o[1]);

620 }

621

622 core.int buildCounterEventReminders = 0;

623 buildEventReminders() {

624 var o = new api.EventReminders();

625 buildCounterEventReminders++;

626 if (buildCounterEventReminders < 3) {

627 o.overrides = buildUnnamed676();

628 o.useDefault = true;

629 }

630 buildCounterEventReminders--;

631 return o;

632 }

633

634 checkEventReminders(api.EventReminders o) {

635 buildCounterEventReminders++;

636 if (buildCounterEventReminders < 3) {

637 checkUnnamed676(o.overrides);

638 unittest.expect(o.useDefault, unittest.isTrue);

639 }

640 buildCounterEventReminders--;

641 }

642

643 core.int buildCounterEventSource = 0;

644 buildEventSource() {

645 var o = new api.EventSource();

646 buildCounterEventSource++;

647 if (buildCounterEventSource < 3) {

648 o.title = "foo";

649 o.url = "foo";

650 }

651 buildCounterEventSource--;

652 return o;

653 }

654

655 checkEventSource(api.EventSource o) {

656 buildCounterEventSource++;

657 if (buildCounterEventSource < 3) {

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

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

660 }

661 buildCounterEventSource--;

662 }

663

664 core.int buildCounterEvent = 0;

665 buildEvent() {

666 var o = new api.Event();

667 buildCounterEvent++;

668 if (buildCounterEvent < 3) {

669 o.anyoneCanAddSelf = true;

670 o.attendees = buildUnnamed671();

671 o.attendeesOmitted = true;

672 o.colorId = "foo";

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

674 o.creator = buildEventCreator();

675 o.description = "foo";

676 o.end = buildEventDateTime();

677 o.endTimeUnspecified = true;

678 o.etag = "foo";

679 o.extendedProperties = buildEventExtendedProperties();

680 o.gadget = buildEventGadget();

681 o.guestsCanInviteOthers = true;

682 o.guestsCanModify = true;

683 o.guestsCanSeeOtherGuests = true;

684 o.hangoutLink = "foo";

685 o.htmlLink = "foo";

686 o.iCalUID = "foo";

687 o.id = "foo";

688 o.kind = "foo";

689 o.location = "foo";

690 o.locked = true;

691 o.organizer = buildEventOrganizer();

692 o.originalStartTime = buildEventDateTime();

693 o.privateCopy = true;

694 o.recurrence = buildUnnamed675();

695 o.recurringEventId = "foo";

696 o.reminders = buildEventReminders();

697 o.sequence = 42;

698 o.source = buildEventSource();

699 o.start = buildEventDateTime();

700 o.status = "foo";

701 o.summary = "foo";

702 o.transparency = "foo";

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

704 o.visibility = "foo";

705 }

706 buildCounterEvent--;

707 return o;

708 }

709

710 checkEvent(api.Event o) {

711 buildCounterEvent++;

712 if (buildCounterEvent < 3) {

713 unittest.expect(o.anyoneCanAddSelf, unittest.isTrue);

714 checkUnnamed671(o.attendees);

715 unittest.expect(o.attendeesOmitted, unittest.isTrue);

716 unittest.expect(o.colorId, unittest.equals('foo'));

717 unittest.expect(o.created, unittest.equals(core.DateTime.parse("2002-02-27T1 4:01:02")));

718 checkEventCreator(o.creator);

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

720 checkEventDateTime(o.end);

721 unittest.expect(o.endTimeUnspecified, unittest.isTrue);

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

723 checkEventExtendedProperties(o.extendedProperties);

724 checkEventGadget(o.gadget);

725 unittest.expect(o.guestsCanInviteOthers, unittest.isTrue);

726 unittest.expect(o.guestsCanModify, unittest.isTrue);

727 unittest.expect(o.guestsCanSeeOtherGuests, unittest.isTrue);

728 unittest.expect(o.hangoutLink, unittest.equals('foo'));

729 unittest.expect(o.htmlLink, unittest.equals('foo'));

730 unittest.expect(o.iCalUID, unittest.equals('foo'));

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

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

733 unittest.expect(o.location, unittest.equals('foo'));

734 unittest.expect(o.locked, unittest.isTrue);

735 checkEventOrganizer(o.organizer);

736 checkEventDateTime(o.originalStartTime);

737 unittest.expect(o.privateCopy, unittest.isTrue);

738 checkUnnamed675(o.recurrence);

739 unittest.expect(o.recurringEventId, unittest.equals('foo'));

740 checkEventReminders(o.reminders);

741 unittest.expect(o.sequence, unittest.equals(42));

742 checkEventSource(o.source);

743 checkEventDateTime(o.start);

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

745 unittest.expect(o.summary, unittest.equals('foo'));

746 unittest.expect(o.transparency, unittest.equals('foo'));

747 unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T1 4:01:02")));

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

749 }

750 buildCounterEvent--;

751 }

752

753 core.int buildCounterEventAttendee = 0;

754 buildEventAttendee() {

755 var o = new api.EventAttendee();

756 buildCounterEventAttendee++;

757 if (buildCounterEventAttendee < 3) {

758 o.additionalGuests = 42;

759 o.comment = "foo";

760 o.displayName = "foo";

761 o.email = "foo";

762 o.id = "foo";

763 o.optional = true;

764 o.organizer = true;

765 o.resource = true;

766 o.responseStatus = "foo";

767 o.self = true;

768 }

769 buildCounterEventAttendee--;

770 return o;

771 }

772

773 checkEventAttendee(api.EventAttendee o) {

774 buildCounterEventAttendee++;

775 if (buildCounterEventAttendee < 3) {

776 unittest.expect(o.additionalGuests, unittest.equals(42));

777 unittest.expect(o.comment, unittest.equals('foo'));

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

779 unittest.expect(o.email, unittest.equals('foo'));

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

781 unittest.expect(o.optional, unittest.isTrue);

782 unittest.expect(o.organizer, unittest.isTrue);

783 unittest.expect(o.resource, unittest.isTrue);

784 unittest.expect(o.responseStatus, unittest.equals('foo'));

785 unittest.expect(o.self, unittest.isTrue);

786 }

787 buildCounterEventAttendee--;

788 }

789

790 core.int buildCounterEventDateTime = 0;

791 buildEventDateTime() {

792 var o = new api.EventDateTime();

793 buildCounterEventDateTime++;

794 if (buildCounterEventDateTime < 3) {

795 o.date = core.DateTime.parse("2002-02-27T14:01:02Z");

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

797 o.timeZone = "foo";

798 }

799 buildCounterEventDateTime--;

800 return o;

801 }

802

803 checkEventDateTime(api.EventDateTime o) {

804 buildCounterEventDateTime++;

805 if (buildCounterEventDateTime < 3) {

806 unittest.expect(o.date, unittest.equals(core.DateTime.parse("2002-02-27T00:0 0:00")));

807 unittest.expect(o.dateTime, unittest.equals(core.DateTime.parse("2002-02-27T 14:01:02")));

808 unittest.expect(o.timeZone, unittest.equals('foo'));

809 }

810 buildCounterEventDateTime--;

811 }

812

813 core.int buildCounterEventReminder = 0;

814 buildEventReminder() {

815 var o = new api.EventReminder();

816 buildCounterEventReminder++;

817 if (buildCounterEventReminder < 3) {

818 o.method = "foo";

819 o.minutes = 42;

820 }

821 buildCounterEventReminder--;

822 return o;

823 }

824

825 checkEventReminder(api.EventReminder o) {

826 buildCounterEventReminder++;

827 if (buildCounterEventReminder < 3) {

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

829 unittest.expect(o.minutes, unittest.equals(42));

830 }

831 buildCounterEventReminder--;

832 }

833

834 buildUnnamed677() {

835 var o = new core.List<api.EventReminder>();

836 o.add(buildEventReminder());

837 o.add(buildEventReminder());

838 return o;

839 }

840

841 checkUnnamed677(core.List<api.EventReminder> o) {

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

843 checkEventReminder(o[0]);

844 checkEventReminder(o[1]);

845 }

846

847 buildUnnamed678() {

848 var o = new core.List<api.Event>();

849 o.add(buildEvent());

850 o.add(buildEvent());

851 return o;

852 }

853

854 checkUnnamed678(core.List<api.Event> o) {

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

856 checkEvent(o[0]);

857 checkEvent(o[1]);

858 }

859

860 core.int buildCounterEvents = 0;

861 buildEvents() {

862 var o = new api.Events();

863 buildCounterEvents++;

864 if (buildCounterEvents < 3) {

865 o.accessRole = "foo";

866 o.defaultReminders = buildUnnamed677();

867 o.description = "foo";

868 o.etag = "foo";

869 o.items = buildUnnamed678();

870 o.kind = "foo";

871 o.nextPageToken = "foo";

872 o.nextSyncToken = "foo";

873 o.summary = "foo";

874 o.timeZone = "foo";

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

876 }

877 buildCounterEvents--;

878 return o;

879 }

880

881 checkEvents(api.Events o) {

882 buildCounterEvents++;

883 if (buildCounterEvents < 3) {

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

885 checkUnnamed677(o.defaultReminders);

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

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

888 checkUnnamed678(o.items);

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

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

891 unittest.expect(o.nextSyncToken, unittest.equals('foo'));

892 unittest.expect(o.summary, unittest.equals('foo'));

893 unittest.expect(o.timeZone, unittest.equals('foo'));

894 unittest.expect(o.updated, unittest.equals(core.DateTime.parse("2002-02-27T1 4:01:02")));

895 }

896 buildCounterEvents--;

897 }

898

899 buildUnnamed679() {

900 var o = new core.List<api.TimePeriod>();

901 o.add(buildTimePeriod());

902 o.add(buildTimePeriod());

903 return o;

904 }

905

906 checkUnnamed679(core.List<api.TimePeriod> o) {

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

908 checkTimePeriod(o[0]);

909 checkTimePeriod(o[1]);

910 }

911

912 buildUnnamed680() {

913 var o = new core.List<api.Error>();

914 o.add(buildError());

915 o.add(buildError());

916 return o;

917 }

918

919 checkUnnamed680(core.List<api.Error> o) {

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

921 checkError(o[0]);

922 checkError(o[1]);

923 }

924

925 core.int buildCounterFreeBusyCalendar = 0;

926 buildFreeBusyCalendar() {

927 var o = new api.FreeBusyCalendar();

928 buildCounterFreeBusyCalendar++;

929 if (buildCounterFreeBusyCalendar < 3) {

930 o.busy = buildUnnamed679();

931 o.errors = buildUnnamed680();

932 }

933 buildCounterFreeBusyCalendar--;

934 return o;

935 }

936

937 checkFreeBusyCalendar(api.FreeBusyCalendar o) {

938 buildCounterFreeBusyCalendar++;

939 if (buildCounterFreeBusyCalendar < 3) {

940 checkUnnamed679(o.busy);

941 checkUnnamed680(o.errors);

942 }

943 buildCounterFreeBusyCalendar--;

944 }

945

946 buildUnnamed681() {

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

948 o.add("foo");

949 o.add("foo");

950 return o;

951 }

952

953 checkUnnamed681(core.List<core.String> o) {

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

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

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

957 }

958

959 buildUnnamed682() {

960 var o = new core.List<api.Error>();

961 o.add(buildError());

962 o.add(buildError());

963 return o;

964 }

965

966 checkUnnamed682(core.List<api.Error> o) {

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

968 checkError(o[0]);

969 checkError(o[1]);

970 }

971

972 core.int buildCounterFreeBusyGroup = 0;

973 buildFreeBusyGroup() {

974 var o = new api.FreeBusyGroup();

975 buildCounterFreeBusyGroup++;

976 if (buildCounterFreeBusyGroup < 3) {

977 o.calendars = buildUnnamed681();

978 o.errors = buildUnnamed682();

979 }

980 buildCounterFreeBusyGroup--;

981 return o;

982 }

983

984 checkFreeBusyGroup(api.FreeBusyGroup o) {

985 buildCounterFreeBusyGroup++;

986 if (buildCounterFreeBusyGroup < 3) {

987 checkUnnamed681(o.calendars);

988 checkUnnamed682(o.errors);

989 }

990 buildCounterFreeBusyGroup--;

991 }

992

993 buildUnnamed683() {

994 var o = new core.List<api.FreeBusyRequestItem>();

995 o.add(buildFreeBusyRequestItem());

996 o.add(buildFreeBusyRequestItem());

997 return o;

998 }

999

1000 checkUnnamed683(core.List<api.FreeBusyRequestItem> o) {

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

1002 checkFreeBusyRequestItem(o[0]);

1003 checkFreeBusyRequestItem(o[1]);

1004 }

1005

1006 core.int buildCounterFreeBusyRequest = 0;

1007 buildFreeBusyRequest() {

1008 var o = new api.FreeBusyRequest();

1009 buildCounterFreeBusyRequest++;

1010 if (buildCounterFreeBusyRequest < 3) {

1011 o.calendarExpansionMax = 42;

1012 o.groupExpansionMax = 42;

1013 o.items = buildUnnamed683();

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

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

1016 o.timeZone = "foo";

1017 }

1018 buildCounterFreeBusyRequest--;

1019 return o;

1020 }

1021

1022 checkFreeBusyRequest(api.FreeBusyRequest o) {

1023 buildCounterFreeBusyRequest++;

1024 if (buildCounterFreeBusyRequest < 3) {

1025 unittest.expect(o.calendarExpansionMax, unittest.equals(42));

1026 unittest.expect(o.groupExpansionMax, unittest.equals(42));

1027 checkUnnamed683(o.items);

1028 unittest.expect(o.timeMax, unittest.equals(core.DateTime.parse("2002-02-27T1 4:01:02")));

1029 unittest.expect(o.timeMin, unittest.equals(core.DateTime.parse("2002-02-27T1 4:01:02")));

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

1031 }

1032 buildCounterFreeBusyRequest--;

1033 }

1034

1035 core.int buildCounterFreeBusyRequestItem = 0;

1036 buildFreeBusyRequestItem() {

1037 var o = new api.FreeBusyRequestItem();

1038 buildCounterFreeBusyRequestItem++;

1039 if (buildCounterFreeBusyRequestItem < 3) {

1040 o.id = "foo";

1041 }

1042 buildCounterFreeBusyRequestItem--;

1043 return o;

1044 }

1045

1046 checkFreeBusyRequestItem(api.FreeBusyRequestItem o) {

1047 buildCounterFreeBusyRequestItem++;

1048 if (buildCounterFreeBusyRequestItem < 3) {

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

1050 }

1051 buildCounterFreeBusyRequestItem--;

1052 }

1053

1054 buildUnnamed684() {

1055 var o = new core.Map<core.String, api.FreeBusyCalendar>();

1056 o["x"] = buildFreeBusyCalendar();

1057 o["y"] = buildFreeBusyCalendar();

1058 return o;

1059 }

1060

1061 checkUnnamed684(core.Map<core.String, api.FreeBusyCalendar> o) {

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

1063 checkFreeBusyCalendar(o["x"]);

1064 checkFreeBusyCalendar(o["y"]);

1065 }

1066

1067 buildUnnamed685() {

1068 var o = new core.Map<core.String, api.FreeBusyGroup>();

1069 o["x"] = buildFreeBusyGroup();

1070 o["y"] = buildFreeBusyGroup();

1071 return o;

1072 }

1073

1074 checkUnnamed685(core.Map<core.String, api.FreeBusyGroup> o) {

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

1076 checkFreeBusyGroup(o["x"]);

1077 checkFreeBusyGroup(o["y"]);

1078 }

1079

1080 core.int buildCounterFreeBusyResponse = 0;

1081 buildFreeBusyResponse() {

1082 var o = new api.FreeBusyResponse();

1083 buildCounterFreeBusyResponse++;

1084 if (buildCounterFreeBusyResponse < 3) {

1085 o.calendars = buildUnnamed684();

1086 o.groups = buildUnnamed685();

1087 o.kind = "foo";

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

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

1090 }

1091 buildCounterFreeBusyResponse--;

1092 return o;

1093 }

1094

1095 checkFreeBusyResponse(api.FreeBusyResponse o) {

1096 buildCounterFreeBusyResponse++;

1097 if (buildCounterFreeBusyResponse < 3) {

1098 checkUnnamed684(o.calendars);

1099 checkUnnamed685(o.groups);

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

1101 unittest.expect(o.timeMax, unittest.equals(core.DateTime.parse("2002-02-27T1 4:01:02")));

1102 unittest.expect(o.timeMin, unittest.equals(core.DateTime.parse("2002-02-27T1 4:01:02")));

1103 }

1104 buildCounterFreeBusyResponse--;

1105 }

1106

1107 core.int buildCounterSetting = 0;

1108 buildSetting() {

1109 var o = new api.Setting();

1110 buildCounterSetting++;

1111 if (buildCounterSetting < 3) {

1112 o.etag = "foo";

1113 o.id = "foo";

1114 o.kind = "foo";

1115 o.value = "foo";

1116 }

1117 buildCounterSetting--;

1118 return o;

1119 }

1120

1121 checkSetting(api.Setting o) {

1122 buildCounterSetting++;

1123 if (buildCounterSetting < 3) {

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

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

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

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

1128 }

1129 buildCounterSetting--;

1130 }

1131

1132 buildUnnamed686() {

1133 var o = new core.List<api.Setting>();

1134 o.add(buildSetting());

1135 o.add(buildSetting());

1136 return o;

1137 }

1138

1139 checkUnnamed686(core.List<api.Setting> o) {

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

1141 checkSetting(o[0]);

1142 checkSetting(o[1]);

1143 }

1144

1145 core.int buildCounterSettings = 0;

1146 buildSettings() {

1147 var o = new api.Settings();

1148 buildCounterSettings++;

1149 if (buildCounterSettings < 3) {

1150 o.etag = "foo";

1151 o.items = buildUnnamed686();

1152 o.kind = "foo";

1153 o.nextPageToken = "foo";

1154 o.nextSyncToken = "foo";

1155 }

1156 buildCounterSettings--;

1157 return o;

1158 }

1159

1160 checkSettings(api.Settings o) {

1161 buildCounterSettings++;

1162 if (buildCounterSettings < 3) {

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

1164 checkUnnamed686(o.items);

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

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

1167 unittest.expect(o.nextSyncToken, unittest.equals('foo'));

1168 }

1169 buildCounterSettings--;

1170 }

1171

1172 core.int buildCounterTimePeriod = 0;

1173 buildTimePeriod() {

1174 var o = new api.TimePeriod();

1175 buildCounterTimePeriod++;

1176 if (buildCounterTimePeriod < 3) {

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

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

1179 }

1180 buildCounterTimePeriod--;

1181 return o;

1182 }

1183

1184 checkTimePeriod(api.TimePeriod o) {

1185 buildCounterTimePeriod++;

1186 if (buildCounterTimePeriod < 3) {

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

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

1189 }

1190 buildCounterTimePeriod--;

1191 }

1192

1193 buildUnnamed687() {

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

1195 o.add("foo");

1196 o.add("foo");

1197 return o;

1198 }

1199

1200 checkUnnamed687(core.List<core.String> o) {

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

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

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

1204 }

1205

1206 buildUnnamed688() {

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

1208 o.add("foo");

1209 o.add("foo");

1210 return o;

1211 }

1212

1213 checkUnnamed688(core.List<core.String> o) {

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

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

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

1217 }

1218

1219 buildUnnamed689() {

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

1221 o.add("foo");

1222 o.add("foo");

1223 return o;

1224 }

1225

1226 checkUnnamed689(core.List<core.String> o) {

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

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

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

1230 }

1231

1232 buildUnnamed690() {

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

1234 o.add("foo");

1235 o.add("foo");

1236 return o;

1237 }

1238

1239 checkUnnamed690(core.List<core.String> o) {

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

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

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

1243 }

1244

1245

1246 main() {

1247 unittest.group("obj-schema-Acl", () {

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

1249 var o = buildAcl();

1250 var od = new api.Acl.fromJson(o.toJson());

1251 checkAcl(od);

1252 });

1253 });

1254

1255

1256 unittest.group("obj-schema-AclRuleScope", () {

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

1258 var o = buildAclRuleScope();

1259 var od = new api.AclRuleScope.fromJson(o.toJson());

1260 checkAclRuleScope(od);

1261 });

1262 });

1263

1264

1265 unittest.group("obj-schema-AclRule", () {

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

1267 var o = buildAclRule();

1268 var od = new api.AclRule.fromJson(o.toJson());

1269 checkAclRule(od);

1270 });

1271 });

1272

1273

1274 unittest.group("obj-schema-Calendar", () {

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

1276 var o = buildCalendar();

1277 var od = new api.Calendar.fromJson(o.toJson());

1278 checkCalendar(od);

1279 });

1280 });

1281

1282

1283 unittest.group("obj-schema-CalendarList", () {

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

1285 var o = buildCalendarList();

1286 var od = new api.CalendarList.fromJson(o.toJson());

1287 checkCalendarList(od);

1288 });

1289 });

1290

1291

1292 unittest.group("obj-schema-CalendarListEntryNotificationSettings", () {

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

1294 var o = buildCalendarListEntryNotificationSettings();

1295 var od = new api.CalendarListEntryNotificationSettings.fromJson(o.toJson() );

1296 checkCalendarListEntryNotificationSettings(od);

1297 });

1298 });

1299

1300

1301 unittest.group("obj-schema-CalendarListEntry", () {

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

1303 var o = buildCalendarListEntry();

1304 var od = new api.CalendarListEntry.fromJson(o.toJson());

1305 checkCalendarListEntry(od);

1306 });

1307 });

1308

1309

1310 unittest.group("obj-schema-CalendarNotification", () {

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

1312 var o = buildCalendarNotification();

1313 var od = new api.CalendarNotification.fromJson(o.toJson());

1314 checkCalendarNotification(od);

1315 });

1316 });

1317

1318

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

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

1321 var o = buildChannel();

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

1323 checkChannel(od);

1324 });

1325 });

1326

1327

1328 unittest.group("obj-schema-ColorDefinition", () {

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

1330 var o = buildColorDefinition();

1331 var od = new api.ColorDefinition.fromJson(o.toJson());

1332 checkColorDefinition(od);

1333 });

1334 });

1335

1336

1337 unittest.group("obj-schema-Colors", () {

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

1339 var o = buildColors();

1340 var od = new api.Colors.fromJson(o.toJson());

1341 checkColors(od);

1342 });

1343 });

1344

1345

1346 unittest.group("obj-schema-Error", () {

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

1348 var o = buildError();

1349 var od = new api.Error.fromJson(o.toJson());

1350 checkError(od);

1351 });

1352 });

1353

1354

1355 unittest.group("obj-schema-EventCreator", () {

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

1357 var o = buildEventCreator();

1358 var od = new api.EventCreator.fromJson(o.toJson());

1359 checkEventCreator(od);

1360 });

1361 });

1362

1363

1364 unittest.group("obj-schema-EventExtendedProperties", () {

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

1366 var o = buildEventExtendedProperties();

1367 var od = new api.EventExtendedProperties.fromJson(o.toJson());

1368 checkEventExtendedProperties(od);

1369 });

1370 });

1371

1372

1373 unittest.group("obj-schema-EventGadget", () {

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

1375 var o = buildEventGadget();

1376 var od = new api.EventGadget.fromJson(o.toJson());

1377 checkEventGadget(od);

1378 });

1379 });

1380

1381

1382 unittest.group("obj-schema-EventOrganizer", () {

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

1384 var o = buildEventOrganizer();

1385 var od = new api.EventOrganizer.fromJson(o.toJson());

1386 checkEventOrganizer(od);

1387 });

1388 });

1389

1390

1391 unittest.group("obj-schema-EventReminders", () {

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

1393 var o = buildEventReminders();

1394 var od = new api.EventReminders.fromJson(o.toJson());

1395 checkEventReminders(od);

1396 });

1397 });

1398

1399

1400 unittest.group("obj-schema-EventSource", () {

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

1402 var o = buildEventSource();

1403 var od = new api.EventSource.fromJson(o.toJson());

1404 checkEventSource(od);

1405 });

1406 });

1407

1408

1409 unittest.group("obj-schema-Event", () {

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

1411 var o = buildEvent();

1412 var od = new api.Event.fromJson(o.toJson());

1413 checkEvent(od);

1414 });

1415 });

1416

1417

1418 unittest.group("obj-schema-EventAttendee", () {

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

1420 var o = buildEventAttendee();

1421 var od = new api.EventAttendee.fromJson(o.toJson());

1422 checkEventAttendee(od);

1423 });

1424 });

1425

1426

1427 unittest.group("obj-schema-EventDateTime", () {

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

1429 var o = buildEventDateTime();

1430 var od = new api.EventDateTime.fromJson(o.toJson());

1431 checkEventDateTime(od);

1432 });

1433 });

1434

1435

1436 unittest.group("obj-schema-EventReminder", () {

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

1438 var o = buildEventReminder();

1439 var od = new api.EventReminder.fromJson(o.toJson());

1440 checkEventReminder(od);

1441 });

1442 });

1443

1444

1445 unittest.group("obj-schema-Events", () {

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

1447 var o = buildEvents();

1448 var od = new api.Events.fromJson(o.toJson());

1449 checkEvents(od);

1450 });

1451 });

1452

1453

1454 unittest.group("obj-schema-FreeBusyCalendar", () {

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

1456 var o = buildFreeBusyCalendar();

1457 var od = new api.FreeBusyCalendar.fromJson(o.toJson());

1458 checkFreeBusyCalendar(od);

1459 });

1460 });

1461

1462

1463 unittest.group("obj-schema-FreeBusyGroup", () {

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

1465 var o = buildFreeBusyGroup();

1466 var od = new api.FreeBusyGroup.fromJson(o.toJson());

1467 checkFreeBusyGroup(od);

1468 });

1469 });

1470

1471

1472 unittest.group("obj-schema-FreeBusyRequest", () {

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

1474 var o = buildFreeBusyRequest();

1475 var od = new api.FreeBusyRequest.fromJson(o.toJson());

1476 checkFreeBusyRequest(od);

1477 });

1478 });

1479

1480

1481 unittest.group("obj-schema-FreeBusyRequestItem", () {

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

1483 var o = buildFreeBusyRequestItem();

1484 var od = new api.FreeBusyRequestItem.fromJson(o.toJson());

1485 checkFreeBusyRequestItem(od);

1486 });

1487 });

1488

1489

1490 unittest.group("obj-schema-FreeBusyResponse", () {

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

1492 var o = buildFreeBusyResponse();

1493 var od = new api.FreeBusyResponse.fromJson(o.toJson());

1494 checkFreeBusyResponse(od);

1495 });

1496 });

1497

1498

1499 unittest.group("obj-schema-Setting", () {

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

1501 var o = buildSetting();

1502 var od = new api.Setting.fromJson(o.toJson());

1503 checkSetting(od);

1504 });

1505 });

1506

1507

1508 unittest.group("obj-schema-Settings", () {

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

1510 var o = buildSettings();

1511 var od = new api.Settings.fromJson(o.toJson());

1512 checkSettings(od);

1513 });

1514 });

1515

1516

1517 unittest.group("obj-schema-TimePeriod", () {

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

1519 var o = buildTimePeriod();

1520 var od = new api.TimePeriod.fromJson(o.toJson());

1521 checkTimePeriod(od);

1522 });

1523 });

1524

1525

1526 unittest.group("resource-AclResourceApi", () {

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

1528

1529 var mock = new common_test.HttpServerMock();

1530 api.AclResourceApi res = new api.CalendarApi(mock).acl;

1531 var arg_calendarId = "foo";

1532 var arg_ruleId = "foo";

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

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

1535 var pathOffset = 0;

1536 var index;

1537 var subPart;

1538 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

1539 pathOffset += 13;

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

1541 pathOffset += 10;

1542 index = path.indexOf("/acl/", pathOffset);

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

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

1545 pathOffset = index;

1546 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

1548 pathOffset += 5;

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

1550 pathOffset = path.length;

1551 unittest.expect(subPart, unittest.equals("$arg_ruleId"));

1552

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

1554 var queryOffset = 0;

1555 var queryMap = {};

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

1557 parseBool(n) {

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

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

1560 if (n == null) return null;

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

1562 }

1563 if (query.length > 0) {

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

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

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

1567 }

1568 }

1569

1570

1571 var h = {

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

1573 };

1574 var resp = "";

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

1576 }), true);

1577 res.delete(arg_calendarId, arg_ruleId).then(unittest.expectAsync((_) {}));

1578 });

1579

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

1581

1582 var mock = new common_test.HttpServerMock();

1583 api.AclResourceApi res = new api.CalendarApi(mock).acl;

1584 var arg_calendarId = "foo";

1585 var arg_ruleId = "foo";

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

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

1588 var pathOffset = 0;

1589 var index;

1590 var subPart;

1591 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

1592 pathOffset += 13;

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

1594 pathOffset += 10;

1595 index = path.indexOf("/acl/", pathOffset);

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

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

1598 pathOffset = index;

1599 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

1601 pathOffset += 5;

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

1603 pathOffset = path.length;

1604 unittest.expect(subPart, unittest.equals("$arg_ruleId"));

1605

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

1607 var queryOffset = 0;

1608 var queryMap = {};

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

1610 parseBool(n) {

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

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

1613 if (n == null) return null;

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

1615 }

1616 if (query.length > 0) {

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

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

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

1620 }

1621 }

1622

1623

1624 var h = {

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

1626 };

1627 var resp = convert.JSON.encode(buildAclRule());

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

1629 }), true);

1630 res.get(arg_calendarId, arg_ruleId).then(unittest.expectAsync(((api.AclRul e response) {

1631 checkAclRule(response);

1632 })));

1633 });

1634

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

1636

1637 var mock = new common_test.HttpServerMock();

1638 api.AclResourceApi res = new api.CalendarApi(mock).acl;

1639 var arg_request = buildAclRule();

1640 var arg_calendarId = "foo";

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

1642 var obj = new api.AclRule.fromJson(json);

1643 checkAclRule(obj);

1644

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

1646 var pathOffset = 0;

1647 var index;

1648 var subPart;

1649 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

1650 pathOffset += 13;

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

1652 pathOffset += 10;

1653 index = path.indexOf("/acl", pathOffset);

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

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

1656 pathOffset = index;

1657 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

1658 unittest.expect(path.substring(pathOffset, pathOffset + 4), unittest.equ als("/acl"));

1659 pathOffset += 4;

1660

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

1662 var queryOffset = 0;

1663 var queryMap = {};

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

1665 parseBool(n) {

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

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

1668 if (n == null) return null;

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

1670 }

1671 if (query.length > 0) {

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

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

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

1675 }

1676 }

1677

1678

1679 var h = {

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

1681 };

1682 var resp = convert.JSON.encode(buildAclRule());

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

1684 }), true);

1685 res.insert(arg_request, arg_calendarId).then(unittest.expectAsync(((api.Ac lRule response) {

1686 checkAclRule(response);

1687 })));

1688 });

1689

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

1691

1692 var mock = new common_test.HttpServerMock();

1693 api.AclResourceApi res = new api.CalendarApi(mock).acl;

1694 var arg_calendarId = "foo";

1695 var arg_maxResults = 42;

1696 var arg_pageToken = "foo";

1697 var arg_showDeleted = true;

1698 var arg_syncToken = "foo";

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

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

1701 var pathOffset = 0;

1702 var index;

1703 var subPart;

1704 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

1705 pathOffset += 13;

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

1707 pathOffset += 10;

1708 index = path.indexOf("/acl", pathOffset);

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

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

1711 pathOffset = index;

1712 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

1713 unittest.expect(path.substring(pathOffset, pathOffset + 4), unittest.equ als("/acl"));

1714 pathOffset += 4;

1715

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

1717 var queryOffset = 0;

1718 var queryMap = {};

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

1720 parseBool(n) {

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

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

1723 if (n == null) return null;

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

1725 }

1726 if (query.length > 0) {

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

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

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

1730 }

1731 }

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

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

1734 unittest.expect(queryMap["showDeleted"].first, unittest.equals("$arg_sho wDeleted"));

1735 unittest.expect(queryMap["syncToken"].first, unittest.equals(arg_syncTok en));

1736

1737

1738 var h = {

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

1740 };

1741 var resp = convert.JSON.encode(buildAcl());

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

1743 }), true);

1744 res.list(arg_calendarId, maxResults: arg_maxResults, pageToken: arg_pageTo ken, showDeleted: arg_showDeleted, syncToken: arg_syncToken).then(unittest.expec tAsync(((api.Acl response) {

1745 checkAcl(response);

1746 })));

1747 });

1748

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

1750

1751 var mock = new common_test.HttpServerMock();

1752 api.AclResourceApi res = new api.CalendarApi(mock).acl;

1753 var arg_request = buildAclRule();

1754 var arg_calendarId = "foo";

1755 var arg_ruleId = "foo";

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

1757 var obj = new api.AclRule.fromJson(json);

1758 checkAclRule(obj);

1759

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

1761 var pathOffset = 0;

1762 var index;

1763 var subPart;

1764 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

1765 pathOffset += 13;

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

1767 pathOffset += 10;

1768 index = path.indexOf("/acl/", pathOffset);

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

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

1771 pathOffset = index;

1772 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

1774 pathOffset += 5;

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

1776 pathOffset = path.length;

1777 unittest.expect(subPart, unittest.equals("$arg_ruleId"));

1778

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

1780 var queryOffset = 0;

1781 var queryMap = {};

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

1783 parseBool(n) {

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

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

1786 if (n == null) return null;

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

1788 }

1789 if (query.length > 0) {

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

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

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

1793 }

1794 }

1795

1796

1797 var h = {

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

1799 };

1800 var resp = convert.JSON.encode(buildAclRule());

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

1802 }), true);

1803 res.patch(arg_request, arg_calendarId, arg_ruleId).then(unittest.expectAsy nc(((api.AclRule response) {

1804 checkAclRule(response);

1805 })));

1806 });

1807

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

1809

1810 var mock = new common_test.HttpServerMock();

1811 api.AclResourceApi res = new api.CalendarApi(mock).acl;

1812 var arg_request = buildAclRule();

1813 var arg_calendarId = "foo";

1814 var arg_ruleId = "foo";

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

1816 var obj = new api.AclRule.fromJson(json);

1817 checkAclRule(obj);

1818

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

1820 var pathOffset = 0;

1821 var index;

1822 var subPart;

1823 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

1824 pathOffset += 13;

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

1826 pathOffset += 10;

1827 index = path.indexOf("/acl/", pathOffset);

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

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

1830 pathOffset = index;

1831 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

1833 pathOffset += 5;

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

1835 pathOffset = path.length;

1836 unittest.expect(subPart, unittest.equals("$arg_ruleId"));

1837

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

1839 var queryOffset = 0;

1840 var queryMap = {};

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

1842 parseBool(n) {

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

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

1845 if (n == null) return null;

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

1847 }

1848 if (query.length > 0) {

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

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

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

1852 }

1853 }

1854

1855

1856 var h = {

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

1858 };

1859 var resp = convert.JSON.encode(buildAclRule());

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

1861 }), true);

1862 res.update(arg_request, arg_calendarId, arg_ruleId).then(unittest.expectAs ync(((api.AclRule response) {

1863 checkAclRule(response);

1864 })));

1865 });

1866

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

1868

1869 var mock = new common_test.HttpServerMock();

1870 api.AclResourceApi res = new api.CalendarApi(mock).acl;

1871 var arg_request = buildChannel();

1872 var arg_calendarId = "foo";

1873 var arg_maxResults = 42;

1874 var arg_pageToken = "foo";

1875 var arg_showDeleted = true;

1876 var arg_syncToken = "foo";

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

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

1879 checkChannel(obj);

1880

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

1882 var pathOffset = 0;

1883 var index;

1884 var subPart;

1885 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

1886 pathOffset += 13;

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

1888 pathOffset += 10;

1889 index = path.indexOf("/acl/watch", pathOffset);

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

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

1892 pathOffset = index;

1893 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

1894 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/acl/watch"));

1895 pathOffset += 10;

1896

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

1898 var queryOffset = 0;

1899 var queryMap = {};

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

1901 parseBool(n) {

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

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

1904 if (n == null) return null;

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

1906 }

1907 if (query.length > 0) {

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

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

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

1911 }

1912 }

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

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

1915 unittest.expect(queryMap["showDeleted"].first, unittest.equals("$arg_sho wDeleted"));

1916 unittest.expect(queryMap["syncToken"].first, unittest.equals(arg_syncTok en));

1917

1918

1919 var h = {

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

1921 };

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

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

1924 }), true);

1925 res.watch(arg_request, arg_calendarId, maxResults: arg_maxResults, pageTok en: arg_pageToken, showDeleted: arg_showDeleted, syncToken: arg_syncToken).then( unittest.expectAsync(((api.Channel response) {

1926 checkChannel(response);

1927 })));

1928 });

1929

1930 });

1931

1932

1933 unittest.group("resource-CalendarListResourceApi", () {

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

1935

1936 var mock = new common_test.HttpServerMock();

1937 api.CalendarListResourceApi res = new api.CalendarApi(mock).calendarList;

1938 var arg_calendarId = "foo";

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

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

1941 var pathOffset = 0;

1942 var index;

1943 var subPart;

1944 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

1945 pathOffset += 13;

1946 unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.eq uals("users/me/calendarList/"));

1947 pathOffset += 22;

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

1949 pathOffset = path.length;

1950 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

1951

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

1953 var queryOffset = 0;

1954 var queryMap = {};

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

1956 parseBool(n) {

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

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

1959 if (n == null) return null;

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

1961 }

1962 if (query.length > 0) {

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

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

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

1966 }

1967 }

1968

1969

1970 var h = {

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

1972 };

1973 var resp = "";

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

1975 }), true);

1976 res.delete(arg_calendarId).then(unittest.expectAsync((_) {}));

1977 });

1978

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

1980

1981 var mock = new common_test.HttpServerMock();

1982 api.CalendarListResourceApi res = new api.CalendarApi(mock).calendarList;

1983 var arg_calendarId = "foo";

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

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

1986 var pathOffset = 0;

1987 var index;

1988 var subPart;

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

1990 pathOffset += 13;

1991 unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.eq uals("users/me/calendarList/"));

1992 pathOffset += 22;

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

1994 pathOffset = path.length;

1995 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

1996

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

1998 var queryOffset = 0;

1999 var queryMap = {};

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

2001 parseBool(n) {

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

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

2004 if (n == null) return null;

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

2006 }

2007 if (query.length > 0) {

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

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

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

2011 }

2012 }

2013

2014

2015 var h = {

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

2017 };

2018 var resp = convert.JSON.encode(buildCalendarListEntry());

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

2020 }), true);

2021 res.get(arg_calendarId).then(unittest.expectAsync(((api.CalendarListEntry response) {

2022 checkCalendarListEntry(response);

2023 })));

2024 });

2025

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

2027

2028 var mock = new common_test.HttpServerMock();

2029 api.CalendarListResourceApi res = new api.CalendarApi(mock).calendarList;

2030 var arg_request = buildCalendarListEntry();

2031 var arg_colorRgbFormat = true;

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

2033 var obj = new api.CalendarListEntry.fromJson(json);

2034 checkCalendarListEntry(obj);

2035

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

2037 var pathOffset = 0;

2038 var index;

2039 var subPart;

2040 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2041 pathOffset += 13;

2042 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("users/me/calendarList"));

2043 pathOffset += 21;

2044

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

2046 var queryOffset = 0;

2047 var queryMap = {};

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

2049 parseBool(n) {

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

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

2052 if (n == null) return null;

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

2054 }

2055 if (query.length > 0) {

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

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

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

2059 }

2060 }

2061 unittest.expect(queryMap["colorRgbFormat"].first, unittest.equals("$arg_ colorRgbFormat"));

2062

2063

2064 var h = {

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

2066 };

2067 var resp = convert.JSON.encode(buildCalendarListEntry());

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

2069 }), true);

2070 res.insert(arg_request, colorRgbFormat: arg_colorRgbFormat).then(unittest. expectAsync(((api.CalendarListEntry response) {

2071 checkCalendarListEntry(response);

2072 })));

2073 });

2074

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

2076

2077 var mock = new common_test.HttpServerMock();

2078 api.CalendarListResourceApi res = new api.CalendarApi(mock).calendarList;

2079 var arg_maxResults = 42;

2080 var arg_minAccessRole = "foo";

2081 var arg_pageToken = "foo";

2082 var arg_showDeleted = true;

2083 var arg_showHidden = true;

2084 var arg_syncToken = "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 + 13), unittest.eq uals("/calendar/v3/"));

2091 pathOffset += 13;

2092 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("users/me/calendarList"));

2093 pathOffset += 21;

2094

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

2096 var queryOffset = 0;

2097 var queryMap = {};

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

2099 parseBool(n) {

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

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

2102 if (n == null) return null;

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

2104 }

2105 if (query.length > 0) {

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

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

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

2109 }

2110 }

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

2112 unittest.expect(queryMap["minAccessRole"].first, unittest.equals(arg_min AccessRole));

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

2114 unittest.expect(queryMap["showDeleted"].first, unittest.equals("$arg_sho wDeleted"));

2115 unittest.expect(queryMap["showHidden"].first, unittest.equals("$arg_show Hidden"));

2116 unittest.expect(queryMap["syncToken"].first, unittest.equals(arg_syncTok en));

2117

2118

2119 var h = {

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

2121 };

2122 var resp = convert.JSON.encode(buildCalendarList());

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

2124 }), true);

2125 res.list(maxResults: arg_maxResults, minAccessRole: arg_minAccessRole, pag eToken: arg_pageToken, showDeleted: arg_showDeleted, showHidden: arg_showHidden, syncToken: arg_syncToken).then(unittest.expectAsync(((api.CalendarList response ) {

2126 checkCalendarList(response);

2127 })));

2128 });

2129

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

2131

2132 var mock = new common_test.HttpServerMock();

2133 api.CalendarListResourceApi res = new api.CalendarApi(mock).calendarList;

2134 var arg_request = buildCalendarListEntry();

2135 var arg_calendarId = "foo";

2136 var arg_colorRgbFormat = true;

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

2138 var obj = new api.CalendarListEntry.fromJson(json);

2139 checkCalendarListEntry(obj);

2140

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

2142 var pathOffset = 0;

2143 var index;

2144 var subPart;

2145 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2146 pathOffset += 13;

2147 unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.eq uals("users/me/calendarList/"));

2148 pathOffset += 22;

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

2150 pathOffset = path.length;

2151 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

2152

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

2154 var queryOffset = 0;

2155 var queryMap = {};

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

2157 parseBool(n) {

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

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

2160 if (n == null) return null;

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

2162 }

2163 if (query.length > 0) {

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

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

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

2167 }

2168 }

2169 unittest.expect(queryMap["colorRgbFormat"].first, unittest.equals("$arg_ colorRgbFormat"));

2170

2171

2172 var h = {

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

2174 };

2175 var resp = convert.JSON.encode(buildCalendarListEntry());

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

2177 }), true);

2178 res.patch(arg_request, arg_calendarId, colorRgbFormat: arg_colorRgbFormat) .then(unittest.expectAsync(((api.CalendarListEntry response) {

2179 checkCalendarListEntry(response);

2180 })));

2181 });

2182

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

2184

2185 var mock = new common_test.HttpServerMock();

2186 api.CalendarListResourceApi res = new api.CalendarApi(mock).calendarList;

2187 var arg_request = buildCalendarListEntry();

2188 var arg_calendarId = "foo";

2189 var arg_colorRgbFormat = true;

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

2191 var obj = new api.CalendarListEntry.fromJson(json);

2192 checkCalendarListEntry(obj);

2193

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

2195 var pathOffset = 0;

2196 var index;

2197 var subPart;

2198 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2199 pathOffset += 13;

2200 unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.eq uals("users/me/calendarList/"));

2201 pathOffset += 22;

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

2203 pathOffset = path.length;

2204 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

2205

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

2207 var queryOffset = 0;

2208 var queryMap = {};

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

2210 parseBool(n) {

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

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

2213 if (n == null) return null;

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

2215 }

2216 if (query.length > 0) {

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

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

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

2220 }

2221 }

2222 unittest.expect(queryMap["colorRgbFormat"].first, unittest.equals("$arg_ colorRgbFormat"));

2223

2224

2225 var h = {

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

2227 };

2228 var resp = convert.JSON.encode(buildCalendarListEntry());

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

2230 }), true);

2231 res.update(arg_request, arg_calendarId, colorRgbFormat: arg_colorRgbFormat ).then(unittest.expectAsync(((api.CalendarListEntry response) {

2232 checkCalendarListEntry(response);

2233 })));

2234 });

2235

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

2237

2238 var mock = new common_test.HttpServerMock();

2239 api.CalendarListResourceApi res = new api.CalendarApi(mock).calendarList;

2240 var arg_request = buildChannel();

2241 var arg_maxResults = 42;

2242 var arg_minAccessRole = "foo";

2243 var arg_pageToken = "foo";

2244 var arg_showDeleted = true;

2245 var arg_showHidden = true;

2246 var arg_syncToken = "foo";

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

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

2249 checkChannel(obj);

2250

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

2252 var pathOffset = 0;

2253 var index;

2254 var subPart;

2255 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2256 pathOffset += 13;

2257 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("users/me/calendarList/watch"));

2258 pathOffset += 27;

2259

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

2261 var queryOffset = 0;

2262 var queryMap = {};

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

2264 parseBool(n) {

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

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

2267 if (n == null) return null;

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

2269 }

2270 if (query.length > 0) {

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

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

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

2274 }

2275 }

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

2277 unittest.expect(queryMap["minAccessRole"].first, unittest.equals(arg_min AccessRole));

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

2279 unittest.expect(queryMap["showDeleted"].first, unittest.equals("$arg_sho wDeleted"));

2280 unittest.expect(queryMap["showHidden"].first, unittest.equals("$arg_show Hidden"));

2281 unittest.expect(queryMap["syncToken"].first, unittest.equals(arg_syncTok en));

2282

2283

2284 var h = {

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

2286 };

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

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

2289 }), true);

2290 res.watch(arg_request, maxResults: arg_maxResults, minAccessRole: arg_minA ccessRole, pageToken: arg_pageToken, showDeleted: arg_showDeleted, showHidden: a rg_showHidden, syncToken: arg_syncToken).then(unittest.expectAsync(((api.Channel response) {

2291 checkChannel(response);

2292 })));

2293 });

2294

2295 });

2296

2297

2298 unittest.group("resource-CalendarsResourceApi", () {

2299 unittest.test("method--clear", () {

2300

2301 var mock = new common_test.HttpServerMock();

2302 api.CalendarsResourceApi res = new api.CalendarApi(mock).calendars;

2303 var arg_calendarId = "foo";

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

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

2306 var pathOffset = 0;

2307 var index;

2308 var subPart;

2309 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2310 pathOffset += 13;

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

2312 pathOffset += 10;

2313 index = path.indexOf("/clear", pathOffset);

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

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

2316 pathOffset = index;

2317 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

2319 pathOffset += 6;

2320

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

2322 var queryOffset = 0;

2323 var queryMap = {};

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

2325 parseBool(n) {

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

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

2328 if (n == null) return null;

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

2330 }

2331 if (query.length > 0) {

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

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

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

2335 }

2336 }

2337

2338

2339 var h = {

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

2341 };

2342 var resp = "";

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

2344 }), true);

2345 res.clear(arg_calendarId).then(unittest.expectAsync((_) {}));

2346 });

2347

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

2349

2350 var mock = new common_test.HttpServerMock();

2351 api.CalendarsResourceApi res = new api.CalendarApi(mock).calendars;

2352 var arg_calendarId = "foo";

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

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

2355 var pathOffset = 0;

2356 var index;

2357 var subPart;

2358 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2359 pathOffset += 13;

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

2361 pathOffset += 10;

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

2363 pathOffset = path.length;

2364 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

2365

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

2367 var queryOffset = 0;

2368 var queryMap = {};

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

2370 parseBool(n) {

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

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

2373 if (n == null) return null;

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

2375 }

2376 if (query.length > 0) {

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

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

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

2380 }

2381 }

2382

2383

2384 var h = {

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

2386 };

2387 var resp = "";

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

2389 }), true);

2390 res.delete(arg_calendarId).then(unittest.expectAsync((_) {}));

2391 });

2392

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

2394

2395 var mock = new common_test.HttpServerMock();

2396 api.CalendarsResourceApi res = new api.CalendarApi(mock).calendars;

2397 var arg_calendarId = "foo";

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

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

2400 var pathOffset = 0;

2401 var index;

2402 var subPart;

2403 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2404 pathOffset += 13;

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

2406 pathOffset += 10;

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

2408 pathOffset = path.length;

2409 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

2410

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

2412 var queryOffset = 0;

2413 var queryMap = {};

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

2415 parseBool(n) {

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

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

2418 if (n == null) return null;

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

2420 }

2421 if (query.length > 0) {

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

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

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

2425 }

2426 }

2427

2428

2429 var h = {

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

2431 };

2432 var resp = convert.JSON.encode(buildCalendar());

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

2434 }), true);

2435 res.get(arg_calendarId).then(unittest.expectAsync(((api.Calendar response) {

2436 checkCalendar(response);

2437 })));

2438 });

2439

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

2441

2442 var mock = new common_test.HttpServerMock();

2443 api.CalendarsResourceApi res = new api.CalendarApi(mock).calendars;

2444 var arg_request = buildCalendar();

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

2446 var obj = new api.Calendar.fromJson(json);

2447 checkCalendar(obj);

2448

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

2450 var pathOffset = 0;

2451 var index;

2452 var subPart;

2453 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2454 pathOffset += 13;

2455 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("calendars"));

2456 pathOffset += 9;

2457

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

2459 var queryOffset = 0;

2460 var queryMap = {};

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

2462 parseBool(n) {

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

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

2465 if (n == null) return null;

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

2467 }

2468 if (query.length > 0) {

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

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

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

2472 }

2473 }

2474

2475

2476 var h = {

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

2478 };

2479 var resp = convert.JSON.encode(buildCalendar());

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

2481 }), true);

2482 res.insert(arg_request).then(unittest.expectAsync(((api.Calendar response) {

2483 checkCalendar(response);

2484 })));

2485 });

2486

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

2488

2489 var mock = new common_test.HttpServerMock();

2490 api.CalendarsResourceApi res = new api.CalendarApi(mock).calendars;

2491 var arg_request = buildCalendar();

2492 var arg_calendarId = "foo";

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

2494 var obj = new api.Calendar.fromJson(json);

2495 checkCalendar(obj);

2496

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

2498 var pathOffset = 0;

2499 var index;

2500 var subPart;

2501 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2502 pathOffset += 13;

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

2504 pathOffset += 10;

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

2506 pathOffset = path.length;

2507 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

2508

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

2510 var queryOffset = 0;

2511 var queryMap = {};

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

2513 parseBool(n) {

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

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

2516 if (n == null) return null;

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

2518 }

2519 if (query.length > 0) {

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

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

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

2523 }

2524 }

2525

2526

2527 var h = {

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

2529 };

2530 var resp = convert.JSON.encode(buildCalendar());

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

2532 }), true);

2533 res.patch(arg_request, arg_calendarId).then(unittest.expectAsync(((api.Cal endar response) {

2534 checkCalendar(response);

2535 })));

2536 });

2537

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

2539

2540 var mock = new common_test.HttpServerMock();

2541 api.CalendarsResourceApi res = new api.CalendarApi(mock).calendars;

2542 var arg_request = buildCalendar();

2543 var arg_calendarId = "foo";

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

2545 var obj = new api.Calendar.fromJson(json);

2546 checkCalendar(obj);

2547

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

2549 var pathOffset = 0;

2550 var index;

2551 var subPart;

2552 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2553 pathOffset += 13;

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

2555 pathOffset += 10;

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

2557 pathOffset = path.length;

2558 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

2559

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

2561 var queryOffset = 0;

2562 var queryMap = {};

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

2564 parseBool(n) {

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

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

2567 if (n == null) return null;

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

2569 }

2570 if (query.length > 0) {

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

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

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

2574 }

2575 }

2576

2577

2578 var h = {

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

2580 };

2581 var resp = convert.JSON.encode(buildCalendar());

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

2583 }), true);

2584 res.update(arg_request, arg_calendarId).then(unittest.expectAsync(((api.Ca lendar response) {

2585 checkCalendar(response);

2586 })));

2587 });

2588

2589 });

2590

2591

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

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

2594

2595 var mock = new common_test.HttpServerMock();

2596 api.ChannelsResourceApi res = new api.CalendarApi(mock).channels;

2597 var arg_request = buildChannel();

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

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

2600 checkChannel(obj);

2601

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

2603 var pathOffset = 0;

2604 var index;

2605 var subPart;

2606 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2607 pathOffset += 13;

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

2609 pathOffset += 13;

2610

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

2612 var queryOffset = 0;

2613 var queryMap = {};

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

2615 parseBool(n) {

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

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

2618 if (n == null) return null;

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

2620 }

2621 if (query.length > 0) {

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

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

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

2625 }

2626 }

2627

2628

2629 var h = {

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

2631 };

2632 var resp = "";

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

2634 }), true);

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

2636 });

2637

2638 });

2639

2640

2641 unittest.group("resource-ColorsResourceApi", () {

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

2643

2644 var mock = new common_test.HttpServerMock();

2645 api.ColorsResourceApi res = new api.CalendarApi(mock).colors;

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

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

2648 var pathOffset = 0;

2649 var index;

2650 var subPart;

2651 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2652 pathOffset += 13;

2653 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("colors"));

2654 pathOffset += 6;

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

2673

2674 var h = {

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

2676 };

2677 var resp = convert.JSON.encode(buildColors());

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

2679 }), true);

2680 res.get().then(unittest.expectAsync(((api.Colors response) {

2681 checkColors(response);

2682 })));

2683 });

2684

2685 });

2686

2687

2688 unittest.group("resource-EventsResourceApi", () {

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

2690

2691 var mock = new common_test.HttpServerMock();

2692 api.EventsResourceApi res = new api.CalendarApi(mock).events;

2693 var arg_calendarId = "foo";

2694 var arg_eventId = "foo";

2695 var arg_sendNotifications = true;

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

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

2698 var pathOffset = 0;

2699 var index;

2700 var subPart;

2701 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2702 pathOffset += 13;

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

2704 pathOffset += 10;

2705 index = path.indexOf("/events/", pathOffset);

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

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

2708 pathOffset = index;

2709 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

2711 pathOffset += 8;

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

2713 pathOffset = path.length;

2714 unittest.expect(subPart, unittest.equals("$arg_eventId"));

2715

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

2717 var queryOffset = 0;

2718 var queryMap = {};

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

2720 parseBool(n) {

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

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

2723 if (n == null) return null;

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

2725 }

2726 if (query.length > 0) {

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

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

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

2730 }

2731 }

2732 unittest.expect(queryMap["sendNotifications"].first, unittest.equals("$a rg_sendNotifications"));

2733

2734

2735 var h = {

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

2737 };

2738 var resp = "";

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

2740 }), true);

2741 res.delete(arg_calendarId, arg_eventId, sendNotifications: arg_sendNotific ations).then(unittest.expectAsync((_) {}));

2742 });

2743

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

2745

2746 var mock = new common_test.HttpServerMock();

2747 api.EventsResourceApi res = new api.CalendarApi(mock).events;

2748 var arg_calendarId = "foo";

2749 var arg_eventId = "foo";

2750 var arg_alwaysIncludeEmail = true;

2751 var arg_maxAttendees = 42;

2752 var arg_timeZone = "foo";

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

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

2755 var pathOffset = 0;

2756 var index;

2757 var subPart;

2758 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2759 pathOffset += 13;

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

2761 pathOffset += 10;

2762 index = path.indexOf("/events/", pathOffset);

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

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

2765 pathOffset = index;

2766 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

2768 pathOffset += 8;

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

2770 pathOffset = path.length;

2771 unittest.expect(subPart, unittest.equals("$arg_eventId"));

2772

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

2774 var queryOffset = 0;

2775 var queryMap = {};

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

2777 parseBool(n) {

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

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

2780 if (n == null) return null;

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

2782 }

2783 if (query.length > 0) {

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

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

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

2787 }

2788 }

2789 unittest.expect(queryMap["alwaysIncludeEmail"].first, unittest.equals("$ arg_alwaysIncludeEmail"));

2790 unittest.expect(core.int.parse(queryMap["maxAttendees"].first), unittest .equals(arg_maxAttendees));

2791 unittest.expect(queryMap["timeZone"].first, unittest.equals(arg_timeZone ));

2792

2793

2794 var h = {

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

2796 };

2797 var resp = convert.JSON.encode(buildEvent());

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

2799 }), true);

2800 res.get(arg_calendarId, arg_eventId, alwaysIncludeEmail: arg_alwaysInclude Email, maxAttendees: arg_maxAttendees, timeZone: arg_timeZone).then(unittest.exp ectAsync(((api.Event response) {

2801 checkEvent(response);

2802 })));

2803 });

2804

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

2806

2807 var mock = new common_test.HttpServerMock();

2808 api.EventsResourceApi res = new api.CalendarApi(mock).events;

2809 var arg_request = buildEvent();

2810 var arg_calendarId = "foo";

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

2812 var obj = new api.Event.fromJson(json);

2813 checkEvent(obj);

2814

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

2816 var pathOffset = 0;

2817 var index;

2818 var subPart;

2819 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2820 pathOffset += 13;

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

2822 pathOffset += 10;

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

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

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

2826 pathOffset = index;

2827 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

2828 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/events/import"));

2829 pathOffset += 14;

2830

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

2832 var queryOffset = 0;

2833 var queryMap = {};

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

2835 parseBool(n) {

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

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

2838 if (n == null) return null;

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

2840 }

2841 if (query.length > 0) {

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

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

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

2845 }

2846 }

2847

2848

2849 var h = {

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

2851 };

2852 var resp = convert.JSON.encode(buildEvent());

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

2854 }), true);

2855 res.import(arg_request, arg_calendarId).then(unittest.expectAsync(((api.Ev ent response) {

2856 checkEvent(response);

2857 })));

2858 });

2859

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

2861

2862 var mock = new common_test.HttpServerMock();

2863 api.EventsResourceApi res = new api.CalendarApi(mock).events;

2864 var arg_request = buildEvent();

2865 var arg_calendarId = "foo";

2866 var arg_maxAttendees = 42;

2867 var arg_sendNotifications = true;

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

2869 var obj = new api.Event.fromJson(json);

2870 checkEvent(obj);

2871

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

2873 var pathOffset = 0;

2874 var index;

2875 var subPart;

2876 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2877 pathOffset += 13;

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

2879 pathOffset += 10;

2880 index = path.indexOf("/events", pathOffset);

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

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

2883 pathOffset = index;

2884 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

2886 pathOffset += 7;

2887

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

2889 var queryOffset = 0;

2890 var queryMap = {};

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

2892 parseBool(n) {

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

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

2895 if (n == null) return null;

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

2897 }

2898 if (query.length > 0) {

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

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

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

2902 }

2903 }

2904 unittest.expect(core.int.parse(queryMap["maxAttendees"].first), unittest .equals(arg_maxAttendees));

2905 unittest.expect(queryMap["sendNotifications"].first, unittest.equals("$a rg_sendNotifications"));

2906

2907

2908 var h = {

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

2910 };

2911 var resp = convert.JSON.encode(buildEvent());

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

2913 }), true);

2914 res.insert(arg_request, arg_calendarId, maxAttendees: arg_maxAttendees, se ndNotifications: arg_sendNotifications).then(unittest.expectAsync(((api.Event re sponse) {

2915 checkEvent(response);

2916 })));

2917 });

2918

2919 unittest.test("method--instances", () {

2920

2921 var mock = new common_test.HttpServerMock();

2922 api.EventsResourceApi res = new api.CalendarApi(mock).events;

2923 var arg_calendarId = "foo";

2924 var arg_eventId = "foo";

2925 var arg_alwaysIncludeEmail = true;

2926 var arg_maxAttendees = 42;

2927 var arg_maxResults = 42;

2928 var arg_originalStart = "foo";

2929 var arg_pageToken = "foo";

2930 var arg_showDeleted = true;

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

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

2933 var arg_timeZone = "foo";

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

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

2936 var pathOffset = 0;

2937 var index;

2938 var subPart;

2939 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

2940 pathOffset += 13;

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

2942 pathOffset += 10;

2943 index = path.indexOf("/events/", pathOffset);

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

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

2946 pathOffset = index;

2947 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

2949 pathOffset += 8;

2950 index = path.indexOf("/instances", pathOffset);

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

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

2953 pathOffset = index;

2954 unittest.expect(subPart, unittest.equals("$arg_eventId"));

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

2956 pathOffset += 10;

2957

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

2959 var queryOffset = 0;

2960 var queryMap = {};

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

2962 parseBool(n) {

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

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

2965 if (n == null) return null;

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

2967 }

2968 if (query.length > 0) {

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

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

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

2972 }

2973 }

2974 unittest.expect(queryMap["alwaysIncludeEmail"].first, unittest.equals("$ arg_alwaysIncludeEmail"));

2975 unittest.expect(core.int.parse(queryMap["maxAttendees"].first), unittest .equals(arg_maxAttendees));

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

2977 unittest.expect(queryMap["originalStart"].first, unittest.equals(arg_ori ginalStart));

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

2979 unittest.expect(queryMap["showDeleted"].first, unittest.equals("$arg_sho wDeleted"));

2980 unittest.expect(core.DateTime.parse(queryMap["timeMax"].first), unittest .equals(arg_timeMax));

2981 unittest.expect(core.DateTime.parse(queryMap["timeMin"].first), unittest .equals(arg_timeMin));

2982 unittest.expect(queryMap["timeZone"].first, unittest.equals(arg_timeZone ));

2983

2984

2985 var h = {

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

2987 };

2988 var resp = convert.JSON.encode(buildEvents());

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

2990 }), true);

2991 res.instances(arg_calendarId, arg_eventId, alwaysIncludeEmail: arg_alwaysI ncludeEmail, maxAttendees: arg_maxAttendees, maxResults: arg_maxResults, origina lStart: arg_originalStart, pageToken: arg_pageToken, showDeleted: arg_showDelete d, timeMax: arg_timeMax, timeMin: arg_timeMin, timeZone: arg_timeZone).then(unit test.expectAsync(((api.Events response) {

2992 checkEvents(response);

2993 })));

2994 });

2995

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

2997

2998 var mock = new common_test.HttpServerMock();

2999 api.EventsResourceApi res = new api.CalendarApi(mock).events;

3000 var arg_calendarId = "foo";

3001 var arg_alwaysIncludeEmail = true;

3002 var arg_iCalUID = "foo";

3003 var arg_maxAttendees = 42;

3004 var arg_maxResults = 42;

3005 var arg_orderBy = "foo";

3006 var arg_pageToken = "foo";

3007 var arg_privateExtendedProperty = buildUnnamed687();

3008 var arg_q = "foo";

3009 var arg_sharedExtendedProperty = buildUnnamed688();

3010 var arg_showDeleted = true;

3011 var arg_showHiddenInvitations = true;

3012 var arg_singleEvents = true;

3013 var arg_syncToken = "foo";

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

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

3016 var arg_timeZone = "foo";

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

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

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

3020 var pathOffset = 0;

3021 var index;

3022 var subPart;

3023 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3024 pathOffset += 13;

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

3026 pathOffset += 10;

3027 index = path.indexOf("/events", pathOffset);

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

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

3030 pathOffset = index;

3031 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

3033 pathOffset += 7;

3034

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

3036 var queryOffset = 0;

3037 var queryMap = {};

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

3039 parseBool(n) {

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

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

3042 if (n == null) return null;

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

3044 }

3045 if (query.length > 0) {

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

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

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

3049 }

3050 }

3051 unittest.expect(queryMap["alwaysIncludeEmail"].first, unittest.equals("$ arg_alwaysIncludeEmail"));

3052 unittest.expect(queryMap["iCalUID"].first, unittest.equals(arg_iCalUID)) ;

3053 unittest.expect(core.int.parse(queryMap["maxAttendees"].first), unittest .equals(arg_maxAttendees));

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

3055 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

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

3057 unittest.expect(queryMap["privateExtendedProperty"], unittest.equals(arg _privateExtendedProperty));

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

3059 unittest.expect(queryMap["sharedExtendedProperty"], unittest.equals(arg_ sharedExtendedProperty));

3060 unittest.expect(queryMap["showDeleted"].first, unittest.equals("$arg_sho wDeleted"));

3061 unittest.expect(queryMap["showHiddenInvitations"].first, unittest.equals ("$arg_showHiddenInvitations"));

3062 unittest.expect(queryMap["singleEvents"].first, unittest.equals("$arg_si ngleEvents"));

3063 unittest.expect(queryMap["syncToken"].first, unittest.equals(arg_syncTok en));

3064 unittest.expect(core.DateTime.parse(queryMap["timeMax"].first), unittest .equals(arg_timeMax));

3065 unittest.expect(core.DateTime.parse(queryMap["timeMin"].first), unittest .equals(arg_timeMin));

3066 unittest.expect(queryMap["timeZone"].first, unittest.equals(arg_timeZone ));

3067 unittest.expect(core.DateTime.parse(queryMap["updatedMin"].first), unitt est.equals(arg_updatedMin));

3068

3069

3070 var h = {

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

3072 };

3073 var resp = convert.JSON.encode(buildEvents());

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

3075 }), true);

3076 res.list(arg_calendarId, alwaysIncludeEmail: arg_alwaysIncludeEmail, iCalU ID: arg_iCalUID, maxAttendees: arg_maxAttendees, maxResults: arg_maxResults, ord erBy: arg_orderBy, pageToken: arg_pageToken, privateExtendedProperty: arg_privat eExtendedProperty, q: arg_q, sharedExtendedProperty: arg_sharedExtendedProperty, showDeleted: arg_showDeleted, showHiddenInvitations: arg_showHiddenInvitations, singleEvents: arg_singleEvents, syncToken: arg_syncToken, timeMax: arg_timeMax, timeMin: arg_timeMin, timeZone: arg_timeZone, updatedMin: arg_updatedMin).then( unittest.expectAsync(((api.Events response) {

3077 checkEvents(response);

3078 })));

3079 });

3080

3081 unittest.test("method--move", () {

3082

3083 var mock = new common_test.HttpServerMock();

3084 api.EventsResourceApi res = new api.CalendarApi(mock).events;

3085 var arg_calendarId = "foo";

3086 var arg_eventId = "foo";

3087 var arg_destination = "foo";

3088 var arg_sendNotifications = true;

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

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

3091 var pathOffset = 0;

3092 var index;

3093 var subPart;

3094 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3095 pathOffset += 13;

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

3097 pathOffset += 10;

3098 index = path.indexOf("/events/", pathOffset);

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

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

3101 pathOffset = index;

3102 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

3104 pathOffset += 8;

3105 index = path.indexOf("/move", pathOffset);

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

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

3108 pathOffset = index;

3109 unittest.expect(subPart, unittest.equals("$arg_eventId"));

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

3111 pathOffset += 5;

3112

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

3114 var queryOffset = 0;

3115 var queryMap = {};

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

3117 parseBool(n) {

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

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

3120 if (n == null) return null;

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

3122 }

3123 if (query.length > 0) {

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

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

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

3127 }

3128 }

3129 unittest.expect(queryMap["destination"].first, unittest.equals(arg_desti nation));

3130 unittest.expect(queryMap["sendNotifications"].first, unittest.equals("$a rg_sendNotifications"));

3131

3132

3133 var h = {

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

3135 };

3136 var resp = convert.JSON.encode(buildEvent());

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

3138 }), true);

3139 res.move(arg_calendarId, arg_eventId, arg_destination, sendNotifications: arg_sendNotifications).then(unittest.expectAsync(((api.Event response) {

3140 checkEvent(response);

3141 })));

3142 });

3143

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

3145

3146 var mock = new common_test.HttpServerMock();

3147 api.EventsResourceApi res = new api.CalendarApi(mock).events;

3148 var arg_request = buildEvent();

3149 var arg_calendarId = "foo";

3150 var arg_eventId = "foo";

3151 var arg_alwaysIncludeEmail = true;

3152 var arg_maxAttendees = 42;

3153 var arg_sendNotifications = true;

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

3155 var obj = new api.Event.fromJson(json);

3156 checkEvent(obj);

3157

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

3159 var pathOffset = 0;

3160 var index;

3161 var subPart;

3162 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3163 pathOffset += 13;

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

3165 pathOffset += 10;

3166 index = path.indexOf("/events/", pathOffset);

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

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

3169 pathOffset = index;

3170 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

3172 pathOffset += 8;

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

3174 pathOffset = path.length;

3175 unittest.expect(subPart, unittest.equals("$arg_eventId"));

3176

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

3178 var queryOffset = 0;

3179 var queryMap = {};

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

3181 parseBool(n) {

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

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

3184 if (n == null) return null;

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

3186 }

3187 if (query.length > 0) {

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

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

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

3191 }

3192 }

3193 unittest.expect(queryMap["alwaysIncludeEmail"].first, unittest.equals("$ arg_alwaysIncludeEmail"));

3194 unittest.expect(core.int.parse(queryMap["maxAttendees"].first), unittest .equals(arg_maxAttendees));

3195 unittest.expect(queryMap["sendNotifications"].first, unittest.equals("$a rg_sendNotifications"));

3196

3197

3198 var h = {

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

3200 };

3201 var resp = convert.JSON.encode(buildEvent());

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

3203 }), true);

3204 res.patch(arg_request, arg_calendarId, arg_eventId, alwaysIncludeEmail: ar g_alwaysIncludeEmail, maxAttendees: arg_maxAttendees, sendNotifications: arg_sen dNotifications).then(unittest.expectAsync(((api.Event response) {

3205 checkEvent(response);

3206 })));

3207 });

3208

3209 unittest.test("method--quickAdd", () {

3210

3211 var mock = new common_test.HttpServerMock();

3212 api.EventsResourceApi res = new api.CalendarApi(mock).events;

3213 var arg_calendarId = "foo";

3214 var arg_text = "foo";

3215 var arg_sendNotifications = true;

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

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

3218 var pathOffset = 0;

3219 var index;

3220 var subPart;

3221 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3222 pathOffset += 13;

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

3224 pathOffset += 10;

3225 index = path.indexOf("/events/quickAdd", pathOffset);

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

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

3228 pathOffset = index;

3229 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

3230 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/events/quickAdd"));

3231 pathOffset += 16;

3232

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

3234 var queryOffset = 0;

3235 var queryMap = {};

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

3237 parseBool(n) {

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

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

3240 if (n == null) return null;

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

3242 }

3243 if (query.length > 0) {

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

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

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

3247 }

3248 }

3249 unittest.expect(queryMap["text"].first, unittest.equals(arg_text));

3250 unittest.expect(queryMap["sendNotifications"].first, unittest.equals("$a rg_sendNotifications"));

3251

3252

3253 var h = {

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

3255 };

3256 var resp = convert.JSON.encode(buildEvent());

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

3258 }), true);

3259 res.quickAdd(arg_calendarId, arg_text, sendNotifications: arg_sendNotifica tions).then(unittest.expectAsync(((api.Event response) {

3260 checkEvent(response);

3261 })));

3262 });

3263

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

3265

3266 var mock = new common_test.HttpServerMock();

3267 api.EventsResourceApi res = new api.CalendarApi(mock).events;

3268 var arg_request = buildEvent();

3269 var arg_calendarId = "foo";

3270 var arg_eventId = "foo";

3271 var arg_alwaysIncludeEmail = true;

3272 var arg_maxAttendees = 42;

3273 var arg_sendNotifications = true;

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

3275 var obj = new api.Event.fromJson(json);

3276 checkEvent(obj);

3277

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

3279 var pathOffset = 0;

3280 var index;

3281 var subPart;

3282 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3283 pathOffset += 13;

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

3285 pathOffset += 10;

3286 index = path.indexOf("/events/", pathOffset);

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

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

3289 pathOffset = index;

3290 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

3292 pathOffset += 8;

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

3294 pathOffset = path.length;

3295 unittest.expect(subPart, unittest.equals("$arg_eventId"));

3296

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

3298 var queryOffset = 0;

3299 var queryMap = {};

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

3301 parseBool(n) {

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

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

3304 if (n == null) return null;

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

3306 }

3307 if (query.length > 0) {

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

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

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

3311 }

3312 }

3313 unittest.expect(queryMap["alwaysIncludeEmail"].first, unittest.equals("$ arg_alwaysIncludeEmail"));

3314 unittest.expect(core.int.parse(queryMap["maxAttendees"].first), unittest .equals(arg_maxAttendees));

3315 unittest.expect(queryMap["sendNotifications"].first, unittest.equals("$a rg_sendNotifications"));

3316

3317

3318 var h = {

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

3320 };

3321 var resp = convert.JSON.encode(buildEvent());

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

3323 }), true);

3324 res.update(arg_request, arg_calendarId, arg_eventId, alwaysIncludeEmail: a rg_alwaysIncludeEmail, maxAttendees: arg_maxAttendees, sendNotifications: arg_se ndNotifications).then(unittest.expectAsync(((api.Event response) {

3325 checkEvent(response);

3326 })));

3327 });

3328

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

3330

3331 var mock = new common_test.HttpServerMock();

3332 api.EventsResourceApi res = new api.CalendarApi(mock).events;

3333 var arg_request = buildChannel();

3334 var arg_calendarId = "foo";

3335 var arg_alwaysIncludeEmail = true;

3336 var arg_iCalUID = "foo";

3337 var arg_maxAttendees = 42;

3338 var arg_maxResults = 42;

3339 var arg_orderBy = "foo";

3340 var arg_pageToken = "foo";

3341 var arg_privateExtendedProperty = buildUnnamed689();

3342 var arg_q = "foo";

3343 var arg_sharedExtendedProperty = buildUnnamed690();

3344 var arg_showDeleted = true;

3345 var arg_showHiddenInvitations = true;

3346 var arg_singleEvents = true;

3347 var arg_syncToken = "foo";

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

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

3350 var arg_timeZone = "foo";

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

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

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

3354 checkChannel(obj);

3355

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

3357 var pathOffset = 0;

3358 var index;

3359 var subPart;

3360 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3361 pathOffset += 13;

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

3363 pathOffset += 10;

3364 index = path.indexOf("/events/watch", pathOffset);

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

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

3367 pathOffset = index;

3368 unittest.expect(subPart, unittest.equals("$arg_calendarId"));

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

3370 pathOffset += 13;

3371

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

3373 var queryOffset = 0;

3374 var queryMap = {};

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

3376 parseBool(n) {

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

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

3379 if (n == null) return null;

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

3381 }

3382 if (query.length > 0) {

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

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

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

3386 }

3387 }

3388 unittest.expect(queryMap["alwaysIncludeEmail"].first, unittest.equals("$ arg_alwaysIncludeEmail"));

3389 unittest.expect(queryMap["iCalUID"].first, unittest.equals(arg_iCalUID)) ;

3390 unittest.expect(core.int.parse(queryMap["maxAttendees"].first), unittest .equals(arg_maxAttendees));

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

3392 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

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

3394 unittest.expect(queryMap["privateExtendedProperty"], unittest.equals(arg _privateExtendedProperty));

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

3396 unittest.expect(queryMap["sharedExtendedProperty"], unittest.equals(arg_ sharedExtendedProperty));

3397 unittest.expect(queryMap["showDeleted"].first, unittest.equals("$arg_sho wDeleted"));

3398 unittest.expect(queryMap["showHiddenInvitations"].first, unittest.equals ("$arg_showHiddenInvitations"));

3399 unittest.expect(queryMap["singleEvents"].first, unittest.equals("$arg_si ngleEvents"));

3400 unittest.expect(queryMap["syncToken"].first, unittest.equals(arg_syncTok en));

3401 unittest.expect(core.DateTime.parse(queryMap["timeMax"].first), unittest .equals(arg_timeMax));

3402 unittest.expect(core.DateTime.parse(queryMap["timeMin"].first), unittest .equals(arg_timeMin));

3403 unittest.expect(queryMap["timeZone"].first, unittest.equals(arg_timeZone ));

3404 unittest.expect(core.DateTime.parse(queryMap["updatedMin"].first), unitt est.equals(arg_updatedMin));

3405

3406

3407 var h = {

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

3409 };

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

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

3412 }), true);

3413 res.watch(arg_request, arg_calendarId, alwaysIncludeEmail: arg_alwaysInclu deEmail, iCalUID: arg_iCalUID, maxAttendees: arg_maxAttendees, maxResults: arg_m axResults, orderBy: arg_orderBy, pageToken: arg_pageToken, privateExtendedProper ty: arg_privateExtendedProperty, q: arg_q, sharedExtendedProperty: arg_sharedExt endedProperty, showDeleted: arg_showDeleted, showHiddenInvitations: arg_showHidd enInvitations, singleEvents: arg_singleEvents, syncToken: arg_syncToken, timeMax : arg_timeMax, timeMin: arg_timeMin, timeZone: arg_timeZone, updatedMin: arg_upd atedMin).then(unittest.expectAsync(((api.Channel response) {

3414 checkChannel(response);

3415 })));

3416 });

3417

3418 });

3419

3420

3421 unittest.group("resource-FreebusyResourceApi", () {

3422 unittest.test("method--query", () {

3423

3424 var mock = new common_test.HttpServerMock();

3425 api.FreebusyResourceApi res = new api.CalendarApi(mock).freebusy;

3426 var arg_request = buildFreeBusyRequest();

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

3428 var obj = new api.FreeBusyRequest.fromJson(json);

3429 checkFreeBusyRequest(obj);

3430

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

3432 var pathOffset = 0;

3433 var index;

3434 var subPart;

3435 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3436 pathOffset += 13;

3437 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("freeBusy"));

3438 pathOffset += 8;

3439

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

3441 var queryOffset = 0;

3442 var queryMap = {};

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

3444 parseBool(n) {

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

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

3447 if (n == null) return null;

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

3449 }

3450 if (query.length > 0) {

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

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

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

3454 }

3455 }

3456

3457

3458 var h = {

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

3460 };

3461 var resp = convert.JSON.encode(buildFreeBusyResponse());

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

3463 }), true);

3464 res.query(arg_request).then(unittest.expectAsync(((api.FreeBusyResponse re sponse) {

3465 checkFreeBusyResponse(response);

3466 })));

3467 });

3468

3469 });

3470

3471

3472 unittest.group("resource-SettingsResourceApi", () {

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

3474

3475 var mock = new common_test.HttpServerMock();

3476 api.SettingsResourceApi res = new api.CalendarApi(mock).settings;

3477 var arg_setting = "foo";

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

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

3480 var pathOffset = 0;

3481 var index;

3482 var subPart;

3483 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3484 pathOffset += 13;

3485 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("users/me/settings/"));

3486 pathOffset += 18;

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

3488 pathOffset = path.length;

3489 unittest.expect(subPart, unittest.equals("$arg_setting"));

3490

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

3492 var queryOffset = 0;

3493 var queryMap = {};

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

3495 parseBool(n) {

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

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

3498 if (n == null) return null;

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

3500 }

3501 if (query.length > 0) {

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

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

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

3505 }

3506 }

3507

3508

3509 var h = {

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

3511 };

3512 var resp = convert.JSON.encode(buildSetting());

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

3514 }), true);

3515 res.get(arg_setting).then(unittest.expectAsync(((api.Setting response) {

3516 checkSetting(response);

3517 })));

3518 });

3519

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

3521

3522 var mock = new common_test.HttpServerMock();

3523 api.SettingsResourceApi res = new api.CalendarApi(mock).settings;

3524 var arg_maxResults = 42;

3525 var arg_pageToken = "foo";

3526 var arg_syncToken = "foo";

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

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

3529 var pathOffset = 0;

3530 var index;

3531 var subPart;

3532 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3533 pathOffset += 13;

3534 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("users/me/settings"));

3535 pathOffset += 17;

3536

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

3538 var queryOffset = 0;

3539 var queryMap = {};

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

3541 parseBool(n) {

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

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

3544 if (n == null) return null;

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

3546 }

3547 if (query.length > 0) {

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

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

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

3551 }

3552 }

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

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

3555 unittest.expect(queryMap["syncToken"].first, unittest.equals(arg_syncTok en));

3556

3557

3558 var h = {

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

3560 };

3561 var resp = convert.JSON.encode(buildSettings());

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

3563 }), true);

3564 res.list(maxResults: arg_maxResults, pageToken: arg_pageToken, syncToken: arg_syncToken).then(unittest.expectAsync(((api.Settings response) {

3565 checkSettings(response);

3566 })));

3567 });

3568

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

3570

3571 var mock = new common_test.HttpServerMock();

3572 api.SettingsResourceApi res = new api.CalendarApi(mock).settings;

3573 var arg_request = buildChannel();

3574 var arg_maxResults = 42;

3575 var arg_pageToken = "foo";

3576 var arg_syncToken = "foo";

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

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

3579 checkChannel(obj);

3580

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

3582 var pathOffset = 0;

3583 var index;

3584 var subPart;

3585 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/calendar/v3/"));

3586 pathOffset += 13;

3587 unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.eq uals("users/me/settings/watch"));

3588 pathOffset += 23;

3589

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

3591 var queryOffset = 0;

3592 var queryMap = {};

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

3594 parseBool(n) {

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

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

3597 if (n == null) return null;

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

3599 }

3600 if (query.length > 0) {

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

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

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

3604 }

3605 }

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

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

3608 unittest.expect(queryMap["syncToken"].first, unittest.equals(arg_syncTok en));

3609

3610

3611 var h = {

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

3613 };

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

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

3616 }), true);

3617 res.watch(arg_request, maxResults: arg_maxResults, pageToken: arg_pageToke n, syncToken: arg_syncToken).then(unittest.expectAsync(((api.Channel response) {

3618 checkChannel(response);

3619 })));

3620 });

3621

3622 });

3623

3624

3625 }

3626

OLD	NEW

« no previous file with comments | « generated/googleapis/test/books/v1_test.dart ('k') | generated/googleapis/test/calendar/v3_test.dart » ('j') | no next file with comments »