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

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

16

17

18

19 core.int buildCounterAccessConfig = 0;

20 buildAccessConfig() {

21 var o = new api.AccessConfig();

22 buildCounterAccessConfig++;

23 if (buildCounterAccessConfig < 3) {

24 o.kind = "foo";

25 o.name = "foo";

26 o.natIP = "foo";

27 o.type = "foo";

28 }

29 buildCounterAccessConfig--;

30 return o;

31 }

32

33 checkAccessConfig(api.AccessConfig o) {

34 buildCounterAccessConfig++;

35 if (buildCounterAccessConfig < 3) {

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

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

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

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

40 }

41 buildCounterAccessConfig--;

42 }

43

44 buildUnnamed839() {

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

46 o.add("foo");

47 o.add("foo");

48 return o;

49 }

50

51 checkUnnamed839(core.List<core.String> o) {

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

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

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

55 }

56

57 core.int buildCounterAddress = 0;

58 buildAddress() {

59 var o = new api.Address();

60 buildCounterAddress++;

61 if (buildCounterAddress < 3) {

62 o.address = "foo";

63 o.creationTimestamp = "foo";

64 o.description = "foo";

65 o.id = "foo";

66 o.kind = "foo";

67 o.name = "foo";

68 o.region = "foo";

69 o.selfLink = "foo";

70 o.status = "foo";

71 o.users = buildUnnamed839();

72 }

73 buildCounterAddress--;

74 return o;

75 }

76

77 checkAddress(api.Address o) {

78 buildCounterAddress++;

79 if (buildCounterAddress < 3) {

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

81 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

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

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

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

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

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

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

89 checkUnnamed839(o.users);

90 }

91 buildCounterAddress--;

92 }

93

94 buildUnnamed840() {

95 var o = new core.Map<core.String, api.AddressesScopedList>();

96 o["x"] = buildAddressesScopedList();

97 o["y"] = buildAddressesScopedList();

98 return o;

99 }

100

101 checkUnnamed840(core.Map<core.String, api.AddressesScopedList> o) {

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

103 checkAddressesScopedList(o["x"]);

104 checkAddressesScopedList(o["y"]);

105 }

106

107 core.int buildCounterAddressAggregatedList = 0;

108 buildAddressAggregatedList() {

109 var o = new api.AddressAggregatedList();

110 buildCounterAddressAggregatedList++;

111 if (buildCounterAddressAggregatedList < 3) {

112 o.id = "foo";

113 o.items = buildUnnamed840();

114 o.kind = "foo";

115 o.nextPageToken = "foo";

116 o.selfLink = "foo";

117 }

118 buildCounterAddressAggregatedList--;

119 return o;

120 }

121

122 checkAddressAggregatedList(api.AddressAggregatedList o) {

123 buildCounterAddressAggregatedList++;

124 if (buildCounterAddressAggregatedList < 3) {

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

126 checkUnnamed840(o.items);

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

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

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

130 }

131 buildCounterAddressAggregatedList--;

132 }

133

134 buildUnnamed841() {

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

136 o.add(buildAddress());

137 o.add(buildAddress());

138 return o;

139 }

140

141 checkUnnamed841(core.List<api.Address> o) {

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

143 checkAddress(o[0]);

144 checkAddress(o[1]);

145 }

146

147 core.int buildCounterAddressList = 0;

148 buildAddressList() {

149 var o = new api.AddressList();

150 buildCounterAddressList++;

151 if (buildCounterAddressList < 3) {

152 o.id = "foo";

153 o.items = buildUnnamed841();

154 o.kind = "foo";

155 o.nextPageToken = "foo";

156 o.selfLink = "foo";

157 }

158 buildCounterAddressList--;

159 return o;

160 }

161

162 checkAddressList(api.AddressList o) {

163 buildCounterAddressList++;

164 if (buildCounterAddressList < 3) {

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

166 checkUnnamed841(o.items);

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

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

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

170 }

171 buildCounterAddressList--;

172 }

173

174 buildUnnamed842() {

175 var o = new core.List<api.Address>();

176 o.add(buildAddress());

177 o.add(buildAddress());

178 return o;

179 }

180

181 checkUnnamed842(core.List<api.Address> o) {

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

183 checkAddress(o[0]);

184 checkAddress(o[1]);

185 }

186

187 core.int buildCounterAddressesScopedListWarningData = 0;

188 buildAddressesScopedListWarningData() {

189 var o = new api.AddressesScopedListWarningData();

190 buildCounterAddressesScopedListWarningData++;

191 if (buildCounterAddressesScopedListWarningData < 3) {

192 o.key = "foo";

193 o.value = "foo";

194 }

195 buildCounterAddressesScopedListWarningData--;

196 return o;

197 }

198

199 checkAddressesScopedListWarningData(api.AddressesScopedListWarningData o) {

200 buildCounterAddressesScopedListWarningData++;

201 if (buildCounterAddressesScopedListWarningData < 3) {

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

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

204 }

205 buildCounterAddressesScopedListWarningData--;

206 }

207

208 buildUnnamed843() {

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

210 o.add(buildAddressesScopedListWarningData());

211 o.add(buildAddressesScopedListWarningData());

212 return o;

213 }

214

215 checkUnnamed843(core.List<api.AddressesScopedListWarningData> o) {

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

217 checkAddressesScopedListWarningData(o[0]);

218 checkAddressesScopedListWarningData(o[1]);

219 }

220

221 core.int buildCounterAddressesScopedListWarning = 0;

222 buildAddressesScopedListWarning() {

223 var o = new api.AddressesScopedListWarning();

224 buildCounterAddressesScopedListWarning++;

225 if (buildCounterAddressesScopedListWarning < 3) {

226 o.code = "foo";

227 o.data = buildUnnamed843();

228 o.message = "foo";

229 }

230 buildCounterAddressesScopedListWarning--;

231 return o;

232 }

233

234 checkAddressesScopedListWarning(api.AddressesScopedListWarning o) {

235 buildCounterAddressesScopedListWarning++;

236 if (buildCounterAddressesScopedListWarning < 3) {

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

238 checkUnnamed843(o.data);

239 unittest.expect(o.message, unittest.equals('foo'));

240 }

241 buildCounterAddressesScopedListWarning--;

242 }

243

244 core.int buildCounterAddressesScopedList = 0;

245 buildAddressesScopedList() {

246 var o = new api.AddressesScopedList();

247 buildCounterAddressesScopedList++;

248 if (buildCounterAddressesScopedList < 3) {

249 o.addresses = buildUnnamed842();

250 o.warning = buildAddressesScopedListWarning();

251 }

252 buildCounterAddressesScopedList--;

253 return o;

254 }

255

256 checkAddressesScopedList(api.AddressesScopedList o) {

257 buildCounterAddressesScopedList++;

258 if (buildCounterAddressesScopedList < 3) {

259 checkUnnamed842(o.addresses);

260 checkAddressesScopedListWarning(o.warning);

261 }

262 buildCounterAddressesScopedList--;

263 }

264

265 buildUnnamed844() {

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

267 o.add("foo");

268 o.add("foo");

269 return o;

270 }

271

272 checkUnnamed844(core.List<core.String> o) {

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

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

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

276 }

277

278 core.int buildCounterAttachedDisk = 0;

279 buildAttachedDisk() {

280 var o = new api.AttachedDisk();

281 buildCounterAttachedDisk++;

282 if (buildCounterAttachedDisk < 3) {

283 o.autoDelete = true;

284 o.boot = true;

285 o.deviceName = "foo";

286 o.index = 42;

287 o.initializeParams = buildAttachedDiskInitializeParams();

288 o.kind = "foo";

289 o.licenses = buildUnnamed844();

290 o.mode = "foo";

291 o.source = "foo";

292 o.type = "foo";

293 }

294 buildCounterAttachedDisk--;

295 return o;

296 }

297

298 checkAttachedDisk(api.AttachedDisk o) {

299 buildCounterAttachedDisk++;

300 if (buildCounterAttachedDisk < 3) {

301 unittest.expect(o.autoDelete, unittest.isTrue);

302 unittest.expect(o.boot, unittest.isTrue);

303 unittest.expect(o.deviceName, unittest.equals('foo'));

304 unittest.expect(o.index, unittest.equals(42));

305 checkAttachedDiskInitializeParams(o.initializeParams);

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

307 checkUnnamed844(o.licenses);

308 unittest.expect(o.mode, unittest.equals('foo'));

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

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

311 }

312 buildCounterAttachedDisk--;

313 }

314

315 core.int buildCounterAttachedDiskInitializeParams = 0;

316 buildAttachedDiskInitializeParams() {

317 var o = new api.AttachedDiskInitializeParams();

318 buildCounterAttachedDiskInitializeParams++;

319 if (buildCounterAttachedDiskInitializeParams < 3) {

320 o.diskName = "foo";

321 o.diskSizeGb = "foo";

322 o.diskType = "foo";

323 o.sourceImage = "foo";

324 }

325 buildCounterAttachedDiskInitializeParams--;

326 return o;

327 }

328

329 checkAttachedDiskInitializeParams(api.AttachedDiskInitializeParams o) {

330 buildCounterAttachedDiskInitializeParams++;

331 if (buildCounterAttachedDiskInitializeParams < 3) {

332 unittest.expect(o.diskName, unittest.equals('foo'));

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

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

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

336 }

337 buildCounterAttachedDiskInitializeParams--;

338 }

339

340 core.int buildCounterBackend = 0;

341 buildBackend() {

342 var o = new api.Backend();

343 buildCounterBackend++;

344 if (buildCounterBackend < 3) {

345 o.balancingMode = "foo";

346 o.capacityScaler = 42.0;

347 o.description = "foo";

348 o.group = "foo";

349 o.maxRate = 42;

350 o.maxRatePerInstance = 42.0;

351 o.maxUtilization = 42.0;

352 }

353 buildCounterBackend--;

354 return o;

355 }

356

357 checkBackend(api.Backend o) {

358 buildCounterBackend++;

359 if (buildCounterBackend < 3) {

360 unittest.expect(o.balancingMode, unittest.equals('foo'));

361 unittest.expect(o.capacityScaler, unittest.equals(42.0));

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

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

364 unittest.expect(o.maxRate, unittest.equals(42));

365 unittest.expect(o.maxRatePerInstance, unittest.equals(42.0));

366 unittest.expect(o.maxUtilization, unittest.equals(42.0));

367 }

368 buildCounterBackend--;

369 }

370

371 buildUnnamed845() {

372 var o = new core.List<api.Backend>();

373 o.add(buildBackend());

374 o.add(buildBackend());

375 return o;

376 }

377

378 checkUnnamed845(core.List<api.Backend> o) {

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

380 checkBackend(o[0]);

381 checkBackend(o[1]);

382 }

383

384 buildUnnamed846() {

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

386 o.add("foo");

387 o.add("foo");

388 return o;

389 }

390

391 checkUnnamed846(core.List<core.String> o) {

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

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

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

395 }

396

397 core.int buildCounterBackendService = 0;

398 buildBackendService() {

399 var o = new api.BackendService();

400 buildCounterBackendService++;

401 if (buildCounterBackendService < 3) {

402 o.backends = buildUnnamed845();

403 o.creationTimestamp = "foo";

404 o.description = "foo";

405 o.fingerprint = "foo";

406 o.healthChecks = buildUnnamed846();

407 o.id = "foo";

408 o.kind = "foo";

409 o.name = "foo";

410 o.port = 42;

411 o.portName = "foo";

412 o.protocol = "foo";

413 o.selfLink = "foo";

414 o.timeoutSec = 42;

415 }

416 buildCounterBackendService--;

417 return o;

418 }

419

420 checkBackendService(api.BackendService o) {

421 buildCounterBackendService++;

422 if (buildCounterBackendService < 3) {

423 checkUnnamed845(o.backends);

424 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

426 unittest.expect(o.fingerprint, unittest.equals('foo'));

427 checkUnnamed846(o.healthChecks);

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

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

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

431 unittest.expect(o.port, unittest.equals(42));

432 unittest.expect(o.portName, unittest.equals('foo'));

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

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

435 unittest.expect(o.timeoutSec, unittest.equals(42));

436 }

437 buildCounterBackendService--;

438 }

439

440 buildUnnamed847() {

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

442 o.add(buildHealthStatus());

443 o.add(buildHealthStatus());

444 return o;

445 }

446

447 checkUnnamed847(core.List<api.HealthStatus> o) {

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

449 checkHealthStatus(o[0]);

450 checkHealthStatus(o[1]);

451 }

452

453 core.int buildCounterBackendServiceGroupHealth = 0;

454 buildBackendServiceGroupHealth() {

455 var o = new api.BackendServiceGroupHealth();

456 buildCounterBackendServiceGroupHealth++;

457 if (buildCounterBackendServiceGroupHealth < 3) {

458 o.healthStatus = buildUnnamed847();

459 o.kind = "foo";

460 }

461 buildCounterBackendServiceGroupHealth--;

462 return o;

463 }

464

465 checkBackendServiceGroupHealth(api.BackendServiceGroupHealth o) {

466 buildCounterBackendServiceGroupHealth++;

467 if (buildCounterBackendServiceGroupHealth < 3) {

468 checkUnnamed847(o.healthStatus);

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

470 }

471 buildCounterBackendServiceGroupHealth--;

472 }

473

474 buildUnnamed848() {

475 var o = new core.List<api.BackendService>();

476 o.add(buildBackendService());

477 o.add(buildBackendService());

478 return o;

479 }

480

481 checkUnnamed848(core.List<api.BackendService> o) {

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

483 checkBackendService(o[0]);

484 checkBackendService(o[1]);

485 }

486

487 core.int buildCounterBackendServiceList = 0;

488 buildBackendServiceList() {

489 var o = new api.BackendServiceList();

490 buildCounterBackendServiceList++;

491 if (buildCounterBackendServiceList < 3) {

492 o.id = "foo";

493 o.items = buildUnnamed848();

494 o.kind = "foo";

495 o.nextPageToken = "foo";

496 o.selfLink = "foo";

497 }

498 buildCounterBackendServiceList--;

499 return o;

500 }

501

502 checkBackendServiceList(api.BackendServiceList o) {

503 buildCounterBackendServiceList++;

504 if (buildCounterBackendServiceList < 3) {

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

506 checkUnnamed848(o.items);

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

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

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

510 }

511 buildCounterBackendServiceList--;

512 }

513

514 core.int buildCounterDeprecationStatus = 0;

515 buildDeprecationStatus() {

516 var o = new api.DeprecationStatus();

517 buildCounterDeprecationStatus++;

518 if (buildCounterDeprecationStatus < 3) {

519 o.deleted = "foo";

520 o.deprecated = "foo";

521 o.obsolete = "foo";

522 o.replacement = "foo";

523 o.state = "foo";

524 }

525 buildCounterDeprecationStatus--;

526 return o;

527 }

528

529 checkDeprecationStatus(api.DeprecationStatus o) {

530 buildCounterDeprecationStatus++;

531 if (buildCounterDeprecationStatus < 3) {

532 unittest.expect(o.deleted, unittest.equals('foo'));

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

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

535 unittest.expect(o.replacement, unittest.equals('foo'));

536 unittest.expect(o.state, unittest.equals('foo'));

537 }

538 buildCounterDeprecationStatus--;

539 }

540

541 buildUnnamed849() {

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

543 o.add("foo");

544 o.add("foo");

545 return o;

546 }

547

548 checkUnnamed849(core.List<core.String> o) {

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

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

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

552 }

553

554 core.int buildCounterDisk = 0;

555 buildDisk() {

556 var o = new api.Disk();

557 buildCounterDisk++;

558 if (buildCounterDisk < 3) {

559 o.creationTimestamp = "foo";

560 o.description = "foo";

561 o.id = "foo";

562 o.kind = "foo";

563 o.licenses = buildUnnamed849();

564 o.name = "foo";

565 o.options = "foo";

566 o.selfLink = "foo";

567 o.sizeGb = "foo";

568 o.sourceImage = "foo";

569 o.sourceImageId = "foo";

570 o.sourceSnapshot = "foo";

571 o.sourceSnapshotId = "foo";

572 o.status = "foo";

573 o.type = "foo";

574 o.zone = "foo";

575 }

576 buildCounterDisk--;

577 return o;

578 }

579

580 checkDisk(api.Disk o) {

581 buildCounterDisk++;

582 if (buildCounterDisk < 3) {

583 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

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

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

587 checkUnnamed849(o.licenses);

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

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

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

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

592 unittest.expect(o.sourceImage, unittest.equals('foo'));

593 unittest.expect(o.sourceImageId, unittest.equals('foo'));

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

595 unittest.expect(o.sourceSnapshotId, unittest.equals('foo'));

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

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

598 unittest.expect(o.zone, unittest.equals('foo'));

599 }

600 buildCounterDisk--;

601 }

602

603 buildUnnamed850() {

604 var o = new core.Map<core.String, api.DisksScopedList>();

605 o["x"] = buildDisksScopedList();

606 o["y"] = buildDisksScopedList();

607 return o;

608 }

609

610 checkUnnamed850(core.Map<core.String, api.DisksScopedList> o) {

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

612 checkDisksScopedList(o["x"]);

613 checkDisksScopedList(o["y"]);

614 }

615

616 core.int buildCounterDiskAggregatedList = 0;

617 buildDiskAggregatedList() {

618 var o = new api.DiskAggregatedList();

619 buildCounterDiskAggregatedList++;

620 if (buildCounterDiskAggregatedList < 3) {

621 o.id = "foo";

622 o.items = buildUnnamed850();

623 o.kind = "foo";

624 o.nextPageToken = "foo";

625 o.selfLink = "foo";

626 }

627 buildCounterDiskAggregatedList--;

628 return o;

629 }

630

631 checkDiskAggregatedList(api.DiskAggregatedList o) {

632 buildCounterDiskAggregatedList++;

633 if (buildCounterDiskAggregatedList < 3) {

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

635 checkUnnamed850(o.items);

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

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

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

639 }

640 buildCounterDiskAggregatedList--;

641 }

642

643 buildUnnamed851() {

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

645 o.add(buildDisk());

646 o.add(buildDisk());

647 return o;

648 }

649

650 checkUnnamed851(core.List<api.Disk> o) {

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

652 checkDisk(o[0]);

653 checkDisk(o[1]);

654 }

655

656 core.int buildCounterDiskList = 0;

657 buildDiskList() {

658 var o = new api.DiskList();

659 buildCounterDiskList++;

660 if (buildCounterDiskList < 3) {

661 o.id = "foo";

662 o.items = buildUnnamed851();

663 o.kind = "foo";

664 o.nextPageToken = "foo";

665 o.selfLink = "foo";

666 }

667 buildCounterDiskList--;

668 return o;

669 }

670

671 checkDiskList(api.DiskList o) {

672 buildCounterDiskList++;

673 if (buildCounterDiskList < 3) {

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

675 checkUnnamed851(o.items);

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

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

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

679 }

680 buildCounterDiskList--;

681 }

682

683 core.int buildCounterDiskType = 0;

684 buildDiskType() {

685 var o = new api.DiskType();

686 buildCounterDiskType++;

687 if (buildCounterDiskType < 3) {

688 o.creationTimestamp = "foo";

689 o.defaultDiskSizeGb = "foo";

690 o.deprecated = buildDeprecationStatus();

691 o.description = "foo";

692 o.id = "foo";

693 o.kind = "foo";

694 o.name = "foo";

695 o.selfLink = "foo";

696 o.validDiskSize = "foo";

697 o.zone = "foo";

698 }

699 buildCounterDiskType--;

700 return o;

701 }

702

703 checkDiskType(api.DiskType o) {

704 buildCounterDiskType++;

705 if (buildCounterDiskType < 3) {

706 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

707 unittest.expect(o.defaultDiskSizeGb, unittest.equals('foo'));

708 checkDeprecationStatus(o.deprecated);

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

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

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

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

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

714 unittest.expect(o.validDiskSize, unittest.equals('foo'));

715 unittest.expect(o.zone, unittest.equals('foo'));

716 }

717 buildCounterDiskType--;

718 }

719

720 buildUnnamed852() {

721 var o = new core.Map<core.String, api.DiskTypesScopedList>();

722 o["x"] = buildDiskTypesScopedList();

723 o["y"] = buildDiskTypesScopedList();

724 return o;

725 }

726

727 checkUnnamed852(core.Map<core.String, api.DiskTypesScopedList> o) {

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

729 checkDiskTypesScopedList(o["x"]);

730 checkDiskTypesScopedList(o["y"]);

731 }

732

733 core.int buildCounterDiskTypeAggregatedList = 0;

734 buildDiskTypeAggregatedList() {

735 var o = new api.DiskTypeAggregatedList();

736 buildCounterDiskTypeAggregatedList++;

737 if (buildCounterDiskTypeAggregatedList < 3) {

738 o.id = "foo";

739 o.items = buildUnnamed852();

740 o.kind = "foo";

741 o.nextPageToken = "foo";

742 o.selfLink = "foo";

743 }

744 buildCounterDiskTypeAggregatedList--;

745 return o;

746 }

747

748 checkDiskTypeAggregatedList(api.DiskTypeAggregatedList o) {

749 buildCounterDiskTypeAggregatedList++;

750 if (buildCounterDiskTypeAggregatedList < 3) {

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

752 checkUnnamed852(o.items);

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

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

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

756 }

757 buildCounterDiskTypeAggregatedList--;

758 }

759

760 buildUnnamed853() {

761 var o = new core.List<api.DiskType>();

762 o.add(buildDiskType());

763 o.add(buildDiskType());

764 return o;

765 }

766

767 checkUnnamed853(core.List<api.DiskType> o) {

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

769 checkDiskType(o[0]);

770 checkDiskType(o[1]);

771 }

772

773 core.int buildCounterDiskTypeList = 0;

774 buildDiskTypeList() {

775 var o = new api.DiskTypeList();

776 buildCounterDiskTypeList++;

777 if (buildCounterDiskTypeList < 3) {

778 o.id = "foo";

779 o.items = buildUnnamed853();

780 o.kind = "foo";

781 o.nextPageToken = "foo";

782 o.selfLink = "foo";

783 }

784 buildCounterDiskTypeList--;

785 return o;

786 }

787

788 checkDiskTypeList(api.DiskTypeList o) {

789 buildCounterDiskTypeList++;

790 if (buildCounterDiskTypeList < 3) {

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

792 checkUnnamed853(o.items);

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

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

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

796 }

797 buildCounterDiskTypeList--;

798 }

799

800 buildUnnamed854() {

801 var o = new core.List<api.DiskType>();

802 o.add(buildDiskType());

803 o.add(buildDiskType());

804 return o;

805 }

806

807 checkUnnamed854(core.List<api.DiskType> o) {

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

809 checkDiskType(o[0]);

810 checkDiskType(o[1]);

811 }

812

813 core.int buildCounterDiskTypesScopedListWarningData = 0;

814 buildDiskTypesScopedListWarningData() {

815 var o = new api.DiskTypesScopedListWarningData();

816 buildCounterDiskTypesScopedListWarningData++;

817 if (buildCounterDiskTypesScopedListWarningData < 3) {

818 o.key = "foo";

819 o.value = "foo";

820 }

821 buildCounterDiskTypesScopedListWarningData--;

822 return o;

823 }

824

825 checkDiskTypesScopedListWarningData(api.DiskTypesScopedListWarningData o) {

826 buildCounterDiskTypesScopedListWarningData++;

827 if (buildCounterDiskTypesScopedListWarningData < 3) {

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

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

830 }

831 buildCounterDiskTypesScopedListWarningData--;

832 }

833

834 buildUnnamed855() {

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

836 o.add(buildDiskTypesScopedListWarningData());

837 o.add(buildDiskTypesScopedListWarningData());

838 return o;

839 }

840

841 checkUnnamed855(core.List<api.DiskTypesScopedListWarningData> o) {

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

843 checkDiskTypesScopedListWarningData(o[0]);

844 checkDiskTypesScopedListWarningData(o[1]);

845 }

846

847 core.int buildCounterDiskTypesScopedListWarning = 0;

848 buildDiskTypesScopedListWarning() {

849 var o = new api.DiskTypesScopedListWarning();

850 buildCounterDiskTypesScopedListWarning++;

851 if (buildCounterDiskTypesScopedListWarning < 3) {

852 o.code = "foo";

853 o.data = buildUnnamed855();

854 o.message = "foo";

855 }

856 buildCounterDiskTypesScopedListWarning--;

857 return o;

858 }

859

860 checkDiskTypesScopedListWarning(api.DiskTypesScopedListWarning o) {

861 buildCounterDiskTypesScopedListWarning++;

862 if (buildCounterDiskTypesScopedListWarning < 3) {

863 unittest.expect(o.code, unittest.equals('foo'));

864 checkUnnamed855(o.data);

865 unittest.expect(o.message, unittest.equals('foo'));

866 }

867 buildCounterDiskTypesScopedListWarning--;

868 }

869

870 core.int buildCounterDiskTypesScopedList = 0;

871 buildDiskTypesScopedList() {

872 var o = new api.DiskTypesScopedList();

873 buildCounterDiskTypesScopedList++;

874 if (buildCounterDiskTypesScopedList < 3) {

875 o.diskTypes = buildUnnamed854();

876 o.warning = buildDiskTypesScopedListWarning();

877 }

878 buildCounterDiskTypesScopedList--;

879 return o;

880 }

881

882 checkDiskTypesScopedList(api.DiskTypesScopedList o) {

883 buildCounterDiskTypesScopedList++;

884 if (buildCounterDiskTypesScopedList < 3) {

885 checkUnnamed854(o.diskTypes);

886 checkDiskTypesScopedListWarning(o.warning);

887 }

888 buildCounterDiskTypesScopedList--;

889 }

890

891 buildUnnamed856() {

892 var o = new core.List<api.Disk>();

893 o.add(buildDisk());

894 o.add(buildDisk());

895 return o;

896 }

897

898 checkUnnamed856(core.List<api.Disk> o) {

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

900 checkDisk(o[0]);

901 checkDisk(o[1]);

902 }

903

904 core.int buildCounterDisksScopedListWarningData = 0;

905 buildDisksScopedListWarningData() {

906 var o = new api.DisksScopedListWarningData();

907 buildCounterDisksScopedListWarningData++;

908 if (buildCounterDisksScopedListWarningData < 3) {

909 o.key = "foo";

910 o.value = "foo";

911 }

912 buildCounterDisksScopedListWarningData--;

913 return o;

914 }

915

916 checkDisksScopedListWarningData(api.DisksScopedListWarningData o) {

917 buildCounterDisksScopedListWarningData++;

918 if (buildCounterDisksScopedListWarningData < 3) {

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

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

921 }

922 buildCounterDisksScopedListWarningData--;

923 }

924

925 buildUnnamed857() {

926 var o = new core.List<api.DisksScopedListWarningData>();

927 o.add(buildDisksScopedListWarningData());

928 o.add(buildDisksScopedListWarningData());

929 return o;

930 }

931

932 checkUnnamed857(core.List<api.DisksScopedListWarningData> o) {

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

934 checkDisksScopedListWarningData(o[0]);

935 checkDisksScopedListWarningData(o[1]);

936 }

937

938 core.int buildCounterDisksScopedListWarning = 0;

939 buildDisksScopedListWarning() {

940 var o = new api.DisksScopedListWarning();

941 buildCounterDisksScopedListWarning++;

942 if (buildCounterDisksScopedListWarning < 3) {

943 o.code = "foo";

944 o.data = buildUnnamed857();

945 o.message = "foo";

946 }

947 buildCounterDisksScopedListWarning--;

948 return o;

949 }

950

951 checkDisksScopedListWarning(api.DisksScopedListWarning o) {

952 buildCounterDisksScopedListWarning++;

953 if (buildCounterDisksScopedListWarning < 3) {

954 unittest.expect(o.code, unittest.equals('foo'));

955 checkUnnamed857(o.data);

956 unittest.expect(o.message, unittest.equals('foo'));

957 }

958 buildCounterDisksScopedListWarning--;

959 }

960

961 core.int buildCounterDisksScopedList = 0;

962 buildDisksScopedList() {

963 var o = new api.DisksScopedList();

964 buildCounterDisksScopedList++;

965 if (buildCounterDisksScopedList < 3) {

966 o.disks = buildUnnamed856();

967 o.warning = buildDisksScopedListWarning();

968 }

969 buildCounterDisksScopedList--;

970 return o;

971 }

972

973 checkDisksScopedList(api.DisksScopedList o) {

974 buildCounterDisksScopedList++;

975 if (buildCounterDisksScopedList < 3) {

976 checkUnnamed856(o.disks);

977 checkDisksScopedListWarning(o.warning);

978 }

979 buildCounterDisksScopedList--;

980 }

981

982 buildUnnamed858() {

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

984 o.add("foo");

985 o.add("foo");

986 return o;

987 }

988

989 checkUnnamed858(core.List<core.String> o) {

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

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

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

993 }

994

995 core.int buildCounterFirewallAllowed = 0;

996 buildFirewallAllowed() {

997 var o = new api.FirewallAllowed();

998 buildCounterFirewallAllowed++;

999 if (buildCounterFirewallAllowed < 3) {

1000 o.IPProtocol = "foo";

1001 o.ports = buildUnnamed858();

1002 }

1003 buildCounterFirewallAllowed--;

1004 return o;

1005 }

1006

1007 checkFirewallAllowed(api.FirewallAllowed o) {

1008 buildCounterFirewallAllowed++;

1009 if (buildCounterFirewallAllowed < 3) {

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

1011 checkUnnamed858(o.ports);

1012 }

1013 buildCounterFirewallAllowed--;

1014 }

1015

1016 buildUnnamed859() {

1017 var o = new core.List<api.FirewallAllowed>();

1018 o.add(buildFirewallAllowed());

1019 o.add(buildFirewallAllowed());

1020 return o;

1021 }

1022

1023 checkUnnamed859(core.List<api.FirewallAllowed> o) {

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

1025 checkFirewallAllowed(o[0]);

1026 checkFirewallAllowed(o[1]);

1027 }

1028

1029 buildUnnamed860() {

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

1031 o.add("foo");

1032 o.add("foo");

1033 return o;

1034 }

1035

1036 checkUnnamed860(core.List<core.String> o) {

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

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

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

1040 }

1041

1042 buildUnnamed861() {

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

1044 o.add("foo");

1045 o.add("foo");

1046 return o;

1047 }

1048

1049 checkUnnamed861(core.List<core.String> o) {

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

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

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

1053 }

1054

1055 buildUnnamed862() {

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

1057 o.add("foo");

1058 o.add("foo");

1059 return o;

1060 }

1061

1062 checkUnnamed862(core.List<core.String> o) {

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

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

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

1066 }

1067

1068 core.int buildCounterFirewall = 0;

1069 buildFirewall() {

1070 var o = new api.Firewall();

1071 buildCounterFirewall++;

1072 if (buildCounterFirewall < 3) {

1073 o.allowed = buildUnnamed859();

1074 o.creationTimestamp = "foo";

1075 o.description = "foo";

1076 o.id = "foo";

1077 o.kind = "foo";

1078 o.name = "foo";

1079 o.network = "foo";

1080 o.selfLink = "foo";

1081 o.sourceRanges = buildUnnamed860();

1082 o.sourceTags = buildUnnamed861();

1083 o.targetTags = buildUnnamed862();

1084 }

1085 buildCounterFirewall--;

1086 return o;

1087 }

1088

1089 checkFirewall(api.Firewall o) {

1090 buildCounterFirewall++;

1091 if (buildCounterFirewall < 3) {

1092 checkUnnamed859(o.allowed);

1093 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

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

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

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

1098 unittest.expect(o.network, unittest.equals('foo'));

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

1100 checkUnnamed860(o.sourceRanges);

1101 checkUnnamed861(o.sourceTags);

1102 checkUnnamed862(o.targetTags);

1103 }

1104 buildCounterFirewall--;

1105 }

1106

1107 buildUnnamed863() {

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

1109 o.add(buildFirewall());

1110 o.add(buildFirewall());

1111 return o;

1112 }

1113

1114 checkUnnamed863(core.List<api.Firewall> o) {

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

1116 checkFirewall(o[0]);

1117 checkFirewall(o[1]);

1118 }

1119

1120 core.int buildCounterFirewallList = 0;

1121 buildFirewallList() {

1122 var o = new api.FirewallList();

1123 buildCounterFirewallList++;

1124 if (buildCounterFirewallList < 3) {

1125 o.id = "foo";

1126 o.items = buildUnnamed863();

1127 o.kind = "foo";

1128 o.nextPageToken = "foo";

1129 o.selfLink = "foo";

1130 }

1131 buildCounterFirewallList--;

1132 return o;

1133 }

1134

1135 checkFirewallList(api.FirewallList o) {

1136 buildCounterFirewallList++;

1137 if (buildCounterFirewallList < 3) {

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

1139 checkUnnamed863(o.items);

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

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

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

1143 }

1144 buildCounterFirewallList--;

1145 }

1146

1147 core.int buildCounterForwardingRule = 0;

1148 buildForwardingRule() {

1149 var o = new api.ForwardingRule();

1150 buildCounterForwardingRule++;

1151 if (buildCounterForwardingRule < 3) {

1152 o.IPAddress = "foo";

1153 o.IPProtocol = "foo";

1154 o.creationTimestamp = "foo";

1155 o.description = "foo";

1156 o.id = "foo";

1157 o.kind = "foo";

1158 o.name = "foo";

1159 o.portRange = "foo";

1160 o.region = "foo";

1161 o.selfLink = "foo";

1162 o.target = "foo";

1163 }

1164 buildCounterForwardingRule--;

1165 return o;

1166 }

1167

1168 checkForwardingRule(api.ForwardingRule o) {

1169 buildCounterForwardingRule++;

1170 if (buildCounterForwardingRule < 3) {

1171 unittest.expect(o.IPAddress, unittest.equals('foo'));

1172 unittest.expect(o.IPProtocol, unittest.equals('foo'));

1173 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

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

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

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

1178 unittest.expect(o.portRange, unittest.equals('foo'));

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

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

1181 unittest.expect(o.target, unittest.equals('foo'));

1182 }

1183 buildCounterForwardingRule--;

1184 }

1185

1186 buildUnnamed864() {

1187 var o = new core.Map<core.String, api.ForwardingRulesScopedList>();

1188 o["x"] = buildForwardingRulesScopedList();

1189 o["y"] = buildForwardingRulesScopedList();

1190 return o;

1191 }

1192

1193 checkUnnamed864(core.Map<core.String, api.ForwardingRulesScopedList> o) {

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

1195 checkForwardingRulesScopedList(o["x"]);

1196 checkForwardingRulesScopedList(o["y"]);

1197 }

1198

1199 core.int buildCounterForwardingRuleAggregatedList = 0;

1200 buildForwardingRuleAggregatedList() {

1201 var o = new api.ForwardingRuleAggregatedList();

1202 buildCounterForwardingRuleAggregatedList++;

1203 if (buildCounterForwardingRuleAggregatedList < 3) {

1204 o.id = "foo";

1205 o.items = buildUnnamed864();

1206 o.kind = "foo";

1207 o.nextPageToken = "foo";

1208 o.selfLink = "foo";

1209 }

1210 buildCounterForwardingRuleAggregatedList--;

1211 return o;

1212 }

1213

1214 checkForwardingRuleAggregatedList(api.ForwardingRuleAggregatedList o) {

1215 buildCounterForwardingRuleAggregatedList++;

1216 if (buildCounterForwardingRuleAggregatedList < 3) {

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

1218 checkUnnamed864(o.items);

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

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

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

1222 }

1223 buildCounterForwardingRuleAggregatedList--;

1224 }

1225

1226 buildUnnamed865() {

1227 var o = new core.List<api.ForwardingRule>();

1228 o.add(buildForwardingRule());

1229 o.add(buildForwardingRule());

1230 return o;

1231 }

1232

1233 checkUnnamed865(core.List<api.ForwardingRule> o) {

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

1235 checkForwardingRule(o[0]);

1236 checkForwardingRule(o[1]);

1237 }

1238

1239 core.int buildCounterForwardingRuleList = 0;

1240 buildForwardingRuleList() {

1241 var o = new api.ForwardingRuleList();

1242 buildCounterForwardingRuleList++;

1243 if (buildCounterForwardingRuleList < 3) {

1244 o.id = "foo";

1245 o.items = buildUnnamed865();

1246 o.kind = "foo";

1247 o.nextPageToken = "foo";

1248 o.selfLink = "foo";

1249 }

1250 buildCounterForwardingRuleList--;

1251 return o;

1252 }

1253

1254 checkForwardingRuleList(api.ForwardingRuleList o) {

1255 buildCounterForwardingRuleList++;

1256 if (buildCounterForwardingRuleList < 3) {

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

1258 checkUnnamed865(o.items);

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

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

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

1262 }

1263 buildCounterForwardingRuleList--;

1264 }

1265

1266 buildUnnamed866() {

1267 var o = new core.List<api.ForwardingRule>();

1268 o.add(buildForwardingRule());

1269 o.add(buildForwardingRule());

1270 return o;

1271 }

1272

1273 checkUnnamed866(core.List<api.ForwardingRule> o) {

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

1275 checkForwardingRule(o[0]);

1276 checkForwardingRule(o[1]);

1277 }

1278

1279 core.int buildCounterForwardingRulesScopedListWarningData = 0;

1280 buildForwardingRulesScopedListWarningData() {

1281 var o = new api.ForwardingRulesScopedListWarningData();

1282 buildCounterForwardingRulesScopedListWarningData++;

1283 if (buildCounterForwardingRulesScopedListWarningData < 3) {

1284 o.key = "foo";

1285 o.value = "foo";

1286 }

1287 buildCounterForwardingRulesScopedListWarningData--;

1288 return o;

1289 }

1290

1291 checkForwardingRulesScopedListWarningData(api.ForwardingRulesScopedListWarningDa ta o) {

1292 buildCounterForwardingRulesScopedListWarningData++;

1293 if (buildCounterForwardingRulesScopedListWarningData < 3) {

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

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

1296 }

1297 buildCounterForwardingRulesScopedListWarningData--;

1298 }

1299

1300 buildUnnamed867() {

1301 var o = new core.List<api.ForwardingRulesScopedListWarningData>();

1302 o.add(buildForwardingRulesScopedListWarningData());

1303 o.add(buildForwardingRulesScopedListWarningData());

1304 return o;

1305 }

1306

1307 checkUnnamed867(core.List<api.ForwardingRulesScopedListWarningData> o) {

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

1309 checkForwardingRulesScopedListWarningData(o[0]);

1310 checkForwardingRulesScopedListWarningData(o[1]);

1311 }

1312

1313 core.int buildCounterForwardingRulesScopedListWarning = 0;

1314 buildForwardingRulesScopedListWarning() {

1315 var o = new api.ForwardingRulesScopedListWarning();

1316 buildCounterForwardingRulesScopedListWarning++;

1317 if (buildCounterForwardingRulesScopedListWarning < 3) {

1318 o.code = "foo";

1319 o.data = buildUnnamed867();

1320 o.message = "foo";

1321 }

1322 buildCounterForwardingRulesScopedListWarning--;

1323 return o;

1324 }

1325

1326 checkForwardingRulesScopedListWarning(api.ForwardingRulesScopedListWarning o) {

1327 buildCounterForwardingRulesScopedListWarning++;

1328 if (buildCounterForwardingRulesScopedListWarning < 3) {

1329 unittest.expect(o.code, unittest.equals('foo'));

1330 checkUnnamed867(o.data);

1331 unittest.expect(o.message, unittest.equals('foo'));

1332 }

1333 buildCounterForwardingRulesScopedListWarning--;

1334 }

1335

1336 core.int buildCounterForwardingRulesScopedList = 0;

1337 buildForwardingRulesScopedList() {

1338 var o = new api.ForwardingRulesScopedList();

1339 buildCounterForwardingRulesScopedList++;

1340 if (buildCounterForwardingRulesScopedList < 3) {

1341 o.forwardingRules = buildUnnamed866();

1342 o.warning = buildForwardingRulesScopedListWarning();

1343 }

1344 buildCounterForwardingRulesScopedList--;

1345 return o;

1346 }

1347

1348 checkForwardingRulesScopedList(api.ForwardingRulesScopedList o) {

1349 buildCounterForwardingRulesScopedList++;

1350 if (buildCounterForwardingRulesScopedList < 3) {

1351 checkUnnamed866(o.forwardingRules);

1352 checkForwardingRulesScopedListWarning(o.warning);

1353 }

1354 buildCounterForwardingRulesScopedList--;

1355 }

1356

1357 core.int buildCounterHealthCheckReference = 0;

1358 buildHealthCheckReference() {

1359 var o = new api.HealthCheckReference();

1360 buildCounterHealthCheckReference++;

1361 if (buildCounterHealthCheckReference < 3) {

1362 o.healthCheck = "foo";

1363 }

1364 buildCounterHealthCheckReference--;

1365 return o;

1366 }

1367

1368 checkHealthCheckReference(api.HealthCheckReference o) {

1369 buildCounterHealthCheckReference++;

1370 if (buildCounterHealthCheckReference < 3) {

1371 unittest.expect(o.healthCheck, unittest.equals('foo'));

1372 }

1373 buildCounterHealthCheckReference--;

1374 }

1375

1376 core.int buildCounterHealthStatus = 0;

1377 buildHealthStatus() {

1378 var o = new api.HealthStatus();

1379 buildCounterHealthStatus++;

1380 if (buildCounterHealthStatus < 3) {

1381 o.healthState = "foo";

1382 o.instance = "foo";

1383 o.ipAddress = "foo";

1384 o.port = 42;

1385 }

1386 buildCounterHealthStatus--;

1387 return o;

1388 }

1389

1390 checkHealthStatus(api.HealthStatus o) {

1391 buildCounterHealthStatus++;

1392 if (buildCounterHealthStatus < 3) {

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

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

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

1396 unittest.expect(o.port, unittest.equals(42));

1397 }

1398 buildCounterHealthStatus--;

1399 }

1400

1401 buildUnnamed868() {

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

1403 o.add("foo");

1404 o.add("foo");

1405 return o;

1406 }

1407

1408 checkUnnamed868(core.List<core.String> o) {

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

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

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

1412 }

1413

1414 core.int buildCounterHostRule = 0;

1415 buildHostRule() {

1416 var o = new api.HostRule();

1417 buildCounterHostRule++;

1418 if (buildCounterHostRule < 3) {

1419 o.description = "foo";

1420 o.hosts = buildUnnamed868();

1421 o.pathMatcher = "foo";

1422 }

1423 buildCounterHostRule--;

1424 return o;

1425 }

1426

1427 checkHostRule(api.HostRule o) {

1428 buildCounterHostRule++;

1429 if (buildCounterHostRule < 3) {

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

1431 checkUnnamed868(o.hosts);

1432 unittest.expect(o.pathMatcher, unittest.equals('foo'));

1433 }

1434 buildCounterHostRule--;

1435 }

1436

1437 core.int buildCounterHttpHealthCheck = 0;

1438 buildHttpHealthCheck() {

1439 var o = new api.HttpHealthCheck();

1440 buildCounterHttpHealthCheck++;

1441 if (buildCounterHttpHealthCheck < 3) {

1442 o.checkIntervalSec = 42;

1443 o.creationTimestamp = "foo";

1444 o.description = "foo";

1445 o.healthyThreshold = 42;

1446 o.host = "foo";

1447 o.id = "foo";

1448 o.kind = "foo";

1449 o.name = "foo";

1450 o.port = 42;

1451 o.requestPath = "foo";

1452 o.selfLink = "foo";

1453 o.timeoutSec = 42;

1454 o.unhealthyThreshold = 42;

1455 }

1456 buildCounterHttpHealthCheck--;

1457 return o;

1458 }

1459

1460 checkHttpHealthCheck(api.HttpHealthCheck o) {

1461 buildCounterHttpHealthCheck++;

1462 if (buildCounterHttpHealthCheck < 3) {

1463 unittest.expect(o.checkIntervalSec, unittest.equals(42));

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

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

1466 unittest.expect(o.healthyThreshold, unittest.equals(42));

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

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

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

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

1471 unittest.expect(o.port, unittest.equals(42));

1472 unittest.expect(o.requestPath, unittest.equals('foo'));

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

1474 unittest.expect(o.timeoutSec, unittest.equals(42));

1475 unittest.expect(o.unhealthyThreshold, unittest.equals(42));

1476 }

1477 buildCounterHttpHealthCheck--;

1478 }

1479

1480 buildUnnamed869() {

1481 var o = new core.List<api.HttpHealthCheck>();

1482 o.add(buildHttpHealthCheck());

1483 o.add(buildHttpHealthCheck());

1484 return o;

1485 }

1486

1487 checkUnnamed869(core.List<api.HttpHealthCheck> o) {

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

1489 checkHttpHealthCheck(o[0]);

1490 checkHttpHealthCheck(o[1]);

1491 }

1492

1493 core.int buildCounterHttpHealthCheckList = 0;

1494 buildHttpHealthCheckList() {

1495 var o = new api.HttpHealthCheckList();

1496 buildCounterHttpHealthCheckList++;

1497 if (buildCounterHttpHealthCheckList < 3) {

1498 o.id = "foo";

1499 o.items = buildUnnamed869();

1500 o.kind = "foo";

1501 o.nextPageToken = "foo";

1502 o.selfLink = "foo";

1503 }

1504 buildCounterHttpHealthCheckList--;

1505 return o;

1506 }

1507

1508 checkHttpHealthCheckList(api.HttpHealthCheckList o) {

1509 buildCounterHttpHealthCheckList++;

1510 if (buildCounterHttpHealthCheckList < 3) {

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

1512 checkUnnamed869(o.items);

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

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

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

1516 }

1517 buildCounterHttpHealthCheckList--;

1518 }

1519

1520 buildUnnamed870() {

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

1522 o.add("foo");

1523 o.add("foo");

1524 return o;

1525 }

1526

1527 checkUnnamed870(core.List<core.String> o) {

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

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

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

1531 }

1532

1533 core.int buildCounterImageRawDisk = 0;

1534 buildImageRawDisk() {

1535 var o = new api.ImageRawDisk();

1536 buildCounterImageRawDisk++;

1537 if (buildCounterImageRawDisk < 3) {

1538 o.containerType = "foo";

1539 o.sha1Checksum = "foo";

1540 o.source = "foo";

1541 }

1542 buildCounterImageRawDisk--;

1543 return o;

1544 }

1545

1546 checkImageRawDisk(api.ImageRawDisk o) {

1547 buildCounterImageRawDisk++;

1548 if (buildCounterImageRawDisk < 3) {

1549 unittest.expect(o.containerType, unittest.equals('foo'));

1550 unittest.expect(o.sha1Checksum, unittest.equals('foo'));

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

1552 }

1553 buildCounterImageRawDisk--;

1554 }

1555

1556 core.int buildCounterImage = 0;

1557 buildImage() {

1558 var o = new api.Image();

1559 buildCounterImage++;

1560 if (buildCounterImage < 3) {

1561 o.archiveSizeBytes = "foo";

1562 o.creationTimestamp = "foo";

1563 o.deprecated = buildDeprecationStatus();

1564 o.description = "foo";

1565 o.diskSizeGb = "foo";

1566 o.id = "foo";

1567 o.kind = "foo";

1568 o.licenses = buildUnnamed870();

1569 o.name = "foo";

1570 o.rawDisk = buildImageRawDisk();

1571 o.selfLink = "foo";

1572 o.sourceDisk = "foo";

1573 o.sourceDiskId = "foo";

1574 o.sourceType = "foo";

1575 o.status = "foo";

1576 }

1577 buildCounterImage--;

1578 return o;

1579 }

1580

1581 checkImage(api.Image o) {

1582 buildCounterImage++;

1583 if (buildCounterImage < 3) {

1584 unittest.expect(o.archiveSizeBytes, unittest.equals('foo'));

1585 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

1586 checkDeprecationStatus(o.deprecated);

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

1588 unittest.expect(o.diskSizeGb, unittest.equals('foo'));

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

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

1591 checkUnnamed870(o.licenses);

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

1593 checkImageRawDisk(o.rawDisk);

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

1595 unittest.expect(o.sourceDisk, unittest.equals('foo'));

1596 unittest.expect(o.sourceDiskId, unittest.equals('foo'));

1597 unittest.expect(o.sourceType, unittest.equals('foo'));

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

1599 }

1600 buildCounterImage--;

1601 }

1602

1603 buildUnnamed871() {

1604 var o = new core.List<api.Image>();

1605 o.add(buildImage());

1606 o.add(buildImage());

1607 return o;

1608 }

1609

1610 checkUnnamed871(core.List<api.Image> o) {

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

1612 checkImage(o[0]);

1613 checkImage(o[1]);

1614 }

1615

1616 core.int buildCounterImageList = 0;

1617 buildImageList() {

1618 var o = new api.ImageList();

1619 buildCounterImageList++;

1620 if (buildCounterImageList < 3) {

1621 o.id = "foo";

1622 o.items = buildUnnamed871();

1623 o.kind = "foo";

1624 o.nextPageToken = "foo";

1625 o.selfLink = "foo";

1626 }

1627 buildCounterImageList--;

1628 return o;

1629 }

1630

1631 checkImageList(api.ImageList o) {

1632 buildCounterImageList++;

1633 if (buildCounterImageList < 3) {

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

1635 checkUnnamed871(o.items);

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

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

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

1639 }

1640 buildCounterImageList--;

1641 }

1642

1643 buildUnnamed872() {

1644 var o = new core.List<api.AttachedDisk>();

1645 o.add(buildAttachedDisk());

1646 o.add(buildAttachedDisk());

1647 return o;

1648 }

1649

1650 checkUnnamed872(core.List<api.AttachedDisk> o) {

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

1652 checkAttachedDisk(o[0]);

1653 checkAttachedDisk(o[1]);

1654 }

1655

1656 buildUnnamed873() {

1657 var o = new core.List<api.NetworkInterface>();

1658 o.add(buildNetworkInterface());

1659 o.add(buildNetworkInterface());

1660 return o;

1661 }

1662

1663 checkUnnamed873(core.List<api.NetworkInterface> o) {

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

1665 checkNetworkInterface(o[0]);

1666 checkNetworkInterface(o[1]);

1667 }

1668

1669 buildUnnamed874() {

1670 var o = new core.List<api.ServiceAccount>();

1671 o.add(buildServiceAccount());

1672 o.add(buildServiceAccount());

1673 return o;

1674 }

1675

1676 checkUnnamed874(core.List<api.ServiceAccount> o) {

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

1678 checkServiceAccount(o[0]);

1679 checkServiceAccount(o[1]);

1680 }

1681

1682 core.int buildCounterInstance = 0;

1683 buildInstance() {

1684 var o = new api.Instance();

1685 buildCounterInstance++;

1686 if (buildCounterInstance < 3) {

1687 o.canIpForward = true;

1688 o.creationTimestamp = "foo";

1689 o.description = "foo";

1690 o.disks = buildUnnamed872();

1691 o.id = "foo";

1692 o.kind = "foo";

1693 o.machineType = "foo";

1694 o.metadata = buildMetadata();

1695 o.name = "foo";

1696 o.networkInterfaces = buildUnnamed873();

1697 o.scheduling = buildScheduling();

1698 o.selfLink = "foo";

1699 o.serviceAccounts = buildUnnamed874();

1700 o.status = "foo";

1701 o.statusMessage = "foo";

1702 o.tags = buildTags();

1703 o.zone = "foo";

1704 }

1705 buildCounterInstance--;

1706 return o;

1707 }

1708

1709 checkInstance(api.Instance o) {

1710 buildCounterInstance++;

1711 if (buildCounterInstance < 3) {

1712 unittest.expect(o.canIpForward, unittest.isTrue);

1713 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

1715 checkUnnamed872(o.disks);

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

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

1718 unittest.expect(o.machineType, unittest.equals('foo'));

1719 checkMetadata(o.metadata);

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

1721 checkUnnamed873(o.networkInterfaces);

1722 checkScheduling(o.scheduling);

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

1724 checkUnnamed874(o.serviceAccounts);

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

1726 unittest.expect(o.statusMessage, unittest.equals('foo'));

1727 checkTags(o.tags);

1728 unittest.expect(o.zone, unittest.equals('foo'));

1729 }

1730 buildCounterInstance--;

1731 }

1732

1733 buildUnnamed875() {

1734 var o = new core.Map<core.String, api.InstancesScopedList>();

1735 o["x"] = buildInstancesScopedList();

1736 o["y"] = buildInstancesScopedList();

1737 return o;

1738 }

1739

1740 checkUnnamed875(core.Map<core.String, api.InstancesScopedList> o) {

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

1742 checkInstancesScopedList(o["x"]);

1743 checkInstancesScopedList(o["y"]);

1744 }

1745

1746 core.int buildCounterInstanceAggregatedList = 0;

1747 buildInstanceAggregatedList() {

1748 var o = new api.InstanceAggregatedList();

1749 buildCounterInstanceAggregatedList++;

1750 if (buildCounterInstanceAggregatedList < 3) {

1751 o.id = "foo";

1752 o.items = buildUnnamed875();

1753 o.kind = "foo";

1754 o.nextPageToken = "foo";

1755 o.selfLink = "foo";

1756 }

1757 buildCounterInstanceAggregatedList--;

1758 return o;

1759 }

1760

1761 checkInstanceAggregatedList(api.InstanceAggregatedList o) {

1762 buildCounterInstanceAggregatedList++;

1763 if (buildCounterInstanceAggregatedList < 3) {

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

1765 checkUnnamed875(o.items);

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

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

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

1769 }

1770 buildCounterInstanceAggregatedList--;

1771 }

1772

1773 buildUnnamed876() {

1774 var o = new core.List<api.Instance>();

1775 o.add(buildInstance());

1776 o.add(buildInstance());

1777 return o;

1778 }

1779

1780 checkUnnamed876(core.List<api.Instance> o) {

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

1782 checkInstance(o[0]);

1783 checkInstance(o[1]);

1784 }

1785

1786 core.int buildCounterInstanceList = 0;

1787 buildInstanceList() {

1788 var o = new api.InstanceList();

1789 buildCounterInstanceList++;

1790 if (buildCounterInstanceList < 3) {

1791 o.id = "foo";

1792 o.items = buildUnnamed876();

1793 o.kind = "foo";

1794 o.nextPageToken = "foo";

1795 o.selfLink = "foo";

1796 }

1797 buildCounterInstanceList--;

1798 return o;

1799 }

1800

1801 checkInstanceList(api.InstanceList o) {

1802 buildCounterInstanceList++;

1803 if (buildCounterInstanceList < 3) {

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

1805 checkUnnamed876(o.items);

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

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

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

1809 }

1810 buildCounterInstanceList--;

1811 }

1812

1813 core.int buildCounterInstanceReference = 0;

1814 buildInstanceReference() {

1815 var o = new api.InstanceReference();

1816 buildCounterInstanceReference++;

1817 if (buildCounterInstanceReference < 3) {

1818 o.instance = "foo";

1819 }

1820 buildCounterInstanceReference--;

1821 return o;

1822 }

1823

1824 checkInstanceReference(api.InstanceReference o) {

1825 buildCounterInstanceReference++;

1826 if (buildCounterInstanceReference < 3) {

1827 unittest.expect(o.instance, unittest.equals('foo'));

1828 }

1829 buildCounterInstanceReference--;

1830 }

1831

1832 buildUnnamed877() {

1833 var o = new core.List<api.Instance>();

1834 o.add(buildInstance());

1835 o.add(buildInstance());

1836 return o;

1837 }

1838

1839 checkUnnamed877(core.List<api.Instance> o) {

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

1841 checkInstance(o[0]);

1842 checkInstance(o[1]);

1843 }

1844

1845 core.int buildCounterInstancesScopedListWarningData = 0;

1846 buildInstancesScopedListWarningData() {

1847 var o = new api.InstancesScopedListWarningData();

1848 buildCounterInstancesScopedListWarningData++;

1849 if (buildCounterInstancesScopedListWarningData < 3) {

1850 o.key = "foo";

1851 o.value = "foo";

1852 }

1853 buildCounterInstancesScopedListWarningData--;

1854 return o;

1855 }

1856

1857 checkInstancesScopedListWarningData(api.InstancesScopedListWarningData o) {

1858 buildCounterInstancesScopedListWarningData++;

1859 if (buildCounterInstancesScopedListWarningData < 3) {

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

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

1862 }

1863 buildCounterInstancesScopedListWarningData--;

1864 }

1865

1866 buildUnnamed878() {

1867 var o = new core.List<api.InstancesScopedListWarningData>();

1868 o.add(buildInstancesScopedListWarningData());

1869 o.add(buildInstancesScopedListWarningData());

1870 return o;

1871 }

1872

1873 checkUnnamed878(core.List<api.InstancesScopedListWarningData> o) {

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

1875 checkInstancesScopedListWarningData(o[0]);

1876 checkInstancesScopedListWarningData(o[1]);

1877 }

1878

1879 core.int buildCounterInstancesScopedListWarning = 0;

1880 buildInstancesScopedListWarning() {

1881 var o = new api.InstancesScopedListWarning();

1882 buildCounterInstancesScopedListWarning++;

1883 if (buildCounterInstancesScopedListWarning < 3) {

1884 o.code = "foo";

1885 o.data = buildUnnamed878();

1886 o.message = "foo";

1887 }

1888 buildCounterInstancesScopedListWarning--;

1889 return o;

1890 }

1891

1892 checkInstancesScopedListWarning(api.InstancesScopedListWarning o) {

1893 buildCounterInstancesScopedListWarning++;

1894 if (buildCounterInstancesScopedListWarning < 3) {

1895 unittest.expect(o.code, unittest.equals('foo'));

1896 checkUnnamed878(o.data);

1897 unittest.expect(o.message, unittest.equals('foo'));

1898 }

1899 buildCounterInstancesScopedListWarning--;

1900 }

1901

1902 core.int buildCounterInstancesScopedList = 0;

1903 buildInstancesScopedList() {

1904 var o = new api.InstancesScopedList();

1905 buildCounterInstancesScopedList++;

1906 if (buildCounterInstancesScopedList < 3) {

1907 o.instances = buildUnnamed877();

1908 o.warning = buildInstancesScopedListWarning();

1909 }

1910 buildCounterInstancesScopedList--;

1911 return o;

1912 }

1913

1914 checkInstancesScopedList(api.InstancesScopedList o) {

1915 buildCounterInstancesScopedList++;

1916 if (buildCounterInstancesScopedList < 3) {

1917 checkUnnamed877(o.instances);

1918 checkInstancesScopedListWarning(o.warning);

1919 }

1920 buildCounterInstancesScopedList--;

1921 }

1922

1923 core.int buildCounterLicense = 0;

1924 buildLicense() {

1925 var o = new api.License();

1926 buildCounterLicense++;

1927 if (buildCounterLicense < 3) {

1928 o.chargesUseFee = true;

1929 o.kind = "foo";

1930 o.name = "foo";

1931 o.selfLink = "foo";

1932 }

1933 buildCounterLicense--;

1934 return o;

1935 }

1936

1937 checkLicense(api.License o) {

1938 buildCounterLicense++;

1939 if (buildCounterLicense < 3) {

1940 unittest.expect(o.chargesUseFee, unittest.isTrue);

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

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

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

1944 }

1945 buildCounterLicense--;

1946 }

1947

1948 core.int buildCounterMachineTypeScratchDisks = 0;

1949 buildMachineTypeScratchDisks() {

1950 var o = new api.MachineTypeScratchDisks();

1951 buildCounterMachineTypeScratchDisks++;

1952 if (buildCounterMachineTypeScratchDisks < 3) {

1953 o.diskGb = 42;

1954 }

1955 buildCounterMachineTypeScratchDisks--;

1956 return o;

1957 }

1958

1959 checkMachineTypeScratchDisks(api.MachineTypeScratchDisks o) {

1960 buildCounterMachineTypeScratchDisks++;

1961 if (buildCounterMachineTypeScratchDisks < 3) {

1962 unittest.expect(o.diskGb, unittest.equals(42));

1963 }

1964 buildCounterMachineTypeScratchDisks--;

1965 }

1966

1967 buildUnnamed879() {

1968 var o = new core.List<api.MachineTypeScratchDisks>();

1969 o.add(buildMachineTypeScratchDisks());

1970 o.add(buildMachineTypeScratchDisks());

1971 return o;

1972 }

1973

1974 checkUnnamed879(core.List<api.MachineTypeScratchDisks> o) {

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

1976 checkMachineTypeScratchDisks(o[0]);

1977 checkMachineTypeScratchDisks(o[1]);

1978 }

1979

1980 core.int buildCounterMachineType = 0;

1981 buildMachineType() {

1982 var o = new api.MachineType();

1983 buildCounterMachineType++;

1984 if (buildCounterMachineType < 3) {

1985 o.creationTimestamp = "foo";

1986 o.deprecated = buildDeprecationStatus();

1987 o.description = "foo";

1988 o.guestCpus = 42;

1989 o.id = "foo";

1990 o.imageSpaceGb = 42;

1991 o.kind = "foo";

1992 o.maximumPersistentDisks = 42;

1993 o.maximumPersistentDisksSizeGb = "foo";

1994 o.memoryMb = 42;

1995 o.name = "foo";

1996 o.scratchDisks = buildUnnamed879();

1997 o.selfLink = "foo";

1998 o.zone = "foo";

1999 }

2000 buildCounterMachineType--;

2001 return o;

2002 }

2003

2004 checkMachineType(api.MachineType o) {

2005 buildCounterMachineType++;

2006 if (buildCounterMachineType < 3) {

2007 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

2008 checkDeprecationStatus(o.deprecated);

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

2010 unittest.expect(o.guestCpus, unittest.equals(42));

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

2012 unittest.expect(o.imageSpaceGb, unittest.equals(42));

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

2014 unittest.expect(o.maximumPersistentDisks, unittest.equals(42));

2015 unittest.expect(o.maximumPersistentDisksSizeGb, unittest.equals('foo'));

2016 unittest.expect(o.memoryMb, unittest.equals(42));

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

2018 checkUnnamed879(o.scratchDisks);

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

2020 unittest.expect(o.zone, unittest.equals('foo'));

2021 }

2022 buildCounterMachineType--;

2023 }

2024

2025 buildUnnamed880() {

2026 var o = new core.Map<core.String, api.MachineTypesScopedList>();

2027 o["x"] = buildMachineTypesScopedList();

2028 o["y"] = buildMachineTypesScopedList();

2029 return o;

2030 }

2031

2032 checkUnnamed880(core.Map<core.String, api.MachineTypesScopedList> o) {

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

2034 checkMachineTypesScopedList(o["x"]);

2035 checkMachineTypesScopedList(o["y"]);

2036 }

2037

2038 core.int buildCounterMachineTypeAggregatedList = 0;

2039 buildMachineTypeAggregatedList() {

2040 var o = new api.MachineTypeAggregatedList();

2041 buildCounterMachineTypeAggregatedList++;

2042 if (buildCounterMachineTypeAggregatedList < 3) {

2043 o.id = "foo";

2044 o.items = buildUnnamed880();

2045 o.kind = "foo";

2046 o.nextPageToken = "foo";

2047 o.selfLink = "foo";

2048 }

2049 buildCounterMachineTypeAggregatedList--;

2050 return o;

2051 }

2052

2053 checkMachineTypeAggregatedList(api.MachineTypeAggregatedList o) {

2054 buildCounterMachineTypeAggregatedList++;

2055 if (buildCounterMachineTypeAggregatedList < 3) {

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

2057 checkUnnamed880(o.items);

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

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

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

2061 }

2062 buildCounterMachineTypeAggregatedList--;

2063 }

2064

2065 buildUnnamed881() {

2066 var o = new core.List<api.MachineType>();

2067 o.add(buildMachineType());

2068 o.add(buildMachineType());

2069 return o;

2070 }

2071

2072 checkUnnamed881(core.List<api.MachineType> o) {

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

2074 checkMachineType(o[0]);

2075 checkMachineType(o[1]);

2076 }

2077

2078 core.int buildCounterMachineTypeList = 0;

2079 buildMachineTypeList() {

2080 var o = new api.MachineTypeList();

2081 buildCounterMachineTypeList++;

2082 if (buildCounterMachineTypeList < 3) {

2083 o.id = "foo";

2084 o.items = buildUnnamed881();

2085 o.kind = "foo";

2086 o.nextPageToken = "foo";

2087 o.selfLink = "foo";

2088 }

2089 buildCounterMachineTypeList--;

2090 return o;

2091 }

2092

2093 checkMachineTypeList(api.MachineTypeList o) {

2094 buildCounterMachineTypeList++;

2095 if (buildCounterMachineTypeList < 3) {

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

2097 checkUnnamed881(o.items);

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

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

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

2101 }

2102 buildCounterMachineTypeList--;

2103 }

2104

2105 buildUnnamed882() {

2106 var o = new core.List<api.MachineType>();

2107 o.add(buildMachineType());

2108 o.add(buildMachineType());

2109 return o;

2110 }

2111

2112 checkUnnamed882(core.List<api.MachineType> o) {

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

2114 checkMachineType(o[0]);

2115 checkMachineType(o[1]);

2116 }

2117

2118 core.int buildCounterMachineTypesScopedListWarningData = 0;

2119 buildMachineTypesScopedListWarningData() {

2120 var o = new api.MachineTypesScopedListWarningData();

2121 buildCounterMachineTypesScopedListWarningData++;

2122 if (buildCounterMachineTypesScopedListWarningData < 3) {

2123 o.key = "foo";

2124 o.value = "foo";

2125 }

2126 buildCounterMachineTypesScopedListWarningData--;

2127 return o;

2128 }

2129

2130 checkMachineTypesScopedListWarningData(api.MachineTypesScopedListWarningData o) {

2131 buildCounterMachineTypesScopedListWarningData++;

2132 if (buildCounterMachineTypesScopedListWarningData < 3) {

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

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

2135 }

2136 buildCounterMachineTypesScopedListWarningData--;

2137 }

2138

2139 buildUnnamed883() {

2140 var o = new core.List<api.MachineTypesScopedListWarningData>();

2141 o.add(buildMachineTypesScopedListWarningData());

2142 o.add(buildMachineTypesScopedListWarningData());

2143 return o;

2144 }

2145

2146 checkUnnamed883(core.List<api.MachineTypesScopedListWarningData> o) {

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

2148 checkMachineTypesScopedListWarningData(o[0]);

2149 checkMachineTypesScopedListWarningData(o[1]);

2150 }

2151

2152 core.int buildCounterMachineTypesScopedListWarning = 0;

2153 buildMachineTypesScopedListWarning() {

2154 var o = new api.MachineTypesScopedListWarning();

2155 buildCounterMachineTypesScopedListWarning++;

2156 if (buildCounterMachineTypesScopedListWarning < 3) {

2157 o.code = "foo";

2158 o.data = buildUnnamed883();

2159 o.message = "foo";

2160 }

2161 buildCounterMachineTypesScopedListWarning--;

2162 return o;

2163 }

2164

2165 checkMachineTypesScopedListWarning(api.MachineTypesScopedListWarning o) {

2166 buildCounterMachineTypesScopedListWarning++;

2167 if (buildCounterMachineTypesScopedListWarning < 3) {

2168 unittest.expect(o.code, unittest.equals('foo'));

2169 checkUnnamed883(o.data);

2170 unittest.expect(o.message, unittest.equals('foo'));

2171 }

2172 buildCounterMachineTypesScopedListWarning--;

2173 }

2174

2175 core.int buildCounterMachineTypesScopedList = 0;

2176 buildMachineTypesScopedList() {

2177 var o = new api.MachineTypesScopedList();

2178 buildCounterMachineTypesScopedList++;

2179 if (buildCounterMachineTypesScopedList < 3) {

2180 o.machineTypes = buildUnnamed882();

2181 o.warning = buildMachineTypesScopedListWarning();

2182 }

2183 buildCounterMachineTypesScopedList--;

2184 return o;

2185 }

2186

2187 checkMachineTypesScopedList(api.MachineTypesScopedList o) {

2188 buildCounterMachineTypesScopedList++;

2189 if (buildCounterMachineTypesScopedList < 3) {

2190 checkUnnamed882(o.machineTypes);

2191 checkMachineTypesScopedListWarning(o.warning);

2192 }

2193 buildCounterMachineTypesScopedList--;

2194 }

2195

2196 core.int buildCounterMetadataItems = 0;

2197 buildMetadataItems() {

2198 var o = new api.MetadataItems();

2199 buildCounterMetadataItems++;

2200 if (buildCounterMetadataItems < 3) {

2201 o.key = "foo";

2202 o.value = "foo";

2203 }

2204 buildCounterMetadataItems--;

2205 return o;

2206 }

2207

2208 checkMetadataItems(api.MetadataItems o) {

2209 buildCounterMetadataItems++;

2210 if (buildCounterMetadataItems < 3) {

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

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

2213 }

2214 buildCounterMetadataItems--;

2215 }

2216

2217 buildUnnamed884() {

2218 var o = new core.List<api.MetadataItems>();

2219 o.add(buildMetadataItems());

2220 o.add(buildMetadataItems());

2221 return o;

2222 }

2223

2224 checkUnnamed884(core.List<api.MetadataItems> o) {

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

2226 checkMetadataItems(o[0]);

2227 checkMetadataItems(o[1]);

2228 }

2229

2230 core.int buildCounterMetadata = 0;

2231 buildMetadata() {

2232 var o = new api.Metadata();

2233 buildCounterMetadata++;

2234 if (buildCounterMetadata < 3) {

2235 o.fingerprint = "foo";

2236 o.items = buildUnnamed884();

2237 o.kind = "foo";

2238 }

2239 buildCounterMetadata--;

2240 return o;

2241 }

2242

2243 checkMetadata(api.Metadata o) {

2244 buildCounterMetadata++;

2245 if (buildCounterMetadata < 3) {

2246 unittest.expect(o.fingerprint, unittest.equals('foo'));

2247 checkUnnamed884(o.items);

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

2249 }

2250 buildCounterMetadata--;

2251 }

2252

2253 core.int buildCounterNetwork = 0;

2254 buildNetwork() {

2255 var o = new api.Network();

2256 buildCounterNetwork++;

2257 if (buildCounterNetwork < 3) {

2258 o.IPv4Range = "foo";

2259 o.creationTimestamp = "foo";

2260 o.description = "foo";

2261 o.gatewayIPv4 = "foo";

2262 o.id = "foo";

2263 o.kind = "foo";

2264 o.name = "foo";

2265 o.selfLink = "foo";

2266 }

2267 buildCounterNetwork--;

2268 return o;

2269 }

2270

2271 checkNetwork(api.Network o) {

2272 buildCounterNetwork++;

2273 if (buildCounterNetwork < 3) {

2274 unittest.expect(o.IPv4Range, unittest.equals('foo'));

2275 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

2277 unittest.expect(o.gatewayIPv4, unittest.equals('foo'));

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

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

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

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

2282 }

2283 buildCounterNetwork--;

2284 }

2285

2286 buildUnnamed885() {

2287 var o = new core.List<api.AccessConfig>();

2288 o.add(buildAccessConfig());

2289 o.add(buildAccessConfig());

2290 return o;

2291 }

2292

2293 checkUnnamed885(core.List<api.AccessConfig> o) {

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

2295 checkAccessConfig(o[0]);

2296 checkAccessConfig(o[1]);

2297 }

2298

2299 core.int buildCounterNetworkInterface = 0;

2300 buildNetworkInterface() {

2301 var o = new api.NetworkInterface();

2302 buildCounterNetworkInterface++;

2303 if (buildCounterNetworkInterface < 3) {

2304 o.accessConfigs = buildUnnamed885();

2305 o.name = "foo";

2306 o.network = "foo";

2307 o.networkIP = "foo";

2308 }

2309 buildCounterNetworkInterface--;

2310 return o;

2311 }

2312

2313 checkNetworkInterface(api.NetworkInterface o) {

2314 buildCounterNetworkInterface++;

2315 if (buildCounterNetworkInterface < 3) {

2316 checkUnnamed885(o.accessConfigs);

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

2318 unittest.expect(o.network, unittest.equals('foo'));

2319 unittest.expect(o.networkIP, unittest.equals('foo'));

2320 }

2321 buildCounterNetworkInterface--;

2322 }

2323

2324 buildUnnamed886() {

2325 var o = new core.List<api.Network>();

2326 o.add(buildNetwork());

2327 o.add(buildNetwork());

2328 return o;

2329 }

2330

2331 checkUnnamed886(core.List<api.Network> o) {

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

2333 checkNetwork(o[0]);

2334 checkNetwork(o[1]);

2335 }

2336

2337 core.int buildCounterNetworkList = 0;

2338 buildNetworkList() {

2339 var o = new api.NetworkList();

2340 buildCounterNetworkList++;

2341 if (buildCounterNetworkList < 3) {

2342 o.id = "foo";

2343 o.items = buildUnnamed886();

2344 o.kind = "foo";

2345 o.nextPageToken = "foo";

2346 o.selfLink = "foo";

2347 }

2348 buildCounterNetworkList--;

2349 return o;

2350 }

2351

2352 checkNetworkList(api.NetworkList o) {

2353 buildCounterNetworkList++;

2354 if (buildCounterNetworkList < 3) {

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

2356 checkUnnamed886(o.items);

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

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

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

2360 }

2361 buildCounterNetworkList--;

2362 }

2363

2364 core.int buildCounterOperationErrorErrors = 0;

2365 buildOperationErrorErrors() {

2366 var o = new api.OperationErrorErrors();

2367 buildCounterOperationErrorErrors++;

2368 if (buildCounterOperationErrorErrors < 3) {

2369 o.code = "foo";

2370 o.location = "foo";

2371 o.message = "foo";

2372 }

2373 buildCounterOperationErrorErrors--;

2374 return o;

2375 }

2376

2377 checkOperationErrorErrors(api.OperationErrorErrors o) {

2378 buildCounterOperationErrorErrors++;

2379 if (buildCounterOperationErrorErrors < 3) {

2380 unittest.expect(o.code, unittest.equals('foo'));

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

2382 unittest.expect(o.message, unittest.equals('foo'));

2383 }

2384 buildCounterOperationErrorErrors--;

2385 }

2386

2387 buildUnnamed887() {

2388 var o = new core.List<api.OperationErrorErrors>();

2389 o.add(buildOperationErrorErrors());

2390 o.add(buildOperationErrorErrors());

2391 return o;

2392 }

2393

2394 checkUnnamed887(core.List<api.OperationErrorErrors> o) {

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

2396 checkOperationErrorErrors(o[0]);

2397 checkOperationErrorErrors(o[1]);

2398 }

2399

2400 core.int buildCounterOperationError = 0;

2401 buildOperationError() {

2402 var o = new api.OperationError();

2403 buildCounterOperationError++;

2404 if (buildCounterOperationError < 3) {

2405 o.errors = buildUnnamed887();

2406 }

2407 buildCounterOperationError--;

2408 return o;

2409 }

2410

2411 checkOperationError(api.OperationError o) {

2412 buildCounterOperationError++;

2413 if (buildCounterOperationError < 3) {

2414 checkUnnamed887(o.errors);

2415 }

2416 buildCounterOperationError--;

2417 }

2418

2419 core.int buildCounterOperationWarningsData = 0;

2420 buildOperationWarningsData() {

2421 var o = new api.OperationWarningsData();

2422 buildCounterOperationWarningsData++;

2423 if (buildCounterOperationWarningsData < 3) {

2424 o.key = "foo";

2425 o.value = "foo";

2426 }

2427 buildCounterOperationWarningsData--;

2428 return o;

2429 }

2430

2431 checkOperationWarningsData(api.OperationWarningsData o) {

2432 buildCounterOperationWarningsData++;

2433 if (buildCounterOperationWarningsData < 3) {

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

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

2436 }

2437 buildCounterOperationWarningsData--;

2438 }

2439

2440 buildUnnamed888() {

2441 var o = new core.List<api.OperationWarningsData>();

2442 o.add(buildOperationWarningsData());

2443 o.add(buildOperationWarningsData());

2444 return o;

2445 }

2446

2447 checkUnnamed888(core.List<api.OperationWarningsData> o) {

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

2449 checkOperationWarningsData(o[0]);

2450 checkOperationWarningsData(o[1]);

2451 }

2452

2453 core.int buildCounterOperationWarnings = 0;

2454 buildOperationWarnings() {

2455 var o = new api.OperationWarnings();

2456 buildCounterOperationWarnings++;

2457 if (buildCounterOperationWarnings < 3) {

2458 o.code = "foo";

2459 o.data = buildUnnamed888();

2460 o.message = "foo";

2461 }

2462 buildCounterOperationWarnings--;

2463 return o;

2464 }

2465

2466 checkOperationWarnings(api.OperationWarnings o) {

2467 buildCounterOperationWarnings++;

2468 if (buildCounterOperationWarnings < 3) {

2469 unittest.expect(o.code, unittest.equals('foo'));

2470 checkUnnamed888(o.data);

2471 unittest.expect(o.message, unittest.equals('foo'));

2472 }

2473 buildCounterOperationWarnings--;

2474 }

2475

2476 buildUnnamed889() {

2477 var o = new core.List<api.OperationWarnings>();

2478 o.add(buildOperationWarnings());

2479 o.add(buildOperationWarnings());

2480 return o;

2481 }

2482

2483 checkUnnamed889(core.List<api.OperationWarnings> o) {

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

2485 checkOperationWarnings(o[0]);

2486 checkOperationWarnings(o[1]);

2487 }

2488

2489 core.int buildCounterOperation = 0;

2490 buildOperation() {

2491 var o = new api.Operation();

2492 buildCounterOperation++;

2493 if (buildCounterOperation < 3) {

2494 o.clientOperationId = "foo";

2495 o.creationTimestamp = "foo";

2496 o.endTime = "foo";

2497 o.error = buildOperationError();

2498 o.httpErrorMessage = "foo";

2499 o.httpErrorStatusCode = 42;

2500 o.id = "foo";

2501 o.insertTime = "foo";

2502 o.kind = "foo";

2503 o.name = "foo";

2504 o.operationType = "foo";

2505 o.progress = 42;

2506 o.region = "foo";

2507 o.selfLink = "foo";

2508 o.startTime = "foo";

2509 o.status = "foo";

2510 o.statusMessage = "foo";

2511 o.targetId = "foo";

2512 o.targetLink = "foo";

2513 o.user = "foo";

2514 o.warnings = buildUnnamed889();

2515 o.zone = "foo";

2516 }

2517 buildCounterOperation--;

2518 return o;

2519 }

2520

2521 checkOperation(api.Operation o) {

2522 buildCounterOperation++;

2523 if (buildCounterOperation < 3) {

2524 unittest.expect(o.clientOperationId, unittest.equals('foo'));

2525 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

2526 unittest.expect(o.endTime, unittest.equals('foo'));

2527 checkOperationError(o.error);

2528 unittest.expect(o.httpErrorMessage, unittest.equals('foo'));

2529 unittest.expect(o.httpErrorStatusCode, unittest.equals(42));

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

2531 unittest.expect(o.insertTime, unittest.equals('foo'));

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

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

2534 unittest.expect(o.operationType, unittest.equals('foo'));

2535 unittest.expect(o.progress, unittest.equals(42));

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

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

2538 unittest.expect(o.startTime, unittest.equals('foo'));

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

2540 unittest.expect(o.statusMessage, unittest.equals('foo'));

2541 unittest.expect(o.targetId, unittest.equals('foo'));

2542 unittest.expect(o.targetLink, unittest.equals('foo'));

2543 unittest.expect(o.user, unittest.equals('foo'));

2544 checkUnnamed889(o.warnings);

2545 unittest.expect(o.zone, unittest.equals('foo'));

2546 }

2547 buildCounterOperation--;

2548 }

2549

2550 buildUnnamed890() {

2551 var o = new core.Map<core.String, api.OperationsScopedList>();

2552 o["x"] = buildOperationsScopedList();

2553 o["y"] = buildOperationsScopedList();

2554 return o;

2555 }

2556

2557 checkUnnamed890(core.Map<core.String, api.OperationsScopedList> o) {

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

2559 checkOperationsScopedList(o["x"]);

2560 checkOperationsScopedList(o["y"]);

2561 }

2562

2563 core.int buildCounterOperationAggregatedList = 0;

2564 buildOperationAggregatedList() {

2565 var o = new api.OperationAggregatedList();

2566 buildCounterOperationAggregatedList++;

2567 if (buildCounterOperationAggregatedList < 3) {

2568 o.id = "foo";

2569 o.items = buildUnnamed890();

2570 o.kind = "foo";

2571 o.nextPageToken = "foo";

2572 o.selfLink = "foo";

2573 }

2574 buildCounterOperationAggregatedList--;

2575 return o;

2576 }

2577

2578 checkOperationAggregatedList(api.OperationAggregatedList o) {

2579 buildCounterOperationAggregatedList++;

2580 if (buildCounterOperationAggregatedList < 3) {

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

2582 checkUnnamed890(o.items);

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

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

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

2586 }

2587 buildCounterOperationAggregatedList--;

2588 }

2589

2590 buildUnnamed891() {

2591 var o = new core.List<api.Operation>();

2592 o.add(buildOperation());

2593 o.add(buildOperation());

2594 return o;

2595 }

2596

2597 checkUnnamed891(core.List<api.Operation> o) {

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

2599 checkOperation(o[0]);

2600 checkOperation(o[1]);

2601 }

2602

2603 core.int buildCounterOperationList = 0;

2604 buildOperationList() {

2605 var o = new api.OperationList();

2606 buildCounterOperationList++;

2607 if (buildCounterOperationList < 3) {

2608 o.id = "foo";

2609 o.items = buildUnnamed891();

2610 o.kind = "foo";

2611 o.nextPageToken = "foo";

2612 o.selfLink = "foo";

2613 }

2614 buildCounterOperationList--;

2615 return o;

2616 }

2617

2618 checkOperationList(api.OperationList o) {

2619 buildCounterOperationList++;

2620 if (buildCounterOperationList < 3) {

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

2622 checkUnnamed891(o.items);

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

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

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

2626 }

2627 buildCounterOperationList--;

2628 }

2629

2630 buildUnnamed892() {

2631 var o = new core.List<api.Operation>();

2632 o.add(buildOperation());

2633 o.add(buildOperation());

2634 return o;

2635 }

2636

2637 checkUnnamed892(core.List<api.Operation> o) {

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

2639 checkOperation(o[0]);

2640 checkOperation(o[1]);

2641 }

2642

2643 core.int buildCounterOperationsScopedListWarningData = 0;

2644 buildOperationsScopedListWarningData() {

2645 var o = new api.OperationsScopedListWarningData();

2646 buildCounterOperationsScopedListWarningData++;

2647 if (buildCounterOperationsScopedListWarningData < 3) {

2648 o.key = "foo";

2649 o.value = "foo";

2650 }

2651 buildCounterOperationsScopedListWarningData--;

2652 return o;

2653 }

2654

2655 checkOperationsScopedListWarningData(api.OperationsScopedListWarningData o) {

2656 buildCounterOperationsScopedListWarningData++;

2657 if (buildCounterOperationsScopedListWarningData < 3) {

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

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

2660 }

2661 buildCounterOperationsScopedListWarningData--;

2662 }

2663

2664 buildUnnamed893() {

2665 var o = new core.List<api.OperationsScopedListWarningData>();

2666 o.add(buildOperationsScopedListWarningData());

2667 o.add(buildOperationsScopedListWarningData());

2668 return o;

2669 }

2670

2671 checkUnnamed893(core.List<api.OperationsScopedListWarningData> o) {

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

2673 checkOperationsScopedListWarningData(o[0]);

2674 checkOperationsScopedListWarningData(o[1]);

2675 }

2676

2677 core.int buildCounterOperationsScopedListWarning = 0;

2678 buildOperationsScopedListWarning() {

2679 var o = new api.OperationsScopedListWarning();

2680 buildCounterOperationsScopedListWarning++;

2681 if (buildCounterOperationsScopedListWarning < 3) {

2682 o.code = "foo";

2683 o.data = buildUnnamed893();

2684 o.message = "foo";

2685 }

2686 buildCounterOperationsScopedListWarning--;

2687 return o;

2688 }

2689

2690 checkOperationsScopedListWarning(api.OperationsScopedListWarning o) {

2691 buildCounterOperationsScopedListWarning++;

2692 if (buildCounterOperationsScopedListWarning < 3) {

2693 unittest.expect(o.code, unittest.equals('foo'));

2694 checkUnnamed893(o.data);

2695 unittest.expect(o.message, unittest.equals('foo'));

2696 }

2697 buildCounterOperationsScopedListWarning--;

2698 }

2699

2700 core.int buildCounterOperationsScopedList = 0;

2701 buildOperationsScopedList() {

2702 var o = new api.OperationsScopedList();

2703 buildCounterOperationsScopedList++;

2704 if (buildCounterOperationsScopedList < 3) {

2705 o.operations = buildUnnamed892();

2706 o.warning = buildOperationsScopedListWarning();

2707 }

2708 buildCounterOperationsScopedList--;

2709 return o;

2710 }

2711

2712 checkOperationsScopedList(api.OperationsScopedList o) {

2713 buildCounterOperationsScopedList++;

2714 if (buildCounterOperationsScopedList < 3) {

2715 checkUnnamed892(o.operations);

2716 checkOperationsScopedListWarning(o.warning);

2717 }

2718 buildCounterOperationsScopedList--;

2719 }

2720

2721 buildUnnamed894() {

2722 var o = new core.List<api.PathRule>();

2723 o.add(buildPathRule());

2724 o.add(buildPathRule());

2725 return o;

2726 }

2727

2728 checkUnnamed894(core.List<api.PathRule> o) {

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

2730 checkPathRule(o[0]);

2731 checkPathRule(o[1]);

2732 }

2733

2734 core.int buildCounterPathMatcher = 0;

2735 buildPathMatcher() {

2736 var o = new api.PathMatcher();

2737 buildCounterPathMatcher++;

2738 if (buildCounterPathMatcher < 3) {

2739 o.defaultService = "foo";

2740 o.description = "foo";

2741 o.name = "foo";

2742 o.pathRules = buildUnnamed894();

2743 }

2744 buildCounterPathMatcher--;

2745 return o;

2746 }

2747

2748 checkPathMatcher(api.PathMatcher o) {

2749 buildCounterPathMatcher++;

2750 if (buildCounterPathMatcher < 3) {

2751 unittest.expect(o.defaultService, unittest.equals('foo'));

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

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

2754 checkUnnamed894(o.pathRules);

2755 }

2756 buildCounterPathMatcher--;

2757 }

2758

2759 buildUnnamed895() {

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

2761 o.add("foo");

2762 o.add("foo");

2763 return o;

2764 }

2765

2766 checkUnnamed895(core.List<core.String> o) {

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

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

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

2770 }

2771

2772 core.int buildCounterPathRule = 0;

2773 buildPathRule() {

2774 var o = new api.PathRule();

2775 buildCounterPathRule++;

2776 if (buildCounterPathRule < 3) {

2777 o.paths = buildUnnamed895();

2778 o.service = "foo";

2779 }

2780 buildCounterPathRule--;

2781 return o;

2782 }

2783

2784 checkPathRule(api.PathRule o) {

2785 buildCounterPathRule++;

2786 if (buildCounterPathRule < 3) {

2787 checkUnnamed895(o.paths);

2788 unittest.expect(o.service, unittest.equals('foo'));

2789 }

2790 buildCounterPathRule--;

2791 }

2792

2793 buildUnnamed896() {

2794 var o = new core.List<api.Quota>();

2795 o.add(buildQuota());

2796 o.add(buildQuota());

2797 return o;

2798 }

2799

2800 checkUnnamed896(core.List<api.Quota> o) {

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

2802 checkQuota(o[0]);

2803 checkQuota(o[1]);

2804 }

2805

2806 core.int buildCounterProject = 0;

2807 buildProject() {

2808 var o = new api.Project();

2809 buildCounterProject++;

2810 if (buildCounterProject < 3) {

2811 o.commonInstanceMetadata = buildMetadata();

2812 o.creationTimestamp = "foo";

2813 o.description = "foo";

2814 o.id = "foo";

2815 o.kind = "foo";

2816 o.name = "foo";

2817 o.quotas = buildUnnamed896();

2818 o.selfLink = "foo";

2819 o.usageExportLocation = buildUsageExportLocation();

2820 }

2821 buildCounterProject--;

2822 return o;

2823 }

2824

2825 checkProject(api.Project o) {

2826 buildCounterProject++;

2827 if (buildCounterProject < 3) {

2828 checkMetadata(o.commonInstanceMetadata);

2829 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

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

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

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

2834 checkUnnamed896(o.quotas);

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

2836 checkUsageExportLocation(o.usageExportLocation);

2837 }

2838 buildCounterProject--;

2839 }

2840

2841 core.int buildCounterQuota = 0;

2842 buildQuota() {

2843 var o = new api.Quota();

2844 buildCounterQuota++;

2845 if (buildCounterQuota < 3) {

2846 o.limit = 42.0;

2847 o.metric = "foo";

2848 o.usage = 42.0;

2849 }

2850 buildCounterQuota--;

2851 return o;

2852 }

2853

2854 checkQuota(api.Quota o) {

2855 buildCounterQuota++;

2856 if (buildCounterQuota < 3) {

2857 unittest.expect(o.limit, unittest.equals(42.0));

2858 unittest.expect(o.metric, unittest.equals('foo'));

2859 unittest.expect(o.usage, unittest.equals(42.0));

2860 }

2861 buildCounterQuota--;

2862 }

2863

2864 buildUnnamed897() {

2865 var o = new core.List<api.Quota>();

2866 o.add(buildQuota());

2867 o.add(buildQuota());

2868 return o;

2869 }

2870

2871 checkUnnamed897(core.List<api.Quota> o) {

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

2873 checkQuota(o[0]);

2874 checkQuota(o[1]);

2875 }

2876

2877 buildUnnamed898() {

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

2879 o.add("foo");

2880 o.add("foo");

2881 return o;

2882 }

2883

2884 checkUnnamed898(core.List<core.String> o) {

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

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

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

2888 }

2889

2890 core.int buildCounterRegion = 0;

2891 buildRegion() {

2892 var o = new api.Region();

2893 buildCounterRegion++;

2894 if (buildCounterRegion < 3) {

2895 o.creationTimestamp = "foo";

2896 o.deprecated = buildDeprecationStatus();

2897 o.description = "foo";

2898 o.id = "foo";

2899 o.kind = "foo";

2900 o.name = "foo";

2901 o.quotas = buildUnnamed897();

2902 o.selfLink = "foo";

2903 o.status = "foo";

2904 o.zones = buildUnnamed898();

2905 }

2906 buildCounterRegion--;

2907 return o;

2908 }

2909

2910 checkRegion(api.Region o) {

2911 buildCounterRegion++;

2912 if (buildCounterRegion < 3) {

2913 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

2914 checkDeprecationStatus(o.deprecated);

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

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

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

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

2919 checkUnnamed897(o.quotas);

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

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

2922 checkUnnamed898(o.zones);

2923 }

2924 buildCounterRegion--;

2925 }

2926

2927 buildUnnamed899() {

2928 var o = new core.List<api.Region>();

2929 o.add(buildRegion());

2930 o.add(buildRegion());

2931 return o;

2932 }

2933

2934 checkUnnamed899(core.List<api.Region> o) {

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

2936 checkRegion(o[0]);

2937 checkRegion(o[1]);

2938 }

2939

2940 core.int buildCounterRegionList = 0;

2941 buildRegionList() {

2942 var o = new api.RegionList();

2943 buildCounterRegionList++;

2944 if (buildCounterRegionList < 3) {

2945 o.id = "foo";

2946 o.items = buildUnnamed899();

2947 o.kind = "foo";

2948 o.nextPageToken = "foo";

2949 o.selfLink = "foo";

2950 }

2951 buildCounterRegionList--;

2952 return o;

2953 }

2954

2955 checkRegionList(api.RegionList o) {

2956 buildCounterRegionList++;

2957 if (buildCounterRegionList < 3) {

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

2959 checkUnnamed899(o.items);

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

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

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

2963 }

2964 buildCounterRegionList--;

2965 }

2966

2967 core.int buildCounterResourceGroupReference = 0;

2968 buildResourceGroupReference() {

2969 var o = new api.ResourceGroupReference();

2970 buildCounterResourceGroupReference++;

2971 if (buildCounterResourceGroupReference < 3) {

2972 o.group = "foo";

2973 }

2974 buildCounterResourceGroupReference--;

2975 return o;

2976 }

2977

2978 checkResourceGroupReference(api.ResourceGroupReference o) {

2979 buildCounterResourceGroupReference++;

2980 if (buildCounterResourceGroupReference < 3) {

2981 unittest.expect(o.group, unittest.equals('foo'));

2982 }

2983 buildCounterResourceGroupReference--;

2984 }

2985

2986 buildUnnamed900() {

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

2988 o.add("foo");

2989 o.add("foo");

2990 return o;

2991 }

2992

2993 checkUnnamed900(core.List<core.String> o) {

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

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

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

2997 }

2998

2999 core.int buildCounterRouteWarningsData = 0;

3000 buildRouteWarningsData() {

3001 var o = new api.RouteWarningsData();

3002 buildCounterRouteWarningsData++;

3003 if (buildCounterRouteWarningsData < 3) {

3004 o.key = "foo";

3005 o.value = "foo";

3006 }

3007 buildCounterRouteWarningsData--;

3008 return o;

3009 }

3010

3011 checkRouteWarningsData(api.RouteWarningsData o) {

3012 buildCounterRouteWarningsData++;

3013 if (buildCounterRouteWarningsData < 3) {

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

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

3016 }

3017 buildCounterRouteWarningsData--;

3018 }

3019

3020 buildUnnamed901() {

3021 var o = new core.List<api.RouteWarningsData>();

3022 o.add(buildRouteWarningsData());

3023 o.add(buildRouteWarningsData());

3024 return o;

3025 }

3026

3027 checkUnnamed901(core.List<api.RouteWarningsData> o) {

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

3029 checkRouteWarningsData(o[0]);

3030 checkRouteWarningsData(o[1]);

3031 }

3032

3033 core.int buildCounterRouteWarnings = 0;

3034 buildRouteWarnings() {

3035 var o = new api.RouteWarnings();

3036 buildCounterRouteWarnings++;

3037 if (buildCounterRouteWarnings < 3) {

3038 o.code = "foo";

3039 o.data = buildUnnamed901();

3040 o.message = "foo";

3041 }

3042 buildCounterRouteWarnings--;

3043 return o;

3044 }

3045

3046 checkRouteWarnings(api.RouteWarnings o) {

3047 buildCounterRouteWarnings++;

3048 if (buildCounterRouteWarnings < 3) {

3049 unittest.expect(o.code, unittest.equals('foo'));

3050 checkUnnamed901(o.data);

3051 unittest.expect(o.message, unittest.equals('foo'));

3052 }

3053 buildCounterRouteWarnings--;

3054 }

3055

3056 buildUnnamed902() {

3057 var o = new core.List<api.RouteWarnings>();

3058 o.add(buildRouteWarnings());

3059 o.add(buildRouteWarnings());

3060 return o;

3061 }

3062

3063 checkUnnamed902(core.List<api.RouteWarnings> o) {

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

3065 checkRouteWarnings(o[0]);

3066 checkRouteWarnings(o[1]);

3067 }

3068

3069 core.int buildCounterRoute = 0;

3070 buildRoute() {

3071 var o = new api.Route();

3072 buildCounterRoute++;

3073 if (buildCounterRoute < 3) {

3074 o.creationTimestamp = "foo";

3075 o.description = "foo";

3076 o.destRange = "foo";

3077 o.id = "foo";

3078 o.kind = "foo";

3079 o.name = "foo";

3080 o.network = "foo";

3081 o.nextHopGateway = "foo";

3082 o.nextHopInstance = "foo";

3083 o.nextHopIp = "foo";

3084 o.nextHopNetwork = "foo";

3085 o.priority = 42;

3086 o.selfLink = "foo";

3087 o.tags = buildUnnamed900();

3088 o.warnings = buildUnnamed902();

3089 }

3090 buildCounterRoute--;

3091 return o;

3092 }

3093

3094 checkRoute(api.Route o) {

3095 buildCounterRoute++;

3096 if (buildCounterRoute < 3) {

3097 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

3099 unittest.expect(o.destRange, unittest.equals('foo'));

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

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

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

3103 unittest.expect(o.network, unittest.equals('foo'));

3104 unittest.expect(o.nextHopGateway, unittest.equals('foo'));

3105 unittest.expect(o.nextHopInstance, unittest.equals('foo'));

3106 unittest.expect(o.nextHopIp, unittest.equals('foo'));

3107 unittest.expect(o.nextHopNetwork, unittest.equals('foo'));

3108 unittest.expect(o.priority, unittest.equals(42));

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

3110 checkUnnamed900(o.tags);

3111 checkUnnamed902(o.warnings);

3112 }

3113 buildCounterRoute--;

3114 }

3115

3116 buildUnnamed903() {

3117 var o = new core.List<api.Route>();

3118 o.add(buildRoute());

3119 o.add(buildRoute());

3120 return o;

3121 }

3122

3123 checkUnnamed903(core.List<api.Route> o) {

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

3125 checkRoute(o[0]);

3126 checkRoute(o[1]);

3127 }

3128

3129 core.int buildCounterRouteList = 0;

3130 buildRouteList() {

3131 var o = new api.RouteList();

3132 buildCounterRouteList++;

3133 if (buildCounterRouteList < 3) {

3134 o.id = "foo";

3135 o.items = buildUnnamed903();

3136 o.kind = "foo";

3137 o.nextPageToken = "foo";

3138 o.selfLink = "foo";

3139 }

3140 buildCounterRouteList--;

3141 return o;

3142 }

3143

3144 checkRouteList(api.RouteList o) {

3145 buildCounterRouteList++;

3146 if (buildCounterRouteList < 3) {

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

3148 checkUnnamed903(o.items);

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

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

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

3152 }

3153 buildCounterRouteList--;

3154 }

3155

3156 core.int buildCounterScheduling = 0;

3157 buildScheduling() {

3158 var o = new api.Scheduling();

3159 buildCounterScheduling++;

3160 if (buildCounterScheduling < 3) {

3161 o.automaticRestart = true;

3162 o.onHostMaintenance = "foo";

3163 }

3164 buildCounterScheduling--;

3165 return o;

3166 }

3167

3168 checkScheduling(api.Scheduling o) {

3169 buildCounterScheduling++;

3170 if (buildCounterScheduling < 3) {

3171 unittest.expect(o.automaticRestart, unittest.isTrue);

3172 unittest.expect(o.onHostMaintenance, unittest.equals('foo'));

3173 }

3174 buildCounterScheduling--;

3175 }

3176

3177 core.int buildCounterSerialPortOutput = 0;

3178 buildSerialPortOutput() {

3179 var o = new api.SerialPortOutput();

3180 buildCounterSerialPortOutput++;

3181 if (buildCounterSerialPortOutput < 3) {

3182 o.contents = "foo";

3183 o.kind = "foo";

3184 o.selfLink = "foo";

3185 }

3186 buildCounterSerialPortOutput--;

3187 return o;

3188 }

3189

3190 checkSerialPortOutput(api.SerialPortOutput o) {

3191 buildCounterSerialPortOutput++;

3192 if (buildCounterSerialPortOutput < 3) {

3193 unittest.expect(o.contents, unittest.equals('foo'));

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

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

3196 }

3197 buildCounterSerialPortOutput--;

3198 }

3199

3200 buildUnnamed904() {

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

3202 o.add("foo");

3203 o.add("foo");

3204 return o;

3205 }

3206

3207 checkUnnamed904(core.List<core.String> o) {

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

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

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

3211 }

3212

3213 core.int buildCounterServiceAccount = 0;

3214 buildServiceAccount() {

3215 var o = new api.ServiceAccount();

3216 buildCounterServiceAccount++;

3217 if (buildCounterServiceAccount < 3) {

3218 o.email = "foo";

3219 o.scopes = buildUnnamed904();

3220 }

3221 buildCounterServiceAccount--;

3222 return o;

3223 }

3224

3225 checkServiceAccount(api.ServiceAccount o) {

3226 buildCounterServiceAccount++;

3227 if (buildCounterServiceAccount < 3) {

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

3229 checkUnnamed904(o.scopes);

3230 }

3231 buildCounterServiceAccount--;

3232 }

3233

3234 buildUnnamed905() {

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

3236 o.add("foo");

3237 o.add("foo");

3238 return o;

3239 }

3240

3241 checkUnnamed905(core.List<core.String> o) {

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

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

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

3245 }

3246

3247 core.int buildCounterSnapshot = 0;

3248 buildSnapshot() {

3249 var o = new api.Snapshot();

3250 buildCounterSnapshot++;

3251 if (buildCounterSnapshot < 3) {

3252 o.creationTimestamp = "foo";

3253 o.description = "foo";

3254 o.diskSizeGb = "foo";

3255 o.id = "foo";

3256 o.kind = "foo";

3257 o.licenses = buildUnnamed905();

3258 o.name = "foo";

3259 o.selfLink = "foo";

3260 o.sourceDisk = "foo";

3261 o.sourceDiskId = "foo";

3262 o.status = "foo";

3263 o.storageBytes = "foo";

3264 o.storageBytesStatus = "foo";

3265 }

3266 buildCounterSnapshot--;

3267 return o;

3268 }

3269

3270 checkSnapshot(api.Snapshot o) {

3271 buildCounterSnapshot++;

3272 if (buildCounterSnapshot < 3) {

3273 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

3275 unittest.expect(o.diskSizeGb, unittest.equals('foo'));

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

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

3278 checkUnnamed905(o.licenses);

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

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

3281 unittest.expect(o.sourceDisk, unittest.equals('foo'));

3282 unittest.expect(o.sourceDiskId, unittest.equals('foo'));

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

3284 unittest.expect(o.storageBytes, unittest.equals('foo'));

3285 unittest.expect(o.storageBytesStatus, unittest.equals('foo'));

3286 }

3287 buildCounterSnapshot--;

3288 }

3289

3290 buildUnnamed906() {

3291 var o = new core.List<api.Snapshot>();

3292 o.add(buildSnapshot());

3293 o.add(buildSnapshot());

3294 return o;

3295 }

3296

3297 checkUnnamed906(core.List<api.Snapshot> o) {

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

3299 checkSnapshot(o[0]);

3300 checkSnapshot(o[1]);

3301 }

3302

3303 core.int buildCounterSnapshotList = 0;

3304 buildSnapshotList() {

3305 var o = new api.SnapshotList();

3306 buildCounterSnapshotList++;

3307 if (buildCounterSnapshotList < 3) {

3308 o.id = "foo";

3309 o.items = buildUnnamed906();

3310 o.kind = "foo";

3311 o.nextPageToken = "foo";

3312 o.selfLink = "foo";

3313 }

3314 buildCounterSnapshotList--;

3315 return o;

3316 }

3317

3318 checkSnapshotList(api.SnapshotList o) {

3319 buildCounterSnapshotList++;

3320 if (buildCounterSnapshotList < 3) {

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

3322 checkUnnamed906(o.items);

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

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

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

3326 }

3327 buildCounterSnapshotList--;

3328 }

3329

3330 buildUnnamed907() {

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

3332 o.add("foo");

3333 o.add("foo");

3334 return o;

3335 }

3336

3337 checkUnnamed907(core.List<core.String> o) {

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

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

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

3341 }

3342

3343 core.int buildCounterTags = 0;

3344 buildTags() {

3345 var o = new api.Tags();

3346 buildCounterTags++;

3347 if (buildCounterTags < 3) {

3348 o.fingerprint = "foo";

3349 o.items = buildUnnamed907();

3350 }

3351 buildCounterTags--;

3352 return o;

3353 }

3354

3355 checkTags(api.Tags o) {

3356 buildCounterTags++;

3357 if (buildCounterTags < 3) {

3358 unittest.expect(o.fingerprint, unittest.equals('foo'));

3359 checkUnnamed907(o.items);

3360 }

3361 buildCounterTags--;

3362 }

3363

3364 core.int buildCounterTargetHttpProxy = 0;

3365 buildTargetHttpProxy() {

3366 var o = new api.TargetHttpProxy();

3367 buildCounterTargetHttpProxy++;

3368 if (buildCounterTargetHttpProxy < 3) {

3369 o.creationTimestamp = "foo";

3370 o.description = "foo";

3371 o.id = "foo";

3372 o.kind = "foo";

3373 o.name = "foo";

3374 o.selfLink = "foo";

3375 o.urlMap = "foo";

3376 }

3377 buildCounterTargetHttpProxy--;

3378 return o;

3379 }

3380

3381 checkTargetHttpProxy(api.TargetHttpProxy o) {

3382 buildCounterTargetHttpProxy++;

3383 if (buildCounterTargetHttpProxy < 3) {

3384 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

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

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

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

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

3390 unittest.expect(o.urlMap, unittest.equals('foo'));

3391 }

3392 buildCounterTargetHttpProxy--;

3393 }

3394

3395 buildUnnamed908() {

3396 var o = new core.List<api.TargetHttpProxy>();

3397 o.add(buildTargetHttpProxy());

3398 o.add(buildTargetHttpProxy());

3399 return o;

3400 }

3401

3402 checkUnnamed908(core.List<api.TargetHttpProxy> o) {

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

3404 checkTargetHttpProxy(o[0]);

3405 checkTargetHttpProxy(o[1]);

3406 }

3407

3408 core.int buildCounterTargetHttpProxyList = 0;

3409 buildTargetHttpProxyList() {

3410 var o = new api.TargetHttpProxyList();

3411 buildCounterTargetHttpProxyList++;

3412 if (buildCounterTargetHttpProxyList < 3) {

3413 o.id = "foo";

3414 o.items = buildUnnamed908();

3415 o.kind = "foo";

3416 o.nextPageToken = "foo";

3417 o.selfLink = "foo";

3418 }

3419 buildCounterTargetHttpProxyList--;

3420 return o;

3421 }

3422

3423 checkTargetHttpProxyList(api.TargetHttpProxyList o) {

3424 buildCounterTargetHttpProxyList++;

3425 if (buildCounterTargetHttpProxyList < 3) {

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

3427 checkUnnamed908(o.items);

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

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

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

3431 }

3432 buildCounterTargetHttpProxyList--;

3433 }

3434

3435 core.int buildCounterTargetInstance = 0;

3436 buildTargetInstance() {

3437 var o = new api.TargetInstance();

3438 buildCounterTargetInstance++;

3439 if (buildCounterTargetInstance < 3) {

3440 o.creationTimestamp = "foo";

3441 o.description = "foo";

3442 o.id = "foo";

3443 o.instance = "foo";

3444 o.kind = "foo";

3445 o.name = "foo";

3446 o.natPolicy = "foo";

3447 o.selfLink = "foo";

3448 o.zone = "foo";

3449 }

3450 buildCounterTargetInstance--;

3451 return o;

3452 }

3453

3454 checkTargetInstance(api.TargetInstance o) {

3455 buildCounterTargetInstance++;

3456 if (buildCounterTargetInstance < 3) {

3457 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

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

3460 unittest.expect(o.instance, unittest.equals('foo'));

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

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

3463 unittest.expect(o.natPolicy, unittest.equals('foo'));

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

3465 unittest.expect(o.zone, unittest.equals('foo'));

3466 }

3467 buildCounterTargetInstance--;

3468 }

3469

3470 buildUnnamed909() {

3471 var o = new core.Map<core.String, api.TargetInstancesScopedList>();

3472 o["x"] = buildTargetInstancesScopedList();

3473 o["y"] = buildTargetInstancesScopedList();

3474 return o;

3475 }

3476

3477 checkUnnamed909(core.Map<core.String, api.TargetInstancesScopedList> o) {

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

3479 checkTargetInstancesScopedList(o["x"]);

3480 checkTargetInstancesScopedList(o["y"]);

3481 }

3482

3483 core.int buildCounterTargetInstanceAggregatedList = 0;

3484 buildTargetInstanceAggregatedList() {

3485 var o = new api.TargetInstanceAggregatedList();

3486 buildCounterTargetInstanceAggregatedList++;

3487 if (buildCounterTargetInstanceAggregatedList < 3) {

3488 o.id = "foo";

3489 o.items = buildUnnamed909();

3490 o.kind = "foo";

3491 o.nextPageToken = "foo";

3492 o.selfLink = "foo";

3493 }

3494 buildCounterTargetInstanceAggregatedList--;

3495 return o;

3496 }

3497

3498 checkTargetInstanceAggregatedList(api.TargetInstanceAggregatedList o) {

3499 buildCounterTargetInstanceAggregatedList++;

3500 if (buildCounterTargetInstanceAggregatedList < 3) {

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

3502 checkUnnamed909(o.items);

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

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

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

3506 }

3507 buildCounterTargetInstanceAggregatedList--;

3508 }

3509

3510 buildUnnamed910() {

3511 var o = new core.List<api.TargetInstance>();

3512 o.add(buildTargetInstance());

3513 o.add(buildTargetInstance());

3514 return o;

3515 }

3516

3517 checkUnnamed910(core.List<api.TargetInstance> o) {

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

3519 checkTargetInstance(o[0]);

3520 checkTargetInstance(o[1]);

3521 }

3522

3523 core.int buildCounterTargetInstanceList = 0;

3524 buildTargetInstanceList() {

3525 var o = new api.TargetInstanceList();

3526 buildCounterTargetInstanceList++;

3527 if (buildCounterTargetInstanceList < 3) {

3528 o.id = "foo";

3529 o.items = buildUnnamed910();

3530 o.kind = "foo";

3531 o.nextPageToken = "foo";

3532 o.selfLink = "foo";

3533 }

3534 buildCounterTargetInstanceList--;

3535 return o;

3536 }

3537

3538 checkTargetInstanceList(api.TargetInstanceList o) {

3539 buildCounterTargetInstanceList++;

3540 if (buildCounterTargetInstanceList < 3) {

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

3542 checkUnnamed910(o.items);

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

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

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

3546 }

3547 buildCounterTargetInstanceList--;

3548 }

3549

3550 buildUnnamed911() {

3551 var o = new core.List<api.TargetInstance>();

3552 o.add(buildTargetInstance());

3553 o.add(buildTargetInstance());

3554 return o;

3555 }

3556

3557 checkUnnamed911(core.List<api.TargetInstance> o) {

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

3559 checkTargetInstance(o[0]);

3560 checkTargetInstance(o[1]);

3561 }

3562

3563 core.int buildCounterTargetInstancesScopedListWarningData = 0;

3564 buildTargetInstancesScopedListWarningData() {

3565 var o = new api.TargetInstancesScopedListWarningData();

3566 buildCounterTargetInstancesScopedListWarningData++;

3567 if (buildCounterTargetInstancesScopedListWarningData < 3) {

3568 o.key = "foo";

3569 o.value = "foo";

3570 }

3571 buildCounterTargetInstancesScopedListWarningData--;

3572 return o;

3573 }

3574

3575 checkTargetInstancesScopedListWarningData(api.TargetInstancesScopedListWarningDa ta o) {

3576 buildCounterTargetInstancesScopedListWarningData++;

3577 if (buildCounterTargetInstancesScopedListWarningData < 3) {

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

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

3580 }

3581 buildCounterTargetInstancesScopedListWarningData--;

3582 }

3583

3584 buildUnnamed912() {

3585 var o = new core.List<api.TargetInstancesScopedListWarningData>();

3586 o.add(buildTargetInstancesScopedListWarningData());

3587 o.add(buildTargetInstancesScopedListWarningData());

3588 return o;

3589 }

3590

3591 checkUnnamed912(core.List<api.TargetInstancesScopedListWarningData> o) {

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

3593 checkTargetInstancesScopedListWarningData(o[0]);

3594 checkTargetInstancesScopedListWarningData(o[1]);

3595 }

3596

3597 core.int buildCounterTargetInstancesScopedListWarning = 0;

3598 buildTargetInstancesScopedListWarning() {

3599 var o = new api.TargetInstancesScopedListWarning();

3600 buildCounterTargetInstancesScopedListWarning++;

3601 if (buildCounterTargetInstancesScopedListWarning < 3) {

3602 o.code = "foo";

3603 o.data = buildUnnamed912();

3604 o.message = "foo";

3605 }

3606 buildCounterTargetInstancesScopedListWarning--;

3607 return o;

3608 }

3609

3610 checkTargetInstancesScopedListWarning(api.TargetInstancesScopedListWarning o) {

3611 buildCounterTargetInstancesScopedListWarning++;

3612 if (buildCounterTargetInstancesScopedListWarning < 3) {

3613 unittest.expect(o.code, unittest.equals('foo'));

3614 checkUnnamed912(o.data);

3615 unittest.expect(o.message, unittest.equals('foo'));

3616 }

3617 buildCounterTargetInstancesScopedListWarning--;

3618 }

3619

3620 core.int buildCounterTargetInstancesScopedList = 0;

3621 buildTargetInstancesScopedList() {

3622 var o = new api.TargetInstancesScopedList();

3623 buildCounterTargetInstancesScopedList++;

3624 if (buildCounterTargetInstancesScopedList < 3) {

3625 o.targetInstances = buildUnnamed911();

3626 o.warning = buildTargetInstancesScopedListWarning();

3627 }

3628 buildCounterTargetInstancesScopedList--;

3629 return o;

3630 }

3631

3632 checkTargetInstancesScopedList(api.TargetInstancesScopedList o) {

3633 buildCounterTargetInstancesScopedList++;

3634 if (buildCounterTargetInstancesScopedList < 3) {

3635 checkUnnamed911(o.targetInstances);

3636 checkTargetInstancesScopedListWarning(o.warning);

3637 }

3638 buildCounterTargetInstancesScopedList--;

3639 }

3640

3641 buildUnnamed913() {

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

3643 o.add("foo");

3644 o.add("foo");

3645 return o;

3646 }

3647

3648 checkUnnamed913(core.List<core.String> o) {

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

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

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

3652 }

3653

3654 buildUnnamed914() {

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

3656 o.add("foo");

3657 o.add("foo");

3658 return o;

3659 }

3660

3661 checkUnnamed914(core.List<core.String> o) {

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

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

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

3665 }

3666

3667 core.int buildCounterTargetPool = 0;

3668 buildTargetPool() {

3669 var o = new api.TargetPool();

3670 buildCounterTargetPool++;

3671 if (buildCounterTargetPool < 3) {

3672 o.backupPool = "foo";

3673 o.creationTimestamp = "foo";

3674 o.description = "foo";

3675 o.failoverRatio = 42.0;

3676 o.healthChecks = buildUnnamed913();

3677 o.id = "foo";

3678 o.instances = buildUnnamed914();

3679 o.kind = "foo";

3680 o.name = "foo";

3681 o.region = "foo";

3682 o.selfLink = "foo";

3683 o.sessionAffinity = "foo";

3684 }

3685 buildCounterTargetPool--;

3686 return o;

3687 }

3688

3689 checkTargetPool(api.TargetPool o) {

3690 buildCounterTargetPool++;

3691 if (buildCounterTargetPool < 3) {

3692 unittest.expect(o.backupPool, unittest.equals('foo'));

3693 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

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

3695 unittest.expect(o.failoverRatio, unittest.equals(42.0));

3696 checkUnnamed913(o.healthChecks);

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

3698 checkUnnamed914(o.instances);

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

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

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

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

3703 unittest.expect(o.sessionAffinity, unittest.equals('foo'));

3704 }

3705 buildCounterTargetPool--;

3706 }

3707

3708 buildUnnamed915() {

3709 var o = new core.Map<core.String, api.TargetPoolsScopedList>();

3710 o["x"] = buildTargetPoolsScopedList();

3711 o["y"] = buildTargetPoolsScopedList();

3712 return o;

3713 }

3714

3715 checkUnnamed915(core.Map<core.String, api.TargetPoolsScopedList> o) {

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

3717 checkTargetPoolsScopedList(o["x"]);

3718 checkTargetPoolsScopedList(o["y"]);

3719 }

3720

3721 core.int buildCounterTargetPoolAggregatedList = 0;

3722 buildTargetPoolAggregatedList() {

3723 var o = new api.TargetPoolAggregatedList();

3724 buildCounterTargetPoolAggregatedList++;

3725 if (buildCounterTargetPoolAggregatedList < 3) {

3726 o.id = "foo";

3727 o.items = buildUnnamed915();

3728 o.kind = "foo";

3729 o.nextPageToken = "foo";

3730 o.selfLink = "foo";

3731 }

3732 buildCounterTargetPoolAggregatedList--;

3733 return o;

3734 }

3735

3736 checkTargetPoolAggregatedList(api.TargetPoolAggregatedList o) {

3737 buildCounterTargetPoolAggregatedList++;

3738 if (buildCounterTargetPoolAggregatedList < 3) {

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

3740 checkUnnamed915(o.items);

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

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

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

3744 }

3745 buildCounterTargetPoolAggregatedList--;

3746 }

3747

3748 buildUnnamed916() {

3749 var o = new core.List<api.HealthStatus>();

3750 o.add(buildHealthStatus());

3751 o.add(buildHealthStatus());

3752 return o;

3753 }

3754

3755 checkUnnamed916(core.List<api.HealthStatus> o) {

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

3757 checkHealthStatus(o[0]);

3758 checkHealthStatus(o[1]);

3759 }

3760

3761 core.int buildCounterTargetPoolInstanceHealth = 0;

3762 buildTargetPoolInstanceHealth() {

3763 var o = new api.TargetPoolInstanceHealth();

3764 buildCounterTargetPoolInstanceHealth++;

3765 if (buildCounterTargetPoolInstanceHealth < 3) {

3766 o.healthStatus = buildUnnamed916();

3767 o.kind = "foo";

3768 }

3769 buildCounterTargetPoolInstanceHealth--;

3770 return o;

3771 }

3772

3773 checkTargetPoolInstanceHealth(api.TargetPoolInstanceHealth o) {

3774 buildCounterTargetPoolInstanceHealth++;

3775 if (buildCounterTargetPoolInstanceHealth < 3) {

3776 checkUnnamed916(o.healthStatus);

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

3778 }

3779 buildCounterTargetPoolInstanceHealth--;

3780 }

3781

3782 buildUnnamed917() {

3783 var o = new core.List<api.TargetPool>();

3784 o.add(buildTargetPool());

3785 o.add(buildTargetPool());

3786 return o;

3787 }

3788

3789 checkUnnamed917(core.List<api.TargetPool> o) {

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

3791 checkTargetPool(o[0]);

3792 checkTargetPool(o[1]);

3793 }

3794

3795 core.int buildCounterTargetPoolList = 0;

3796 buildTargetPoolList() {

3797 var o = new api.TargetPoolList();

3798 buildCounterTargetPoolList++;

3799 if (buildCounterTargetPoolList < 3) {

3800 o.id = "foo";

3801 o.items = buildUnnamed917();

3802 o.kind = "foo";

3803 o.nextPageToken = "foo";

3804 o.selfLink = "foo";

3805 }

3806 buildCounterTargetPoolList--;

3807 return o;

3808 }

3809

3810 checkTargetPoolList(api.TargetPoolList o) {

3811 buildCounterTargetPoolList++;

3812 if (buildCounterTargetPoolList < 3) {

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

3814 checkUnnamed917(o.items);

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

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

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

3818 }

3819 buildCounterTargetPoolList--;

3820 }

3821

3822 buildUnnamed918() {

3823 var o = new core.List<api.HealthCheckReference>();

3824 o.add(buildHealthCheckReference());

3825 o.add(buildHealthCheckReference());

3826 return o;

3827 }

3828

3829 checkUnnamed918(core.List<api.HealthCheckReference> o) {

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

3831 checkHealthCheckReference(o[0]);

3832 checkHealthCheckReference(o[1]);

3833 }

3834

3835 core.int buildCounterTargetPoolsAddHealthCheckRequest = 0;

3836 buildTargetPoolsAddHealthCheckRequest() {

3837 var o = new api.TargetPoolsAddHealthCheckRequest();

3838 buildCounterTargetPoolsAddHealthCheckRequest++;

3839 if (buildCounterTargetPoolsAddHealthCheckRequest < 3) {

3840 o.healthChecks = buildUnnamed918();

3841 }

3842 buildCounterTargetPoolsAddHealthCheckRequest--;

3843 return o;

3844 }

3845

3846 checkTargetPoolsAddHealthCheckRequest(api.TargetPoolsAddHealthCheckRequest o) {

3847 buildCounterTargetPoolsAddHealthCheckRequest++;

3848 if (buildCounterTargetPoolsAddHealthCheckRequest < 3) {

3849 checkUnnamed918(o.healthChecks);

3850 }

3851 buildCounterTargetPoolsAddHealthCheckRequest--;

3852 }

3853

3854 buildUnnamed919() {

3855 var o = new core.List<api.InstanceReference>();

3856 o.add(buildInstanceReference());

3857 o.add(buildInstanceReference());

3858 return o;

3859 }

3860

3861 checkUnnamed919(core.List<api.InstanceReference> o) {

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

3863 checkInstanceReference(o[0]);

3864 checkInstanceReference(o[1]);

3865 }

3866

3867 core.int buildCounterTargetPoolsAddInstanceRequest = 0;

3868 buildTargetPoolsAddInstanceRequest() {

3869 var o = new api.TargetPoolsAddInstanceRequest();

3870 buildCounterTargetPoolsAddInstanceRequest++;

3871 if (buildCounterTargetPoolsAddInstanceRequest < 3) {

3872 o.instances = buildUnnamed919();

3873 }

3874 buildCounterTargetPoolsAddInstanceRequest--;

3875 return o;

3876 }

3877

3878 checkTargetPoolsAddInstanceRequest(api.TargetPoolsAddInstanceRequest o) {

3879 buildCounterTargetPoolsAddInstanceRequest++;

3880 if (buildCounterTargetPoolsAddInstanceRequest < 3) {

3881 checkUnnamed919(o.instances);

3882 }

3883 buildCounterTargetPoolsAddInstanceRequest--;

3884 }

3885

3886 buildUnnamed920() {

3887 var o = new core.List<api.HealthCheckReference>();

3888 o.add(buildHealthCheckReference());

3889 o.add(buildHealthCheckReference());

3890 return o;

3891 }

3892

3893 checkUnnamed920(core.List<api.HealthCheckReference> o) {

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

3895 checkHealthCheckReference(o[0]);

3896 checkHealthCheckReference(o[1]);

3897 }

3898

3899 core.int buildCounterTargetPoolsRemoveHealthCheckRequest = 0;

3900 buildTargetPoolsRemoveHealthCheckRequest() {

3901 var o = new api.TargetPoolsRemoveHealthCheckRequest();

3902 buildCounterTargetPoolsRemoveHealthCheckRequest++;

3903 if (buildCounterTargetPoolsRemoveHealthCheckRequest < 3) {

3904 o.healthChecks = buildUnnamed920();

3905 }

3906 buildCounterTargetPoolsRemoveHealthCheckRequest--;

3907 return o;

3908 }

3909

3910 checkTargetPoolsRemoveHealthCheckRequest(api.TargetPoolsRemoveHealthCheckRequest o) {

3911 buildCounterTargetPoolsRemoveHealthCheckRequest++;

3912 if (buildCounterTargetPoolsRemoveHealthCheckRequest < 3) {

3913 checkUnnamed920(o.healthChecks);

3914 }

3915 buildCounterTargetPoolsRemoveHealthCheckRequest--;

3916 }

3917

3918 buildUnnamed921() {

3919 var o = new core.List<api.InstanceReference>();

3920 o.add(buildInstanceReference());

3921 o.add(buildInstanceReference());

3922 return o;

3923 }

3924

3925 checkUnnamed921(core.List<api.InstanceReference> o) {

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

3927 checkInstanceReference(o[0]);

3928 checkInstanceReference(o[1]);

3929 }

3930

3931 core.int buildCounterTargetPoolsRemoveInstanceRequest = 0;

3932 buildTargetPoolsRemoveInstanceRequest() {

3933 var o = new api.TargetPoolsRemoveInstanceRequest();

3934 buildCounterTargetPoolsRemoveInstanceRequest++;

3935 if (buildCounterTargetPoolsRemoveInstanceRequest < 3) {

3936 o.instances = buildUnnamed921();

3937 }

3938 buildCounterTargetPoolsRemoveInstanceRequest--;

3939 return o;

3940 }

3941

3942 checkTargetPoolsRemoveInstanceRequest(api.TargetPoolsRemoveInstanceRequest o) {

3943 buildCounterTargetPoolsRemoveInstanceRequest++;

3944 if (buildCounterTargetPoolsRemoveInstanceRequest < 3) {

3945 checkUnnamed921(o.instances);

3946 }

3947 buildCounterTargetPoolsRemoveInstanceRequest--;

3948 }

3949

3950 buildUnnamed922() {

3951 var o = new core.List<api.TargetPool>();

3952 o.add(buildTargetPool());

3953 o.add(buildTargetPool());

3954 return o;

3955 }

3956

3957 checkUnnamed922(core.List<api.TargetPool> o) {

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

3959 checkTargetPool(o[0]);

3960 checkTargetPool(o[1]);

3961 }

3962

3963 core.int buildCounterTargetPoolsScopedListWarningData = 0;

3964 buildTargetPoolsScopedListWarningData() {

3965 var o = new api.TargetPoolsScopedListWarningData();

3966 buildCounterTargetPoolsScopedListWarningData++;

3967 if (buildCounterTargetPoolsScopedListWarningData < 3) {

3968 o.key = "foo";

3969 o.value = "foo";

3970 }

3971 buildCounterTargetPoolsScopedListWarningData--;

3972 return o;

3973 }

3974

3975 checkTargetPoolsScopedListWarningData(api.TargetPoolsScopedListWarningData o) {

3976 buildCounterTargetPoolsScopedListWarningData++;

3977 if (buildCounterTargetPoolsScopedListWarningData < 3) {

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

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

3980 }

3981 buildCounterTargetPoolsScopedListWarningData--;

3982 }

3983

3984 buildUnnamed923() {

3985 var o = new core.List<api.TargetPoolsScopedListWarningData>();

3986 o.add(buildTargetPoolsScopedListWarningData());

3987 o.add(buildTargetPoolsScopedListWarningData());

3988 return o;

3989 }

3990

3991 checkUnnamed923(core.List<api.TargetPoolsScopedListWarningData> o) {

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

3993 checkTargetPoolsScopedListWarningData(o[0]);

3994 checkTargetPoolsScopedListWarningData(o[1]);

3995 }

3996

3997 core.int buildCounterTargetPoolsScopedListWarning = 0;

3998 buildTargetPoolsScopedListWarning() {

3999 var o = new api.TargetPoolsScopedListWarning();

4000 buildCounterTargetPoolsScopedListWarning++;

4001 if (buildCounterTargetPoolsScopedListWarning < 3) {

4002 o.code = "foo";

4003 o.data = buildUnnamed923();

4004 o.message = "foo";

4005 }

4006 buildCounterTargetPoolsScopedListWarning--;

4007 return o;

4008 }

4009

4010 checkTargetPoolsScopedListWarning(api.TargetPoolsScopedListWarning o) {

4011 buildCounterTargetPoolsScopedListWarning++;

4012 if (buildCounterTargetPoolsScopedListWarning < 3) {

4013 unittest.expect(o.code, unittest.equals('foo'));

4014 checkUnnamed923(o.data);

4015 unittest.expect(o.message, unittest.equals('foo'));

4016 }

4017 buildCounterTargetPoolsScopedListWarning--;

4018 }

4019

4020 core.int buildCounterTargetPoolsScopedList = 0;

4021 buildTargetPoolsScopedList() {

4022 var o = new api.TargetPoolsScopedList();

4023 buildCounterTargetPoolsScopedList++;

4024 if (buildCounterTargetPoolsScopedList < 3) {

4025 o.targetPools = buildUnnamed922();

4026 o.warning = buildTargetPoolsScopedListWarning();

4027 }

4028 buildCounterTargetPoolsScopedList--;

4029 return o;

4030 }

4031

4032 checkTargetPoolsScopedList(api.TargetPoolsScopedList o) {

4033 buildCounterTargetPoolsScopedList++;

4034 if (buildCounterTargetPoolsScopedList < 3) {

4035 checkUnnamed922(o.targetPools);

4036 checkTargetPoolsScopedListWarning(o.warning);

4037 }

4038 buildCounterTargetPoolsScopedList--;

4039 }

4040

4041 core.int buildCounterTargetReference = 0;

4042 buildTargetReference() {

4043 var o = new api.TargetReference();

4044 buildCounterTargetReference++;

4045 if (buildCounterTargetReference < 3) {

4046 o.target = "foo";

4047 }

4048 buildCounterTargetReference--;

4049 return o;

4050 }

4051

4052 checkTargetReference(api.TargetReference o) {

4053 buildCounterTargetReference++;

4054 if (buildCounterTargetReference < 3) {

4055 unittest.expect(o.target, unittest.equals('foo'));

4056 }

4057 buildCounterTargetReference--;

4058 }

4059

4060 core.int buildCounterTestFailure = 0;

4061 buildTestFailure() {

4062 var o = new api.TestFailure();

4063 buildCounterTestFailure++;

4064 if (buildCounterTestFailure < 3) {

4065 o.actualService = "foo";

4066 o.expectedService = "foo";

4067 o.host = "foo";

4068 o.path = "foo";

4069 }

4070 buildCounterTestFailure--;

4071 return o;

4072 }

4073

4074 checkTestFailure(api.TestFailure o) {

4075 buildCounterTestFailure++;

4076 if (buildCounterTestFailure < 3) {

4077 unittest.expect(o.actualService, unittest.equals('foo'));

4078 unittest.expect(o.expectedService, unittest.equals('foo'));

4079 unittest.expect(o.host, unittest.equals('foo'));

4080 unittest.expect(o.path, unittest.equals('foo'));

4081 }

4082 buildCounterTestFailure--;

4083 }

4084

4085 buildUnnamed924() {

4086 var o = new core.List<api.HostRule>();

4087 o.add(buildHostRule());

4088 o.add(buildHostRule());

4089 return o;

4090 }

4091

4092 checkUnnamed924(core.List<api.HostRule> o) {

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

4094 checkHostRule(o[0]);

4095 checkHostRule(o[1]);

4096 }

4097

4098 buildUnnamed925() {

4099 var o = new core.List<api.PathMatcher>();

4100 o.add(buildPathMatcher());

4101 o.add(buildPathMatcher());

4102 return o;

4103 }

4104

4105 checkUnnamed925(core.List<api.PathMatcher> o) {

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

4107 checkPathMatcher(o[0]);

4108 checkPathMatcher(o[1]);

4109 }

4110

4111 buildUnnamed926() {

4112 var o = new core.List<api.UrlMapTest>();

4113 o.add(buildUrlMapTest());

4114 o.add(buildUrlMapTest());

4115 return o;

4116 }

4117

4118 checkUnnamed926(core.List<api.UrlMapTest> o) {

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

4120 checkUrlMapTest(o[0]);

4121 checkUrlMapTest(o[1]);

4122 }

4123

4124 core.int buildCounterUrlMap = 0;

4125 buildUrlMap() {

4126 var o = new api.UrlMap();

4127 buildCounterUrlMap++;

4128 if (buildCounterUrlMap < 3) {

4129 o.creationTimestamp = "foo";

4130 o.defaultService = "foo";

4131 o.description = "foo";

4132 o.fingerprint = "foo";

4133 o.hostRules = buildUnnamed924();

4134 o.id = "foo";

4135 o.kind = "foo";

4136 o.name = "foo";

4137 o.pathMatchers = buildUnnamed925();

4138 o.selfLink = "foo";

4139 o.tests = buildUnnamed926();

4140 }

4141 buildCounterUrlMap--;

4142 return o;

4143 }

4144

4145 checkUrlMap(api.UrlMap o) {

4146 buildCounterUrlMap++;

4147 if (buildCounterUrlMap < 3) {

4148 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

4149 unittest.expect(o.defaultService, unittest.equals('foo'));

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

4151 unittest.expect(o.fingerprint, unittest.equals('foo'));

4152 checkUnnamed924(o.hostRules);

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

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

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

4156 checkUnnamed925(o.pathMatchers);

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

4158 checkUnnamed926(o.tests);

4159 }

4160 buildCounterUrlMap--;

4161 }

4162

4163 buildUnnamed927() {

4164 var o = new core.List<api.UrlMap>();

4165 o.add(buildUrlMap());

4166 o.add(buildUrlMap());

4167 return o;

4168 }

4169

4170 checkUnnamed927(core.List<api.UrlMap> o) {

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

4172 checkUrlMap(o[0]);

4173 checkUrlMap(o[1]);

4174 }

4175

4176 core.int buildCounterUrlMapList = 0;

4177 buildUrlMapList() {

4178 var o = new api.UrlMapList();

4179 buildCounterUrlMapList++;

4180 if (buildCounterUrlMapList < 3) {

4181 o.id = "foo";

4182 o.items = buildUnnamed927();

4183 o.kind = "foo";

4184 o.nextPageToken = "foo";

4185 o.selfLink = "foo";

4186 }

4187 buildCounterUrlMapList--;

4188 return o;

4189 }

4190

4191 checkUrlMapList(api.UrlMapList o) {

4192 buildCounterUrlMapList++;

4193 if (buildCounterUrlMapList < 3) {

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

4195 checkUnnamed927(o.items);

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

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

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

4199 }

4200 buildCounterUrlMapList--;

4201 }

4202

4203 core.int buildCounterUrlMapReference = 0;

4204 buildUrlMapReference() {

4205 var o = new api.UrlMapReference();

4206 buildCounterUrlMapReference++;

4207 if (buildCounterUrlMapReference < 3) {

4208 o.urlMap = "foo";

4209 }

4210 buildCounterUrlMapReference--;

4211 return o;

4212 }

4213

4214 checkUrlMapReference(api.UrlMapReference o) {

4215 buildCounterUrlMapReference++;

4216 if (buildCounterUrlMapReference < 3) {

4217 unittest.expect(o.urlMap, unittest.equals('foo'));

4218 }

4219 buildCounterUrlMapReference--;

4220 }

4221

4222 core.int buildCounterUrlMapTest = 0;

4223 buildUrlMapTest() {

4224 var o = new api.UrlMapTest();

4225 buildCounterUrlMapTest++;

4226 if (buildCounterUrlMapTest < 3) {

4227 o.description = "foo";

4228 o.host = "foo";

4229 o.path = "foo";

4230 o.service = "foo";

4231 }

4232 buildCounterUrlMapTest--;

4233 return o;

4234 }

4235

4236 checkUrlMapTest(api.UrlMapTest o) {

4237 buildCounterUrlMapTest++;

4238 if (buildCounterUrlMapTest < 3) {

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

4240 unittest.expect(o.host, unittest.equals('foo'));

4241 unittest.expect(o.path, unittest.equals('foo'));

4242 unittest.expect(o.service, unittest.equals('foo'));

4243 }

4244 buildCounterUrlMapTest--;

4245 }

4246

4247 buildUnnamed928() {

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

4249 o.add("foo");

4250 o.add("foo");

4251 return o;

4252 }

4253

4254 checkUnnamed928(core.List<core.String> o) {

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

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

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

4258 }

4259

4260 buildUnnamed929() {

4261 var o = new core.List<api.TestFailure>();

4262 o.add(buildTestFailure());

4263 o.add(buildTestFailure());

4264 return o;

4265 }

4266

4267 checkUnnamed929(core.List<api.TestFailure> o) {

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

4269 checkTestFailure(o[0]);

4270 checkTestFailure(o[1]);

4271 }

4272

4273 core.int buildCounterUrlMapValidationResult = 0;

4274 buildUrlMapValidationResult() {

4275 var o = new api.UrlMapValidationResult();

4276 buildCounterUrlMapValidationResult++;

4277 if (buildCounterUrlMapValidationResult < 3) {

4278 o.loadErrors = buildUnnamed928();

4279 o.loadSucceeded = true;

4280 o.testFailures = buildUnnamed929();

4281 o.testPassed = true;

4282 }

4283 buildCounterUrlMapValidationResult--;

4284 return o;

4285 }

4286

4287 checkUrlMapValidationResult(api.UrlMapValidationResult o) {

4288 buildCounterUrlMapValidationResult++;

4289 if (buildCounterUrlMapValidationResult < 3) {

4290 checkUnnamed928(o.loadErrors);

4291 unittest.expect(o.loadSucceeded, unittest.isTrue);

4292 checkUnnamed929(o.testFailures);

4293 unittest.expect(o.testPassed, unittest.isTrue);

4294 }

4295 buildCounterUrlMapValidationResult--;

4296 }

4297

4298 core.int buildCounterUrlMapsValidateRequest = 0;

4299 buildUrlMapsValidateRequest() {

4300 var o = new api.UrlMapsValidateRequest();

4301 buildCounterUrlMapsValidateRequest++;

4302 if (buildCounterUrlMapsValidateRequest < 3) {

4303 o.resource = buildUrlMap();

4304 }

4305 buildCounterUrlMapsValidateRequest--;

4306 return o;

4307 }

4308

4309 checkUrlMapsValidateRequest(api.UrlMapsValidateRequest o) {

4310 buildCounterUrlMapsValidateRequest++;

4311 if (buildCounterUrlMapsValidateRequest < 3) {

4312 checkUrlMap(o.resource);

4313 }

4314 buildCounterUrlMapsValidateRequest--;

4315 }

4316

4317 core.int buildCounterUrlMapsValidateResponse = 0;

4318 buildUrlMapsValidateResponse() {

4319 var o = new api.UrlMapsValidateResponse();

4320 buildCounterUrlMapsValidateResponse++;

4321 if (buildCounterUrlMapsValidateResponse < 3) {

4322 o.result = buildUrlMapValidationResult();

4323 }

4324 buildCounterUrlMapsValidateResponse--;

4325 return o;

4326 }

4327

4328 checkUrlMapsValidateResponse(api.UrlMapsValidateResponse o) {

4329 buildCounterUrlMapsValidateResponse++;

4330 if (buildCounterUrlMapsValidateResponse < 3) {

4331 checkUrlMapValidationResult(o.result);

4332 }

4333 buildCounterUrlMapsValidateResponse--;

4334 }

4335

4336 core.int buildCounterUsageExportLocation = 0;

4337 buildUsageExportLocation() {

4338 var o = new api.UsageExportLocation();

4339 buildCounterUsageExportLocation++;

4340 if (buildCounterUsageExportLocation < 3) {

4341 o.bucketName = "foo";

4342 o.reportNamePrefix = "foo";

4343 }

4344 buildCounterUsageExportLocation--;

4345 return o;

4346 }

4347

4348 checkUsageExportLocation(api.UsageExportLocation o) {

4349 buildCounterUsageExportLocation++;

4350 if (buildCounterUsageExportLocation < 3) {

4351 unittest.expect(o.bucketName, unittest.equals('foo'));

4352 unittest.expect(o.reportNamePrefix, unittest.equals('foo'));

4353 }

4354 buildCounterUsageExportLocation--;

4355 }

4356

4357 core.int buildCounterZoneMaintenanceWindows = 0;

4358 buildZoneMaintenanceWindows() {

4359 var o = new api.ZoneMaintenanceWindows();

4360 buildCounterZoneMaintenanceWindows++;

4361 if (buildCounterZoneMaintenanceWindows < 3) {

4362 o.beginTime = "foo";

4363 o.description = "foo";

4364 o.endTime = "foo";

4365 o.name = "foo";

4366 }

4367 buildCounterZoneMaintenanceWindows--;

4368 return o;

4369 }

4370

4371 checkZoneMaintenanceWindows(api.ZoneMaintenanceWindows o) {

4372 buildCounterZoneMaintenanceWindows++;

4373 if (buildCounterZoneMaintenanceWindows < 3) {

4374 unittest.expect(o.beginTime, unittest.equals('foo'));

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

4376 unittest.expect(o.endTime, unittest.equals('foo'));

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

4378 }

4379 buildCounterZoneMaintenanceWindows--;

4380 }

4381

4382 buildUnnamed930() {

4383 var o = new core.List<api.ZoneMaintenanceWindows>();

4384 o.add(buildZoneMaintenanceWindows());

4385 o.add(buildZoneMaintenanceWindows());

4386 return o;

4387 }

4388

4389 checkUnnamed930(core.List<api.ZoneMaintenanceWindows> o) {

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

4391 checkZoneMaintenanceWindows(o[0]);

4392 checkZoneMaintenanceWindows(o[1]);

4393 }

4394

4395 core.int buildCounterZone = 0;

4396 buildZone() {

4397 var o = new api.Zone();

4398 buildCounterZone++;

4399 if (buildCounterZone < 3) {

4400 o.creationTimestamp = "foo";

4401 o.deprecated = buildDeprecationStatus();

4402 o.description = "foo";

4403 o.id = "foo";

4404 o.kind = "foo";

4405 o.maintenanceWindows = buildUnnamed930();

4406 o.name = "foo";

4407 o.region = "foo";

4408 o.selfLink = "foo";

4409 o.status = "foo";

4410 }

4411 buildCounterZone--;

4412 return o;

4413 }

4414

4415 checkZone(api.Zone o) {

4416 buildCounterZone++;

4417 if (buildCounterZone < 3) {

4418 unittest.expect(o.creationTimestamp, unittest.equals('foo'));

4419 checkDeprecationStatus(o.deprecated);

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

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

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

4423 checkUnnamed930(o.maintenanceWindows);

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

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

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

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

4428 }

4429 buildCounterZone--;

4430 }

4431

4432 buildUnnamed931() {

4433 var o = new core.List<api.Zone>();

4434 o.add(buildZone());

4435 o.add(buildZone());

4436 return o;

4437 }

4438

4439 checkUnnamed931(core.List<api.Zone> o) {

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

4441 checkZone(o[0]);

4442 checkZone(o[1]);

4443 }

4444

4445 core.int buildCounterZoneList = 0;

4446 buildZoneList() {

4447 var o = new api.ZoneList();

4448 buildCounterZoneList++;

4449 if (buildCounterZoneList < 3) {

4450 o.id = "foo";

4451 o.items = buildUnnamed931();

4452 o.kind = "foo";

4453 o.nextPageToken = "foo";

4454 o.selfLink = "foo";

4455 }

4456 buildCounterZoneList--;

4457 return o;

4458 }

4459

4460 checkZoneList(api.ZoneList o) {

4461 buildCounterZoneList++;

4462 if (buildCounterZoneList < 3) {

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

4464 checkUnnamed931(o.items);

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

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

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

4468 }

4469 buildCounterZoneList--;

4470 }

4471

4472

4473 main() {

4474 unittest.group("obj-schema-AccessConfig", () {

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

4476 var o = buildAccessConfig();

4477 var od = new api.AccessConfig.fromJson(o.toJson());

4478 checkAccessConfig(od);

4479 });

4480 });

4481

4482

4483 unittest.group("obj-schema-Address", () {

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

4485 var o = buildAddress();

4486 var od = new api.Address.fromJson(o.toJson());

4487 checkAddress(od);

4488 });

4489 });

4490

4491

4492 unittest.group("obj-schema-AddressAggregatedList", () {

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

4494 var o = buildAddressAggregatedList();

4495 var od = new api.AddressAggregatedList.fromJson(o.toJson());

4496 checkAddressAggregatedList(od);

4497 });

4498 });

4499

4500

4501 unittest.group("obj-schema-AddressList", () {

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

4503 var o = buildAddressList();

4504 var od = new api.AddressList.fromJson(o.toJson());

4505 checkAddressList(od);

4506 });

4507 });

4508

4509

4510 unittest.group("obj-schema-AddressesScopedListWarningData", () {

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

4512 var o = buildAddressesScopedListWarningData();

4513 var od = new api.AddressesScopedListWarningData.fromJson(o.toJson());

4514 checkAddressesScopedListWarningData(od);

4515 });

4516 });

4517

4518

4519 unittest.group("obj-schema-AddressesScopedListWarning", () {

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

4521 var o = buildAddressesScopedListWarning();

4522 var od = new api.AddressesScopedListWarning.fromJson(o.toJson());

4523 checkAddressesScopedListWarning(od);

4524 });

4525 });

4526

4527

4528 unittest.group("obj-schema-AddressesScopedList", () {

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

4530 var o = buildAddressesScopedList();

4531 var od = new api.AddressesScopedList.fromJson(o.toJson());

4532 checkAddressesScopedList(od);

4533 });

4534 });

4535

4536

4537 unittest.group("obj-schema-AttachedDisk", () {

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

4539 var o = buildAttachedDisk();

4540 var od = new api.AttachedDisk.fromJson(o.toJson());

4541 checkAttachedDisk(od);

4542 });

4543 });

4544

4545

4546 unittest.group("obj-schema-AttachedDiskInitializeParams", () {

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

4548 var o = buildAttachedDiskInitializeParams();

4549 var od = new api.AttachedDiskInitializeParams.fromJson(o.toJson());

4550 checkAttachedDiskInitializeParams(od);

4551 });

4552 });

4553

4554

4555 unittest.group("obj-schema-Backend", () {

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

4557 var o = buildBackend();

4558 var od = new api.Backend.fromJson(o.toJson());

4559 checkBackend(od);

4560 });

4561 });

4562

4563

4564 unittest.group("obj-schema-BackendService", () {

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

4566 var o = buildBackendService();

4567 var od = new api.BackendService.fromJson(o.toJson());

4568 checkBackendService(od);

4569 });

4570 });

4571

4572

4573 unittest.group("obj-schema-BackendServiceGroupHealth", () {

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

4575 var o = buildBackendServiceGroupHealth();

4576 var od = new api.BackendServiceGroupHealth.fromJson(o.toJson());

4577 checkBackendServiceGroupHealth(od);

4578 });

4579 });

4580

4581

4582 unittest.group("obj-schema-BackendServiceList", () {

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

4584 var o = buildBackendServiceList();

4585 var od = new api.BackendServiceList.fromJson(o.toJson());

4586 checkBackendServiceList(od);

4587 });

4588 });

4589

4590

4591 unittest.group("obj-schema-DeprecationStatus", () {

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

4593 var o = buildDeprecationStatus();

4594 var od = new api.DeprecationStatus.fromJson(o.toJson());

4595 checkDeprecationStatus(od);

4596 });

4597 });

4598

4599

4600 unittest.group("obj-schema-Disk", () {

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

4602 var o = buildDisk();

4603 var od = new api.Disk.fromJson(o.toJson());

4604 checkDisk(od);

4605 });

4606 });

4607

4608

4609 unittest.group("obj-schema-DiskAggregatedList", () {

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

4611 var o = buildDiskAggregatedList();

4612 var od = new api.DiskAggregatedList.fromJson(o.toJson());

4613 checkDiskAggregatedList(od);

4614 });

4615 });

4616

4617

4618 unittest.group("obj-schema-DiskList", () {

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

4620 var o = buildDiskList();

4621 var od = new api.DiskList.fromJson(o.toJson());

4622 checkDiskList(od);

4623 });

4624 });

4625

4626

4627 unittest.group("obj-schema-DiskType", () {

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

4629 var o = buildDiskType();

4630 var od = new api.DiskType.fromJson(o.toJson());

4631 checkDiskType(od);

4632 });

4633 });

4634

4635

4636 unittest.group("obj-schema-DiskTypeAggregatedList", () {

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

4638 var o = buildDiskTypeAggregatedList();

4639 var od = new api.DiskTypeAggregatedList.fromJson(o.toJson());

4640 checkDiskTypeAggregatedList(od);

4641 });

4642 });

4643

4644

4645 unittest.group("obj-schema-DiskTypeList", () {

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

4647 var o = buildDiskTypeList();

4648 var od = new api.DiskTypeList.fromJson(o.toJson());

4649 checkDiskTypeList(od);

4650 });

4651 });

4652

4653

4654 unittest.group("obj-schema-DiskTypesScopedListWarningData", () {

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

4656 var o = buildDiskTypesScopedListWarningData();

4657 var od = new api.DiskTypesScopedListWarningData.fromJson(o.toJson());

4658 checkDiskTypesScopedListWarningData(od);

4659 });

4660 });

4661

4662

4663 unittest.group("obj-schema-DiskTypesScopedListWarning", () {

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

4665 var o = buildDiskTypesScopedListWarning();

4666 var od = new api.DiskTypesScopedListWarning.fromJson(o.toJson());

4667 checkDiskTypesScopedListWarning(od);

4668 });

4669 });

4670

4671

4672 unittest.group("obj-schema-DiskTypesScopedList", () {

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

4674 var o = buildDiskTypesScopedList();

4675 var od = new api.DiskTypesScopedList.fromJson(o.toJson());

4676 checkDiskTypesScopedList(od);

4677 });

4678 });

4679

4680

4681 unittest.group("obj-schema-DisksScopedListWarningData", () {

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

4683 var o = buildDisksScopedListWarningData();

4684 var od = new api.DisksScopedListWarningData.fromJson(o.toJson());

4685 checkDisksScopedListWarningData(od);

4686 });

4687 });

4688

4689

4690 unittest.group("obj-schema-DisksScopedListWarning", () {

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

4692 var o = buildDisksScopedListWarning();

4693 var od = new api.DisksScopedListWarning.fromJson(o.toJson());

4694 checkDisksScopedListWarning(od);

4695 });

4696 });

4697

4698

4699 unittest.group("obj-schema-DisksScopedList", () {

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

4701 var o = buildDisksScopedList();

4702 var od = new api.DisksScopedList.fromJson(o.toJson());

4703 checkDisksScopedList(od);

4704 });

4705 });

4706

4707

4708 unittest.group("obj-schema-FirewallAllowed", () {

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

4710 var o = buildFirewallAllowed();

4711 var od = new api.FirewallAllowed.fromJson(o.toJson());

4712 checkFirewallAllowed(od);

4713 });

4714 });

4715

4716

4717 unittest.group("obj-schema-Firewall", () {

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

4719 var o = buildFirewall();

4720 var od = new api.Firewall.fromJson(o.toJson());

4721 checkFirewall(od);

4722 });

4723 });

4724

4725

4726 unittest.group("obj-schema-FirewallList", () {

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

4728 var o = buildFirewallList();

4729 var od = new api.FirewallList.fromJson(o.toJson());

4730 checkFirewallList(od);

4731 });

4732 });

4733

4734

4735 unittest.group("obj-schema-ForwardingRule", () {

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

4737 var o = buildForwardingRule();

4738 var od = new api.ForwardingRule.fromJson(o.toJson());

4739 checkForwardingRule(od);

4740 });

4741 });

4742

4743

4744 unittest.group("obj-schema-ForwardingRuleAggregatedList", () {

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

4746 var o = buildForwardingRuleAggregatedList();

4747 var od = new api.ForwardingRuleAggregatedList.fromJson(o.toJson());

4748 checkForwardingRuleAggregatedList(od);

4749 });

4750 });

4751

4752

4753 unittest.group("obj-schema-ForwardingRuleList", () {

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

4755 var o = buildForwardingRuleList();

4756 var od = new api.ForwardingRuleList.fromJson(o.toJson());

4757 checkForwardingRuleList(od);

4758 });

4759 });

4760

4761

4762 unittest.group("obj-schema-ForwardingRulesScopedListWarningData", () {

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

4764 var o = buildForwardingRulesScopedListWarningData();

4765 var od = new api.ForwardingRulesScopedListWarningData.fromJson(o.toJson()) ;

4766 checkForwardingRulesScopedListWarningData(od);

4767 });

4768 });

4769

4770

4771 unittest.group("obj-schema-ForwardingRulesScopedListWarning", () {

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

4773 var o = buildForwardingRulesScopedListWarning();

4774 var od = new api.ForwardingRulesScopedListWarning.fromJson(o.toJson());

4775 checkForwardingRulesScopedListWarning(od);

4776 });

4777 });

4778

4779

4780 unittest.group("obj-schema-ForwardingRulesScopedList", () {

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

4782 var o = buildForwardingRulesScopedList();

4783 var od = new api.ForwardingRulesScopedList.fromJson(o.toJson());

4784 checkForwardingRulesScopedList(od);

4785 });

4786 });

4787

4788

4789 unittest.group("obj-schema-HealthCheckReference", () {

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

4791 var o = buildHealthCheckReference();

4792 var od = new api.HealthCheckReference.fromJson(o.toJson());

4793 checkHealthCheckReference(od);

4794 });

4795 });

4796

4797

4798 unittest.group("obj-schema-HealthStatus", () {

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

4800 var o = buildHealthStatus();

4801 var od = new api.HealthStatus.fromJson(o.toJson());

4802 checkHealthStatus(od);

4803 });

4804 });

4805

4806

4807 unittest.group("obj-schema-HostRule", () {

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

4809 var o = buildHostRule();

4810 var od = new api.HostRule.fromJson(o.toJson());

4811 checkHostRule(od);

4812 });

4813 });

4814

4815

4816 unittest.group("obj-schema-HttpHealthCheck", () {

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

4818 var o = buildHttpHealthCheck();

4819 var od = new api.HttpHealthCheck.fromJson(o.toJson());

4820 checkHttpHealthCheck(od);

4821 });

4822 });

4823

4824

4825 unittest.group("obj-schema-HttpHealthCheckList", () {

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

4827 var o = buildHttpHealthCheckList();

4828 var od = new api.HttpHealthCheckList.fromJson(o.toJson());

4829 checkHttpHealthCheckList(od);

4830 });

4831 });

4832

4833

4834 unittest.group("obj-schema-ImageRawDisk", () {

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

4836 var o = buildImageRawDisk();

4837 var od = new api.ImageRawDisk.fromJson(o.toJson());

4838 checkImageRawDisk(od);

4839 });

4840 });

4841

4842

4843 unittest.group("obj-schema-Image", () {

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

4845 var o = buildImage();

4846 var od = new api.Image.fromJson(o.toJson());

4847 checkImage(od);

4848 });

4849 });

4850

4851

4852 unittest.group("obj-schema-ImageList", () {

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

4854 var o = buildImageList();

4855 var od = new api.ImageList.fromJson(o.toJson());

4856 checkImageList(od);

4857 });

4858 });

4859

4860

4861 unittest.group("obj-schema-Instance", () {

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

4863 var o = buildInstance();

4864 var od = new api.Instance.fromJson(o.toJson());

4865 checkInstance(od);

4866 });

4867 });

4868

4869

4870 unittest.group("obj-schema-InstanceAggregatedList", () {

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

4872 var o = buildInstanceAggregatedList();

4873 var od = new api.InstanceAggregatedList.fromJson(o.toJson());

4874 checkInstanceAggregatedList(od);

4875 });

4876 });

4877

4878

4879 unittest.group("obj-schema-InstanceList", () {

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

4881 var o = buildInstanceList();

4882 var od = new api.InstanceList.fromJson(o.toJson());

4883 checkInstanceList(od);

4884 });

4885 });

4886

4887

4888 unittest.group("obj-schema-InstanceReference", () {

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

4890 var o = buildInstanceReference();

4891 var od = new api.InstanceReference.fromJson(o.toJson());

4892 checkInstanceReference(od);

4893 });

4894 });

4895

4896

4897 unittest.group("obj-schema-InstancesScopedListWarningData", () {

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

4899 var o = buildInstancesScopedListWarningData();

4900 var od = new api.InstancesScopedListWarningData.fromJson(o.toJson());

4901 checkInstancesScopedListWarningData(od);

4902 });

4903 });

4904

4905

4906 unittest.group("obj-schema-InstancesScopedListWarning", () {

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

4908 var o = buildInstancesScopedListWarning();

4909 var od = new api.InstancesScopedListWarning.fromJson(o.toJson());

4910 checkInstancesScopedListWarning(od);

4911 });

4912 });

4913

4914

4915 unittest.group("obj-schema-InstancesScopedList", () {

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

4917 var o = buildInstancesScopedList();

4918 var od = new api.InstancesScopedList.fromJson(o.toJson());

4919 checkInstancesScopedList(od);

4920 });

4921 });

4922

4923

4924 unittest.group("obj-schema-License", () {

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

4926 var o = buildLicense();

4927 var od = new api.License.fromJson(o.toJson());

4928 checkLicense(od);

4929 });

4930 });

4931

4932

4933 unittest.group("obj-schema-MachineTypeScratchDisks", () {

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

4935 var o = buildMachineTypeScratchDisks();

4936 var od = new api.MachineTypeScratchDisks.fromJson(o.toJson());

4937 checkMachineTypeScratchDisks(od);

4938 });

4939 });

4940

4941

4942 unittest.group("obj-schema-MachineType", () {

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

4944 var o = buildMachineType();

4945 var od = new api.MachineType.fromJson(o.toJson());

4946 checkMachineType(od);

4947 });

4948 });

4949

4950

4951 unittest.group("obj-schema-MachineTypeAggregatedList", () {

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

4953 var o = buildMachineTypeAggregatedList();

4954 var od = new api.MachineTypeAggregatedList.fromJson(o.toJson());

4955 checkMachineTypeAggregatedList(od);

4956 });

4957 });

4958

4959

4960 unittest.group("obj-schema-MachineTypeList", () {

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

4962 var o = buildMachineTypeList();

4963 var od = new api.MachineTypeList.fromJson(o.toJson());

4964 checkMachineTypeList(od);

4965 });

4966 });

4967

4968

4969 unittest.group("obj-schema-MachineTypesScopedListWarningData", () {

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

4971 var o = buildMachineTypesScopedListWarningData();

4972 var od = new api.MachineTypesScopedListWarningData.fromJson(o.toJson());

4973 checkMachineTypesScopedListWarningData(od);

4974 });

4975 });

4976

4977

4978 unittest.group("obj-schema-MachineTypesScopedListWarning", () {

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

4980 var o = buildMachineTypesScopedListWarning();

4981 var od = new api.MachineTypesScopedListWarning.fromJson(o.toJson());

4982 checkMachineTypesScopedListWarning(od);

4983 });

4984 });

4985

4986

4987 unittest.group("obj-schema-MachineTypesScopedList", () {

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

4989 var o = buildMachineTypesScopedList();

4990 var od = new api.MachineTypesScopedList.fromJson(o.toJson());

4991 checkMachineTypesScopedList(od);

4992 });

4993 });

4994

4995

4996 unittest.group("obj-schema-MetadataItems", () {

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

4998 var o = buildMetadataItems();

4999 var od = new api.MetadataItems.fromJson(o.toJson());

5000 checkMetadataItems(od);

5001 });

5002 });

5003

5004

5005 unittest.group("obj-schema-Metadata", () {

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

5007 var o = buildMetadata();

5008 var od = new api.Metadata.fromJson(o.toJson());

5009 checkMetadata(od);

5010 });

5011 });

5012

5013

5014 unittest.group("obj-schema-Network", () {

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

5016 var o = buildNetwork();

5017 var od = new api.Network.fromJson(o.toJson());

5018 checkNetwork(od);

5019 });

5020 });

5021

5022

5023 unittest.group("obj-schema-NetworkInterface", () {

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

5025 var o = buildNetworkInterface();

5026 var od = new api.NetworkInterface.fromJson(o.toJson());

5027 checkNetworkInterface(od);

5028 });

5029 });

5030

5031

5032 unittest.group("obj-schema-NetworkList", () {

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

5034 var o = buildNetworkList();

5035 var od = new api.NetworkList.fromJson(o.toJson());

5036 checkNetworkList(od);

5037 });

5038 });

5039

5040

5041 unittest.group("obj-schema-OperationErrorErrors", () {

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

5043 var o = buildOperationErrorErrors();

5044 var od = new api.OperationErrorErrors.fromJson(o.toJson());

5045 checkOperationErrorErrors(od);

5046 });

5047 });

5048

5049

5050 unittest.group("obj-schema-OperationError", () {

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

5052 var o = buildOperationError();

5053 var od = new api.OperationError.fromJson(o.toJson());

5054 checkOperationError(od);

5055 });

5056 });

5057

5058

5059 unittest.group("obj-schema-OperationWarningsData", () {

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

5061 var o = buildOperationWarningsData();

5062 var od = new api.OperationWarningsData.fromJson(o.toJson());

5063 checkOperationWarningsData(od);

5064 });

5065 });

5066

5067

5068 unittest.group("obj-schema-OperationWarnings", () {

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

5070 var o = buildOperationWarnings();

5071 var od = new api.OperationWarnings.fromJson(o.toJson());

5072 checkOperationWarnings(od);

5073 });

5074 });

5075

5076

5077 unittest.group("obj-schema-Operation", () {

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

5079 var o = buildOperation();

5080 var od = new api.Operation.fromJson(o.toJson());

5081 checkOperation(od);

5082 });

5083 });

5084

5085

5086 unittest.group("obj-schema-OperationAggregatedList", () {

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

5088 var o = buildOperationAggregatedList();

5089 var od = new api.OperationAggregatedList.fromJson(o.toJson());

5090 checkOperationAggregatedList(od);

5091 });

5092 });

5093

5094

5095 unittest.group("obj-schema-OperationList", () {

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

5097 var o = buildOperationList();

5098 var od = new api.OperationList.fromJson(o.toJson());

5099 checkOperationList(od);

5100 });

5101 });

5102

5103

5104 unittest.group("obj-schema-OperationsScopedListWarningData", () {

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

5106 var o = buildOperationsScopedListWarningData();

5107 var od = new api.OperationsScopedListWarningData.fromJson(o.toJson());

5108 checkOperationsScopedListWarningData(od);

5109 });

5110 });

5111

5112

5113 unittest.group("obj-schema-OperationsScopedListWarning", () {

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

5115 var o = buildOperationsScopedListWarning();

5116 var od = new api.OperationsScopedListWarning.fromJson(o.toJson());

5117 checkOperationsScopedListWarning(od);

5118 });

5119 });

5120

5121

5122 unittest.group("obj-schema-OperationsScopedList", () {

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

5124 var o = buildOperationsScopedList();

5125 var od = new api.OperationsScopedList.fromJson(o.toJson());

5126 checkOperationsScopedList(od);

5127 });

5128 });

5129

5130

5131 unittest.group("obj-schema-PathMatcher", () {

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

5133 var o = buildPathMatcher();

5134 var od = new api.PathMatcher.fromJson(o.toJson());

5135 checkPathMatcher(od);

5136 });

5137 });

5138

5139

5140 unittest.group("obj-schema-PathRule", () {

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

5142 var o = buildPathRule();

5143 var od = new api.PathRule.fromJson(o.toJson());

5144 checkPathRule(od);

5145 });

5146 });

5147

5148

5149 unittest.group("obj-schema-Project", () {

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

5151 var o = buildProject();

5152 var od = new api.Project.fromJson(o.toJson());

5153 checkProject(od);

5154 });

5155 });

5156

5157

5158 unittest.group("obj-schema-Quota", () {

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

5160 var o = buildQuota();

5161 var od = new api.Quota.fromJson(o.toJson());

5162 checkQuota(od);

5163 });

5164 });

5165

5166

5167 unittest.group("obj-schema-Region", () {

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

5169 var o = buildRegion();

5170 var od = new api.Region.fromJson(o.toJson());

5171 checkRegion(od);

5172 });

5173 });

5174

5175

5176 unittest.group("obj-schema-RegionList", () {

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

5178 var o = buildRegionList();

5179 var od = new api.RegionList.fromJson(o.toJson());

5180 checkRegionList(od);

5181 });

5182 });

5183

5184

5185 unittest.group("obj-schema-ResourceGroupReference", () {

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

5187 var o = buildResourceGroupReference();

5188 var od = new api.ResourceGroupReference.fromJson(o.toJson());

5189 checkResourceGroupReference(od);

5190 });

5191 });

5192

5193

5194 unittest.group("obj-schema-RouteWarningsData", () {

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

5196 var o = buildRouteWarningsData();

5197 var od = new api.RouteWarningsData.fromJson(o.toJson());

5198 checkRouteWarningsData(od);

5199 });

5200 });

5201

5202

5203 unittest.group("obj-schema-RouteWarnings", () {

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

5205 var o = buildRouteWarnings();

5206 var od = new api.RouteWarnings.fromJson(o.toJson());

5207 checkRouteWarnings(od);

5208 });

5209 });

5210

5211

5212 unittest.group("obj-schema-Route", () {

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

5214 var o = buildRoute();

5215 var od = new api.Route.fromJson(o.toJson());

5216 checkRoute(od);

5217 });

5218 });

5219

5220

5221 unittest.group("obj-schema-RouteList", () {

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

5223 var o = buildRouteList();

5224 var od = new api.RouteList.fromJson(o.toJson());

5225 checkRouteList(od);

5226 });

5227 });

5228

5229

5230 unittest.group("obj-schema-Scheduling", () {

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

5232 var o = buildScheduling();

5233 var od = new api.Scheduling.fromJson(o.toJson());

5234 checkScheduling(od);

5235 });

5236 });

5237

5238

5239 unittest.group("obj-schema-SerialPortOutput", () {

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

5241 var o = buildSerialPortOutput();

5242 var od = new api.SerialPortOutput.fromJson(o.toJson());

5243 checkSerialPortOutput(od);

5244 });

5245 });

5246

5247

5248 unittest.group("obj-schema-ServiceAccount", () {

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

5250 var o = buildServiceAccount();

5251 var od = new api.ServiceAccount.fromJson(o.toJson());

5252 checkServiceAccount(od);

5253 });

5254 });

5255

5256

5257 unittest.group("obj-schema-Snapshot", () {

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

5259 var o = buildSnapshot();

5260 var od = new api.Snapshot.fromJson(o.toJson());

5261 checkSnapshot(od);

5262 });

5263 });

5264

5265

5266 unittest.group("obj-schema-SnapshotList", () {

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

5268 var o = buildSnapshotList();

5269 var od = new api.SnapshotList.fromJson(o.toJson());

5270 checkSnapshotList(od);

5271 });

5272 });

5273

5274

5275 unittest.group("obj-schema-Tags", () {

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

5277 var o = buildTags();

5278 var od = new api.Tags.fromJson(o.toJson());

5279 checkTags(od);

5280 });

5281 });

5282

5283

5284 unittest.group("obj-schema-TargetHttpProxy", () {

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

5286 var o = buildTargetHttpProxy();

5287 var od = new api.TargetHttpProxy.fromJson(o.toJson());

5288 checkTargetHttpProxy(od);

5289 });

5290 });

5291

5292

5293 unittest.group("obj-schema-TargetHttpProxyList", () {

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

5295 var o = buildTargetHttpProxyList();

5296 var od = new api.TargetHttpProxyList.fromJson(o.toJson());

5297 checkTargetHttpProxyList(od);

5298 });

5299 });

5300

5301

5302 unittest.group("obj-schema-TargetInstance", () {

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

5304 var o = buildTargetInstance();

5305 var od = new api.TargetInstance.fromJson(o.toJson());

5306 checkTargetInstance(od);

5307 });

5308 });

5309

5310

5311 unittest.group("obj-schema-TargetInstanceAggregatedList", () {

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

5313 var o = buildTargetInstanceAggregatedList();

5314 var od = new api.TargetInstanceAggregatedList.fromJson(o.toJson());

5315 checkTargetInstanceAggregatedList(od);

5316 });

5317 });

5318

5319

5320 unittest.group("obj-schema-TargetInstanceList", () {

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

5322 var o = buildTargetInstanceList();

5323 var od = new api.TargetInstanceList.fromJson(o.toJson());

5324 checkTargetInstanceList(od);

5325 });

5326 });

5327

5328

5329 unittest.group("obj-schema-TargetInstancesScopedListWarningData", () {

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

5331 var o = buildTargetInstancesScopedListWarningData();

5332 var od = new api.TargetInstancesScopedListWarningData.fromJson(o.toJson()) ;

5333 checkTargetInstancesScopedListWarningData(od);

5334 });

5335 });

5336

5337

5338 unittest.group("obj-schema-TargetInstancesScopedListWarning", () {

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

5340 var o = buildTargetInstancesScopedListWarning();

5341 var od = new api.TargetInstancesScopedListWarning.fromJson(o.toJson());

5342 checkTargetInstancesScopedListWarning(od);

5343 });

5344 });

5345

5346

5347 unittest.group("obj-schema-TargetInstancesScopedList", () {

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

5349 var o = buildTargetInstancesScopedList();

5350 var od = new api.TargetInstancesScopedList.fromJson(o.toJson());

5351 checkTargetInstancesScopedList(od);

5352 });

5353 });

5354

5355

5356 unittest.group("obj-schema-TargetPool", () {

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

5358 var o = buildTargetPool();

5359 var od = new api.TargetPool.fromJson(o.toJson());

5360 checkTargetPool(od);

5361 });

5362 });

5363

5364

5365 unittest.group("obj-schema-TargetPoolAggregatedList", () {

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

5367 var o = buildTargetPoolAggregatedList();

5368 var od = new api.TargetPoolAggregatedList.fromJson(o.toJson());

5369 checkTargetPoolAggregatedList(od);

5370 });

5371 });

5372

5373

5374 unittest.group("obj-schema-TargetPoolInstanceHealth", () {

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

5376 var o = buildTargetPoolInstanceHealth();

5377 var od = new api.TargetPoolInstanceHealth.fromJson(o.toJson());

5378 checkTargetPoolInstanceHealth(od);

5379 });

5380 });

5381

5382

5383 unittest.group("obj-schema-TargetPoolList", () {

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

5385 var o = buildTargetPoolList();

5386 var od = new api.TargetPoolList.fromJson(o.toJson());

5387 checkTargetPoolList(od);

5388 });

5389 });

5390

5391

5392 unittest.group("obj-schema-TargetPoolsAddHealthCheckRequest", () {

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

5394 var o = buildTargetPoolsAddHealthCheckRequest();

5395 var od = new api.TargetPoolsAddHealthCheckRequest.fromJson(o.toJson());

5396 checkTargetPoolsAddHealthCheckRequest(od);

5397 });

5398 });

5399

5400

5401 unittest.group("obj-schema-TargetPoolsAddInstanceRequest", () {

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

5403 var o = buildTargetPoolsAddInstanceRequest();

5404 var od = new api.TargetPoolsAddInstanceRequest.fromJson(o.toJson());

5405 checkTargetPoolsAddInstanceRequest(od);

5406 });

5407 });

5408

5409

5410 unittest.group("obj-schema-TargetPoolsRemoveHealthCheckRequest", () {

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

5412 var o = buildTargetPoolsRemoveHealthCheckRequest();

5413 var od = new api.TargetPoolsRemoveHealthCheckRequest.fromJson(o.toJson());

5414 checkTargetPoolsRemoveHealthCheckRequest(od);

5415 });

5416 });

5417

5418

5419 unittest.group("obj-schema-TargetPoolsRemoveInstanceRequest", () {

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

5421 var o = buildTargetPoolsRemoveInstanceRequest();

5422 var od = new api.TargetPoolsRemoveInstanceRequest.fromJson(o.toJson());

5423 checkTargetPoolsRemoveInstanceRequest(od);

5424 });

5425 });

5426

5427

5428 unittest.group("obj-schema-TargetPoolsScopedListWarningData", () {

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

5430 var o = buildTargetPoolsScopedListWarningData();

5431 var od = new api.TargetPoolsScopedListWarningData.fromJson(o.toJson());

5432 checkTargetPoolsScopedListWarningData(od);

5433 });

5434 });

5435

5436

5437 unittest.group("obj-schema-TargetPoolsScopedListWarning", () {

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

5439 var o = buildTargetPoolsScopedListWarning();

5440 var od = new api.TargetPoolsScopedListWarning.fromJson(o.toJson());

5441 checkTargetPoolsScopedListWarning(od);

5442 });

5443 });

5444

5445

5446 unittest.group("obj-schema-TargetPoolsScopedList", () {

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

5448 var o = buildTargetPoolsScopedList();

5449 var od = new api.TargetPoolsScopedList.fromJson(o.toJson());

5450 checkTargetPoolsScopedList(od);

5451 });

5452 });

5453

5454

5455 unittest.group("obj-schema-TargetReference", () {

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

5457 var o = buildTargetReference();

5458 var od = new api.TargetReference.fromJson(o.toJson());

5459 checkTargetReference(od);

5460 });

5461 });

5462

5463

5464 unittest.group("obj-schema-TestFailure", () {

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

5466 var o = buildTestFailure();

5467 var od = new api.TestFailure.fromJson(o.toJson());

5468 checkTestFailure(od);

5469 });

5470 });

5471

5472

5473 unittest.group("obj-schema-UrlMap", () {

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

5475 var o = buildUrlMap();

5476 var od = new api.UrlMap.fromJson(o.toJson());

5477 checkUrlMap(od);

5478 });

5479 });

5480

5481

5482 unittest.group("obj-schema-UrlMapList", () {

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

5484 var o = buildUrlMapList();

5485 var od = new api.UrlMapList.fromJson(o.toJson());

5486 checkUrlMapList(od);

5487 });

5488 });

5489

5490

5491 unittest.group("obj-schema-UrlMapReference", () {

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

5493 var o = buildUrlMapReference();

5494 var od = new api.UrlMapReference.fromJson(o.toJson());

5495 checkUrlMapReference(od);

5496 });

5497 });

5498

5499

5500 unittest.group("obj-schema-UrlMapTest", () {

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

5502 var o = buildUrlMapTest();

5503 var od = new api.UrlMapTest.fromJson(o.toJson());

5504 checkUrlMapTest(od);

5505 });

5506 });

5507

5508

5509 unittest.group("obj-schema-UrlMapValidationResult", () {

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

5511 var o = buildUrlMapValidationResult();

5512 var od = new api.UrlMapValidationResult.fromJson(o.toJson());

5513 checkUrlMapValidationResult(od);

5514 });

5515 });

5516

5517

5518 unittest.group("obj-schema-UrlMapsValidateRequest", () {

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

5520 var o = buildUrlMapsValidateRequest();

5521 var od = new api.UrlMapsValidateRequest.fromJson(o.toJson());

5522 checkUrlMapsValidateRequest(od);

5523 });

5524 });

5525

5526

5527 unittest.group("obj-schema-UrlMapsValidateResponse", () {

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

5529 var o = buildUrlMapsValidateResponse();

5530 var od = new api.UrlMapsValidateResponse.fromJson(o.toJson());

5531 checkUrlMapsValidateResponse(od);

5532 });

5533 });

5534

5535

5536 unittest.group("obj-schema-UsageExportLocation", () {

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

5538 var o = buildUsageExportLocation();

5539 var od = new api.UsageExportLocation.fromJson(o.toJson());

5540 checkUsageExportLocation(od);

5541 });

5542 });

5543

5544

5545 unittest.group("obj-schema-ZoneMaintenanceWindows", () {

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

5547 var o = buildZoneMaintenanceWindows();

5548 var od = new api.ZoneMaintenanceWindows.fromJson(o.toJson());

5549 checkZoneMaintenanceWindows(od);

5550 });

5551 });

5552

5553

5554 unittest.group("obj-schema-Zone", () {

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

5556 var o = buildZone();

5557 var od = new api.Zone.fromJson(o.toJson());

5558 checkZone(od);

5559 });

5560 });

5561

5562

5563 unittest.group("obj-schema-ZoneList", () {

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

5565 var o = buildZoneList();

5566 var od = new api.ZoneList.fromJson(o.toJson());

5567 checkZoneList(od);

5568 });

5569 });

5570

5571

5572 unittest.group("resource-AddressesResourceApi", () {

5573 unittest.test("method--aggregatedList", () {

5574

5575 var mock = new common_test.HttpServerMock();

5576 api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;

5577 var arg_project = "foo";

5578 var arg_filter = "foo";

5579 var arg_maxResults = 42;

5580 var arg_pageToken = "foo";

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

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

5583 var pathOffset = 0;

5584 var index;

5585 var subPart;

5586 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

5587 pathOffset += 21;

5588 index = path.indexOf("/aggregated/addresses", pathOffset);

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

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

5591 pathOffset = index;

5592 unittest.expect(subPart, unittest.equals("$arg_project"));

5593 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/aggregated/addresses"));

5594 pathOffset += 21;

5595

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

5597 var queryOffset = 0;

5598 var queryMap = {};

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

5600 parseBool(n) {

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

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

5603 if (n == null) return null;

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

5605 }

5606 if (query.length > 0) {

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

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

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

5610 }

5611 }

5612 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

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

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

5615

5616

5617 var h = {

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

5619 };

5620 var resp = convert.JSON.encode(buildAddressAggregatedList());

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

5622 }), true);

5623 res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.AddressAggregate dList response) {

5624 checkAddressAggregatedList(response);

5625 })));

5626 });

5627

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

5629

5630 var mock = new common_test.HttpServerMock();

5631 api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;

5632 var arg_project = "foo";

5633 var arg_region = "foo";

5634 var arg_address = "foo";

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

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

5637 var pathOffset = 0;

5638 var index;

5639 var subPart;

5640 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

5641 pathOffset += 21;

5642 index = path.indexOf("/regions/", pathOffset);

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

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

5645 pathOffset = index;

5646 unittest.expect(subPart, unittest.equals("$arg_project"));

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

5648 pathOffset += 9;

5649 index = path.indexOf("/addresses/", pathOffset);

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

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

5652 pathOffset = index;

5653 unittest.expect(subPart, unittest.equals("$arg_region"));

5654 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/addresses/"));

5655 pathOffset += 11;

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

5657 pathOffset = path.length;

5658 unittest.expect(subPart, unittest.equals("$arg_address"));

5659

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

5661 var queryOffset = 0;

5662 var queryMap = {};

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

5664 parseBool(n) {

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

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

5667 if (n == null) return null;

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

5669 }

5670 if (query.length > 0) {

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

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

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

5674 }

5675 }

5676

5677

5678 var h = {

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

5680 };

5681 var resp = convert.JSON.encode(buildOperation());

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

5683 }), true);

5684 res.delete(arg_project, arg_region, arg_address).then(unittest.expectAsync (((api.Operation response) {

5685 checkOperation(response);

5686 })));

5687 });

5688

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

5690

5691 var mock = new common_test.HttpServerMock();

5692 api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;

5693 var arg_project = "foo";

5694 var arg_region = "foo";

5695 var arg_address = "foo";

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

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

5698 var pathOffset = 0;

5699 var index;

5700 var subPart;

5701 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

5702 pathOffset += 21;

5703 index = path.indexOf("/regions/", pathOffset);

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

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

5706 pathOffset = index;

5707 unittest.expect(subPart, unittest.equals("$arg_project"));

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

5709 pathOffset += 9;

5710 index = path.indexOf("/addresses/", pathOffset);

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

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

5713 pathOffset = index;

5714 unittest.expect(subPart, unittest.equals("$arg_region"));

5715 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/addresses/"));

5716 pathOffset += 11;

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

5718 pathOffset = path.length;

5719 unittest.expect(subPart, unittest.equals("$arg_address"));

5720

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

5722 var queryOffset = 0;

5723 var queryMap = {};

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

5725 parseBool(n) {

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

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

5728 if (n == null) return null;

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

5730 }

5731 if (query.length > 0) {

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

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

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

5735 }

5736 }

5737

5738

5739 var h = {

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

5741 };

5742 var resp = convert.JSON.encode(buildAddress());

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

5744 }), true);

5745 res.get(arg_project, arg_region, arg_address).then(unittest.expectAsync((( api.Address response) {

5746 checkAddress(response);

5747 })));

5748 });

5749

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

5751

5752 var mock = new common_test.HttpServerMock();

5753 api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;

5754 var arg_request = buildAddress();

5755 var arg_project = "foo";

5756 var arg_region = "foo";

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

5758 var obj = new api.Address.fromJson(json);

5759 checkAddress(obj);

5760

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

5762 var pathOffset = 0;

5763 var index;

5764 var subPart;

5765 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

5766 pathOffset += 21;

5767 index = path.indexOf("/regions/", pathOffset);

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

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

5770 pathOffset = index;

5771 unittest.expect(subPart, unittest.equals("$arg_project"));

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

5773 pathOffset += 9;

5774 index = path.indexOf("/addresses", pathOffset);

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

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

5777 pathOffset = index;

5778 unittest.expect(subPart, unittest.equals("$arg_region"));

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

5780 pathOffset += 10;

5781

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

5783 var queryOffset = 0;

5784 var queryMap = {};

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

5786 parseBool(n) {

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

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

5789 if (n == null) return null;

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

5791 }

5792 if (query.length > 0) {

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

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

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

5796 }

5797 }

5798

5799

5800 var h = {

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

5802 };

5803 var resp = convert.JSON.encode(buildOperation());

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

5805 }), true);

5806 res.insert(arg_request, arg_project, arg_region).then(unittest.expectAsync (((api.Operation response) {

5807 checkOperation(response);

5808 })));

5809 });

5810

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

5812

5813 var mock = new common_test.HttpServerMock();

5814 api.AddressesResourceApi res = new api.ComputeApi(mock).addresses;

5815 var arg_project = "foo";

5816 var arg_region = "foo";

5817 var arg_filter = "foo";

5818 var arg_maxResults = 42;

5819 var arg_pageToken = "foo";

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

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

5822 var pathOffset = 0;

5823 var index;

5824 var subPart;

5825 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

5826 pathOffset += 21;

5827 index = path.indexOf("/regions/", pathOffset);

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

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

5830 pathOffset = index;

5831 unittest.expect(subPart, unittest.equals("$arg_project"));

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

5833 pathOffset += 9;

5834 index = path.indexOf("/addresses", pathOffset);

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

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

5837 pathOffset = index;

5838 unittest.expect(subPart, unittest.equals("$arg_region"));

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

5840 pathOffset += 10;

5841

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

5843 var queryOffset = 0;

5844 var queryMap = {};

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

5846 parseBool(n) {

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

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

5849 if (n == null) return null;

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

5851 }

5852 if (query.length > 0) {

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

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

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

5856 }

5857 }

5858 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

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

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

5861

5862

5863 var h = {

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

5865 };

5866 var resp = convert.JSON.encode(buildAddressList());

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

5868 }), true);

5869 res.list(arg_project, arg_region, filter: arg_filter, maxResults: arg_maxR esults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.AddressList re sponse) {

5870 checkAddressList(response);

5871 })));

5872 });

5873

5874 });

5875

5876

5877 unittest.group("resource-BackendServicesResourceApi", () {

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

5879

5880 var mock = new common_test.HttpServerMock();

5881 api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServi ces;

5882 var arg_project = "foo";

5883 var arg_backendService = "foo";

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

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

5886 var pathOffset = 0;

5887 var index;

5888 var subPart;

5889 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

5890 pathOffset += 21;

5891 index = path.indexOf("/global/backendServices/", pathOffset);

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

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

5894 pathOffset = index;

5895 unittest.expect(subPart, unittest.equals("$arg_project"));

5896 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/backendServices/"));

5897 pathOffset += 24;

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

5899 pathOffset = path.length;

5900 unittest.expect(subPart, unittest.equals("$arg_backendService"));

5901

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

5903 var queryOffset = 0;

5904 var queryMap = {};

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

5906 parseBool(n) {

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

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

5909 if (n == null) return null;

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

5911 }

5912 if (query.length > 0) {

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

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

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

5916 }

5917 }

5918

5919

5920 var h = {

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

5922 };

5923 var resp = convert.JSON.encode(buildOperation());

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

5925 }), true);

5926 res.delete(arg_project, arg_backendService).then(unittest.expectAsync(((ap i.Operation response) {

5927 checkOperation(response);

5928 })));

5929 });

5930

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

5932

5933 var mock = new common_test.HttpServerMock();

5934 api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServi ces;

5935 var arg_project = "foo";

5936 var arg_backendService = "foo";

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

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

5939 var pathOffset = 0;

5940 var index;

5941 var subPart;

5942 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

5943 pathOffset += 21;

5944 index = path.indexOf("/global/backendServices/", pathOffset);

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

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

5947 pathOffset = index;

5948 unittest.expect(subPart, unittest.equals("$arg_project"));

5949 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/backendServices/"));

5950 pathOffset += 24;

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

5952 pathOffset = path.length;

5953 unittest.expect(subPart, unittest.equals("$arg_backendService"));

5954

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

5956 var queryOffset = 0;

5957 var queryMap = {};

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

5959 parseBool(n) {

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

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

5962 if (n == null) return null;

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

5964 }

5965 if (query.length > 0) {

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

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

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

5969 }

5970 }

5971

5972

5973 var h = {

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

5975 };

5976 var resp = convert.JSON.encode(buildBackendService());

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

5978 }), true);

5979 res.get(arg_project, arg_backendService).then(unittest.expectAsync(((api.B ackendService response) {

5980 checkBackendService(response);

5981 })));

5982 });

5983

5984 unittest.test("method--getHealth", () {

5985

5986 var mock = new common_test.HttpServerMock();

5987 api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServi ces;

5988 var arg_request = buildResourceGroupReference();

5989 var arg_project = "foo";

5990 var arg_backendService = "foo";

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

5992 var obj = new api.ResourceGroupReference.fromJson(json);

5993 checkResourceGroupReference(obj);

5994

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

5996 var pathOffset = 0;

5997 var index;

5998 var subPart;

5999 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6000 pathOffset += 21;

6001 index = path.indexOf("/global/backendServices/", pathOffset);

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

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

6004 pathOffset = index;

6005 unittest.expect(subPart, unittest.equals("$arg_project"));

6006 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/backendServices/"));

6007 pathOffset += 24;

6008 index = path.indexOf("/getHealth", pathOffset);

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

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

6011 pathOffset = index;

6012 unittest.expect(subPart, unittest.equals("$arg_backendService"));

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

6014 pathOffset += 10;

6015

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

6017 var queryOffset = 0;

6018 var queryMap = {};

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

6020 parseBool(n) {

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

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

6023 if (n == null) return null;

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

6025 }

6026 if (query.length > 0) {

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

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

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

6030 }

6031 }

6032

6033

6034 var h = {

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

6036 };

6037 var resp = convert.JSON.encode(buildBackendServiceGroupHealth());

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

6039 }), true);

6040 res.getHealth(arg_request, arg_project, arg_backendService).then(unittest. expectAsync(((api.BackendServiceGroupHealth response) {

6041 checkBackendServiceGroupHealth(response);

6042 })));

6043 });

6044

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

6046

6047 var mock = new common_test.HttpServerMock();

6048 api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServi ces;

6049 var arg_request = buildBackendService();

6050 var arg_project = "foo";

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

6052 var obj = new api.BackendService.fromJson(json);

6053 checkBackendService(obj);

6054

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

6056 var pathOffset = 0;

6057 var index;

6058 var subPart;

6059 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6060 pathOffset += 21;

6061 index = path.indexOf("/global/backendServices", pathOffset);

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

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

6064 pathOffset = index;

6065 unittest.expect(subPart, unittest.equals("$arg_project"));

6066 unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.eq uals("/global/backendServices"));

6067 pathOffset += 23;

6068

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

6070 var queryOffset = 0;

6071 var queryMap = {};

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

6073 parseBool(n) {

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

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

6076 if (n == null) return null;

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

6078 }

6079 if (query.length > 0) {

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

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

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

6083 }

6084 }

6085

6086

6087 var h = {

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

6089 };

6090 var resp = convert.JSON.encode(buildOperation());

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

6092 }), true);

6093 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

6094 checkOperation(response);

6095 })));

6096 });

6097

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

6099

6100 var mock = new common_test.HttpServerMock();

6101 api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServi ces;

6102 var arg_project = "foo";

6103 var arg_filter = "foo";

6104 var arg_maxResults = 42;

6105 var arg_pageToken = "foo";

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

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

6108 var pathOffset = 0;

6109 var index;

6110 var subPart;

6111 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6112 pathOffset += 21;

6113 index = path.indexOf("/global/backendServices", pathOffset);

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

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

6116 pathOffset = index;

6117 unittest.expect(subPart, unittest.equals("$arg_project"));

6118 unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.eq uals("/global/backendServices"));

6119 pathOffset += 23;

6120

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

6122 var queryOffset = 0;

6123 var queryMap = {};

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

6125 parseBool(n) {

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

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

6128 if (n == null) return null;

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

6130 }

6131 if (query.length > 0) {

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

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

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

6135 }

6136 }

6137 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

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

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

6140

6141

6142 var h = {

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

6144 };

6145 var resp = convert.JSON.encode(buildBackendServiceList());

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

6147 }), true);

6148 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.BackendServiceList respons e) {

6149 checkBackendServiceList(response);

6150 })));

6151 });

6152

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

6154

6155 var mock = new common_test.HttpServerMock();

6156 api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServi ces;

6157 var arg_request = buildBackendService();

6158 var arg_project = "foo";

6159 var arg_backendService = "foo";

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

6161 var obj = new api.BackendService.fromJson(json);

6162 checkBackendService(obj);

6163

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

6165 var pathOffset = 0;

6166 var index;

6167 var subPart;

6168 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6169 pathOffset += 21;

6170 index = path.indexOf("/global/backendServices/", pathOffset);

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

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

6173 pathOffset = index;

6174 unittest.expect(subPart, unittest.equals("$arg_project"));

6175 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/backendServices/"));

6176 pathOffset += 24;

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

6178 pathOffset = path.length;

6179 unittest.expect(subPart, unittest.equals("$arg_backendService"));

6180

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

6182 var queryOffset = 0;

6183 var queryMap = {};

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

6185 parseBool(n) {

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

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

6188 if (n == null) return null;

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

6190 }

6191 if (query.length > 0) {

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

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

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

6195 }

6196 }

6197

6198

6199 var h = {

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

6201 };

6202 var resp = convert.JSON.encode(buildOperation());

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

6204 }), true);

6205 res.patch(arg_request, arg_project, arg_backendService).then(unittest.expe ctAsync(((api.Operation response) {

6206 checkOperation(response);

6207 })));

6208 });

6209

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

6211

6212 var mock = new common_test.HttpServerMock();

6213 api.BackendServicesResourceApi res = new api.ComputeApi(mock).backendServi ces;

6214 var arg_request = buildBackendService();

6215 var arg_project = "foo";

6216 var arg_backendService = "foo";

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

6218 var obj = new api.BackendService.fromJson(json);

6219 checkBackendService(obj);

6220

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

6222 var pathOffset = 0;

6223 var index;

6224 var subPart;

6225 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6226 pathOffset += 21;

6227 index = path.indexOf("/global/backendServices/", pathOffset);

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

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

6230 pathOffset = index;

6231 unittest.expect(subPart, unittest.equals("$arg_project"));

6232 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/backendServices/"));

6233 pathOffset += 24;

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

6235 pathOffset = path.length;

6236 unittest.expect(subPart, unittest.equals("$arg_backendService"));

6237

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

6239 var queryOffset = 0;

6240 var queryMap = {};

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

6242 parseBool(n) {

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

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

6245 if (n == null) return null;

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

6247 }

6248 if (query.length > 0) {

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

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

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

6252 }

6253 }

6254

6255

6256 var h = {

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

6258 };

6259 var resp = convert.JSON.encode(buildOperation());

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

6261 }), true);

6262 res.update(arg_request, arg_project, arg_backendService).then(unittest.exp ectAsync(((api.Operation response) {

6263 checkOperation(response);

6264 })));

6265 });

6266

6267 });

6268

6269

6270 unittest.group("resource-DiskTypesResourceApi", () {

6271 unittest.test("method--aggregatedList", () {

6272

6273 var mock = new common_test.HttpServerMock();

6274 api.DiskTypesResourceApi res = new api.ComputeApi(mock).diskTypes;

6275 var arg_project = "foo";

6276 var arg_filter = "foo";

6277 var arg_maxResults = 42;

6278 var arg_pageToken = "foo";

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

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

6281 var pathOffset = 0;

6282 var index;

6283 var subPart;

6284 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6285 pathOffset += 21;

6286 index = path.indexOf("/aggregated/diskTypes", pathOffset);

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

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

6289 pathOffset = index;

6290 unittest.expect(subPart, unittest.equals("$arg_project"));

6291 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/aggregated/diskTypes"));

6292 pathOffset += 21;

6293

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

6295 var queryOffset = 0;

6296 var queryMap = {};

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

6298 parseBool(n) {

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

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

6301 if (n == null) return null;

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

6303 }

6304 if (query.length > 0) {

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

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

6307 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6308 }

6309 }

6310 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

6311 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6312 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6313

6314

6315 var h = {

6316 "content-type" : "application/json; charset=utf-8",

6317 };

6318 var resp = convert.JSON.encode(buildDiskTypeAggregatedList());

6319 return new async.Future.value(common_test.stringResponse(200, h, resp));

6320 }), true);

6321 res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DiskTypeAggregat edList response) {

6322 checkDiskTypeAggregatedList(response);

6323 })));

6324 });

6325

6326 unittest.test("method--get", () {

6327

6328 var mock = new common_test.HttpServerMock();

6329 api.DiskTypesResourceApi res = new api.ComputeApi(mock).diskTypes;

6330 var arg_project = "foo";

6331 var arg_zone = "foo";

6332 var arg_diskType = "foo";

6333 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6334 var path = (req.url).path;

6335 var pathOffset = 0;

6336 var index;

6337 var subPart;

6338 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6339 pathOffset += 21;

6340 index = path.indexOf("/zones/", pathOffset);

6341 unittest.expect(index >= 0, unittest.isTrue);

6342 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6343 pathOffset = index;

6344 unittest.expect(subPart, unittest.equals("$arg_project"));

6345 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

6346 pathOffset += 7;

6347 index = path.indexOf("/diskTypes/", pathOffset);

6348 unittest.expect(index >= 0, unittest.isTrue);

6349 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6350 pathOffset = index;

6351 unittest.expect(subPart, unittest.equals("$arg_zone"));

6352 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/diskTypes/"));

6353 pathOffset += 11;

6354 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6355 pathOffset = path.length;

6356 unittest.expect(subPart, unittest.equals("$arg_diskType"));

6357

6358 var query = (req.url).query;

6359 var queryOffset = 0;

6360 var queryMap = {};

6361 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6362 parseBool(n) {

6363 if (n == "true") return true;

6364 if (n == "false") return false;

6365 if (n == null) return null;

6366 throw new core.ArgumentError("Invalid boolean: $n");

6367 }

6368 if (query.length > 0) {

6369 for (var part in query.split("&")) {

6370 var keyvalue = part.split("=");

6371 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6372 }

6373 }

6374

6375

6376 var h = {

6377 "content-type" : "application/json; charset=utf-8",

6378 };

6379 var resp = convert.JSON.encode(buildDiskType());

6380 return new async.Future.value(common_test.stringResponse(200, h, resp));

6381 }), true);

6382 res.get(arg_project, arg_zone, arg_diskType).then(unittest.expectAsync(((a pi.DiskType response) {

6383 checkDiskType(response);

6384 })));

6385 });

6386

6387 unittest.test("method--list", () {

6388

6389 var mock = new common_test.HttpServerMock();

6390 api.DiskTypesResourceApi res = new api.ComputeApi(mock).diskTypes;

6391 var arg_project = "foo";

6392 var arg_zone = "foo";

6393 var arg_filter = "foo";

6394 var arg_maxResults = 42;

6395 var arg_pageToken = "foo";

6396 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6397 var path = (req.url).path;

6398 var pathOffset = 0;

6399 var index;

6400 var subPart;

6401 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6402 pathOffset += 21;

6403 index = path.indexOf("/zones/", pathOffset);

6404 unittest.expect(index >= 0, unittest.isTrue);

6405 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6406 pathOffset = index;

6407 unittest.expect(subPart, unittest.equals("$arg_project"));

6408 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

6409 pathOffset += 7;

6410 index = path.indexOf("/diskTypes", pathOffset);

6411 unittest.expect(index >= 0, unittest.isTrue);

6412 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6413 pathOffset = index;

6414 unittest.expect(subPart, unittest.equals("$arg_zone"));

6415 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/diskTypes"));

6416 pathOffset += 10;

6417

6418 var query = (req.url).query;

6419 var queryOffset = 0;

6420 var queryMap = {};

6421 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6422 parseBool(n) {

6423 if (n == "true") return true;

6424 if (n == "false") return false;

6425 if (n == null) return null;

6426 throw new core.ArgumentError("Invalid boolean: $n");

6427 }

6428 if (query.length > 0) {

6429 for (var part in query.split("&")) {

6430 var keyvalue = part.split("=");

6431 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6432 }

6433 }

6434 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

6435 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6436 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6437

6438

6439 var h = {

6440 "content-type" : "application/json; charset=utf-8",

6441 };

6442 var resp = convert.JSON.encode(buildDiskTypeList());

6443 return new async.Future.value(common_test.stringResponse(200, h, resp));

6444 }), true);

6445 res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DiskTypeList res ponse) {

6446 checkDiskTypeList(response);

6447 })));

6448 });

6449

6450 });

6451

6452

6453 unittest.group("resource-DisksResourceApi", () {

6454 unittest.test("method--aggregatedList", () {

6455

6456 var mock = new common_test.HttpServerMock();

6457 api.DisksResourceApi res = new api.ComputeApi(mock).disks;

6458 var arg_project = "foo";

6459 var arg_filter = "foo";

6460 var arg_maxResults = 42;

6461 var arg_pageToken = "foo";

6462 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6463 var path = (req.url).path;

6464 var pathOffset = 0;

6465 var index;

6466 var subPart;

6467 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6468 pathOffset += 21;

6469 index = path.indexOf("/aggregated/disks", pathOffset);

6470 unittest.expect(index >= 0, unittest.isTrue);

6471 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6472 pathOffset = index;

6473 unittest.expect(subPart, unittest.equals("$arg_project"));

6474 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/aggregated/disks"));

6475 pathOffset += 17;

6476

6477 var query = (req.url).query;

6478 var queryOffset = 0;

6479 var queryMap = {};

6480 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6481 parseBool(n) {

6482 if (n == "true") return true;

6483 if (n == "false") return false;

6484 if (n == null) return null;

6485 throw new core.ArgumentError("Invalid boolean: $n");

6486 }

6487 if (query.length > 0) {

6488 for (var part in query.split("&")) {

6489 var keyvalue = part.split("=");

6490 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6491 }

6492 }

6493 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

6494 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6495 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6496

6497

6498 var h = {

6499 "content-type" : "application/json; charset=utf-8",

6500 };

6501 var resp = convert.JSON.encode(buildDiskAggregatedList());

6502 return new async.Future.value(common_test.stringResponse(200, h, resp));

6503 }), true);

6504 res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DiskAggregatedLi st response) {

6505 checkDiskAggregatedList(response);

6506 })));

6507 });

6508

6509 unittest.test("method--createSnapshot", () {

6510

6511 var mock = new common_test.HttpServerMock();

6512 api.DisksResourceApi res = new api.ComputeApi(mock).disks;

6513 var arg_request = buildSnapshot();

6514 var arg_project = "foo";

6515 var arg_zone = "foo";

6516 var arg_disk = "foo";

6517 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6518 var obj = new api.Snapshot.fromJson(json);

6519 checkSnapshot(obj);

6520

6521 var path = (req.url).path;

6522 var pathOffset = 0;

6523 var index;

6524 var subPart;

6525 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6526 pathOffset += 21;

6527 index = path.indexOf("/zones/", pathOffset);

6528 unittest.expect(index >= 0, unittest.isTrue);

6529 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6530 pathOffset = index;

6531 unittest.expect(subPart, unittest.equals("$arg_project"));

6532 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

6533 pathOffset += 7;

6534 index = path.indexOf("/disks/", pathOffset);

6535 unittest.expect(index >= 0, unittest.isTrue);

6536 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6537 pathOffset = index;

6538 unittest.expect(subPart, unittest.equals("$arg_zone"));

6539 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/disks/"));

6540 pathOffset += 7;

6541 index = path.indexOf("/createSnapshot", pathOffset);

6542 unittest.expect(index >= 0, unittest.isTrue);

6543 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6544 pathOffset = index;

6545 unittest.expect(subPart, unittest.equals("$arg_disk"));

6546 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/createSnapshot"));

6547 pathOffset += 15;

6548

6549 var query = (req.url).query;

6550 var queryOffset = 0;

6551 var queryMap = {};

6552 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6553 parseBool(n) {

6554 if (n == "true") return true;

6555 if (n == "false") return false;

6556 if (n == null) return null;

6557 throw new core.ArgumentError("Invalid boolean: $n");

6558 }

6559 if (query.length > 0) {

6560 for (var part in query.split("&")) {

6561 var keyvalue = part.split("=");

6562 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6563 }

6564 }

6565

6566

6567 var h = {

6568 "content-type" : "application/json; charset=utf-8",

6569 };

6570 var resp = convert.JSON.encode(buildOperation());

6571 return new async.Future.value(common_test.stringResponse(200, h, resp));

6572 }), true);

6573 res.createSnapshot(arg_request, arg_project, arg_zone, arg_disk).then(unit test.expectAsync(((api.Operation response) {

6574 checkOperation(response);

6575 })));

6576 });

6577

6578 unittest.test("method--delete", () {

6579

6580 var mock = new common_test.HttpServerMock();

6581 api.DisksResourceApi res = new api.ComputeApi(mock).disks;

6582 var arg_project = "foo";

6583 var arg_zone = "foo";

6584 var arg_disk = "foo";

6585 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6586 var path = (req.url).path;

6587 var pathOffset = 0;

6588 var index;

6589 var subPart;

6590 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6591 pathOffset += 21;

6592 index = path.indexOf("/zones/", pathOffset);

6593 unittest.expect(index >= 0, unittest.isTrue);

6594 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6595 pathOffset = index;

6596 unittest.expect(subPart, unittest.equals("$arg_project"));

6597 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

6598 pathOffset += 7;

6599 index = path.indexOf("/disks/", pathOffset);

6600 unittest.expect(index >= 0, unittest.isTrue);

6601 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6602 pathOffset = index;

6603 unittest.expect(subPart, unittest.equals("$arg_zone"));

6604 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/disks/"));

6605 pathOffset += 7;

6606 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6607 pathOffset = path.length;

6608 unittest.expect(subPart, unittest.equals("$arg_disk"));

6609

6610 var query = (req.url).query;

6611 var queryOffset = 0;

6612 var queryMap = {};

6613 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6614 parseBool(n) {

6615 if (n == "true") return true;

6616 if (n == "false") return false;

6617 if (n == null) return null;

6618 throw new core.ArgumentError("Invalid boolean: $n");

6619 }

6620 if (query.length > 0) {

6621 for (var part in query.split("&")) {

6622 var keyvalue = part.split("=");

6623 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6624 }

6625 }

6626

6627

6628 var h = {

6629 "content-type" : "application/json; charset=utf-8",

6630 };

6631 var resp = convert.JSON.encode(buildOperation());

6632 return new async.Future.value(common_test.stringResponse(200, h, resp));

6633 }), true);

6634 res.delete(arg_project, arg_zone, arg_disk).then(unittest.expectAsync(((ap i.Operation response) {

6635 checkOperation(response);

6636 })));

6637 });

6638

6639 unittest.test("method--get", () {

6640

6641 var mock = new common_test.HttpServerMock();

6642 api.DisksResourceApi res = new api.ComputeApi(mock).disks;

6643 var arg_project = "foo";

6644 var arg_zone = "foo";

6645 var arg_disk = "foo";

6646 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6647 var path = (req.url).path;

6648 var pathOffset = 0;

6649 var index;

6650 var subPart;

6651 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6652 pathOffset += 21;

6653 index = path.indexOf("/zones/", pathOffset);

6654 unittest.expect(index >= 0, unittest.isTrue);

6655 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6656 pathOffset = index;

6657 unittest.expect(subPart, unittest.equals("$arg_project"));

6658 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

6659 pathOffset += 7;

6660 index = path.indexOf("/disks/", pathOffset);

6661 unittest.expect(index >= 0, unittest.isTrue);

6662 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6663 pathOffset = index;

6664 unittest.expect(subPart, unittest.equals("$arg_zone"));

6665 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/disks/"));

6666 pathOffset += 7;

6667 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6668 pathOffset = path.length;

6669 unittest.expect(subPart, unittest.equals("$arg_disk"));

6670

6671 var query = (req.url).query;

6672 var queryOffset = 0;

6673 var queryMap = {};

6674 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6675 parseBool(n) {

6676 if (n == "true") return true;

6677 if (n == "false") return false;

6678 if (n == null) return null;

6679 throw new core.ArgumentError("Invalid boolean: $n");

6680 }

6681 if (query.length > 0) {

6682 for (var part in query.split("&")) {

6683 var keyvalue = part.split("=");

6684 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6685 }

6686 }

6687

6688

6689 var h = {

6690 "content-type" : "application/json; charset=utf-8",

6691 };

6692 var resp = convert.JSON.encode(buildDisk());

6693 return new async.Future.value(common_test.stringResponse(200, h, resp));

6694 }), true);

6695 res.get(arg_project, arg_zone, arg_disk).then(unittest.expectAsync(((api.D isk response) {

6696 checkDisk(response);

6697 })));

6698 });

6699

6700 unittest.test("method--insert", () {

6701

6702 var mock = new common_test.HttpServerMock();

6703 api.DisksResourceApi res = new api.ComputeApi(mock).disks;

6704 var arg_request = buildDisk();

6705 var arg_project = "foo";

6706 var arg_zone = "foo";

6707 var arg_sourceImage = "foo";

6708 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6709 var obj = new api.Disk.fromJson(json);

6710 checkDisk(obj);

6711

6712 var path = (req.url).path;

6713 var pathOffset = 0;

6714 var index;

6715 var subPart;

6716 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6717 pathOffset += 21;

6718 index = path.indexOf("/zones/", pathOffset);

6719 unittest.expect(index >= 0, unittest.isTrue);

6720 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6721 pathOffset = index;

6722 unittest.expect(subPart, unittest.equals("$arg_project"));

6723 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

6724 pathOffset += 7;

6725 index = path.indexOf("/disks", pathOffset);

6726 unittest.expect(index >= 0, unittest.isTrue);

6727 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6728 pathOffset = index;

6729 unittest.expect(subPart, unittest.equals("$arg_zone"));

6730 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/disks"));

6731 pathOffset += 6;

6732

6733 var query = (req.url).query;

6734 var queryOffset = 0;

6735 var queryMap = {};

6736 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6737 parseBool(n) {

6738 if (n == "true") return true;

6739 if (n == "false") return false;

6740 if (n == null) return null;

6741 throw new core.ArgumentError("Invalid boolean: $n");

6742 }

6743 if (query.length > 0) {

6744 for (var part in query.split("&")) {

6745 var keyvalue = part.split("=");

6746 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6747 }

6748 }

6749 unittest.expect(queryMap["sourceImage"].first, unittest.equals(arg_sourc eImage));

6750

6751

6752 var h = {

6753 "content-type" : "application/json; charset=utf-8",

6754 };

6755 var resp = convert.JSON.encode(buildOperation());

6756 return new async.Future.value(common_test.stringResponse(200, h, resp));

6757 }), true);

6758 res.insert(arg_request, arg_project, arg_zone, sourceImage: arg_sourceImag e).then(unittest.expectAsync(((api.Operation response) {

6759 checkOperation(response);

6760 })));

6761 });

6762

6763 unittest.test("method--list", () {

6764

6765 var mock = new common_test.HttpServerMock();

6766 api.DisksResourceApi res = new api.ComputeApi(mock).disks;

6767 var arg_project = "foo";

6768 var arg_zone = "foo";

6769 var arg_filter = "foo";

6770 var arg_maxResults = 42;

6771 var arg_pageToken = "foo";

6772 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6773 var path = (req.url).path;

6774 var pathOffset = 0;

6775 var index;

6776 var subPart;

6777 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6778 pathOffset += 21;

6779 index = path.indexOf("/zones/", pathOffset);

6780 unittest.expect(index >= 0, unittest.isTrue);

6781 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6782 pathOffset = index;

6783 unittest.expect(subPart, unittest.equals("$arg_project"));

6784 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

6785 pathOffset += 7;

6786 index = path.indexOf("/disks", pathOffset);

6787 unittest.expect(index >= 0, unittest.isTrue);

6788 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6789 pathOffset = index;

6790 unittest.expect(subPart, unittest.equals("$arg_zone"));

6791 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/disks"));

6792 pathOffset += 6;

6793

6794 var query = (req.url).query;

6795 var queryOffset = 0;

6796 var queryMap = {};

6797 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6798 parseBool(n) {

6799 if (n == "true") return true;

6800 if (n == "false") return false;

6801 if (n == null) return null;

6802 throw new core.ArgumentError("Invalid boolean: $n");

6803 }

6804 if (query.length > 0) {

6805 for (var part in query.split("&")) {

6806 var keyvalue = part.split("=");

6807 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6808 }

6809 }

6810 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

6811 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

6812 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

6813

6814

6815 var h = {

6816 "content-type" : "application/json; charset=utf-8",

6817 };

6818 var resp = convert.JSON.encode(buildDiskList());

6819 return new async.Future.value(common_test.stringResponse(200, h, resp));

6820 }), true);

6821 res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.DiskList respons e) {

6822 checkDiskList(response);

6823 })));

6824 });

6825

6826 });

6827

6828

6829 unittest.group("resource-FirewallsResourceApi", () {

6830 unittest.test("method--delete", () {

6831

6832 var mock = new common_test.HttpServerMock();

6833 api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;

6834 var arg_project = "foo";

6835 var arg_firewall = "foo";

6836 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6837 var path = (req.url).path;

6838 var pathOffset = 0;

6839 var index;

6840 var subPart;

6841 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6842 pathOffset += 21;

6843 index = path.indexOf("/global/firewalls/", pathOffset);

6844 unittest.expect(index >= 0, unittest.isTrue);

6845 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6846 pathOffset = index;

6847 unittest.expect(subPart, unittest.equals("$arg_project"));

6848 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/global/firewalls/"));

6849 pathOffset += 18;

6850 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6851 pathOffset = path.length;

6852 unittest.expect(subPart, unittest.equals("$arg_firewall"));

6853

6854 var query = (req.url).query;

6855 var queryOffset = 0;

6856 var queryMap = {};

6857 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6858 parseBool(n) {

6859 if (n == "true") return true;

6860 if (n == "false") return false;

6861 if (n == null) return null;

6862 throw new core.ArgumentError("Invalid boolean: $n");

6863 }

6864 if (query.length > 0) {

6865 for (var part in query.split("&")) {

6866 var keyvalue = part.split("=");

6867 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6868 }

6869 }

6870

6871

6872 var h = {

6873 "content-type" : "application/json; charset=utf-8",

6874 };

6875 var resp = convert.JSON.encode(buildOperation());

6876 return new async.Future.value(common_test.stringResponse(200, h, resp));

6877 }), true);

6878 res.delete(arg_project, arg_firewall).then(unittest.expectAsync(((api.Oper ation response) {

6879 checkOperation(response);

6880 })));

6881 });

6882

6883 unittest.test("method--get", () {

6884

6885 var mock = new common_test.HttpServerMock();

6886 api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;

6887 var arg_project = "foo";

6888 var arg_firewall = "foo";

6889 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6890 var path = (req.url).path;

6891 var pathOffset = 0;

6892 var index;

6893 var subPart;

6894 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6895 pathOffset += 21;

6896 index = path.indexOf("/global/firewalls/", pathOffset);

6897 unittest.expect(index >= 0, unittest.isTrue);

6898 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6899 pathOffset = index;

6900 unittest.expect(subPart, unittest.equals("$arg_project"));

6901 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/global/firewalls/"));

6902 pathOffset += 18;

6903 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

6904 pathOffset = path.length;

6905 unittest.expect(subPart, unittest.equals("$arg_firewall"));

6906

6907 var query = (req.url).query;

6908 var queryOffset = 0;

6909 var queryMap = {};

6910 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6911 parseBool(n) {

6912 if (n == "true") return true;

6913 if (n == "false") return false;

6914 if (n == null) return null;

6915 throw new core.ArgumentError("Invalid boolean: $n");

6916 }

6917 if (query.length > 0) {

6918 for (var part in query.split("&")) {

6919 var keyvalue = part.split("=");

6920 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6921 }

6922 }

6923

6924

6925 var h = {

6926 "content-type" : "application/json; charset=utf-8",

6927 };

6928 var resp = convert.JSON.encode(buildFirewall());

6929 return new async.Future.value(common_test.stringResponse(200, h, resp));

6930 }), true);

6931 res.get(arg_project, arg_firewall).then(unittest.expectAsync(((api.Firewal l response) {

6932 checkFirewall(response);

6933 })));

6934 });

6935

6936 unittest.test("method--insert", () {

6937

6938 var mock = new common_test.HttpServerMock();

6939 api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;

6940 var arg_request = buildFirewall();

6941 var arg_project = "foo";

6942 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6943 var obj = new api.Firewall.fromJson(json);

6944 checkFirewall(obj);

6945

6946 var path = (req.url).path;

6947 var pathOffset = 0;

6948 var index;

6949 var subPart;

6950 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

6951 pathOffset += 21;

6952 index = path.indexOf("/global/firewalls", pathOffset);

6953 unittest.expect(index >= 0, unittest.isTrue);

6954 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

6955 pathOffset = index;

6956 unittest.expect(subPart, unittest.equals("$arg_project"));

6957 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/global/firewalls"));

6958 pathOffset += 17;

6959

6960 var query = (req.url).query;

6961 var queryOffset = 0;

6962 var queryMap = {};

6963 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

6964 parseBool(n) {

6965 if (n == "true") return true;

6966 if (n == "false") return false;

6967 if (n == null) return null;

6968 throw new core.ArgumentError("Invalid boolean: $n");

6969 }

6970 if (query.length > 0) {

6971 for (var part in query.split("&")) {

6972 var keyvalue = part.split("=");

6973 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

6974 }

6975 }

6976

6977

6978 var h = {

6979 "content-type" : "application/json; charset=utf-8",

6980 };

6981 var resp = convert.JSON.encode(buildOperation());

6982 return new async.Future.value(common_test.stringResponse(200, h, resp));

6983 }), true);

6984 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

6985 checkOperation(response);

6986 })));

6987 });

6988

6989 unittest.test("method--list", () {

6990

6991 var mock = new common_test.HttpServerMock();

6992 api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;

6993 var arg_project = "foo";

6994 var arg_filter = "foo";

6995 var arg_maxResults = 42;

6996 var arg_pageToken = "foo";

6997 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

6998 var path = (req.url).path;

6999 var pathOffset = 0;

7000 var index;

7001 var subPart;

7002 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7003 pathOffset += 21;

7004 index = path.indexOf("/global/firewalls", pathOffset);

7005 unittest.expect(index >= 0, unittest.isTrue);

7006 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7007 pathOffset = index;

7008 unittest.expect(subPart, unittest.equals("$arg_project"));

7009 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/global/firewalls"));

7010 pathOffset += 17;

7011

7012 var query = (req.url).query;

7013 var queryOffset = 0;

7014 var queryMap = {};

7015 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7016 parseBool(n) {

7017 if (n == "true") return true;

7018 if (n == "false") return false;

7019 if (n == null) return null;

7020 throw new core.ArgumentError("Invalid boolean: $n");

7021 }

7022 if (query.length > 0) {

7023 for (var part in query.split("&")) {

7024 var keyvalue = part.split("=");

7025 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7026 }

7027 }

7028 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

7029 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

7030 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

7031

7032

7033 var h = {

7034 "content-type" : "application/json; charset=utf-8",

7035 };

7036 var resp = convert.JSON.encode(buildFirewallList());

7037 return new async.Future.value(common_test.stringResponse(200, h, resp));

7038 }), true);

7039 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.FirewallList response) {

7040 checkFirewallList(response);

7041 })));

7042 });

7043

7044 unittest.test("method--patch", () {

7045

7046 var mock = new common_test.HttpServerMock();

7047 api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;

7048 var arg_request = buildFirewall();

7049 var arg_project = "foo";

7050 var arg_firewall = "foo";

7051 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7052 var obj = new api.Firewall.fromJson(json);

7053 checkFirewall(obj);

7054

7055 var path = (req.url).path;

7056 var pathOffset = 0;

7057 var index;

7058 var subPart;

7059 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7060 pathOffset += 21;

7061 index = path.indexOf("/global/firewalls/", pathOffset);

7062 unittest.expect(index >= 0, unittest.isTrue);

7063 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7064 pathOffset = index;

7065 unittest.expect(subPart, unittest.equals("$arg_project"));

7066 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/global/firewalls/"));

7067 pathOffset += 18;

7068 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

7069 pathOffset = path.length;

7070 unittest.expect(subPart, unittest.equals("$arg_firewall"));

7071

7072 var query = (req.url).query;

7073 var queryOffset = 0;

7074 var queryMap = {};

7075 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7076 parseBool(n) {

7077 if (n == "true") return true;

7078 if (n == "false") return false;

7079 if (n == null) return null;

7080 throw new core.ArgumentError("Invalid boolean: $n");

7081 }

7082 if (query.length > 0) {

7083 for (var part in query.split("&")) {

7084 var keyvalue = part.split("=");

7085 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7086 }

7087 }

7088

7089

7090 var h = {

7091 "content-type" : "application/json; charset=utf-8",

7092 };

7093 var resp = convert.JSON.encode(buildOperation());

7094 return new async.Future.value(common_test.stringResponse(200, h, resp));

7095 }), true);

7096 res.patch(arg_request, arg_project, arg_firewall).then(unittest.expectAsyn c(((api.Operation response) {

7097 checkOperation(response);

7098 })));

7099 });

7100

7101 unittest.test("method--update", () {

7102

7103 var mock = new common_test.HttpServerMock();

7104 api.FirewallsResourceApi res = new api.ComputeApi(mock).firewalls;

7105 var arg_request = buildFirewall();

7106 var arg_project = "foo";

7107 var arg_firewall = "foo";

7108 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7109 var obj = new api.Firewall.fromJson(json);

7110 checkFirewall(obj);

7111

7112 var path = (req.url).path;

7113 var pathOffset = 0;

7114 var index;

7115 var subPart;

7116 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7117 pathOffset += 21;

7118 index = path.indexOf("/global/firewalls/", pathOffset);

7119 unittest.expect(index >= 0, unittest.isTrue);

7120 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7121 pathOffset = index;

7122 unittest.expect(subPart, unittest.equals("$arg_project"));

7123 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/global/firewalls/"));

7124 pathOffset += 18;

7125 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

7126 pathOffset = path.length;

7127 unittest.expect(subPart, unittest.equals("$arg_firewall"));

7128

7129 var query = (req.url).query;

7130 var queryOffset = 0;

7131 var queryMap = {};

7132 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7133 parseBool(n) {

7134 if (n == "true") return true;

7135 if (n == "false") return false;

7136 if (n == null) return null;

7137 throw new core.ArgumentError("Invalid boolean: $n");

7138 }

7139 if (query.length > 0) {

7140 for (var part in query.split("&")) {

7141 var keyvalue = part.split("=");

7142 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7143 }

7144 }

7145

7146

7147 var h = {

7148 "content-type" : "application/json; charset=utf-8",

7149 };

7150 var resp = convert.JSON.encode(buildOperation());

7151 return new async.Future.value(common_test.stringResponse(200, h, resp));

7152 }), true);

7153 res.update(arg_request, arg_project, arg_firewall).then(unittest.expectAsy nc(((api.Operation response) {

7154 checkOperation(response);

7155 })));

7156 });

7157

7158 });

7159

7160

7161 unittest.group("resource-ForwardingRulesResourceApi", () {

7162 unittest.test("method--aggregatedList", () {

7163

7164 var mock = new common_test.HttpServerMock();

7165 api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRu les;

7166 var arg_project = "foo";

7167 var arg_filter = "foo";

7168 var arg_maxResults = 42;

7169 var arg_pageToken = "foo";

7170 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7171 var path = (req.url).path;

7172 var pathOffset = 0;

7173 var index;

7174 var subPart;

7175 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7176 pathOffset += 21;

7177 index = path.indexOf("/aggregated/forwardingRules", pathOffset);

7178 unittest.expect(index >= 0, unittest.isTrue);

7179 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7180 pathOffset = index;

7181 unittest.expect(subPart, unittest.equals("$arg_project"));

7182 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/aggregated/forwardingRules"));

7183 pathOffset += 27;

7184

7185 var query = (req.url).query;

7186 var queryOffset = 0;

7187 var queryMap = {};

7188 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7189 parseBool(n) {

7190 if (n == "true") return true;

7191 if (n == "false") return false;

7192 if (n == null) return null;

7193 throw new core.ArgumentError("Invalid boolean: $n");

7194 }

7195 if (query.length > 0) {

7196 for (var part in query.split("&")) {

7197 var keyvalue = part.split("=");

7198 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7199 }

7200 }

7201 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

7202 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

7203 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

7204

7205

7206 var h = {

7207 "content-type" : "application/json; charset=utf-8",

7208 };

7209 var resp = convert.JSON.encode(buildForwardingRuleAggregatedList());

7210 return new async.Future.value(common_test.stringResponse(200, h, resp));

7211 }), true);

7212 res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ForwardingRuleAg gregatedList response) {

7213 checkForwardingRuleAggregatedList(response);

7214 })));

7215 });

7216

7217 unittest.test("method--delete", () {

7218

7219 var mock = new common_test.HttpServerMock();

7220 api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRu les;

7221 var arg_project = "foo";

7222 var arg_region = "foo";

7223 var arg_forwardingRule = "foo";

7224 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7225 var path = (req.url).path;

7226 var pathOffset = 0;

7227 var index;

7228 var subPart;

7229 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7230 pathOffset += 21;

7231 index = path.indexOf("/regions/", pathOffset);

7232 unittest.expect(index >= 0, unittest.isTrue);

7233 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7234 pathOffset = index;

7235 unittest.expect(subPart, unittest.equals("$arg_project"));

7236 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

7237 pathOffset += 9;

7238 index = path.indexOf("/forwardingRules/", pathOffset);

7239 unittest.expect(index >= 0, unittest.isTrue);

7240 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7241 pathOffset = index;

7242 unittest.expect(subPart, unittest.equals("$arg_region"));

7243 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/forwardingRules/"));

7244 pathOffset += 17;

7245 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

7246 pathOffset = path.length;

7247 unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));

7248

7249 var query = (req.url).query;

7250 var queryOffset = 0;

7251 var queryMap = {};

7252 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7253 parseBool(n) {

7254 if (n == "true") return true;

7255 if (n == "false") return false;

7256 if (n == null) return null;

7257 throw new core.ArgumentError("Invalid boolean: $n");

7258 }

7259 if (query.length > 0) {

7260 for (var part in query.split("&")) {

7261 var keyvalue = part.split("=");

7262 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7263 }

7264 }

7265

7266

7267 var h = {

7268 "content-type" : "application/json; charset=utf-8",

7269 };

7270 var resp = convert.JSON.encode(buildOperation());

7271 return new async.Future.value(common_test.stringResponse(200, h, resp));

7272 }), true);

7273 res.delete(arg_project, arg_region, arg_forwardingRule).then(unittest.expe ctAsync(((api.Operation response) {

7274 checkOperation(response);

7275 })));

7276 });

7277

7278 unittest.test("method--get", () {

7279

7280 var mock = new common_test.HttpServerMock();

7281 api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRu les;

7282 var arg_project = "foo";

7283 var arg_region = "foo";

7284 var arg_forwardingRule = "foo";

7285 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7286 var path = (req.url).path;

7287 var pathOffset = 0;

7288 var index;

7289 var subPart;

7290 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7291 pathOffset += 21;

7292 index = path.indexOf("/regions/", pathOffset);

7293 unittest.expect(index >= 0, unittest.isTrue);

7294 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7295 pathOffset = index;

7296 unittest.expect(subPart, unittest.equals("$arg_project"));

7297 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

7298 pathOffset += 9;

7299 index = path.indexOf("/forwardingRules/", pathOffset);

7300 unittest.expect(index >= 0, unittest.isTrue);

7301 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7302 pathOffset = index;

7303 unittest.expect(subPart, unittest.equals("$arg_region"));

7304 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/forwardingRules/"));

7305 pathOffset += 17;

7306 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

7307 pathOffset = path.length;

7308 unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));

7309

7310 var query = (req.url).query;

7311 var queryOffset = 0;

7312 var queryMap = {};

7313 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7314 parseBool(n) {

7315 if (n == "true") return true;

7316 if (n == "false") return false;

7317 if (n == null) return null;

7318 throw new core.ArgumentError("Invalid boolean: $n");

7319 }

7320 if (query.length > 0) {

7321 for (var part in query.split("&")) {

7322 var keyvalue = part.split("=");

7323 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7324 }

7325 }

7326

7327

7328 var h = {

7329 "content-type" : "application/json; charset=utf-8",

7330 };

7331 var resp = convert.JSON.encode(buildForwardingRule());

7332 return new async.Future.value(common_test.stringResponse(200, h, resp));

7333 }), true);

7334 res.get(arg_project, arg_region, arg_forwardingRule).then(unittest.expectA sync(((api.ForwardingRule response) {

7335 checkForwardingRule(response);

7336 })));

7337 });

7338

7339 unittest.test("method--insert", () {

7340

7341 var mock = new common_test.HttpServerMock();

7342 api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRu les;

7343 var arg_request = buildForwardingRule();

7344 var arg_project = "foo";

7345 var arg_region = "foo";

7346 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7347 var obj = new api.ForwardingRule.fromJson(json);

7348 checkForwardingRule(obj);

7349

7350 var path = (req.url).path;

7351 var pathOffset = 0;

7352 var index;

7353 var subPart;

7354 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7355 pathOffset += 21;

7356 index = path.indexOf("/regions/", pathOffset);

7357 unittest.expect(index >= 0, unittest.isTrue);

7358 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7359 pathOffset = index;

7360 unittest.expect(subPart, unittest.equals("$arg_project"));

7361 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

7362 pathOffset += 9;

7363 index = path.indexOf("/forwardingRules", pathOffset);

7364 unittest.expect(index >= 0, unittest.isTrue);

7365 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7366 pathOffset = index;

7367 unittest.expect(subPart, unittest.equals("$arg_region"));

7368 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/forwardingRules"));

7369 pathOffset += 16;

7370

7371 var query = (req.url).query;

7372 var queryOffset = 0;

7373 var queryMap = {};

7374 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7375 parseBool(n) {

7376 if (n == "true") return true;

7377 if (n == "false") return false;

7378 if (n == null) return null;

7379 throw new core.ArgumentError("Invalid boolean: $n");

7380 }

7381 if (query.length > 0) {

7382 for (var part in query.split("&")) {

7383 var keyvalue = part.split("=");

7384 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7385 }

7386 }

7387

7388

7389 var h = {

7390 "content-type" : "application/json; charset=utf-8",

7391 };

7392 var resp = convert.JSON.encode(buildOperation());

7393 return new async.Future.value(common_test.stringResponse(200, h, resp));

7394 }), true);

7395 res.insert(arg_request, arg_project, arg_region).then(unittest.expectAsync (((api.Operation response) {

7396 checkOperation(response);

7397 })));

7398 });

7399

7400 unittest.test("method--list", () {

7401

7402 var mock = new common_test.HttpServerMock();

7403 api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRu les;

7404 var arg_project = "foo";

7405 var arg_region = "foo";

7406 var arg_filter = "foo";

7407 var arg_maxResults = 42;

7408 var arg_pageToken = "foo";

7409 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7410 var path = (req.url).path;

7411 var pathOffset = 0;

7412 var index;

7413 var subPart;

7414 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7415 pathOffset += 21;

7416 index = path.indexOf("/regions/", pathOffset);

7417 unittest.expect(index >= 0, unittest.isTrue);

7418 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7419 pathOffset = index;

7420 unittest.expect(subPart, unittest.equals("$arg_project"));

7421 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

7422 pathOffset += 9;

7423 index = path.indexOf("/forwardingRules", pathOffset);

7424 unittest.expect(index >= 0, unittest.isTrue);

7425 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7426 pathOffset = index;

7427 unittest.expect(subPart, unittest.equals("$arg_region"));

7428 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/forwardingRules"));

7429 pathOffset += 16;

7430

7431 var query = (req.url).query;

7432 var queryOffset = 0;

7433 var queryMap = {};

7434 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7435 parseBool(n) {

7436 if (n == "true") return true;

7437 if (n == "false") return false;

7438 if (n == null) return null;

7439 throw new core.ArgumentError("Invalid boolean: $n");

7440 }

7441 if (query.length > 0) {

7442 for (var part in query.split("&")) {

7443 var keyvalue = part.split("=");

7444 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7445 }

7446 }

7447 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

7448 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

7449 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

7450

7451

7452 var h = {

7453 "content-type" : "application/json; charset=utf-8",

7454 };

7455 var resp = convert.JSON.encode(buildForwardingRuleList());

7456 return new async.Future.value(common_test.stringResponse(200, h, resp));

7457 }), true);

7458 res.list(arg_project, arg_region, filter: arg_filter, maxResults: arg_maxR esults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ForwardingRule List response) {

7459 checkForwardingRuleList(response);

7460 })));

7461 });

7462

7463 unittest.test("method--setTarget", () {

7464

7465 var mock = new common_test.HttpServerMock();

7466 api.ForwardingRulesResourceApi res = new api.ComputeApi(mock).forwardingRu les;

7467 var arg_request = buildTargetReference();

7468 var arg_project = "foo";

7469 var arg_region = "foo";

7470 var arg_forwardingRule = "foo";

7471 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7472 var obj = new api.TargetReference.fromJson(json);

7473 checkTargetReference(obj);

7474

7475 var path = (req.url).path;

7476 var pathOffset = 0;

7477 var index;

7478 var subPart;

7479 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7480 pathOffset += 21;

7481 index = path.indexOf("/regions/", pathOffset);

7482 unittest.expect(index >= 0, unittest.isTrue);

7483 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7484 pathOffset = index;

7485 unittest.expect(subPart, unittest.equals("$arg_project"));

7486 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

7487 pathOffset += 9;

7488 index = path.indexOf("/forwardingRules/", pathOffset);

7489 unittest.expect(index >= 0, unittest.isTrue);

7490 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7491 pathOffset = index;

7492 unittest.expect(subPart, unittest.equals("$arg_region"));

7493 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/forwardingRules/"));

7494 pathOffset += 17;

7495 index = path.indexOf("/setTarget", pathOffset);

7496 unittest.expect(index >= 0, unittest.isTrue);

7497 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7498 pathOffset = index;

7499 unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));

7500 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/setTarget"));

7501 pathOffset += 10;

7502

7503 var query = (req.url).query;

7504 var queryOffset = 0;

7505 var queryMap = {};

7506 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7507 parseBool(n) {

7508 if (n == "true") return true;

7509 if (n == "false") return false;

7510 if (n == null) return null;

7511 throw new core.ArgumentError("Invalid boolean: $n");

7512 }

7513 if (query.length > 0) {

7514 for (var part in query.split("&")) {

7515 var keyvalue = part.split("=");

7516 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7517 }

7518 }

7519

7520

7521 var h = {

7522 "content-type" : "application/json; charset=utf-8",

7523 };

7524 var resp = convert.JSON.encode(buildOperation());

7525 return new async.Future.value(common_test.stringResponse(200, h, resp));

7526 }), true);

7527 res.setTarget(arg_request, arg_project, arg_region, arg_forwardingRule).th en(unittest.expectAsync(((api.Operation response) {

7528 checkOperation(response);

7529 })));

7530 });

7531

7532 });

7533

7534

7535 unittest.group("resource-GlobalAddressesResourceApi", () {

7536 unittest.test("method--delete", () {

7537

7538 var mock = new common_test.HttpServerMock();

7539 api.GlobalAddressesResourceApi res = new api.ComputeApi(mock).globalAddres ses;

7540 var arg_project = "foo";

7541 var arg_address = "foo";

7542 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7543 var path = (req.url).path;

7544 var pathOffset = 0;

7545 var index;

7546 var subPart;

7547 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7548 pathOffset += 21;

7549 index = path.indexOf("/global/addresses/", pathOffset);

7550 unittest.expect(index >= 0, unittest.isTrue);

7551 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7552 pathOffset = index;

7553 unittest.expect(subPart, unittest.equals("$arg_project"));

7554 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/global/addresses/"));

7555 pathOffset += 18;

7556 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

7557 pathOffset = path.length;

7558 unittest.expect(subPart, unittest.equals("$arg_address"));

7559

7560 var query = (req.url).query;

7561 var queryOffset = 0;

7562 var queryMap = {};

7563 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7564 parseBool(n) {

7565 if (n == "true") return true;

7566 if (n == "false") return false;

7567 if (n == null) return null;

7568 throw new core.ArgumentError("Invalid boolean: $n");

7569 }

7570 if (query.length > 0) {

7571 for (var part in query.split("&")) {

7572 var keyvalue = part.split("=");

7573 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7574 }

7575 }

7576

7577

7578 var h = {

7579 "content-type" : "application/json; charset=utf-8",

7580 };

7581 var resp = convert.JSON.encode(buildOperation());

7582 return new async.Future.value(common_test.stringResponse(200, h, resp));

7583 }), true);

7584 res.delete(arg_project, arg_address).then(unittest.expectAsync(((api.Opera tion response) {

7585 checkOperation(response);

7586 })));

7587 });

7588

7589 unittest.test("method--get", () {

7590

7591 var mock = new common_test.HttpServerMock();

7592 api.GlobalAddressesResourceApi res = new api.ComputeApi(mock).globalAddres ses;

7593 var arg_project = "foo";

7594 var arg_address = "foo";

7595 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7596 var path = (req.url).path;

7597 var pathOffset = 0;

7598 var index;

7599 var subPart;

7600 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7601 pathOffset += 21;

7602 index = path.indexOf("/global/addresses/", pathOffset);

7603 unittest.expect(index >= 0, unittest.isTrue);

7604 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7605 pathOffset = index;

7606 unittest.expect(subPart, unittest.equals("$arg_project"));

7607 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/global/addresses/"));

7608 pathOffset += 18;

7609 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

7610 pathOffset = path.length;

7611 unittest.expect(subPart, unittest.equals("$arg_address"));

7612

7613 var query = (req.url).query;

7614 var queryOffset = 0;

7615 var queryMap = {};

7616 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7617 parseBool(n) {

7618 if (n == "true") return true;

7619 if (n == "false") return false;

7620 if (n == null) return null;

7621 throw new core.ArgumentError("Invalid boolean: $n");

7622 }

7623 if (query.length > 0) {

7624 for (var part in query.split("&")) {

7625 var keyvalue = part.split("=");

7626 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7627 }

7628 }

7629

7630

7631 var h = {

7632 "content-type" : "application/json; charset=utf-8",

7633 };

7634 var resp = convert.JSON.encode(buildAddress());

7635 return new async.Future.value(common_test.stringResponse(200, h, resp));

7636 }), true);

7637 res.get(arg_project, arg_address).then(unittest.expectAsync(((api.Address response) {

7638 checkAddress(response);

7639 })));

7640 });

7641

7642 unittest.test("method--insert", () {

7643

7644 var mock = new common_test.HttpServerMock();

7645 api.GlobalAddressesResourceApi res = new api.ComputeApi(mock).globalAddres ses;

7646 var arg_request = buildAddress();

7647 var arg_project = "foo";

7648 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7649 var obj = new api.Address.fromJson(json);

7650 checkAddress(obj);

7651

7652 var path = (req.url).path;

7653 var pathOffset = 0;

7654 var index;

7655 var subPart;

7656 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7657 pathOffset += 21;

7658 index = path.indexOf("/global/addresses", pathOffset);

7659 unittest.expect(index >= 0, unittest.isTrue);

7660 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7661 pathOffset = index;

7662 unittest.expect(subPart, unittest.equals("$arg_project"));

7663 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/global/addresses"));

7664 pathOffset += 17;

7665

7666 var query = (req.url).query;

7667 var queryOffset = 0;

7668 var queryMap = {};

7669 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7670 parseBool(n) {

7671 if (n == "true") return true;

7672 if (n == "false") return false;

7673 if (n == null) return null;

7674 throw new core.ArgumentError("Invalid boolean: $n");

7675 }

7676 if (query.length > 0) {

7677 for (var part in query.split("&")) {

7678 var keyvalue = part.split("=");

7679 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7680 }

7681 }

7682

7683

7684 var h = {

7685 "content-type" : "application/json; charset=utf-8",

7686 };

7687 var resp = convert.JSON.encode(buildOperation());

7688 return new async.Future.value(common_test.stringResponse(200, h, resp));

7689 }), true);

7690 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

7691 checkOperation(response);

7692 })));

7693 });

7694

7695 unittest.test("method--list", () {

7696

7697 var mock = new common_test.HttpServerMock();

7698 api.GlobalAddressesResourceApi res = new api.ComputeApi(mock).globalAddres ses;

7699 var arg_project = "foo";

7700 var arg_filter = "foo";

7701 var arg_maxResults = 42;

7702 var arg_pageToken = "foo";

7703 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7704 var path = (req.url).path;

7705 var pathOffset = 0;

7706 var index;

7707 var subPart;

7708 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7709 pathOffset += 21;

7710 index = path.indexOf("/global/addresses", pathOffset);

7711 unittest.expect(index >= 0, unittest.isTrue);

7712 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7713 pathOffset = index;

7714 unittest.expect(subPart, unittest.equals("$arg_project"));

7715 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/global/addresses"));

7716 pathOffset += 17;

7717

7718 var query = (req.url).query;

7719 var queryOffset = 0;

7720 var queryMap = {};

7721 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7722 parseBool(n) {

7723 if (n == "true") return true;

7724 if (n == "false") return false;

7725 if (n == null) return null;

7726 throw new core.ArgumentError("Invalid boolean: $n");

7727 }

7728 if (query.length > 0) {

7729 for (var part in query.split("&")) {

7730 var keyvalue = part.split("=");

7731 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7732 }

7733 }

7734 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

7735 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

7736 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

7737

7738

7739 var h = {

7740 "content-type" : "application/json; charset=utf-8",

7741 };

7742 var resp = convert.JSON.encode(buildAddressList());

7743 return new async.Future.value(common_test.stringResponse(200, h, resp));

7744 }), true);

7745 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.AddressList response) {

7746 checkAddressList(response);

7747 })));

7748 });

7749

7750 });

7751

7752

7753 unittest.group("resource-GlobalForwardingRulesResourceApi", () {

7754 unittest.test("method--delete", () {

7755

7756 var mock = new common_test.HttpServerMock();

7757 api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).global ForwardingRules;

7758 var arg_project = "foo";

7759 var arg_forwardingRule = "foo";

7760 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7761 var path = (req.url).path;

7762 var pathOffset = 0;

7763 var index;

7764 var subPart;

7765 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7766 pathOffset += 21;

7767 index = path.indexOf("/global/forwardingRules/", pathOffset);

7768 unittest.expect(index >= 0, unittest.isTrue);

7769 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7770 pathOffset = index;

7771 unittest.expect(subPart, unittest.equals("$arg_project"));

7772 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/forwardingRules/"));

7773 pathOffset += 24;

7774 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

7775 pathOffset = path.length;

7776 unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));

7777

7778 var query = (req.url).query;

7779 var queryOffset = 0;

7780 var queryMap = {};

7781 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7782 parseBool(n) {

7783 if (n == "true") return true;

7784 if (n == "false") return false;

7785 if (n == null) return null;

7786 throw new core.ArgumentError("Invalid boolean: $n");

7787 }

7788 if (query.length > 0) {

7789 for (var part in query.split("&")) {

7790 var keyvalue = part.split("=");

7791 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7792 }

7793 }

7794

7795

7796 var h = {

7797 "content-type" : "application/json; charset=utf-8",

7798 };

7799 var resp = convert.JSON.encode(buildOperation());

7800 return new async.Future.value(common_test.stringResponse(200, h, resp));

7801 }), true);

7802 res.delete(arg_project, arg_forwardingRule).then(unittest.expectAsync(((ap i.Operation response) {

7803 checkOperation(response);

7804 })));

7805 });

7806

7807 unittest.test("method--get", () {

7808

7809 var mock = new common_test.HttpServerMock();

7810 api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).global ForwardingRules;

7811 var arg_project = "foo";

7812 var arg_forwardingRule = "foo";

7813 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7814 var path = (req.url).path;

7815 var pathOffset = 0;

7816 var index;

7817 var subPart;

7818 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7819 pathOffset += 21;

7820 index = path.indexOf("/global/forwardingRules/", pathOffset);

7821 unittest.expect(index >= 0, unittest.isTrue);

7822 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7823 pathOffset = index;

7824 unittest.expect(subPart, unittest.equals("$arg_project"));

7825 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/forwardingRules/"));

7826 pathOffset += 24;

7827 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

7828 pathOffset = path.length;

7829 unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));

7830

7831 var query = (req.url).query;

7832 var queryOffset = 0;

7833 var queryMap = {};

7834 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7835 parseBool(n) {

7836 if (n == "true") return true;

7837 if (n == "false") return false;

7838 if (n == null) return null;

7839 throw new core.ArgumentError("Invalid boolean: $n");

7840 }

7841 if (query.length > 0) {

7842 for (var part in query.split("&")) {

7843 var keyvalue = part.split("=");

7844 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7845 }

7846 }

7847

7848

7849 var h = {

7850 "content-type" : "application/json; charset=utf-8",

7851 };

7852 var resp = convert.JSON.encode(buildForwardingRule());

7853 return new async.Future.value(common_test.stringResponse(200, h, resp));

7854 }), true);

7855 res.get(arg_project, arg_forwardingRule).then(unittest.expectAsync(((api.F orwardingRule response) {

7856 checkForwardingRule(response);

7857 })));

7858 });

7859

7860 unittest.test("method--insert", () {

7861

7862 var mock = new common_test.HttpServerMock();

7863 api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).global ForwardingRules;

7864 var arg_request = buildForwardingRule();

7865 var arg_project = "foo";

7866 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7867 var obj = new api.ForwardingRule.fromJson(json);

7868 checkForwardingRule(obj);

7869

7870 var path = (req.url).path;

7871 var pathOffset = 0;

7872 var index;

7873 var subPart;

7874 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7875 pathOffset += 21;

7876 index = path.indexOf("/global/forwardingRules", pathOffset);

7877 unittest.expect(index >= 0, unittest.isTrue);

7878 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7879 pathOffset = index;

7880 unittest.expect(subPart, unittest.equals("$arg_project"));

7881 unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.eq uals("/global/forwardingRules"));

7882 pathOffset += 23;

7883

7884 var query = (req.url).query;

7885 var queryOffset = 0;

7886 var queryMap = {};

7887 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7888 parseBool(n) {

7889 if (n == "true") return true;

7890 if (n == "false") return false;

7891 if (n == null) return null;

7892 throw new core.ArgumentError("Invalid boolean: $n");

7893 }

7894 if (query.length > 0) {

7895 for (var part in query.split("&")) {

7896 var keyvalue = part.split("=");

7897 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7898 }

7899 }

7900

7901

7902 var h = {

7903 "content-type" : "application/json; charset=utf-8",

7904 };

7905 var resp = convert.JSON.encode(buildOperation());

7906 return new async.Future.value(common_test.stringResponse(200, h, resp));

7907 }), true);

7908 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

7909 checkOperation(response);

7910 })));

7911 });

7912

7913 unittest.test("method--list", () {

7914

7915 var mock = new common_test.HttpServerMock();

7916 api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).global ForwardingRules;

7917 var arg_project = "foo";

7918 var arg_filter = "foo";

7919 var arg_maxResults = 42;

7920 var arg_pageToken = "foo";

7921 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7922 var path = (req.url).path;

7923 var pathOffset = 0;

7924 var index;

7925 var subPart;

7926 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7927 pathOffset += 21;

7928 index = path.indexOf("/global/forwardingRules", pathOffset);

7929 unittest.expect(index >= 0, unittest.isTrue);

7930 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7931 pathOffset = index;

7932 unittest.expect(subPart, unittest.equals("$arg_project"));

7933 unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.eq uals("/global/forwardingRules"));

7934 pathOffset += 23;

7935

7936 var query = (req.url).query;

7937 var queryOffset = 0;

7938 var queryMap = {};

7939 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

7940 parseBool(n) {

7941 if (n == "true") return true;

7942 if (n == "false") return false;

7943 if (n == null) return null;

7944 throw new core.ArgumentError("Invalid boolean: $n");

7945 }

7946 if (query.length > 0) {

7947 for (var part in query.split("&")) {

7948 var keyvalue = part.split("=");

7949 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

7950 }

7951 }

7952 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

7953 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

7954 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

7955

7956

7957 var h = {

7958 "content-type" : "application/json; charset=utf-8",

7959 };

7960 var resp = convert.JSON.encode(buildForwardingRuleList());

7961 return new async.Future.value(common_test.stringResponse(200, h, resp));

7962 }), true);

7963 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.ForwardingRuleList respons e) {

7964 checkForwardingRuleList(response);

7965 })));

7966 });

7967

7968 unittest.test("method--setTarget", () {

7969

7970 var mock = new common_test.HttpServerMock();

7971 api.GlobalForwardingRulesResourceApi res = new api.ComputeApi(mock).global ForwardingRules;

7972 var arg_request = buildTargetReference();

7973 var arg_project = "foo";

7974 var arg_forwardingRule = "foo";

7975 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

7976 var obj = new api.TargetReference.fromJson(json);

7977 checkTargetReference(obj);

7978

7979 var path = (req.url).path;

7980 var pathOffset = 0;

7981 var index;

7982 var subPart;

7983 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

7984 pathOffset += 21;

7985 index = path.indexOf("/global/forwardingRules/", pathOffset);

7986 unittest.expect(index >= 0, unittest.isTrue);

7987 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7988 pathOffset = index;

7989 unittest.expect(subPart, unittest.equals("$arg_project"));

7990 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/forwardingRules/"));

7991 pathOffset += 24;

7992 index = path.indexOf("/setTarget", pathOffset);

7993 unittest.expect(index >= 0, unittest.isTrue);

7994 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

7995 pathOffset = index;

7996 unittest.expect(subPart, unittest.equals("$arg_forwardingRule"));

7997 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/setTarget"));

7998 pathOffset += 10;

7999

8000 var query = (req.url).query;

8001 var queryOffset = 0;

8002 var queryMap = {};

8003 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8004 parseBool(n) {

8005 if (n == "true") return true;

8006 if (n == "false") return false;

8007 if (n == null) return null;

8008 throw new core.ArgumentError("Invalid boolean: $n");

8009 }

8010 if (query.length > 0) {

8011 for (var part in query.split("&")) {

8012 var keyvalue = part.split("=");

8013 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8014 }

8015 }

8016

8017

8018 var h = {

8019 "content-type" : "application/json; charset=utf-8",

8020 };

8021 var resp = convert.JSON.encode(buildOperation());

8022 return new async.Future.value(common_test.stringResponse(200, h, resp));

8023 }), true);

8024 res.setTarget(arg_request, arg_project, arg_forwardingRule).then(unittest. expectAsync(((api.Operation response) {

8025 checkOperation(response);

8026 })));

8027 });

8028

8029 });

8030

8031

8032 unittest.group("resource-GlobalOperationsResourceApi", () {

8033 unittest.test("method--aggregatedList", () {

8034

8035 var mock = new common_test.HttpServerMock();

8036 api.GlobalOperationsResourceApi res = new api.ComputeApi(mock).globalOpera tions;

8037 var arg_project = "foo";

8038 var arg_filter = "foo";

8039 var arg_maxResults = 42;

8040 var arg_pageToken = "foo";

8041 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8042 var path = (req.url).path;

8043 var pathOffset = 0;

8044 var index;

8045 var subPart;

8046 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8047 pathOffset += 21;

8048 index = path.indexOf("/aggregated/operations", pathOffset);

8049 unittest.expect(index >= 0, unittest.isTrue);

8050 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8051 pathOffset = index;

8052 unittest.expect(subPart, unittest.equals("$arg_project"));

8053 unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.eq uals("/aggregated/operations"));

8054 pathOffset += 22;

8055

8056 var query = (req.url).query;

8057 var queryOffset = 0;

8058 var queryMap = {};

8059 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8060 parseBool(n) {

8061 if (n == "true") return true;

8062 if (n == "false") return false;

8063 if (n == null) return null;

8064 throw new core.ArgumentError("Invalid boolean: $n");

8065 }

8066 if (query.length > 0) {

8067 for (var part in query.split("&")) {

8068 var keyvalue = part.split("=");

8069 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8070 }

8071 }

8072 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

8073 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

8074 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

8075

8076

8077 var h = {

8078 "content-type" : "application/json; charset=utf-8",

8079 };

8080 var resp = convert.JSON.encode(buildOperationAggregatedList());

8081 return new async.Future.value(common_test.stringResponse(200, h, resp));

8082 }), true);

8083 res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.OperationAggrega tedList response) {

8084 checkOperationAggregatedList(response);

8085 })));

8086 });

8087

8088 unittest.test("method--delete", () {

8089

8090 var mock = new common_test.HttpServerMock();

8091 api.GlobalOperationsResourceApi res = new api.ComputeApi(mock).globalOpera tions;

8092 var arg_project = "foo";

8093 var arg_operation = "foo";

8094 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8095 var path = (req.url).path;

8096 var pathOffset = 0;

8097 var index;

8098 var subPart;

8099 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8100 pathOffset += 21;

8101 index = path.indexOf("/global/operations/", pathOffset);

8102 unittest.expect(index >= 0, unittest.isTrue);

8103 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8104 pathOffset = index;

8105 unittest.expect(subPart, unittest.equals("$arg_project"));

8106 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("/global/operations/"));

8107 pathOffset += 19;

8108 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

8109 pathOffset = path.length;

8110 unittest.expect(subPart, unittest.equals("$arg_operation"));

8111

8112 var query = (req.url).query;

8113 var queryOffset = 0;

8114 var queryMap = {};

8115 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8116 parseBool(n) {

8117 if (n == "true") return true;

8118 if (n == "false") return false;

8119 if (n == null) return null;

8120 throw new core.ArgumentError("Invalid boolean: $n");

8121 }

8122 if (query.length > 0) {

8123 for (var part in query.split("&")) {

8124 var keyvalue = part.split("=");

8125 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8126 }

8127 }

8128

8129

8130 var h = {

8131 "content-type" : "application/json; charset=utf-8",

8132 };

8133 var resp = "";

8134 return new async.Future.value(common_test.stringResponse(200, h, resp));

8135 }), true);

8136 res.delete(arg_project, arg_operation).then(unittest.expectAsync((_) {}));

8137 });

8138

8139 unittest.test("method--get", () {

8140

8141 var mock = new common_test.HttpServerMock();

8142 api.GlobalOperationsResourceApi res = new api.ComputeApi(mock).globalOpera tions;

8143 var arg_project = "foo";

8144 var arg_operation = "foo";

8145 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8146 var path = (req.url).path;

8147 var pathOffset = 0;

8148 var index;

8149 var subPart;

8150 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8151 pathOffset += 21;

8152 index = path.indexOf("/global/operations/", pathOffset);

8153 unittest.expect(index >= 0, unittest.isTrue);

8154 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8155 pathOffset = index;

8156 unittest.expect(subPart, unittest.equals("$arg_project"));

8157 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("/global/operations/"));

8158 pathOffset += 19;

8159 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

8160 pathOffset = path.length;

8161 unittest.expect(subPart, unittest.equals("$arg_operation"));

8162

8163 var query = (req.url).query;

8164 var queryOffset = 0;

8165 var queryMap = {};

8166 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8167 parseBool(n) {

8168 if (n == "true") return true;

8169 if (n == "false") return false;

8170 if (n == null) return null;

8171 throw new core.ArgumentError("Invalid boolean: $n");

8172 }

8173 if (query.length > 0) {

8174 for (var part in query.split("&")) {

8175 var keyvalue = part.split("=");

8176 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8177 }

8178 }

8179

8180

8181 var h = {

8182 "content-type" : "application/json; charset=utf-8",

8183 };

8184 var resp = convert.JSON.encode(buildOperation());

8185 return new async.Future.value(common_test.stringResponse(200, h, resp));

8186 }), true);

8187 res.get(arg_project, arg_operation).then(unittest.expectAsync(((api.Operat ion response) {

8188 checkOperation(response);

8189 })));

8190 });

8191

8192 unittest.test("method--list", () {

8193

8194 var mock = new common_test.HttpServerMock();

8195 api.GlobalOperationsResourceApi res = new api.ComputeApi(mock).globalOpera tions;

8196 var arg_project = "foo";

8197 var arg_filter = "foo";

8198 var arg_maxResults = 42;

8199 var arg_pageToken = "foo";

8200 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8201 var path = (req.url).path;

8202 var pathOffset = 0;

8203 var index;

8204 var subPart;

8205 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8206 pathOffset += 21;

8207 index = path.indexOf("/global/operations", pathOffset);

8208 unittest.expect(index >= 0, unittest.isTrue);

8209 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8210 pathOffset = index;

8211 unittest.expect(subPart, unittest.equals("$arg_project"));

8212 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/global/operations"));

8213 pathOffset += 18;

8214

8215 var query = (req.url).query;

8216 var queryOffset = 0;

8217 var queryMap = {};

8218 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8219 parseBool(n) {

8220 if (n == "true") return true;

8221 if (n == "false") return false;

8222 if (n == null) return null;

8223 throw new core.ArgumentError("Invalid boolean: $n");

8224 }

8225 if (query.length > 0) {

8226 for (var part in query.split("&")) {

8227 var keyvalue = part.split("=");

8228 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8229 }

8230 }

8231 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

8232 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

8233 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

8234

8235

8236 var h = {

8237 "content-type" : "application/json; charset=utf-8",

8238 };

8239 var resp = convert.JSON.encode(buildOperationList());

8240 return new async.Future.value(common_test.stringResponse(200, h, resp));

8241 }), true);

8242 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.OperationList response) {

8243 checkOperationList(response);

8244 })));

8245 });

8246

8247 });

8248

8249

8250 unittest.group("resource-HttpHealthChecksResourceApi", () {

8251 unittest.test("method--delete", () {

8252

8253 var mock = new common_test.HttpServerMock();

8254 api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthC hecks;

8255 var arg_project = "foo";

8256 var arg_httpHealthCheck = "foo";

8257 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8258 var path = (req.url).path;

8259 var pathOffset = 0;

8260 var index;

8261 var subPart;

8262 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8263 pathOffset += 21;

8264 index = path.indexOf("/global/httpHealthChecks/", pathOffset);

8265 unittest.expect(index >= 0, unittest.isTrue);

8266 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8267 pathOffset = index;

8268 unittest.expect(subPart, unittest.equals("$arg_project"));

8269 unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.eq uals("/global/httpHealthChecks/"));

8270 pathOffset += 25;

8271 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

8272 pathOffset = path.length;

8273 unittest.expect(subPart, unittest.equals("$arg_httpHealthCheck"));

8274

8275 var query = (req.url).query;

8276 var queryOffset = 0;

8277 var queryMap = {};

8278 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8279 parseBool(n) {

8280 if (n == "true") return true;

8281 if (n == "false") return false;

8282 if (n == null) return null;

8283 throw new core.ArgumentError("Invalid boolean: $n");

8284 }

8285 if (query.length > 0) {

8286 for (var part in query.split("&")) {

8287 var keyvalue = part.split("=");

8288 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8289 }

8290 }

8291

8292

8293 var h = {

8294 "content-type" : "application/json; charset=utf-8",

8295 };

8296 var resp = convert.JSON.encode(buildOperation());

8297 return new async.Future.value(common_test.stringResponse(200, h, resp));

8298 }), true);

8299 res.delete(arg_project, arg_httpHealthCheck).then(unittest.expectAsync(((a pi.Operation response) {

8300 checkOperation(response);

8301 })));

8302 });

8303

8304 unittest.test("method--get", () {

8305

8306 var mock = new common_test.HttpServerMock();

8307 api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthC hecks;

8308 var arg_project = "foo";

8309 var arg_httpHealthCheck = "foo";

8310 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8311 var path = (req.url).path;

8312 var pathOffset = 0;

8313 var index;

8314 var subPart;

8315 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8316 pathOffset += 21;

8317 index = path.indexOf("/global/httpHealthChecks/", pathOffset);

8318 unittest.expect(index >= 0, unittest.isTrue);

8319 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8320 pathOffset = index;

8321 unittest.expect(subPart, unittest.equals("$arg_project"));

8322 unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.eq uals("/global/httpHealthChecks/"));

8323 pathOffset += 25;

8324 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

8325 pathOffset = path.length;

8326 unittest.expect(subPart, unittest.equals("$arg_httpHealthCheck"));

8327

8328 var query = (req.url).query;

8329 var queryOffset = 0;

8330 var queryMap = {};

8331 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8332 parseBool(n) {

8333 if (n == "true") return true;

8334 if (n == "false") return false;

8335 if (n == null) return null;

8336 throw new core.ArgumentError("Invalid boolean: $n");

8337 }

8338 if (query.length > 0) {

8339 for (var part in query.split("&")) {

8340 var keyvalue = part.split("=");

8341 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8342 }

8343 }

8344

8345

8346 var h = {

8347 "content-type" : "application/json; charset=utf-8",

8348 };

8349 var resp = convert.JSON.encode(buildHttpHealthCheck());

8350 return new async.Future.value(common_test.stringResponse(200, h, resp));

8351 }), true);

8352 res.get(arg_project, arg_httpHealthCheck).then(unittest.expectAsync(((api. HttpHealthCheck response) {

8353 checkHttpHealthCheck(response);

8354 })));

8355 });

8356

8357 unittest.test("method--insert", () {

8358

8359 var mock = new common_test.HttpServerMock();

8360 api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthC hecks;

8361 var arg_request = buildHttpHealthCheck();

8362 var arg_project = "foo";

8363 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8364 var obj = new api.HttpHealthCheck.fromJson(json);

8365 checkHttpHealthCheck(obj);

8366

8367 var path = (req.url).path;

8368 var pathOffset = 0;

8369 var index;

8370 var subPart;

8371 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8372 pathOffset += 21;

8373 index = path.indexOf("/global/httpHealthChecks", pathOffset);

8374 unittest.expect(index >= 0, unittest.isTrue);

8375 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8376 pathOffset = index;

8377 unittest.expect(subPart, unittest.equals("$arg_project"));

8378 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/httpHealthChecks"));

8379 pathOffset += 24;

8380

8381 var query = (req.url).query;

8382 var queryOffset = 0;

8383 var queryMap = {};

8384 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8385 parseBool(n) {

8386 if (n == "true") return true;

8387 if (n == "false") return false;

8388 if (n == null) return null;

8389 throw new core.ArgumentError("Invalid boolean: $n");

8390 }

8391 if (query.length > 0) {

8392 for (var part in query.split("&")) {

8393 var keyvalue = part.split("=");

8394 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8395 }

8396 }

8397

8398

8399 var h = {

8400 "content-type" : "application/json; charset=utf-8",

8401 };

8402 var resp = convert.JSON.encode(buildOperation());

8403 return new async.Future.value(common_test.stringResponse(200, h, resp));

8404 }), true);

8405 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

8406 checkOperation(response);

8407 })));

8408 });

8409

8410 unittest.test("method--list", () {

8411

8412 var mock = new common_test.HttpServerMock();

8413 api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthC hecks;

8414 var arg_project = "foo";

8415 var arg_filter = "foo";

8416 var arg_maxResults = 42;

8417 var arg_pageToken = "foo";

8418 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8419 var path = (req.url).path;

8420 var pathOffset = 0;

8421 var index;

8422 var subPart;

8423 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8424 pathOffset += 21;

8425 index = path.indexOf("/global/httpHealthChecks", pathOffset);

8426 unittest.expect(index >= 0, unittest.isTrue);

8427 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8428 pathOffset = index;

8429 unittest.expect(subPart, unittest.equals("$arg_project"));

8430 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/global/httpHealthChecks"));

8431 pathOffset += 24;

8432

8433 var query = (req.url).query;

8434 var queryOffset = 0;

8435 var queryMap = {};

8436 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8437 parseBool(n) {

8438 if (n == "true") return true;

8439 if (n == "false") return false;

8440 if (n == null) return null;

8441 throw new core.ArgumentError("Invalid boolean: $n");

8442 }

8443 if (query.length > 0) {

8444 for (var part in query.split("&")) {

8445 var keyvalue = part.split("=");

8446 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8447 }

8448 }

8449 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

8450 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

8451 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

8452

8453

8454 var h = {

8455 "content-type" : "application/json; charset=utf-8",

8456 };

8457 var resp = convert.JSON.encode(buildHttpHealthCheckList());

8458 return new async.Future.value(common_test.stringResponse(200, h, resp));

8459 }), true);

8460 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.HttpHealthCheckList respon se) {

8461 checkHttpHealthCheckList(response);

8462 })));

8463 });

8464

8465 unittest.test("method--patch", () {

8466

8467 var mock = new common_test.HttpServerMock();

8468 api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthC hecks;

8469 var arg_request = buildHttpHealthCheck();

8470 var arg_project = "foo";

8471 var arg_httpHealthCheck = "foo";

8472 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8473 var obj = new api.HttpHealthCheck.fromJson(json);

8474 checkHttpHealthCheck(obj);

8475

8476 var path = (req.url).path;

8477 var pathOffset = 0;

8478 var index;

8479 var subPart;

8480 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8481 pathOffset += 21;

8482 index = path.indexOf("/global/httpHealthChecks/", pathOffset);

8483 unittest.expect(index >= 0, unittest.isTrue);

8484 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8485 pathOffset = index;

8486 unittest.expect(subPart, unittest.equals("$arg_project"));

8487 unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.eq uals("/global/httpHealthChecks/"));

8488 pathOffset += 25;

8489 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

8490 pathOffset = path.length;

8491 unittest.expect(subPart, unittest.equals("$arg_httpHealthCheck"));

8492

8493 var query = (req.url).query;

8494 var queryOffset = 0;

8495 var queryMap = {};

8496 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8497 parseBool(n) {

8498 if (n == "true") return true;

8499 if (n == "false") return false;

8500 if (n == null) return null;

8501 throw new core.ArgumentError("Invalid boolean: $n");

8502 }

8503 if (query.length > 0) {

8504 for (var part in query.split("&")) {

8505 var keyvalue = part.split("=");

8506 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8507 }

8508 }

8509

8510

8511 var h = {

8512 "content-type" : "application/json; charset=utf-8",

8513 };

8514 var resp = convert.JSON.encode(buildOperation());

8515 return new async.Future.value(common_test.stringResponse(200, h, resp));

8516 }), true);

8517 res.patch(arg_request, arg_project, arg_httpHealthCheck).then(unittest.exp ectAsync(((api.Operation response) {

8518 checkOperation(response);

8519 })));

8520 });

8521

8522 unittest.test("method--update", () {

8523

8524 var mock = new common_test.HttpServerMock();

8525 api.HttpHealthChecksResourceApi res = new api.ComputeApi(mock).httpHealthC hecks;

8526 var arg_request = buildHttpHealthCheck();

8527 var arg_project = "foo";

8528 var arg_httpHealthCheck = "foo";

8529 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8530 var obj = new api.HttpHealthCheck.fromJson(json);

8531 checkHttpHealthCheck(obj);

8532

8533 var path = (req.url).path;

8534 var pathOffset = 0;

8535 var index;

8536 var subPart;

8537 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8538 pathOffset += 21;

8539 index = path.indexOf("/global/httpHealthChecks/", pathOffset);

8540 unittest.expect(index >= 0, unittest.isTrue);

8541 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8542 pathOffset = index;

8543 unittest.expect(subPart, unittest.equals("$arg_project"));

8544 unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.eq uals("/global/httpHealthChecks/"));

8545 pathOffset += 25;

8546 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

8547 pathOffset = path.length;

8548 unittest.expect(subPart, unittest.equals("$arg_httpHealthCheck"));

8549

8550 var query = (req.url).query;

8551 var queryOffset = 0;

8552 var queryMap = {};

8553 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8554 parseBool(n) {

8555 if (n == "true") return true;

8556 if (n == "false") return false;

8557 if (n == null) return null;

8558 throw new core.ArgumentError("Invalid boolean: $n");

8559 }

8560 if (query.length > 0) {

8561 for (var part in query.split("&")) {

8562 var keyvalue = part.split("=");

8563 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8564 }

8565 }

8566

8567

8568 var h = {

8569 "content-type" : "application/json; charset=utf-8",

8570 };

8571 var resp = convert.JSON.encode(buildOperation());

8572 return new async.Future.value(common_test.stringResponse(200, h, resp));

8573 }), true);

8574 res.update(arg_request, arg_project, arg_httpHealthCheck).then(unittest.ex pectAsync(((api.Operation response) {

8575 checkOperation(response);

8576 })));

8577 });

8578

8579 });

8580

8581

8582 unittest.group("resource-ImagesResourceApi", () {

8583 unittest.test("method--delete", () {

8584

8585 var mock = new common_test.HttpServerMock();

8586 api.ImagesResourceApi res = new api.ComputeApi(mock).images;

8587 var arg_project = "foo";

8588 var arg_image = "foo";

8589 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8590 var path = (req.url).path;

8591 var pathOffset = 0;

8592 var index;

8593 var subPart;

8594 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8595 pathOffset += 21;

8596 index = path.indexOf("/global/images/", pathOffset);

8597 unittest.expect(index >= 0, unittest.isTrue);

8598 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8599 pathOffset = index;

8600 unittest.expect(subPart, unittest.equals("$arg_project"));

8601 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/global/images/"));

8602 pathOffset += 15;

8603 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

8604 pathOffset = path.length;

8605 unittest.expect(subPart, unittest.equals("$arg_image"));

8606

8607 var query = (req.url).query;

8608 var queryOffset = 0;

8609 var queryMap = {};

8610 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8611 parseBool(n) {

8612 if (n == "true") return true;

8613 if (n == "false") return false;

8614 if (n == null) return null;

8615 throw new core.ArgumentError("Invalid boolean: $n");

8616 }

8617 if (query.length > 0) {

8618 for (var part in query.split("&")) {

8619 var keyvalue = part.split("=");

8620 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8621 }

8622 }

8623

8624

8625 var h = {

8626 "content-type" : "application/json; charset=utf-8",

8627 };

8628 var resp = convert.JSON.encode(buildOperation());

8629 return new async.Future.value(common_test.stringResponse(200, h, resp));

8630 }), true);

8631 res.delete(arg_project, arg_image).then(unittest.expectAsync(((api.Operati on response) {

8632 checkOperation(response);

8633 })));

8634 });

8635

8636 unittest.test("method--deprecate", () {

8637

8638 var mock = new common_test.HttpServerMock();

8639 api.ImagesResourceApi res = new api.ComputeApi(mock).images;

8640 var arg_request = buildDeprecationStatus();

8641 var arg_project = "foo";

8642 var arg_image = "foo";

8643 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8644 var obj = new api.DeprecationStatus.fromJson(json);

8645 checkDeprecationStatus(obj);

8646

8647 var path = (req.url).path;

8648 var pathOffset = 0;

8649 var index;

8650 var subPart;

8651 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8652 pathOffset += 21;

8653 index = path.indexOf("/global/images/", pathOffset);

8654 unittest.expect(index >= 0, unittest.isTrue);

8655 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8656 pathOffset = index;

8657 unittest.expect(subPart, unittest.equals("$arg_project"));

8658 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/global/images/"));

8659 pathOffset += 15;

8660 index = path.indexOf("/deprecate", pathOffset);

8661 unittest.expect(index >= 0, unittest.isTrue);

8662 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8663 pathOffset = index;

8664 unittest.expect(subPart, unittest.equals("$arg_image"));

8665 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/deprecate"));

8666 pathOffset += 10;

8667

8668 var query = (req.url).query;

8669 var queryOffset = 0;

8670 var queryMap = {};

8671 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8672 parseBool(n) {

8673 if (n == "true") return true;

8674 if (n == "false") return false;

8675 if (n == null) return null;

8676 throw new core.ArgumentError("Invalid boolean: $n");

8677 }

8678 if (query.length > 0) {

8679 for (var part in query.split("&")) {

8680 var keyvalue = part.split("=");

8681 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8682 }

8683 }

8684

8685

8686 var h = {

8687 "content-type" : "application/json; charset=utf-8",

8688 };

8689 var resp = convert.JSON.encode(buildOperation());

8690 return new async.Future.value(common_test.stringResponse(200, h, resp));

8691 }), true);

8692 res.deprecate(arg_request, arg_project, arg_image).then(unittest.expectAsy nc(((api.Operation response) {

8693 checkOperation(response);

8694 })));

8695 });

8696

8697 unittest.test("method--get", () {

8698

8699 var mock = new common_test.HttpServerMock();

8700 api.ImagesResourceApi res = new api.ComputeApi(mock).images;

8701 var arg_project = "foo";

8702 var arg_image = "foo";

8703 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8704 var path = (req.url).path;

8705 var pathOffset = 0;

8706 var index;

8707 var subPart;

8708 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8709 pathOffset += 21;

8710 index = path.indexOf("/global/images/", pathOffset);

8711 unittest.expect(index >= 0, unittest.isTrue);

8712 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8713 pathOffset = index;

8714 unittest.expect(subPart, unittest.equals("$arg_project"));

8715 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/global/images/"));

8716 pathOffset += 15;

8717 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

8718 pathOffset = path.length;

8719 unittest.expect(subPart, unittest.equals("$arg_image"));

8720

8721 var query = (req.url).query;

8722 var queryOffset = 0;

8723 var queryMap = {};

8724 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8725 parseBool(n) {

8726 if (n == "true") return true;

8727 if (n == "false") return false;

8728 if (n == null) return null;

8729 throw new core.ArgumentError("Invalid boolean: $n");

8730 }

8731 if (query.length > 0) {

8732 for (var part in query.split("&")) {

8733 var keyvalue = part.split("=");

8734 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8735 }

8736 }

8737

8738

8739 var h = {

8740 "content-type" : "application/json; charset=utf-8",

8741 };

8742 var resp = convert.JSON.encode(buildImage());

8743 return new async.Future.value(common_test.stringResponse(200, h, resp));

8744 }), true);

8745 res.get(arg_project, arg_image).then(unittest.expectAsync(((api.Image resp onse) {

8746 checkImage(response);

8747 })));

8748 });

8749

8750 unittest.test("method--insert", () {

8751

8752 var mock = new common_test.HttpServerMock();

8753 api.ImagesResourceApi res = new api.ComputeApi(mock).images;

8754 var arg_request = buildImage();

8755 var arg_project = "foo";

8756 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8757 var obj = new api.Image.fromJson(json);

8758 checkImage(obj);

8759

8760 var path = (req.url).path;

8761 var pathOffset = 0;

8762 var index;

8763 var subPart;

8764 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8765 pathOffset += 21;

8766 index = path.indexOf("/global/images", pathOffset);

8767 unittest.expect(index >= 0, unittest.isTrue);

8768 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8769 pathOffset = index;

8770 unittest.expect(subPart, unittest.equals("$arg_project"));

8771 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/global/images"));

8772 pathOffset += 14;

8773

8774 var query = (req.url).query;

8775 var queryOffset = 0;

8776 var queryMap = {};

8777 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8778 parseBool(n) {

8779 if (n == "true") return true;

8780 if (n == "false") return false;

8781 if (n == null) return null;

8782 throw new core.ArgumentError("Invalid boolean: $n");

8783 }

8784 if (query.length > 0) {

8785 for (var part in query.split("&")) {

8786 var keyvalue = part.split("=");

8787 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8788 }

8789 }

8790

8791

8792 var h = {

8793 "content-type" : "application/json; charset=utf-8",

8794 };

8795 var resp = convert.JSON.encode(buildOperation());

8796 return new async.Future.value(common_test.stringResponse(200, h, resp));

8797 }), true);

8798 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

8799 checkOperation(response);

8800 })));

8801 });

8802

8803 unittest.test("method--list", () {

8804

8805 var mock = new common_test.HttpServerMock();

8806 api.ImagesResourceApi res = new api.ComputeApi(mock).images;

8807 var arg_project = "foo";

8808 var arg_filter = "foo";

8809 var arg_maxResults = 42;

8810 var arg_pageToken = "foo";

8811 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8812 var path = (req.url).path;

8813 var pathOffset = 0;

8814 var index;

8815 var subPart;

8816 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8817 pathOffset += 21;

8818 index = path.indexOf("/global/images", pathOffset);

8819 unittest.expect(index >= 0, unittest.isTrue);

8820 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8821 pathOffset = index;

8822 unittest.expect(subPart, unittest.equals("$arg_project"));

8823 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/global/images"));

8824 pathOffset += 14;

8825

8826 var query = (req.url).query;

8827 var queryOffset = 0;

8828 var queryMap = {};

8829 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8830 parseBool(n) {

8831 if (n == "true") return true;

8832 if (n == "false") return false;

8833 if (n == null) return null;

8834 throw new core.ArgumentError("Invalid boolean: $n");

8835 }

8836 if (query.length > 0) {

8837 for (var part in query.split("&")) {

8838 var keyvalue = part.split("=");

8839 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8840 }

8841 }

8842 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

8843 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

8844 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

8845

8846

8847 var h = {

8848 "content-type" : "application/json; charset=utf-8",

8849 };

8850 var resp = convert.JSON.encode(buildImageList());

8851 return new async.Future.value(common_test.stringResponse(200, h, resp));

8852 }), true);

8853 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.ImageList response) {

8854 checkImageList(response);

8855 })));

8856 });

8857

8858 });

8859

8860

8861 unittest.group("resource-InstancesResourceApi", () {

8862 unittest.test("method--addAccessConfig", () {

8863

8864 var mock = new common_test.HttpServerMock();

8865 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

8866 var arg_request = buildAccessConfig();

8867 var arg_project = "foo";

8868 var arg_zone = "foo";

8869 var arg_instance = "foo";

8870 var arg_networkInterface = "foo";

8871 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8872 var obj = new api.AccessConfig.fromJson(json);

8873 checkAccessConfig(obj);

8874

8875 var path = (req.url).path;

8876 var pathOffset = 0;

8877 var index;

8878 var subPart;

8879 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8880 pathOffset += 21;

8881 index = path.indexOf("/zones/", pathOffset);

8882 unittest.expect(index >= 0, unittest.isTrue);

8883 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8884 pathOffset = index;

8885 unittest.expect(subPart, unittest.equals("$arg_project"));

8886 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

8887 pathOffset += 7;

8888 index = path.indexOf("/instances/", pathOffset);

8889 unittest.expect(index >= 0, unittest.isTrue);

8890 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8891 pathOffset = index;

8892 unittest.expect(subPart, unittest.equals("$arg_zone"));

8893 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

8894 pathOffset += 11;

8895 index = path.indexOf("/addAccessConfig", pathOffset);

8896 unittest.expect(index >= 0, unittest.isTrue);

8897 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8898 pathOffset = index;

8899 unittest.expect(subPart, unittest.equals("$arg_instance"));

8900 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/addAccessConfig"));

8901 pathOffset += 16;

8902

8903 var query = (req.url).query;

8904 var queryOffset = 0;

8905 var queryMap = {};

8906 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8907 parseBool(n) {

8908 if (n == "true") return true;

8909 if (n == "false") return false;

8910 if (n == null) return null;

8911 throw new core.ArgumentError("Invalid boolean: $n");

8912 }

8913 if (query.length > 0) {

8914 for (var part in query.split("&")) {

8915 var keyvalue = part.split("=");

8916 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8917 }

8918 }

8919 unittest.expect(queryMap["networkInterface"].first, unittest.equals(arg_ networkInterface));

8920

8921

8922 var h = {

8923 "content-type" : "application/json; charset=utf-8",

8924 };

8925 var resp = convert.JSON.encode(buildOperation());

8926 return new async.Future.value(common_test.stringResponse(200, h, resp));

8927 }), true);

8928 res.addAccessConfig(arg_request, arg_project, arg_zone, arg_instance, arg_ networkInterface).then(unittest.expectAsync(((api.Operation response) {

8929 checkOperation(response);

8930 })));

8931 });

8932

8933 unittest.test("method--aggregatedList", () {

8934

8935 var mock = new common_test.HttpServerMock();

8936 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

8937 var arg_project = "foo";

8938 var arg_filter = "foo";

8939 var arg_maxResults = 42;

8940 var arg_pageToken = "foo";

8941 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8942 var path = (req.url).path;

8943 var pathOffset = 0;

8944 var index;

8945 var subPart;

8946 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

8947 pathOffset += 21;

8948 index = path.indexOf("/aggregated/instances", pathOffset);

8949 unittest.expect(index >= 0, unittest.isTrue);

8950 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

8951 pathOffset = index;

8952 unittest.expect(subPart, unittest.equals("$arg_project"));

8953 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/aggregated/instances"));

8954 pathOffset += 21;

8955

8956 var query = (req.url).query;

8957 var queryOffset = 0;

8958 var queryMap = {};

8959 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

8960 parseBool(n) {

8961 if (n == "true") return true;

8962 if (n == "false") return false;

8963 if (n == null) return null;

8964 throw new core.ArgumentError("Invalid boolean: $n");

8965 }

8966 if (query.length > 0) {

8967 for (var part in query.split("&")) {

8968 var keyvalue = part.split("=");

8969 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

8970 }

8971 }

8972 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

8973 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

8974 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

8975

8976

8977 var h = {

8978 "content-type" : "application/json; charset=utf-8",

8979 };

8980 var resp = convert.JSON.encode(buildInstanceAggregatedList());

8981 return new async.Future.value(common_test.stringResponse(200, h, resp));

8982 }), true);

8983 res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.InstanceAggregat edList response) {

8984 checkInstanceAggregatedList(response);

8985 })));

8986 });

8987

8988 unittest.test("method--attachDisk", () {

8989

8990 var mock = new common_test.HttpServerMock();

8991 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

8992 var arg_request = buildAttachedDisk();

8993 var arg_project = "foo";

8994 var arg_zone = "foo";

8995 var arg_instance = "foo";

8996 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

8997 var obj = new api.AttachedDisk.fromJson(json);

8998 checkAttachedDisk(obj);

8999

9000 var path = (req.url).path;

9001 var pathOffset = 0;

9002 var index;

9003 var subPart;

9004 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9005 pathOffset += 21;

9006 index = path.indexOf("/zones/", pathOffset);

9007 unittest.expect(index >= 0, unittest.isTrue);

9008 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9009 pathOffset = index;

9010 unittest.expect(subPart, unittest.equals("$arg_project"));

9011 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9012 pathOffset += 7;

9013 index = path.indexOf("/instances/", pathOffset);

9014 unittest.expect(index >= 0, unittest.isTrue);

9015 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9016 pathOffset = index;

9017 unittest.expect(subPart, unittest.equals("$arg_zone"));

9018 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9019 pathOffset += 11;

9020 index = path.indexOf("/attachDisk", pathOffset);

9021 unittest.expect(index >= 0, unittest.isTrue);

9022 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9023 pathOffset = index;

9024 unittest.expect(subPart, unittest.equals("$arg_instance"));

9025 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/attachDisk"));

9026 pathOffset += 11;

9027

9028 var query = (req.url).query;

9029 var queryOffset = 0;

9030 var queryMap = {};

9031 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9032 parseBool(n) {

9033 if (n == "true") return true;

9034 if (n == "false") return false;

9035 if (n == null) return null;

9036 throw new core.ArgumentError("Invalid boolean: $n");

9037 }

9038 if (query.length > 0) {

9039 for (var part in query.split("&")) {

9040 var keyvalue = part.split("=");

9041 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9042 }

9043 }

9044

9045

9046 var h = {

9047 "content-type" : "application/json; charset=utf-8",

9048 };

9049 var resp = convert.JSON.encode(buildOperation());

9050 return new async.Future.value(common_test.stringResponse(200, h, resp));

9051 }), true);

9052 res.attachDisk(arg_request, arg_project, arg_zone, arg_instance).then(unit test.expectAsync(((api.Operation response) {

9053 checkOperation(response);

9054 })));

9055 });

9056

9057 unittest.test("method--delete", () {

9058

9059 var mock = new common_test.HttpServerMock();

9060 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9061 var arg_project = "foo";

9062 var arg_zone = "foo";

9063 var arg_instance = "foo";

9064 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9065 var path = (req.url).path;

9066 var pathOffset = 0;

9067 var index;

9068 var subPart;

9069 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9070 pathOffset += 21;

9071 index = path.indexOf("/zones/", pathOffset);

9072 unittest.expect(index >= 0, unittest.isTrue);

9073 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9074 pathOffset = index;

9075 unittest.expect(subPart, unittest.equals("$arg_project"));

9076 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9077 pathOffset += 7;

9078 index = path.indexOf("/instances/", pathOffset);

9079 unittest.expect(index >= 0, unittest.isTrue);

9080 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9081 pathOffset = index;

9082 unittest.expect(subPart, unittest.equals("$arg_zone"));

9083 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9084 pathOffset += 11;

9085 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

9086 pathOffset = path.length;

9087 unittest.expect(subPart, unittest.equals("$arg_instance"));

9088

9089 var query = (req.url).query;

9090 var queryOffset = 0;

9091 var queryMap = {};

9092 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9093 parseBool(n) {

9094 if (n == "true") return true;

9095 if (n == "false") return false;

9096 if (n == null) return null;

9097 throw new core.ArgumentError("Invalid boolean: $n");

9098 }

9099 if (query.length > 0) {

9100 for (var part in query.split("&")) {

9101 var keyvalue = part.split("=");

9102 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9103 }

9104 }

9105

9106

9107 var h = {

9108 "content-type" : "application/json; charset=utf-8",

9109 };

9110 var resp = convert.JSON.encode(buildOperation());

9111 return new async.Future.value(common_test.stringResponse(200, h, resp));

9112 }), true);

9113 res.delete(arg_project, arg_zone, arg_instance).then(unittest.expectAsync( ((api.Operation response) {

9114 checkOperation(response);

9115 })));

9116 });

9117

9118 unittest.test("method--deleteAccessConfig", () {

9119

9120 var mock = new common_test.HttpServerMock();

9121 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9122 var arg_project = "foo";

9123 var arg_zone = "foo";

9124 var arg_instance = "foo";

9125 var arg_accessConfig = "foo";

9126 var arg_networkInterface = "foo";

9127 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9128 var path = (req.url).path;

9129 var pathOffset = 0;

9130 var index;

9131 var subPart;

9132 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9133 pathOffset += 21;

9134 index = path.indexOf("/zones/", pathOffset);

9135 unittest.expect(index >= 0, unittest.isTrue);

9136 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9137 pathOffset = index;

9138 unittest.expect(subPart, unittest.equals("$arg_project"));

9139 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9140 pathOffset += 7;

9141 index = path.indexOf("/instances/", pathOffset);

9142 unittest.expect(index >= 0, unittest.isTrue);

9143 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9144 pathOffset = index;

9145 unittest.expect(subPart, unittest.equals("$arg_zone"));

9146 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9147 pathOffset += 11;

9148 index = path.indexOf("/deleteAccessConfig", pathOffset);

9149 unittest.expect(index >= 0, unittest.isTrue);

9150 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9151 pathOffset = index;

9152 unittest.expect(subPart, unittest.equals("$arg_instance"));

9153 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("/deleteAccessConfig"));

9154 pathOffset += 19;

9155

9156 var query = (req.url).query;

9157 var queryOffset = 0;

9158 var queryMap = {};

9159 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9160 parseBool(n) {

9161 if (n == "true") return true;

9162 if (n == "false") return false;

9163 if (n == null) return null;

9164 throw new core.ArgumentError("Invalid boolean: $n");

9165 }

9166 if (query.length > 0) {

9167 for (var part in query.split("&")) {

9168 var keyvalue = part.split("=");

9169 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9170 }

9171 }

9172 unittest.expect(queryMap["accessConfig"].first, unittest.equals(arg_acce ssConfig));

9173 unittest.expect(queryMap["networkInterface"].first, unittest.equals(arg_ networkInterface));

9174

9175

9176 var h = {

9177 "content-type" : "application/json; charset=utf-8",

9178 };

9179 var resp = convert.JSON.encode(buildOperation());

9180 return new async.Future.value(common_test.stringResponse(200, h, resp));

9181 }), true);

9182 res.deleteAccessConfig(arg_project, arg_zone, arg_instance, arg_accessConf ig, arg_networkInterface).then(unittest.expectAsync(((api.Operation response) {

9183 checkOperation(response);

9184 })));

9185 });

9186

9187 unittest.test("method--detachDisk", () {

9188

9189 var mock = new common_test.HttpServerMock();

9190 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9191 var arg_project = "foo";

9192 var arg_zone = "foo";

9193 var arg_instance = "foo";

9194 var arg_deviceName = "foo";

9195 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9196 var path = (req.url).path;

9197 var pathOffset = 0;

9198 var index;

9199 var subPart;

9200 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9201 pathOffset += 21;

9202 index = path.indexOf("/zones/", pathOffset);

9203 unittest.expect(index >= 0, unittest.isTrue);

9204 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9205 pathOffset = index;

9206 unittest.expect(subPart, unittest.equals("$arg_project"));

9207 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9208 pathOffset += 7;

9209 index = path.indexOf("/instances/", pathOffset);

9210 unittest.expect(index >= 0, unittest.isTrue);

9211 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9212 pathOffset = index;

9213 unittest.expect(subPart, unittest.equals("$arg_zone"));

9214 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9215 pathOffset += 11;

9216 index = path.indexOf("/detachDisk", pathOffset);

9217 unittest.expect(index >= 0, unittest.isTrue);

9218 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9219 pathOffset = index;

9220 unittest.expect(subPart, unittest.equals("$arg_instance"));

9221 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/detachDisk"));

9222 pathOffset += 11;

9223

9224 var query = (req.url).query;

9225 var queryOffset = 0;

9226 var queryMap = {};

9227 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9228 parseBool(n) {

9229 if (n == "true") return true;

9230 if (n == "false") return false;

9231 if (n == null) return null;

9232 throw new core.ArgumentError("Invalid boolean: $n");

9233 }

9234 if (query.length > 0) {

9235 for (var part in query.split("&")) {

9236 var keyvalue = part.split("=");

9237 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9238 }

9239 }

9240 unittest.expect(queryMap["deviceName"].first, unittest.equals(arg_device Name));

9241

9242

9243 var h = {

9244 "content-type" : "application/json; charset=utf-8",

9245 };

9246 var resp = convert.JSON.encode(buildOperation());

9247 return new async.Future.value(common_test.stringResponse(200, h, resp));

9248 }), true);

9249 res.detachDisk(arg_project, arg_zone, arg_instance, arg_deviceName).then(u nittest.expectAsync(((api.Operation response) {

9250 checkOperation(response);

9251 })));

9252 });

9253

9254 unittest.test("method--get", () {

9255

9256 var mock = new common_test.HttpServerMock();

9257 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9258 var arg_project = "foo";

9259 var arg_zone = "foo";

9260 var arg_instance = "foo";

9261 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9262 var path = (req.url).path;

9263 var pathOffset = 0;

9264 var index;

9265 var subPart;

9266 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9267 pathOffset += 21;

9268 index = path.indexOf("/zones/", pathOffset);

9269 unittest.expect(index >= 0, unittest.isTrue);

9270 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9271 pathOffset = index;

9272 unittest.expect(subPart, unittest.equals("$arg_project"));

9273 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9274 pathOffset += 7;

9275 index = path.indexOf("/instances/", pathOffset);

9276 unittest.expect(index >= 0, unittest.isTrue);

9277 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9278 pathOffset = index;

9279 unittest.expect(subPart, unittest.equals("$arg_zone"));

9280 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9281 pathOffset += 11;

9282 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

9283 pathOffset = path.length;

9284 unittest.expect(subPart, unittest.equals("$arg_instance"));

9285

9286 var query = (req.url).query;

9287 var queryOffset = 0;

9288 var queryMap = {};

9289 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9290 parseBool(n) {

9291 if (n == "true") return true;

9292 if (n == "false") return false;

9293 if (n == null) return null;

9294 throw new core.ArgumentError("Invalid boolean: $n");

9295 }

9296 if (query.length > 0) {

9297 for (var part in query.split("&")) {

9298 var keyvalue = part.split("=");

9299 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9300 }

9301 }

9302

9303

9304 var h = {

9305 "content-type" : "application/json; charset=utf-8",

9306 };

9307 var resp = convert.JSON.encode(buildInstance());

9308 return new async.Future.value(common_test.stringResponse(200, h, resp));

9309 }), true);

9310 res.get(arg_project, arg_zone, arg_instance).then(unittest.expectAsync(((a pi.Instance response) {

9311 checkInstance(response);

9312 })));

9313 });

9314

9315 unittest.test("method--getSerialPortOutput", () {

9316

9317 var mock = new common_test.HttpServerMock();

9318 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9319 var arg_project = "foo";

9320 var arg_zone = "foo";

9321 var arg_instance = "foo";

9322 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9323 var path = (req.url).path;

9324 var pathOffset = 0;

9325 var index;

9326 var subPart;

9327 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9328 pathOffset += 21;

9329 index = path.indexOf("/zones/", pathOffset);

9330 unittest.expect(index >= 0, unittest.isTrue);

9331 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9332 pathOffset = index;

9333 unittest.expect(subPart, unittest.equals("$arg_project"));

9334 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9335 pathOffset += 7;

9336 index = path.indexOf("/instances/", pathOffset);

9337 unittest.expect(index >= 0, unittest.isTrue);

9338 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9339 pathOffset = index;

9340 unittest.expect(subPart, unittest.equals("$arg_zone"));

9341 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9342 pathOffset += 11;

9343 index = path.indexOf("/serialPort", pathOffset);

9344 unittest.expect(index >= 0, unittest.isTrue);

9345 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9346 pathOffset = index;

9347 unittest.expect(subPart, unittest.equals("$arg_instance"));

9348 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/serialPort"));

9349 pathOffset += 11;

9350

9351 var query = (req.url).query;

9352 var queryOffset = 0;

9353 var queryMap = {};

9354 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9355 parseBool(n) {

9356 if (n == "true") return true;

9357 if (n == "false") return false;

9358 if (n == null) return null;

9359 throw new core.ArgumentError("Invalid boolean: $n");

9360 }

9361 if (query.length > 0) {

9362 for (var part in query.split("&")) {

9363 var keyvalue = part.split("=");

9364 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9365 }

9366 }

9367

9368

9369 var h = {

9370 "content-type" : "application/json; charset=utf-8",

9371 };

9372 var resp = convert.JSON.encode(buildSerialPortOutput());

9373 return new async.Future.value(common_test.stringResponse(200, h, resp));

9374 }), true);

9375 res.getSerialPortOutput(arg_project, arg_zone, arg_instance).then(unittest .expectAsync(((api.SerialPortOutput response) {

9376 checkSerialPortOutput(response);

9377 })));

9378 });

9379

9380 unittest.test("method--insert", () {

9381

9382 var mock = new common_test.HttpServerMock();

9383 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9384 var arg_request = buildInstance();

9385 var arg_project = "foo";

9386 var arg_zone = "foo";

9387 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9388 var obj = new api.Instance.fromJson(json);

9389 checkInstance(obj);

9390

9391 var path = (req.url).path;

9392 var pathOffset = 0;

9393 var index;

9394 var subPart;

9395 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9396 pathOffset += 21;

9397 index = path.indexOf("/zones/", pathOffset);

9398 unittest.expect(index >= 0, unittest.isTrue);

9399 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9400 pathOffset = index;

9401 unittest.expect(subPart, unittest.equals("$arg_project"));

9402 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9403 pathOffset += 7;

9404 index = path.indexOf("/instances", pathOffset);

9405 unittest.expect(index >= 0, unittest.isTrue);

9406 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9407 pathOffset = index;

9408 unittest.expect(subPart, unittest.equals("$arg_zone"));

9409 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/instances"));

9410 pathOffset += 10;

9411

9412 var query = (req.url).query;

9413 var queryOffset = 0;

9414 var queryMap = {};

9415 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9416 parseBool(n) {

9417 if (n == "true") return true;

9418 if (n == "false") return false;

9419 if (n == null) return null;

9420 throw new core.ArgumentError("Invalid boolean: $n");

9421 }

9422 if (query.length > 0) {

9423 for (var part in query.split("&")) {

9424 var keyvalue = part.split("=");

9425 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9426 }

9427 }

9428

9429

9430 var h = {

9431 "content-type" : "application/json; charset=utf-8",

9432 };

9433 var resp = convert.JSON.encode(buildOperation());

9434 return new async.Future.value(common_test.stringResponse(200, h, resp));

9435 }), true);

9436 res.insert(arg_request, arg_project, arg_zone).then(unittest.expectAsync(( (api.Operation response) {

9437 checkOperation(response);

9438 })));

9439 });

9440

9441 unittest.test("method--list", () {

9442

9443 var mock = new common_test.HttpServerMock();

9444 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9445 var arg_project = "foo";

9446 var arg_zone = "foo";

9447 var arg_filter = "foo";

9448 var arg_maxResults = 42;

9449 var arg_pageToken = "foo";

9450 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9451 var path = (req.url).path;

9452 var pathOffset = 0;

9453 var index;

9454 var subPart;

9455 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9456 pathOffset += 21;

9457 index = path.indexOf("/zones/", pathOffset);

9458 unittest.expect(index >= 0, unittest.isTrue);

9459 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9460 pathOffset = index;

9461 unittest.expect(subPart, unittest.equals("$arg_project"));

9462 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9463 pathOffset += 7;

9464 index = path.indexOf("/instances", pathOffset);

9465 unittest.expect(index >= 0, unittest.isTrue);

9466 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9467 pathOffset = index;

9468 unittest.expect(subPart, unittest.equals("$arg_zone"));

9469 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/instances"));

9470 pathOffset += 10;

9471

9472 var query = (req.url).query;

9473 var queryOffset = 0;

9474 var queryMap = {};

9475 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9476 parseBool(n) {

9477 if (n == "true") return true;

9478 if (n == "false") return false;

9479 if (n == null) return null;

9480 throw new core.ArgumentError("Invalid boolean: $n");

9481 }

9482 if (query.length > 0) {

9483 for (var part in query.split("&")) {

9484 var keyvalue = part.split("=");

9485 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9486 }

9487 }

9488 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

9489 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

9490 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

9491

9492

9493 var h = {

9494 "content-type" : "application/json; charset=utf-8",

9495 };

9496 var resp = convert.JSON.encode(buildInstanceList());

9497 return new async.Future.value(common_test.stringResponse(200, h, resp));

9498 }), true);

9499 res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.InstanceList res ponse) {

9500 checkInstanceList(response);

9501 })));

9502 });

9503

9504 unittest.test("method--reset", () {

9505

9506 var mock = new common_test.HttpServerMock();

9507 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9508 var arg_project = "foo";

9509 var arg_zone = "foo";

9510 var arg_instance = "foo";

9511 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9512 var path = (req.url).path;

9513 var pathOffset = 0;

9514 var index;

9515 var subPart;

9516 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9517 pathOffset += 21;

9518 index = path.indexOf("/zones/", pathOffset);

9519 unittest.expect(index >= 0, unittest.isTrue);

9520 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9521 pathOffset = index;

9522 unittest.expect(subPart, unittest.equals("$arg_project"));

9523 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9524 pathOffset += 7;

9525 index = path.indexOf("/instances/", pathOffset);

9526 unittest.expect(index >= 0, unittest.isTrue);

9527 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9528 pathOffset = index;

9529 unittest.expect(subPart, unittest.equals("$arg_zone"));

9530 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9531 pathOffset += 11;

9532 index = path.indexOf("/reset", pathOffset);

9533 unittest.expect(index >= 0, unittest.isTrue);

9534 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9535 pathOffset = index;

9536 unittest.expect(subPart, unittest.equals("$arg_instance"));

9537 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/reset"));

9538 pathOffset += 6;

9539

9540 var query = (req.url).query;

9541 var queryOffset = 0;

9542 var queryMap = {};

9543 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9544 parseBool(n) {

9545 if (n == "true") return true;

9546 if (n == "false") return false;

9547 if (n == null) return null;

9548 throw new core.ArgumentError("Invalid boolean: $n");

9549 }

9550 if (query.length > 0) {

9551 for (var part in query.split("&")) {

9552 var keyvalue = part.split("=");

9553 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9554 }

9555 }

9556

9557

9558 var h = {

9559 "content-type" : "application/json; charset=utf-8",

9560 };

9561 var resp = convert.JSON.encode(buildOperation());

9562 return new async.Future.value(common_test.stringResponse(200, h, resp));

9563 }), true);

9564 res.reset(arg_project, arg_zone, arg_instance).then(unittest.expectAsync(( (api.Operation response) {

9565 checkOperation(response);

9566 })));

9567 });

9568

9569 unittest.test("method--setDiskAutoDelete", () {

9570

9571 var mock = new common_test.HttpServerMock();

9572 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9573 var arg_project = "foo";

9574 var arg_zone = "foo";

9575 var arg_instance = "foo";

9576 var arg_autoDelete = true;

9577 var arg_deviceName = "foo";

9578 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9579 var path = (req.url).path;

9580 var pathOffset = 0;

9581 var index;

9582 var subPart;

9583 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9584 pathOffset += 21;

9585 index = path.indexOf("/zones/", pathOffset);

9586 unittest.expect(index >= 0, unittest.isTrue);

9587 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9588 pathOffset = index;

9589 unittest.expect(subPart, unittest.equals("$arg_project"));

9590 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9591 pathOffset += 7;

9592 index = path.indexOf("/instances/", pathOffset);

9593 unittest.expect(index >= 0, unittest.isTrue);

9594 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9595 pathOffset = index;

9596 unittest.expect(subPart, unittest.equals("$arg_zone"));

9597 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9598 pathOffset += 11;

9599 index = path.indexOf("/setDiskAutoDelete", pathOffset);

9600 unittest.expect(index >= 0, unittest.isTrue);

9601 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9602 pathOffset = index;

9603 unittest.expect(subPart, unittest.equals("$arg_instance"));

9604 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/setDiskAutoDelete"));

9605 pathOffset += 18;

9606

9607 var query = (req.url).query;

9608 var queryOffset = 0;

9609 var queryMap = {};

9610 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9611 parseBool(n) {

9612 if (n == "true") return true;

9613 if (n == "false") return false;

9614 if (n == null) return null;

9615 throw new core.ArgumentError("Invalid boolean: $n");

9616 }

9617 if (query.length > 0) {

9618 for (var part in query.split("&")) {

9619 var keyvalue = part.split("=");

9620 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9621 }

9622 }

9623 unittest.expect(queryMap["autoDelete"].first, unittest.equals("$arg_auto Delete"));

9624 unittest.expect(queryMap["deviceName"].first, unittest.equals(arg_device Name));

9625

9626

9627 var h = {

9628 "content-type" : "application/json; charset=utf-8",

9629 };

9630 var resp = convert.JSON.encode(buildOperation());

9631 return new async.Future.value(common_test.stringResponse(200, h, resp));

9632 }), true);

9633 res.setDiskAutoDelete(arg_project, arg_zone, arg_instance, arg_autoDelete, arg_deviceName).then(unittest.expectAsync(((api.Operation response) {

9634 checkOperation(response);

9635 })));

9636 });

9637

9638 unittest.test("method--setMetadata", () {

9639

9640 var mock = new common_test.HttpServerMock();

9641 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9642 var arg_request = buildMetadata();

9643 var arg_project = "foo";

9644 var arg_zone = "foo";

9645 var arg_instance = "foo";

9646 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9647 var obj = new api.Metadata.fromJson(json);

9648 checkMetadata(obj);

9649

9650 var path = (req.url).path;

9651 var pathOffset = 0;

9652 var index;

9653 var subPart;

9654 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9655 pathOffset += 21;

9656 index = path.indexOf("/zones/", pathOffset);

9657 unittest.expect(index >= 0, unittest.isTrue);

9658 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9659 pathOffset = index;

9660 unittest.expect(subPart, unittest.equals("$arg_project"));

9661 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9662 pathOffset += 7;

9663 index = path.indexOf("/instances/", pathOffset);

9664 unittest.expect(index >= 0, unittest.isTrue);

9665 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9666 pathOffset = index;

9667 unittest.expect(subPart, unittest.equals("$arg_zone"));

9668 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9669 pathOffset += 11;

9670 index = path.indexOf("/setMetadata", pathOffset);

9671 unittest.expect(index >= 0, unittest.isTrue);

9672 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9673 pathOffset = index;

9674 unittest.expect(subPart, unittest.equals("$arg_instance"));

9675 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/setMetadata"));

9676 pathOffset += 12;

9677

9678 var query = (req.url).query;

9679 var queryOffset = 0;

9680 var queryMap = {};

9681 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9682 parseBool(n) {

9683 if (n == "true") return true;

9684 if (n == "false") return false;

9685 if (n == null) return null;

9686 throw new core.ArgumentError("Invalid boolean: $n");

9687 }

9688 if (query.length > 0) {

9689 for (var part in query.split("&")) {

9690 var keyvalue = part.split("=");

9691 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9692 }

9693 }

9694

9695

9696 var h = {

9697 "content-type" : "application/json; charset=utf-8",

9698 };

9699 var resp = convert.JSON.encode(buildOperation());

9700 return new async.Future.value(common_test.stringResponse(200, h, resp));

9701 }), true);

9702 res.setMetadata(arg_request, arg_project, arg_zone, arg_instance).then(uni ttest.expectAsync(((api.Operation response) {

9703 checkOperation(response);

9704 })));

9705 });

9706

9707 unittest.test("method--setScheduling", () {

9708

9709 var mock = new common_test.HttpServerMock();

9710 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9711 var arg_request = buildScheduling();

9712 var arg_project = "foo";

9713 var arg_zone = "foo";

9714 var arg_instance = "foo";

9715 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9716 var obj = new api.Scheduling.fromJson(json);

9717 checkScheduling(obj);

9718

9719 var path = (req.url).path;

9720 var pathOffset = 0;

9721 var index;

9722 var subPart;

9723 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9724 pathOffset += 21;

9725 index = path.indexOf("/zones/", pathOffset);

9726 unittest.expect(index >= 0, unittest.isTrue);

9727 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9728 pathOffset = index;

9729 unittest.expect(subPart, unittest.equals("$arg_project"));

9730 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9731 pathOffset += 7;

9732 index = path.indexOf("/instances/", pathOffset);

9733 unittest.expect(index >= 0, unittest.isTrue);

9734 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9735 pathOffset = index;

9736 unittest.expect(subPart, unittest.equals("$arg_zone"));

9737 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9738 pathOffset += 11;

9739 index = path.indexOf("/setScheduling", pathOffset);

9740 unittest.expect(index >= 0, unittest.isTrue);

9741 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9742 pathOffset = index;

9743 unittest.expect(subPart, unittest.equals("$arg_instance"));

9744 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/setScheduling"));

9745 pathOffset += 14;

9746

9747 var query = (req.url).query;

9748 var queryOffset = 0;

9749 var queryMap = {};

9750 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9751 parseBool(n) {

9752 if (n == "true") return true;

9753 if (n == "false") return false;

9754 if (n == null) return null;

9755 throw new core.ArgumentError("Invalid boolean: $n");

9756 }

9757 if (query.length > 0) {

9758 for (var part in query.split("&")) {

9759 var keyvalue = part.split("=");

9760 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9761 }

9762 }

9763

9764

9765 var h = {

9766 "content-type" : "application/json; charset=utf-8",

9767 };

9768 var resp = convert.JSON.encode(buildOperation());

9769 return new async.Future.value(common_test.stringResponse(200, h, resp));

9770 }), true);

9771 res.setScheduling(arg_request, arg_project, arg_zone, arg_instance).then(u nittest.expectAsync(((api.Operation response) {

9772 checkOperation(response);

9773 })));

9774 });

9775

9776 unittest.test("method--setTags", () {

9777

9778 var mock = new common_test.HttpServerMock();

9779 api.InstancesResourceApi res = new api.ComputeApi(mock).instances;

9780 var arg_request = buildTags();

9781 var arg_project = "foo";

9782 var arg_zone = "foo";

9783 var arg_instance = "foo";

9784 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9785 var obj = new api.Tags.fromJson(json);

9786 checkTags(obj);

9787

9788 var path = (req.url).path;

9789 var pathOffset = 0;

9790 var index;

9791 var subPart;

9792 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9793 pathOffset += 21;

9794 index = path.indexOf("/zones/", pathOffset);

9795 unittest.expect(index >= 0, unittest.isTrue);

9796 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9797 pathOffset = index;

9798 unittest.expect(subPart, unittest.equals("$arg_project"));

9799 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9800 pathOffset += 7;

9801 index = path.indexOf("/instances/", pathOffset);

9802 unittest.expect(index >= 0, unittest.isTrue);

9803 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9804 pathOffset = index;

9805 unittest.expect(subPart, unittest.equals("$arg_zone"));

9806 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/instances/"));

9807 pathOffset += 11;

9808 index = path.indexOf("/setTags", pathOffset);

9809 unittest.expect(index >= 0, unittest.isTrue);

9810 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9811 pathOffset = index;

9812 unittest.expect(subPart, unittest.equals("$arg_instance"));

9813 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/setTags"));

9814 pathOffset += 8;

9815

9816 var query = (req.url).query;

9817 var queryOffset = 0;

9818 var queryMap = {};

9819 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9820 parseBool(n) {

9821 if (n == "true") return true;

9822 if (n == "false") return false;

9823 if (n == null) return null;

9824 throw new core.ArgumentError("Invalid boolean: $n");

9825 }

9826 if (query.length > 0) {

9827 for (var part in query.split("&")) {

9828 var keyvalue = part.split("=");

9829 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9830 }

9831 }

9832

9833

9834 var h = {

9835 "content-type" : "application/json; charset=utf-8",

9836 };

9837 var resp = convert.JSON.encode(buildOperation());

9838 return new async.Future.value(common_test.stringResponse(200, h, resp));

9839 }), true);

9840 res.setTags(arg_request, arg_project, arg_zone, arg_instance).then(unittes t.expectAsync(((api.Operation response) {

9841 checkOperation(response);

9842 })));

9843 });

9844

9845 });

9846

9847

9848 unittest.group("resource-LicensesResourceApi", () {

9849 unittest.test("method--get", () {

9850

9851 var mock = new common_test.HttpServerMock();

9852 api.LicensesResourceApi res = new api.ComputeApi(mock).licenses;

9853 var arg_project = "foo";

9854 var arg_license = "foo";

9855 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9856 var path = (req.url).path;

9857 var pathOffset = 0;

9858 var index;

9859 var subPart;

9860 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9861 pathOffset += 21;

9862 index = path.indexOf("/global/licenses/", pathOffset);

9863 unittest.expect(index >= 0, unittest.isTrue);

9864 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9865 pathOffset = index;

9866 unittest.expect(subPart, unittest.equals("$arg_project"));

9867 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/global/licenses/"));

9868 pathOffset += 17;

9869 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

9870 pathOffset = path.length;

9871 unittest.expect(subPart, unittest.equals("$arg_license"));

9872

9873 var query = (req.url).query;

9874 var queryOffset = 0;

9875 var queryMap = {};

9876 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9877 parseBool(n) {

9878 if (n == "true") return true;

9879 if (n == "false") return false;

9880 if (n == null) return null;

9881 throw new core.ArgumentError("Invalid boolean: $n");

9882 }

9883 if (query.length > 0) {

9884 for (var part in query.split("&")) {

9885 var keyvalue = part.split("=");

9886 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9887 }

9888 }

9889

9890

9891 var h = {

9892 "content-type" : "application/json; charset=utf-8",

9893 };

9894 var resp = convert.JSON.encode(buildLicense());

9895 return new async.Future.value(common_test.stringResponse(200, h, resp));

9896 }), true);

9897 res.get(arg_project, arg_license).then(unittest.expectAsync(((api.License response) {

9898 checkLicense(response);

9899 })));

9900 });

9901

9902 });

9903

9904

9905 unittest.group("resource-MachineTypesResourceApi", () {

9906 unittest.test("method--aggregatedList", () {

9907

9908 var mock = new common_test.HttpServerMock();

9909 api.MachineTypesResourceApi res = new api.ComputeApi(mock).machineTypes;

9910 var arg_project = "foo";

9911 var arg_filter = "foo";

9912 var arg_maxResults = 42;

9913 var arg_pageToken = "foo";

9914 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9915 var path = (req.url).path;

9916 var pathOffset = 0;

9917 var index;

9918 var subPart;

9919 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9920 pathOffset += 21;

9921 index = path.indexOf("/aggregated/machineTypes", pathOffset);

9922 unittest.expect(index >= 0, unittest.isTrue);

9923 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9924 pathOffset = index;

9925 unittest.expect(subPart, unittest.equals("$arg_project"));

9926 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("/aggregated/machineTypes"));

9927 pathOffset += 24;

9928

9929 var query = (req.url).query;

9930 var queryOffset = 0;

9931 var queryMap = {};

9932 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9933 parseBool(n) {

9934 if (n == "true") return true;

9935 if (n == "false") return false;

9936 if (n == null) return null;

9937 throw new core.ArgumentError("Invalid boolean: $n");

9938 }

9939 if (query.length > 0) {

9940 for (var part in query.split("&")) {

9941 var keyvalue = part.split("=");

9942 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

9943 }

9944 }

9945 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

9946 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

9947 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

9948

9949

9950 var h = {

9951 "content-type" : "application/json; charset=utf-8",

9952 };

9953 var resp = convert.JSON.encode(buildMachineTypeAggregatedList());

9954 return new async.Future.value(common_test.stringResponse(200, h, resp));

9955 }), true);

9956 res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.MachineTypeAggre gatedList response) {

9957 checkMachineTypeAggregatedList(response);

9958 })));

9959 });

9960

9961 unittest.test("method--get", () {

9962

9963 var mock = new common_test.HttpServerMock();

9964 api.MachineTypesResourceApi res = new api.ComputeApi(mock).machineTypes;

9965 var arg_project = "foo";

9966 var arg_zone = "foo";

9967 var arg_machineType = "foo";

9968 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

9969 var path = (req.url).path;

9970 var pathOffset = 0;

9971 var index;

9972 var subPart;

9973 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

9974 pathOffset += 21;

9975 index = path.indexOf("/zones/", pathOffset);

9976 unittest.expect(index >= 0, unittest.isTrue);

9977 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9978 pathOffset = index;

9979 unittest.expect(subPart, unittest.equals("$arg_project"));

9980 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

9981 pathOffset += 7;

9982 index = path.indexOf("/machineTypes/", pathOffset);

9983 unittest.expect(index >= 0, unittest.isTrue);

9984 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

9985 pathOffset = index;

9986 unittest.expect(subPart, unittest.equals("$arg_zone"));

9987 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/machineTypes/"));

9988 pathOffset += 14;

9989 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

9990 pathOffset = path.length;

9991 unittest.expect(subPart, unittest.equals("$arg_machineType"));

9992

9993 var query = (req.url).query;

9994 var queryOffset = 0;

9995 var queryMap = {};

9996 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

9997 parseBool(n) {

9998 if (n == "true") return true;

9999 if (n == "false") return false;

10000 if (n == null) return null;

10001 throw new core.ArgumentError("Invalid boolean: $n");

10002 }

10003 if (query.length > 0) {

10004 for (var part in query.split("&")) {

10005 var keyvalue = part.split("=");

10006 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10007 }

10008 }

10009

10010

10011 var h = {

10012 "content-type" : "application/json; charset=utf-8",

10013 };

10014 var resp = convert.JSON.encode(buildMachineType());

10015 return new async.Future.value(common_test.stringResponse(200, h, resp));

10016 }), true);

10017 res.get(arg_project, arg_zone, arg_machineType).then(unittest.expectAsync( ((api.MachineType response) {

10018 checkMachineType(response);

10019 })));

10020 });

10021

10022 unittest.test("method--list", () {

10023

10024 var mock = new common_test.HttpServerMock();

10025 api.MachineTypesResourceApi res = new api.ComputeApi(mock).machineTypes;

10026 var arg_project = "foo";

10027 var arg_zone = "foo";

10028 var arg_filter = "foo";

10029 var arg_maxResults = 42;

10030 var arg_pageToken = "foo";

10031 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10032 var path = (req.url).path;

10033 var pathOffset = 0;

10034 var index;

10035 var subPart;

10036 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10037 pathOffset += 21;

10038 index = path.indexOf("/zones/", pathOffset);

10039 unittest.expect(index >= 0, unittest.isTrue);

10040 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10041 pathOffset = index;

10042 unittest.expect(subPart, unittest.equals("$arg_project"));

10043 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

10044 pathOffset += 7;

10045 index = path.indexOf("/machineTypes", pathOffset);

10046 unittest.expect(index >= 0, unittest.isTrue);

10047 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10048 pathOffset = index;

10049 unittest.expect(subPart, unittest.equals("$arg_zone"));

10050 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/machineTypes"));

10051 pathOffset += 13;

10052

10053 var query = (req.url).query;

10054 var queryOffset = 0;

10055 var queryMap = {};

10056 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10057 parseBool(n) {

10058 if (n == "true") return true;

10059 if (n == "false") return false;

10060 if (n == null) return null;

10061 throw new core.ArgumentError("Invalid boolean: $n");

10062 }

10063 if (query.length > 0) {

10064 for (var part in query.split("&")) {

10065 var keyvalue = part.split("=");

10066 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10067 }

10068 }

10069 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

10070 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

10071 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

10072

10073

10074 var h = {

10075 "content-type" : "application/json; charset=utf-8",

10076 };

10077 var resp = convert.JSON.encode(buildMachineTypeList());

10078 return new async.Future.value(common_test.stringResponse(200, h, resp));

10079 }), true);

10080 res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.MachineTypeList response) {

10081 checkMachineTypeList(response);

10082 })));

10083 });

10084

10085 });

10086

10087

10088 unittest.group("resource-NetworksResourceApi", () {

10089 unittest.test("method--delete", () {

10090

10091 var mock = new common_test.HttpServerMock();

10092 api.NetworksResourceApi res = new api.ComputeApi(mock).networks;

10093 var arg_project = "foo";

10094 var arg_network = "foo";

10095 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10096 var path = (req.url).path;

10097 var pathOffset = 0;

10098 var index;

10099 var subPart;

10100 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10101 pathOffset += 21;

10102 index = path.indexOf("/global/networks/", pathOffset);

10103 unittest.expect(index >= 0, unittest.isTrue);

10104 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10105 pathOffset = index;

10106 unittest.expect(subPart, unittest.equals("$arg_project"));

10107 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/global/networks/"));

10108 pathOffset += 17;

10109 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

10110 pathOffset = path.length;

10111 unittest.expect(subPart, unittest.equals("$arg_network"));

10112

10113 var query = (req.url).query;

10114 var queryOffset = 0;

10115 var queryMap = {};

10116 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10117 parseBool(n) {

10118 if (n == "true") return true;

10119 if (n == "false") return false;

10120 if (n == null) return null;

10121 throw new core.ArgumentError("Invalid boolean: $n");

10122 }

10123 if (query.length > 0) {

10124 for (var part in query.split("&")) {

10125 var keyvalue = part.split("=");

10126 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10127 }

10128 }

10129

10130

10131 var h = {

10132 "content-type" : "application/json; charset=utf-8",

10133 };

10134 var resp = convert.JSON.encode(buildOperation());

10135 return new async.Future.value(common_test.stringResponse(200, h, resp));

10136 }), true);

10137 res.delete(arg_project, arg_network).then(unittest.expectAsync(((api.Opera tion response) {

10138 checkOperation(response);

10139 })));

10140 });

10141

10142 unittest.test("method--get", () {

10143

10144 var mock = new common_test.HttpServerMock();

10145 api.NetworksResourceApi res = new api.ComputeApi(mock).networks;

10146 var arg_project = "foo";

10147 var arg_network = "foo";

10148 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10149 var path = (req.url).path;

10150 var pathOffset = 0;

10151 var index;

10152 var subPart;

10153 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10154 pathOffset += 21;

10155 index = path.indexOf("/global/networks/", pathOffset);

10156 unittest.expect(index >= 0, unittest.isTrue);

10157 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10158 pathOffset = index;

10159 unittest.expect(subPart, unittest.equals("$arg_project"));

10160 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/global/networks/"));

10161 pathOffset += 17;

10162 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

10163 pathOffset = path.length;

10164 unittest.expect(subPart, unittest.equals("$arg_network"));

10165

10166 var query = (req.url).query;

10167 var queryOffset = 0;

10168 var queryMap = {};

10169 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10170 parseBool(n) {

10171 if (n == "true") return true;

10172 if (n == "false") return false;

10173 if (n == null) return null;

10174 throw new core.ArgumentError("Invalid boolean: $n");

10175 }

10176 if (query.length > 0) {

10177 for (var part in query.split("&")) {

10178 var keyvalue = part.split("=");

10179 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10180 }

10181 }

10182

10183

10184 var h = {

10185 "content-type" : "application/json; charset=utf-8",

10186 };

10187 var resp = convert.JSON.encode(buildNetwork());

10188 return new async.Future.value(common_test.stringResponse(200, h, resp));

10189 }), true);

10190 res.get(arg_project, arg_network).then(unittest.expectAsync(((api.Network response) {

10191 checkNetwork(response);

10192 })));

10193 });

10194

10195 unittest.test("method--insert", () {

10196

10197 var mock = new common_test.HttpServerMock();

10198 api.NetworksResourceApi res = new api.ComputeApi(mock).networks;

10199 var arg_request = buildNetwork();

10200 var arg_project = "foo";

10201 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10202 var obj = new api.Network.fromJson(json);

10203 checkNetwork(obj);

10204

10205 var path = (req.url).path;

10206 var pathOffset = 0;

10207 var index;

10208 var subPart;

10209 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10210 pathOffset += 21;

10211 index = path.indexOf("/global/networks", pathOffset);

10212 unittest.expect(index >= 0, unittest.isTrue);

10213 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10214 pathOffset = index;

10215 unittest.expect(subPart, unittest.equals("$arg_project"));

10216 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/global/networks"));

10217 pathOffset += 16;

10218

10219 var query = (req.url).query;

10220 var queryOffset = 0;

10221 var queryMap = {};

10222 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10223 parseBool(n) {

10224 if (n == "true") return true;

10225 if (n == "false") return false;

10226 if (n == null) return null;

10227 throw new core.ArgumentError("Invalid boolean: $n");

10228 }

10229 if (query.length > 0) {

10230 for (var part in query.split("&")) {

10231 var keyvalue = part.split("=");

10232 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10233 }

10234 }

10235

10236

10237 var h = {

10238 "content-type" : "application/json; charset=utf-8",

10239 };

10240 var resp = convert.JSON.encode(buildOperation());

10241 return new async.Future.value(common_test.stringResponse(200, h, resp));

10242 }), true);

10243 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

10244 checkOperation(response);

10245 })));

10246 });

10247

10248 unittest.test("method--list", () {

10249

10250 var mock = new common_test.HttpServerMock();

10251 api.NetworksResourceApi res = new api.ComputeApi(mock).networks;

10252 var arg_project = "foo";

10253 var arg_filter = "foo";

10254 var arg_maxResults = 42;

10255 var arg_pageToken = "foo";

10256 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10257 var path = (req.url).path;

10258 var pathOffset = 0;

10259 var index;

10260 var subPart;

10261 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10262 pathOffset += 21;

10263 index = path.indexOf("/global/networks", pathOffset);

10264 unittest.expect(index >= 0, unittest.isTrue);

10265 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10266 pathOffset = index;

10267 unittest.expect(subPart, unittest.equals("$arg_project"));

10268 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/global/networks"));

10269 pathOffset += 16;

10270

10271 var query = (req.url).query;

10272 var queryOffset = 0;

10273 var queryMap = {};

10274 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10275 parseBool(n) {

10276 if (n == "true") return true;

10277 if (n == "false") return false;

10278 if (n == null) return null;

10279 throw new core.ArgumentError("Invalid boolean: $n");

10280 }

10281 if (query.length > 0) {

10282 for (var part in query.split("&")) {

10283 var keyvalue = part.split("=");

10284 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10285 }

10286 }

10287 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

10288 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

10289 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

10290

10291

10292 var h = {

10293 "content-type" : "application/json; charset=utf-8",

10294 };

10295 var resp = convert.JSON.encode(buildNetworkList());

10296 return new async.Future.value(common_test.stringResponse(200, h, resp));

10297 }), true);

10298 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.NetworkList response) {

10299 checkNetworkList(response);

10300 })));

10301 });

10302

10303 });

10304

10305

10306 unittest.group("resource-ProjectsResourceApi", () {

10307 unittest.test("method--get", () {

10308

10309 var mock = new common_test.HttpServerMock();

10310 api.ProjectsResourceApi res = new api.ComputeApi(mock).projects;

10311 var arg_project = "foo";

10312 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10313 var path = (req.url).path;

10314 var pathOffset = 0;

10315 var index;

10316 var subPart;

10317 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10318 pathOffset += 21;

10319 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

10320 pathOffset = path.length;

10321 unittest.expect(subPart, unittest.equals("$arg_project"));

10322

10323 var query = (req.url).query;

10324 var queryOffset = 0;

10325 var queryMap = {};

10326 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10327 parseBool(n) {

10328 if (n == "true") return true;

10329 if (n == "false") return false;

10330 if (n == null) return null;

10331 throw new core.ArgumentError("Invalid boolean: $n");

10332 }

10333 if (query.length > 0) {

10334 for (var part in query.split("&")) {

10335 var keyvalue = part.split("=");

10336 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10337 }

10338 }

10339

10340

10341 var h = {

10342 "content-type" : "application/json; charset=utf-8",

10343 };

10344 var resp = convert.JSON.encode(buildProject());

10345 return new async.Future.value(common_test.stringResponse(200, h, resp));

10346 }), true);

10347 res.get(arg_project).then(unittest.expectAsync(((api.Project response) {

10348 checkProject(response);

10349 })));

10350 });

10351

10352 unittest.test("method--setCommonInstanceMetadata", () {

10353

10354 var mock = new common_test.HttpServerMock();

10355 api.ProjectsResourceApi res = new api.ComputeApi(mock).projects;

10356 var arg_request = buildMetadata();

10357 var arg_project = "foo";

10358 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10359 var obj = new api.Metadata.fromJson(json);

10360 checkMetadata(obj);

10361

10362 var path = (req.url).path;

10363 var pathOffset = 0;

10364 var index;

10365 var subPart;

10366 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10367 pathOffset += 21;

10368 index = path.indexOf("/setCommonInstanceMetadata", pathOffset);

10369 unittest.expect(index >= 0, unittest.isTrue);

10370 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10371 pathOffset = index;

10372 unittest.expect(subPart, unittest.equals("$arg_project"));

10373 unittest.expect(path.substring(pathOffset, pathOffset + 26), unittest.eq uals("/setCommonInstanceMetadata"));

10374 pathOffset += 26;

10375

10376 var query = (req.url).query;

10377 var queryOffset = 0;

10378 var queryMap = {};

10379 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10380 parseBool(n) {

10381 if (n == "true") return true;

10382 if (n == "false") return false;

10383 if (n == null) return null;

10384 throw new core.ArgumentError("Invalid boolean: $n");

10385 }

10386 if (query.length > 0) {

10387 for (var part in query.split("&")) {

10388 var keyvalue = part.split("=");

10389 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10390 }

10391 }

10392

10393

10394 var h = {

10395 "content-type" : "application/json; charset=utf-8",

10396 };

10397 var resp = convert.JSON.encode(buildOperation());

10398 return new async.Future.value(common_test.stringResponse(200, h, resp));

10399 }), true);

10400 res.setCommonInstanceMetadata(arg_request, arg_project).then(unittest.expe ctAsync(((api.Operation response) {

10401 checkOperation(response);

10402 })));

10403 });

10404

10405 unittest.test("method--setUsageExportBucket", () {

10406

10407 var mock = new common_test.HttpServerMock();

10408 api.ProjectsResourceApi res = new api.ComputeApi(mock).projects;

10409 var arg_request = buildUsageExportLocation();

10410 var arg_project = "foo";

10411 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10412 var obj = new api.UsageExportLocation.fromJson(json);

10413 checkUsageExportLocation(obj);

10414

10415 var path = (req.url).path;

10416 var pathOffset = 0;

10417 var index;

10418 var subPart;

10419 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10420 pathOffset += 21;

10421 index = path.indexOf("/setUsageExportBucket", pathOffset);

10422 unittest.expect(index >= 0, unittest.isTrue);

10423 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10424 pathOffset = index;

10425 unittest.expect(subPart, unittest.equals("$arg_project"));

10426 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/setUsageExportBucket"));

10427 pathOffset += 21;

10428

10429 var query = (req.url).query;

10430 var queryOffset = 0;

10431 var queryMap = {};

10432 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10433 parseBool(n) {

10434 if (n == "true") return true;

10435 if (n == "false") return false;

10436 if (n == null) return null;

10437 throw new core.ArgumentError("Invalid boolean: $n");

10438 }

10439 if (query.length > 0) {

10440 for (var part in query.split("&")) {

10441 var keyvalue = part.split("=");

10442 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10443 }

10444 }

10445

10446

10447 var h = {

10448 "content-type" : "application/json; charset=utf-8",

10449 };

10450 var resp = convert.JSON.encode(buildOperation());

10451 return new async.Future.value(common_test.stringResponse(200, h, resp));

10452 }), true);

10453 res.setUsageExportBucket(arg_request, arg_project).then(unittest.expectAsy nc(((api.Operation response) {

10454 checkOperation(response);

10455 })));

10456 });

10457

10458 });

10459

10460

10461 unittest.group("resource-RegionOperationsResourceApi", () {

10462 unittest.test("method--delete", () {

10463

10464 var mock = new common_test.HttpServerMock();

10465 api.RegionOperationsResourceApi res = new api.ComputeApi(mock).regionOpera tions;

10466 var arg_project = "foo";

10467 var arg_region = "foo";

10468 var arg_operation = "foo";

10469 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10470 var path = (req.url).path;

10471 var pathOffset = 0;

10472 var index;

10473 var subPart;

10474 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10475 pathOffset += 21;

10476 index = path.indexOf("/regions/", pathOffset);

10477 unittest.expect(index >= 0, unittest.isTrue);

10478 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10479 pathOffset = index;

10480 unittest.expect(subPart, unittest.equals("$arg_project"));

10481 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

10482 pathOffset += 9;

10483 index = path.indexOf("/operations/", pathOffset);

10484 unittest.expect(index >= 0, unittest.isTrue);

10485 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10486 pathOffset = index;

10487 unittest.expect(subPart, unittest.equals("$arg_region"));

10488 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/operations/"));

10489 pathOffset += 12;

10490 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

10491 pathOffset = path.length;

10492 unittest.expect(subPart, unittest.equals("$arg_operation"));

10493

10494 var query = (req.url).query;

10495 var queryOffset = 0;

10496 var queryMap = {};

10497 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10498 parseBool(n) {

10499 if (n == "true") return true;

10500 if (n == "false") return false;

10501 if (n == null) return null;

10502 throw new core.ArgumentError("Invalid boolean: $n");

10503 }

10504 if (query.length > 0) {

10505 for (var part in query.split("&")) {

10506 var keyvalue = part.split("=");

10507 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10508 }

10509 }

10510

10511

10512 var h = {

10513 "content-type" : "application/json; charset=utf-8",

10514 };

10515 var resp = "";

10516 return new async.Future.value(common_test.stringResponse(200, h, resp));

10517 }), true);

10518 res.delete(arg_project, arg_region, arg_operation).then(unittest.expectAsy nc((_) {}));

10519 });

10520

10521 unittest.test("method--get", () {

10522

10523 var mock = new common_test.HttpServerMock();

10524 api.RegionOperationsResourceApi res = new api.ComputeApi(mock).regionOpera tions;

10525 var arg_project = "foo";

10526 var arg_region = "foo";

10527 var arg_operation = "foo";

10528 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10529 var path = (req.url).path;

10530 var pathOffset = 0;

10531 var index;

10532 var subPart;

10533 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10534 pathOffset += 21;

10535 index = path.indexOf("/regions/", pathOffset);

10536 unittest.expect(index >= 0, unittest.isTrue);

10537 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10538 pathOffset = index;

10539 unittest.expect(subPart, unittest.equals("$arg_project"));

10540 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

10541 pathOffset += 9;

10542 index = path.indexOf("/operations/", pathOffset);

10543 unittest.expect(index >= 0, unittest.isTrue);

10544 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10545 pathOffset = index;

10546 unittest.expect(subPart, unittest.equals("$arg_region"));

10547 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/operations/"));

10548 pathOffset += 12;

10549 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

10550 pathOffset = path.length;

10551 unittest.expect(subPart, unittest.equals("$arg_operation"));

10552

10553 var query = (req.url).query;

10554 var queryOffset = 0;

10555 var queryMap = {};

10556 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10557 parseBool(n) {

10558 if (n == "true") return true;

10559 if (n == "false") return false;

10560 if (n == null) return null;

10561 throw new core.ArgumentError("Invalid boolean: $n");

10562 }

10563 if (query.length > 0) {

10564 for (var part in query.split("&")) {

10565 var keyvalue = part.split("=");

10566 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10567 }

10568 }

10569

10570

10571 var h = {

10572 "content-type" : "application/json; charset=utf-8",

10573 };

10574 var resp = convert.JSON.encode(buildOperation());

10575 return new async.Future.value(common_test.stringResponse(200, h, resp));

10576 }), true);

10577 res.get(arg_project, arg_region, arg_operation).then(unittest.expectAsync( ((api.Operation response) {

10578 checkOperation(response);

10579 })));

10580 });

10581

10582 unittest.test("method--list", () {

10583

10584 var mock = new common_test.HttpServerMock();

10585 api.RegionOperationsResourceApi res = new api.ComputeApi(mock).regionOpera tions;

10586 var arg_project = "foo";

10587 var arg_region = "foo";

10588 var arg_filter = "foo";

10589 var arg_maxResults = 42;

10590 var arg_pageToken = "foo";

10591 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10592 var path = (req.url).path;

10593 var pathOffset = 0;

10594 var index;

10595 var subPart;

10596 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10597 pathOffset += 21;

10598 index = path.indexOf("/regions/", pathOffset);

10599 unittest.expect(index >= 0, unittest.isTrue);

10600 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10601 pathOffset = index;

10602 unittest.expect(subPart, unittest.equals("$arg_project"));

10603 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

10604 pathOffset += 9;

10605 index = path.indexOf("/operations", pathOffset);

10606 unittest.expect(index >= 0, unittest.isTrue);

10607 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10608 pathOffset = index;

10609 unittest.expect(subPart, unittest.equals("$arg_region"));

10610 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/operations"));

10611 pathOffset += 11;

10612

10613 var query = (req.url).query;

10614 var queryOffset = 0;

10615 var queryMap = {};

10616 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10617 parseBool(n) {

10618 if (n == "true") return true;

10619 if (n == "false") return false;

10620 if (n == null) return null;

10621 throw new core.ArgumentError("Invalid boolean: $n");

10622 }

10623 if (query.length > 0) {

10624 for (var part in query.split("&")) {

10625 var keyvalue = part.split("=");

10626 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10627 }

10628 }

10629 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

10630 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

10631 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

10632

10633

10634 var h = {

10635 "content-type" : "application/json; charset=utf-8",

10636 };

10637 var resp = convert.JSON.encode(buildOperationList());

10638 return new async.Future.value(common_test.stringResponse(200, h, resp));

10639 }), true);

10640 res.list(arg_project, arg_region, filter: arg_filter, maxResults: arg_maxR esults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.OperationList response) {

10641 checkOperationList(response);

10642 })));

10643 });

10644

10645 });

10646

10647

10648 unittest.group("resource-RegionsResourceApi", () {

10649 unittest.test("method--get", () {

10650

10651 var mock = new common_test.HttpServerMock();

10652 api.RegionsResourceApi res = new api.ComputeApi(mock).regions;

10653 var arg_project = "foo";

10654 var arg_region = "foo";

10655 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10656 var path = (req.url).path;

10657 var pathOffset = 0;

10658 var index;

10659 var subPart;

10660 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10661 pathOffset += 21;

10662 index = path.indexOf("/regions/", pathOffset);

10663 unittest.expect(index >= 0, unittest.isTrue);

10664 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10665 pathOffset = index;

10666 unittest.expect(subPart, unittest.equals("$arg_project"));

10667 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

10668 pathOffset += 9;

10669 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

10670 pathOffset = path.length;

10671 unittest.expect(subPart, unittest.equals("$arg_region"));

10672

10673 var query = (req.url).query;

10674 var queryOffset = 0;

10675 var queryMap = {};

10676 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10677 parseBool(n) {

10678 if (n == "true") return true;

10679 if (n == "false") return false;

10680 if (n == null) return null;

10681 throw new core.ArgumentError("Invalid boolean: $n");

10682 }

10683 if (query.length > 0) {

10684 for (var part in query.split("&")) {

10685 var keyvalue = part.split("=");

10686 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10687 }

10688 }

10689

10690

10691 var h = {

10692 "content-type" : "application/json; charset=utf-8",

10693 };

10694 var resp = convert.JSON.encode(buildRegion());

10695 return new async.Future.value(common_test.stringResponse(200, h, resp));

10696 }), true);

10697 res.get(arg_project, arg_region).then(unittest.expectAsync(((api.Region re sponse) {

10698 checkRegion(response);

10699 })));

10700 });

10701

10702 unittest.test("method--list", () {

10703

10704 var mock = new common_test.HttpServerMock();

10705 api.RegionsResourceApi res = new api.ComputeApi(mock).regions;

10706 var arg_project = "foo";

10707 var arg_filter = "foo";

10708 var arg_maxResults = 42;

10709 var arg_pageToken = "foo";

10710 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10711 var path = (req.url).path;

10712 var pathOffset = 0;

10713 var index;

10714 var subPart;

10715 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10716 pathOffset += 21;

10717 index = path.indexOf("/regions", pathOffset);

10718 unittest.expect(index >= 0, unittest.isTrue);

10719 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10720 pathOffset = index;

10721 unittest.expect(subPart, unittest.equals("$arg_project"));

10722 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/regions"));

10723 pathOffset += 8;

10724

10725 var query = (req.url).query;

10726 var queryOffset = 0;

10727 var queryMap = {};

10728 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10729 parseBool(n) {

10730 if (n == "true") return true;

10731 if (n == "false") return false;

10732 if (n == null) return null;

10733 throw new core.ArgumentError("Invalid boolean: $n");

10734 }

10735 if (query.length > 0) {

10736 for (var part in query.split("&")) {

10737 var keyvalue = part.split("=");

10738 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10739 }

10740 }

10741 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

10742 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

10743 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

10744

10745

10746 var h = {

10747 "content-type" : "application/json; charset=utf-8",

10748 };

10749 var resp = convert.JSON.encode(buildRegionList());

10750 return new async.Future.value(common_test.stringResponse(200, h, resp));

10751 }), true);

10752 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.RegionList response) {

10753 checkRegionList(response);

10754 })));

10755 });

10756

10757 });

10758

10759

10760 unittest.group("resource-RoutesResourceApi", () {

10761 unittest.test("method--delete", () {

10762

10763 var mock = new common_test.HttpServerMock();

10764 api.RoutesResourceApi res = new api.ComputeApi(mock).routes;

10765 var arg_project = "foo";

10766 var arg_route = "foo";

10767 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10768 var path = (req.url).path;

10769 var pathOffset = 0;

10770 var index;

10771 var subPart;

10772 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10773 pathOffset += 21;

10774 index = path.indexOf("/global/routes/", pathOffset);

10775 unittest.expect(index >= 0, unittest.isTrue);

10776 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10777 pathOffset = index;

10778 unittest.expect(subPart, unittest.equals("$arg_project"));

10779 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/global/routes/"));

10780 pathOffset += 15;

10781 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

10782 pathOffset = path.length;

10783 unittest.expect(subPart, unittest.equals("$arg_route"));

10784

10785 var query = (req.url).query;

10786 var queryOffset = 0;

10787 var queryMap = {};

10788 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10789 parseBool(n) {

10790 if (n == "true") return true;

10791 if (n == "false") return false;

10792 if (n == null) return null;

10793 throw new core.ArgumentError("Invalid boolean: $n");

10794 }

10795 if (query.length > 0) {

10796 for (var part in query.split("&")) {

10797 var keyvalue = part.split("=");

10798 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10799 }

10800 }

10801

10802

10803 var h = {

10804 "content-type" : "application/json; charset=utf-8",

10805 };

10806 var resp = convert.JSON.encode(buildOperation());

10807 return new async.Future.value(common_test.stringResponse(200, h, resp));

10808 }), true);

10809 res.delete(arg_project, arg_route).then(unittest.expectAsync(((api.Operati on response) {

10810 checkOperation(response);

10811 })));

10812 });

10813

10814 unittest.test("method--get", () {

10815

10816 var mock = new common_test.HttpServerMock();

10817 api.RoutesResourceApi res = new api.ComputeApi(mock).routes;

10818 var arg_project = "foo";

10819 var arg_route = "foo";

10820 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10821 var path = (req.url).path;

10822 var pathOffset = 0;

10823 var index;

10824 var subPart;

10825 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10826 pathOffset += 21;

10827 index = path.indexOf("/global/routes/", pathOffset);

10828 unittest.expect(index >= 0, unittest.isTrue);

10829 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10830 pathOffset = index;

10831 unittest.expect(subPart, unittest.equals("$arg_project"));

10832 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/global/routes/"));

10833 pathOffset += 15;

10834 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

10835 pathOffset = path.length;

10836 unittest.expect(subPart, unittest.equals("$arg_route"));

10837

10838 var query = (req.url).query;

10839 var queryOffset = 0;

10840 var queryMap = {};

10841 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10842 parseBool(n) {

10843 if (n == "true") return true;

10844 if (n == "false") return false;

10845 if (n == null) return null;

10846 throw new core.ArgumentError("Invalid boolean: $n");

10847 }

10848 if (query.length > 0) {

10849 for (var part in query.split("&")) {

10850 var keyvalue = part.split("=");

10851 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10852 }

10853 }

10854

10855

10856 var h = {

10857 "content-type" : "application/json; charset=utf-8",

10858 };

10859 var resp = convert.JSON.encode(buildRoute());

10860 return new async.Future.value(common_test.stringResponse(200, h, resp));

10861 }), true);

10862 res.get(arg_project, arg_route).then(unittest.expectAsync(((api.Route resp onse) {

10863 checkRoute(response);

10864 })));

10865 });

10866

10867 unittest.test("method--insert", () {

10868

10869 var mock = new common_test.HttpServerMock();

10870 api.RoutesResourceApi res = new api.ComputeApi(mock).routes;

10871 var arg_request = buildRoute();

10872 var arg_project = "foo";

10873 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10874 var obj = new api.Route.fromJson(json);

10875 checkRoute(obj);

10876

10877 var path = (req.url).path;

10878 var pathOffset = 0;

10879 var index;

10880 var subPart;

10881 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10882 pathOffset += 21;

10883 index = path.indexOf("/global/routes", pathOffset);

10884 unittest.expect(index >= 0, unittest.isTrue);

10885 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10886 pathOffset = index;

10887 unittest.expect(subPart, unittest.equals("$arg_project"));

10888 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/global/routes"));

10889 pathOffset += 14;

10890

10891 var query = (req.url).query;

10892 var queryOffset = 0;

10893 var queryMap = {};

10894 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10895 parseBool(n) {

10896 if (n == "true") return true;

10897 if (n == "false") return false;

10898 if (n == null) return null;

10899 throw new core.ArgumentError("Invalid boolean: $n");

10900 }

10901 if (query.length > 0) {

10902 for (var part in query.split("&")) {

10903 var keyvalue = part.split("=");

10904 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10905 }

10906 }

10907

10908

10909 var h = {

10910 "content-type" : "application/json; charset=utf-8",

10911 };

10912 var resp = convert.JSON.encode(buildOperation());

10913 return new async.Future.value(common_test.stringResponse(200, h, resp));

10914 }), true);

10915 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

10916 checkOperation(response);

10917 })));

10918 });

10919

10920 unittest.test("method--list", () {

10921

10922 var mock = new common_test.HttpServerMock();

10923 api.RoutesResourceApi res = new api.ComputeApi(mock).routes;

10924 var arg_project = "foo";

10925 var arg_filter = "foo";

10926 var arg_maxResults = 42;

10927 var arg_pageToken = "foo";

10928 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10929 var path = (req.url).path;

10930 var pathOffset = 0;

10931 var index;

10932 var subPart;

10933 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10934 pathOffset += 21;

10935 index = path.indexOf("/global/routes", pathOffset);

10936 unittest.expect(index >= 0, unittest.isTrue);

10937 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10938 pathOffset = index;

10939 unittest.expect(subPart, unittest.equals("$arg_project"));

10940 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/global/routes"));

10941 pathOffset += 14;

10942

10943 var query = (req.url).query;

10944 var queryOffset = 0;

10945 var queryMap = {};

10946 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

10947 parseBool(n) {

10948 if (n == "true") return true;

10949 if (n == "false") return false;

10950 if (n == null) return null;

10951 throw new core.ArgumentError("Invalid boolean: $n");

10952 }

10953 if (query.length > 0) {

10954 for (var part in query.split("&")) {

10955 var keyvalue = part.split("=");

10956 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

10957 }

10958 }

10959 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

10960 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

10961 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

10962

10963

10964 var h = {

10965 "content-type" : "application/json; charset=utf-8",

10966 };

10967 var resp = convert.JSON.encode(buildRouteList());

10968 return new async.Future.value(common_test.stringResponse(200, h, resp));

10969 }), true);

10970 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.RouteList response) {

10971 checkRouteList(response);

10972 })));

10973 });

10974

10975 });

10976

10977

10978 unittest.group("resource-SnapshotsResourceApi", () {

10979 unittest.test("method--delete", () {

10980

10981 var mock = new common_test.HttpServerMock();

10982 api.SnapshotsResourceApi res = new api.ComputeApi(mock).snapshots;

10983 var arg_project = "foo";

10984 var arg_snapshot = "foo";

10985 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

10986 var path = (req.url).path;

10987 var pathOffset = 0;

10988 var index;

10989 var subPart;

10990 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

10991 pathOffset += 21;

10992 index = path.indexOf("/global/snapshots/", pathOffset);

10993 unittest.expect(index >= 0, unittest.isTrue);

10994 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

10995 pathOffset = index;

10996 unittest.expect(subPart, unittest.equals("$arg_project"));

10997 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/global/snapshots/"));

10998 pathOffset += 18;

10999 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

11000 pathOffset = path.length;

11001 unittest.expect(subPart, unittest.equals("$arg_snapshot"));

11002

11003 var query = (req.url).query;

11004 var queryOffset = 0;

11005 var queryMap = {};

11006 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11007 parseBool(n) {

11008 if (n == "true") return true;

11009 if (n == "false") return false;

11010 if (n == null) return null;

11011 throw new core.ArgumentError("Invalid boolean: $n");

11012 }

11013 if (query.length > 0) {

11014 for (var part in query.split("&")) {

11015 var keyvalue = part.split("=");

11016 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11017 }

11018 }

11019

11020

11021 var h = {

11022 "content-type" : "application/json; charset=utf-8",

11023 };

11024 var resp = convert.JSON.encode(buildOperation());

11025 return new async.Future.value(common_test.stringResponse(200, h, resp));

11026 }), true);

11027 res.delete(arg_project, arg_snapshot).then(unittest.expectAsync(((api.Oper ation response) {

11028 checkOperation(response);

11029 })));

11030 });

11031

11032 unittest.test("method--get", () {

11033

11034 var mock = new common_test.HttpServerMock();

11035 api.SnapshotsResourceApi res = new api.ComputeApi(mock).snapshots;

11036 var arg_project = "foo";

11037 var arg_snapshot = "foo";

11038 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11039 var path = (req.url).path;

11040 var pathOffset = 0;

11041 var index;

11042 var subPart;

11043 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11044 pathOffset += 21;

11045 index = path.indexOf("/global/snapshots/", pathOffset);

11046 unittest.expect(index >= 0, unittest.isTrue);

11047 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11048 pathOffset = index;

11049 unittest.expect(subPart, unittest.equals("$arg_project"));

11050 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/global/snapshots/"));

11051 pathOffset += 18;

11052 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

11053 pathOffset = path.length;

11054 unittest.expect(subPart, unittest.equals("$arg_snapshot"));

11055

11056 var query = (req.url).query;

11057 var queryOffset = 0;

11058 var queryMap = {};

11059 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11060 parseBool(n) {

11061 if (n == "true") return true;

11062 if (n == "false") return false;

11063 if (n == null) return null;

11064 throw new core.ArgumentError("Invalid boolean: $n");

11065 }

11066 if (query.length > 0) {

11067 for (var part in query.split("&")) {

11068 var keyvalue = part.split("=");

11069 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11070 }

11071 }

11072

11073

11074 var h = {

11075 "content-type" : "application/json; charset=utf-8",

11076 };

11077 var resp = convert.JSON.encode(buildSnapshot());

11078 return new async.Future.value(common_test.stringResponse(200, h, resp));

11079 }), true);

11080 res.get(arg_project, arg_snapshot).then(unittest.expectAsync(((api.Snapsho t response) {

11081 checkSnapshot(response);

11082 })));

11083 });

11084

11085 unittest.test("method--list", () {

11086

11087 var mock = new common_test.HttpServerMock();

11088 api.SnapshotsResourceApi res = new api.ComputeApi(mock).snapshots;

11089 var arg_project = "foo";

11090 var arg_filter = "foo";

11091 var arg_maxResults = 42;

11092 var arg_pageToken = "foo";

11093 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11094 var path = (req.url).path;

11095 var pathOffset = 0;

11096 var index;

11097 var subPart;

11098 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11099 pathOffset += 21;

11100 index = path.indexOf("/global/snapshots", pathOffset);

11101 unittest.expect(index >= 0, unittest.isTrue);

11102 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11103 pathOffset = index;

11104 unittest.expect(subPart, unittest.equals("$arg_project"));

11105 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/global/snapshots"));

11106 pathOffset += 17;

11107

11108 var query = (req.url).query;

11109 var queryOffset = 0;

11110 var queryMap = {};

11111 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11112 parseBool(n) {

11113 if (n == "true") return true;

11114 if (n == "false") return false;

11115 if (n == null) return null;

11116 throw new core.ArgumentError("Invalid boolean: $n");

11117 }

11118 if (query.length > 0) {

11119 for (var part in query.split("&")) {

11120 var keyvalue = part.split("=");

11121 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11122 }

11123 }

11124 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

11125 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

11126 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

11127

11128

11129 var h = {

11130 "content-type" : "application/json; charset=utf-8",

11131 };

11132 var resp = convert.JSON.encode(buildSnapshotList());

11133 return new async.Future.value(common_test.stringResponse(200, h, resp));

11134 }), true);

11135 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.SnapshotList response) {

11136 checkSnapshotList(response);

11137 })));

11138 });

11139

11140 });

11141

11142

11143 unittest.group("resource-TargetHttpProxiesResourceApi", () {

11144 unittest.test("method--delete", () {

11145

11146 var mock = new common_test.HttpServerMock();

11147 api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttp Proxies;

11148 var arg_project = "foo";

11149 var arg_targetHttpProxy = "foo";

11150 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11151 var path = (req.url).path;

11152 var pathOffset = 0;

11153 var index;

11154 var subPart;

11155 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11156 pathOffset += 21;

11157 index = path.indexOf("/global/targetHttpProxies/", pathOffset);

11158 unittest.expect(index >= 0, unittest.isTrue);

11159 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11160 pathOffset = index;

11161 unittest.expect(subPart, unittest.equals("$arg_project"));

11162 unittest.expect(path.substring(pathOffset, pathOffset + 26), unittest.eq uals("/global/targetHttpProxies/"));

11163 pathOffset += 26;

11164 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

11165 pathOffset = path.length;

11166 unittest.expect(subPart, unittest.equals("$arg_targetHttpProxy"));

11167

11168 var query = (req.url).query;

11169 var queryOffset = 0;

11170 var queryMap = {};

11171 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11172 parseBool(n) {

11173 if (n == "true") return true;

11174 if (n == "false") return false;

11175 if (n == null) return null;

11176 throw new core.ArgumentError("Invalid boolean: $n");

11177 }

11178 if (query.length > 0) {

11179 for (var part in query.split("&")) {

11180 var keyvalue = part.split("=");

11181 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11182 }

11183 }

11184

11185

11186 var h = {

11187 "content-type" : "application/json; charset=utf-8",

11188 };

11189 var resp = convert.JSON.encode(buildOperation());

11190 return new async.Future.value(common_test.stringResponse(200, h, resp));

11191 }), true);

11192 res.delete(arg_project, arg_targetHttpProxy).then(unittest.expectAsync(((a pi.Operation response) {

11193 checkOperation(response);

11194 })));

11195 });

11196

11197 unittest.test("method--get", () {

11198

11199 var mock = new common_test.HttpServerMock();

11200 api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttp Proxies;

11201 var arg_project = "foo";

11202 var arg_targetHttpProxy = "foo";

11203 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11204 var path = (req.url).path;

11205 var pathOffset = 0;

11206 var index;

11207 var subPart;

11208 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11209 pathOffset += 21;

11210 index = path.indexOf("/global/targetHttpProxies/", pathOffset);

11211 unittest.expect(index >= 0, unittest.isTrue);

11212 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11213 pathOffset = index;

11214 unittest.expect(subPart, unittest.equals("$arg_project"));

11215 unittest.expect(path.substring(pathOffset, pathOffset + 26), unittest.eq uals("/global/targetHttpProxies/"));

11216 pathOffset += 26;

11217 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

11218 pathOffset = path.length;

11219 unittest.expect(subPart, unittest.equals("$arg_targetHttpProxy"));

11220

11221 var query = (req.url).query;

11222 var queryOffset = 0;

11223 var queryMap = {};

11224 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11225 parseBool(n) {

11226 if (n == "true") return true;

11227 if (n == "false") return false;

11228 if (n == null) return null;

11229 throw new core.ArgumentError("Invalid boolean: $n");

11230 }

11231 if (query.length > 0) {

11232 for (var part in query.split("&")) {

11233 var keyvalue = part.split("=");

11234 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11235 }

11236 }

11237

11238

11239 var h = {

11240 "content-type" : "application/json; charset=utf-8",

11241 };

11242 var resp = convert.JSON.encode(buildTargetHttpProxy());

11243 return new async.Future.value(common_test.stringResponse(200, h, resp));

11244 }), true);

11245 res.get(arg_project, arg_targetHttpProxy).then(unittest.expectAsync(((api. TargetHttpProxy response) {

11246 checkTargetHttpProxy(response);

11247 })));

11248 });

11249

11250 unittest.test("method--insert", () {

11251

11252 var mock = new common_test.HttpServerMock();

11253 api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttp Proxies;

11254 var arg_request = buildTargetHttpProxy();

11255 var arg_project = "foo";

11256 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11257 var obj = new api.TargetHttpProxy.fromJson(json);

11258 checkTargetHttpProxy(obj);

11259

11260 var path = (req.url).path;

11261 var pathOffset = 0;

11262 var index;

11263 var subPart;

11264 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11265 pathOffset += 21;

11266 index = path.indexOf("/global/targetHttpProxies", pathOffset);

11267 unittest.expect(index >= 0, unittest.isTrue);

11268 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11269 pathOffset = index;

11270 unittest.expect(subPart, unittest.equals("$arg_project"));

11271 unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.eq uals("/global/targetHttpProxies"));

11272 pathOffset += 25;

11273

11274 var query = (req.url).query;

11275 var queryOffset = 0;

11276 var queryMap = {};

11277 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11278 parseBool(n) {

11279 if (n == "true") return true;

11280 if (n == "false") return false;

11281 if (n == null) return null;

11282 throw new core.ArgumentError("Invalid boolean: $n");

11283 }

11284 if (query.length > 0) {

11285 for (var part in query.split("&")) {

11286 var keyvalue = part.split("=");

11287 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11288 }

11289 }

11290

11291

11292 var h = {

11293 "content-type" : "application/json; charset=utf-8",

11294 };

11295 var resp = convert.JSON.encode(buildOperation());

11296 return new async.Future.value(common_test.stringResponse(200, h, resp));

11297 }), true);

11298 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

11299 checkOperation(response);

11300 })));

11301 });

11302

11303 unittest.test("method--list", () {

11304

11305 var mock = new common_test.HttpServerMock();

11306 api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttp Proxies;

11307 var arg_project = "foo";

11308 var arg_filter = "foo";

11309 var arg_maxResults = 42;

11310 var arg_pageToken = "foo";

11311 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11312 var path = (req.url).path;

11313 var pathOffset = 0;

11314 var index;

11315 var subPart;

11316 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11317 pathOffset += 21;

11318 index = path.indexOf("/global/targetHttpProxies", pathOffset);

11319 unittest.expect(index >= 0, unittest.isTrue);

11320 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11321 pathOffset = index;

11322 unittest.expect(subPart, unittest.equals("$arg_project"));

11323 unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.eq uals("/global/targetHttpProxies"));

11324 pathOffset += 25;

11325

11326 var query = (req.url).query;

11327 var queryOffset = 0;

11328 var queryMap = {};

11329 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11330 parseBool(n) {

11331 if (n == "true") return true;

11332 if (n == "false") return false;

11333 if (n == null) return null;

11334 throw new core.ArgumentError("Invalid boolean: $n");

11335 }

11336 if (query.length > 0) {

11337 for (var part in query.split("&")) {

11338 var keyvalue = part.split("=");

11339 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11340 }

11341 }

11342 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

11343 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

11344 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

11345

11346

11347 var h = {

11348 "content-type" : "application/json; charset=utf-8",

11349 };

11350 var resp = convert.JSON.encode(buildTargetHttpProxyList());

11351 return new async.Future.value(common_test.stringResponse(200, h, resp));

11352 }), true);

11353 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.TargetHttpProxyList respon se) {

11354 checkTargetHttpProxyList(response);

11355 })));

11356 });

11357

11358 unittest.test("method--setUrlMap", () {

11359

11360 var mock = new common_test.HttpServerMock();

11361 api.TargetHttpProxiesResourceApi res = new api.ComputeApi(mock).targetHttp Proxies;

11362 var arg_request = buildUrlMapReference();

11363 var arg_project = "foo";

11364 var arg_targetHttpProxy = "foo";

11365 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11366 var obj = new api.UrlMapReference.fromJson(json);

11367 checkUrlMapReference(obj);

11368

11369 var path = (req.url).path;

11370 var pathOffset = 0;

11371 var index;

11372 var subPart;

11373 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11374 pathOffset += 21;

11375 index = path.indexOf("/targetHttpProxies/", pathOffset);

11376 unittest.expect(index >= 0, unittest.isTrue);

11377 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11378 pathOffset = index;

11379 unittest.expect(subPart, unittest.equals("$arg_project"));

11380 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("/targetHttpProxies/"));

11381 pathOffset += 19;

11382 index = path.indexOf("/setUrlMap", pathOffset);

11383 unittest.expect(index >= 0, unittest.isTrue);

11384 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11385 pathOffset = index;

11386 unittest.expect(subPart, unittest.equals("$arg_targetHttpProxy"));

11387 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/setUrlMap"));

11388 pathOffset += 10;

11389

11390 var query = (req.url).query;

11391 var queryOffset = 0;

11392 var queryMap = {};

11393 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11394 parseBool(n) {

11395 if (n == "true") return true;

11396 if (n == "false") return false;

11397 if (n == null) return null;

11398 throw new core.ArgumentError("Invalid boolean: $n");

11399 }

11400 if (query.length > 0) {

11401 for (var part in query.split("&")) {

11402 var keyvalue = part.split("=");

11403 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11404 }

11405 }

11406

11407

11408 var h = {

11409 "content-type" : "application/json; charset=utf-8",

11410 };

11411 var resp = convert.JSON.encode(buildOperation());

11412 return new async.Future.value(common_test.stringResponse(200, h, resp));

11413 }), true);

11414 res.setUrlMap(arg_request, arg_project, arg_targetHttpProxy).then(unittest .expectAsync(((api.Operation response) {

11415 checkOperation(response);

11416 })));

11417 });

11418

11419 });

11420

11421

11422 unittest.group("resource-TargetInstancesResourceApi", () {

11423 unittest.test("method--aggregatedList", () {

11424

11425 var mock = new common_test.HttpServerMock();

11426 api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstan ces;

11427 var arg_project = "foo";

11428 var arg_filter = "foo";

11429 var arg_maxResults = 42;

11430 var arg_pageToken = "foo";

11431 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11432 var path = (req.url).path;

11433 var pathOffset = 0;

11434 var index;

11435 var subPart;

11436 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11437 pathOffset += 21;

11438 index = path.indexOf("/aggregated/targetInstances", pathOffset);

11439 unittest.expect(index >= 0, unittest.isTrue);

11440 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11441 pathOffset = index;

11442 unittest.expect(subPart, unittest.equals("$arg_project"));

11443 unittest.expect(path.substring(pathOffset, pathOffset + 27), unittest.eq uals("/aggregated/targetInstances"));

11444 pathOffset += 27;

11445

11446 var query = (req.url).query;

11447 var queryOffset = 0;

11448 var queryMap = {};

11449 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11450 parseBool(n) {

11451 if (n == "true") return true;

11452 if (n == "false") return false;

11453 if (n == null) return null;

11454 throw new core.ArgumentError("Invalid boolean: $n");

11455 }

11456 if (query.length > 0) {

11457 for (var part in query.split("&")) {

11458 var keyvalue = part.split("=");

11459 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11460 }

11461 }

11462 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

11463 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

11464 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

11465

11466

11467 var h = {

11468 "content-type" : "application/json; charset=utf-8",

11469 };

11470 var resp = convert.JSON.encode(buildTargetInstanceAggregatedList());

11471 return new async.Future.value(common_test.stringResponse(200, h, resp));

11472 }), true);

11473 res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TargetInstanceAg gregatedList response) {

11474 checkTargetInstanceAggregatedList(response);

11475 })));

11476 });

11477

11478 unittest.test("method--delete", () {

11479

11480 var mock = new common_test.HttpServerMock();

11481 api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstan ces;

11482 var arg_project = "foo";

11483 var arg_zone = "foo";

11484 var arg_targetInstance = "foo";

11485 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11486 var path = (req.url).path;

11487 var pathOffset = 0;

11488 var index;

11489 var subPart;

11490 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11491 pathOffset += 21;

11492 index = path.indexOf("/zones/", pathOffset);

11493 unittest.expect(index >= 0, unittest.isTrue);

11494 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11495 pathOffset = index;

11496 unittest.expect(subPart, unittest.equals("$arg_project"));

11497 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

11498 pathOffset += 7;

11499 index = path.indexOf("/targetInstances/", pathOffset);

11500 unittest.expect(index >= 0, unittest.isTrue);

11501 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11502 pathOffset = index;

11503 unittest.expect(subPart, unittest.equals("$arg_zone"));

11504 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/targetInstances/"));

11505 pathOffset += 17;

11506 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

11507 pathOffset = path.length;

11508 unittest.expect(subPart, unittest.equals("$arg_targetInstance"));

11509

11510 var query = (req.url).query;

11511 var queryOffset = 0;

11512 var queryMap = {};

11513 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11514 parseBool(n) {

11515 if (n == "true") return true;

11516 if (n == "false") return false;

11517 if (n == null) return null;

11518 throw new core.ArgumentError("Invalid boolean: $n");

11519 }

11520 if (query.length > 0) {

11521 for (var part in query.split("&")) {

11522 var keyvalue = part.split("=");

11523 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11524 }

11525 }

11526

11527

11528 var h = {

11529 "content-type" : "application/json; charset=utf-8",

11530 };

11531 var resp = convert.JSON.encode(buildOperation());

11532 return new async.Future.value(common_test.stringResponse(200, h, resp));

11533 }), true);

11534 res.delete(arg_project, arg_zone, arg_targetInstance).then(unittest.expect Async(((api.Operation response) {

11535 checkOperation(response);

11536 })));

11537 });

11538

11539 unittest.test("method--get", () {

11540

11541 var mock = new common_test.HttpServerMock();

11542 api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstan ces;

11543 var arg_project = "foo";

11544 var arg_zone = "foo";

11545 var arg_targetInstance = "foo";

11546 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11547 var path = (req.url).path;

11548 var pathOffset = 0;

11549 var index;

11550 var subPart;

11551 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11552 pathOffset += 21;

11553 index = path.indexOf("/zones/", pathOffset);

11554 unittest.expect(index >= 0, unittest.isTrue);

11555 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11556 pathOffset = index;

11557 unittest.expect(subPart, unittest.equals("$arg_project"));

11558 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

11559 pathOffset += 7;

11560 index = path.indexOf("/targetInstances/", pathOffset);

11561 unittest.expect(index >= 0, unittest.isTrue);

11562 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11563 pathOffset = index;

11564 unittest.expect(subPart, unittest.equals("$arg_zone"));

11565 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/targetInstances/"));

11566 pathOffset += 17;

11567 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

11568 pathOffset = path.length;

11569 unittest.expect(subPart, unittest.equals("$arg_targetInstance"));

11570

11571 var query = (req.url).query;

11572 var queryOffset = 0;

11573 var queryMap = {};

11574 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11575 parseBool(n) {

11576 if (n == "true") return true;

11577 if (n == "false") return false;

11578 if (n == null) return null;

11579 throw new core.ArgumentError("Invalid boolean: $n");

11580 }

11581 if (query.length > 0) {

11582 for (var part in query.split("&")) {

11583 var keyvalue = part.split("=");

11584 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11585 }

11586 }

11587

11588

11589 var h = {

11590 "content-type" : "application/json; charset=utf-8",

11591 };

11592 var resp = convert.JSON.encode(buildTargetInstance());

11593 return new async.Future.value(common_test.stringResponse(200, h, resp));

11594 }), true);

11595 res.get(arg_project, arg_zone, arg_targetInstance).then(unittest.expectAsy nc(((api.TargetInstance response) {

11596 checkTargetInstance(response);

11597 })));

11598 });

11599

11600 unittest.test("method--insert", () {

11601

11602 var mock = new common_test.HttpServerMock();

11603 api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstan ces;

11604 var arg_request = buildTargetInstance();

11605 var arg_project = "foo";

11606 var arg_zone = "foo";

11607 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11608 var obj = new api.TargetInstance.fromJson(json);

11609 checkTargetInstance(obj);

11610

11611 var path = (req.url).path;

11612 var pathOffset = 0;

11613 var index;

11614 var subPart;

11615 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11616 pathOffset += 21;

11617 index = path.indexOf("/zones/", pathOffset);

11618 unittest.expect(index >= 0, unittest.isTrue);

11619 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11620 pathOffset = index;

11621 unittest.expect(subPart, unittest.equals("$arg_project"));

11622 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

11623 pathOffset += 7;

11624 index = path.indexOf("/targetInstances", pathOffset);

11625 unittest.expect(index >= 0, unittest.isTrue);

11626 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11627 pathOffset = index;

11628 unittest.expect(subPart, unittest.equals("$arg_zone"));

11629 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/targetInstances"));

11630 pathOffset += 16;

11631

11632 var query = (req.url).query;

11633 var queryOffset = 0;

11634 var queryMap = {};

11635 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11636 parseBool(n) {

11637 if (n == "true") return true;

11638 if (n == "false") return false;

11639 if (n == null) return null;

11640 throw new core.ArgumentError("Invalid boolean: $n");

11641 }

11642 if (query.length > 0) {

11643 for (var part in query.split("&")) {

11644 var keyvalue = part.split("=");

11645 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11646 }

11647 }

11648

11649

11650 var h = {

11651 "content-type" : "application/json; charset=utf-8",

11652 };

11653 var resp = convert.JSON.encode(buildOperation());

11654 return new async.Future.value(common_test.stringResponse(200, h, resp));

11655 }), true);

11656 res.insert(arg_request, arg_project, arg_zone).then(unittest.expectAsync(( (api.Operation response) {

11657 checkOperation(response);

11658 })));

11659 });

11660

11661 unittest.test("method--list", () {

11662

11663 var mock = new common_test.HttpServerMock();

11664 api.TargetInstancesResourceApi res = new api.ComputeApi(mock).targetInstan ces;

11665 var arg_project = "foo";

11666 var arg_zone = "foo";

11667 var arg_filter = "foo";

11668 var arg_maxResults = 42;

11669 var arg_pageToken = "foo";

11670 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11671 var path = (req.url).path;

11672 var pathOffset = 0;

11673 var index;

11674 var subPart;

11675 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11676 pathOffset += 21;

11677 index = path.indexOf("/zones/", pathOffset);

11678 unittest.expect(index >= 0, unittest.isTrue);

11679 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11680 pathOffset = index;

11681 unittest.expect(subPart, unittest.equals("$arg_project"));

11682 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

11683 pathOffset += 7;

11684 index = path.indexOf("/targetInstances", pathOffset);

11685 unittest.expect(index >= 0, unittest.isTrue);

11686 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11687 pathOffset = index;

11688 unittest.expect(subPart, unittest.equals("$arg_zone"));

11689 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/targetInstances"));

11690 pathOffset += 16;

11691

11692 var query = (req.url).query;

11693 var queryOffset = 0;

11694 var queryMap = {};

11695 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11696 parseBool(n) {

11697 if (n == "true") return true;

11698 if (n == "false") return false;

11699 if (n == null) return null;

11700 throw new core.ArgumentError("Invalid boolean: $n");

11701 }

11702 if (query.length > 0) {

11703 for (var part in query.split("&")) {

11704 var keyvalue = part.split("=");

11705 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11706 }

11707 }

11708 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

11709 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

11710 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

11711

11712

11713 var h = {

11714 "content-type" : "application/json; charset=utf-8",

11715 };

11716 var resp = convert.JSON.encode(buildTargetInstanceList());

11717 return new async.Future.value(common_test.stringResponse(200, h, resp));

11718 }), true);

11719 res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TargetInstanceLi st response) {

11720 checkTargetInstanceList(response);

11721 })));

11722 });

11723

11724 });

11725

11726

11727 unittest.group("resource-TargetPoolsResourceApi", () {

11728 unittest.test("method--addHealthCheck", () {

11729

11730 var mock = new common_test.HttpServerMock();

11731 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

11732 var arg_request = buildTargetPoolsAddHealthCheckRequest();

11733 var arg_project = "foo";

11734 var arg_region = "foo";

11735 var arg_targetPool = "foo";

11736 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11737 var obj = new api.TargetPoolsAddHealthCheckRequest.fromJson(json);

11738 checkTargetPoolsAddHealthCheckRequest(obj);

11739

11740 var path = (req.url).path;

11741 var pathOffset = 0;

11742 var index;

11743 var subPart;

11744 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11745 pathOffset += 21;

11746 index = path.indexOf("/regions/", pathOffset);

11747 unittest.expect(index >= 0, unittest.isTrue);

11748 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11749 pathOffset = index;

11750 unittest.expect(subPart, unittest.equals("$arg_project"));

11751 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

11752 pathOffset += 9;

11753 index = path.indexOf("/targetPools/", pathOffset);

11754 unittest.expect(index >= 0, unittest.isTrue);

11755 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11756 pathOffset = index;

11757 unittest.expect(subPart, unittest.equals("$arg_region"));

11758 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/targetPools/"));

11759 pathOffset += 13;

11760 index = path.indexOf("/addHealthCheck", pathOffset);

11761 unittest.expect(index >= 0, unittest.isTrue);

11762 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11763 pathOffset = index;

11764 unittest.expect(subPart, unittest.equals("$arg_targetPool"));

11765 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/addHealthCheck"));

11766 pathOffset += 15;

11767

11768 var query = (req.url).query;

11769 var queryOffset = 0;

11770 var queryMap = {};

11771 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11772 parseBool(n) {

11773 if (n == "true") return true;

11774 if (n == "false") return false;

11775 if (n == null) return null;

11776 throw new core.ArgumentError("Invalid boolean: $n");

11777 }

11778 if (query.length > 0) {

11779 for (var part in query.split("&")) {

11780 var keyvalue = part.split("=");

11781 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11782 }

11783 }

11784

11785

11786 var h = {

11787 "content-type" : "application/json; charset=utf-8",

11788 };

11789 var resp = convert.JSON.encode(buildOperation());

11790 return new async.Future.value(common_test.stringResponse(200, h, resp));

11791 }), true);

11792 res.addHealthCheck(arg_request, arg_project, arg_region, arg_targetPool).t hen(unittest.expectAsync(((api.Operation response) {

11793 checkOperation(response);

11794 })));

11795 });

11796

11797 unittest.test("method--addInstance", () {

11798

11799 var mock = new common_test.HttpServerMock();

11800 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

11801 var arg_request = buildTargetPoolsAddInstanceRequest();

11802 var arg_project = "foo";

11803 var arg_region = "foo";

11804 var arg_targetPool = "foo";

11805 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11806 var obj = new api.TargetPoolsAddInstanceRequest.fromJson(json);

11807 checkTargetPoolsAddInstanceRequest(obj);

11808

11809 var path = (req.url).path;

11810 var pathOffset = 0;

11811 var index;

11812 var subPart;

11813 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11814 pathOffset += 21;

11815 index = path.indexOf("/regions/", pathOffset);

11816 unittest.expect(index >= 0, unittest.isTrue);

11817 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11818 pathOffset = index;

11819 unittest.expect(subPart, unittest.equals("$arg_project"));

11820 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

11821 pathOffset += 9;

11822 index = path.indexOf("/targetPools/", pathOffset);

11823 unittest.expect(index >= 0, unittest.isTrue);

11824 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11825 pathOffset = index;

11826 unittest.expect(subPart, unittest.equals("$arg_region"));

11827 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/targetPools/"));

11828 pathOffset += 13;

11829 index = path.indexOf("/addInstance", pathOffset);

11830 unittest.expect(index >= 0, unittest.isTrue);

11831 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11832 pathOffset = index;

11833 unittest.expect(subPart, unittest.equals("$arg_targetPool"));

11834 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/addInstance"));

11835 pathOffset += 12;

11836

11837 var query = (req.url).query;

11838 var queryOffset = 0;

11839 var queryMap = {};

11840 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11841 parseBool(n) {

11842 if (n == "true") return true;

11843 if (n == "false") return false;

11844 if (n == null) return null;

11845 throw new core.ArgumentError("Invalid boolean: $n");

11846 }

11847 if (query.length > 0) {

11848 for (var part in query.split("&")) {

11849 var keyvalue = part.split("=");

11850 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11851 }

11852 }

11853

11854

11855 var h = {

11856 "content-type" : "application/json; charset=utf-8",

11857 };

11858 var resp = convert.JSON.encode(buildOperation());

11859 return new async.Future.value(common_test.stringResponse(200, h, resp));

11860 }), true);

11861 res.addInstance(arg_request, arg_project, arg_region, arg_targetPool).then (unittest.expectAsync(((api.Operation response) {

11862 checkOperation(response);

11863 })));

11864 });

11865

11866 unittest.test("method--aggregatedList", () {

11867

11868 var mock = new common_test.HttpServerMock();

11869 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

11870 var arg_project = "foo";

11871 var arg_filter = "foo";

11872 var arg_maxResults = 42;

11873 var arg_pageToken = "foo";

11874 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11875 var path = (req.url).path;

11876 var pathOffset = 0;

11877 var index;

11878 var subPart;

11879 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11880 pathOffset += 21;

11881 index = path.indexOf("/aggregated/targetPools", pathOffset);

11882 unittest.expect(index >= 0, unittest.isTrue);

11883 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11884 pathOffset = index;

11885 unittest.expect(subPart, unittest.equals("$arg_project"));

11886 unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.eq uals("/aggregated/targetPools"));

11887 pathOffset += 23;

11888

11889 var query = (req.url).query;

11890 var queryOffset = 0;

11891 var queryMap = {};

11892 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11893 parseBool(n) {

11894 if (n == "true") return true;

11895 if (n == "false") return false;

11896 if (n == null) return null;

11897 throw new core.ArgumentError("Invalid boolean: $n");

11898 }

11899 if (query.length > 0) {

11900 for (var part in query.split("&")) {

11901 var keyvalue = part.split("=");

11902 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11903 }

11904 }

11905 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

11906 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

11907 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

11908

11909

11910 var h = {

11911 "content-type" : "application/json; charset=utf-8",

11912 };

11913 var resp = convert.JSON.encode(buildTargetPoolAggregatedList());

11914 return new async.Future.value(common_test.stringResponse(200, h, resp));

11915 }), true);

11916 res.aggregatedList(arg_project, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TargetPoolAggreg atedList response) {

11917 checkTargetPoolAggregatedList(response);

11918 })));

11919 });

11920

11921 unittest.test("method--delete", () {

11922

11923 var mock = new common_test.HttpServerMock();

11924 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

11925 var arg_project = "foo";

11926 var arg_region = "foo";

11927 var arg_targetPool = "foo";

11928 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11929 var path = (req.url).path;

11930 var pathOffset = 0;

11931 var index;

11932 var subPart;

11933 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11934 pathOffset += 21;

11935 index = path.indexOf("/regions/", pathOffset);

11936 unittest.expect(index >= 0, unittest.isTrue);

11937 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11938 pathOffset = index;

11939 unittest.expect(subPart, unittest.equals("$arg_project"));

11940 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

11941 pathOffset += 9;

11942 index = path.indexOf("/targetPools/", pathOffset);

11943 unittest.expect(index >= 0, unittest.isTrue);

11944 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11945 pathOffset = index;

11946 unittest.expect(subPart, unittest.equals("$arg_region"));

11947 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/targetPools/"));

11948 pathOffset += 13;

11949 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

11950 pathOffset = path.length;

11951 unittest.expect(subPart, unittest.equals("$arg_targetPool"));

11952

11953 var query = (req.url).query;

11954 var queryOffset = 0;

11955 var queryMap = {};

11956 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

11957 parseBool(n) {

11958 if (n == "true") return true;

11959 if (n == "false") return false;

11960 if (n == null) return null;

11961 throw new core.ArgumentError("Invalid boolean: $n");

11962 }

11963 if (query.length > 0) {

11964 for (var part in query.split("&")) {

11965 var keyvalue = part.split("=");

11966 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

11967 }

11968 }

11969

11970

11971 var h = {

11972 "content-type" : "application/json; charset=utf-8",

11973 };

11974 var resp = convert.JSON.encode(buildOperation());

11975 return new async.Future.value(common_test.stringResponse(200, h, resp));

11976 }), true);

11977 res.delete(arg_project, arg_region, arg_targetPool).then(unittest.expectAs ync(((api.Operation response) {

11978 checkOperation(response);

11979 })));

11980 });

11981

11982 unittest.test("method--get", () {

11983

11984 var mock = new common_test.HttpServerMock();

11985 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

11986 var arg_project = "foo";

11987 var arg_region = "foo";

11988 var arg_targetPool = "foo";

11989 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

11990 var path = (req.url).path;

11991 var pathOffset = 0;

11992 var index;

11993 var subPart;

11994 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

11995 pathOffset += 21;

11996 index = path.indexOf("/regions/", pathOffset);

11997 unittest.expect(index >= 0, unittest.isTrue);

11998 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

11999 pathOffset = index;

12000 unittest.expect(subPart, unittest.equals("$arg_project"));

12001 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

12002 pathOffset += 9;

12003 index = path.indexOf("/targetPools/", pathOffset);

12004 unittest.expect(index >= 0, unittest.isTrue);

12005 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12006 pathOffset = index;

12007 unittest.expect(subPart, unittest.equals("$arg_region"));

12008 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/targetPools/"));

12009 pathOffset += 13;

12010 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

12011 pathOffset = path.length;

12012 unittest.expect(subPart, unittest.equals("$arg_targetPool"));

12013

12014 var query = (req.url).query;

12015 var queryOffset = 0;

12016 var queryMap = {};

12017 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12018 parseBool(n) {

12019 if (n == "true") return true;

12020 if (n == "false") return false;

12021 if (n == null) return null;

12022 throw new core.ArgumentError("Invalid boolean: $n");

12023 }

12024 if (query.length > 0) {

12025 for (var part in query.split("&")) {

12026 var keyvalue = part.split("=");

12027 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12028 }

12029 }

12030

12031

12032 var h = {

12033 "content-type" : "application/json; charset=utf-8",

12034 };

12035 var resp = convert.JSON.encode(buildTargetPool());

12036 return new async.Future.value(common_test.stringResponse(200, h, resp));

12037 }), true);

12038 res.get(arg_project, arg_region, arg_targetPool).then(unittest.expectAsync (((api.TargetPool response) {

12039 checkTargetPool(response);

12040 })));

12041 });

12042

12043 unittest.test("method--getHealth", () {

12044

12045 var mock = new common_test.HttpServerMock();

12046 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

12047 var arg_request = buildInstanceReference();

12048 var arg_project = "foo";

12049 var arg_region = "foo";

12050 var arg_targetPool = "foo";

12051 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12052 var obj = new api.InstanceReference.fromJson(json);

12053 checkInstanceReference(obj);

12054

12055 var path = (req.url).path;

12056 var pathOffset = 0;

12057 var index;

12058 var subPart;

12059 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12060 pathOffset += 21;

12061 index = path.indexOf("/regions/", pathOffset);

12062 unittest.expect(index >= 0, unittest.isTrue);

12063 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12064 pathOffset = index;

12065 unittest.expect(subPart, unittest.equals("$arg_project"));

12066 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

12067 pathOffset += 9;

12068 index = path.indexOf("/targetPools/", pathOffset);

12069 unittest.expect(index >= 0, unittest.isTrue);

12070 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12071 pathOffset = index;

12072 unittest.expect(subPart, unittest.equals("$arg_region"));

12073 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/targetPools/"));

12074 pathOffset += 13;

12075 index = path.indexOf("/getHealth", pathOffset);

12076 unittest.expect(index >= 0, unittest.isTrue);

12077 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12078 pathOffset = index;

12079 unittest.expect(subPart, unittest.equals("$arg_targetPool"));

12080 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/getHealth"));

12081 pathOffset += 10;

12082

12083 var query = (req.url).query;

12084 var queryOffset = 0;

12085 var queryMap = {};

12086 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12087 parseBool(n) {

12088 if (n == "true") return true;

12089 if (n == "false") return false;

12090 if (n == null) return null;

12091 throw new core.ArgumentError("Invalid boolean: $n");

12092 }

12093 if (query.length > 0) {

12094 for (var part in query.split("&")) {

12095 var keyvalue = part.split("=");

12096 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12097 }

12098 }

12099

12100

12101 var h = {

12102 "content-type" : "application/json; charset=utf-8",

12103 };

12104 var resp = convert.JSON.encode(buildTargetPoolInstanceHealth());

12105 return new async.Future.value(common_test.stringResponse(200, h, resp));

12106 }), true);

12107 res.getHealth(arg_request, arg_project, arg_region, arg_targetPool).then(u nittest.expectAsync(((api.TargetPoolInstanceHealth response) {

12108 checkTargetPoolInstanceHealth(response);

12109 })));

12110 });

12111

12112 unittest.test("method--insert", () {

12113

12114 var mock = new common_test.HttpServerMock();

12115 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

12116 var arg_request = buildTargetPool();

12117 var arg_project = "foo";

12118 var arg_region = "foo";

12119 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12120 var obj = new api.TargetPool.fromJson(json);

12121 checkTargetPool(obj);

12122

12123 var path = (req.url).path;

12124 var pathOffset = 0;

12125 var index;

12126 var subPart;

12127 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12128 pathOffset += 21;

12129 index = path.indexOf("/regions/", pathOffset);

12130 unittest.expect(index >= 0, unittest.isTrue);

12131 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12132 pathOffset = index;

12133 unittest.expect(subPart, unittest.equals("$arg_project"));

12134 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

12135 pathOffset += 9;

12136 index = path.indexOf("/targetPools", pathOffset);

12137 unittest.expect(index >= 0, unittest.isTrue);

12138 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12139 pathOffset = index;

12140 unittest.expect(subPart, unittest.equals("$arg_region"));

12141 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/targetPools"));

12142 pathOffset += 12;

12143

12144 var query = (req.url).query;

12145 var queryOffset = 0;

12146 var queryMap = {};

12147 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12148 parseBool(n) {

12149 if (n == "true") return true;

12150 if (n == "false") return false;

12151 if (n == null) return null;

12152 throw new core.ArgumentError("Invalid boolean: $n");

12153 }

12154 if (query.length > 0) {

12155 for (var part in query.split("&")) {

12156 var keyvalue = part.split("=");

12157 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12158 }

12159 }

12160

12161

12162 var h = {

12163 "content-type" : "application/json; charset=utf-8",

12164 };

12165 var resp = convert.JSON.encode(buildOperation());

12166 return new async.Future.value(common_test.stringResponse(200, h, resp));

12167 }), true);

12168 res.insert(arg_request, arg_project, arg_region).then(unittest.expectAsync (((api.Operation response) {

12169 checkOperation(response);

12170 })));

12171 });

12172

12173 unittest.test("method--list", () {

12174

12175 var mock = new common_test.HttpServerMock();

12176 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

12177 var arg_project = "foo";

12178 var arg_region = "foo";

12179 var arg_filter = "foo";

12180 var arg_maxResults = 42;

12181 var arg_pageToken = "foo";

12182 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12183 var path = (req.url).path;

12184 var pathOffset = 0;

12185 var index;

12186 var subPart;

12187 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12188 pathOffset += 21;

12189 index = path.indexOf("/regions/", pathOffset);

12190 unittest.expect(index >= 0, unittest.isTrue);

12191 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12192 pathOffset = index;

12193 unittest.expect(subPart, unittest.equals("$arg_project"));

12194 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

12195 pathOffset += 9;

12196 index = path.indexOf("/targetPools", pathOffset);

12197 unittest.expect(index >= 0, unittest.isTrue);

12198 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12199 pathOffset = index;

12200 unittest.expect(subPart, unittest.equals("$arg_region"));

12201 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/targetPools"));

12202 pathOffset += 12;

12203

12204 var query = (req.url).query;

12205 var queryOffset = 0;

12206 var queryMap = {};

12207 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12208 parseBool(n) {

12209 if (n == "true") return true;

12210 if (n == "false") return false;

12211 if (n == null) return null;

12212 throw new core.ArgumentError("Invalid boolean: $n");

12213 }

12214 if (query.length > 0) {

12215 for (var part in query.split("&")) {

12216 var keyvalue = part.split("=");

12217 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12218 }

12219 }

12220 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

12221 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

12222 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

12223

12224

12225 var h = {

12226 "content-type" : "application/json; charset=utf-8",

12227 };

12228 var resp = convert.JSON.encode(buildTargetPoolList());

12229 return new async.Future.value(common_test.stringResponse(200, h, resp));

12230 }), true);

12231 res.list(arg_project, arg_region, filter: arg_filter, maxResults: arg_maxR esults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.TargetPoolList response) {

12232 checkTargetPoolList(response);

12233 })));

12234 });

12235

12236 unittest.test("method--removeHealthCheck", () {

12237

12238 var mock = new common_test.HttpServerMock();

12239 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

12240 var arg_request = buildTargetPoolsRemoveHealthCheckRequest();

12241 var arg_project = "foo";

12242 var arg_region = "foo";

12243 var arg_targetPool = "foo";

12244 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12245 var obj = new api.TargetPoolsRemoveHealthCheckRequest.fromJson(json);

12246 checkTargetPoolsRemoveHealthCheckRequest(obj);

12247

12248 var path = (req.url).path;

12249 var pathOffset = 0;

12250 var index;

12251 var subPart;

12252 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12253 pathOffset += 21;

12254 index = path.indexOf("/regions/", pathOffset);

12255 unittest.expect(index >= 0, unittest.isTrue);

12256 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12257 pathOffset = index;

12258 unittest.expect(subPart, unittest.equals("$arg_project"));

12259 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

12260 pathOffset += 9;

12261 index = path.indexOf("/targetPools/", pathOffset);

12262 unittest.expect(index >= 0, unittest.isTrue);

12263 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12264 pathOffset = index;

12265 unittest.expect(subPart, unittest.equals("$arg_region"));

12266 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/targetPools/"));

12267 pathOffset += 13;

12268 index = path.indexOf("/removeHealthCheck", pathOffset);

12269 unittest.expect(index >= 0, unittest.isTrue);

12270 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12271 pathOffset = index;

12272 unittest.expect(subPart, unittest.equals("$arg_targetPool"));

12273 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/removeHealthCheck"));

12274 pathOffset += 18;

12275

12276 var query = (req.url).query;

12277 var queryOffset = 0;

12278 var queryMap = {};

12279 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12280 parseBool(n) {

12281 if (n == "true") return true;

12282 if (n == "false") return false;

12283 if (n == null) return null;

12284 throw new core.ArgumentError("Invalid boolean: $n");

12285 }

12286 if (query.length > 0) {

12287 for (var part in query.split("&")) {

12288 var keyvalue = part.split("=");

12289 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12290 }

12291 }

12292

12293

12294 var h = {

12295 "content-type" : "application/json; charset=utf-8",

12296 };

12297 var resp = convert.JSON.encode(buildOperation());

12298 return new async.Future.value(common_test.stringResponse(200, h, resp));

12299 }), true);

12300 res.removeHealthCheck(arg_request, arg_project, arg_region, arg_targetPool ).then(unittest.expectAsync(((api.Operation response) {

12301 checkOperation(response);

12302 })));

12303 });

12304

12305 unittest.test("method--removeInstance", () {

12306

12307 var mock = new common_test.HttpServerMock();

12308 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

12309 var arg_request = buildTargetPoolsRemoveInstanceRequest();

12310 var arg_project = "foo";

12311 var arg_region = "foo";

12312 var arg_targetPool = "foo";

12313 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12314 var obj = new api.TargetPoolsRemoveInstanceRequest.fromJson(json);

12315 checkTargetPoolsRemoveInstanceRequest(obj);

12316

12317 var path = (req.url).path;

12318 var pathOffset = 0;

12319 var index;

12320 var subPart;

12321 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12322 pathOffset += 21;

12323 index = path.indexOf("/regions/", pathOffset);

12324 unittest.expect(index >= 0, unittest.isTrue);

12325 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12326 pathOffset = index;

12327 unittest.expect(subPart, unittest.equals("$arg_project"));

12328 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

12329 pathOffset += 9;

12330 index = path.indexOf("/targetPools/", pathOffset);

12331 unittest.expect(index >= 0, unittest.isTrue);

12332 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12333 pathOffset = index;

12334 unittest.expect(subPart, unittest.equals("$arg_region"));

12335 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/targetPools/"));

12336 pathOffset += 13;

12337 index = path.indexOf("/removeInstance", pathOffset);

12338 unittest.expect(index >= 0, unittest.isTrue);

12339 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12340 pathOffset = index;

12341 unittest.expect(subPart, unittest.equals("$arg_targetPool"));

12342 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/removeInstance"));

12343 pathOffset += 15;

12344

12345 var query = (req.url).query;

12346 var queryOffset = 0;

12347 var queryMap = {};

12348 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12349 parseBool(n) {

12350 if (n == "true") return true;

12351 if (n == "false") return false;

12352 if (n == null) return null;

12353 throw new core.ArgumentError("Invalid boolean: $n");

12354 }

12355 if (query.length > 0) {

12356 for (var part in query.split("&")) {

12357 var keyvalue = part.split("=");

12358 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12359 }

12360 }

12361

12362

12363 var h = {

12364 "content-type" : "application/json; charset=utf-8",

12365 };

12366 var resp = convert.JSON.encode(buildOperation());

12367 return new async.Future.value(common_test.stringResponse(200, h, resp));

12368 }), true);

12369 res.removeInstance(arg_request, arg_project, arg_region, arg_targetPool).t hen(unittest.expectAsync(((api.Operation response) {

12370 checkOperation(response);

12371 })));

12372 });

12373

12374 unittest.test("method--setBackup", () {

12375

12376 var mock = new common_test.HttpServerMock();

12377 api.TargetPoolsResourceApi res = new api.ComputeApi(mock).targetPools;

12378 var arg_request = buildTargetReference();

12379 var arg_project = "foo";

12380 var arg_region = "foo";

12381 var arg_targetPool = "foo";

12382 var arg_failoverRatio = 42.0;

12383 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12384 var obj = new api.TargetReference.fromJson(json);

12385 checkTargetReference(obj);

12386

12387 var path = (req.url).path;

12388 var pathOffset = 0;

12389 var index;

12390 var subPart;

12391 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12392 pathOffset += 21;

12393 index = path.indexOf("/regions/", pathOffset);

12394 unittest.expect(index >= 0, unittest.isTrue);

12395 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12396 pathOffset = index;

12397 unittest.expect(subPart, unittest.equals("$arg_project"));

12398 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/regions/"));

12399 pathOffset += 9;

12400 index = path.indexOf("/targetPools/", pathOffset);

12401 unittest.expect(index >= 0, unittest.isTrue);

12402 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12403 pathOffset = index;

12404 unittest.expect(subPart, unittest.equals("$arg_region"));

12405 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("/targetPools/"));

12406 pathOffset += 13;

12407 index = path.indexOf("/setBackup", pathOffset);

12408 unittest.expect(index >= 0, unittest.isTrue);

12409 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12410 pathOffset = index;

12411 unittest.expect(subPart, unittest.equals("$arg_targetPool"));

12412 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/setBackup"));

12413 pathOffset += 10;

12414

12415 var query = (req.url).query;

12416 var queryOffset = 0;

12417 var queryMap = {};

12418 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12419 parseBool(n) {

12420 if (n == "true") return true;

12421 if (n == "false") return false;

12422 if (n == null) return null;

12423 throw new core.ArgumentError("Invalid boolean: $n");

12424 }

12425 if (query.length > 0) {

12426 for (var part in query.split("&")) {

12427 var keyvalue = part.split("=");

12428 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12429 }

12430 }

12431 unittest.expect(core.num.parse(queryMap["failoverRatio"].first), unittes t.equals(arg_failoverRatio));

12432

12433

12434 var h = {

12435 "content-type" : "application/json; charset=utf-8",

12436 };

12437 var resp = convert.JSON.encode(buildOperation());

12438 return new async.Future.value(common_test.stringResponse(200, h, resp));

12439 }), true);

12440 res.setBackup(arg_request, arg_project, arg_region, arg_targetPool, failov erRatio: arg_failoverRatio).then(unittest.expectAsync(((api.Operation response) {

12441 checkOperation(response);

12442 })));

12443 });

12444

12445 });

12446

12447

12448 unittest.group("resource-UrlMapsResourceApi", () {

12449 unittest.test("method--delete", () {

12450

12451 var mock = new common_test.HttpServerMock();

12452 api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;

12453 var arg_project = "foo";

12454 var arg_urlMap = "foo";

12455 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12456 var path = (req.url).path;

12457 var pathOffset = 0;

12458 var index;

12459 var subPart;

12460 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12461 pathOffset += 21;

12462 index = path.indexOf("/global/urlMaps/", pathOffset);

12463 unittest.expect(index >= 0, unittest.isTrue);

12464 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12465 pathOffset = index;

12466 unittest.expect(subPart, unittest.equals("$arg_project"));

12467 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/global/urlMaps/"));

12468 pathOffset += 16;

12469 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

12470 pathOffset = path.length;

12471 unittest.expect(subPart, unittest.equals("$arg_urlMap"));

12472

12473 var query = (req.url).query;

12474 var queryOffset = 0;

12475 var queryMap = {};

12476 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12477 parseBool(n) {

12478 if (n == "true") return true;

12479 if (n == "false") return false;

12480 if (n == null) return null;

12481 throw new core.ArgumentError("Invalid boolean: $n");

12482 }

12483 if (query.length > 0) {

12484 for (var part in query.split("&")) {

12485 var keyvalue = part.split("=");

12486 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12487 }

12488 }

12489

12490

12491 var h = {

12492 "content-type" : "application/json; charset=utf-8",

12493 };

12494 var resp = convert.JSON.encode(buildOperation());

12495 return new async.Future.value(common_test.stringResponse(200, h, resp));

12496 }), true);

12497 res.delete(arg_project, arg_urlMap).then(unittest.expectAsync(((api.Operat ion response) {

12498 checkOperation(response);

12499 })));

12500 });

12501

12502 unittest.test("method--get", () {

12503

12504 var mock = new common_test.HttpServerMock();

12505 api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;

12506 var arg_project = "foo";

12507 var arg_urlMap = "foo";

12508 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12509 var path = (req.url).path;

12510 var pathOffset = 0;

12511 var index;

12512 var subPart;

12513 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12514 pathOffset += 21;

12515 index = path.indexOf("/global/urlMaps/", pathOffset);

12516 unittest.expect(index >= 0, unittest.isTrue);

12517 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12518 pathOffset = index;

12519 unittest.expect(subPart, unittest.equals("$arg_project"));

12520 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/global/urlMaps/"));

12521 pathOffset += 16;

12522 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

12523 pathOffset = path.length;

12524 unittest.expect(subPart, unittest.equals("$arg_urlMap"));

12525

12526 var query = (req.url).query;

12527 var queryOffset = 0;

12528 var queryMap = {};

12529 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12530 parseBool(n) {

12531 if (n == "true") return true;

12532 if (n == "false") return false;

12533 if (n == null) return null;

12534 throw new core.ArgumentError("Invalid boolean: $n");

12535 }

12536 if (query.length > 0) {

12537 for (var part in query.split("&")) {

12538 var keyvalue = part.split("=");

12539 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12540 }

12541 }

12542

12543

12544 var h = {

12545 "content-type" : "application/json; charset=utf-8",

12546 };

12547 var resp = convert.JSON.encode(buildUrlMap());

12548 return new async.Future.value(common_test.stringResponse(200, h, resp));

12549 }), true);

12550 res.get(arg_project, arg_urlMap).then(unittest.expectAsync(((api.UrlMap re sponse) {

12551 checkUrlMap(response);

12552 })));

12553 });

12554

12555 unittest.test("method--insert", () {

12556

12557 var mock = new common_test.HttpServerMock();

12558 api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;

12559 var arg_request = buildUrlMap();

12560 var arg_project = "foo";

12561 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12562 var obj = new api.UrlMap.fromJson(json);

12563 checkUrlMap(obj);

12564

12565 var path = (req.url).path;

12566 var pathOffset = 0;

12567 var index;

12568 var subPart;

12569 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12570 pathOffset += 21;

12571 index = path.indexOf("/global/urlMaps", pathOffset);

12572 unittest.expect(index >= 0, unittest.isTrue);

12573 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12574 pathOffset = index;

12575 unittest.expect(subPart, unittest.equals("$arg_project"));

12576 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/global/urlMaps"));

12577 pathOffset += 15;

12578

12579 var query = (req.url).query;

12580 var queryOffset = 0;

12581 var queryMap = {};

12582 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12583 parseBool(n) {

12584 if (n == "true") return true;

12585 if (n == "false") return false;

12586 if (n == null) return null;

12587 throw new core.ArgumentError("Invalid boolean: $n");

12588 }

12589 if (query.length > 0) {

12590 for (var part in query.split("&")) {

12591 var keyvalue = part.split("=");

12592 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12593 }

12594 }

12595

12596

12597 var h = {

12598 "content-type" : "application/json; charset=utf-8",

12599 };

12600 var resp = convert.JSON.encode(buildOperation());

12601 return new async.Future.value(common_test.stringResponse(200, h, resp));

12602 }), true);

12603 res.insert(arg_request, arg_project).then(unittest.expectAsync(((api.Opera tion response) {

12604 checkOperation(response);

12605 })));

12606 });

12607

12608 unittest.test("method--list", () {

12609

12610 var mock = new common_test.HttpServerMock();

12611 api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;

12612 var arg_project = "foo";

12613 var arg_filter = "foo";

12614 var arg_maxResults = 42;

12615 var arg_pageToken = "foo";

12616 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12617 var path = (req.url).path;

12618 var pathOffset = 0;

12619 var index;

12620 var subPart;

12621 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12622 pathOffset += 21;

12623 index = path.indexOf("/global/urlMaps", pathOffset);

12624 unittest.expect(index >= 0, unittest.isTrue);

12625 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12626 pathOffset = index;

12627 unittest.expect(subPart, unittest.equals("$arg_project"));

12628 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/global/urlMaps"));

12629 pathOffset += 15;

12630

12631 var query = (req.url).query;

12632 var queryOffset = 0;

12633 var queryMap = {};

12634 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12635 parseBool(n) {

12636 if (n == "true") return true;

12637 if (n == "false") return false;

12638 if (n == null) return null;

12639 throw new core.ArgumentError("Invalid boolean: $n");

12640 }

12641 if (query.length > 0) {

12642 for (var part in query.split("&")) {

12643 var keyvalue = part.split("=");

12644 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12645 }

12646 }

12647 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

12648 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

12649 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

12650

12651

12652 var h = {

12653 "content-type" : "application/json; charset=utf-8",

12654 };

12655 var resp = convert.JSON.encode(buildUrlMapList());

12656 return new async.Future.value(common_test.stringResponse(200, h, resp));

12657 }), true);

12658 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.UrlMapList response) {

12659 checkUrlMapList(response);

12660 })));

12661 });

12662

12663 unittest.test("method--patch", () {

12664

12665 var mock = new common_test.HttpServerMock();

12666 api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;

12667 var arg_request = buildUrlMap();

12668 var arg_project = "foo";

12669 var arg_urlMap = "foo";

12670 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12671 var obj = new api.UrlMap.fromJson(json);

12672 checkUrlMap(obj);

12673

12674 var path = (req.url).path;

12675 var pathOffset = 0;

12676 var index;

12677 var subPart;

12678 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12679 pathOffset += 21;

12680 index = path.indexOf("/global/urlMaps/", pathOffset);

12681 unittest.expect(index >= 0, unittest.isTrue);

12682 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12683 pathOffset = index;

12684 unittest.expect(subPart, unittest.equals("$arg_project"));

12685 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/global/urlMaps/"));

12686 pathOffset += 16;

12687 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

12688 pathOffset = path.length;

12689 unittest.expect(subPart, unittest.equals("$arg_urlMap"));

12690

12691 var query = (req.url).query;

12692 var queryOffset = 0;

12693 var queryMap = {};

12694 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12695 parseBool(n) {

12696 if (n == "true") return true;

12697 if (n == "false") return false;

12698 if (n == null) return null;

12699 throw new core.ArgumentError("Invalid boolean: $n");

12700 }

12701 if (query.length > 0) {

12702 for (var part in query.split("&")) {

12703 var keyvalue = part.split("=");

12704 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12705 }

12706 }

12707

12708

12709 var h = {

12710 "content-type" : "application/json; charset=utf-8",

12711 };

12712 var resp = convert.JSON.encode(buildOperation());

12713 return new async.Future.value(common_test.stringResponse(200, h, resp));

12714 }), true);

12715 res.patch(arg_request, arg_project, arg_urlMap).then(unittest.expectAsync( ((api.Operation response) {

12716 checkOperation(response);

12717 })));

12718 });

12719

12720 unittest.test("method--update", () {

12721

12722 var mock = new common_test.HttpServerMock();

12723 api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;

12724 var arg_request = buildUrlMap();

12725 var arg_project = "foo";

12726 var arg_urlMap = "foo";

12727 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12728 var obj = new api.UrlMap.fromJson(json);

12729 checkUrlMap(obj);

12730

12731 var path = (req.url).path;

12732 var pathOffset = 0;

12733 var index;

12734 var subPart;

12735 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12736 pathOffset += 21;

12737 index = path.indexOf("/global/urlMaps/", pathOffset);

12738 unittest.expect(index >= 0, unittest.isTrue);

12739 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12740 pathOffset = index;

12741 unittest.expect(subPart, unittest.equals("$arg_project"));

12742 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/global/urlMaps/"));

12743 pathOffset += 16;

12744 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

12745 pathOffset = path.length;

12746 unittest.expect(subPart, unittest.equals("$arg_urlMap"));

12747

12748 var query = (req.url).query;

12749 var queryOffset = 0;

12750 var queryMap = {};

12751 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12752 parseBool(n) {

12753 if (n == "true") return true;

12754 if (n == "false") return false;

12755 if (n == null) return null;

12756 throw new core.ArgumentError("Invalid boolean: $n");

12757 }

12758 if (query.length > 0) {

12759 for (var part in query.split("&")) {

12760 var keyvalue = part.split("=");

12761 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12762 }

12763 }

12764

12765

12766 var h = {

12767 "content-type" : "application/json; charset=utf-8",

12768 };

12769 var resp = convert.JSON.encode(buildOperation());

12770 return new async.Future.value(common_test.stringResponse(200, h, resp));

12771 }), true);

12772 res.update(arg_request, arg_project, arg_urlMap).then(unittest.expectAsync (((api.Operation response) {

12773 checkOperation(response);

12774 })));

12775 });

12776

12777 unittest.test("method--validate", () {

12778

12779 var mock = new common_test.HttpServerMock();

12780 api.UrlMapsResourceApi res = new api.ComputeApi(mock).urlMaps;

12781 var arg_request = buildUrlMapsValidateRequest();

12782 var arg_project = "foo";

12783 var arg_urlMap = "foo";

12784 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12785 var obj = new api.UrlMapsValidateRequest.fromJson(json);

12786 checkUrlMapsValidateRequest(obj);

12787

12788 var path = (req.url).path;

12789 var pathOffset = 0;

12790 var index;

12791 var subPart;

12792 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12793 pathOffset += 21;

12794 index = path.indexOf("/global/urlMaps/", pathOffset);

12795 unittest.expect(index >= 0, unittest.isTrue);

12796 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12797 pathOffset = index;

12798 unittest.expect(subPart, unittest.equals("$arg_project"));

12799 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/global/urlMaps/"));

12800 pathOffset += 16;

12801 index = path.indexOf("/validate", pathOffset);

12802 unittest.expect(index >= 0, unittest.isTrue);

12803 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12804 pathOffset = index;

12805 unittest.expect(subPart, unittest.equals("$arg_urlMap"));

12806 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/validate"));

12807 pathOffset += 9;

12808

12809 var query = (req.url).query;

12810 var queryOffset = 0;

12811 var queryMap = {};

12812 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12813 parseBool(n) {

12814 if (n == "true") return true;

12815 if (n == "false") return false;

12816 if (n == null) return null;

12817 throw new core.ArgumentError("Invalid boolean: $n");

12818 }

12819 if (query.length > 0) {

12820 for (var part in query.split("&")) {

12821 var keyvalue = part.split("=");

12822 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12823 }

12824 }

12825

12826

12827 var h = {

12828 "content-type" : "application/json; charset=utf-8",

12829 };

12830 var resp = convert.JSON.encode(buildUrlMapsValidateResponse());

12831 return new async.Future.value(common_test.stringResponse(200, h, resp));

12832 }), true);

12833 res.validate(arg_request, arg_project, arg_urlMap).then(unittest.expectAsy nc(((api.UrlMapsValidateResponse response) {

12834 checkUrlMapsValidateResponse(response);

12835 })));

12836 });

12837

12838 });

12839

12840

12841 unittest.group("resource-ZoneOperationsResourceApi", () {

12842 unittest.test("method--delete", () {

12843

12844 var mock = new common_test.HttpServerMock();

12845 api.ZoneOperationsResourceApi res = new api.ComputeApi(mock).zoneOperation s;

12846 var arg_project = "foo";

12847 var arg_zone = "foo";

12848 var arg_operation = "foo";

12849 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12850 var path = (req.url).path;

12851 var pathOffset = 0;

12852 var index;

12853 var subPart;

12854 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12855 pathOffset += 21;

12856 index = path.indexOf("/zones/", pathOffset);

12857 unittest.expect(index >= 0, unittest.isTrue);

12858 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12859 pathOffset = index;

12860 unittest.expect(subPart, unittest.equals("$arg_project"));

12861 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

12862 pathOffset += 7;

12863 index = path.indexOf("/operations/", pathOffset);

12864 unittest.expect(index >= 0, unittest.isTrue);

12865 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12866 pathOffset = index;

12867 unittest.expect(subPart, unittest.equals("$arg_zone"));

12868 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/operations/"));

12869 pathOffset += 12;

12870 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

12871 pathOffset = path.length;

12872 unittest.expect(subPart, unittest.equals("$arg_operation"));

12873

12874 var query = (req.url).query;

12875 var queryOffset = 0;

12876 var queryMap = {};

12877 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12878 parseBool(n) {

12879 if (n == "true") return true;

12880 if (n == "false") return false;

12881 if (n == null) return null;

12882 throw new core.ArgumentError("Invalid boolean: $n");

12883 }

12884 if (query.length > 0) {

12885 for (var part in query.split("&")) {

12886 var keyvalue = part.split("=");

12887 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12888 }

12889 }

12890

12891

12892 var h = {

12893 "content-type" : "application/json; charset=utf-8",

12894 };

12895 var resp = "";

12896 return new async.Future.value(common_test.stringResponse(200, h, resp));

12897 }), true);

12898 res.delete(arg_project, arg_zone, arg_operation).then(unittest.expectAsync ((_) {}));

12899 });

12900

12901 unittest.test("method--get", () {

12902

12903 var mock = new common_test.HttpServerMock();

12904 api.ZoneOperationsResourceApi res = new api.ComputeApi(mock).zoneOperation s;

12905 var arg_project = "foo";

12906 var arg_zone = "foo";

12907 var arg_operation = "foo";

12908 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12909 var path = (req.url).path;

12910 var pathOffset = 0;

12911 var index;

12912 var subPart;

12913 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12914 pathOffset += 21;

12915 index = path.indexOf("/zones/", pathOffset);

12916 unittest.expect(index >= 0, unittest.isTrue);

12917 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12918 pathOffset = index;

12919 unittest.expect(subPart, unittest.equals("$arg_project"));

12920 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

12921 pathOffset += 7;

12922 index = path.indexOf("/operations/", pathOffset);

12923 unittest.expect(index >= 0, unittest.isTrue);

12924 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12925 pathOffset = index;

12926 unittest.expect(subPart, unittest.equals("$arg_zone"));

12927 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/operations/"));

12928 pathOffset += 12;

12929 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

12930 pathOffset = path.length;

12931 unittest.expect(subPart, unittest.equals("$arg_operation"));

12932

12933 var query = (req.url).query;

12934 var queryOffset = 0;

12935 var queryMap = {};

12936 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12937 parseBool(n) {

12938 if (n == "true") return true;

12939 if (n == "false") return false;

12940 if (n == null) return null;

12941 throw new core.ArgumentError("Invalid boolean: $n");

12942 }

12943 if (query.length > 0) {

12944 for (var part in query.split("&")) {

12945 var keyvalue = part.split("=");

12946 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

12947 }

12948 }

12949

12950

12951 var h = {

12952 "content-type" : "application/json; charset=utf-8",

12953 };

12954 var resp = convert.JSON.encode(buildOperation());

12955 return new async.Future.value(common_test.stringResponse(200, h, resp));

12956 }), true);

12957 res.get(arg_project, arg_zone, arg_operation).then(unittest.expectAsync((( api.Operation response) {

12958 checkOperation(response);

12959 })));

12960 });

12961

12962 unittest.test("method--list", () {

12963

12964 var mock = new common_test.HttpServerMock();

12965 api.ZoneOperationsResourceApi res = new api.ComputeApi(mock).zoneOperation s;

12966 var arg_project = "foo";

12967 var arg_zone = "foo";

12968 var arg_filter = "foo";

12969 var arg_maxResults = 42;

12970 var arg_pageToken = "foo";

12971 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

12972 var path = (req.url).path;

12973 var pathOffset = 0;

12974 var index;

12975 var subPart;

12976 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

12977 pathOffset += 21;

12978 index = path.indexOf("/zones/", pathOffset);

12979 unittest.expect(index >= 0, unittest.isTrue);

12980 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12981 pathOffset = index;

12982 unittest.expect(subPart, unittest.equals("$arg_project"));

12983 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

12984 pathOffset += 7;

12985 index = path.indexOf("/operations", pathOffset);

12986 unittest.expect(index >= 0, unittest.isTrue);

12987 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

12988 pathOffset = index;

12989 unittest.expect(subPart, unittest.equals("$arg_zone"));

12990 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/operations"));

12991 pathOffset += 11;

12992

12993 var query = (req.url).query;

12994 var queryOffset = 0;

12995 var queryMap = {};

12996 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

12997 parseBool(n) {

12998 if (n == "true") return true;

12999 if (n == "false") return false;

13000 if (n == null) return null;

13001 throw new core.ArgumentError("Invalid boolean: $n");

13002 }

13003 if (query.length > 0) {

13004 for (var part in query.split("&")) {

13005 var keyvalue = part.split("=");

13006 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

13007 }

13008 }

13009 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

13010 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

13011 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

13012

13013

13014 var h = {

13015 "content-type" : "application/json; charset=utf-8",

13016 };

13017 var resp = convert.JSON.encode(buildOperationList());

13018 return new async.Future.value(common_test.stringResponse(200, h, resp));

13019 }), true);

13020 res.list(arg_project, arg_zone, filter: arg_filter, maxResults: arg_maxRes ults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.OperationList re sponse) {

13021 checkOperationList(response);

13022 })));

13023 });

13024

13025 });

13026

13027

13028 unittest.group("resource-ZonesResourceApi", () {

13029 unittest.test("method--get", () {

13030

13031 var mock = new common_test.HttpServerMock();

13032 api.ZonesResourceApi res = new api.ComputeApi(mock).zones;

13033 var arg_project = "foo";

13034 var arg_zone = "foo";

13035 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

13036 var path = (req.url).path;

13037 var pathOffset = 0;

13038 var index;

13039 var subPart;

13040 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

13041 pathOffset += 21;

13042 index = path.indexOf("/zones/", pathOffset);

13043 unittest.expect(index >= 0, unittest.isTrue);

13044 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

13045 pathOffset = index;

13046 unittest.expect(subPart, unittest.equals("$arg_project"));

13047 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/zones/"));

13048 pathOffset += 7;

13049 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

13050 pathOffset = path.length;

13051 unittest.expect(subPart, unittest.equals("$arg_zone"));

13052

13053 var query = (req.url).query;

13054 var queryOffset = 0;

13055 var queryMap = {};

13056 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

13057 parseBool(n) {

13058 if (n == "true") return true;

13059 if (n == "false") return false;

13060 if (n == null) return null;

13061 throw new core.ArgumentError("Invalid boolean: $n");

13062 }

13063 if (query.length > 0) {

13064 for (var part in query.split("&")) {

13065 var keyvalue = part.split("=");

13066 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

13067 }

13068 }

13069

13070

13071 var h = {

13072 "content-type" : "application/json; charset=utf-8",

13073 };

13074 var resp = convert.JSON.encode(buildZone());

13075 return new async.Future.value(common_test.stringResponse(200, h, resp));

13076 }), true);

13077 res.get(arg_project, arg_zone).then(unittest.expectAsync(((api.Zone respon se) {

13078 checkZone(response);

13079 })));

13080 });

13081

13082 unittest.test("method--list", () {

13083

13084 var mock = new common_test.HttpServerMock();

13085 api.ZonesResourceApi res = new api.ComputeApi(mock).zones;

13086 var arg_project = "foo";

13087 var arg_filter = "foo";

13088 var arg_maxResults = 42;

13089 var arg_pageToken = "foo";

13090 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

13091 var path = (req.url).path;

13092 var pathOffset = 0;

13093 var index;

13094 var subPart;

13095 unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.eq uals("/compute/v1/projects/"));

13096 pathOffset += 21;

13097 index = path.indexOf("/zones", pathOffset);

13098 unittest.expect(index >= 0, unittest.isTrue);

13099 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

13100 pathOffset = index;

13101 unittest.expect(subPart, unittest.equals("$arg_project"));

13102 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("/zones"));

13103 pathOffset += 6;

13104

13105 var query = (req.url).query;

13106 var queryOffset = 0;

13107 var queryMap = {};

13108 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

13109 parseBool(n) {

13110 if (n == "true") return true;

13111 if (n == "false") return false;

13112 if (n == null) return null;

13113 throw new core.ArgumentError("Invalid boolean: $n");

13114 }

13115 if (query.length > 0) {

13116 for (var part in query.split("&")) {

13117 var keyvalue = part.split("=");

13118 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

13119 }

13120 }

13121 unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));

13122 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

13123 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

13124

13125

13126 var h = {

13127 "content-type" : "application/json; charset=utf-8",

13128 };

13129 var resp = convert.JSON.encode(buildZoneList());

13130 return new async.Future.value(common_test.stringResponse(200, h, resp));

13131 }), true);

13132 res.list(arg_project, filter: arg_filter, maxResults: arg_maxResults, page Token: arg_pageToken).then(unittest.expectAsync(((api.ZoneList response) {

13133 checkZoneList(response);

13134 })));

13135 });

13136

13137 });

13138

13139

13140 }

13141

OLD	NEW

« no previous file with comments | « generated/googleapis/test/civicinfo/v1_test.dart ('k') | generated/googleapis/test/compute/v1_test.dart » ('j') | no next file with comments »