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

Side by Side Diff: generated/googleapis/test/admin/directory_v1.dart

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

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

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

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 library googleapis.admin.directory_v1.test;

2

3 import "dart:core" as core;

4 import "dart:collection" as collection;

5 import "dart:async" as async;

6 import "dart:convert" as convert;

7

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

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

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

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

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

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

14

15 import 'package:googleapis/admin/directory_v1.dart' as api;

16

17

18

19 core.int buildCounterAlias = 0;

20 buildAlias() {

21 var o = new api.Alias();

22 buildCounterAlias++;

23 if (buildCounterAlias < 3) {

24 o.alias = "foo";

25 o.etag = "foo";

26 o.id = "foo";

27 o.kind = "foo";

28 o.primaryEmail = "foo";

29 }

30 buildCounterAlias--;

31 return o;

32 }

33

34 checkAlias(api.Alias o) {

35 buildCounterAlias++;

36 if (buildCounterAlias < 3) {

37 unittest.expect(o.alias, unittest.equals('foo'));

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

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

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

41 unittest.expect(o.primaryEmail, unittest.equals('foo'));

42 }

43 buildCounterAlias--;

44 }

45

46 buildUnnamed456() {

47 var o = new core.List<api.Alias>();

48 o.add(buildAlias());

49 o.add(buildAlias());

50 return o;

51 }

52

53 checkUnnamed456(core.List<api.Alias> o) {

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

55 checkAlias(o[0]);

56 checkAlias(o[1]);

57 }

58

59 core.int buildCounterAliases = 0;

60 buildAliases() {

61 var o = new api.Aliases();

62 buildCounterAliases++;

63 if (buildCounterAliases < 3) {

64 o.aliases = buildUnnamed456();

65 o.etag = "foo";

66 o.kind = "foo";

67 }

68 buildCounterAliases--;

69 return o;

70 }

71

72 checkAliases(api.Aliases o) {

73 buildCounterAliases++;

74 if (buildCounterAliases < 3) {

75 checkUnnamed456(o.aliases);

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

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

78 }

79 buildCounterAliases--;

80 }

81

82 core.int buildCounterAsp = 0;

83 buildAsp() {

84 var o = new api.Asp();

85 buildCounterAsp++;

86 if (buildCounterAsp < 3) {

87 o.codeId = 42;

88 o.creationTime = "foo";

89 o.etag = "foo";

90 o.kind = "foo";

91 o.lastTimeUsed = "foo";

92 o.name = "foo";

93 o.userKey = "foo";

94 }

95 buildCounterAsp--;

96 return o;

97 }

98

99 checkAsp(api.Asp o) {

100 buildCounterAsp++;

101 if (buildCounterAsp < 3) {

102 unittest.expect(o.codeId, unittest.equals(42));

103 unittest.expect(o.creationTime, unittest.equals('foo'));

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

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

106 unittest.expect(o.lastTimeUsed, unittest.equals('foo'));

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

108 unittest.expect(o.userKey, unittest.equals('foo'));

109 }

110 buildCounterAsp--;

111 }

112

113 buildUnnamed457() {

114 var o = new core.List<api.Asp>();

115 o.add(buildAsp());

116 o.add(buildAsp());

117 return o;

118 }

119

120 checkUnnamed457(core.List<api.Asp> o) {

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

122 checkAsp(o[0]);

123 checkAsp(o[1]);

124 }

125

126 core.int buildCounterAsps = 0;

127 buildAsps() {

128 var o = new api.Asps();

129 buildCounterAsps++;

130 if (buildCounterAsps < 3) {

131 o.etag = "foo";

132 o.items = buildUnnamed457();

133 o.kind = "foo";

134 }

135 buildCounterAsps--;

136 return o;

137 }

138

139 checkAsps(api.Asps o) {

140 buildCounterAsps++;

141 if (buildCounterAsps < 3) {

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

143 checkUnnamed457(o.items);

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

145 }

146 buildCounterAsps--;

147 }

148

149 buildUnnamed458() {

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

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

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

153 return o;

154 }

155

156 checkUnnamed458(core.Map<core.String, core.String> o) {

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

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

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

160 }

161

162 core.int buildCounterChannel = 0;

163 buildChannel() {

164 var o = new api.Channel();

165 buildCounterChannel++;

166 if (buildCounterChannel < 3) {

167 o.address = "foo";

168 o.expiration = "foo";

169 o.id = "foo";

170 o.kind = "foo";

171 o.params = buildUnnamed458();

172 o.payload = true;

173 o.resourceId = "foo";

174 o.resourceUri = "foo";

175 o.token = "foo";

176 o.type = "foo";

177 }

178 buildCounterChannel--;

179 return o;

180 }

181

182 checkChannel(api.Channel o) {

183 buildCounterChannel++;

184 if (buildCounterChannel < 3) {

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

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

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

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

189 checkUnnamed458(o.params);

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

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

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

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

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

195 }

196 buildCounterChannel--;

197 }

198

199 core.int buildCounterChromeOsDeviceRecentUsers = 0;

200 buildChromeOsDeviceRecentUsers() {

201 var o = new api.ChromeOsDeviceRecentUsers();

202 buildCounterChromeOsDeviceRecentUsers++;

203 if (buildCounterChromeOsDeviceRecentUsers < 3) {

204 o.email = "foo";

205 o.type = "foo";

206 }

207 buildCounterChromeOsDeviceRecentUsers--;

208 return o;

209 }

210

211 checkChromeOsDeviceRecentUsers(api.ChromeOsDeviceRecentUsers o) {

212 buildCounterChromeOsDeviceRecentUsers++;

213 if (buildCounterChromeOsDeviceRecentUsers < 3) {

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

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

216 }

217 buildCounterChromeOsDeviceRecentUsers--;

218 }

219

220 buildUnnamed459() {

221 var o = new core.List<api.ChromeOsDeviceRecentUsers>();

222 o.add(buildChromeOsDeviceRecentUsers());

223 o.add(buildChromeOsDeviceRecentUsers());

224 return o;

225 }

226

227 checkUnnamed459(core.List<api.ChromeOsDeviceRecentUsers> o) {

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

229 checkChromeOsDeviceRecentUsers(o[0]);

230 checkChromeOsDeviceRecentUsers(o[1]);

231 }

232

233 core.int buildCounterChromeOsDevice = 0;

234 buildChromeOsDevice() {

235 var o = new api.ChromeOsDevice();

236 buildCounterChromeOsDevice++;

237 if (buildCounterChromeOsDevice < 3) {

238 o.annotatedLocation = "foo";

239 o.annotatedUser = "foo";

240 o.bootMode = "foo";

241 o.deviceId = "foo";

242 o.etag = "foo";

243 o.ethernetMacAddress = "foo";

244 o.firmwareVersion = "foo";

245 o.kind = "foo";

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

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

248 o.macAddress = "foo";

249 o.meid = "foo";

250 o.model = "foo";

251 o.notes = "foo";

252 o.orderNumber = "foo";

253 o.orgUnitPath = "foo";

254 o.osVersion = "foo";

255 o.platformVersion = "foo";

256 o.recentUsers = buildUnnamed459();

257 o.serialNumber = "foo";

258 o.status = "foo";

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

260 o.willAutoRenew = true;

261 }

262 buildCounterChromeOsDevice--;

263 return o;

264 }

265

266 checkChromeOsDevice(api.ChromeOsDevice o) {

267 buildCounterChromeOsDevice++;

268 if (buildCounterChromeOsDevice < 3) {

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

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

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

272 unittest.expect(o.deviceId, unittest.equals('foo'));

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

274 unittest.expect(o.ethernetMacAddress, unittest.equals('foo'));

275 unittest.expect(o.firmwareVersion, unittest.equals('foo'));

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

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

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

279 unittest.expect(o.macAddress, unittest.equals('foo'));

280 unittest.expect(o.meid, unittest.equals('foo'));

281 unittest.expect(o.model, unittest.equals('foo'));

282 unittest.expect(o.notes, unittest.equals('foo'));

283 unittest.expect(o.orderNumber, unittest.equals('foo'));

284 unittest.expect(o.orgUnitPath, unittest.equals('foo'));

285 unittest.expect(o.osVersion, unittest.equals('foo'));

286 unittest.expect(o.platformVersion, unittest.equals('foo'));

287 checkUnnamed459(o.recentUsers);

288 unittest.expect(o.serialNumber, unittest.equals('foo'));

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

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

291 unittest.expect(o.willAutoRenew, unittest.isTrue);

292 }

293 buildCounterChromeOsDevice--;

294 }

295

296 buildUnnamed460() {

297 var o = new core.List<api.ChromeOsDevice>();

298 o.add(buildChromeOsDevice());

299 o.add(buildChromeOsDevice());

300 return o;

301 }

302

303 checkUnnamed460(core.List<api.ChromeOsDevice> o) {

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

305 checkChromeOsDevice(o[0]);

306 checkChromeOsDevice(o[1]);

307 }

308

309 core.int buildCounterChromeOsDevices = 0;

310 buildChromeOsDevices() {

311 var o = new api.ChromeOsDevices();

312 buildCounterChromeOsDevices++;

313 if (buildCounterChromeOsDevices < 3) {

314 o.chromeosdevices = buildUnnamed460();

315 o.etag = "foo";

316 o.kind = "foo";

317 o.nextPageToken = "foo";

318 }

319 buildCounterChromeOsDevices--;

320 return o;

321 }

322

323 checkChromeOsDevices(api.ChromeOsDevices o) {

324 buildCounterChromeOsDevices++;

325 if (buildCounterChromeOsDevices < 3) {

326 checkUnnamed460(o.chromeosdevices);

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

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

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

330 }

331 buildCounterChromeOsDevices--;

332 }

333

334 buildUnnamed461() {

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

336 o.add("foo");

337 o.add("foo");

338 return o;

339 }

340

341 checkUnnamed461(core.List<core.String> o) {

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

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

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

345 }

346

347 buildUnnamed462() {

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

349 o.add("foo");

350 o.add("foo");

351 return o;

352 }

353

354 checkUnnamed462(core.List<core.String> o) {

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

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

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

358 }

359

360 core.int buildCounterGroup = 0;

361 buildGroup() {

362 var o = new api.Group();

363 buildCounterGroup++;

364 if (buildCounterGroup < 3) {

365 o.adminCreated = true;

366 o.aliases = buildUnnamed461();

367 o.description = "foo";

368 o.directMembersCount = "foo";

369 o.email = "foo";

370 o.etag = "foo";

371 o.id = "foo";

372 o.kind = "foo";

373 o.name = "foo";

374 o.nonEditableAliases = buildUnnamed462();

375 }

376 buildCounterGroup--;

377 return o;

378 }

379

380 checkGroup(api.Group o) {

381 buildCounterGroup++;

382 if (buildCounterGroup < 3) {

383 unittest.expect(o.adminCreated, unittest.isTrue);

384 checkUnnamed461(o.aliases);

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

386 unittest.expect(o.directMembersCount, unittest.equals('foo'));

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

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

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

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

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

392 checkUnnamed462(o.nonEditableAliases);

393 }

394 buildCounterGroup--;

395 }

396

397 buildUnnamed463() {

398 var o = new core.List<api.Group>();

399 o.add(buildGroup());

400 o.add(buildGroup());

401 return o;

402 }

403

404 checkUnnamed463(core.List<api.Group> o) {

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

406 checkGroup(o[0]);

407 checkGroup(o[1]);

408 }

409

410 core.int buildCounterGroups = 0;

411 buildGroups() {

412 var o = new api.Groups();

413 buildCounterGroups++;

414 if (buildCounterGroups < 3) {

415 o.etag = "foo";

416 o.groups = buildUnnamed463();

417 o.kind = "foo";

418 o.nextPageToken = "foo";

419 }

420 buildCounterGroups--;

421 return o;

422 }

423

424 checkGroups(api.Groups o) {

425 buildCounterGroups++;

426 if (buildCounterGroups < 3) {

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

428 checkUnnamed463(o.groups);

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

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

431 }

432 buildCounterGroups--;

433 }

434

435 core.int buildCounterMember = 0;

436 buildMember() {

437 var o = new api.Member();

438 buildCounterMember++;

439 if (buildCounterMember < 3) {

440 o.email = "foo";

441 o.etag = "foo";

442 o.id = "foo";

443 o.kind = "foo";

444 o.role = "foo";

445 o.type = "foo";

446 }

447 buildCounterMember--;

448 return o;

449 }

450

451 checkMember(api.Member o) {

452 buildCounterMember++;

453 if (buildCounterMember < 3) {

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

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

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

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

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

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

460 }

461 buildCounterMember--;

462 }

463

464 buildUnnamed464() {

465 var o = new core.List<api.Member>();

466 o.add(buildMember());

467 o.add(buildMember());

468 return o;

469 }

470

471 checkUnnamed464(core.List<api.Member> o) {

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

473 checkMember(o[0]);

474 checkMember(o[1]);

475 }

476

477 core.int buildCounterMembers = 0;

478 buildMembers() {

479 var o = new api.Members();

480 buildCounterMembers++;

481 if (buildCounterMembers < 3) {

482 o.etag = "foo";

483 o.kind = "foo";

484 o.members = buildUnnamed464();

485 o.nextPageToken = "foo";

486 }

487 buildCounterMembers--;

488 return o;

489 }

490

491 checkMembers(api.Members o) {

492 buildCounterMembers++;

493 if (buildCounterMembers < 3) {

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

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

496 checkUnnamed464(o.members);

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

498 }

499 buildCounterMembers--;

500 }

501

502 buildUnnamed465() {

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

504 o.add("foo");

505 o.add("foo");

506 return o;

507 }

508

509 checkUnnamed465(core.List<core.String> o) {

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

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

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

513 }

514

515 core.int buildCounterMobileDeviceApplications = 0;

516 buildMobileDeviceApplications() {

517 var o = new api.MobileDeviceApplications();

518 buildCounterMobileDeviceApplications++;

519 if (buildCounterMobileDeviceApplications < 3) {

520 o.displayName = "foo";

521 o.packageName = "foo";

522 o.permission = buildUnnamed465();

523 o.versionCode = 42;

524 o.versionName = "foo";

525 }

526 buildCounterMobileDeviceApplications--;

527 return o;

528 }

529

530 checkMobileDeviceApplications(api.MobileDeviceApplications o) {

531 buildCounterMobileDeviceApplications++;

532 if (buildCounterMobileDeviceApplications < 3) {

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

534 unittest.expect(o.packageName, unittest.equals('foo'));

535 checkUnnamed465(o.permission);

536 unittest.expect(o.versionCode, unittest.equals(42));

537 unittest.expect(o.versionName, unittest.equals('foo'));

538 }

539 buildCounterMobileDeviceApplications--;

540 }

541

542 buildUnnamed466() {

543 var o = new core.List<api.MobileDeviceApplications>();

544 o.add(buildMobileDeviceApplications());

545 o.add(buildMobileDeviceApplications());

546 return o;

547 }

548

549 checkUnnamed466(core.List<api.MobileDeviceApplications> o) {

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

551 checkMobileDeviceApplications(o[0]);

552 checkMobileDeviceApplications(o[1]);

553 }

554

555 buildUnnamed467() {

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

557 o.add("foo");

558 o.add("foo");

559 return o;

560 }

561

562 checkUnnamed467(core.List<core.String> o) {

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

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

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

566 }

567

568 buildUnnamed468() {

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

570 o.add("foo");

571 o.add("foo");

572 return o;

573 }

574

575 checkUnnamed468(core.List<core.String> o) {

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

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

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

579 }

580

581 core.int buildCounterMobileDevice = 0;

582 buildMobileDevice() {

583 var o = new api.MobileDevice();

584 buildCounterMobileDevice++;

585 if (buildCounterMobileDevice < 3) {

586 o.applications = buildUnnamed466();

587 o.basebandVersion = "foo";

588 o.buildNumber = "foo";

589 o.defaultLanguage = "foo";

590 o.deviceCompromisedStatus = "foo";

591 o.deviceId = "foo";

592 o.email = buildUnnamed467();

593 o.etag = "foo";

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

595 o.hardwareId = "foo";

596 o.imei = "foo";

597 o.kernelVersion = "foo";

598 o.kind = "foo";

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

600 o.managedAccountIsOnOwnerProfile = true;

601 o.meid = "foo";

602 o.model = "foo";

603 o.name = buildUnnamed468();

604 o.networkOperator = "foo";

605 o.os = "foo";

606 o.resourceId = "foo";

607 o.serialNumber = "foo";

608 o.status = "foo";

609 o.type = "foo";

610 o.userAgent = "foo";

611 o.wifiMacAddress = "foo";

612 }

613 buildCounterMobileDevice--;

614 return o;

615 }

616

617 checkMobileDevice(api.MobileDevice o) {

618 buildCounterMobileDevice++;

619 if (buildCounterMobileDevice < 3) {

620 checkUnnamed466(o.applications);

621 unittest.expect(o.basebandVersion, unittest.equals('foo'));

622 unittest.expect(o.buildNumber, unittest.equals('foo'));

623 unittest.expect(o.defaultLanguage, unittest.equals('foo'));

624 unittest.expect(o.deviceCompromisedStatus, unittest.equals('foo'));

625 unittest.expect(o.deviceId, unittest.equals('foo'));

626 checkUnnamed467(o.email);

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

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

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

630 unittest.expect(o.imei, unittest.equals('foo'));

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

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

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

634 unittest.expect(o.managedAccountIsOnOwnerProfile, unittest.isTrue);

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

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

637 checkUnnamed468(o.name);

638 unittest.expect(o.networkOperator, unittest.equals('foo'));

639 unittest.expect(o.os, unittest.equals('foo'));

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

641 unittest.expect(o.serialNumber, unittest.equals('foo'));

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

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

644 unittest.expect(o.userAgent, unittest.equals('foo'));

645 unittest.expect(o.wifiMacAddress, unittest.equals('foo'));

646 }

647 buildCounterMobileDevice--;

648 }

649

650 core.int buildCounterMobileDeviceAction = 0;

651 buildMobileDeviceAction() {

652 var o = new api.MobileDeviceAction();

653 buildCounterMobileDeviceAction++;

654 if (buildCounterMobileDeviceAction < 3) {

655 o.action = "foo";

656 }

657 buildCounterMobileDeviceAction--;

658 return o;

659 }

660

661 checkMobileDeviceAction(api.MobileDeviceAction o) {

662 buildCounterMobileDeviceAction++;

663 if (buildCounterMobileDeviceAction < 3) {

664 unittest.expect(o.action, unittest.equals('foo'));

665 }

666 buildCounterMobileDeviceAction--;

667 }

668

669 buildUnnamed469() {

670 var o = new core.List<api.MobileDevice>();

671 o.add(buildMobileDevice());

672 o.add(buildMobileDevice());

673 return o;

674 }

675

676 checkUnnamed469(core.List<api.MobileDevice> o) {

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

678 checkMobileDevice(o[0]);

679 checkMobileDevice(o[1]);

680 }

681

682 core.int buildCounterMobileDevices = 0;

683 buildMobileDevices() {

684 var o = new api.MobileDevices();

685 buildCounterMobileDevices++;

686 if (buildCounterMobileDevices < 3) {

687 o.etag = "foo";

688 o.kind = "foo";

689 o.mobiledevices = buildUnnamed469();

690 o.nextPageToken = "foo";

691 }

692 buildCounterMobileDevices--;

693 return o;

694 }

695

696 checkMobileDevices(api.MobileDevices o) {

697 buildCounterMobileDevices++;

698 if (buildCounterMobileDevices < 3) {

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

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

701 checkUnnamed469(o.mobiledevices);

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

703 }

704 buildCounterMobileDevices--;

705 }

706

707 core.int buildCounterNotification = 0;

708 buildNotification() {

709 var o = new api.Notification();

710 buildCounterNotification++;

711 if (buildCounterNotification < 3) {

712 o.body = "foo";

713 o.etag = "foo";

714 o.fromAddress = "foo";

715 o.isUnread = true;

716 o.kind = "foo";

717 o.notificationId = "foo";

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

719 o.subject = "foo";

720 }

721 buildCounterNotification--;

722 return o;

723 }

724

725 checkNotification(api.Notification o) {

726 buildCounterNotification++;

727 if (buildCounterNotification < 3) {

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

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

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

731 unittest.expect(o.isUnread, unittest.isTrue);

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

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

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

735 unittest.expect(o.subject, unittest.equals('foo'));

736 }

737 buildCounterNotification--;

738 }

739

740 buildUnnamed470() {

741 var o = new core.List<api.Notification>();

742 o.add(buildNotification());

743 o.add(buildNotification());

744 return o;

745 }

746

747 checkUnnamed470(core.List<api.Notification> o) {

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

749 checkNotification(o[0]);

750 checkNotification(o[1]);

751 }

752

753 core.int buildCounterNotifications = 0;

754 buildNotifications() {

755 var o = new api.Notifications();

756 buildCounterNotifications++;

757 if (buildCounterNotifications < 3) {

758 o.etag = "foo";

759 o.items = buildUnnamed470();

760 o.kind = "foo";

761 o.nextPageToken = "foo";

762 o.unreadNotificationsCount = 42;

763 }

764 buildCounterNotifications--;

765 return o;

766 }

767

768 checkNotifications(api.Notifications o) {

769 buildCounterNotifications++;

770 if (buildCounterNotifications < 3) {

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

772 checkUnnamed470(o.items);

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

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

775 unittest.expect(o.unreadNotificationsCount, unittest.equals(42));

776 }

777 buildCounterNotifications--;

778 }

779

780 core.int buildCounterOrgUnit = 0;

781 buildOrgUnit() {

782 var o = new api.OrgUnit();

783 buildCounterOrgUnit++;

784 if (buildCounterOrgUnit < 3) {

785 o.blockInheritance = true;

786 o.description = "foo";

787 o.etag = "foo";

788 o.kind = "foo";

789 o.name = "foo";

790 o.orgUnitPath = "foo";

791 o.parentOrgUnitPath = "foo";

792 }

793 buildCounterOrgUnit--;

794 return o;

795 }

796

797 checkOrgUnit(api.OrgUnit o) {

798 buildCounterOrgUnit++;

799 if (buildCounterOrgUnit < 3) {

800 unittest.expect(o.blockInheritance, unittest.isTrue);

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

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

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

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

805 unittest.expect(o.orgUnitPath, unittest.equals('foo'));

806 unittest.expect(o.parentOrgUnitPath, unittest.equals('foo'));

807 }

808 buildCounterOrgUnit--;

809 }

810

811 buildUnnamed471() {

812 var o = new core.List<api.OrgUnit>();

813 o.add(buildOrgUnit());

814 o.add(buildOrgUnit());

815 return o;

816 }

817

818 checkUnnamed471(core.List<api.OrgUnit> o) {

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

820 checkOrgUnit(o[0]);

821 checkOrgUnit(o[1]);

822 }

823

824 core.int buildCounterOrgUnits = 0;

825 buildOrgUnits() {

826 var o = new api.OrgUnits();

827 buildCounterOrgUnits++;

828 if (buildCounterOrgUnits < 3) {

829 o.etag = "foo";

830 o.kind = "foo";

831 o.organizationUnits = buildUnnamed471();

832 }

833 buildCounterOrgUnits--;

834 return o;

835 }

836

837 checkOrgUnits(api.OrgUnits o) {

838 buildCounterOrgUnits++;

839 if (buildCounterOrgUnits < 3) {

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

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

842 checkUnnamed471(o.organizationUnits);

843 }

844 buildCounterOrgUnits--;

845 }

846

847 buildUnnamed472() {

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

849 o.add("foo");

850 o.add("foo");

851 return o;

852 }

853

854 checkUnnamed472(core.List<core.String> o) {

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

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

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

858 }

859

860 core.int buildCounterToken = 0;

861 buildToken() {

862 var o = new api.Token();

863 buildCounterToken++;

864 if (buildCounterToken < 3) {

865 o.anonymous = true;

866 o.clientId = "foo";

867 o.displayText = "foo";

868 o.etag = "foo";

869 o.kind = "foo";

870 o.nativeApp = true;

871 o.scopes = buildUnnamed472();

872 o.userKey = "foo";

873 }

874 buildCounterToken--;

875 return o;

876 }

877

878 checkToken(api.Token o) {

879 buildCounterToken++;

880 if (buildCounterToken < 3) {

881 unittest.expect(o.anonymous, unittest.isTrue);

882 unittest.expect(o.clientId, unittest.equals('foo'));

883 unittest.expect(o.displayText, unittest.equals('foo'));

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

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

886 unittest.expect(o.nativeApp, unittest.isTrue);

887 checkUnnamed472(o.scopes);

888 unittest.expect(o.userKey, unittest.equals('foo'));

889 }

890 buildCounterToken--;

891 }

892

893 buildUnnamed473() {

894 var o = new core.List<api.Token>();

895 o.add(buildToken());

896 o.add(buildToken());

897 return o;

898 }

899

900 checkUnnamed473(core.List<api.Token> o) {

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

902 checkToken(o[0]);

903 checkToken(o[1]);

904 }

905

906 core.int buildCounterTokens = 0;

907 buildTokens() {

908 var o = new api.Tokens();

909 buildCounterTokens++;

910 if (buildCounterTokens < 3) {

911 o.etag = "foo";

912 o.items = buildUnnamed473();

913 o.kind = "foo";

914 }

915 buildCounterTokens--;

916 return o;

917 }

918

919 checkTokens(api.Tokens o) {

920 buildCounterTokens++;

921 if (buildCounterTokens < 3) {

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

923 checkUnnamed473(o.items);

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

925 }

926 buildCounterTokens--;

927 }

928

929 buildUnnamed474() {

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

931 o.add("foo");

932 o.add("foo");

933 return o;

934 }

935

936 checkUnnamed474(core.List<core.String> o) {

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

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

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

940 }

941

942 buildUnnamed475() {

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

944 o.add("foo");

945 o.add("foo");

946 return o;

947 }

948

949 checkUnnamed475(core.List<core.String> o) {

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

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

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

953 }

954

955 core.int buildCounterUser = 0;

956 buildUser() {

957 var o = new api.User();

958 buildCounterUser++;

959 if (buildCounterUser < 3) {

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

961 o.agreedToTerms = true;

962 o.aliases = buildUnnamed474();

963 o.changePasswordAtNextLogin = true;

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

965 o.customerId = "foo";

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

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

968 o.etag = "foo";

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

970 o.hashFunction = "foo";

971 o.id = "foo";

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

973 o.includeInGlobalAddressList = true;

974 o.ipWhitelisted = true;

975 o.isAdmin = true;

976 o.isDelegatedAdmin = true;

977 o.isMailboxSetup = true;

978 o.kind = "foo";

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

980 o.name = buildUserName();

981 o.nonEditableAliases = buildUnnamed475();

982 o.orgUnitPath = "foo";

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

984 o.password = "foo";

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

986 o.primaryEmail = "foo";

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

988 o.suspended = true;

989 o.suspensionReason = "foo";

990 o.thumbnailPhotoUrl = "foo";

991 }

992 buildCounterUser--;

993 return o;

994 }

995

996 checkUser(api.User o) {

997 buildCounterUser++;

998 if (buildCounterUser < 3) {

999 var casted1 = (o.addresses) as core.Map; unittest.expect(casted1, unittest.h asLength(3)); unittest.expect(casted1["list"], unittest.equals([1, 2, 3])); unit test.expect(casted1["bool"], unittest.equals(true)); unittest.expect(casted1["st ring"], unittest.equals('foo'));

1000 unittest.expect(o.agreedToTerms, unittest.isTrue);

1001 checkUnnamed474(o.aliases);

1002 unittest.expect(o.changePasswordAtNextLogin, unittest.isTrue);

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

1004 unittest.expect(o.customerId, unittest.equals('foo'));

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

1006 var casted2 = (o.emails) as core.Map; unittest.expect(casted2, unittest.hasL ength(3)); unittest.expect(casted2["list"], unittest.equals([1, 2, 3])); unittes t.expect(casted2["bool"], unittest.equals(true)); unittest.expect(casted2["strin g"], unittest.equals('foo'));

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

1008 var casted3 = (o.externalIds) as core.Map; unittest.expect(casted3, unittest .hasLength(3)); unittest.expect(casted3["list"], unittest.equals([1, 2, 3])); un ittest.expect(casted3["bool"], unittest.equals(true)); unittest.expect(casted3[" string"], unittest.equals('foo'));

1009 unittest.expect(o.hashFunction, unittest.equals('foo'));

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

1011 var casted4 = (o.ims) as core.Map; unittest.expect(casted4, unittest.hasLeng th(3)); unittest.expect(casted4["list"], unittest.equals([1, 2, 3])); unittest.e xpect(casted4["bool"], unittest.equals(true)); unittest.expect(casted4["string"] , unittest.equals('foo'));

1012 unittest.expect(o.includeInGlobalAddressList, unittest.isTrue);

1013 unittest.expect(o.ipWhitelisted, unittest.isTrue);

1014 unittest.expect(o.isAdmin, unittest.isTrue);

1015 unittest.expect(o.isDelegatedAdmin, unittest.isTrue);

1016 unittest.expect(o.isMailboxSetup, unittest.isTrue);

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

1018 unittest.expect(o.lastLoginTime, unittest.equals(core.DateTime.parse("2002-0 2-27T14:01:02")));

1019 checkUserName(o.name);

1020 checkUnnamed475(o.nonEditableAliases);

1021 unittest.expect(o.orgUnitPath, unittest.equals('foo'));

1022 var casted5 = (o.organizations) as core.Map; unittest.expect(casted5, unitte st.hasLength(3)); unittest.expect(casted5["list"], unittest.equals([1, 2, 3])); unittest.expect(casted5["bool"], unittest.equals(true)); unittest.expect(casted5 ["string"], unittest.equals('foo'));

1023 unittest.expect(o.password, unittest.equals('foo'));

1024 var casted6 = (o.phones) as core.Map; unittest.expect(casted6, unittest.hasL ength(3)); unittest.expect(casted6["list"], unittest.equals([1, 2, 3])); unittes t.expect(casted6["bool"], unittest.equals(true)); unittest.expect(casted6["strin g"], unittest.equals('foo'));

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

1026 var casted7 = (o.relations) as core.Map; unittest.expect(casted7, unittest.h asLength(3)); unittest.expect(casted7["list"], unittest.equals([1, 2, 3])); unit test.expect(casted7["bool"], unittest.equals(true)); unittest.expect(casted7["st ring"], unittest.equals('foo'));

1027 unittest.expect(o.suspended, unittest.isTrue);

1028 unittest.expect(o.suspensionReason, unittest.equals('foo'));

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

1030 }

1031 buildCounterUser--;

1032 }

1033

1034 core.int buildCounterUserAddress = 0;

1035 buildUserAddress() {

1036 var o = new api.UserAddress();

1037 buildCounterUserAddress++;

1038 if (buildCounterUserAddress < 3) {

1039 o.country = "foo";

1040 o.countryCode = "foo";

1041 o.customType = "foo";

1042 o.extendedAddress = "foo";

1043 o.formatted = "foo";

1044 o.locality = "foo";

1045 o.poBox = "foo";

1046 o.postalCode = "foo";

1047 o.primary = true;

1048 o.region = "foo";

1049 o.sourceIsStructured = true;

1050 o.streetAddress = "foo";

1051 o.type = "foo";

1052 }

1053 buildCounterUserAddress--;

1054 return o;

1055 }

1056

1057 checkUserAddress(api.UserAddress o) {

1058 buildCounterUserAddress++;

1059 if (buildCounterUserAddress < 3) {

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

1061 unittest.expect(o.countryCode, unittest.equals('foo'));

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

1063 unittest.expect(o.extendedAddress, unittest.equals('foo'));

1064 unittest.expect(o.formatted, unittest.equals('foo'));

1065 unittest.expect(o.locality, unittest.equals('foo'));

1066 unittest.expect(o.poBox, unittest.equals('foo'));

1067 unittest.expect(o.postalCode, unittest.equals('foo'));

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

1069 unittest.expect(o.region, unittest.equals('foo'));

1070 unittest.expect(o.sourceIsStructured, unittest.isTrue);

1071 unittest.expect(o.streetAddress, unittest.equals('foo'));

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

1073 }

1074 buildCounterUserAddress--;

1075 }

1076

1077 core.int buildCounterUserEmail = 0;

1078 buildUserEmail() {

1079 var o = new api.UserEmail();

1080 buildCounterUserEmail++;

1081 if (buildCounterUserEmail < 3) {

1082 o.address = "foo";

1083 o.customType = "foo";

1084 o.primary = true;

1085 o.type = "foo";

1086 }

1087 buildCounterUserEmail--;

1088 return o;

1089 }

1090

1091 checkUserEmail(api.UserEmail o) {

1092 buildCounterUserEmail++;

1093 if (buildCounterUserEmail < 3) {

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

1095 unittest.expect(o.customType, unittest.equals('foo'));

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

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

1098 }

1099 buildCounterUserEmail--;

1100 }

1101

1102 core.int buildCounterUserExternalId = 0;

1103 buildUserExternalId() {

1104 var o = new api.UserExternalId();

1105 buildCounterUserExternalId++;

1106 if (buildCounterUserExternalId < 3) {

1107 o.customType = "foo";

1108 o.type = "foo";

1109 o.value = "foo";

1110 }

1111 buildCounterUserExternalId--;

1112 return o;

1113 }

1114

1115 checkUserExternalId(api.UserExternalId o) {

1116 buildCounterUserExternalId++;

1117 if (buildCounterUserExternalId < 3) {

1118 unittest.expect(o.customType, unittest.equals('foo'));

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

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

1121 }

1122 buildCounterUserExternalId--;

1123 }

1124

1125 core.int buildCounterUserIm = 0;

1126 buildUserIm() {

1127 var o = new api.UserIm();

1128 buildCounterUserIm++;

1129 if (buildCounterUserIm < 3) {

1130 o.customProtocol = "foo";

1131 o.customType = "foo";

1132 o.im = "foo";

1133 o.primary = true;

1134 o.protocol = "foo";

1135 o.type = "foo";

1136 }

1137 buildCounterUserIm--;

1138 return o;

1139 }

1140

1141 checkUserIm(api.UserIm o) {

1142 buildCounterUserIm++;

1143 if (buildCounterUserIm < 3) {

1144 unittest.expect(o.customProtocol, unittest.equals('foo'));

1145 unittest.expect(o.customType, unittest.equals('foo'));

1146 unittest.expect(o.im, unittest.equals('foo'));

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

1148 unittest.expect(o.protocol, unittest.equals('foo'));

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

1150 }

1151 buildCounterUserIm--;

1152 }

1153

1154 core.int buildCounterUserMakeAdmin = 0;

1155 buildUserMakeAdmin() {

1156 var o = new api.UserMakeAdmin();

1157 buildCounterUserMakeAdmin++;

1158 if (buildCounterUserMakeAdmin < 3) {

1159 o.status = true;

1160 }

1161 buildCounterUserMakeAdmin--;

1162 return o;

1163 }

1164

1165 checkUserMakeAdmin(api.UserMakeAdmin o) {

1166 buildCounterUserMakeAdmin++;

1167 if (buildCounterUserMakeAdmin < 3) {

1168 unittest.expect(o.status, unittest.isTrue);

1169 }

1170 buildCounterUserMakeAdmin--;

1171 }

1172

1173 core.int buildCounterUserName = 0;

1174 buildUserName() {

1175 var o = new api.UserName();

1176 buildCounterUserName++;

1177 if (buildCounterUserName < 3) {

1178 o.familyName = "foo";

1179 o.fullName = "foo";

1180 o.givenName = "foo";

1181 }

1182 buildCounterUserName--;

1183 return o;

1184 }

1185

1186 checkUserName(api.UserName o) {

1187 buildCounterUserName++;

1188 if (buildCounterUserName < 3) {

1189 unittest.expect(o.familyName, unittest.equals('foo'));

1190 unittest.expect(o.fullName, unittest.equals('foo'));

1191 unittest.expect(o.givenName, unittest.equals('foo'));

1192 }

1193 buildCounterUserName--;

1194 }

1195

1196 core.int buildCounterUserOrganization = 0;

1197 buildUserOrganization() {

1198 var o = new api.UserOrganization();

1199 buildCounterUserOrganization++;

1200 if (buildCounterUserOrganization < 3) {

1201 o.costCenter = "foo";

1202 o.customType = "foo";

1203 o.department = "foo";

1204 o.description = "foo";

1205 o.domain = "foo";

1206 o.location = "foo";

1207 o.name = "foo";

1208 o.primary = true;

1209 o.symbol = "foo";

1210 o.title = "foo";

1211 o.type = "foo";

1212 }

1213 buildCounterUserOrganization--;

1214 return o;

1215 }

1216

1217 checkUserOrganization(api.UserOrganization o) {

1218 buildCounterUserOrganization++;

1219 if (buildCounterUserOrganization < 3) {

1220 unittest.expect(o.costCenter, unittest.equals('foo'));

1221 unittest.expect(o.customType, unittest.equals('foo'));

1222 unittest.expect(o.department, unittest.equals('foo'));

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

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

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

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

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

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

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

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

1231 }

1232 buildCounterUserOrganization--;

1233 }

1234

1235 core.int buildCounterUserPhone = 0;

1236 buildUserPhone() {

1237 var o = new api.UserPhone();

1238 buildCounterUserPhone++;

1239 if (buildCounterUserPhone < 3) {

1240 o.customType = "foo";

1241 o.primary = true;

1242 o.type = "foo";

1243 o.value = "foo";

1244 }

1245 buildCounterUserPhone--;

1246 return o;

1247 }

1248

1249 checkUserPhone(api.UserPhone o) {

1250 buildCounterUserPhone++;

1251 if (buildCounterUserPhone < 3) {

1252 unittest.expect(o.customType, unittest.equals('foo'));

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

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

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

1256 }

1257 buildCounterUserPhone--;

1258 }

1259

1260 core.int buildCounterUserPhoto = 0;

1261 buildUserPhoto() {

1262 var o = new api.UserPhoto();

1263 buildCounterUserPhoto++;

1264 if (buildCounterUserPhoto < 3) {

1265 o.etag = "foo";

1266 o.height = 42;

1267 o.id = "foo";

1268 o.kind = "foo";

1269 o.mimeType = "foo";

1270 o.photoData = "foo";

1271 o.primaryEmail = "foo";

1272 o.width = 42;

1273 }

1274 buildCounterUserPhoto--;

1275 return o;

1276 }

1277

1278 checkUserPhoto(api.UserPhoto o) {

1279 buildCounterUserPhoto++;

1280 if (buildCounterUserPhoto < 3) {

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

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

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

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

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

1286 unittest.expect(o.photoData, unittest.equals('foo'));

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

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

1289 }

1290 buildCounterUserPhoto--;

1291 }

1292

1293 core.int buildCounterUserRelation = 0;

1294 buildUserRelation() {

1295 var o = new api.UserRelation();

1296 buildCounterUserRelation++;

1297 if (buildCounterUserRelation < 3) {

1298 o.customType = "foo";

1299 o.type = "foo";

1300 o.value = "foo";

1301 }

1302 buildCounterUserRelation--;

1303 return o;

1304 }

1305

1306 checkUserRelation(api.UserRelation o) {

1307 buildCounterUserRelation++;

1308 if (buildCounterUserRelation < 3) {

1309 unittest.expect(o.customType, unittest.equals('foo'));

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

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

1312 }

1313 buildCounterUserRelation--;

1314 }

1315

1316 core.int buildCounterUserUndelete = 0;

1317 buildUserUndelete() {

1318 var o = new api.UserUndelete();

1319 buildCounterUserUndelete++;

1320 if (buildCounterUserUndelete < 3) {

1321 o.orgUnitPath = "foo";

1322 }

1323 buildCounterUserUndelete--;

1324 return o;

1325 }

1326

1327 checkUserUndelete(api.UserUndelete o) {

1328 buildCounterUserUndelete++;

1329 if (buildCounterUserUndelete < 3) {

1330 unittest.expect(o.orgUnitPath, unittest.equals('foo'));

1331 }

1332 buildCounterUserUndelete--;

1333 }

1334

1335 buildUnnamed476() {

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

1337 o.add(buildUser());

1338 o.add(buildUser());

1339 return o;

1340 }

1341

1342 checkUnnamed476(core.List<api.User> o) {

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

1344 checkUser(o[0]);

1345 checkUser(o[1]);

1346 }

1347

1348 core.int buildCounterUsers = 0;

1349 buildUsers() {

1350 var o = new api.Users();

1351 buildCounterUsers++;

1352 if (buildCounterUsers < 3) {

1353 o.etag = "foo";

1354 o.kind = "foo";

1355 o.nextPageToken = "foo";

1356 o.triggerEvent = "foo";

1357 o.users = buildUnnamed476();

1358 }

1359 buildCounterUsers--;

1360 return o;

1361 }

1362

1363 checkUsers(api.Users o) {

1364 buildCounterUsers++;

1365 if (buildCounterUsers < 3) {

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

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

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

1369 unittest.expect(o.triggerEvent, unittest.equals('foo'));

1370 checkUnnamed476(o.users);

1371 }

1372 buildCounterUsers--;

1373 }

1374

1375 core.int buildCounterVerificationCode = 0;

1376 buildVerificationCode() {

1377 var o = new api.VerificationCode();

1378 buildCounterVerificationCode++;

1379 if (buildCounterVerificationCode < 3) {

1380 o.etag = "foo";

1381 o.kind = "foo";

1382 o.userId = "foo";

1383 o.verificationCode = "foo";

1384 }

1385 buildCounterVerificationCode--;

1386 return o;

1387 }

1388

1389 checkVerificationCode(api.VerificationCode o) {

1390 buildCounterVerificationCode++;

1391 if (buildCounterVerificationCode < 3) {

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

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

1394 unittest.expect(o.userId, unittest.equals('foo'));

1395 unittest.expect(o.verificationCode, unittest.equals('foo'));

1396 }

1397 buildCounterVerificationCode--;

1398 }

1399

1400 buildUnnamed477() {

1401 var o = new core.List<api.VerificationCode>();

1402 o.add(buildVerificationCode());

1403 o.add(buildVerificationCode());

1404 return o;

1405 }

1406

1407 checkUnnamed477(core.List<api.VerificationCode> o) {

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

1409 checkVerificationCode(o[0]);

1410 checkVerificationCode(o[1]);

1411 }

1412

1413 core.int buildCounterVerificationCodes = 0;

1414 buildVerificationCodes() {

1415 var o = new api.VerificationCodes();

1416 buildCounterVerificationCodes++;

1417 if (buildCounterVerificationCodes < 3) {

1418 o.etag = "foo";

1419 o.items = buildUnnamed477();

1420 o.kind = "foo";

1421 }

1422 buildCounterVerificationCodes--;

1423 return o;

1424 }

1425

1426 checkVerificationCodes(api.VerificationCodes o) {

1427 buildCounterVerificationCodes++;

1428 if (buildCounterVerificationCodes < 3) {

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

1430 checkUnnamed477(o.items);

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

1432 }

1433 buildCounterVerificationCodes--;

1434 }

1435

1436 buildUnnamed478() {

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

1438 o.add("foo");

1439 o.add("foo");

1440 return o;

1441 }

1442

1443 checkUnnamed478(core.List<core.String> o) {

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

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

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

1447 }

1448

1449 buildUnnamed479() {

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

1451 o.add("foo");

1452 o.add("foo");

1453 return o;

1454 }

1455

1456 checkUnnamed479(core.List<core.String> o) {

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

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

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

1460 }

1461

1462 buildUnnamed480() {

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

1464 o.add("foo");

1465 o.add("foo");

1466 return o;

1467 }

1468

1469 checkUnnamed480(core.List<core.String> o) {

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

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

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

1473 }

1474

1475 buildUnnamed481() {

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

1477 o.add("foo");

1478 o.add("foo");

1479 return o;

1480 }

1481

1482 checkUnnamed481(core.List<core.String> o) {

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

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

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

1486 }

1487

1488

1489 main() {

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

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

1492 var o = buildAlias();

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

1494 checkAlias(od);

1495 });

1496 });

1497

1498

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

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

1501 var o = buildAliases();

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

1503 checkAliases(od);

1504 });

1505 });

1506

1507

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

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

1510 var o = buildAsp();

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

1512 checkAsp(od);

1513 });

1514 });

1515

1516

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

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

1519 var o = buildAsps();

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

1521 checkAsps(od);

1522 });

1523 });

1524

1525

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

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

1528 var o = buildChannel();

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

1530 checkChannel(od);

1531 });

1532 });

1533

1534

1535 unittest.group("obj-schema-ChromeOsDeviceRecentUsers", () {

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

1537 var o = buildChromeOsDeviceRecentUsers();

1538 var od = new api.ChromeOsDeviceRecentUsers.fromJson(o.toJson());

1539 checkChromeOsDeviceRecentUsers(od);

1540 });

1541 });

1542

1543

1544 unittest.group("obj-schema-ChromeOsDevice", () {

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

1546 var o = buildChromeOsDevice();

1547 var od = new api.ChromeOsDevice.fromJson(o.toJson());

1548 checkChromeOsDevice(od);

1549 });

1550 });

1551

1552

1553 unittest.group("obj-schema-ChromeOsDevices", () {

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

1555 var o = buildChromeOsDevices();

1556 var od = new api.ChromeOsDevices.fromJson(o.toJson());

1557 checkChromeOsDevices(od);

1558 });

1559 });

1560

1561

1562 unittest.group("obj-schema-Group", () {

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

1564 var o = buildGroup();

1565 var od = new api.Group.fromJson(o.toJson());

1566 checkGroup(od);

1567 });

1568 });

1569

1570

1571 unittest.group("obj-schema-Groups", () {

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

1573 var o = buildGroups();

1574 var od = new api.Groups.fromJson(o.toJson());

1575 checkGroups(od);

1576 });

1577 });

1578

1579

1580 unittest.group("obj-schema-Member", () {

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

1582 var o = buildMember();

1583 var od = new api.Member.fromJson(o.toJson());

1584 checkMember(od);

1585 });

1586 });

1587

1588

1589 unittest.group("obj-schema-Members", () {

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

1591 var o = buildMembers();

1592 var od = new api.Members.fromJson(o.toJson());

1593 checkMembers(od);

1594 });

1595 });

1596

1597

1598 unittest.group("obj-schema-MobileDeviceApplications", () {

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

1600 var o = buildMobileDeviceApplications();

1601 var od = new api.MobileDeviceApplications.fromJson(o.toJson());

1602 checkMobileDeviceApplications(od);

1603 });

1604 });

1605

1606

1607 unittest.group("obj-schema-MobileDevice", () {

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

1609 var o = buildMobileDevice();

1610 var od = new api.MobileDevice.fromJson(o.toJson());

1611 checkMobileDevice(od);

1612 });

1613 });

1614

1615

1616 unittest.group("obj-schema-MobileDeviceAction", () {

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

1618 var o = buildMobileDeviceAction();

1619 var od = new api.MobileDeviceAction.fromJson(o.toJson());

1620 checkMobileDeviceAction(od);

1621 });

1622 });

1623

1624

1625 unittest.group("obj-schema-MobileDevices", () {

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

1627 var o = buildMobileDevices();

1628 var od = new api.MobileDevices.fromJson(o.toJson());

1629 checkMobileDevices(od);

1630 });

1631 });

1632

1633

1634 unittest.group("obj-schema-Notification", () {

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

1636 var o = buildNotification();

1637 var od = new api.Notification.fromJson(o.toJson());

1638 checkNotification(od);

1639 });

1640 });

1641

1642

1643 unittest.group("obj-schema-Notifications", () {

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

1645 var o = buildNotifications();

1646 var od = new api.Notifications.fromJson(o.toJson());

1647 checkNotifications(od);

1648 });

1649 });

1650

1651

1652 unittest.group("obj-schema-OrgUnit", () {

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

1654 var o = buildOrgUnit();

1655 var od = new api.OrgUnit.fromJson(o.toJson());

1656 checkOrgUnit(od);

1657 });

1658 });

1659

1660

1661 unittest.group("obj-schema-OrgUnits", () {

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

1663 var o = buildOrgUnits();

1664 var od = new api.OrgUnits.fromJson(o.toJson());

1665 checkOrgUnits(od);

1666 });

1667 });

1668

1669

1670 unittest.group("obj-schema-Token", () {

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

1672 var o = buildToken();

1673 var od = new api.Token.fromJson(o.toJson());

1674 checkToken(od);

1675 });

1676 });

1677

1678

1679 unittest.group("obj-schema-Tokens", () {

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

1681 var o = buildTokens();

1682 var od = new api.Tokens.fromJson(o.toJson());

1683 checkTokens(od);

1684 });

1685 });

1686

1687

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

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

1690 var o = buildUser();

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

1692 checkUser(od);

1693 });

1694 });

1695

1696

1697 unittest.group("obj-schema-UserAddress", () {

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

1699 var o = buildUserAddress();

1700 var od = new api.UserAddress.fromJson(o.toJson());

1701 checkUserAddress(od);

1702 });

1703 });

1704

1705

1706 unittest.group("obj-schema-UserEmail", () {

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

1708 var o = buildUserEmail();

1709 var od = new api.UserEmail.fromJson(o.toJson());

1710 checkUserEmail(od);

1711 });

1712 });

1713

1714

1715 unittest.group("obj-schema-UserExternalId", () {

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

1717 var o = buildUserExternalId();

1718 var od = new api.UserExternalId.fromJson(o.toJson());

1719 checkUserExternalId(od);

1720 });

1721 });

1722

1723

1724 unittest.group("obj-schema-UserIm", () {

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

1726 var o = buildUserIm();

1727 var od = new api.UserIm.fromJson(o.toJson());

1728 checkUserIm(od);

1729 });

1730 });

1731

1732

1733 unittest.group("obj-schema-UserMakeAdmin", () {

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

1735 var o = buildUserMakeAdmin();

1736 var od = new api.UserMakeAdmin.fromJson(o.toJson());

1737 checkUserMakeAdmin(od);

1738 });

1739 });

1740

1741

1742 unittest.group("obj-schema-UserName", () {

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

1744 var o = buildUserName();

1745 var od = new api.UserName.fromJson(o.toJson());

1746 checkUserName(od);

1747 });

1748 });

1749

1750

1751 unittest.group("obj-schema-UserOrganization", () {

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

1753 var o = buildUserOrganization();

1754 var od = new api.UserOrganization.fromJson(o.toJson());

1755 checkUserOrganization(od);

1756 });

1757 });

1758

1759

1760 unittest.group("obj-schema-UserPhone", () {

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

1762 var o = buildUserPhone();

1763 var od = new api.UserPhone.fromJson(o.toJson());

1764 checkUserPhone(od);

1765 });

1766 });

1767

1768

1769 unittest.group("obj-schema-UserPhoto", () {

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

1771 var o = buildUserPhoto();

1772 var od = new api.UserPhoto.fromJson(o.toJson());

1773 checkUserPhoto(od);

1774 });

1775 });

1776

1777

1778 unittest.group("obj-schema-UserRelation", () {

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

1780 var o = buildUserRelation();

1781 var od = new api.UserRelation.fromJson(o.toJson());

1782 checkUserRelation(od);

1783 });

1784 });

1785

1786

1787 unittest.group("obj-schema-UserUndelete", () {

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

1789 var o = buildUserUndelete();

1790 var od = new api.UserUndelete.fromJson(o.toJson());

1791 checkUserUndelete(od);

1792 });

1793 });

1794

1795

1796 unittest.group("obj-schema-Users", () {

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

1798 var o = buildUsers();

1799 var od = new api.Users.fromJson(o.toJson());

1800 checkUsers(od);

1801 });

1802 });

1803

1804

1805 unittest.group("obj-schema-VerificationCode", () {

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

1807 var o = buildVerificationCode();

1808 var od = new api.VerificationCode.fromJson(o.toJson());

1809 checkVerificationCode(od);

1810 });

1811 });

1812

1813

1814 unittest.group("obj-schema-VerificationCodes", () {

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

1816 var o = buildVerificationCodes();

1817 var od = new api.VerificationCodes.fromJson(o.toJson());

1818 checkVerificationCodes(od);

1819 });

1820 });

1821

1822

1823 unittest.group("resource-AspsResourceApi", () {

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

1825

1826 var mock = new common_test.HttpServerMock();

1827 api.AspsResourceApi res = new api.AdminApi(mock).asps;

1828 var arg_userKey = "foo";

1829 var arg_codeId = 42;

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

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

1832 var pathOffset = 0;

1833 var index;

1834 var subPart;

1835 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

1836 pathOffset += 20;

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

1838 pathOffset += 6;

1839 index = path.indexOf("/asps/", pathOffset);

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

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

1842 pathOffset = index;

1843 unittest.expect(subPart, unittest.equals("$arg_userKey"));

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

1845 pathOffset += 6;

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

1847 pathOffset = path.length;

1848 unittest.expect(subPart, unittest.equals("$arg_codeId"));

1849

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

1851 var queryOffset = 0;

1852 var queryMap = {};

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

1854 parseBool(n) {

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

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

1857 if (n == null) return null;

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

1859 }

1860 if (query.length > 0) {

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

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

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

1864 }

1865 }

1866

1867

1868 var h = {

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

1870 };

1871 var resp = "";

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

1873 }), true);

1874 res.delete(arg_userKey, arg_codeId).then(unittest.expectAsync((_) {}));

1875 });

1876

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

1878

1879 var mock = new common_test.HttpServerMock();

1880 api.AspsResourceApi res = new api.AdminApi(mock).asps;

1881 var arg_userKey = "foo";

1882 var arg_codeId = 42;

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

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

1885 var pathOffset = 0;

1886 var index;

1887 var subPart;

1888 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

1889 pathOffset += 20;

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

1891 pathOffset += 6;

1892 index = path.indexOf("/asps/", pathOffset);

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

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

1895 pathOffset = index;

1896 unittest.expect(subPart, unittest.equals("$arg_userKey"));

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

1898 pathOffset += 6;

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

1900 pathOffset = path.length;

1901 unittest.expect(subPart, unittest.equals("$arg_codeId"));

1902

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

1904 var queryOffset = 0;

1905 var queryMap = {};

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

1907 parseBool(n) {

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

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

1910 if (n == null) return null;

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

1912 }

1913 if (query.length > 0) {

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

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

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

1917 }

1918 }

1919

1920

1921 var h = {

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

1923 };

1924 var resp = convert.JSON.encode(buildAsp());

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

1926 }), true);

1927 res.get(arg_userKey, arg_codeId).then(unittest.expectAsync(((api.Asp respo nse) {

1928 checkAsp(response);

1929 })));

1930 });

1931

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

1933

1934 var mock = new common_test.HttpServerMock();

1935 api.AspsResourceApi res = new api.AdminApi(mock).asps;

1936 var arg_userKey = "foo";

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

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

1939 var pathOffset = 0;

1940 var index;

1941 var subPart;

1942 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

1943 pathOffset += 20;

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

1945 pathOffset += 6;

1946 index = path.indexOf("/asps", pathOffset);

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

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

1949 pathOffset = index;

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

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

1952 pathOffset += 5;

1953

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

1955 var queryOffset = 0;

1956 var queryMap = {};

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

1958 parseBool(n) {

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

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

1961 if (n == null) return null;

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

1963 }

1964 if (query.length > 0) {

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

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

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

1968 }

1969 }

1970

1971

1972 var h = {

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

1974 };

1975 var resp = convert.JSON.encode(buildAsps());

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

1977 }), true);

1978 res.list(arg_userKey).then(unittest.expectAsync(((api.Asps response) {

1979 checkAsps(response);

1980 })));

1981 });

1982

1983 });

1984

1985

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

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

1988

1989 var mock = new common_test.HttpServerMock();

1990 api.ChannelsResourceApi res = new api.AdminApi(mock).channels;

1991 var arg_request = buildChannel();

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

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

1994 checkChannel(obj);

1995

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

1997 var pathOffset = 0;

1998 var index;

1999 var subPart;

2000 unittest.expect(path.substring(pathOffset, pathOffset + 33), unittest.eq uals("/admin/directory_v1/channels/stop"));

2001 pathOffset += 33;

2002

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

2004 var queryOffset = 0;

2005 var queryMap = {};

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

2007 parseBool(n) {

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

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

2010 if (n == null) return null;

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

2012 }

2013 if (query.length > 0) {

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

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

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

2017 }

2018 }

2019

2020

2021 var h = {

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

2023 };

2024 var resp = "";

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

2026 }), true);

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

2028 });

2029

2030 });

2031

2032

2033 unittest.group("resource-ChromeosdevicesResourceApi", () {

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

2035

2036 var mock = new common_test.HttpServerMock();

2037 api.ChromeosdevicesResourceApi res = new api.AdminApi(mock).chromeosdevice s;

2038 var arg_customerId = "foo";

2039 var arg_deviceId = "foo";

2040 var arg_projection = "foo";

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

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

2043 var pathOffset = 0;

2044 var index;

2045 var subPart;

2046 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2047 pathOffset += 20;

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

2049 pathOffset += 9;

2050 index = path.indexOf("/devices/chromeos/", pathOffset);

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

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

2053 pathOffset = index;

2054 unittest.expect(subPart, unittest.equals("$arg_customerId"));

2055 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/devices/chromeos/"));

2056 pathOffset += 18;

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

2058 pathOffset = path.length;

2059 unittest.expect(subPart, unittest.equals("$arg_deviceId"));

2060

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

2062 var queryOffset = 0;

2063 var queryMap = {};

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

2065 parseBool(n) {

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

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

2068 if (n == null) return null;

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

2070 }

2071 if (query.length > 0) {

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

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

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

2075 }

2076 }

2077 unittest.expect(queryMap["projection"].first, unittest.equals(arg_projec tion));

2078

2079

2080 var h = {

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

2082 };

2083 var resp = convert.JSON.encode(buildChromeOsDevice());

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

2085 }), true);

2086 res.get(arg_customerId, arg_deviceId, projection: arg_projection).then(uni ttest.expectAsync(((api.ChromeOsDevice response) {

2087 checkChromeOsDevice(response);

2088 })));

2089 });

2090

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

2092

2093 var mock = new common_test.HttpServerMock();

2094 api.ChromeosdevicesResourceApi res = new api.AdminApi(mock).chromeosdevice s;

2095 var arg_customerId = "foo";

2096 var arg_maxResults = 42;

2097 var arg_orderBy = "foo";

2098 var arg_pageToken = "foo";

2099 var arg_projection = "foo";

2100 var arg_query = "foo";

2101 var arg_sortOrder = "foo";

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

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

2104 var pathOffset = 0;

2105 var index;

2106 var subPart;

2107 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2108 pathOffset += 20;

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

2110 pathOffset += 9;

2111 index = path.indexOf("/devices/chromeos", pathOffset);

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

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

2114 pathOffset = index;

2115 unittest.expect(subPart, unittest.equals("$arg_customerId"));

2116 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/devices/chromeos"));

2117 pathOffset += 17;

2118

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

2120 var queryOffset = 0;

2121 var queryMap = {};

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

2123 parseBool(n) {

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

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

2126 if (n == null) return null;

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

2128 }

2129 if (query.length > 0) {

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

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

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

2133 }

2134 }

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

2136 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

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

2138 unittest.expect(queryMap["projection"].first, unittest.equals(arg_projec tion));

2139 unittest.expect(queryMap["query"].first, unittest.equals(arg_query));

2140 unittest.expect(queryMap["sortOrder"].first, unittest.equals(arg_sortOrd er));

2141

2142

2143 var h = {

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

2145 };

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

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

2148 }), true);

2149 res.list(arg_customerId, maxResults: arg_maxResults, orderBy: arg_orderBy, pageToken: arg_pageToken, projection: arg_projection, query: arg_query, sortOrd er: arg_sortOrder).then(unittest.expectAsync(((api.ChromeOsDevices response) {

2150 checkChromeOsDevices(response);

2151 })));

2152 });

2153

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

2155

2156 var mock = new common_test.HttpServerMock();

2157 api.ChromeosdevicesResourceApi res = new api.AdminApi(mock).chromeosdevice s;

2158 var arg_request = buildChromeOsDevice();

2159 var arg_customerId = "foo";

2160 var arg_deviceId = "foo";

2161 var arg_projection = "foo";

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

2163 var obj = new api.ChromeOsDevice.fromJson(json);

2164 checkChromeOsDevice(obj);

2165

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

2167 var pathOffset = 0;

2168 var index;

2169 var subPart;

2170 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2171 pathOffset += 20;

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

2173 pathOffset += 9;

2174 index = path.indexOf("/devices/chromeos/", pathOffset);

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

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

2177 pathOffset = index;

2178 unittest.expect(subPart, unittest.equals("$arg_customerId"));

2179 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/devices/chromeos/"));

2180 pathOffset += 18;

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

2182 pathOffset = path.length;

2183 unittest.expect(subPart, unittest.equals("$arg_deviceId"));

2184

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

2186 var queryOffset = 0;

2187 var queryMap = {};

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

2189 parseBool(n) {

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

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

2192 if (n == null) return null;

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

2194 }

2195 if (query.length > 0) {

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

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

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

2199 }

2200 }

2201 unittest.expect(queryMap["projection"].first, unittest.equals(arg_projec tion));

2202

2203

2204 var h = {

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

2206 };

2207 var resp = convert.JSON.encode(buildChromeOsDevice());

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

2209 }), true);

2210 res.patch(arg_request, arg_customerId, arg_deviceId, projection: arg_proje ction).then(unittest.expectAsync(((api.ChromeOsDevice response) {

2211 checkChromeOsDevice(response);

2212 })));

2213 });

2214

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

2216

2217 var mock = new common_test.HttpServerMock();

2218 api.ChromeosdevicesResourceApi res = new api.AdminApi(mock).chromeosdevice s;

2219 var arg_request = buildChromeOsDevice();

2220 var arg_customerId = "foo";

2221 var arg_deviceId = "foo";

2222 var arg_projection = "foo";

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

2224 var obj = new api.ChromeOsDevice.fromJson(json);

2225 checkChromeOsDevice(obj);

2226

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

2228 var pathOffset = 0;

2229 var index;

2230 var subPart;

2231 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2232 pathOffset += 20;

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

2234 pathOffset += 9;

2235 index = path.indexOf("/devices/chromeos/", pathOffset);

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

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

2238 pathOffset = index;

2239 unittest.expect(subPart, unittest.equals("$arg_customerId"));

2240 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/devices/chromeos/"));

2241 pathOffset += 18;

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

2243 pathOffset = path.length;

2244 unittest.expect(subPart, unittest.equals("$arg_deviceId"));

2245

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

2247 var queryOffset = 0;

2248 var queryMap = {};

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

2250 parseBool(n) {

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

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

2253 if (n == null) return null;

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

2255 }

2256 if (query.length > 0) {

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

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

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

2260 }

2261 }

2262 unittest.expect(queryMap["projection"].first, unittest.equals(arg_projec tion));

2263

2264

2265 var h = {

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

2267 };

2268 var resp = convert.JSON.encode(buildChromeOsDevice());

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

2270 }), true);

2271 res.update(arg_request, arg_customerId, arg_deviceId, projection: arg_proj ection).then(unittest.expectAsync(((api.ChromeOsDevice response) {

2272 checkChromeOsDevice(response);

2273 })));

2274 });

2275

2276 });

2277

2278

2279 unittest.group("resource-GroupsResourceApi", () {

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

2281

2282 var mock = new common_test.HttpServerMock();

2283 api.GroupsResourceApi res = new api.AdminApi(mock).groups;

2284 var arg_groupKey = "foo";

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

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

2287 var pathOffset = 0;

2288 var index;

2289 var subPart;

2290 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2291 pathOffset += 20;

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

2293 pathOffset += 7;

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

2295 pathOffset = path.length;

2296 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

2297

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

2299 var queryOffset = 0;

2300 var queryMap = {};

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

2302 parseBool(n) {

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

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

2305 if (n == null) return null;

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

2307 }

2308 if (query.length > 0) {

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

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

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

2312 }

2313 }

2314

2315

2316 var h = {

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

2318 };

2319 var resp = "";

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

2321 }), true);

2322 res.delete(arg_groupKey).then(unittest.expectAsync((_) {}));

2323 });

2324

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

2326

2327 var mock = new common_test.HttpServerMock();

2328 api.GroupsResourceApi res = new api.AdminApi(mock).groups;

2329 var arg_groupKey = "foo";

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

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

2332 var pathOffset = 0;

2333 var index;

2334 var subPart;

2335 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2336 pathOffset += 20;

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

2338 pathOffset += 7;

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

2340 pathOffset = path.length;

2341 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

2342

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

2344 var queryOffset = 0;

2345 var queryMap = {};

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

2347 parseBool(n) {

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

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

2350 if (n == null) return null;

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

2352 }

2353 if (query.length > 0) {

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

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

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

2357 }

2358 }

2359

2360

2361 var h = {

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

2363 };

2364 var resp = convert.JSON.encode(buildGroup());

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

2366 }), true);

2367 res.get(arg_groupKey).then(unittest.expectAsync(((api.Group response) {

2368 checkGroup(response);

2369 })));

2370 });

2371

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

2373

2374 var mock = new common_test.HttpServerMock();

2375 api.GroupsResourceApi res = new api.AdminApi(mock).groups;

2376 var arg_request = buildGroup();

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

2378 var obj = new api.Group.fromJson(json);

2379 checkGroup(obj);

2380

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

2382 var pathOffset = 0;

2383 var index;

2384 var subPart;

2385 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2386 pathOffset += 20;

2387 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("groups"));

2388 pathOffset += 6;

2389

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

2391 var queryOffset = 0;

2392 var queryMap = {};

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

2394 parseBool(n) {

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

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

2397 if (n == null) return null;

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

2399 }

2400 if (query.length > 0) {

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

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

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

2404 }

2405 }

2406

2407

2408 var h = {

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

2410 };

2411 var resp = convert.JSON.encode(buildGroup());

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

2413 }), true);

2414 res.insert(arg_request).then(unittest.expectAsync(((api.Group response) {

2415 checkGroup(response);

2416 })));

2417 });

2418

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

2420

2421 var mock = new common_test.HttpServerMock();

2422 api.GroupsResourceApi res = new api.AdminApi(mock).groups;

2423 var arg_customer = "foo";

2424 var arg_domain = "foo";

2425 var arg_maxResults = 42;

2426 var arg_pageToken = "foo";

2427 var arg_userKey = "foo";

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

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

2430 var pathOffset = 0;

2431 var index;

2432 var subPart;

2433 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2434 pathOffset += 20;

2435 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("groups"));

2436 pathOffset += 6;

2437

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

2439 var queryOffset = 0;

2440 var queryMap = {};

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

2442 parseBool(n) {

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

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

2445 if (n == null) return null;

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

2447 }

2448 if (query.length > 0) {

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

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

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

2452 }

2453 }

2454 unittest.expect(queryMap["customer"].first, unittest.equals(arg_customer ));

2455 unittest.expect(queryMap["domain"].first, unittest.equals(arg_domain));

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

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

2458 unittest.expect(queryMap["userKey"].first, unittest.equals(arg_userKey)) ;

2459

2460

2461 var h = {

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

2463 };

2464 var resp = convert.JSON.encode(buildGroups());

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

2466 }), true);

2467 res.list(customer: arg_customer, domain: arg_domain, maxResults: arg_maxRe sults, pageToken: arg_pageToken, userKey: arg_userKey).then(unittest.expectAsync (((api.Groups response) {

2468 checkGroups(response);

2469 })));

2470 });

2471

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

2473

2474 var mock = new common_test.HttpServerMock();

2475 api.GroupsResourceApi res = new api.AdminApi(mock).groups;

2476 var arg_request = buildGroup();

2477 var arg_groupKey = "foo";

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

2479 var obj = new api.Group.fromJson(json);

2480 checkGroup(obj);

2481

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

2483 var pathOffset = 0;

2484 var index;

2485 var subPart;

2486 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2487 pathOffset += 20;

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

2489 pathOffset += 7;

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

2491 pathOffset = path.length;

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

2493

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

2495 var queryOffset = 0;

2496 var queryMap = {};

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

2498 parseBool(n) {

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

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

2501 if (n == null) return null;

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

2503 }

2504 if (query.length > 0) {

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

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

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

2508 }

2509 }

2510

2511

2512 var h = {

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

2514 };

2515 var resp = convert.JSON.encode(buildGroup());

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

2517 }), true);

2518 res.patch(arg_request, arg_groupKey).then(unittest.expectAsync(((api.Group response) {

2519 checkGroup(response);

2520 })));

2521 });

2522

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

2524

2525 var mock = new common_test.HttpServerMock();

2526 api.GroupsResourceApi res = new api.AdminApi(mock).groups;

2527 var arg_request = buildGroup();

2528 var arg_groupKey = "foo";

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

2530 var obj = new api.Group.fromJson(json);

2531 checkGroup(obj);

2532

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

2534 var pathOffset = 0;

2535 var index;

2536 var subPart;

2537 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2538 pathOffset += 20;

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

2540 pathOffset += 7;

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

2542 pathOffset = path.length;

2543 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

2544

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

2546 var queryOffset = 0;

2547 var queryMap = {};

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

2549 parseBool(n) {

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

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

2552 if (n == null) return null;

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

2554 }

2555 if (query.length > 0) {

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

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

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

2559 }

2560 }

2561

2562

2563 var h = {

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

2565 };

2566 var resp = convert.JSON.encode(buildGroup());

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

2568 }), true);

2569 res.update(arg_request, arg_groupKey).then(unittest.expectAsync(((api.Grou p response) {

2570 checkGroup(response);

2571 })));

2572 });

2573

2574 });

2575

2576

2577 unittest.group("resource-GroupsAliasesResourceApi", () {

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

2579

2580 var mock = new common_test.HttpServerMock();

2581 api.GroupsAliasesResourceApi res = new api.AdminApi(mock).groups.aliases;

2582 var arg_groupKey = "foo";

2583 var arg_alias = "foo";

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

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

2586 var pathOffset = 0;

2587 var index;

2588 var subPart;

2589 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2590 pathOffset += 20;

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

2592 pathOffset += 7;

2593 index = path.indexOf("/aliases/", pathOffset);

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

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

2596 pathOffset = index;

2597 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

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

2599 pathOffset += 9;

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

2601 pathOffset = path.length;

2602 unittest.expect(subPart, unittest.equals("$arg_alias"));

2603

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

2605 var queryOffset = 0;

2606 var queryMap = {};

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

2608 parseBool(n) {

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

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

2611 if (n == null) return null;

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

2613 }

2614 if (query.length > 0) {

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

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

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

2618 }

2619 }

2620

2621

2622 var h = {

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

2624 };

2625 var resp = "";

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

2627 }), true);

2628 res.delete(arg_groupKey, arg_alias).then(unittest.expectAsync((_) {}));

2629 });

2630

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

2632

2633 var mock = new common_test.HttpServerMock();

2634 api.GroupsAliasesResourceApi res = new api.AdminApi(mock).groups.aliases;

2635 var arg_request = buildAlias();

2636 var arg_groupKey = "foo";

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

2638 var obj = new api.Alias.fromJson(json);

2639 checkAlias(obj);

2640

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

2642 var pathOffset = 0;

2643 var index;

2644 var subPart;

2645 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2646 pathOffset += 20;

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

2648 pathOffset += 7;

2649 index = path.indexOf("/aliases", pathOffset);

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

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

2652 pathOffset = index;

2653 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

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

2655 pathOffset += 8;

2656

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

2658 var queryOffset = 0;

2659 var queryMap = {};

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

2661 parseBool(n) {

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

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

2664 if (n == null) return null;

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

2666 }

2667 if (query.length > 0) {

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

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

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

2671 }

2672 }

2673

2674

2675 var h = {

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

2677 };

2678 var resp = convert.JSON.encode(buildAlias());

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

2680 }), true);

2681 res.insert(arg_request, arg_groupKey).then(unittest.expectAsync(((api.Alia s response) {

2682 checkAlias(response);

2683 })));

2684 });

2685

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

2687

2688 var mock = new common_test.HttpServerMock();

2689 api.GroupsAliasesResourceApi res = new api.AdminApi(mock).groups.aliases;

2690 var arg_groupKey = "foo";

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

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

2693 var pathOffset = 0;

2694 var index;

2695 var subPart;

2696 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2697 pathOffset += 20;

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

2699 pathOffset += 7;

2700 index = path.indexOf("/aliases", pathOffset);

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

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

2703 pathOffset = index;

2704 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

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

2706 pathOffset += 8;

2707

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

2709 var queryOffset = 0;

2710 var queryMap = {};

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

2712 parseBool(n) {

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

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

2715 if (n == null) return null;

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

2717 }

2718 if (query.length > 0) {

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

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

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

2722 }

2723 }

2724

2725

2726 var h = {

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

2728 };

2729 var resp = convert.JSON.encode(buildAliases());

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

2731 }), true);

2732 res.list(arg_groupKey).then(unittest.expectAsync(((api.Aliases response) {

2733 checkAliases(response);

2734 })));

2735 });

2736

2737 });

2738

2739

2740 unittest.group("resource-MembersResourceApi", () {

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

2742

2743 var mock = new common_test.HttpServerMock();

2744 api.MembersResourceApi res = new api.AdminApi(mock).members;

2745 var arg_groupKey = "foo";

2746 var arg_memberKey = "foo";

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

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

2749 var pathOffset = 0;

2750 var index;

2751 var subPart;

2752 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2753 pathOffset += 20;

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

2755 pathOffset += 7;

2756 index = path.indexOf("/members/", pathOffset);

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

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

2759 pathOffset = index;

2760 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

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

2762 pathOffset += 9;

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

2764 pathOffset = path.length;

2765 unittest.expect(subPart, unittest.equals("$arg_memberKey"));

2766

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

2768 var queryOffset = 0;

2769 var queryMap = {};

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

2771 parseBool(n) {

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

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

2774 if (n == null) return null;

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

2776 }

2777 if (query.length > 0) {

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

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

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

2781 }

2782 }

2783

2784

2785 var h = {

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

2787 };

2788 var resp = "";

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

2790 }), true);

2791 res.delete(arg_groupKey, arg_memberKey).then(unittest.expectAsync((_) {})) ;

2792 });

2793

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

2795

2796 var mock = new common_test.HttpServerMock();

2797 api.MembersResourceApi res = new api.AdminApi(mock).members;

2798 var arg_groupKey = "foo";

2799 var arg_memberKey = "foo";

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

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

2802 var pathOffset = 0;

2803 var index;

2804 var subPart;

2805 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2806 pathOffset += 20;

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

2808 pathOffset += 7;

2809 index = path.indexOf("/members/", pathOffset);

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

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

2812 pathOffset = index;

2813 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

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

2815 pathOffset += 9;

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

2817 pathOffset = path.length;

2818 unittest.expect(subPart, unittest.equals("$arg_memberKey"));

2819

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

2821 var queryOffset = 0;

2822 var queryMap = {};

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

2824 parseBool(n) {

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

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

2827 if (n == null) return null;

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

2829 }

2830 if (query.length > 0) {

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

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

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

2834 }

2835 }

2836

2837

2838 var h = {

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

2840 };

2841 var resp = convert.JSON.encode(buildMember());

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

2843 }), true);

2844 res.get(arg_groupKey, arg_memberKey).then(unittest.expectAsync(((api.Membe r response) {

2845 checkMember(response);

2846 })));

2847 });

2848

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

2850

2851 var mock = new common_test.HttpServerMock();

2852 api.MembersResourceApi res = new api.AdminApi(mock).members;

2853 var arg_request = buildMember();

2854 var arg_groupKey = "foo";

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

2856 var obj = new api.Member.fromJson(json);

2857 checkMember(obj);

2858

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

2860 var pathOffset = 0;

2861 var index;

2862 var subPart;

2863 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2864 pathOffset += 20;

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

2866 pathOffset += 7;

2867 index = path.indexOf("/members", pathOffset);

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

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

2870 pathOffset = index;

2871 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

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

2873 pathOffset += 8;

2874

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

2876 var queryOffset = 0;

2877 var queryMap = {};

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

2879 parseBool(n) {

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

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

2882 if (n == null) return null;

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

2884 }

2885 if (query.length > 0) {

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

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

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

2889 }

2890 }

2891

2892

2893 var h = {

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

2895 };

2896 var resp = convert.JSON.encode(buildMember());

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

2898 }), true);

2899 res.insert(arg_request, arg_groupKey).then(unittest.expectAsync(((api.Memb er response) {

2900 checkMember(response);

2901 })));

2902 });

2903

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

2905

2906 var mock = new common_test.HttpServerMock();

2907 api.MembersResourceApi res = new api.AdminApi(mock).members;

2908 var arg_groupKey = "foo";

2909 var arg_maxResults = 42;

2910 var arg_pageToken = "foo";

2911 var arg_roles = "foo";

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

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

2914 var pathOffset = 0;

2915 var index;

2916 var subPart;

2917 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2918 pathOffset += 20;

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

2920 pathOffset += 7;

2921 index = path.indexOf("/members", pathOffset);

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

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

2924 pathOffset = index;

2925 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

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

2927 pathOffset += 8;

2928

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

2930 var queryOffset = 0;

2931 var queryMap = {};

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

2933 parseBool(n) {

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

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

2936 if (n == null) return null;

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

2938 }

2939 if (query.length > 0) {

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

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

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

2943 }

2944 }

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

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

2947 unittest.expect(queryMap["roles"].first, unittest.equals(arg_roles));

2948

2949

2950 var h = {

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

2952 };

2953 var resp = convert.JSON.encode(buildMembers());

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

2955 }), true);

2956 res.list(arg_groupKey, maxResults: arg_maxResults, pageToken: arg_pageToke n, roles: arg_roles).then(unittest.expectAsync(((api.Members response) {

2957 checkMembers(response);

2958 })));

2959 });

2960

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

2962

2963 var mock = new common_test.HttpServerMock();

2964 api.MembersResourceApi res = new api.AdminApi(mock).members;

2965 var arg_request = buildMember();

2966 var arg_groupKey = "foo";

2967 var arg_memberKey = "foo";

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

2969 var obj = new api.Member.fromJson(json);

2970 checkMember(obj);

2971

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

2973 var pathOffset = 0;

2974 var index;

2975 var subPart;

2976 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

2977 pathOffset += 20;

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

2979 pathOffset += 7;

2980 index = path.indexOf("/members/", pathOffset);

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

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

2983 pathOffset = index;

2984 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

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

2986 pathOffset += 9;

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

2988 pathOffset = path.length;

2989 unittest.expect(subPart, unittest.equals("$arg_memberKey"));

2990

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

2992 var queryOffset = 0;

2993 var queryMap = {};

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

2995 parseBool(n) {

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

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

2998 if (n == null) return null;

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

3000 }

3001 if (query.length > 0) {

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

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

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

3005 }

3006 }

3007

3008

3009 var h = {

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

3011 };

3012 var resp = convert.JSON.encode(buildMember());

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

3014 }), true);

3015 res.patch(arg_request, arg_groupKey, arg_memberKey).then(unittest.expectAs ync(((api.Member response) {

3016 checkMember(response);

3017 })));

3018 });

3019

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

3021

3022 var mock = new common_test.HttpServerMock();

3023 api.MembersResourceApi res = new api.AdminApi(mock).members;

3024 var arg_request = buildMember();

3025 var arg_groupKey = "foo";

3026 var arg_memberKey = "foo";

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

3028 var obj = new api.Member.fromJson(json);

3029 checkMember(obj);

3030

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

3032 var pathOffset = 0;

3033 var index;

3034 var subPart;

3035 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3036 pathOffset += 20;

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

3038 pathOffset += 7;

3039 index = path.indexOf("/members/", pathOffset);

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

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

3042 pathOffset = index;

3043 unittest.expect(subPart, unittest.equals("$arg_groupKey"));

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

3045 pathOffset += 9;

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

3047 pathOffset = path.length;

3048 unittest.expect(subPart, unittest.equals("$arg_memberKey"));

3049

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

3051 var queryOffset = 0;

3052 var queryMap = {};

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

3054 parseBool(n) {

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

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

3057 if (n == null) return null;

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

3059 }

3060 if (query.length > 0) {

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

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

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

3064 }

3065 }

3066

3067

3068 var h = {

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

3070 };

3071 var resp = convert.JSON.encode(buildMember());

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

3073 }), true);

3074 res.update(arg_request, arg_groupKey, arg_memberKey).then(unittest.expectA sync(((api.Member response) {

3075 checkMember(response);

3076 })));

3077 });

3078

3079 });

3080

3081

3082 unittest.group("resource-MobiledevicesResourceApi", () {

3083 unittest.test("method--action", () {

3084

3085 var mock = new common_test.HttpServerMock();

3086 api.MobiledevicesResourceApi res = new api.AdminApi(mock).mobiledevices;

3087 var arg_request = buildMobileDeviceAction();

3088 var arg_customerId = "foo";

3089 var arg_resourceId = "foo";

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

3091 var obj = new api.MobileDeviceAction.fromJson(json);

3092 checkMobileDeviceAction(obj);

3093

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

3095 var pathOffset = 0;

3096 var index;

3097 var subPart;

3098 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3099 pathOffset += 20;

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

3101 pathOffset += 9;

3102 index = path.indexOf("/devices/mobile/", pathOffset);

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

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

3105 pathOffset = index;

3106 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3107 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/devices/mobile/"));

3108 pathOffset += 16;

3109 index = path.indexOf("/action", pathOffset);

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

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

3112 pathOffset = index;

3113 unittest.expect(subPart, unittest.equals("$arg_resourceId"));

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

3115 pathOffset += 7;

3116

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

3118 var queryOffset = 0;

3119 var queryMap = {};

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

3121 parseBool(n) {

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

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

3124 if (n == null) return null;

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

3126 }

3127 if (query.length > 0) {

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

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

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

3131 }

3132 }

3133

3134

3135 var h = {

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

3137 };

3138 var resp = "";

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

3140 }), true);

3141 res.action(arg_request, arg_customerId, arg_resourceId).then(unittest.expe ctAsync((_) {}));

3142 });

3143

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

3145

3146 var mock = new common_test.HttpServerMock();

3147 api.MobiledevicesResourceApi res = new api.AdminApi(mock).mobiledevices;

3148 var arg_customerId = "foo";

3149 var arg_resourceId = "foo";

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

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

3152 var pathOffset = 0;

3153 var index;

3154 var subPart;

3155 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3156 pathOffset += 20;

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

3158 pathOffset += 9;

3159 index = path.indexOf("/devices/mobile/", pathOffset);

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

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

3162 pathOffset = index;

3163 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3164 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/devices/mobile/"));

3165 pathOffset += 16;

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

3167 pathOffset = path.length;

3168 unittest.expect(subPart, unittest.equals("$arg_resourceId"));

3169

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

3171 var queryOffset = 0;

3172 var queryMap = {};

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

3174 parseBool(n) {

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

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

3177 if (n == null) return null;

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

3179 }

3180 if (query.length > 0) {

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

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

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

3184 }

3185 }

3186

3187

3188 var h = {

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

3190 };

3191 var resp = "";

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

3193 }), true);

3194 res.delete(arg_customerId, arg_resourceId).then(unittest.expectAsync((_) { }));

3195 });

3196

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

3198

3199 var mock = new common_test.HttpServerMock();

3200 api.MobiledevicesResourceApi res = new api.AdminApi(mock).mobiledevices;

3201 var arg_customerId = "foo";

3202 var arg_resourceId = "foo";

3203 var arg_projection = "foo";

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

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

3206 var pathOffset = 0;

3207 var index;

3208 var subPart;

3209 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3210 pathOffset += 20;

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

3212 pathOffset += 9;

3213 index = path.indexOf("/devices/mobile/", pathOffset);

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

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

3216 pathOffset = index;

3217 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3218 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/devices/mobile/"));

3219 pathOffset += 16;

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

3221 pathOffset = path.length;

3222 unittest.expect(subPart, unittest.equals("$arg_resourceId"));

3223

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

3225 var queryOffset = 0;

3226 var queryMap = {};

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

3228 parseBool(n) {

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

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

3231 if (n == null) return null;

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

3233 }

3234 if (query.length > 0) {

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

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

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

3238 }

3239 }

3240 unittest.expect(queryMap["projection"].first, unittest.equals(arg_projec tion));

3241

3242

3243 var h = {

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

3245 };

3246 var resp = convert.JSON.encode(buildMobileDevice());

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

3248 }), true);

3249 res.get(arg_customerId, arg_resourceId, projection: arg_projection).then(u nittest.expectAsync(((api.MobileDevice response) {

3250 checkMobileDevice(response);

3251 })));

3252 });

3253

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

3255

3256 var mock = new common_test.HttpServerMock();

3257 api.MobiledevicesResourceApi res = new api.AdminApi(mock).mobiledevices;

3258 var arg_customerId = "foo";

3259 var arg_maxResults = 42;

3260 var arg_orderBy = "foo";

3261 var arg_pageToken = "foo";

3262 var arg_projection = "foo";

3263 var arg_query = "foo";

3264 var arg_sortOrder = "foo";

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

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

3267 var pathOffset = 0;

3268 var index;

3269 var subPart;

3270 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3271 pathOffset += 20;

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

3273 pathOffset += 9;

3274 index = path.indexOf("/devices/mobile", pathOffset);

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

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

3277 pathOffset = index;

3278 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3279 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/devices/mobile"));

3280 pathOffset += 15;

3281

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

3283 var queryOffset = 0;

3284 var queryMap = {};

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

3286 parseBool(n) {

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

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

3289 if (n == null) return null;

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

3291 }

3292 if (query.length > 0) {

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

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

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

3296 }

3297 }

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

3299 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

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

3301 unittest.expect(queryMap["projection"].first, unittest.equals(arg_projec tion));

3302 unittest.expect(queryMap["query"].first, unittest.equals(arg_query));

3303 unittest.expect(queryMap["sortOrder"].first, unittest.equals(arg_sortOrd er));

3304

3305

3306 var h = {

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

3308 };

3309 var resp = convert.JSON.encode(buildMobileDevices());

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

3311 }), true);

3312 res.list(arg_customerId, maxResults: arg_maxResults, orderBy: arg_orderBy, pageToken: arg_pageToken, projection: arg_projection, query: arg_query, sortOrd er: arg_sortOrder).then(unittest.expectAsync(((api.MobileDevices response) {

3313 checkMobileDevices(response);

3314 })));

3315 });

3316

3317 });

3318

3319

3320 unittest.group("resource-NotificationsResourceApi", () {

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

3322

3323 var mock = new common_test.HttpServerMock();

3324 api.NotificationsResourceApi res = new api.AdminApi(mock).notifications;

3325 var arg_customer = "foo";

3326 var arg_notificationId = "foo";

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

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

3329 var pathOffset = 0;

3330 var index;

3331 var subPart;

3332 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3333 pathOffset += 20;

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

3335 pathOffset += 9;

3336 index = path.indexOf("/notifications/", pathOffset);

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

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

3339 pathOffset = index;

3340 unittest.expect(subPart, unittest.equals("$arg_customer"));

3341 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/notifications/"));

3342 pathOffset += 15;

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

3344 pathOffset = path.length;

3345 unittest.expect(subPart, unittest.equals("$arg_notificationId"));

3346

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

3348 var queryOffset = 0;

3349 var queryMap = {};

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

3351 parseBool(n) {

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

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

3354 if (n == null) return null;

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

3356 }

3357 if (query.length > 0) {

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

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

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

3361 }

3362 }

3363

3364

3365 var h = {

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

3367 };

3368 var resp = "";

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

3370 }), true);

3371 res.delete(arg_customer, arg_notificationId).then(unittest.expectAsync((_) {}));

3372 });

3373

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

3375

3376 var mock = new common_test.HttpServerMock();

3377 api.NotificationsResourceApi res = new api.AdminApi(mock).notifications;

3378 var arg_customer = "foo";

3379 var arg_notificationId = "foo";

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

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

3382 var pathOffset = 0;

3383 var index;

3384 var subPart;

3385 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3386 pathOffset += 20;

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

3388 pathOffset += 9;

3389 index = path.indexOf("/notifications/", pathOffset);

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

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

3392 pathOffset = index;

3393 unittest.expect(subPart, unittest.equals("$arg_customer"));

3394 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/notifications/"));

3395 pathOffset += 15;

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

3397 pathOffset = path.length;

3398 unittest.expect(subPart, unittest.equals("$arg_notificationId"));

3399

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

3401 var queryOffset = 0;

3402 var queryMap = {};

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

3404 parseBool(n) {

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

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

3407 if (n == null) return null;

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

3409 }

3410 if (query.length > 0) {

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

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

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

3414 }

3415 }

3416

3417

3418 var h = {

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

3420 };

3421 var resp = convert.JSON.encode(buildNotification());

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

3423 }), true);

3424 res.get(arg_customer, arg_notificationId).then(unittest.expectAsync(((api. Notification response) {

3425 checkNotification(response);

3426 })));

3427 });

3428

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

3430

3431 var mock = new common_test.HttpServerMock();

3432 api.NotificationsResourceApi res = new api.AdminApi(mock).notifications;

3433 var arg_customer = "foo";

3434 var arg_language = "foo";

3435 var arg_maxResults = 42;

3436 var arg_pageToken = "foo";

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

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

3439 var pathOffset = 0;

3440 var index;

3441 var subPart;

3442 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3443 pathOffset += 20;

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

3445 pathOffset += 9;

3446 index = path.indexOf("/notifications", pathOffset);

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

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

3449 pathOffset = index;

3450 unittest.expect(subPart, unittest.equals("$arg_customer"));

3451 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/notifications"));

3452 pathOffset += 14;

3453

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

3455 var queryOffset = 0;

3456 var queryMap = {};

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

3458 parseBool(n) {

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

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

3461 if (n == null) return null;

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

3463 }

3464 if (query.length > 0) {

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

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

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

3468 }

3469 }

3470 unittest.expect(queryMap["language"].first, unittest.equals(arg_language ));

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

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

3473

3474

3475 var h = {

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

3477 };

3478 var resp = convert.JSON.encode(buildNotifications());

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

3480 }), true);

3481 res.list(arg_customer, language: arg_language, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.Notifications respons e) {

3482 checkNotifications(response);

3483 })));

3484 });

3485

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

3487

3488 var mock = new common_test.HttpServerMock();

3489 api.NotificationsResourceApi res = new api.AdminApi(mock).notifications;

3490 var arg_request = buildNotification();

3491 var arg_customer = "foo";

3492 var arg_notificationId = "foo";

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

3494 var obj = new api.Notification.fromJson(json);

3495 checkNotification(obj);

3496

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

3498 var pathOffset = 0;

3499 var index;

3500 var subPart;

3501 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3502 pathOffset += 20;

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

3504 pathOffset += 9;

3505 index = path.indexOf("/notifications/", pathOffset);

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

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

3508 pathOffset = index;

3509 unittest.expect(subPart, unittest.equals("$arg_customer"));

3510 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/notifications/"));

3511 pathOffset += 15;

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

3513 pathOffset = path.length;

3514 unittest.expect(subPart, unittest.equals("$arg_notificationId"));

3515

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

3517 var queryOffset = 0;

3518 var queryMap = {};

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

3520 parseBool(n) {

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

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

3523 if (n == null) return null;

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

3525 }

3526 if (query.length > 0) {

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

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

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

3530 }

3531 }

3532

3533

3534 var h = {

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

3536 };

3537 var resp = convert.JSON.encode(buildNotification());

3538 return new async.Future.value(common_test.stringResponse(200, h, resp));

3539 }), true);

3540 res.patch(arg_request, arg_customer, arg_notificationId).then(unittest.exp ectAsync(((api.Notification response) {

3541 checkNotification(response);

3542 })));

3543 });

3544

3545 unittest.test("method--update", () {

3546

3547 var mock = new common_test.HttpServerMock();

3548 api.NotificationsResourceApi res = new api.AdminApi(mock).notifications;

3549 var arg_request = buildNotification();

3550 var arg_customer = "foo";

3551 var arg_notificationId = "foo";

3552 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3553 var obj = new api.Notification.fromJson(json);

3554 checkNotification(obj);

3555

3556 var path = (req.url).path;

3557 var pathOffset = 0;

3558 var index;

3559 var subPart;

3560 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3561 pathOffset += 20;

3562 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("customer/"));

3563 pathOffset += 9;

3564 index = path.indexOf("/notifications/", pathOffset);

3565 unittest.expect(index >= 0, unittest.isTrue);

3566 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3567 pathOffset = index;

3568 unittest.expect(subPart, unittest.equals("$arg_customer"));

3569 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/notifications/"));

3570 pathOffset += 15;

3571 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3572 pathOffset = path.length;

3573 unittest.expect(subPart, unittest.equals("$arg_notificationId"));

3574

3575 var query = (req.url).query;

3576 var queryOffset = 0;

3577 var queryMap = {};

3578 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3579 parseBool(n) {

3580 if (n == "true") return true;

3581 if (n == "false") return false;

3582 if (n == null) return null;

3583 throw new core.ArgumentError("Invalid boolean: $n");

3584 }

3585 if (query.length > 0) {

3586 for (var part in query.split("&")) {

3587 var keyvalue = part.split("=");

3588 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3589 }

3590 }

3591

3592

3593 var h = {

3594 "content-type" : "application/json; charset=utf-8",

3595 };

3596 var resp = convert.JSON.encode(buildNotification());

3597 return new async.Future.value(common_test.stringResponse(200, h, resp));

3598 }), true);

3599 res.update(arg_request, arg_customer, arg_notificationId).then(unittest.ex pectAsync(((api.Notification response) {

3600 checkNotification(response);

3601 })));

3602 });

3603

3604 });

3605

3606

3607 unittest.group("resource-OrgunitsResourceApi", () {

3608 unittest.test("method--delete", () {

3609

3610 var mock = new common_test.HttpServerMock();

3611 api.OrgunitsResourceApi res = new api.AdminApi(mock).orgunits;

3612 var arg_customerId = "foo";

3613 var arg_orgUnitPath = buildUnnamed478();

3614 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3615 var path = (req.url).path;

3616 var pathOffset = 0;

3617 var index;

3618 var subPart;

3619 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3620 pathOffset += 20;

3621 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("customer/"));

3622 pathOffset += 9;

3623 index = path.indexOf("/orgunits", pathOffset);

3624 unittest.expect(index >= 0, unittest.isTrue);

3625 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3626 pathOffset = index;

3627 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3628 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/orgunits"));

3629 pathOffset += 9;

3630 var parts = path.substring(pathOffset).split("/").map(core.Uri.decodeQue ryComponent).where((p) => p.length > 0).toList();

3631 unittest.expect(parts, unittest.equals(arg_orgUnitPath));

3632

3633 var query = (req.url).query;

3634 var queryOffset = 0;

3635 var queryMap = {};

3636 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3637 parseBool(n) {

3638 if (n == "true") return true;

3639 if (n == "false") return false;

3640 if (n == null) return null;

3641 throw new core.ArgumentError("Invalid boolean: $n");

3642 }

3643 if (query.length > 0) {

3644 for (var part in query.split("&")) {

3645 var keyvalue = part.split("=");

3646 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3647 }

3648 }

3649

3650

3651 var h = {

3652 "content-type" : "application/json; charset=utf-8",

3653 };

3654 var resp = "";

3655 return new async.Future.value(common_test.stringResponse(200, h, resp));

3656 }), true);

3657 res.delete(arg_customerId, arg_orgUnitPath).then(unittest.expectAsync((_) {}));

3658 });

3659

3660 unittest.test("method--get", () {

3661

3662 var mock = new common_test.HttpServerMock();

3663 api.OrgunitsResourceApi res = new api.AdminApi(mock).orgunits;

3664 var arg_customerId = "foo";

3665 var arg_orgUnitPath = buildUnnamed479();

3666 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3667 var path = (req.url).path;

3668 var pathOffset = 0;

3669 var index;

3670 var subPart;

3671 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3672 pathOffset += 20;

3673 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("customer/"));

3674 pathOffset += 9;

3675 index = path.indexOf("/orgunits", pathOffset);

3676 unittest.expect(index >= 0, unittest.isTrue);

3677 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3678 pathOffset = index;

3679 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3680 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/orgunits"));

3681 pathOffset += 9;

3682 var parts = path.substring(pathOffset).split("/").map(core.Uri.decodeQue ryComponent).where((p) => p.length > 0).toList();

3683 unittest.expect(parts, unittest.equals(arg_orgUnitPath));

3684

3685 var query = (req.url).query;

3686 var queryOffset = 0;

3687 var queryMap = {};

3688 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3689 parseBool(n) {

3690 if (n == "true") return true;

3691 if (n == "false") return false;

3692 if (n == null) return null;

3693 throw new core.ArgumentError("Invalid boolean: $n");

3694 }

3695 if (query.length > 0) {

3696 for (var part in query.split("&")) {

3697 var keyvalue = part.split("=");

3698 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3699 }

3700 }

3701

3702

3703 var h = {

3704 "content-type" : "application/json; charset=utf-8",

3705 };

3706 var resp = convert.JSON.encode(buildOrgUnit());

3707 return new async.Future.value(common_test.stringResponse(200, h, resp));

3708 }), true);

3709 res.get(arg_customerId, arg_orgUnitPath).then(unittest.expectAsync(((api.O rgUnit response) {

3710 checkOrgUnit(response);

3711 })));

3712 });

3713

3714 unittest.test("method--insert", () {

3715

3716 var mock = new common_test.HttpServerMock();

3717 api.OrgunitsResourceApi res = new api.AdminApi(mock).orgunits;

3718 var arg_request = buildOrgUnit();

3719 var arg_customerId = "foo";

3720 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3721 var obj = new api.OrgUnit.fromJson(json);

3722 checkOrgUnit(obj);

3723

3724 var path = (req.url).path;

3725 var pathOffset = 0;

3726 var index;

3727 var subPart;

3728 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3729 pathOffset += 20;

3730 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("customer/"));

3731 pathOffset += 9;

3732 index = path.indexOf("/orgunits", pathOffset);

3733 unittest.expect(index >= 0, unittest.isTrue);

3734 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3735 pathOffset = index;

3736 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3737 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/orgunits"));

3738 pathOffset += 9;

3739

3740 var query = (req.url).query;

3741 var queryOffset = 0;

3742 var queryMap = {};

3743 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3744 parseBool(n) {

3745 if (n == "true") return true;

3746 if (n == "false") return false;

3747 if (n == null) return null;

3748 throw new core.ArgumentError("Invalid boolean: $n");

3749 }

3750 if (query.length > 0) {

3751 for (var part in query.split("&")) {

3752 var keyvalue = part.split("=");

3753 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3754 }

3755 }

3756

3757

3758 var h = {

3759 "content-type" : "application/json; charset=utf-8",

3760 };

3761 var resp = convert.JSON.encode(buildOrgUnit());

3762 return new async.Future.value(common_test.stringResponse(200, h, resp));

3763 }), true);

3764 res.insert(arg_request, arg_customerId).then(unittest.expectAsync(((api.Or gUnit response) {

3765 checkOrgUnit(response);

3766 })));

3767 });

3768

3769 unittest.test("method--list", () {

3770

3771 var mock = new common_test.HttpServerMock();

3772 api.OrgunitsResourceApi res = new api.AdminApi(mock).orgunits;

3773 var arg_customerId = "foo";

3774 var arg_orgUnitPath = "foo";

3775 var arg_type = "foo";

3776 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3777 var path = (req.url).path;

3778 var pathOffset = 0;

3779 var index;

3780 var subPart;

3781 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3782 pathOffset += 20;

3783 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("customer/"));

3784 pathOffset += 9;

3785 index = path.indexOf("/orgunits", pathOffset);

3786 unittest.expect(index >= 0, unittest.isTrue);

3787 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3788 pathOffset = index;

3789 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3790 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/orgunits"));

3791 pathOffset += 9;

3792

3793 var query = (req.url).query;

3794 var queryOffset = 0;

3795 var queryMap = {};

3796 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3797 parseBool(n) {

3798 if (n == "true") return true;

3799 if (n == "false") return false;

3800 if (n == null) return null;

3801 throw new core.ArgumentError("Invalid boolean: $n");

3802 }

3803 if (query.length > 0) {

3804 for (var part in query.split("&")) {

3805 var keyvalue = part.split("=");

3806 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3807 }

3808 }

3809 unittest.expect(queryMap["orgUnitPath"].first, unittest.equals(arg_orgUn itPath));

3810 unittest.expect(queryMap["type"].first, unittest.equals(arg_type));

3811

3812

3813 var h = {

3814 "content-type" : "application/json; charset=utf-8",

3815 };

3816 var resp = convert.JSON.encode(buildOrgUnits());

3817 return new async.Future.value(common_test.stringResponse(200, h, resp));

3818 }), true);

3819 res.list(arg_customerId, orgUnitPath: arg_orgUnitPath, type: arg_type).the n(unittest.expectAsync(((api.OrgUnits response) {

3820 checkOrgUnits(response);

3821 })));

3822 });

3823

3824 unittest.test("method--patch", () {

3825

3826 var mock = new common_test.HttpServerMock();

3827 api.OrgunitsResourceApi res = new api.AdminApi(mock).orgunits;

3828 var arg_request = buildOrgUnit();

3829 var arg_customerId = "foo";

3830 var arg_orgUnitPath = buildUnnamed480();

3831 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3832 var obj = new api.OrgUnit.fromJson(json);

3833 checkOrgUnit(obj);

3834

3835 var path = (req.url).path;

3836 var pathOffset = 0;

3837 var index;

3838 var subPart;

3839 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3840 pathOffset += 20;

3841 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("customer/"));

3842 pathOffset += 9;

3843 index = path.indexOf("/orgunits", pathOffset);

3844 unittest.expect(index >= 0, unittest.isTrue);

3845 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3846 pathOffset = index;

3847 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3848 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/orgunits"));

3849 pathOffset += 9;

3850 var parts = path.substring(pathOffset).split("/").map(core.Uri.decodeQue ryComponent).where((p) => p.length > 0).toList();

3851 unittest.expect(parts, unittest.equals(arg_orgUnitPath));

3852

3853 var query = (req.url).query;

3854 var queryOffset = 0;

3855 var queryMap = {};

3856 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3857 parseBool(n) {

3858 if (n == "true") return true;

3859 if (n == "false") return false;

3860 if (n == null) return null;

3861 throw new core.ArgumentError("Invalid boolean: $n");

3862 }

3863 if (query.length > 0) {

3864 for (var part in query.split("&")) {

3865 var keyvalue = part.split("=");

3866 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3867 }

3868 }

3869

3870

3871 var h = {

3872 "content-type" : "application/json; charset=utf-8",

3873 };

3874 var resp = convert.JSON.encode(buildOrgUnit());

3875 return new async.Future.value(common_test.stringResponse(200, h, resp));

3876 }), true);

3877 res.patch(arg_request, arg_customerId, arg_orgUnitPath).then(unittest.expe ctAsync(((api.OrgUnit response) {

3878 checkOrgUnit(response);

3879 })));

3880 });

3881

3882 unittest.test("method--update", () {

3883

3884 var mock = new common_test.HttpServerMock();

3885 api.OrgunitsResourceApi res = new api.AdminApi(mock).orgunits;

3886 var arg_request = buildOrgUnit();

3887 var arg_customerId = "foo";

3888 var arg_orgUnitPath = buildUnnamed481();

3889 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3890 var obj = new api.OrgUnit.fromJson(json);

3891 checkOrgUnit(obj);

3892

3893 var path = (req.url).path;

3894 var pathOffset = 0;

3895 var index;

3896 var subPart;

3897 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3898 pathOffset += 20;

3899 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("customer/"));

3900 pathOffset += 9;

3901 index = path.indexOf("/orgunits", pathOffset);

3902 unittest.expect(index >= 0, unittest.isTrue);

3903 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3904 pathOffset = index;

3905 unittest.expect(subPart, unittest.equals("$arg_customerId"));

3906 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/orgunits"));

3907 pathOffset += 9;

3908 var parts = path.substring(pathOffset).split("/").map(core.Uri.decodeQue ryComponent).where((p) => p.length > 0).toList();

3909 unittest.expect(parts, unittest.equals(arg_orgUnitPath));

3910

3911 var query = (req.url).query;

3912 var queryOffset = 0;

3913 var queryMap = {};

3914 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3915 parseBool(n) {

3916 if (n == "true") return true;

3917 if (n == "false") return false;

3918 if (n == null) return null;

3919 throw new core.ArgumentError("Invalid boolean: $n");

3920 }

3921 if (query.length > 0) {

3922 for (var part in query.split("&")) {

3923 var keyvalue = part.split("=");

3924 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3925 }

3926 }

3927

3928

3929 var h = {

3930 "content-type" : "application/json; charset=utf-8",

3931 };

3932 var resp = convert.JSON.encode(buildOrgUnit());

3933 return new async.Future.value(common_test.stringResponse(200, h, resp));

3934 }), true);

3935 res.update(arg_request, arg_customerId, arg_orgUnitPath).then(unittest.exp ectAsync(((api.OrgUnit response) {

3936 checkOrgUnit(response);

3937 })));

3938 });

3939

3940 });

3941

3942

3943 unittest.group("resource-TokensResourceApi", () {

3944 unittest.test("method--delete", () {

3945

3946 var mock = new common_test.HttpServerMock();

3947 api.TokensResourceApi res = new api.AdminApi(mock).tokens;

3948 var arg_userKey = "foo";

3949 var arg_clientId = "foo";

3950 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3951 var path = (req.url).path;

3952 var pathOffset = 0;

3953 var index;

3954 var subPart;

3955 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

3956 pathOffset += 20;

3957 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

3958 pathOffset += 6;

3959 index = path.indexOf("/tokens/", pathOffset);

3960 unittest.expect(index >= 0, unittest.isTrue);

3961 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3962 pathOffset = index;

3963 unittest.expect(subPart, unittest.equals("$arg_userKey"));

3964 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/tokens/"));

3965 pathOffset += 8;

3966 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3967 pathOffset = path.length;

3968 unittest.expect(subPart, unittest.equals("$arg_clientId"));

3969

3970 var query = (req.url).query;

3971 var queryOffset = 0;

3972 var queryMap = {};

3973 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3974 parseBool(n) {

3975 if (n == "true") return true;

3976 if (n == "false") return false;

3977 if (n == null) return null;

3978 throw new core.ArgumentError("Invalid boolean: $n");

3979 }

3980 if (query.length > 0) {

3981 for (var part in query.split("&")) {

3982 var keyvalue = part.split("=");

3983 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3984 }

3985 }

3986

3987

3988 var h = {

3989 "content-type" : "application/json; charset=utf-8",

3990 };

3991 var resp = "";

3992 return new async.Future.value(common_test.stringResponse(200, h, resp));

3993 }), true);

3994 res.delete(arg_userKey, arg_clientId).then(unittest.expectAsync((_) {}));

3995 });

3996

3997 unittest.test("method--get", () {

3998

3999 var mock = new common_test.HttpServerMock();

4000 api.TokensResourceApi res = new api.AdminApi(mock).tokens;

4001 var arg_userKey = "foo";

4002 var arg_clientId = "foo";

4003 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4004 var path = (req.url).path;

4005 var pathOffset = 0;

4006 var index;

4007 var subPart;

4008 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4009 pathOffset += 20;

4010 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4011 pathOffset += 6;

4012 index = path.indexOf("/tokens/", pathOffset);

4013 unittest.expect(index >= 0, unittest.isTrue);

4014 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4015 pathOffset = index;

4016 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4017 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/tokens/"));

4018 pathOffset += 8;

4019 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4020 pathOffset = path.length;

4021 unittest.expect(subPart, unittest.equals("$arg_clientId"));

4022

4023 var query = (req.url).query;

4024 var queryOffset = 0;

4025 var queryMap = {};

4026 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4027 parseBool(n) {

4028 if (n == "true") return true;

4029 if (n == "false") return false;

4030 if (n == null) return null;

4031 throw new core.ArgumentError("Invalid boolean: $n");

4032 }

4033 if (query.length > 0) {

4034 for (var part in query.split("&")) {

4035 var keyvalue = part.split("=");

4036 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4037 }

4038 }

4039

4040

4041 var h = {

4042 "content-type" : "application/json; charset=utf-8",

4043 };

4044 var resp = convert.JSON.encode(buildToken());

4045 return new async.Future.value(common_test.stringResponse(200, h, resp));

4046 }), true);

4047 res.get(arg_userKey, arg_clientId).then(unittest.expectAsync(((api.Token r esponse) {

4048 checkToken(response);

4049 })));

4050 });

4051

4052 unittest.test("method--list", () {

4053

4054 var mock = new common_test.HttpServerMock();

4055 api.TokensResourceApi res = new api.AdminApi(mock).tokens;

4056 var arg_userKey = "foo";

4057 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4058 var path = (req.url).path;

4059 var pathOffset = 0;

4060 var index;

4061 var subPart;

4062 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4063 pathOffset += 20;

4064 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4065 pathOffset += 6;

4066 index = path.indexOf("/tokens", pathOffset);

4067 unittest.expect(index >= 0, unittest.isTrue);

4068 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4069 pathOffset = index;

4070 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4071 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/tokens"));

4072 pathOffset += 7;

4073

4074 var query = (req.url).query;

4075 var queryOffset = 0;

4076 var queryMap = {};

4077 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4078 parseBool(n) {

4079 if (n == "true") return true;

4080 if (n == "false") return false;

4081 if (n == null) return null;

4082 throw new core.ArgumentError("Invalid boolean: $n");

4083 }

4084 if (query.length > 0) {

4085 for (var part in query.split("&")) {

4086 var keyvalue = part.split("=");

4087 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4088 }

4089 }

4090

4091

4092 var h = {

4093 "content-type" : "application/json; charset=utf-8",

4094 };

4095 var resp = convert.JSON.encode(buildTokens());

4096 return new async.Future.value(common_test.stringResponse(200, h, resp));

4097 }), true);

4098 res.list(arg_userKey).then(unittest.expectAsync(((api.Tokens response) {

4099 checkTokens(response);

4100 })));

4101 });

4102

4103 });

4104

4105

4106 unittest.group("resource-UsersResourceApi", () {

4107 unittest.test("method--delete", () {

4108

4109 var mock = new common_test.HttpServerMock();

4110 api.UsersResourceApi res = new api.AdminApi(mock).users;

4111 var arg_userKey = "foo";

4112 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4113 var path = (req.url).path;

4114 var pathOffset = 0;

4115 var index;

4116 var subPart;

4117 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4118 pathOffset += 20;

4119 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4120 pathOffset += 6;

4121 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4122 pathOffset = path.length;

4123 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4124

4125 var query = (req.url).query;

4126 var queryOffset = 0;

4127 var queryMap = {};

4128 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4129 parseBool(n) {

4130 if (n == "true") return true;

4131 if (n == "false") return false;

4132 if (n == null) return null;

4133 throw new core.ArgumentError("Invalid boolean: $n");

4134 }

4135 if (query.length > 0) {

4136 for (var part in query.split("&")) {

4137 var keyvalue = part.split("=");

4138 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4139 }

4140 }

4141

4142

4143 var h = {

4144 "content-type" : "application/json; charset=utf-8",

4145 };

4146 var resp = "";

4147 return new async.Future.value(common_test.stringResponse(200, h, resp));

4148 }), true);

4149 res.delete(arg_userKey).then(unittest.expectAsync((_) {}));

4150 });

4151

4152 unittest.test("method--get", () {

4153

4154 var mock = new common_test.HttpServerMock();

4155 api.UsersResourceApi res = new api.AdminApi(mock).users;

4156 var arg_userKey = "foo";

4157 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4158 var path = (req.url).path;

4159 var pathOffset = 0;

4160 var index;

4161 var subPart;

4162 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4163 pathOffset += 20;

4164 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4165 pathOffset += 6;

4166 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4167 pathOffset = path.length;

4168 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4169

4170 var query = (req.url).query;

4171 var queryOffset = 0;

4172 var queryMap = {};

4173 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4174 parseBool(n) {

4175 if (n == "true") return true;

4176 if (n == "false") return false;

4177 if (n == null) return null;

4178 throw new core.ArgumentError("Invalid boolean: $n");

4179 }

4180 if (query.length > 0) {

4181 for (var part in query.split("&")) {

4182 var keyvalue = part.split("=");

4183 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4184 }

4185 }

4186

4187

4188 var h = {

4189 "content-type" : "application/json; charset=utf-8",

4190 };

4191 var resp = convert.JSON.encode(buildUser());

4192 return new async.Future.value(common_test.stringResponse(200, h, resp));

4193 }), true);

4194 res.get(arg_userKey).then(unittest.expectAsync(((api.User response) {

4195 checkUser(response);

4196 })));

4197 });

4198

4199 unittest.test("method--insert", () {

4200

4201 var mock = new common_test.HttpServerMock();

4202 api.UsersResourceApi res = new api.AdminApi(mock).users;

4203 var arg_request = buildUser();

4204 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4205 var obj = new api.User.fromJson(json);

4206 checkUser(obj);

4207

4208 var path = (req.url).path;

4209 var pathOffset = 0;

4210 var index;

4211 var subPart;

4212 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4213 pathOffset += 20;

4214 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("users"));

4215 pathOffset += 5;

4216

4217 var query = (req.url).query;

4218 var queryOffset = 0;

4219 var queryMap = {};

4220 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4221 parseBool(n) {

4222 if (n == "true") return true;

4223 if (n == "false") return false;

4224 if (n == null) return null;

4225 throw new core.ArgumentError("Invalid boolean: $n");

4226 }

4227 if (query.length > 0) {

4228 for (var part in query.split("&")) {

4229 var keyvalue = part.split("=");

4230 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4231 }

4232 }

4233

4234

4235 var h = {

4236 "content-type" : "application/json; charset=utf-8",

4237 };

4238 var resp = convert.JSON.encode(buildUser());

4239 return new async.Future.value(common_test.stringResponse(200, h, resp));

4240 }), true);

4241 res.insert(arg_request).then(unittest.expectAsync(((api.User response) {

4242 checkUser(response);

4243 })));

4244 });

4245

4246 unittest.test("method--list", () {

4247

4248 var mock = new common_test.HttpServerMock();

4249 api.UsersResourceApi res = new api.AdminApi(mock).users;

4250 var arg_customer = "foo";

4251 var arg_domain = "foo";

4252 var arg_event = "foo";

4253 var arg_maxResults = 42;

4254 var arg_orderBy = "foo";

4255 var arg_pageToken = "foo";

4256 var arg_query = "foo";

4257 var arg_showDeleted = "foo";

4258 var arg_sortOrder = "foo";

4259 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4260 var path = (req.url).path;

4261 var pathOffset = 0;

4262 var index;

4263 var subPart;

4264 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4265 pathOffset += 20;

4266 unittest.expect(path.substring(pathOffset, pathOffset + 5), unittest.equ als("users"));

4267 pathOffset += 5;

4268

4269 var query = (req.url).query;

4270 var queryOffset = 0;

4271 var queryMap = {};

4272 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4273 parseBool(n) {

4274 if (n == "true") return true;

4275 if (n == "false") return false;

4276 if (n == null) return null;

4277 throw new core.ArgumentError("Invalid boolean: $n");

4278 }

4279 if (query.length > 0) {

4280 for (var part in query.split("&")) {

4281 var keyvalue = part.split("=");

4282 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4283 }

4284 }

4285 unittest.expect(queryMap["customer"].first, unittest.equals(arg_customer ));

4286 unittest.expect(queryMap["domain"].first, unittest.equals(arg_domain));

4287 unittest.expect(queryMap["event"].first, unittest.equals(arg_event));

4288 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

4289 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

4290 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

4291 unittest.expect(queryMap["query"].first, unittest.equals(arg_query));

4292 unittest.expect(queryMap["showDeleted"].first, unittest.equals(arg_showD eleted));

4293 unittest.expect(queryMap["sortOrder"].first, unittest.equals(arg_sortOrd er));

4294

4295

4296 var h = {

4297 "content-type" : "application/json; charset=utf-8",

4298 };

4299 var resp = convert.JSON.encode(buildUsers());

4300 return new async.Future.value(common_test.stringResponse(200, h, resp));

4301 }), true);

4302 res.list(customer: arg_customer, domain: arg_domain, event: arg_event, max Results: arg_maxResults, orderBy: arg_orderBy, pageToken: arg_pageToken, query: arg_query, showDeleted: arg_showDeleted, sortOrder: arg_sortOrder).then(unittest .expectAsync(((api.Users response) {

4303 checkUsers(response);

4304 })));

4305 });

4306

4307 unittest.test("method--makeAdmin", () {

4308

4309 var mock = new common_test.HttpServerMock();

4310 api.UsersResourceApi res = new api.AdminApi(mock).users;

4311 var arg_request = buildUserMakeAdmin();

4312 var arg_userKey = "foo";

4313 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4314 var obj = new api.UserMakeAdmin.fromJson(json);

4315 checkUserMakeAdmin(obj);

4316

4317 var path = (req.url).path;

4318 var pathOffset = 0;

4319 var index;

4320 var subPart;

4321 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4322 pathOffset += 20;

4323 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4324 pathOffset += 6;

4325 index = path.indexOf("/makeAdmin", pathOffset);

4326 unittest.expect(index >= 0, unittest.isTrue);

4327 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4328 pathOffset = index;

4329 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4330 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/makeAdmin"));

4331 pathOffset += 10;

4332

4333 var query = (req.url).query;

4334 var queryOffset = 0;

4335 var queryMap = {};

4336 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4337 parseBool(n) {

4338 if (n == "true") return true;

4339 if (n == "false") return false;

4340 if (n == null) return null;

4341 throw new core.ArgumentError("Invalid boolean: $n");

4342 }

4343 if (query.length > 0) {

4344 for (var part in query.split("&")) {

4345 var keyvalue = part.split("=");

4346 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4347 }

4348 }

4349

4350

4351 var h = {

4352 "content-type" : "application/json; charset=utf-8",

4353 };

4354 var resp = "";

4355 return new async.Future.value(common_test.stringResponse(200, h, resp));

4356 }), true);

4357 res.makeAdmin(arg_request, arg_userKey).then(unittest.expectAsync((_) {})) ;

4358 });

4359

4360 unittest.test("method--patch", () {

4361

4362 var mock = new common_test.HttpServerMock();

4363 api.UsersResourceApi res = new api.AdminApi(mock).users;

4364 var arg_request = buildUser();

4365 var arg_userKey = "foo";

4366 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4367 var obj = new api.User.fromJson(json);

4368 checkUser(obj);

4369

4370 var path = (req.url).path;

4371 var pathOffset = 0;

4372 var index;

4373 var subPart;

4374 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4375 pathOffset += 20;

4376 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4377 pathOffset += 6;

4378 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4379 pathOffset = path.length;

4380 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4381

4382 var query = (req.url).query;

4383 var queryOffset = 0;

4384 var queryMap = {};

4385 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4386 parseBool(n) {

4387 if (n == "true") return true;

4388 if (n == "false") return false;

4389 if (n == null) return null;

4390 throw new core.ArgumentError("Invalid boolean: $n");

4391 }

4392 if (query.length > 0) {

4393 for (var part in query.split("&")) {

4394 var keyvalue = part.split("=");

4395 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4396 }

4397 }

4398

4399

4400 var h = {

4401 "content-type" : "application/json; charset=utf-8",

4402 };

4403 var resp = convert.JSON.encode(buildUser());

4404 return new async.Future.value(common_test.stringResponse(200, h, resp));

4405 }), true);

4406 res.patch(arg_request, arg_userKey).then(unittest.expectAsync(((api.User r esponse) {

4407 checkUser(response);

4408 })));

4409 });

4410

4411 unittest.test("method--undelete", () {

4412

4413 var mock = new common_test.HttpServerMock();

4414 api.UsersResourceApi res = new api.AdminApi(mock).users;

4415 var arg_request = buildUserUndelete();

4416 var arg_userKey = "foo";

4417 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4418 var obj = new api.UserUndelete.fromJson(json);

4419 checkUserUndelete(obj);

4420

4421 var path = (req.url).path;

4422 var pathOffset = 0;

4423 var index;

4424 var subPart;

4425 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4426 pathOffset += 20;

4427 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4428 pathOffset += 6;

4429 index = path.indexOf("/undelete", pathOffset);

4430 unittest.expect(index >= 0, unittest.isTrue);

4431 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4432 pathOffset = index;

4433 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4434 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/undelete"));

4435 pathOffset += 9;

4436

4437 var query = (req.url).query;

4438 var queryOffset = 0;

4439 var queryMap = {};

4440 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4441 parseBool(n) {

4442 if (n == "true") return true;

4443 if (n == "false") return false;

4444 if (n == null) return null;

4445 throw new core.ArgumentError("Invalid boolean: $n");

4446 }

4447 if (query.length > 0) {

4448 for (var part in query.split("&")) {

4449 var keyvalue = part.split("=");

4450 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4451 }

4452 }

4453

4454

4455 var h = {

4456 "content-type" : "application/json; charset=utf-8",

4457 };

4458 var resp = "";

4459 return new async.Future.value(common_test.stringResponse(200, h, resp));

4460 }), true);

4461 res.undelete(arg_request, arg_userKey).then(unittest.expectAsync((_) {}));

4462 });

4463

4464 unittest.test("method--update", () {

4465

4466 var mock = new common_test.HttpServerMock();

4467 api.UsersResourceApi res = new api.AdminApi(mock).users;

4468 var arg_request = buildUser();

4469 var arg_userKey = "foo";

4470 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4471 var obj = new api.User.fromJson(json);

4472 checkUser(obj);

4473

4474 var path = (req.url).path;

4475 var pathOffset = 0;

4476 var index;

4477 var subPart;

4478 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4479 pathOffset += 20;

4480 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4481 pathOffset += 6;

4482 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4483 pathOffset = path.length;

4484 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4485

4486 var query = (req.url).query;

4487 var queryOffset = 0;

4488 var queryMap = {};

4489 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4490 parseBool(n) {

4491 if (n == "true") return true;

4492 if (n == "false") return false;

4493 if (n == null) return null;

4494 throw new core.ArgumentError("Invalid boolean: $n");

4495 }

4496 if (query.length > 0) {

4497 for (var part in query.split("&")) {

4498 var keyvalue = part.split("=");

4499 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4500 }

4501 }

4502

4503

4504 var h = {

4505 "content-type" : "application/json; charset=utf-8",

4506 };

4507 var resp = convert.JSON.encode(buildUser());

4508 return new async.Future.value(common_test.stringResponse(200, h, resp));

4509 }), true);

4510 res.update(arg_request, arg_userKey).then(unittest.expectAsync(((api.User response) {

4511 checkUser(response);

4512 })));

4513 });

4514

4515 unittest.test("method--watch", () {

4516

4517 var mock = new common_test.HttpServerMock();

4518 api.UsersResourceApi res = new api.AdminApi(mock).users;

4519 var arg_request = buildChannel();

4520 var arg_customer = "foo";

4521 var arg_domain = "foo";

4522 var arg_event = "foo";

4523 var arg_maxResults = 42;

4524 var arg_orderBy = "foo";

4525 var arg_pageToken = "foo";

4526 var arg_query = "foo";

4527 var arg_showDeleted = "foo";

4528 var arg_sortOrder = "foo";

4529 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4530 var obj = new api.Channel.fromJson(json);

4531 checkChannel(obj);

4532

4533 var path = (req.url).path;

4534 var pathOffset = 0;

4535 var index;

4536 var subPart;

4537 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4538 pathOffset += 20;

4539 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("users/watch"));

4540 pathOffset += 11;

4541

4542 var query = (req.url).query;

4543 var queryOffset = 0;

4544 var queryMap = {};

4545 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4546 parseBool(n) {

4547 if (n == "true") return true;

4548 if (n == "false") return false;

4549 if (n == null) return null;

4550 throw new core.ArgumentError("Invalid boolean: $n");

4551 }

4552 if (query.length > 0) {

4553 for (var part in query.split("&")) {

4554 var keyvalue = part.split("=");

4555 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4556 }

4557 }

4558 unittest.expect(queryMap["customer"].first, unittest.equals(arg_customer ));

4559 unittest.expect(queryMap["domain"].first, unittest.equals(arg_domain));

4560 unittest.expect(queryMap["event"].first, unittest.equals(arg_event));

4561 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

4562 unittest.expect(queryMap["orderBy"].first, unittest.equals(arg_orderBy)) ;

4563 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

4564 unittest.expect(queryMap["query"].first, unittest.equals(arg_query));

4565 unittest.expect(queryMap["showDeleted"].first, unittest.equals(arg_showD eleted));

4566 unittest.expect(queryMap["sortOrder"].first, unittest.equals(arg_sortOrd er));

4567

4568

4569 var h = {

4570 "content-type" : "application/json; charset=utf-8",

4571 };

4572 var resp = convert.JSON.encode(buildChannel());

4573 return new async.Future.value(common_test.stringResponse(200, h, resp));

4574 }), true);

4575 res.watch(arg_request, customer: arg_customer, domain: arg_domain, event: arg_event, maxResults: arg_maxResults, orderBy: arg_orderBy, pageToken: arg_page Token, query: arg_query, showDeleted: arg_showDeleted, sortOrder: arg_sortOrder) .then(unittest.expectAsync(((api.Channel response) {

4576 checkChannel(response);

4577 })));

4578 });

4579

4580 });

4581

4582

4583 unittest.group("resource-UsersAliasesResourceApi", () {

4584 unittest.test("method--delete", () {

4585

4586 var mock = new common_test.HttpServerMock();

4587 api.UsersAliasesResourceApi res = new api.AdminApi(mock).users.aliases;

4588 var arg_userKey = "foo";

4589 var arg_alias = "foo";

4590 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4591 var path = (req.url).path;

4592 var pathOffset = 0;

4593 var index;

4594 var subPart;

4595 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4596 pathOffset += 20;

4597 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4598 pathOffset += 6;

4599 index = path.indexOf("/aliases/", pathOffset);

4600 unittest.expect(index >= 0, unittest.isTrue);

4601 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4602 pathOffset = index;

4603 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4604 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/aliases/"));

4605 pathOffset += 9;

4606 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4607 pathOffset = path.length;

4608 unittest.expect(subPart, unittest.equals("$arg_alias"));

4609

4610 var query = (req.url).query;

4611 var queryOffset = 0;

4612 var queryMap = {};

4613 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4614 parseBool(n) {

4615 if (n == "true") return true;

4616 if (n == "false") return false;

4617 if (n == null) return null;

4618 throw new core.ArgumentError("Invalid boolean: $n");

4619 }

4620 if (query.length > 0) {

4621 for (var part in query.split("&")) {

4622 var keyvalue = part.split("=");

4623 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4624 }

4625 }

4626

4627

4628 var h = {

4629 "content-type" : "application/json; charset=utf-8",

4630 };

4631 var resp = "";

4632 return new async.Future.value(common_test.stringResponse(200, h, resp));

4633 }), true);

4634 res.delete(arg_userKey, arg_alias).then(unittest.expectAsync((_) {}));

4635 });

4636

4637 unittest.test("method--insert", () {

4638

4639 var mock = new common_test.HttpServerMock();

4640 api.UsersAliasesResourceApi res = new api.AdminApi(mock).users.aliases;

4641 var arg_request = buildAlias();

4642 var arg_userKey = "foo";

4643 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4644 var obj = new api.Alias.fromJson(json);

4645 checkAlias(obj);

4646

4647 var path = (req.url).path;

4648 var pathOffset = 0;

4649 var index;

4650 var subPart;

4651 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4652 pathOffset += 20;

4653 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4654 pathOffset += 6;

4655 index = path.indexOf("/aliases", pathOffset);

4656 unittest.expect(index >= 0, unittest.isTrue);

4657 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4658 pathOffset = index;

4659 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4660 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/aliases"));

4661 pathOffset += 8;

4662

4663 var query = (req.url).query;

4664 var queryOffset = 0;

4665 var queryMap = {};

4666 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4667 parseBool(n) {

4668 if (n == "true") return true;

4669 if (n == "false") return false;

4670 if (n == null) return null;

4671 throw new core.ArgumentError("Invalid boolean: $n");

4672 }

4673 if (query.length > 0) {

4674 for (var part in query.split("&")) {

4675 var keyvalue = part.split("=");

4676 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4677 }

4678 }

4679

4680

4681 var h = {

4682 "content-type" : "application/json; charset=utf-8",

4683 };

4684 var resp = convert.JSON.encode(buildAlias());

4685 return new async.Future.value(common_test.stringResponse(200, h, resp));

4686 }), true);

4687 res.insert(arg_request, arg_userKey).then(unittest.expectAsync(((api.Alias response) {

4688 checkAlias(response);

4689 })));

4690 });

4691

4692 unittest.test("method--list", () {

4693

4694 var mock = new common_test.HttpServerMock();

4695 api.UsersAliasesResourceApi res = new api.AdminApi(mock).users.aliases;

4696 var arg_userKey = "foo";

4697 var arg_event = "foo";

4698 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4699 var path = (req.url).path;

4700 var pathOffset = 0;

4701 var index;

4702 var subPart;

4703 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4704 pathOffset += 20;

4705 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4706 pathOffset += 6;

4707 index = path.indexOf("/aliases", pathOffset);

4708 unittest.expect(index >= 0, unittest.isTrue);

4709 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4710 pathOffset = index;

4711 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4712 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/aliases"));

4713 pathOffset += 8;

4714

4715 var query = (req.url).query;

4716 var queryOffset = 0;

4717 var queryMap = {};

4718 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4719 parseBool(n) {

4720 if (n == "true") return true;

4721 if (n == "false") return false;

4722 if (n == null) return null;

4723 throw new core.ArgumentError("Invalid boolean: $n");

4724 }

4725 if (query.length > 0) {

4726 for (var part in query.split("&")) {

4727 var keyvalue = part.split("=");

4728 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4729 }

4730 }

4731 unittest.expect(queryMap["event"].first, unittest.equals(arg_event));

4732

4733

4734 var h = {

4735 "content-type" : "application/json; charset=utf-8",

4736 };

4737 var resp = convert.JSON.encode(buildAliases());

4738 return new async.Future.value(common_test.stringResponse(200, h, resp));

4739 }), true);

4740 res.list(arg_userKey, event: arg_event).then(unittest.expectAsync(((api.Al iases response) {

4741 checkAliases(response);

4742 })));

4743 });

4744

4745 unittest.test("method--watch", () {

4746

4747 var mock = new common_test.HttpServerMock();

4748 api.UsersAliasesResourceApi res = new api.AdminApi(mock).users.aliases;

4749 var arg_request = buildChannel();

4750 var arg_userKey = "foo";

4751 var arg_event = "foo";

4752 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4753 var obj = new api.Channel.fromJson(json);

4754 checkChannel(obj);

4755

4756 var path = (req.url).path;

4757 var pathOffset = 0;

4758 var index;

4759 var subPart;

4760 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4761 pathOffset += 20;

4762 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4763 pathOffset += 6;

4764 index = path.indexOf("/aliases/watch", pathOffset);

4765 unittest.expect(index >= 0, unittest.isTrue);

4766 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4767 pathOffset = index;

4768 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4769 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/aliases/watch"));

4770 pathOffset += 14;

4771

4772 var query = (req.url).query;

4773 var queryOffset = 0;

4774 var queryMap = {};

4775 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4776 parseBool(n) {

4777 if (n == "true") return true;

4778 if (n == "false") return false;

4779 if (n == null) return null;

4780 throw new core.ArgumentError("Invalid boolean: $n");

4781 }

4782 if (query.length > 0) {

4783 for (var part in query.split("&")) {

4784 var keyvalue = part.split("=");

4785 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4786 }

4787 }

4788 unittest.expect(queryMap["event"].first, unittest.equals(arg_event));

4789

4790

4791 var h = {

4792 "content-type" : "application/json; charset=utf-8",

4793 };

4794 var resp = convert.JSON.encode(buildChannel());

4795 return new async.Future.value(common_test.stringResponse(200, h, resp));

4796 }), true);

4797 res.watch(arg_request, arg_userKey, event: arg_event).then(unittest.expect Async(((api.Channel response) {

4798 checkChannel(response);

4799 })));

4800 });

4801

4802 });

4803

4804

4805 unittest.group("resource-UsersPhotosResourceApi", () {

4806 unittest.test("method--delete", () {

4807

4808 var mock = new common_test.HttpServerMock();

4809 api.UsersPhotosResourceApi res = new api.AdminApi(mock).users.photos;

4810 var arg_userKey = "foo";

4811 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4812 var path = (req.url).path;

4813 var pathOffset = 0;

4814 var index;

4815 var subPart;

4816 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4817 pathOffset += 20;

4818 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4819 pathOffset += 6;

4820 index = path.indexOf("/photos/thumbnail", pathOffset);

4821 unittest.expect(index >= 0, unittest.isTrue);

4822 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4823 pathOffset = index;

4824 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4825 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/photos/thumbnail"));

4826 pathOffset += 17;

4827

4828 var query = (req.url).query;

4829 var queryOffset = 0;

4830 var queryMap = {};

4831 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4832 parseBool(n) {

4833 if (n == "true") return true;

4834 if (n == "false") return false;

4835 if (n == null) return null;

4836 throw new core.ArgumentError("Invalid boolean: $n");

4837 }

4838 if (query.length > 0) {

4839 for (var part in query.split("&")) {

4840 var keyvalue = part.split("=");

4841 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4842 }

4843 }

4844

4845

4846 var h = {

4847 "content-type" : "application/json; charset=utf-8",

4848 };

4849 var resp = "";

4850 return new async.Future.value(common_test.stringResponse(200, h, resp));

4851 }), true);

4852 res.delete(arg_userKey).then(unittest.expectAsync((_) {}));

4853 });

4854

4855 unittest.test("method--get", () {

4856

4857 var mock = new common_test.HttpServerMock();

4858 api.UsersPhotosResourceApi res = new api.AdminApi(mock).users.photos;

4859 var arg_userKey = "foo";

4860 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4861 var path = (req.url).path;

4862 var pathOffset = 0;

4863 var index;

4864 var subPart;

4865 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4866 pathOffset += 20;

4867 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4868 pathOffset += 6;

4869 index = path.indexOf("/photos/thumbnail", pathOffset);

4870 unittest.expect(index >= 0, unittest.isTrue);

4871 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4872 pathOffset = index;

4873 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4874 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/photos/thumbnail"));

4875 pathOffset += 17;

4876

4877 var query = (req.url).query;

4878 var queryOffset = 0;

4879 var queryMap = {};

4880 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4881 parseBool(n) {

4882 if (n == "true") return true;

4883 if (n == "false") return false;

4884 if (n == null) return null;

4885 throw new core.ArgumentError("Invalid boolean: $n");

4886 }

4887 if (query.length > 0) {

4888 for (var part in query.split("&")) {

4889 var keyvalue = part.split("=");

4890 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4891 }

4892 }

4893

4894

4895 var h = {

4896 "content-type" : "application/json; charset=utf-8",

4897 };

4898 var resp = convert.JSON.encode(buildUserPhoto());

4899 return new async.Future.value(common_test.stringResponse(200, h, resp));

4900 }), true);

4901 res.get(arg_userKey).then(unittest.expectAsync(((api.UserPhoto response) {

4902 checkUserPhoto(response);

4903 })));

4904 });

4905

4906 unittest.test("method--patch", () {

4907

4908 var mock = new common_test.HttpServerMock();

4909 api.UsersPhotosResourceApi res = new api.AdminApi(mock).users.photos;

4910 var arg_request = buildUserPhoto();

4911 var arg_userKey = "foo";

4912 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4913 var obj = new api.UserPhoto.fromJson(json);

4914 checkUserPhoto(obj);

4915

4916 var path = (req.url).path;

4917 var pathOffset = 0;

4918 var index;

4919 var subPart;

4920 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4921 pathOffset += 20;

4922 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4923 pathOffset += 6;

4924 index = path.indexOf("/photos/thumbnail", pathOffset);

4925 unittest.expect(index >= 0, unittest.isTrue);

4926 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4927 pathOffset = index;

4928 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4929 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/photos/thumbnail"));

4930 pathOffset += 17;

4931

4932 var query = (req.url).query;

4933 var queryOffset = 0;

4934 var queryMap = {};

4935 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4936 parseBool(n) {

4937 if (n == "true") return true;

4938 if (n == "false") return false;

4939 if (n == null) return null;

4940 throw new core.ArgumentError("Invalid boolean: $n");

4941 }

4942 if (query.length > 0) {

4943 for (var part in query.split("&")) {

4944 var keyvalue = part.split("=");

4945 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4946 }

4947 }

4948

4949

4950 var h = {

4951 "content-type" : "application/json; charset=utf-8",

4952 };

4953 var resp = convert.JSON.encode(buildUserPhoto());

4954 return new async.Future.value(common_test.stringResponse(200, h, resp));

4955 }), true);

4956 res.patch(arg_request, arg_userKey).then(unittest.expectAsync(((api.UserPh oto response) {

4957 checkUserPhoto(response);

4958 })));

4959 });

4960

4961 unittest.test("method--update", () {

4962

4963 var mock = new common_test.HttpServerMock();

4964 api.UsersPhotosResourceApi res = new api.AdminApi(mock).users.photos;

4965 var arg_request = buildUserPhoto();

4966 var arg_userKey = "foo";

4967 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4968 var obj = new api.UserPhoto.fromJson(json);

4969 checkUserPhoto(obj);

4970

4971 var path = (req.url).path;

4972 var pathOffset = 0;

4973 var index;

4974 var subPart;

4975 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

4976 pathOffset += 20;

4977 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

4978 pathOffset += 6;

4979 index = path.indexOf("/photos/thumbnail", pathOffset);

4980 unittest.expect(index >= 0, unittest.isTrue);

4981 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4982 pathOffset = index;

4983 unittest.expect(subPart, unittest.equals("$arg_userKey"));

4984 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/photos/thumbnail"));

4985 pathOffset += 17;

4986

4987 var query = (req.url).query;

4988 var queryOffset = 0;

4989 var queryMap = {};

4990 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4991 parseBool(n) {

4992 if (n == "true") return true;

4993 if (n == "false") return false;

4994 if (n == null) return null;

4995 throw new core.ArgumentError("Invalid boolean: $n");

4996 }

4997 if (query.length > 0) {

4998 for (var part in query.split("&")) {

4999 var keyvalue = part.split("=");

5000 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5001 }

5002 }

5003

5004

5005 var h = {

5006 "content-type" : "application/json; charset=utf-8",

5007 };

5008 var resp = convert.JSON.encode(buildUserPhoto());

5009 return new async.Future.value(common_test.stringResponse(200, h, resp));

5010 }), true);

5011 res.update(arg_request, arg_userKey).then(unittest.expectAsync(((api.UserP hoto response) {

5012 checkUserPhoto(response);

5013 })));

5014 });

5015

5016 });

5017

5018

5019 unittest.group("resource-VerificationCodesResourceApi", () {

5020 unittest.test("method--generate", () {

5021

5022 var mock = new common_test.HttpServerMock();

5023 api.VerificationCodesResourceApi res = new api.AdminApi(mock).verification Codes;

5024 var arg_userKey = "foo";

5025 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5026 var path = (req.url).path;

5027 var pathOffset = 0;

5028 var index;

5029 var subPart;

5030 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

5031 pathOffset += 20;

5032 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

5033 pathOffset += 6;

5034 index = path.indexOf("/verificationCodes/generate", pathOffset);

5035 unittest.expect(index >= 0, unittest.isTrue);

5036 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5037 pathOffset = index;

5038 unittest.expect(subPart, unittest.equals("$arg_userKey"));

5039 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/verificationCodes/generate"));

5040 pathOffset += 27;

5041

5042 var query = (req.url).query;

5043 var queryOffset = 0;

5044 var queryMap = {};

5045 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5046 parseBool(n) {

5047 if (n == "true") return true;

5048 if (n == "false") return false;

5049 if (n == null) return null;

5050 throw new core.ArgumentError("Invalid boolean: $n");

5051 }

5052 if (query.length > 0) {

5053 for (var part in query.split("&")) {

5054 var keyvalue = part.split("=");

5055 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5056 }

5057 }

5058

5059

5060 var h = {

5061 "content-type" : "application/json; charset=utf-8",

5062 };

5063 var resp = "";

5064 return new async.Future.value(common_test.stringResponse(200, h, resp));

5065 }), true);

5066 res.generate(arg_userKey).then(unittest.expectAsync((_) {}));

5067 });

5068

5069 unittest.test("method--invalidate", () {

5070

5071 var mock = new common_test.HttpServerMock();

5072 api.VerificationCodesResourceApi res = new api.AdminApi(mock).verification Codes;

5073 var arg_userKey = "foo";

5074 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5075 var path = (req.url).path;

5076 var pathOffset = 0;

5077 var index;

5078 var subPart;

5079 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

5080 pathOffset += 20;

5081 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

5082 pathOffset += 6;

5083 index = path.indexOf("/verificationCodes/invalidate", pathOffset);

5084 unittest.expect(index >= 0, unittest.isTrue);

5085 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5086 pathOffset = index;

5087 unittest.expect(subPart, unittest.equals("$arg_userKey"));

5088 unittest.expect(path.substring(pathOffset, pathOffset + 29), unittest.eq uals("/verificationCodes/invalidate"));

5089 pathOffset += 29;

5090

5091 var query = (req.url).query;

5092 var queryOffset = 0;

5093 var queryMap = {};

5094 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5095 parseBool(n) {

5096 if (n == "true") return true;

5097 if (n == "false") return false;

5098 if (n == null) return null;

5099 throw new core.ArgumentError("Invalid boolean: $n");

5100 }

5101 if (query.length > 0) {

5102 for (var part in query.split("&")) {

5103 var keyvalue = part.split("=");

5104 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5105 }

5106 }

5107

5108

5109 var h = {

5110 "content-type" : "application/json; charset=utf-8",

5111 };

5112 var resp = "";

5113 return new async.Future.value(common_test.stringResponse(200, h, resp));

5114 }), true);

5115 res.invalidate(arg_userKey).then(unittest.expectAsync((_) {}));

5116 });

5117

5118 unittest.test("method--list", () {

5119

5120 var mock = new common_test.HttpServerMock();

5121 api.VerificationCodesResourceApi res = new api.AdminApi(mock).verification Codes;

5122 var arg_userKey = "foo";

5123 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

5124 var path = (req.url).path;

5125 var pathOffset = 0;

5126 var index;

5127 var subPart;

5128 unittest.expect(path.substring(pathOffset, pathOffset + 20), unittest.eq uals("/admin/directory/v1/"));

5129 pathOffset += 20;

5130 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("users/"));

5131 pathOffset += 6;

5132 index = path.indexOf("/verificationCodes", pathOffset);

5133 unittest.expect(index >= 0, unittest.isTrue);

5134 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

5135 pathOffset = index;

5136 unittest.expect(subPart, unittest.equals("$arg_userKey"));

5137 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/verificationCodes"));

5138 pathOffset += 18;

5139

5140 var query = (req.url).query;

5141 var queryOffset = 0;

5142 var queryMap = {};

5143 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

5144 parseBool(n) {

5145 if (n == "true") return true;

5146 if (n == "false") return false;

5147 if (n == null) return null;

5148 throw new core.ArgumentError("Invalid boolean: $n");

5149 }

5150 if (query.length > 0) {

5151 for (var part in query.split("&")) {

5152 var keyvalue = part.split("=");

5153 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

5154 }

5155 }

5156

5157

5158 var h = {

5159 "content-type" : "application/json; charset=utf-8",

5160 };

5161 var resp = convert.JSON.encode(buildVerificationCodes());

5162 return new async.Future.value(common_test.stringResponse(200, h, resp));

5163 }), true);

5164 res.list(arg_userKey).then(unittest.expectAsync(((api.VerificationCodes re sponse) {

5165 checkVerificationCodes(response);

5166 })));

5167 });

5168

5169 });

5170

5171

5172 }

5173

OLD	NEW