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

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

16

17

18

19 buildUnnamed482() {

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

21 o.add(buildBucketAccessControl());

22 o.add(buildBucketAccessControl());

23 return o;

24 }

25

26 checkUnnamed482(core.List<api.BucketAccessControl> o) {

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

28 checkBucketAccessControl(o[0]);

29 checkBucketAccessControl(o[1]);

30 }

31

32 buildUnnamed483() {

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

34 o.add("foo");

35 o.add("foo");

36 return o;

37 }

38

39 checkUnnamed483(core.List<core.String> o) {

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

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

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

43 }

44

45 buildUnnamed484() {

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

47 o.add("foo");

48 o.add("foo");

49 return o;

50 }

51

52 checkUnnamed484(core.List<core.String> o) {

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

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

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

56 }

57

58 buildUnnamed485() {

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

60 o.add("foo");

61 o.add("foo");

62 return o;

63 }

64

65 checkUnnamed485(core.List<core.String> o) {

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

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

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

69 }

70

71 core.int buildCounterBucketCors = 0;

72 buildBucketCors() {

73 var o = new api.BucketCors();

74 buildCounterBucketCors++;

75 if (buildCounterBucketCors < 3) {

76 o.maxAgeSeconds = 42;

77 o.method = buildUnnamed483();

78 o.origin = buildUnnamed484();

79 o.responseHeader = buildUnnamed485();

80 }

81 buildCounterBucketCors--;

82 return o;

83 }

84

85 checkBucketCors(api.BucketCors o) {

86 buildCounterBucketCors++;

87 if (buildCounterBucketCors < 3) {

88 unittest.expect(o.maxAgeSeconds, unittest.equals(42));

89 checkUnnamed483(o.method);

90 checkUnnamed484(o.origin);

91 checkUnnamed485(o.responseHeader);

92 }

93 buildCounterBucketCors--;

94 }

95

96 buildUnnamed486() {

97 var o = new core.List<api.BucketCors>();

98 o.add(buildBucketCors());

99 o.add(buildBucketCors());

100 return o;

101 }

102

103 checkUnnamed486(core.List<api.BucketCors> o) {

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

105 checkBucketCors(o[0]);

106 checkBucketCors(o[1]);

107 }

108

109 buildUnnamed487() {

110 var o = new core.List<api.ObjectAccessControl>();

111 o.add(buildObjectAccessControl());

112 o.add(buildObjectAccessControl());

113 return o;

114 }

115

116 checkUnnamed487(core.List<api.ObjectAccessControl> o) {

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

118 checkObjectAccessControl(o[0]);

119 checkObjectAccessControl(o[1]);

120 }

121

122 core.int buildCounterBucketLifecycleRuleAction = 0;

123 buildBucketLifecycleRuleAction() {

124 var o = new api.BucketLifecycleRuleAction();

125 buildCounterBucketLifecycleRuleAction++;

126 if (buildCounterBucketLifecycleRuleAction < 3) {

127 o.type = "foo";

128 }

129 buildCounterBucketLifecycleRuleAction--;

130 return o;

131 }

132

133 checkBucketLifecycleRuleAction(api.BucketLifecycleRuleAction o) {

134 buildCounterBucketLifecycleRuleAction++;

135 if (buildCounterBucketLifecycleRuleAction < 3) {

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

137 }

138 buildCounterBucketLifecycleRuleAction--;

139 }

140

141 core.int buildCounterBucketLifecycleRuleCondition = 0;

142 buildBucketLifecycleRuleCondition() {

143 var o = new api.BucketLifecycleRuleCondition();

144 buildCounterBucketLifecycleRuleCondition++;

145 if (buildCounterBucketLifecycleRuleCondition < 3) {

146 o.age = 42;

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

148 o.isLive = true;

149 o.numNewerVersions = 42;

150 }

151 buildCounterBucketLifecycleRuleCondition--;

152 return o;

153 }

154

155 checkBucketLifecycleRuleCondition(api.BucketLifecycleRuleCondition o) {

156 buildCounterBucketLifecycleRuleCondition++;

157 if (buildCounterBucketLifecycleRuleCondition < 3) {

158 unittest.expect(o.age, unittest.equals(42));

159 unittest.expect(o.createdBefore, unittest.equals(core.DateTime.parse("2002-0 2-27T00:00:00")));

160 unittest.expect(o.isLive, unittest.isTrue);

161 unittest.expect(o.numNewerVersions, unittest.equals(42));

162 }

163 buildCounterBucketLifecycleRuleCondition--;

164 }

165

166 core.int buildCounterBucketLifecycleRule = 0;

167 buildBucketLifecycleRule() {

168 var o = new api.BucketLifecycleRule();

169 buildCounterBucketLifecycleRule++;

170 if (buildCounterBucketLifecycleRule < 3) {

171 o.action = buildBucketLifecycleRuleAction();

172 o.condition = buildBucketLifecycleRuleCondition();

173 }

174 buildCounterBucketLifecycleRule--;

175 return o;

176 }

177

178 checkBucketLifecycleRule(api.BucketLifecycleRule o) {

179 buildCounterBucketLifecycleRule++;

180 if (buildCounterBucketLifecycleRule < 3) {

181 checkBucketLifecycleRuleAction(o.action);

182 checkBucketLifecycleRuleCondition(o.condition);

183 }

184 buildCounterBucketLifecycleRule--;

185 }

186

187 buildUnnamed488() {

188 var o = new core.List<api.BucketLifecycleRule>();

189 o.add(buildBucketLifecycleRule());

190 o.add(buildBucketLifecycleRule());

191 return o;

192 }

193

194 checkUnnamed488(core.List<api.BucketLifecycleRule> o) {

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

196 checkBucketLifecycleRule(o[0]);

197 checkBucketLifecycleRule(o[1]);

198 }

199

200 core.int buildCounterBucketLifecycle = 0;

201 buildBucketLifecycle() {

202 var o = new api.BucketLifecycle();

203 buildCounterBucketLifecycle++;

204 if (buildCounterBucketLifecycle < 3) {

205 o.rule = buildUnnamed488();

206 }

207 buildCounterBucketLifecycle--;

208 return o;

209 }

210

211 checkBucketLifecycle(api.BucketLifecycle o) {

212 buildCounterBucketLifecycle++;

213 if (buildCounterBucketLifecycle < 3) {

214 checkUnnamed488(o.rule);

215 }

216 buildCounterBucketLifecycle--;

217 }

218

219 core.int buildCounterBucketLogging = 0;

220 buildBucketLogging() {

221 var o = new api.BucketLogging();

222 buildCounterBucketLogging++;

223 if (buildCounterBucketLogging < 3) {

224 o.logBucket = "foo";

225 o.logObjectPrefix = "foo";

226 }

227 buildCounterBucketLogging--;

228 return o;

229 }

230

231 checkBucketLogging(api.BucketLogging o) {

232 buildCounterBucketLogging++;

233 if (buildCounterBucketLogging < 3) {

234 unittest.expect(o.logBucket, unittest.equals('foo'));

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

236 }

237 buildCounterBucketLogging--;

238 }

239

240 core.int buildCounterBucketOwner = 0;

241 buildBucketOwner() {

242 var o = new api.BucketOwner();

243 buildCounterBucketOwner++;

244 if (buildCounterBucketOwner < 3) {

245 o.entity = "foo";

246 o.entityId = "foo";

247 }

248 buildCounterBucketOwner--;

249 return o;

250 }

251

252 checkBucketOwner(api.BucketOwner o) {

253 buildCounterBucketOwner++;

254 if (buildCounterBucketOwner < 3) {

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

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

257 }

258 buildCounterBucketOwner--;

259 }

260

261 core.int buildCounterBucketVersioning = 0;

262 buildBucketVersioning() {

263 var o = new api.BucketVersioning();

264 buildCounterBucketVersioning++;

265 if (buildCounterBucketVersioning < 3) {

266 o.enabled = true;

267 }

268 buildCounterBucketVersioning--;

269 return o;

270 }

271

272 checkBucketVersioning(api.BucketVersioning o) {

273 buildCounterBucketVersioning++;

274 if (buildCounterBucketVersioning < 3) {

275 unittest.expect(o.enabled, unittest.isTrue);

276 }

277 buildCounterBucketVersioning--;

278 }

279

280 core.int buildCounterBucketWebsite = 0;

281 buildBucketWebsite() {

282 var o = new api.BucketWebsite();

283 buildCounterBucketWebsite++;

284 if (buildCounterBucketWebsite < 3) {

285 o.mainPageSuffix = "foo";

286 o.notFoundPage = "foo";

287 }

288 buildCounterBucketWebsite--;

289 return o;

290 }

291

292 checkBucketWebsite(api.BucketWebsite o) {

293 buildCounterBucketWebsite++;

294 if (buildCounterBucketWebsite < 3) {

295 unittest.expect(o.mainPageSuffix, unittest.equals('foo'));

296 unittest.expect(o.notFoundPage, unittest.equals('foo'));

297 }

298 buildCounterBucketWebsite--;

299 }

300

301 core.int buildCounterBucket = 0;

302 buildBucket() {

303 var o = new api.Bucket();

304 buildCounterBucket++;

305 if (buildCounterBucket < 3) {

306 o.acl = buildUnnamed482();

307 o.cors = buildUnnamed486();

308 o.defaultObjectAcl = buildUnnamed487();

309 o.etag = "foo";

310 o.id = "foo";

311 o.kind = "foo";

312 o.lifecycle = buildBucketLifecycle();

313 o.location = "foo";

314 o.logging = buildBucketLogging();

315 o.metageneration = "foo";

316 o.name = "foo";

317 o.owner = buildBucketOwner();

318 o.projectNumber = "foo";

319 o.selfLink = "foo";

320 o.storageClass = "foo";

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

322 o.versioning = buildBucketVersioning();

323 o.website = buildBucketWebsite();

324 }

325 buildCounterBucket--;

326 return o;

327 }

328

329 checkBucket(api.Bucket o) {

330 buildCounterBucket++;

331 if (buildCounterBucket < 3) {

332 checkUnnamed482(o.acl);

333 checkUnnamed486(o.cors);

334 checkUnnamed487(o.defaultObjectAcl);

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

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

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

338 checkBucketLifecycle(o.lifecycle);

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

340 checkBucketLogging(o.logging);

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

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

343 checkBucketOwner(o.owner);

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

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

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

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

348 checkBucketVersioning(o.versioning);

349 checkBucketWebsite(o.website);

350 }

351 buildCounterBucket--;

352 }

353

354 core.int buildCounterBucketAccessControlProjectTeam = 0;

355 buildBucketAccessControlProjectTeam() {

356 var o = new api.BucketAccessControlProjectTeam();

357 buildCounterBucketAccessControlProjectTeam++;

358 if (buildCounterBucketAccessControlProjectTeam < 3) {

359 o.projectNumber = "foo";

360 o.team = "foo";

361 }

362 buildCounterBucketAccessControlProjectTeam--;

363 return o;

364 }

365

366 checkBucketAccessControlProjectTeam(api.BucketAccessControlProjectTeam o) {

367 buildCounterBucketAccessControlProjectTeam++;

368 if (buildCounterBucketAccessControlProjectTeam < 3) {

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

370 unittest.expect(o.team, unittest.equals('foo'));

371 }

372 buildCounterBucketAccessControlProjectTeam--;

373 }

374

375 core.int buildCounterBucketAccessControl = 0;

376 buildBucketAccessControl() {

377 var o = new api.BucketAccessControl();

378 buildCounterBucketAccessControl++;

379 if (buildCounterBucketAccessControl < 3) {

380 o.bucket = "foo";

381 o.domain = "foo";

382 o.email = "foo";

383 o.entity = "foo";

384 o.entityId = "foo";

385 o.etag = "foo";

386 o.id = "foo";

387 o.kind = "foo";

388 o.projectTeam = buildBucketAccessControlProjectTeam();

389 o.role = "foo";

390 o.selfLink = "foo";

391 }

392 buildCounterBucketAccessControl--;

393 return o;

394 }

395

396 checkBucketAccessControl(api.BucketAccessControl o) {

397 buildCounterBucketAccessControl++;

398 if (buildCounterBucketAccessControl < 3) {

399 unittest.expect(o.bucket, unittest.equals('foo'));

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

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

402 unittest.expect(o.entity, unittest.equals('foo'));

403 unittest.expect(o.entityId, unittest.equals('foo'));

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

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

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

407 checkBucketAccessControlProjectTeam(o.projectTeam);

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

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

410 }

411 buildCounterBucketAccessControl--;

412 }

413

414 buildUnnamed489() {

415 var o = new core.List<api.BucketAccessControl>();

416 o.add(buildBucketAccessControl());

417 o.add(buildBucketAccessControl());

418 return o;

419 }

420

421 checkUnnamed489(core.List<api.BucketAccessControl> o) {

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

423 checkBucketAccessControl(o[0]);

424 checkBucketAccessControl(o[1]);

425 }

426

427 core.int buildCounterBucketAccessControls = 0;

428 buildBucketAccessControls() {

429 var o = new api.BucketAccessControls();

430 buildCounterBucketAccessControls++;

431 if (buildCounterBucketAccessControls < 3) {

432 o.items = buildUnnamed489();

433 o.kind = "foo";

434 }

435 buildCounterBucketAccessControls--;

436 return o;

437 }

438

439 checkBucketAccessControls(api.BucketAccessControls o) {

440 buildCounterBucketAccessControls++;

441 if (buildCounterBucketAccessControls < 3) {

442 checkUnnamed489(o.items);

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

444 }

445 buildCounterBucketAccessControls--;

446 }

447

448 buildUnnamed490() {

449 var o = new core.List<api.Bucket>();

450 o.add(buildBucket());

451 o.add(buildBucket());

452 return o;

453 }

454

455 checkUnnamed490(core.List<api.Bucket> o) {

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

457 checkBucket(o[0]);

458 checkBucket(o[1]);

459 }

460

461 core.int buildCounterBuckets = 0;

462 buildBuckets() {

463 var o = new api.Buckets();

464 buildCounterBuckets++;

465 if (buildCounterBuckets < 3) {

466 o.items = buildUnnamed490();

467 o.kind = "foo";

468 o.nextPageToken = "foo";

469 }

470 buildCounterBuckets--;

471 return o;

472 }

473

474 checkBuckets(api.Buckets o) {

475 buildCounterBuckets++;

476 if (buildCounterBuckets < 3) {

477 checkUnnamed490(o.items);

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

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

480 }

481 buildCounterBuckets--;

482 }

483

484 buildUnnamed491() {

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

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

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

488 return o;

489 }

490

491 checkUnnamed491(core.Map<core.String, core.String> o) {

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

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

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

495 }

496

497 core.int buildCounterChannel = 0;

498 buildChannel() {

499 var o = new api.Channel();

500 buildCounterChannel++;

501 if (buildCounterChannel < 3) {

502 o.address = "foo";

503 o.expiration = "foo";

504 o.id = "foo";

505 o.kind = "foo";

506 o.params = buildUnnamed491();

507 o.payload = true;

508 o.resourceId = "foo";

509 o.resourceUri = "foo";

510 o.token = "foo";

511 o.type = "foo";

512 }

513 buildCounterChannel--;

514 return o;

515 }

516

517 checkChannel(api.Channel o) {

518 buildCounterChannel++;

519 if (buildCounterChannel < 3) {

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

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

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

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

524 checkUnnamed491(o.params);

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

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

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

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

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

530 }

531 buildCounterChannel--;

532 }

533

534 core.int buildCounterComposeRequestSourceObjectsObjectPreconditions = 0;

535 buildComposeRequestSourceObjectsObjectPreconditions() {

536 var o = new api.ComposeRequestSourceObjectsObjectPreconditions();

537 buildCounterComposeRequestSourceObjectsObjectPreconditions++;

538 if (buildCounterComposeRequestSourceObjectsObjectPreconditions < 3) {

539 o.ifGenerationMatch = "foo";

540 }

541 buildCounterComposeRequestSourceObjectsObjectPreconditions--;

542 return o;

543 }

544

545 checkComposeRequestSourceObjectsObjectPreconditions(api.ComposeRequestSourceObje ctsObjectPreconditions o) {

546 buildCounterComposeRequestSourceObjectsObjectPreconditions++;

547 if (buildCounterComposeRequestSourceObjectsObjectPreconditions < 3) {

548 unittest.expect(o.ifGenerationMatch, unittest.equals('foo'));

549 }

550 buildCounterComposeRequestSourceObjectsObjectPreconditions--;

551 }

552

553 core.int buildCounterComposeRequestSourceObjects = 0;

554 buildComposeRequestSourceObjects() {

555 var o = new api.ComposeRequestSourceObjects();

556 buildCounterComposeRequestSourceObjects++;

557 if (buildCounterComposeRequestSourceObjects < 3) {

558 o.generation = "foo";

559 o.name = "foo";

560 o.objectPreconditions = buildComposeRequestSourceObjectsObjectPreconditions( );

561 }

562 buildCounterComposeRequestSourceObjects--;

563 return o;

564 }

565

566 checkComposeRequestSourceObjects(api.ComposeRequestSourceObjects o) {

567 buildCounterComposeRequestSourceObjects++;

568 if (buildCounterComposeRequestSourceObjects < 3) {

569 unittest.expect(o.generation, unittest.equals('foo'));

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

571 checkComposeRequestSourceObjectsObjectPreconditions(o.objectPreconditions);

572 }

573 buildCounterComposeRequestSourceObjects--;

574 }

575

576 buildUnnamed492() {

577 var o = new core.List<api.ComposeRequestSourceObjects>();

578 o.add(buildComposeRequestSourceObjects());

579 o.add(buildComposeRequestSourceObjects());

580 return o;

581 }

582

583 checkUnnamed492(core.List<api.ComposeRequestSourceObjects> o) {

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

585 checkComposeRequestSourceObjects(o[0]);

586 checkComposeRequestSourceObjects(o[1]);

587 }

588

589 core.int buildCounterComposeRequest = 0;

590 buildComposeRequest() {

591 var o = new api.ComposeRequest();

592 buildCounterComposeRequest++;

593 if (buildCounterComposeRequest < 3) {

594 o.destination = buildObject();

595 o.kind = "foo";

596 o.sourceObjects = buildUnnamed492();

597 }

598 buildCounterComposeRequest--;

599 return o;

600 }

601

602 checkComposeRequest(api.ComposeRequest o) {

603 buildCounterComposeRequest++;

604 if (buildCounterComposeRequest < 3) {

605 checkObject(o.destination);

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

607 checkUnnamed492(o.sourceObjects);

608 }

609 buildCounterComposeRequest--;

610 }

611

612 buildUnnamed493() {

613 var o = new core.List<api.ObjectAccessControl>();

614 o.add(buildObjectAccessControl());

615 o.add(buildObjectAccessControl());

616 return o;

617 }

618

619 checkUnnamed493(core.List<api.ObjectAccessControl> o) {

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

621 checkObjectAccessControl(o[0]);

622 checkObjectAccessControl(o[1]);

623 }

624

625 buildUnnamed494() {

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

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

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

629 return o;

630 }

631

632 checkUnnamed494(core.Map<core.String, core.String> o) {

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

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

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

636 }

637

638 core.int buildCounterObjectOwner = 0;

639 buildObjectOwner() {

640 var o = new api.ObjectOwner();

641 buildCounterObjectOwner++;

642 if (buildCounterObjectOwner < 3) {

643 o.entity = "foo";

644 o.entityId = "foo";

645 }

646 buildCounterObjectOwner--;

647 return o;

648 }

649

650 checkObjectOwner(api.ObjectOwner o) {

651 buildCounterObjectOwner++;

652 if (buildCounterObjectOwner < 3) {

653 unittest.expect(o.entity, unittest.equals('foo'));

654 unittest.expect(o.entityId, unittest.equals('foo'));

655 }

656 buildCounterObjectOwner--;

657 }

658

659 core.int buildCounterObject = 0;

660 buildObject() {

661 var o = new api.Object();

662 buildCounterObject++;

663 if (buildCounterObject < 3) {

664 o.acl = buildUnnamed493();

665 o.bucket = "foo";

666 o.cacheControl = "foo";

667 o.componentCount = 42;

668 o.contentDisposition = "foo";

669 o.contentEncoding = "foo";

670 o.contentLanguage = "foo";

671 o.contentType = "foo";

672 o.crc32c = "foo";

673 o.etag = "foo";

674 o.generation = "foo";

675 o.id = "foo";

676 o.kind = "foo";

677 o.md5Hash = "foo";

678 o.mediaLink = "foo";

679 o.metadata = buildUnnamed494();

680 o.metageneration = "foo";

681 o.name = "foo";

682 o.owner = buildObjectOwner();

683 o.selfLink = "foo";

684 o.size = "foo";

685 o.storageClass = "foo";

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

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

688 }

689 buildCounterObject--;

690 return o;

691 }

692

693 checkObject(api.Object o) {

694 buildCounterObject++;

695 if (buildCounterObject < 3) {

696 checkUnnamed493(o.acl);

697 unittest.expect(o.bucket, unittest.equals('foo'));

698 unittest.expect(o.cacheControl, unittest.equals('foo'));

699 unittest.expect(o.componentCount, unittest.equals(42));

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

701 unittest.expect(o.contentEncoding, unittest.equals('foo'));

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

703 unittest.expect(o.contentType, unittest.equals('foo'));

704 unittest.expect(o.crc32c, unittest.equals('foo'));

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

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

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

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

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

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

711 checkUnnamed494(o.metadata);

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

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

714 checkObjectOwner(o.owner);

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

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

717 unittest.expect(o.storageClass, unittest.equals('foo'));

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

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

720 }

721 buildCounterObject--;

722 }

723

724 core.int buildCounterObjectAccessControlProjectTeam = 0;

725 buildObjectAccessControlProjectTeam() {

726 var o = new api.ObjectAccessControlProjectTeam();

727 buildCounterObjectAccessControlProjectTeam++;

728 if (buildCounterObjectAccessControlProjectTeam < 3) {

729 o.projectNumber = "foo";

730 o.team = "foo";

731 }

732 buildCounterObjectAccessControlProjectTeam--;

733 return o;

734 }

735

736 checkObjectAccessControlProjectTeam(api.ObjectAccessControlProjectTeam o) {

737 buildCounterObjectAccessControlProjectTeam++;

738 if (buildCounterObjectAccessControlProjectTeam < 3) {

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

740 unittest.expect(o.team, unittest.equals('foo'));

741 }

742 buildCounterObjectAccessControlProjectTeam--;

743 }

744

745 core.int buildCounterObjectAccessControl = 0;

746 buildObjectAccessControl() {

747 var o = new api.ObjectAccessControl();

748 buildCounterObjectAccessControl++;

749 if (buildCounterObjectAccessControl < 3) {

750 o.bucket = "foo";

751 o.domain = "foo";

752 o.email = "foo";

753 o.entity = "foo";

754 o.entityId = "foo";

755 o.etag = "foo";

756 o.generation = "foo";

757 o.id = "foo";

758 o.kind = "foo";

759 o.object = "foo";

760 o.projectTeam = buildObjectAccessControlProjectTeam();

761 o.role = "foo";

762 o.selfLink = "foo";

763 }

764 buildCounterObjectAccessControl--;

765 return o;

766 }

767

768 checkObjectAccessControl(api.ObjectAccessControl o) {

769 buildCounterObjectAccessControl++;

770 if (buildCounterObjectAccessControl < 3) {

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

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

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

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

775 unittest.expect(o.entityId, unittest.equals('foo'));

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

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

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

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

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

781 checkObjectAccessControlProjectTeam(o.projectTeam);

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

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

784 }

785 buildCounterObjectAccessControl--;

786 }

787

788 buildUnnamed495() {

789 var o = new core.List<core.Object>();

790 o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});

791 o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});

792 return o;

793 }

794

795 checkUnnamed495(core.List<core.Object> o) {

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

797 var casted1 = (o[0]) as core.Map; unittest.expect(casted1, unittest.hasLength( 3)); unittest.expect(casted1["list"], unittest.equals([1, 2, 3])); unittest.expe ct(casted1["bool"], unittest.equals(true)); unittest.expect(casted1["string"], u nittest.equals('foo'));

798 var casted2 = (o[1]) as core.Map; unittest.expect(casted2, unittest.hasLength( 3)); unittest.expect(casted2["list"], unittest.equals([1, 2, 3])); unittest.expe ct(casted2["bool"], unittest.equals(true)); unittest.expect(casted2["string"], u nittest.equals('foo'));

799 }

800

801 core.int buildCounterObjectAccessControls = 0;

802 buildObjectAccessControls() {

803 var o = new api.ObjectAccessControls();

804 buildCounterObjectAccessControls++;

805 if (buildCounterObjectAccessControls < 3) {

806 o.items = buildUnnamed495();

807 o.kind = "foo";

808 }

809 buildCounterObjectAccessControls--;

810 return o;

811 }

812

813 checkObjectAccessControls(api.ObjectAccessControls o) {

814 buildCounterObjectAccessControls++;

815 if (buildCounterObjectAccessControls < 3) {

816 checkUnnamed495(o.items);

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

818 }

819 buildCounterObjectAccessControls--;

820 }

821

822 buildUnnamed496() {

823 var o = new core.List<api.Object>();

824 o.add(buildObject());

825 o.add(buildObject());

826 return o;

827 }

828

829 checkUnnamed496(core.List<api.Object> o) {

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

831 checkObject(o[0]);

832 checkObject(o[1]);

833 }

834

835 buildUnnamed497() {

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

837 o.add("foo");

838 o.add("foo");

839 return o;

840 }

841

842 checkUnnamed497(core.List<core.String> o) {

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

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

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

846 }

847

848 core.int buildCounterObjects = 0;

849 buildObjects() {

850 var o = new api.Objects();

851 buildCounterObjects++;

852 if (buildCounterObjects < 3) {

853 o.items = buildUnnamed496();

854 o.kind = "foo";

855 o.nextPageToken = "foo";

856 o.prefixes = buildUnnamed497();

857 }

858 buildCounterObjects--;

859 return o;

860 }

861

862 checkObjects(api.Objects o) {

863 buildCounterObjects++;

864 if (buildCounterObjects < 3) {

865 checkUnnamed496(o.items);

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

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

868 checkUnnamed497(o.prefixes);

869 }

870 buildCounterObjects--;

871 }

872

873

874 main() {

875 unittest.group("obj-schema-BucketCors", () {

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

877 var o = buildBucketCors();

878 var od = new api.BucketCors.fromJson(o.toJson());

879 checkBucketCors(od);

880 });

881 });

882

883

884 unittest.group("obj-schema-BucketLifecycleRuleAction", () {

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

886 var o = buildBucketLifecycleRuleAction();

887 var od = new api.BucketLifecycleRuleAction.fromJson(o.toJson());

888 checkBucketLifecycleRuleAction(od);

889 });

890 });

891

892

893 unittest.group("obj-schema-BucketLifecycleRuleCondition", () {

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

895 var o = buildBucketLifecycleRuleCondition();

896 var od = new api.BucketLifecycleRuleCondition.fromJson(o.toJson());

897 checkBucketLifecycleRuleCondition(od);

898 });

899 });

900

901

902 unittest.group("obj-schema-BucketLifecycleRule", () {

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

904 var o = buildBucketLifecycleRule();

905 var od = new api.BucketLifecycleRule.fromJson(o.toJson());

906 checkBucketLifecycleRule(od);

907 });

908 });

909

910

911 unittest.group("obj-schema-BucketLifecycle", () {

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

913 var o = buildBucketLifecycle();

914 var od = new api.BucketLifecycle.fromJson(o.toJson());

915 checkBucketLifecycle(od);

916 });

917 });

918

919

920 unittest.group("obj-schema-BucketLogging", () {

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

922 var o = buildBucketLogging();

923 var od = new api.BucketLogging.fromJson(o.toJson());

924 checkBucketLogging(od);

925 });

926 });

927

928

929 unittest.group("obj-schema-BucketOwner", () {

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

931 var o = buildBucketOwner();

932 var od = new api.BucketOwner.fromJson(o.toJson());

933 checkBucketOwner(od);

934 });

935 });

936

937

938 unittest.group("obj-schema-BucketVersioning", () {

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

940 var o = buildBucketVersioning();

941 var od = new api.BucketVersioning.fromJson(o.toJson());

942 checkBucketVersioning(od);

943 });

944 });

945

946

947 unittest.group("obj-schema-BucketWebsite", () {

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

949 var o = buildBucketWebsite();

950 var od = new api.BucketWebsite.fromJson(o.toJson());

951 checkBucketWebsite(od);

952 });

953 });

954

955

956 unittest.group("obj-schema-Bucket", () {

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

958 var o = buildBucket();

959 var od = new api.Bucket.fromJson(o.toJson());

960 checkBucket(od);

961 });

962 });

963

964

965 unittest.group("obj-schema-BucketAccessControlProjectTeam", () {

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

967 var o = buildBucketAccessControlProjectTeam();

968 var od = new api.BucketAccessControlProjectTeam.fromJson(o.toJson());

969 checkBucketAccessControlProjectTeam(od);

970 });

971 });

972

973

974 unittest.group("obj-schema-BucketAccessControl", () {

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

976 var o = buildBucketAccessControl();

977 var od = new api.BucketAccessControl.fromJson(o.toJson());

978 checkBucketAccessControl(od);

979 });

980 });

981

982

983 unittest.group("obj-schema-BucketAccessControls", () {

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

985 var o = buildBucketAccessControls();

986 var od = new api.BucketAccessControls.fromJson(o.toJson());

987 checkBucketAccessControls(od);

988 });

989 });

990

991

992 unittest.group("obj-schema-Buckets", () {

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

994 var o = buildBuckets();

995 var od = new api.Buckets.fromJson(o.toJson());

996 checkBuckets(od);

997 });

998 });

999

1000

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

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

1003 var o = buildChannel();

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

1005 checkChannel(od);

1006 });

1007 });

1008

1009

1010 unittest.group("obj-schema-ComposeRequestSourceObjectsObjectPreconditions", () {

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

1012 var o = buildComposeRequestSourceObjectsObjectPreconditions();

1013 var od = new api.ComposeRequestSourceObjectsObjectPreconditions.fromJson(o .toJson());

1014 checkComposeRequestSourceObjectsObjectPreconditions(od);

1015 });

1016 });

1017

1018

1019 unittest.group("obj-schema-ComposeRequestSourceObjects", () {

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

1021 var o = buildComposeRequestSourceObjects();

1022 var od = new api.ComposeRequestSourceObjects.fromJson(o.toJson());

1023 checkComposeRequestSourceObjects(od);

1024 });

1025 });

1026

1027

1028 unittest.group("obj-schema-ComposeRequest", () {

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

1030 var o = buildComposeRequest();

1031 var od = new api.ComposeRequest.fromJson(o.toJson());

1032 checkComposeRequest(od);

1033 });

1034 });

1035

1036

1037 unittest.group("obj-schema-ObjectOwner", () {

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

1039 var o = buildObjectOwner();

1040 var od = new api.ObjectOwner.fromJson(o.toJson());

1041 checkObjectOwner(od);

1042 });

1043 });

1044

1045

1046 unittest.group("obj-schema-Object", () {

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

1048 var o = buildObject();

1049 var od = new api.Object.fromJson(o.toJson());

1050 checkObject(od);

1051 });

1052 });

1053

1054

1055 unittest.group("obj-schema-ObjectAccessControlProjectTeam", () {

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

1057 var o = buildObjectAccessControlProjectTeam();

1058 var od = new api.ObjectAccessControlProjectTeam.fromJson(o.toJson());

1059 checkObjectAccessControlProjectTeam(od);

1060 });

1061 });

1062

1063

1064 unittest.group("obj-schema-ObjectAccessControl", () {

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

1066 var o = buildObjectAccessControl();

1067 var od = new api.ObjectAccessControl.fromJson(o.toJson());

1068 checkObjectAccessControl(od);

1069 });

1070 });

1071

1072

1073 unittest.group("obj-schema-ObjectAccessControls", () {

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

1075 var o = buildObjectAccessControls();

1076 var od = new api.ObjectAccessControls.fromJson(o.toJson());

1077 checkObjectAccessControls(od);

1078 });

1079 });

1080

1081

1082 unittest.group("obj-schema-Objects", () {

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

1084 var o = buildObjects();

1085 var od = new api.Objects.fromJson(o.toJson());

1086 checkObjects(od);

1087 });

1088 });

1089

1090

1091 unittest.group("resource-BucketAccessControlsResourceApi", () {

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

1093

1094 var mock = new common_test.HttpServerMock();

1095 api.BucketAccessControlsResourceApi res = new api.StorageApi(mock).bucketA ccessControls;

1096 var arg_bucket = "foo";

1097 var arg_entity = "foo";

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

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

1100 var pathOffset = 0;

1101 var index;

1102 var subPart;

1103 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1104 pathOffset += 12;

1105 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1106 pathOffset += 2;

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

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

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

1110 pathOffset = index;

1111 unittest.expect(subPart, unittest.equals("$arg_bucket"));

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

1113 pathOffset += 5;

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

1115 pathOffset = path.length;

1116 unittest.expect(subPart, unittest.equals("$arg_entity"));

1117

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

1119 var queryOffset = 0;

1120 var queryMap = {};

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

1122 parseBool(n) {

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

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

1125 if (n == null) return null;

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

1127 }

1128 if (query.length > 0) {

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

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

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

1132 }

1133 }

1134

1135

1136 var h = {

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

1138 };

1139 var resp = "";

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

1141 }), true);

1142 res.delete(arg_bucket, arg_entity).then(unittest.expectAsync((_) {}));

1143 });

1144

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

1146

1147 var mock = new common_test.HttpServerMock();

1148 api.BucketAccessControlsResourceApi res = new api.StorageApi(mock).bucketA ccessControls;

1149 var arg_bucket = "foo";

1150 var arg_entity = "foo";

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

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

1153 var pathOffset = 0;

1154 var index;

1155 var subPart;

1156 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1157 pathOffset += 12;

1158 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1159 pathOffset += 2;

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

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

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

1163 pathOffset = index;

1164 unittest.expect(subPart, unittest.equals("$arg_bucket"));

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

1166 pathOffset += 5;

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

1168 pathOffset = path.length;

1169 unittest.expect(subPart, unittest.equals("$arg_entity"));

1170

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

1172 var queryOffset = 0;

1173 var queryMap = {};

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

1175 parseBool(n) {

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

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

1178 if (n == null) return null;

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

1180 }

1181 if (query.length > 0) {

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

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

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

1185 }

1186 }

1187

1188

1189 var h = {

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

1191 };

1192 var resp = convert.JSON.encode(buildBucketAccessControl());

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

1194 }), true);

1195 res.get(arg_bucket, arg_entity).then(unittest.expectAsync(((api.BucketAcce ssControl response) {

1196 checkBucketAccessControl(response);

1197 })));

1198 });

1199

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

1201

1202 var mock = new common_test.HttpServerMock();

1203 api.BucketAccessControlsResourceApi res = new api.StorageApi(mock).bucketA ccessControls;

1204 var arg_request = buildBucketAccessControl();

1205 var arg_bucket = "foo";

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

1207 var obj = new api.BucketAccessControl.fromJson(json);

1208 checkBucketAccessControl(obj);

1209

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

1211 var pathOffset = 0;

1212 var index;

1213 var subPart;

1214 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1215 pathOffset += 12;

1216 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1217 pathOffset += 2;

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

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

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

1221 pathOffset = index;

1222 unittest.expect(subPart, unittest.equals("$arg_bucket"));

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

1224 pathOffset += 4;

1225

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

1227 var queryOffset = 0;

1228 var queryMap = {};

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

1230 parseBool(n) {

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

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

1233 if (n == null) return null;

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

1235 }

1236 if (query.length > 0) {

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

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

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

1240 }

1241 }

1242

1243

1244 var h = {

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

1246 };

1247 var resp = convert.JSON.encode(buildBucketAccessControl());

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

1249 }), true);

1250 res.insert(arg_request, arg_bucket).then(unittest.expectAsync(((api.Bucket AccessControl response) {

1251 checkBucketAccessControl(response);

1252 })));

1253 });

1254

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

1256

1257 var mock = new common_test.HttpServerMock();

1258 api.BucketAccessControlsResourceApi res = new api.StorageApi(mock).bucketA ccessControls;

1259 var arg_bucket = "foo";

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

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

1262 var pathOffset = 0;

1263 var index;

1264 var subPart;

1265 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1266 pathOffset += 12;

1267 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1268 pathOffset += 2;

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

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

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

1272 pathOffset = index;

1273 unittest.expect(subPart, unittest.equals("$arg_bucket"));

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

1275 pathOffset += 4;

1276

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

1278 var queryOffset = 0;

1279 var queryMap = {};

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

1281 parseBool(n) {

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

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

1284 if (n == null) return null;

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

1286 }

1287 if (query.length > 0) {

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

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

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

1291 }

1292 }

1293

1294

1295 var h = {

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

1297 };

1298 var resp = convert.JSON.encode(buildBucketAccessControls());

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

1300 }), true);

1301 res.list(arg_bucket).then(unittest.expectAsync(((api.BucketAccessControls response) {

1302 checkBucketAccessControls(response);

1303 })));

1304 });

1305

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

1307

1308 var mock = new common_test.HttpServerMock();

1309 api.BucketAccessControlsResourceApi res = new api.StorageApi(mock).bucketA ccessControls;

1310 var arg_request = buildBucketAccessControl();

1311 var arg_bucket = "foo";

1312 var arg_entity = "foo";

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

1314 var obj = new api.BucketAccessControl.fromJson(json);

1315 checkBucketAccessControl(obj);

1316

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

1318 var pathOffset = 0;

1319 var index;

1320 var subPart;

1321 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1322 pathOffset += 12;

1323 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1324 pathOffset += 2;

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

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

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

1328 pathOffset = index;

1329 unittest.expect(subPart, unittest.equals("$arg_bucket"));

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

1331 pathOffset += 5;

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

1333 pathOffset = path.length;

1334 unittest.expect(subPart, unittest.equals("$arg_entity"));

1335

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

1337 var queryOffset = 0;

1338 var queryMap = {};

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

1340 parseBool(n) {

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

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

1343 if (n == null) return null;

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

1345 }

1346 if (query.length > 0) {

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

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

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

1350 }

1351 }

1352

1353

1354 var h = {

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

1356 };

1357 var resp = convert.JSON.encode(buildBucketAccessControl());

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

1359 }), true);

1360 res.patch(arg_request, arg_bucket, arg_entity).then(unittest.expectAsync(( (api.BucketAccessControl response) {

1361 checkBucketAccessControl(response);

1362 })));

1363 });

1364

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

1366

1367 var mock = new common_test.HttpServerMock();

1368 api.BucketAccessControlsResourceApi res = new api.StorageApi(mock).bucketA ccessControls;

1369 var arg_request = buildBucketAccessControl();

1370 var arg_bucket = "foo";

1371 var arg_entity = "foo";

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

1373 var obj = new api.BucketAccessControl.fromJson(json);

1374 checkBucketAccessControl(obj);

1375

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

1377 var pathOffset = 0;

1378 var index;

1379 var subPart;

1380 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1381 pathOffset += 12;

1382 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1383 pathOffset += 2;

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

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

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

1387 pathOffset = index;

1388 unittest.expect(subPart, unittest.equals("$arg_bucket"));

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

1390 pathOffset += 5;

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

1392 pathOffset = path.length;

1393 unittest.expect(subPart, unittest.equals("$arg_entity"));

1394

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

1396 var queryOffset = 0;

1397 var queryMap = {};

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

1399 parseBool(n) {

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

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

1402 if (n == null) return null;

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

1404 }

1405 if (query.length > 0) {

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

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

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

1409 }

1410 }

1411

1412

1413 var h = {

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

1415 };

1416 var resp = convert.JSON.encode(buildBucketAccessControl());

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

1418 }), true);

1419 res.update(arg_request, arg_bucket, arg_entity).then(unittest.expectAsync( ((api.BucketAccessControl response) {

1420 checkBucketAccessControl(response);

1421 })));

1422 });

1423

1424 });

1425

1426

1427 unittest.group("resource-BucketsResourceApi", () {

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

1429

1430 var mock = new common_test.HttpServerMock();

1431 api.BucketsResourceApi res = new api.StorageApi(mock).buckets;

1432 var arg_bucket = "foo";

1433 var arg_ifMetagenerationMatch = "foo";

1434 var arg_ifMetagenerationNotMatch = "foo";

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

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

1437 var pathOffset = 0;

1438 var index;

1439 var subPart;

1440 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1441 pathOffset += 12;

1442 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1443 pathOffset += 2;

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

1445 pathOffset = path.length;

1446 unittest.expect(subPart, unittest.equals("$arg_bucket"));

1447

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

1449 var queryOffset = 0;

1450 var queryMap = {};

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

1452 parseBool(n) {

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

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

1455 if (n == null) return null;

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

1457 }

1458 if (query.length > 0) {

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

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

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

1462 }

1463 }

1464 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

1465 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

1466

1467

1468 var h = {

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

1470 };

1471 var resp = "";

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

1473 }), true);

1474 res.delete(arg_bucket, ifMetagenerationMatch: arg_ifMetagenerationMatch, i fMetagenerationNotMatch: arg_ifMetagenerationNotMatch).then(unittest.expectAsync ((_) {}));

1475 });

1476

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

1478

1479 var mock = new common_test.HttpServerMock();

1480 api.BucketsResourceApi res = new api.StorageApi(mock).buckets;

1481 var arg_bucket = "foo";

1482 var arg_ifMetagenerationMatch = "foo";

1483 var arg_ifMetagenerationNotMatch = "foo";

1484 var arg_projection = "foo";

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

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

1487 var pathOffset = 0;

1488 var index;

1489 var subPart;

1490 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1491 pathOffset += 12;

1492 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1493 pathOffset += 2;

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

1495 pathOffset = path.length;

1496 unittest.expect(subPart, unittest.equals("$arg_bucket"));

1497

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

1499 var queryOffset = 0;

1500 var queryMap = {};

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

1502 parseBool(n) {

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

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

1505 if (n == null) return null;

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

1507 }

1508 if (query.length > 0) {

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

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

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

1512 }

1513 }

1514 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

1515 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

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

1517

1518

1519 var h = {

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

1521 };

1522 var resp = convert.JSON.encode(buildBucket());

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

1524 }), true);

1525 res.get(arg_bucket, ifMetagenerationMatch: arg_ifMetagenerationMatch, ifMe tagenerationNotMatch: arg_ifMetagenerationNotMatch, projection: arg_projection). then(unittest.expectAsync(((api.Bucket response) {

1526 checkBucket(response);

1527 })));

1528 });

1529

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

1531

1532 var mock = new common_test.HttpServerMock();

1533 api.BucketsResourceApi res = new api.StorageApi(mock).buckets;

1534 var arg_request = buildBucket();

1535 var arg_project = "foo";

1536 var arg_predefinedAcl = "foo";

1537 var arg_projection = "foo";

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

1539 var obj = new api.Bucket.fromJson(json);

1540 checkBucket(obj);

1541

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

1543 var pathOffset = 0;

1544 var index;

1545 var subPart;

1546 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1547 pathOffset += 12;

1548 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("b"));

1549 pathOffset += 1;

1550

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

1552 var queryOffset = 0;

1553 var queryMap = {};

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

1555 parseBool(n) {

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

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

1558 if (n == null) return null;

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

1560 }

1561 if (query.length > 0) {

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

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

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

1565 }

1566 }

1567 unittest.expect(queryMap["project"].first, unittest.equals(arg_project)) ;

1568 unittest.expect(queryMap["predefinedAcl"].first, unittest.equals(arg_pre definedAcl));

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

1570

1571

1572 var h = {

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

1574 };

1575 var resp = convert.JSON.encode(buildBucket());

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

1577 }), true);

1578 res.insert(arg_request, arg_project, predefinedAcl: arg_predefinedAcl, pro jection: arg_projection).then(unittest.expectAsync(((api.Bucket response) {

1579 checkBucket(response);

1580 })));

1581 });

1582

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

1584

1585 var mock = new common_test.HttpServerMock();

1586 api.BucketsResourceApi res = new api.StorageApi(mock).buckets;

1587 var arg_project = "foo";

1588 var arg_maxResults = 42;

1589 var arg_pageToken = "foo";

1590 var arg_projection = "foo";

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

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

1593 var pathOffset = 0;

1594 var index;

1595 var subPart;

1596 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1597 pathOffset += 12;

1598 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("b"));

1599 pathOffset += 1;

1600

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

1602 var queryOffset = 0;

1603 var queryMap = {};

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

1605 parseBool(n) {

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

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

1608 if (n == null) return null;

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

1610 }

1611 if (query.length > 0) {

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

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

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

1615 }

1616 }

1617 unittest.expect(queryMap["project"].first, unittest.equals(arg_project)) ;

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

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

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

1621

1622

1623 var h = {

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

1625 };

1626 var resp = convert.JSON.encode(buildBuckets());

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

1628 }), true);

1629 res.list(arg_project, maxResults: arg_maxResults, pageToken: arg_pageToken , projection: arg_projection).then(unittest.expectAsync(((api.Buckets response) {

1630 checkBuckets(response);

1631 })));

1632 });

1633

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

1635

1636 var mock = new common_test.HttpServerMock();

1637 api.BucketsResourceApi res = new api.StorageApi(mock).buckets;

1638 var arg_request = buildBucket();

1639 var arg_bucket = "foo";

1640 var arg_ifMetagenerationMatch = "foo";

1641 var arg_ifMetagenerationNotMatch = "foo";

1642 var arg_predefinedAcl = "foo";

1643 var arg_projection = "foo";

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

1645 var obj = new api.Bucket.fromJson(json);

1646 checkBucket(obj);

1647

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

1649 var pathOffset = 0;

1650 var index;

1651 var subPart;

1652 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1653 pathOffset += 12;

1654 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1655 pathOffset += 2;

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

1657 pathOffset = path.length;

1658 unittest.expect(subPart, unittest.equals("$arg_bucket"));

1659

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

1661 var queryOffset = 0;

1662 var queryMap = {};

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

1664 parseBool(n) {

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

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

1667 if (n == null) return null;

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

1669 }

1670 if (query.length > 0) {

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

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

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

1674 }

1675 }

1676 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

1677 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

1678 unittest.expect(queryMap["predefinedAcl"].first, unittest.equals(arg_pre definedAcl));

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

1680

1681

1682 var h = {

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

1684 };

1685 var resp = convert.JSON.encode(buildBucket());

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

1687 }), true);

1688 res.patch(arg_request, arg_bucket, ifMetagenerationMatch: arg_ifMetagenera tionMatch, ifMetagenerationNotMatch: arg_ifMetagenerationNotMatch, predefinedAcl : arg_predefinedAcl, projection: arg_projection).then(unittest.expectAsync(((api .Bucket response) {

1689 checkBucket(response);

1690 })));

1691 });

1692

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

1694

1695 var mock = new common_test.HttpServerMock();

1696 api.BucketsResourceApi res = new api.StorageApi(mock).buckets;

1697 var arg_request = buildBucket();

1698 var arg_bucket = "foo";

1699 var arg_ifMetagenerationMatch = "foo";

1700 var arg_ifMetagenerationNotMatch = "foo";

1701 var arg_predefinedAcl = "foo";

1702 var arg_projection = "foo";

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

1704 var obj = new api.Bucket.fromJson(json);

1705 checkBucket(obj);

1706

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

1708 var pathOffset = 0;

1709 var index;

1710 var subPart;

1711 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1712 pathOffset += 12;

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

1714 pathOffset += 2;

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

1716 pathOffset = path.length;

1717 unittest.expect(subPart, unittest.equals("$arg_bucket"));

1718

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

1720 var queryOffset = 0;

1721 var queryMap = {};

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

1723 parseBool(n) {

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

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

1726 if (n == null) return null;

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

1728 }

1729 if (query.length > 0) {

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

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

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

1733 }

1734 }

1735 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

1736 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

1737 unittest.expect(queryMap["predefinedAcl"].first, unittest.equals(arg_pre definedAcl));

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

1739

1740

1741 var h = {

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

1743 };

1744 var resp = convert.JSON.encode(buildBucket());

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

1746 }), true);

1747 res.update(arg_request, arg_bucket, ifMetagenerationMatch: arg_ifMetagener ationMatch, ifMetagenerationNotMatch: arg_ifMetagenerationNotMatch, predefinedAc l: arg_predefinedAcl, projection: arg_projection).then(unittest.expectAsync(((ap i.Bucket response) {

1748 checkBucket(response);

1749 })));

1750 });

1751

1752 });

1753

1754

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

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

1757

1758 var mock = new common_test.HttpServerMock();

1759 api.ChannelsResourceApi res = new api.StorageApi(mock).channels;

1760 var arg_request = buildChannel();

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

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

1763 checkChannel(obj);

1764

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

1766 var pathOffset = 0;

1767 var index;

1768 var subPart;

1769 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1770 pathOffset += 12;

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

1772 pathOffset += 13;

1773

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

1775 var queryOffset = 0;

1776 var queryMap = {};

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

1778 parseBool(n) {

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

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

1781 if (n == null) return null;

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

1783 }

1784 if (query.length > 0) {

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

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

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

1788 }

1789 }

1790

1791

1792 var h = {

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

1794 };

1795 var resp = "";

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

1797 }), true);

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

1799 });

1800

1801 });

1802

1803

1804 unittest.group("resource-DefaultObjectAccessControlsResourceApi", () {

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

1806

1807 var mock = new common_test.HttpServerMock();

1808 api.DefaultObjectAccessControlsResourceApi res = new api.StorageApi(mock). defaultObjectAccessControls;

1809 var arg_bucket = "foo";

1810 var arg_entity = "foo";

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

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

1813 var pathOffset = 0;

1814 var index;

1815 var subPart;

1816 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1817 pathOffset += 12;

1818 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1819 pathOffset += 2;

1820 index = path.indexOf("/defaultObjectAcl/", pathOffset);

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

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

1823 pathOffset = index;

1824 unittest.expect(subPart, unittest.equals("$arg_bucket"));

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

1826 pathOffset += 18;

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

1828 pathOffset = path.length;

1829 unittest.expect(subPart, unittest.equals("$arg_entity"));

1830

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

1832 var queryOffset = 0;

1833 var queryMap = {};

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

1835 parseBool(n) {

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

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

1838 if (n == null) return null;

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

1840 }

1841 if (query.length > 0) {

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

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

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

1845 }

1846 }

1847

1848

1849 var h = {

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

1851 };

1852 var resp = "";

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

1854 }), true);

1855 res.delete(arg_bucket, arg_entity).then(unittest.expectAsync((_) {}));

1856 });

1857

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

1859

1860 var mock = new common_test.HttpServerMock();

1861 api.DefaultObjectAccessControlsResourceApi res = new api.StorageApi(mock). defaultObjectAccessControls;

1862 var arg_bucket = "foo";

1863 var arg_entity = "foo";

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

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

1866 var pathOffset = 0;

1867 var index;

1868 var subPart;

1869 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1870 pathOffset += 12;

1871 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1872 pathOffset += 2;

1873 index = path.indexOf("/defaultObjectAcl/", pathOffset);

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

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

1876 pathOffset = index;

1877 unittest.expect(subPart, unittest.equals("$arg_bucket"));

1878 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/defaultObjectAcl/"));

1879 pathOffset += 18;

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

1881 pathOffset = path.length;

1882 unittest.expect(subPart, unittest.equals("$arg_entity"));

1883

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

1885 var queryOffset = 0;

1886 var queryMap = {};

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

1888 parseBool(n) {

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

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

1891 if (n == null) return null;

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

1893 }

1894 if (query.length > 0) {

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

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

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

1898 }

1899 }

1900

1901

1902 var h = {

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

1904 };

1905 var resp = convert.JSON.encode(buildObjectAccessControl());

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

1907 }), true);

1908 res.get(arg_bucket, arg_entity).then(unittest.expectAsync(((api.ObjectAcce ssControl response) {

1909 checkObjectAccessControl(response);

1910 })));

1911 });

1912

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

1914

1915 var mock = new common_test.HttpServerMock();

1916 api.DefaultObjectAccessControlsResourceApi res = new api.StorageApi(mock). defaultObjectAccessControls;

1917 var arg_request = buildObjectAccessControl();

1918 var arg_bucket = "foo";

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

1920 var obj = new api.ObjectAccessControl.fromJson(json);

1921 checkObjectAccessControl(obj);

1922

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

1924 var pathOffset = 0;

1925 var index;

1926 var subPart;

1927 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1928 pathOffset += 12;

1929 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1930 pathOffset += 2;

1931 index = path.indexOf("/defaultObjectAcl", pathOffset);

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

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

1934 pathOffset = index;

1935 unittest.expect(subPart, unittest.equals("$arg_bucket"));

1936 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/defaultObjectAcl"));

1937 pathOffset += 17;

1938

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

1940 var queryOffset = 0;

1941 var queryMap = {};

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

1943 parseBool(n) {

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

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

1946 if (n == null) return null;

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

1948 }

1949 if (query.length > 0) {

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

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

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

1953 }

1954 }

1955

1956

1957 var h = {

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

1959 };

1960 var resp = convert.JSON.encode(buildObjectAccessControl());

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

1962 }), true);

1963 res.insert(arg_request, arg_bucket).then(unittest.expectAsync(((api.Object AccessControl response) {

1964 checkObjectAccessControl(response);

1965 })));

1966 });

1967

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

1969

1970 var mock = new common_test.HttpServerMock();

1971 api.DefaultObjectAccessControlsResourceApi res = new api.StorageApi(mock). defaultObjectAccessControls;

1972 var arg_bucket = "foo";

1973 var arg_ifMetagenerationMatch = "foo";

1974 var arg_ifMetagenerationNotMatch = "foo";

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

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

1977 var pathOffset = 0;

1978 var index;

1979 var subPart;

1980 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

1981 pathOffset += 12;

1982 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

1983 pathOffset += 2;

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

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

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

1987 pathOffset = index;

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

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

1990 pathOffset += 17;

1991

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

1993 var queryOffset = 0;

1994 var queryMap = {};

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

1996 parseBool(n) {

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

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

1999 if (n == null) return null;

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

2001 }

2002 if (query.length > 0) {

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

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

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

2006 }

2007 }

2008 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

2009 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

2010

2011

2012 var h = {

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

2014 };

2015 var resp = convert.JSON.encode(buildObjectAccessControls());

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

2017 }), true);

2018 res.list(arg_bucket, ifMetagenerationMatch: arg_ifMetagenerationMatch, ifM etagenerationNotMatch: arg_ifMetagenerationNotMatch).then(unittest.expectAsync(( (api.ObjectAccessControls response) {

2019 checkObjectAccessControls(response);

2020 })));

2021 });

2022

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

2024

2025 var mock = new common_test.HttpServerMock();

2026 api.DefaultObjectAccessControlsResourceApi res = new api.StorageApi(mock). defaultObjectAccessControls;

2027 var arg_request = buildObjectAccessControl();

2028 var arg_bucket = "foo";

2029 var arg_entity = "foo";

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

2031 var obj = new api.ObjectAccessControl.fromJson(json);

2032 checkObjectAccessControl(obj);

2033

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

2035 var pathOffset = 0;

2036 var index;

2037 var subPart;

2038 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2039 pathOffset += 12;

2040 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2041 pathOffset += 2;

2042 index = path.indexOf("/defaultObjectAcl/", pathOffset);

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

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

2045 pathOffset = index;

2046 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2047 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/defaultObjectAcl/"));

2048 pathOffset += 18;

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

2050 pathOffset = path.length;

2051 unittest.expect(subPart, unittest.equals("$arg_entity"));

2052

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

2054 var queryOffset = 0;

2055 var queryMap = {};

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

2057 parseBool(n) {

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

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

2060 if (n == null) return null;

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

2062 }

2063 if (query.length > 0) {

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

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

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

2067 }

2068 }

2069

2070

2071 var h = {

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

2073 };

2074 var resp = convert.JSON.encode(buildObjectAccessControl());

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

2076 }), true);

2077 res.patch(arg_request, arg_bucket, arg_entity).then(unittest.expectAsync(( (api.ObjectAccessControl response) {

2078 checkObjectAccessControl(response);

2079 })));

2080 });

2081

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

2083

2084 var mock = new common_test.HttpServerMock();

2085 api.DefaultObjectAccessControlsResourceApi res = new api.StorageApi(mock). defaultObjectAccessControls;

2086 var arg_request = buildObjectAccessControl();

2087 var arg_bucket = "foo";

2088 var arg_entity = "foo";

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

2090 var obj = new api.ObjectAccessControl.fromJson(json);

2091 checkObjectAccessControl(obj);

2092

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

2094 var pathOffset = 0;

2095 var index;

2096 var subPart;

2097 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2098 pathOffset += 12;

2099 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2100 pathOffset += 2;

2101 index = path.indexOf("/defaultObjectAcl/", pathOffset);

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

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

2104 pathOffset = index;

2105 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2106 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("/defaultObjectAcl/"));

2107 pathOffset += 18;

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

2109 pathOffset = path.length;

2110 unittest.expect(subPart, unittest.equals("$arg_entity"));

2111

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

2113 var queryOffset = 0;

2114 var queryMap = {};

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

2116 parseBool(n) {

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

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

2119 if (n == null) return null;

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

2121 }

2122 if (query.length > 0) {

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

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

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

2126 }

2127 }

2128

2129

2130 var h = {

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

2132 };

2133 var resp = convert.JSON.encode(buildObjectAccessControl());

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

2135 }), true);

2136 res.update(arg_request, arg_bucket, arg_entity).then(unittest.expectAsync( ((api.ObjectAccessControl response) {

2137 checkObjectAccessControl(response);

2138 })));

2139 });

2140

2141 });

2142

2143

2144 unittest.group("resource-ObjectAccessControlsResourceApi", () {

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

2146

2147 var mock = new common_test.HttpServerMock();

2148 api.ObjectAccessControlsResourceApi res = new api.StorageApi(mock).objectA ccessControls;

2149 var arg_bucket = "foo";

2150 var arg_object = "foo";

2151 var arg_entity = "foo";

2152 var arg_generation = "foo";

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

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

2155 var pathOffset = 0;

2156 var index;

2157 var subPart;

2158 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2159 pathOffset += 12;

2160 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2161 pathOffset += 2;

2162 index = path.indexOf("/o/", pathOffset);

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

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

2165 pathOffset = index;

2166 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2167 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2168 pathOffset += 3;

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

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

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

2172 pathOffset = index;

2173 unittest.expect(subPart, unittest.equals("$arg_object"));

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

2175 pathOffset += 5;

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

2177 pathOffset = path.length;

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

2179

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

2181 var queryOffset = 0;

2182 var queryMap = {};

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

2184 parseBool(n) {

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

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

2187 if (n == null) return null;

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

2189 }

2190 if (query.length > 0) {

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

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

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

2194 }

2195 }

2196 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

2197

2198

2199 var h = {

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

2201 };

2202 var resp = "";

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

2204 }), true);

2205 res.delete(arg_bucket, arg_object, arg_entity, generation: arg_generation) .then(unittest.expectAsync((_) {}));

2206 });

2207

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

2209

2210 var mock = new common_test.HttpServerMock();

2211 api.ObjectAccessControlsResourceApi res = new api.StorageApi(mock).objectA ccessControls;

2212 var arg_bucket = "foo";

2213 var arg_object = "foo";

2214 var arg_entity = "foo";

2215 var arg_generation = "foo";

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

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

2218 var pathOffset = 0;

2219 var index;

2220 var subPart;

2221 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2222 pathOffset += 12;

2223 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2224 pathOffset += 2;

2225 index = path.indexOf("/o/", pathOffset);

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

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

2228 pathOffset = index;

2229 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2230 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2231 pathOffset += 3;

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

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

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

2235 pathOffset = index;

2236 unittest.expect(subPart, unittest.equals("$arg_object"));

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

2238 pathOffset += 5;

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

2240 pathOffset = path.length;

2241 unittest.expect(subPart, unittest.equals("$arg_entity"));

2242

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

2244 var queryOffset = 0;

2245 var queryMap = {};

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

2247 parseBool(n) {

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

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

2250 if (n == null) return null;

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

2252 }

2253 if (query.length > 0) {

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

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

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

2257 }

2258 }

2259 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

2260

2261

2262 var h = {

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

2264 };

2265 var resp = convert.JSON.encode(buildObjectAccessControl());

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

2267 }), true);

2268 res.get(arg_bucket, arg_object, arg_entity, generation: arg_generation).th en(unittest.expectAsync(((api.ObjectAccessControl response) {

2269 checkObjectAccessControl(response);

2270 })));

2271 });

2272

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

2274

2275 var mock = new common_test.HttpServerMock();

2276 api.ObjectAccessControlsResourceApi res = new api.StorageApi(mock).objectA ccessControls;

2277 var arg_request = buildObjectAccessControl();

2278 var arg_bucket = "foo";

2279 var arg_object = "foo";

2280 var arg_generation = "foo";

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

2282 var obj = new api.ObjectAccessControl.fromJson(json);

2283 checkObjectAccessControl(obj);

2284

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

2286 var pathOffset = 0;

2287 var index;

2288 var subPart;

2289 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2290 pathOffset += 12;

2291 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2292 pathOffset += 2;

2293 index = path.indexOf("/o/", pathOffset);

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

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

2296 pathOffset = index;

2297 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2298 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2299 pathOffset += 3;

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

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

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

2303 pathOffset = index;

2304 unittest.expect(subPart, unittest.equals("$arg_object"));

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

2306 pathOffset += 4;

2307

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

2309 var queryOffset = 0;

2310 var queryMap = {};

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

2312 parseBool(n) {

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

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

2315 if (n == null) return null;

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

2317 }

2318 if (query.length > 0) {

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

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

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

2322 }

2323 }

2324 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

2325

2326

2327 var h = {

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

2329 };

2330 var resp = convert.JSON.encode(buildObjectAccessControl());

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

2332 }), true);

2333 res.insert(arg_request, arg_bucket, arg_object, generation: arg_generation ).then(unittest.expectAsync(((api.ObjectAccessControl response) {

2334 checkObjectAccessControl(response);

2335 })));

2336 });

2337

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

2339

2340 var mock = new common_test.HttpServerMock();

2341 api.ObjectAccessControlsResourceApi res = new api.StorageApi(mock).objectA ccessControls;

2342 var arg_bucket = "foo";

2343 var arg_object = "foo";

2344 var arg_generation = "foo";

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

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

2347 var pathOffset = 0;

2348 var index;

2349 var subPart;

2350 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2351 pathOffset += 12;

2352 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2353 pathOffset += 2;

2354 index = path.indexOf("/o/", pathOffset);

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

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

2357 pathOffset = index;

2358 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2359 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2360 pathOffset += 3;

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

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

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

2364 pathOffset = index;

2365 unittest.expect(subPart, unittest.equals("$arg_object"));

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

2367 pathOffset += 4;

2368

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

2370 var queryOffset = 0;

2371 var queryMap = {};

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

2373 parseBool(n) {

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

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

2376 if (n == null) return null;

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

2378 }

2379 if (query.length > 0) {

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

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

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

2383 }

2384 }

2385 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

2386

2387

2388 var h = {

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

2390 };

2391 var resp = convert.JSON.encode(buildObjectAccessControls());

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

2393 }), true);

2394 res.list(arg_bucket, arg_object, generation: arg_generation).then(unittest .expectAsync(((api.ObjectAccessControls response) {

2395 checkObjectAccessControls(response);

2396 })));

2397 });

2398

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

2400

2401 var mock = new common_test.HttpServerMock();

2402 api.ObjectAccessControlsResourceApi res = new api.StorageApi(mock).objectA ccessControls;

2403 var arg_request = buildObjectAccessControl();

2404 var arg_bucket = "foo";

2405 var arg_object = "foo";

2406 var arg_entity = "foo";

2407 var arg_generation = "foo";

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

2409 var obj = new api.ObjectAccessControl.fromJson(json);

2410 checkObjectAccessControl(obj);

2411

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

2413 var pathOffset = 0;

2414 var index;

2415 var subPart;

2416 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2417 pathOffset += 12;

2418 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2419 pathOffset += 2;

2420 index = path.indexOf("/o/", pathOffset);

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

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

2423 pathOffset = index;

2424 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2425 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2426 pathOffset += 3;

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

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

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

2430 pathOffset = index;

2431 unittest.expect(subPart, unittest.equals("$arg_object"));

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

2433 pathOffset += 5;

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

2435 pathOffset = path.length;

2436 unittest.expect(subPart, unittest.equals("$arg_entity"));

2437

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

2439 var queryOffset = 0;

2440 var queryMap = {};

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

2442 parseBool(n) {

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

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

2445 if (n == null) return null;

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

2447 }

2448 if (query.length > 0) {

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

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

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

2452 }

2453 }

2454 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

2455

2456

2457 var h = {

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

2459 };

2460 var resp = convert.JSON.encode(buildObjectAccessControl());

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

2462 }), true);

2463 res.patch(arg_request, arg_bucket, arg_object, arg_entity, generation: arg _generation).then(unittest.expectAsync(((api.ObjectAccessControl response) {

2464 checkObjectAccessControl(response);

2465 })));

2466 });

2467

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

2469

2470 var mock = new common_test.HttpServerMock();

2471 api.ObjectAccessControlsResourceApi res = new api.StorageApi(mock).objectA ccessControls;

2472 var arg_request = buildObjectAccessControl();

2473 var arg_bucket = "foo";

2474 var arg_object = "foo";

2475 var arg_entity = "foo";

2476 var arg_generation = "foo";

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

2478 var obj = new api.ObjectAccessControl.fromJson(json);

2479 checkObjectAccessControl(obj);

2480

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

2482 var pathOffset = 0;

2483 var index;

2484 var subPart;

2485 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2486 pathOffset += 12;

2487 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2488 pathOffset += 2;

2489 index = path.indexOf("/o/", pathOffset);

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

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

2492 pathOffset = index;

2493 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2494 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2495 pathOffset += 3;

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

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

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

2499 pathOffset = index;

2500 unittest.expect(subPart, unittest.equals("$arg_object"));

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

2502 pathOffset += 5;

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

2504 pathOffset = path.length;

2505 unittest.expect(subPart, unittest.equals("$arg_entity"));

2506

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

2508 var queryOffset = 0;

2509 var queryMap = {};

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

2511 parseBool(n) {

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

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

2514 if (n == null) return null;

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

2516 }

2517 if (query.length > 0) {

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

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

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

2521 }

2522 }

2523 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

2524

2525

2526 var h = {

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

2528 };

2529 var resp = convert.JSON.encode(buildObjectAccessControl());

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

2531 }), true);

2532 res.update(arg_request, arg_bucket, arg_object, arg_entity, generation: ar g_generation).then(unittest.expectAsync(((api.ObjectAccessControl response) {

2533 checkObjectAccessControl(response);

2534 })));

2535 });

2536

2537 });

2538

2539

2540 unittest.group("resource-ObjectsResourceApi", () {

2541 unittest.test("method--compose", () {

2542 // TODO: Implement tests for media upload;

2543 // TODO: Implement tests for media download;

2544

2545 var mock = new common_test.HttpServerMock();

2546 api.ObjectsResourceApi res = new api.StorageApi(mock).objects;

2547 var arg_request = buildComposeRequest();

2548 var arg_destinationBucket = "foo";

2549 var arg_destinationObject = "foo";

2550 var arg_destinationPredefinedAcl = "foo";

2551 var arg_ifGenerationMatch = "foo";

2552 var arg_ifMetagenerationMatch = "foo";

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

2554 var obj = new api.ComposeRequest.fromJson(json);

2555 checkComposeRequest(obj);

2556

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

2558 var pathOffset = 0;

2559 var index;

2560 var subPart;

2561 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2562 pathOffset += 12;

2563 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2564 pathOffset += 2;

2565 index = path.indexOf("/o/", pathOffset);

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

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

2568 pathOffset = index;

2569 unittest.expect(subPart, unittest.equals("$arg_destinationBucket"));

2570 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2571 pathOffset += 3;

2572 index = path.indexOf("/compose", pathOffset);

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

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

2575 pathOffset = index;

2576 unittest.expect(subPart, unittest.equals("$arg_destinationObject"));

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

2578 pathOffset += 8;

2579

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

2581 var queryOffset = 0;

2582 var queryMap = {};

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

2584 parseBool(n) {

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

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

2587 if (n == null) return null;

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

2589 }

2590 if (query.length > 0) {

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

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

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

2594 }

2595 }

2596 unittest.expect(queryMap["destinationPredefinedAcl"].first, unittest.equ als(arg_destinationPredefinedAcl));

2597 unittest.expect(queryMap["ifGenerationMatch"].first, unittest.equals(arg _ifGenerationMatch));

2598 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

2599

2600

2601 var h = {

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

2603 };

2604 var resp = convert.JSON.encode(buildObject());

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

2606 }), true);

2607 res.compose(arg_request, arg_destinationBucket, arg_destinationObject, des tinationPredefinedAcl: arg_destinationPredefinedAcl, ifGenerationMatch: arg_ifGe nerationMatch, ifMetagenerationMatch: arg_ifMetagenerationMatch).then(unittest.e xpectAsync(((api.Object response) {

2608 checkObject(response);

2609 })));

2610 });

2611

2612 unittest.test("method--copy", () {

2613 // TODO: Implement tests for media upload;

2614 // TODO: Implement tests for media download;

2615

2616 var mock = new common_test.HttpServerMock();

2617 api.ObjectsResourceApi res = new api.StorageApi(mock).objects;

2618 var arg_request = buildObject();

2619 var arg_sourceBucket = "foo";

2620 var arg_sourceObject = "foo";

2621 var arg_destinationBucket = "foo";

2622 var arg_destinationObject = "foo";

2623 var arg_destinationPredefinedAcl = "foo";

2624 var arg_ifGenerationMatch = "foo";

2625 var arg_ifGenerationNotMatch = "foo";

2626 var arg_ifMetagenerationMatch = "foo";

2627 var arg_ifMetagenerationNotMatch = "foo";

2628 var arg_ifSourceGenerationMatch = "foo";

2629 var arg_ifSourceGenerationNotMatch = "foo";

2630 var arg_ifSourceMetagenerationMatch = "foo";

2631 var arg_ifSourceMetagenerationNotMatch = "foo";

2632 var arg_projection = "foo";

2633 var arg_sourceGeneration = "foo";

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

2635 var obj = new api.Object.fromJson(json);

2636 checkObject(obj);

2637

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

2639 var pathOffset = 0;

2640 var index;

2641 var subPart;

2642 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2643 pathOffset += 12;

2644 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2645 pathOffset += 2;

2646 index = path.indexOf("/o/", pathOffset);

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

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

2649 pathOffset = index;

2650 unittest.expect(subPart, unittest.equals("$arg_sourceBucket"));

2651 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2652 pathOffset += 3;

2653 index = path.indexOf("/copyTo/b/", pathOffset);

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

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

2656 pathOffset = index;

2657 unittest.expect(subPart, unittest.equals("$arg_sourceObject"));

2658 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/copyTo/b/"));

2659 pathOffset += 10;

2660 index = path.indexOf("/o/", pathOffset);

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

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

2663 pathOffset = index;

2664 unittest.expect(subPart, unittest.equals("$arg_destinationBucket"));

2665 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2666 pathOffset += 3;

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

2668 pathOffset = path.length;

2669 unittest.expect(subPart, unittest.equals("$arg_destinationObject"));

2670

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

2672 var queryOffset = 0;

2673 var queryMap = {};

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

2675 parseBool(n) {

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

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

2678 if (n == null) return null;

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

2680 }

2681 if (query.length > 0) {

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

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

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

2685 }

2686 }

2687 unittest.expect(queryMap["destinationPredefinedAcl"].first, unittest.equ als(arg_destinationPredefinedAcl));

2688 unittest.expect(queryMap["ifGenerationMatch"].first, unittest.equals(arg _ifGenerationMatch));

2689 unittest.expect(queryMap["ifGenerationNotMatch"].first, unittest.equals( arg_ifGenerationNotMatch));

2690 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

2691 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

2692 unittest.expect(queryMap["ifSourceGenerationMatch"].first, unittest.equa ls(arg_ifSourceGenerationMatch));

2693 unittest.expect(queryMap["ifSourceGenerationNotMatch"].first, unittest.e quals(arg_ifSourceGenerationNotMatch));

2694 unittest.expect(queryMap["ifSourceMetagenerationMatch"].first, unittest. equals(arg_ifSourceMetagenerationMatch));

2695 unittest.expect(queryMap["ifSourceMetagenerationNotMatch"].first, unitte st.equals(arg_ifSourceMetagenerationNotMatch));

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

2697 unittest.expect(queryMap["sourceGeneration"].first, unittest.equals(arg_ sourceGeneration));

2698

2699

2700 var h = {

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

2702 };

2703 var resp = convert.JSON.encode(buildObject());

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

2705 }), true);

2706 res.copy(arg_request, arg_sourceBucket, arg_sourceObject, arg_destinationB ucket, arg_destinationObject, destinationPredefinedAcl: arg_destinationPredefine dAcl, ifGenerationMatch: arg_ifGenerationMatch, ifGenerationNotMatch: arg_ifGene rationNotMatch, ifMetagenerationMatch: arg_ifMetagenerationMatch, ifMetagenerati onNotMatch: arg_ifMetagenerationNotMatch, ifSourceGenerationMatch: arg_ifSourceG enerationMatch, ifSourceGenerationNotMatch: arg_ifSourceGenerationNotMatch, ifSo urceMetagenerationMatch: arg_ifSourceMetagenerationMatch, ifSourceMetageneration NotMatch: arg_ifSourceMetagenerationNotMatch, projection: arg_projection, source Generation: arg_sourceGeneration).then(unittest.expectAsync(((api.Object respons e) {

2707 checkObject(response);

2708 })));

2709 });

2710

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

2712

2713 var mock = new common_test.HttpServerMock();

2714 api.ObjectsResourceApi res = new api.StorageApi(mock).objects;

2715 var arg_bucket = "foo";

2716 var arg_object = "foo";

2717 var arg_generation = "foo";

2718 var arg_ifGenerationMatch = "foo";

2719 var arg_ifGenerationNotMatch = "foo";

2720 var arg_ifMetagenerationMatch = "foo";

2721 var arg_ifMetagenerationNotMatch = "foo";

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

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

2724 var pathOffset = 0;

2725 var index;

2726 var subPart;

2727 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2728 pathOffset += 12;

2729 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2730 pathOffset += 2;

2731 index = path.indexOf("/o/", pathOffset);

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

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

2734 pathOffset = index;

2735 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2736 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2737 pathOffset += 3;

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

2739 pathOffset = path.length;

2740 unittest.expect(subPart, unittest.equals("$arg_object"));

2741

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

2743 var queryOffset = 0;

2744 var queryMap = {};

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

2746 parseBool(n) {

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

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

2749 if (n == null) return null;

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

2751 }

2752 if (query.length > 0) {

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

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

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

2756 }

2757 }

2758 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

2759 unittest.expect(queryMap["ifGenerationMatch"].first, unittest.equals(arg _ifGenerationMatch));

2760 unittest.expect(queryMap["ifGenerationNotMatch"].first, unittest.equals( arg_ifGenerationNotMatch));

2761 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

2762 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

2763

2764

2765 var h = {

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

2767 };

2768 var resp = "";

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

2770 }), true);

2771 res.delete(arg_bucket, arg_object, generation: arg_generation, ifGeneratio nMatch: arg_ifGenerationMatch, ifGenerationNotMatch: arg_ifGenerationNotMatch, i fMetagenerationMatch: arg_ifMetagenerationMatch, ifMetagenerationNotMatch: arg_i fMetagenerationNotMatch).then(unittest.expectAsync((_) {}));

2772 });

2773

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

2775 // TODO: Implement tests for media upload;

2776 // TODO: Implement tests for media download;

2777

2778 var mock = new common_test.HttpServerMock();

2779 api.ObjectsResourceApi res = new api.StorageApi(mock).objects;

2780 var arg_bucket = "foo";

2781 var arg_object = "foo";

2782 var arg_generation = "foo";

2783 var arg_ifGenerationMatch = "foo";

2784 var arg_ifGenerationNotMatch = "foo";

2785 var arg_ifMetagenerationMatch = "foo";

2786 var arg_ifMetagenerationNotMatch = "foo";

2787 var arg_projection = "foo";

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

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

2790 var pathOffset = 0;

2791 var index;

2792 var subPart;

2793 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2794 pathOffset += 12;

2795 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2796 pathOffset += 2;

2797 index = path.indexOf("/o/", pathOffset);

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

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

2800 pathOffset = index;

2801 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2802 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

2803 pathOffset += 3;

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

2805 pathOffset = path.length;

2806 unittest.expect(subPart, unittest.equals("$arg_object"));

2807

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

2809 var queryOffset = 0;

2810 var queryMap = {};

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

2812 parseBool(n) {

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

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

2815 if (n == null) return null;

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

2817 }

2818 if (query.length > 0) {

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

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

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

2822 }

2823 }

2824 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

2825 unittest.expect(queryMap["ifGenerationMatch"].first, unittest.equals(arg _ifGenerationMatch));

2826 unittest.expect(queryMap["ifGenerationNotMatch"].first, unittest.equals( arg_ifGenerationNotMatch));

2827 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

2828 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

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

2830

2831

2832 var h = {

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

2834 };

2835 var resp = convert.JSON.encode(buildObject());

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

2837 }), true);

2838 res.get(arg_bucket, arg_object, generation: arg_generation, ifGenerationMa tch: arg_ifGenerationMatch, ifGenerationNotMatch: arg_ifGenerationNotMatch, ifMe tagenerationMatch: arg_ifMetagenerationMatch, ifMetagenerationNotMatch: arg_ifMe tagenerationNotMatch, projection: arg_projection).then(unittest.expectAsync(((ap i.Object response) {

2839 checkObject(response);

2840 })));

2841 });

2842

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

2844 // TODO: Implement tests for media upload;

2845 // TODO: Implement tests for media download;

2846

2847 var mock = new common_test.HttpServerMock();

2848 api.ObjectsResourceApi res = new api.StorageApi(mock).objects;

2849 var arg_request = buildObject();

2850 var arg_bucket = "foo";

2851 var arg_contentEncoding = "foo";

2852 var arg_ifGenerationMatch = "foo";

2853 var arg_ifGenerationNotMatch = "foo";

2854 var arg_ifMetagenerationMatch = "foo";

2855 var arg_ifMetagenerationNotMatch = "foo";

2856 var arg_name = "foo";

2857 var arg_predefinedAcl = "foo";

2858 var arg_projection = "foo";

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

2860 var obj = new api.Object.fromJson(json);

2861 checkObject(obj);

2862

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

2864 var pathOffset = 0;

2865 var index;

2866 var subPart;

2867 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2868 pathOffset += 12;

2869 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2870 pathOffset += 2;

2871 index = path.indexOf("/o", pathOffset);

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

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

2874 pathOffset = index;

2875 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2876 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("/o"));

2877 pathOffset += 2;

2878

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

2880 var queryOffset = 0;

2881 var queryMap = {};

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

2883 parseBool(n) {

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

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

2886 if (n == null) return null;

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

2888 }

2889 if (query.length > 0) {

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

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

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

2893 }

2894 }

2895 unittest.expect(queryMap["contentEncoding"].first, unittest.equals(arg_c ontentEncoding));

2896 unittest.expect(queryMap["ifGenerationMatch"].first, unittest.equals(arg _ifGenerationMatch));

2897 unittest.expect(queryMap["ifGenerationNotMatch"].first, unittest.equals( arg_ifGenerationNotMatch));

2898 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

2899 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

2900 unittest.expect(queryMap["name"].first, unittest.equals(arg_name));

2901 unittest.expect(queryMap["predefinedAcl"].first, unittest.equals(arg_pre definedAcl));

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

2903

2904

2905 var h = {

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

2907 };

2908 var resp = convert.JSON.encode(buildObject());

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

2910 }), true);

2911 res.insert(arg_request, arg_bucket, contentEncoding: arg_contentEncoding, ifGenerationMatch: arg_ifGenerationMatch, ifGenerationNotMatch: arg_ifGeneration NotMatch, ifMetagenerationMatch: arg_ifMetagenerationMatch, ifMetagenerationNotM atch: arg_ifMetagenerationNotMatch, name: arg_name, predefinedAcl: arg_predefine dAcl, projection: arg_projection).then(unittest.expectAsync(((api.Object respons e) {

2912 checkObject(response);

2913 })));

2914 });

2915

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

2917

2918 var mock = new common_test.HttpServerMock();

2919 api.ObjectsResourceApi res = new api.StorageApi(mock).objects;

2920 var arg_bucket = "foo";

2921 var arg_delimiter = "foo";

2922 var arg_maxResults = 42;

2923 var arg_pageToken = "foo";

2924 var arg_prefix = "foo";

2925 var arg_projection = "foo";

2926 var arg_versions = true;

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

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

2929 var pathOffset = 0;

2930 var index;

2931 var subPart;

2932 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

2933 pathOffset += 12;

2934 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

2935 pathOffset += 2;

2936 index = path.indexOf("/o", pathOffset);

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

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

2939 pathOffset = index;

2940 unittest.expect(subPart, unittest.equals("$arg_bucket"));

2941 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("/o"));

2942 pathOffset += 2;

2943

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

2945 var queryOffset = 0;

2946 var queryMap = {};

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

2948 parseBool(n) {

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

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

2951 if (n == null) return null;

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

2953 }

2954 if (query.length > 0) {

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

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

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

2958 }

2959 }

2960 unittest.expect(queryMap["delimiter"].first, unittest.equals(arg_delimit er));

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

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

2963 unittest.expect(queryMap["prefix"].first, unittest.equals(arg_prefix));

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

2965 unittest.expect(queryMap["versions"].first, unittest.equals("$arg_versio ns"));

2966

2967

2968 var h = {

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

2970 };

2971 var resp = convert.JSON.encode(buildObjects());

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

2973 }), true);

2974 res.list(arg_bucket, delimiter: arg_delimiter, maxResults: arg_maxResults, pageToken: arg_pageToken, prefix: arg_prefix, projection: arg_projection, versi ons: arg_versions).then(unittest.expectAsync(((api.Objects response) {

2975 checkObjects(response);

2976 })));

2977 });

2978

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

2980

2981 var mock = new common_test.HttpServerMock();

2982 api.ObjectsResourceApi res = new api.StorageApi(mock).objects;

2983 var arg_request = buildObject();

2984 var arg_bucket = "foo";

2985 var arg_object = "foo";

2986 var arg_generation = "foo";

2987 var arg_ifGenerationMatch = "foo";

2988 var arg_ifGenerationNotMatch = "foo";

2989 var arg_ifMetagenerationMatch = "foo";

2990 var arg_ifMetagenerationNotMatch = "foo";

2991 var arg_predefinedAcl = "foo";

2992 var arg_projection = "foo";

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

2994 var obj = new api.Object.fromJson(json);

2995 checkObject(obj);

2996

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

2998 var pathOffset = 0;

2999 var index;

3000 var subPart;

3001 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

3002 pathOffset += 12;

3003 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

3004 pathOffset += 2;

3005 index = path.indexOf("/o/", pathOffset);

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

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

3008 pathOffset = index;

3009 unittest.expect(subPart, unittest.equals("$arg_bucket"));

3010 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

3011 pathOffset += 3;

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

3013 pathOffset = path.length;

3014 unittest.expect(subPart, unittest.equals("$arg_object"));

3015

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

3017 var queryOffset = 0;

3018 var queryMap = {};

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

3020 parseBool(n) {

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

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

3023 if (n == null) return null;

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

3025 }

3026 if (query.length > 0) {

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

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

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

3030 }

3031 }

3032 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

3033 unittest.expect(queryMap["ifGenerationMatch"].first, unittest.equals(arg _ifGenerationMatch));

3034 unittest.expect(queryMap["ifGenerationNotMatch"].first, unittest.equals( arg_ifGenerationNotMatch));

3035 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

3036 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

3037 unittest.expect(queryMap["predefinedAcl"].first, unittest.equals(arg_pre definedAcl));

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

3039

3040

3041 var h = {

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

3043 };

3044 var resp = convert.JSON.encode(buildObject());

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

3046 }), true);

3047 res.patch(arg_request, arg_bucket, arg_object, generation: arg_generation, ifGenerationMatch: arg_ifGenerationMatch, ifGenerationNotMatch: arg_ifGeneratio nNotMatch, ifMetagenerationMatch: arg_ifMetagenerationMatch, ifMetagenerationNot Match: arg_ifMetagenerationNotMatch, predefinedAcl: arg_predefinedAcl, projectio n: arg_projection).then(unittest.expectAsync(((api.Object response) {

3048 checkObject(response);

3049 })));

3050 });

3051

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

3053 // TODO: Implement tests for media upload;

3054 // TODO: Implement tests for media download;

3055

3056 var mock = new common_test.HttpServerMock();

3057 api.ObjectsResourceApi res = new api.StorageApi(mock).objects;

3058 var arg_request = buildObject();

3059 var arg_bucket = "foo";

3060 var arg_object = "foo";

3061 var arg_generation = "foo";

3062 var arg_ifGenerationMatch = "foo";

3063 var arg_ifGenerationNotMatch = "foo";

3064 var arg_ifMetagenerationMatch = "foo";

3065 var arg_ifMetagenerationNotMatch = "foo";

3066 var arg_predefinedAcl = "foo";

3067 var arg_projection = "foo";

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

3069 var obj = new api.Object.fromJson(json);

3070 checkObject(obj);

3071

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

3073 var pathOffset = 0;

3074 var index;

3075 var subPart;

3076 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

3077 pathOffset += 12;

3078 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

3079 pathOffset += 2;

3080 index = path.indexOf("/o/", pathOffset);

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

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

3083 pathOffset = index;

3084 unittest.expect(subPart, unittest.equals("$arg_bucket"));

3085 unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equ als("/o/"));

3086 pathOffset += 3;

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

3088 pathOffset = path.length;

3089 unittest.expect(subPart, unittest.equals("$arg_object"));

3090

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

3092 var queryOffset = 0;

3093 var queryMap = {};

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

3095 parseBool(n) {

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

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

3098 if (n == null) return null;

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

3100 }

3101 if (query.length > 0) {

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

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

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

3105 }

3106 }

3107 unittest.expect(queryMap["generation"].first, unittest.equals(arg_genera tion));

3108 unittest.expect(queryMap["ifGenerationMatch"].first, unittest.equals(arg _ifGenerationMatch));

3109 unittest.expect(queryMap["ifGenerationNotMatch"].first, unittest.equals( arg_ifGenerationNotMatch));

3110 unittest.expect(queryMap["ifMetagenerationMatch"].first, unittest.equals (arg_ifMetagenerationMatch));

3111 unittest.expect(queryMap["ifMetagenerationNotMatch"].first, unittest.equ als(arg_ifMetagenerationNotMatch));

3112 unittest.expect(queryMap["predefinedAcl"].first, unittest.equals(arg_pre definedAcl));

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

3114

3115

3116 var h = {

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

3118 };

3119 var resp = convert.JSON.encode(buildObject());

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

3121 }), true);

3122 res.update(arg_request, arg_bucket, arg_object, generation: arg_generation , ifGenerationMatch: arg_ifGenerationMatch, ifGenerationNotMatch: arg_ifGenerati onNotMatch, ifMetagenerationMatch: arg_ifMetagenerationMatch, ifMetagenerationNo tMatch: arg_ifMetagenerationNotMatch, predefinedAcl: arg_predefinedAcl, projecti on: arg_projection).then(unittest.expectAsync(((api.Object response) {

3123 checkObject(response);

3124 })));

3125 });

3126

3127 unittest.test("method--watchAll", () {

3128

3129 var mock = new common_test.HttpServerMock();

3130 api.ObjectsResourceApi res = new api.StorageApi(mock).objects;

3131 var arg_request = buildChannel();

3132 var arg_bucket = "foo";

3133 var arg_delimiter = "foo";

3134 var arg_maxResults = 42;

3135 var arg_pageToken = "foo";

3136 var arg_prefix = "foo";

3137 var arg_projection = "foo";

3138 var arg_versions = true;

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

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

3141 checkChannel(obj);

3142

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

3144 var pathOffset = 0;

3145 var index;

3146 var subPart;

3147 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/storage/v1/"));

3148 pathOffset += 12;

3149 unittest.expect(path.substring(pathOffset, pathOffset + 2), unittest.equ als("b/"));

3150 pathOffset += 2;

3151 index = path.indexOf("/o/watch", pathOffset);

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

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

3154 pathOffset = index;

3155 unittest.expect(subPart, unittest.equals("$arg_bucket"));

3156 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/o/watch"));

3157 pathOffset += 8;

3158

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

3160 var queryOffset = 0;

3161 var queryMap = {};

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

3163 parseBool(n) {

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

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

3166 if (n == null) return null;

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

3168 }

3169 if (query.length > 0) {

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

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

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

3173 }

3174 }

3175 unittest.expect(queryMap["delimiter"].first, unittest.equals(arg_delimit er));

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

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

3178 unittest.expect(queryMap["prefix"].first, unittest.equals(arg_prefix));

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

3180 unittest.expect(queryMap["versions"].first, unittest.equals("$arg_versio ns"));

3181

3182

3183 var h = {

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

3185 };

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

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

3188 }), true);

3189 res.watchAll(arg_request, arg_bucket, delimiter: arg_delimiter, maxResults : arg_maxResults, pageToken: arg_pageToken, prefix: arg_prefix, projection: arg_ projection, versions: arg_versions).then(unittest.expectAsync(((api.Channel resp onse) {

3190 checkChannel(response);

3191 })));

3192 });

3193

3194 });

3195

3196

3197 }

3198

OLD	NEW

« no previous file with comments | « generated/googleapis/test/siteverification/v1_test.dart ('k') | generated/googleapis/test/storage/v1_test.dart » ('j') | no next file with comments »