generated/googleapis_beta/test/genomics/v1beta.dart - Issue 560323003: Add discovery service to stable APIs

Side by Side Diff: generated/googleapis_beta/test/genomics/v1beta.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.

Jump to:

View unified diff |

OLD	NEW
	(Empty)
1 library googleapis_beta.genomics.v1beta.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_beta/common/common.dart' as common;

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

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

14

15 import 'package:googleapis_beta/genomics/v1beta.dart' as api;

16

17

18

19 core.int buildCounterBeacon = 0;

20 buildBeacon() {

21 var o = new api.Beacon();

22 buildCounterBeacon++;

23 if (buildCounterBeacon < 3) {

24 o.exists = true;

25 }

26 buildCounterBeacon--;

27 return o;

28 }

29

30 checkBeacon(api.Beacon o) {

31 buildCounterBeacon++;

32 if (buildCounterBeacon < 3) {

33 unittest.expect(o.exists, unittest.isTrue);

34 }

35 buildCounterBeacon--;

36 }

37

38 buildUnnamed1122() {

39 var o = new core.List<core.int>();

40 o.add(42);

41 o.add(42);

42 return o;

43 }

44

45 checkUnnamed1122(core.List<core.int> o) {

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

47 unittest.expect(o[0], unittest.equals(42));

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

49 }

50

51 buildUnnamed1123() {

52 var o = new core.List<core.double>();

53 o.add(42.0);

54 o.add(42.0);

55 return o;

56 }

57

58 checkUnnamed1123(core.List<core.double> o) {

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

60 unittest.expect(o[0], unittest.equals(42.0));

61 unittest.expect(o[1], unittest.equals(42.0));

62 }

63

64 buildUnnamed1124() {

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

66 o.add("foo");

67 o.add("foo");

68 return o;

69 }

70

71 checkUnnamed1124(core.List<core.String> o) {

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

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

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

75 }

76

77 buildUnnamed1125() {

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

79 o["x"] = buildUnnamed1124();

80 o["y"] = buildUnnamed1124();

81 return o;

82 }

83

84 checkUnnamed1125(core.Map<core.String, core.List<core.String>> o) {

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

86 checkUnnamed1124(o["x"]);

87 checkUnnamed1124(o["y"]);

88 }

89

90 core.int buildCounterCall = 0;

91 buildCall() {

92 var o = new api.Call();

93 buildCounterCall++;

94 if (buildCounterCall < 3) {

95 o.callsetId = "foo";

96 o.callsetName = "foo";

97 o.genotype = buildUnnamed1122();

98 o.genotypeLikelihood = buildUnnamed1123();

99 o.info = buildUnnamed1125();

100 o.phaseset = "foo";

101 }

102 buildCounterCall--;

103 return o;

104 }

105

106 checkCall(api.Call o) {

107 buildCounterCall++;

108 if (buildCounterCall < 3) {

109 unittest.expect(o.callsetId, unittest.equals('foo'));

110 unittest.expect(o.callsetName, unittest.equals('foo'));

111 checkUnnamed1122(o.genotype);

112 checkUnnamed1123(o.genotypeLikelihood);

113 checkUnnamed1125(o.info);

114 unittest.expect(o.phaseset, unittest.equals('foo'));

115 }

116 buildCounterCall--;

117 }

118

119 buildUnnamed1126() {

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

121 o.add("foo");

122 o.add("foo");

123 return o;

124 }

125

126 checkUnnamed1126(core.List<core.String> o) {

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

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

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

130 }

131

132 buildUnnamed1127() {

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

134 o["x"] = buildUnnamed1126();

135 o["y"] = buildUnnamed1126();

136 return o;

137 }

138

139 checkUnnamed1127(core.Map<core.String, core.List<core.String>> o) {

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

141 checkUnnamed1126(o["x"]);

142 checkUnnamed1126(o["y"]);

143 }

144

145 core.int buildCounterCallset = 0;

146 buildCallset() {

147 var o = new api.Callset();

148 buildCounterCallset++;

149 if (buildCounterCallset < 3) {

150 o.created = "foo";

151 o.id = "foo";

152 o.info = buildUnnamed1127();

153 o.name = "foo";

154 o.variantsetId = "foo";

155 }

156 buildCounterCallset--;

157 return o;

158 }

159

160 checkCallset(api.Callset o) {

161 buildCounterCallset++;

162 if (buildCounterCallset < 3) {

163 unittest.expect(o.created, unittest.equals('foo'));

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

165 checkUnnamed1127(o.info);

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

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

168 }

169 buildCounterCallset--;

170 }

171

172 core.int buildCounterContigBound = 0;

173 buildContigBound() {

174 var o = new api.ContigBound();

175 buildCounterContigBound++;

176 if (buildCounterContigBound < 3) {

177 o.contig = "foo";

178 o.upperBound = "foo";

179 }

180 buildCounterContigBound--;

181 return o;

182 }

183

184 checkContigBound(api.ContigBound o) {

185 buildCounterContigBound++;

186 if (buildCounterContigBound < 3) {

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

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

189 }

190 buildCounterContigBound--;

191 }

192

193 core.int buildCounterCoverageBucket = 0;

194 buildCoverageBucket() {

195 var o = new api.CoverageBucket();

196 buildCounterCoverageBucket++;

197 if (buildCounterCoverageBucket < 3) {

198 o.meanCoverage = 42.0;

199 o.range = buildGenomicRange();

200 }

201 buildCounterCoverageBucket--;

202 return o;

203 }

204

205 checkCoverageBucket(api.CoverageBucket o) {

206 buildCounterCoverageBucket++;

207 if (buildCounterCoverageBucket < 3) {

208 unittest.expect(o.meanCoverage, unittest.equals(42.0));

209 checkGenomicRange(o.range);

210 }

211 buildCounterCoverageBucket--;

212 }

213

214 core.int buildCounterDataset = 0;

215 buildDataset() {

216 var o = new api.Dataset();

217 buildCounterDataset++;

218 if (buildCounterDataset < 3) {

219 o.id = "foo";

220 o.isPublic = true;

221 o.name = "foo";

222 o.projectId = "foo";

223 }

224 buildCounterDataset--;

225 return o;

226 }

227

228 checkDataset(api.Dataset o) {

229 buildCounterDataset++;

230 if (buildCounterDataset < 3) {

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

232 unittest.expect(o.isPublic, unittest.isTrue);

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

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

235 }

236 buildCounterDataset--;

237 }

238

239 buildUnnamed1128() {

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

241 o.add("foo");

242 o.add("foo");

243 return o;

244 }

245

246 checkUnnamed1128(core.List<core.String> o) {

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

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

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

250 }

251

252 buildUnnamed1129() {

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

254 o.add("foo");

255 o.add("foo");

256 return o;

257 }

258

259 checkUnnamed1129(core.List<core.String> o) {

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

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

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

263 }

264

265 core.int buildCounterExperimentalCreateJobRequest = 0;

266 buildExperimentalCreateJobRequest() {

267 var o = new api.ExperimentalCreateJobRequest();

268 buildCounterExperimentalCreateJobRequest++;

269 if (buildCounterExperimentalCreateJobRequest < 3) {

270 o.align = true;

271 o.callVariants = true;

272 o.gcsOutputPath = "foo";

273 o.pairedSourceUris = buildUnnamed1128();

274 o.projectId = "foo";

275 o.sourceUris = buildUnnamed1129();

276 }

277 buildCounterExperimentalCreateJobRequest--;

278 return o;

279 }

280

281 checkExperimentalCreateJobRequest(api.ExperimentalCreateJobRequest o) {

282 buildCounterExperimentalCreateJobRequest++;

283 if (buildCounterExperimentalCreateJobRequest < 3) {

284 unittest.expect(o.align, unittest.isTrue);

285 unittest.expect(o.callVariants, unittest.isTrue);

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

287 checkUnnamed1128(o.pairedSourceUris);

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

289 checkUnnamed1129(o.sourceUris);

290 }

291 buildCounterExperimentalCreateJobRequest--;

292 }

293

294 core.int buildCounterExperimentalCreateJobResponse = 0;

295 buildExperimentalCreateJobResponse() {

296 var o = new api.ExperimentalCreateJobResponse();

297 buildCounterExperimentalCreateJobResponse++;

298 if (buildCounterExperimentalCreateJobResponse < 3) {

299 o.jobId = "foo";

300 }

301 buildCounterExperimentalCreateJobResponse--;

302 return o;

303 }

304

305 checkExperimentalCreateJobResponse(api.ExperimentalCreateJobResponse o) {

306 buildCounterExperimentalCreateJobResponse++;

307 if (buildCounterExperimentalCreateJobResponse < 3) {

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

309 }

310 buildCounterExperimentalCreateJobResponse--;

311 }

312

313 buildUnnamed1130() {

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

315 o.add("foo");

316 o.add("foo");

317 return o;

318 }

319

320 checkUnnamed1130(core.List<core.String> o) {

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

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

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

324 }

325

326 buildUnnamed1131() {

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

328 o.add("foo");

329 o.add("foo");

330 return o;

331 }

332

333 checkUnnamed1131(core.List<core.String> o) {

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

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

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

337 }

338

339 core.int buildCounterExportReadsetsRequest = 0;

340 buildExportReadsetsRequest() {

341 var o = new api.ExportReadsetsRequest();

342 buildCounterExportReadsetsRequest++;

343 if (buildCounterExportReadsetsRequest < 3) {

344 o.exportUri = "foo";

345 o.projectId = "foo";

346 o.readsetIds = buildUnnamed1130();

347 o.referenceNames = buildUnnamed1131();

348 }

349 buildCounterExportReadsetsRequest--;

350 return o;

351 }

352

353 checkExportReadsetsRequest(api.ExportReadsetsRequest o) {

354 buildCounterExportReadsetsRequest++;

355 if (buildCounterExportReadsetsRequest < 3) {

356 unittest.expect(o.exportUri, unittest.equals('foo'));

357 unittest.expect(o.projectId, unittest.equals('foo'));

358 checkUnnamed1130(o.readsetIds);

359 checkUnnamed1131(o.referenceNames);

360 }

361 buildCounterExportReadsetsRequest--;

362 }

363

364 core.int buildCounterExportReadsetsResponse = 0;

365 buildExportReadsetsResponse() {

366 var o = new api.ExportReadsetsResponse();

367 buildCounterExportReadsetsResponse++;

368 if (buildCounterExportReadsetsResponse < 3) {

369 o.jobId = "foo";

370 }

371 buildCounterExportReadsetsResponse--;

372 return o;

373 }

374

375 checkExportReadsetsResponse(api.ExportReadsetsResponse o) {

376 buildCounterExportReadsetsResponse++;

377 if (buildCounterExportReadsetsResponse < 3) {

378 unittest.expect(o.jobId, unittest.equals('foo'));

379 }

380 buildCounterExportReadsetsResponse--;

381 }

382

383 buildUnnamed1132() {

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

385 o.add("foo");

386 o.add("foo");

387 return o;

388 }

389

390 checkUnnamed1132(core.List<core.String> o) {

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

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

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

394 }

395

396 core.int buildCounterExportVariantsRequest = 0;

397 buildExportVariantsRequest() {

398 var o = new api.ExportVariantsRequest();

399 buildCounterExportVariantsRequest++;

400 if (buildCounterExportVariantsRequest < 3) {

401 o.bigqueryDataset = "foo";

402 o.bigqueryTable = "foo";

403 o.callsetIds = buildUnnamed1132();

404 o.format = "foo";

405 o.projectId = "foo";

406 o.variantsetId = "foo";

407 }

408 buildCounterExportVariantsRequest--;

409 return o;

410 }

411

412 checkExportVariantsRequest(api.ExportVariantsRequest o) {

413 buildCounterExportVariantsRequest++;

414 if (buildCounterExportVariantsRequest < 3) {

415 unittest.expect(o.bigqueryDataset, unittest.equals('foo'));

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

417 checkUnnamed1132(o.callsetIds);

418 unittest.expect(o.format, unittest.equals('foo'));

419 unittest.expect(o.projectId, unittest.equals('foo'));

420 unittest.expect(o.variantsetId, unittest.equals('foo'));

421 }

422 buildCounterExportVariantsRequest--;

423 }

424

425 core.int buildCounterExportVariantsResponse = 0;

426 buildExportVariantsResponse() {

427 var o = new api.ExportVariantsResponse();

428 buildCounterExportVariantsResponse++;

429 if (buildCounterExportVariantsResponse < 3) {

430 o.jobId = "foo";

431 }

432 buildCounterExportVariantsResponse--;

433 return o;

434 }

435

436 checkExportVariantsResponse(api.ExportVariantsResponse o) {

437 buildCounterExportVariantsResponse++;

438 if (buildCounterExportVariantsResponse < 3) {

439 unittest.expect(o.jobId, unittest.equals('foo'));

440 }

441 buildCounterExportVariantsResponse--;

442 }

443

444 core.int buildCounterGenomicRange = 0;

445 buildGenomicRange() {

446 var o = new api.GenomicRange();

447 buildCounterGenomicRange++;

448 if (buildCounterGenomicRange < 3) {

449 o.sequenceEnd = "foo";

450 o.sequenceName = "foo";

451 o.sequenceStart = "foo";

452 }

453 buildCounterGenomicRange--;

454 return o;

455 }

456

457 checkGenomicRange(api.GenomicRange o) {

458 buildCounterGenomicRange++;

459 if (buildCounterGenomicRange < 3) {

460 unittest.expect(o.sequenceEnd, unittest.equals('foo'));

461 unittest.expect(o.sequenceName, unittest.equals('foo'));

462 unittest.expect(o.sequenceStart, unittest.equals('foo'));

463 }

464 buildCounterGenomicRange--;

465 }

466

467 buildUnnamed1133() {

468 var o = new core.List<api.ContigBound>();

469 o.add(buildContigBound());

470 o.add(buildContigBound());

471 return o;

472 }

473

474 checkUnnamed1133(core.List<api.ContigBound> o) {

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

476 checkContigBound(o[0]);

477 checkContigBound(o[1]);

478 }

479

480 buildUnnamed1134() {

481 var o = new core.List<api.Metadata>();

482 o.add(buildMetadata());

483 o.add(buildMetadata());

484 return o;

485 }

486

487 checkUnnamed1134(core.List<api.Metadata> o) {

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

489 checkMetadata(o[0]);

490 checkMetadata(o[1]);

491 }

492

493 core.int buildCounterGetVariantsSummaryResponse = 0;

494 buildGetVariantsSummaryResponse() {

495 var o = new api.GetVariantsSummaryResponse();

496 buildCounterGetVariantsSummaryResponse++;

497 if (buildCounterGetVariantsSummaryResponse < 3) {

498 o.contigBounds = buildUnnamed1133();

499 o.metadata = buildUnnamed1134();

500 }

501 buildCounterGetVariantsSummaryResponse--;

502 return o;

503 }

504

505 checkGetVariantsSummaryResponse(api.GetVariantsSummaryResponse o) {

506 buildCounterGetVariantsSummaryResponse++;

507 if (buildCounterGetVariantsSummaryResponse < 3) {

508 checkUnnamed1133(o.contigBounds);

509 checkUnnamed1134(o.metadata);

510 }

511 buildCounterGetVariantsSummaryResponse--;

512 }

513

514 core.int buildCounterHeader = 0;

515 buildHeader() {

516 var o = new api.Header();

517 buildCounterHeader++;

518 if (buildCounterHeader < 3) {

519 o.sortingOrder = "foo";

520 o.version = "foo";

521 }

522 buildCounterHeader--;

523 return o;

524 }

525

526 checkHeader(api.Header o) {

527 buildCounterHeader++;

528 if (buildCounterHeader < 3) {

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

530 unittest.expect(o.version, unittest.equals('foo'));

531 }

532 buildCounterHeader--;

533 }

534

535 buildUnnamed1135() {

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

537 o.add("foo");

538 o.add("foo");

539 return o;

540 }

541

542 checkUnnamed1135(core.List<core.String> o) {

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

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

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

546 }

547

548 buildUnnamed1136() {

549 var o = new core.List<api.Header>();

550 o.add(buildHeader());

551 o.add(buildHeader());

552 return o;

553 }

554

555 checkUnnamed1136(core.List<api.Header> o) {

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

557 checkHeader(o[0]);

558 checkHeader(o[1]);

559 }

560

561 buildUnnamed1137() {

562 var o = new core.List<api.Program>();

563 o.add(buildProgram());

564 o.add(buildProgram());

565 return o;

566 }

567

568 checkUnnamed1137(core.List<api.Program> o) {

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

570 checkProgram(o[0]);

571 checkProgram(o[1]);

572 }

573

574 buildUnnamed1138() {

575 var o = new core.List<api.ReadGroup>();

576 o.add(buildReadGroup());

577 o.add(buildReadGroup());

578 return o;

579 }

580

581 checkUnnamed1138(core.List<api.ReadGroup> o) {

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

583 checkReadGroup(o[0]);

584 checkReadGroup(o[1]);

585 }

586

587 buildUnnamed1139() {

588 var o = new core.List<api.ReferenceSequence>();

589 o.add(buildReferenceSequence());

590 o.add(buildReferenceSequence());

591 return o;

592 }

593

594 checkUnnamed1139(core.List<api.ReferenceSequence> o) {

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

596 checkReferenceSequence(o[0]);

597 checkReferenceSequence(o[1]);

598 }

599

600 core.int buildCounterHeaderSection = 0;

601 buildHeaderSection() {

602 var o = new api.HeaderSection();

603 buildCounterHeaderSection++;

604 if (buildCounterHeaderSection < 3) {

605 o.comments = buildUnnamed1135();

606 o.fileUri = "foo";

607 o.filename = "foo";

608 o.headers = buildUnnamed1136();

609 o.programs = buildUnnamed1137();

610 o.readGroups = buildUnnamed1138();

611 o.refSequences = buildUnnamed1139();

612 }

613 buildCounterHeaderSection--;

614 return o;

615 }

616

617 checkHeaderSection(api.HeaderSection o) {

618 buildCounterHeaderSection++;

619 if (buildCounterHeaderSection < 3) {

620 checkUnnamed1135(o.comments);

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

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

623 checkUnnamed1136(o.headers);

624 checkUnnamed1137(o.programs);

625 checkUnnamed1138(o.readGroups);

626 checkUnnamed1139(o.refSequences);

627 }

628 buildCounterHeaderSection--;

629 }

630

631 buildUnnamed1140() {

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

633 o.add("foo");

634 o.add("foo");

635 return o;

636 }

637

638 checkUnnamed1140(core.List<core.String> o) {

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

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

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

642 }

643

644 core.int buildCounterImportReadsetsRequest = 0;

645 buildImportReadsetsRequest() {

646 var o = new api.ImportReadsetsRequest();

647 buildCounterImportReadsetsRequest++;

648 if (buildCounterImportReadsetsRequest < 3) {

649 o.datasetId = "foo";

650 o.sourceUris = buildUnnamed1140();

651 }

652 buildCounterImportReadsetsRequest--;

653 return o;

654 }

655

656 checkImportReadsetsRequest(api.ImportReadsetsRequest o) {

657 buildCounterImportReadsetsRequest++;

658 if (buildCounterImportReadsetsRequest < 3) {

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

660 checkUnnamed1140(o.sourceUris);

661 }

662 buildCounterImportReadsetsRequest--;

663 }

664

665 core.int buildCounterImportReadsetsResponse = 0;

666 buildImportReadsetsResponse() {

667 var o = new api.ImportReadsetsResponse();

668 buildCounterImportReadsetsResponse++;

669 if (buildCounterImportReadsetsResponse < 3) {

670 o.jobId = "foo";

671 }

672 buildCounterImportReadsetsResponse--;

673 return o;

674 }

675

676 checkImportReadsetsResponse(api.ImportReadsetsResponse o) {

677 buildCounterImportReadsetsResponse++;

678 if (buildCounterImportReadsetsResponse < 3) {

679 unittest.expect(o.jobId, unittest.equals('foo'));

680 }

681 buildCounterImportReadsetsResponse--;

682 }

683

684 buildUnnamed1141() {

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

686 o.add("foo");

687 o.add("foo");

688 return o;

689 }

690

691 checkUnnamed1141(core.List<core.String> o) {

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

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

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

695 }

696

697 core.int buildCounterImportVariantsRequest = 0;

698 buildImportVariantsRequest() {

699 var o = new api.ImportVariantsRequest();

700 buildCounterImportVariantsRequest++;

701 if (buildCounterImportVariantsRequest < 3) {

702 o.format = "foo";

703 o.sourceUris = buildUnnamed1141();

704 o.variantsetId = "foo";

705 }

706 buildCounterImportVariantsRequest--;

707 return o;

708 }

709

710 checkImportVariantsRequest(api.ImportVariantsRequest o) {

711 buildCounterImportVariantsRequest++;

712 if (buildCounterImportVariantsRequest < 3) {

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

714 checkUnnamed1141(o.sourceUris);

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

716 }

717 buildCounterImportVariantsRequest--;

718 }

719

720 core.int buildCounterImportVariantsResponse = 0;

721 buildImportVariantsResponse() {

722 var o = new api.ImportVariantsResponse();

723 buildCounterImportVariantsResponse++;

724 if (buildCounterImportVariantsResponse < 3) {

725 o.jobId = "foo";

726 }

727 buildCounterImportVariantsResponse--;

728 return o;

729 }

730

731 checkImportVariantsResponse(api.ImportVariantsResponse o) {

732 buildCounterImportVariantsResponse++;

733 if (buildCounterImportVariantsResponse < 3) {

734 unittest.expect(o.jobId, unittest.equals('foo'));

735 }

736 buildCounterImportVariantsResponse--;

737 }

738

739 buildUnnamed1142() {

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

741 o.add("foo");

742 o.add("foo");

743 return o;

744 }

745

746 checkUnnamed1142(core.List<core.String> o) {

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

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

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

750 }

751

752 buildUnnamed1143() {

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

754 o.add("foo");

755 o.add("foo");

756 return o;

757 }

758

759 checkUnnamed1143(core.List<core.String> o) {

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

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

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

763 }

764

765 buildUnnamed1144() {

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

767 o.add("foo");

768 o.add("foo");

769 return o;

770 }

771

772 checkUnnamed1144(core.List<core.String> o) {

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

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

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

776 }

777

778 core.int buildCounterJob = 0;

779 buildJob() {

780 var o = new api.Job();

781 buildCounterJob++;

782 if (buildCounterJob < 3) {

783 o.created = "foo";

784 o.description = "foo";

785 o.errors = buildUnnamed1142();

786 o.id = "foo";

787 o.importedIds = buildUnnamed1143();

788 o.projectId = "foo";

789 o.request = buildJobRequest();

790 o.status = "foo";

791 o.warnings = buildUnnamed1144();

792 }

793 buildCounterJob--;

794 return o;

795 }

796

797 checkJob(api.Job o) {

798 buildCounterJob++;

799 if (buildCounterJob < 3) {

800 unittest.expect(o.created, unittest.equals('foo'));

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

802 checkUnnamed1142(o.errors);

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

804 checkUnnamed1143(o.importedIds);

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

806 checkJobRequest(o.request);

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

808 checkUnnamed1144(o.warnings);

809 }

810 buildCounterJob--;

811 }

812

813 buildUnnamed1145() {

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

815 o.add("foo");

816 o.add("foo");

817 return o;

818 }

819

820 checkUnnamed1145(core.List<core.String> o) {

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

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

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

824 }

825

826 buildUnnamed1146() {

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

828 o.add("foo");

829 o.add("foo");

830 return o;

831 }

832

833 checkUnnamed1146(core.List<core.String> o) {

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

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

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

837 }

838

839 core.int buildCounterJobRequest = 0;

840 buildJobRequest() {

841 var o = new api.JobRequest();

842 buildCounterJobRequest++;

843 if (buildCounterJobRequest < 3) {

844 o.destination = buildUnnamed1145();

845 o.source = buildUnnamed1146();

846 o.type = "foo";

847 }

848 buildCounterJobRequest--;

849 return o;

850 }

851

852 checkJobRequest(api.JobRequest o) {

853 buildCounterJobRequest++;

854 if (buildCounterJobRequest < 3) {

855 checkUnnamed1145(o.destination);

856 checkUnnamed1146(o.source);

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

858 }

859 buildCounterJobRequest--;

860 }

861

862 buildUnnamed1147() {

863 var o = new core.List<api.CoverageBucket>();

864 o.add(buildCoverageBucket());

865 o.add(buildCoverageBucket());

866 return o;

867 }

868

869 checkUnnamed1147(core.List<api.CoverageBucket> o) {

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

871 checkCoverageBucket(o[0]);

872 checkCoverageBucket(o[1]);

873 }

874

875 core.int buildCounterListCoverageBucketsResponse = 0;

876 buildListCoverageBucketsResponse() {

877 var o = new api.ListCoverageBucketsResponse();

878 buildCounterListCoverageBucketsResponse++;

879 if (buildCounterListCoverageBucketsResponse < 3) {

880 o.bucketWidth = "foo";

881 o.coverageBuckets = buildUnnamed1147();

882 o.nextPageToken = "foo";

883 }

884 buildCounterListCoverageBucketsResponse--;

885 return o;

886 }

887

888 checkListCoverageBucketsResponse(api.ListCoverageBucketsResponse o) {

889 buildCounterListCoverageBucketsResponse++;

890 if (buildCounterListCoverageBucketsResponse < 3) {

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

892 checkUnnamed1147(o.coverageBuckets);

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

894 }

895 buildCounterListCoverageBucketsResponse--;

896 }

897

898 buildUnnamed1148() {

899 var o = new core.List<api.Dataset>();

900 o.add(buildDataset());

901 o.add(buildDataset());

902 return o;

903 }

904

905 checkUnnamed1148(core.List<api.Dataset> o) {

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

907 checkDataset(o[0]);

908 checkDataset(o[1]);

909 }

910

911 core.int buildCounterListDatasetsResponse = 0;

912 buildListDatasetsResponse() {

913 var o = new api.ListDatasetsResponse();

914 buildCounterListDatasetsResponse++;

915 if (buildCounterListDatasetsResponse < 3) {

916 o.datasets = buildUnnamed1148();

917 o.nextPageToken = "foo";

918 }

919 buildCounterListDatasetsResponse--;

920 return o;

921 }

922

923 checkListDatasetsResponse(api.ListDatasetsResponse o) {

924 buildCounterListDatasetsResponse++;

925 if (buildCounterListDatasetsResponse < 3) {

926 checkUnnamed1148(o.datasets);

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

928 }

929 buildCounterListDatasetsResponse--;

930 }

931

932 buildUnnamed1149() {

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

934 o.add("foo");

935 o.add("foo");

936 return o;

937 }

938

939 checkUnnamed1149(core.List<core.String> o) {

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

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

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

943 }

944

945 buildUnnamed1150() {

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

947 o["x"] = buildUnnamed1149();

948 o["y"] = buildUnnamed1149();

949 return o;

950 }

951

952 checkUnnamed1150(core.Map<core.String, core.List<core.String>> o) {

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

954 checkUnnamed1149(o["x"]);

955 checkUnnamed1149(o["y"]);

956 }

957

958 core.int buildCounterMetadata = 0;

959 buildMetadata() {

960 var o = new api.Metadata();

961 buildCounterMetadata++;

962 if (buildCounterMetadata < 3) {

963 o.description = "foo";

964 o.id = "foo";

965 o.info = buildUnnamed1150();

966 o.key = "foo";

967 o.number = "foo";

968 o.type = "foo";

969 o.value = "foo";

970 }

971 buildCounterMetadata--;

972 return o;

973 }

974

975 checkMetadata(api.Metadata o) {

976 buildCounterMetadata++;

977 if (buildCounterMetadata < 3) {

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

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

980 checkUnnamed1150(o.info);

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

982 unittest.expect(o.number, unittest.equals('foo'));

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

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

985 }

986 buildCounterMetadata--;

987 }

988

989 core.int buildCounterProgram = 0;

990 buildProgram() {

991 var o = new api.Program();

992 buildCounterProgram++;

993 if (buildCounterProgram < 3) {

994 o.commandLine = "foo";

995 o.id = "foo";

996 o.name = "foo";

997 o.prevProgramId = "foo";

998 o.version = "foo";

999 }

1000 buildCounterProgram--;

1001 return o;

1002 }

1003

1004 checkProgram(api.Program o) {

1005 buildCounterProgram++;

1006 if (buildCounterProgram < 3) {

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

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

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

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

1011 unittest.expect(o.version, unittest.equals('foo'));

1012 }

1013 buildCounterProgram--;

1014 }

1015

1016 buildUnnamed1151() {

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

1018 o.add("foo");

1019 o.add("foo");

1020 return o;

1021 }

1022

1023 checkUnnamed1151(core.List<core.String> o) {

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

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

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

1027 }

1028

1029 buildUnnamed1152() {

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

1031 o["x"] = buildUnnamed1151();

1032 o["y"] = buildUnnamed1151();

1033 return o;

1034 }

1035

1036 checkUnnamed1152(core.Map<core.String, core.List<core.String>> o) {

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

1038 checkUnnamed1151(o["x"]);

1039 checkUnnamed1151(o["y"]);

1040 }

1041

1042 core.int buildCounterRead = 0;

1043 buildRead() {

1044 var o = new api.Read();

1045 buildCounterRead++;

1046 if (buildCounterRead < 3) {

1047 o.alignedBases = "foo";

1048 o.baseQuality = "foo";

1049 o.cigar = "foo";

1050 o.flags = 42;

1051 o.id = "foo";

1052 o.mappingQuality = 42;

1053 o.matePosition = 42;

1054 o.mateReferenceSequenceName = "foo";

1055 o.name = "foo";

1056 o.originalBases = "foo";

1057 o.position = 42;

1058 o.readsetId = "foo";

1059 o.referenceSequenceName = "foo";

1060 o.tags = buildUnnamed1152();

1061 o.templateLength = 42;

1062 }

1063 buildCounterRead--;

1064 return o;

1065 }

1066

1067 checkRead(api.Read o) {

1068 buildCounterRead++;

1069 if (buildCounterRead < 3) {

1070 unittest.expect(o.alignedBases, unittest.equals('foo'));

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

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

1073 unittest.expect(o.flags, unittest.equals(42));

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

1075 unittest.expect(o.mappingQuality, unittest.equals(42));

1076 unittest.expect(o.matePosition, unittest.equals(42));

1077 unittest.expect(o.mateReferenceSequenceName, unittest.equals('foo'));

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

1079 unittest.expect(o.originalBases, unittest.equals('foo'));

1080 unittest.expect(o.position, unittest.equals(42));

1081 unittest.expect(o.readsetId, unittest.equals('foo'));

1082 unittest.expect(o.referenceSequenceName, unittest.equals('foo'));

1083 checkUnnamed1152(o.tags);

1084 unittest.expect(o.templateLength, unittest.equals(42));

1085 }

1086 buildCounterRead--;

1087 }

1088

1089 core.int buildCounterReadGroup = 0;

1090 buildReadGroup() {

1091 var o = new api.ReadGroup();

1092 buildCounterReadGroup++;

1093 if (buildCounterReadGroup < 3) {

1094 o.date = "foo";

1095 o.description = "foo";

1096 o.flowOrder = "foo";

1097 o.id = "foo";

1098 o.keySequence = "foo";

1099 o.library = "foo";

1100 o.platformUnit = "foo";

1101 o.predictedInsertSize = 42;

1102 o.processingProgram = "foo";

1103 o.sample = "foo";

1104 o.sequencingCenterName = "foo";

1105 o.sequencingTechnology = "foo";

1106 }

1107 buildCounterReadGroup--;

1108 return o;

1109 }

1110

1111 checkReadGroup(api.ReadGroup o) {

1112 buildCounterReadGroup++;

1113 if (buildCounterReadGroup < 3) {

1114 unittest.expect(o.date, unittest.equals('foo'));

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

1116 unittest.expect(o.flowOrder, unittest.equals('foo'));

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

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

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

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

1121 unittest.expect(o.predictedInsertSize, unittest.equals(42));

1122 unittest.expect(o.processingProgram, unittest.equals('foo'));

1123 unittest.expect(o.sample, unittest.equals('foo'));

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

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

1126 }

1127 buildCounterReadGroup--;

1128 }

1129

1130 buildUnnamed1153() {

1131 var o = new core.List<api.HeaderSection>();

1132 o.add(buildHeaderSection());

1133 o.add(buildHeaderSection());

1134 return o;

1135 }

1136

1137 checkUnnamed1153(core.List<api.HeaderSection> o) {

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

1139 checkHeaderSection(o[0]);

1140 checkHeaderSection(o[1]);

1141 }

1142

1143 core.int buildCounterReadset = 0;

1144 buildReadset() {

1145 var o = new api.Readset();

1146 buildCounterReadset++;

1147 if (buildCounterReadset < 3) {

1148 o.datasetId = "foo";

1149 o.fileData = buildUnnamed1153();

1150 o.id = "foo";

1151 o.name = "foo";

1152 }

1153 buildCounterReadset--;

1154 return o;

1155 }

1156

1157 checkReadset(api.Readset o) {

1158 buildCounterReadset++;

1159 if (buildCounterReadset < 3) {

1160 unittest.expect(o.datasetId, unittest.equals('foo'));

1161 checkUnnamed1153(o.fileData);

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

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

1164 }

1165 buildCounterReadset--;

1166 }

1167

1168 core.int buildCounterReferenceSequence = 0;

1169 buildReferenceSequence() {

1170 var o = new api.ReferenceSequence();

1171 buildCounterReferenceSequence++;

1172 if (buildCounterReferenceSequence < 3) {

1173 o.assemblyId = "foo";

1174 o.length = 42;

1175 o.md5Checksum = "foo";

1176 o.name = "foo";

1177 o.species = "foo";

1178 o.uri = "foo";

1179 }

1180 buildCounterReferenceSequence--;

1181 return o;

1182 }

1183

1184 checkReferenceSequence(api.ReferenceSequence o) {

1185 buildCounterReferenceSequence++;

1186 if (buildCounterReferenceSequence < 3) {

1187 unittest.expect(o.assemblyId, unittest.equals('foo'));

1188 unittest.expect(o.length, unittest.equals(42));

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

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

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

1192 unittest.expect(o.uri, unittest.equals('foo'));

1193 }

1194 buildCounterReferenceSequence--;

1195 }

1196

1197 buildUnnamed1154() {

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

1199 o.add("foo");

1200 o.add("foo");

1201 return o;

1202 }

1203

1204 checkUnnamed1154(core.List<core.String> o) {

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

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

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

1208 }

1209

1210 core.int buildCounterSearchCallsetsRequest = 0;

1211 buildSearchCallsetsRequest() {

1212 var o = new api.SearchCallsetsRequest();

1213 buildCounterSearchCallsetsRequest++;

1214 if (buildCounterSearchCallsetsRequest < 3) {

1215 o.maxResults = "foo";

1216 o.name = "foo";

1217 o.pageToken = "foo";

1218 o.variantsetIds = buildUnnamed1154();

1219 }

1220 buildCounterSearchCallsetsRequest--;

1221 return o;

1222 }

1223

1224 checkSearchCallsetsRequest(api.SearchCallsetsRequest o) {

1225 buildCounterSearchCallsetsRequest++;

1226 if (buildCounterSearchCallsetsRequest < 3) {

1227 unittest.expect(o.maxResults, unittest.equals('foo'));

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

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

1230 checkUnnamed1154(o.variantsetIds);

1231 }

1232 buildCounterSearchCallsetsRequest--;

1233 }

1234

1235 buildUnnamed1155() {

1236 var o = new core.List<api.Callset>();

1237 o.add(buildCallset());

1238 o.add(buildCallset());

1239 return o;

1240 }

1241

1242 checkUnnamed1155(core.List<api.Callset> o) {

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

1244 checkCallset(o[0]);

1245 checkCallset(o[1]);

1246 }

1247

1248 core.int buildCounterSearchCallsetsResponse = 0;

1249 buildSearchCallsetsResponse() {

1250 var o = new api.SearchCallsetsResponse();

1251 buildCounterSearchCallsetsResponse++;

1252 if (buildCounterSearchCallsetsResponse < 3) {

1253 o.callsets = buildUnnamed1155();

1254 o.nextPageToken = "foo";

1255 }

1256 buildCounterSearchCallsetsResponse--;

1257 return o;

1258 }

1259

1260 checkSearchCallsetsResponse(api.SearchCallsetsResponse o) {

1261 buildCounterSearchCallsetsResponse++;

1262 if (buildCounterSearchCallsetsResponse < 3) {

1263 checkUnnamed1155(o.callsets);

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

1265 }

1266 buildCounterSearchCallsetsResponse--;

1267 }

1268

1269 buildUnnamed1156() {

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

1271 o.add("foo");

1272 o.add("foo");

1273 return o;

1274 }

1275

1276 checkUnnamed1156(core.List<core.String> o) {

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

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

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

1280 }

1281

1282 core.int buildCounterSearchJobsRequest = 0;

1283 buildSearchJobsRequest() {

1284 var o = new api.SearchJobsRequest();

1285 buildCounterSearchJobsRequest++;

1286 if (buildCounterSearchJobsRequest < 3) {

1287 o.createdAfter = "foo";

1288 o.createdBefore = "foo";

1289 o.maxResults = "foo";

1290 o.pageToken = "foo";

1291 o.projectId = "foo";

1292 o.status = buildUnnamed1156();

1293 }

1294 buildCounterSearchJobsRequest--;

1295 return o;

1296 }

1297

1298 checkSearchJobsRequest(api.SearchJobsRequest o) {

1299 buildCounterSearchJobsRequest++;

1300 if (buildCounterSearchJobsRequest < 3) {

1301 unittest.expect(o.createdAfter, unittest.equals('foo'));

1302 unittest.expect(o.createdBefore, unittest.equals('foo'));

1303 unittest.expect(o.maxResults, unittest.equals('foo'));

1304 unittest.expect(o.pageToken, unittest.equals('foo'));

1305 unittest.expect(o.projectId, unittest.equals('foo'));

1306 checkUnnamed1156(o.status);

1307 }

1308 buildCounterSearchJobsRequest--;

1309 }

1310

1311 buildUnnamed1157() {

1312 var o = new core.List<api.Job>();

1313 o.add(buildJob());

1314 o.add(buildJob());

1315 return o;

1316 }

1317

1318 checkUnnamed1157(core.List<api.Job> o) {

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

1320 checkJob(o[0]);

1321 checkJob(o[1]);

1322 }

1323

1324 core.int buildCounterSearchJobsResponse = 0;

1325 buildSearchJobsResponse() {

1326 var o = new api.SearchJobsResponse();

1327 buildCounterSearchJobsResponse++;

1328 if (buildCounterSearchJobsResponse < 3) {

1329 o.jobs = buildUnnamed1157();

1330 o.nextPageToken = "foo";

1331 }

1332 buildCounterSearchJobsResponse--;

1333 return o;

1334 }

1335

1336 checkSearchJobsResponse(api.SearchJobsResponse o) {

1337 buildCounterSearchJobsResponse++;

1338 if (buildCounterSearchJobsResponse < 3) {

1339 checkUnnamed1157(o.jobs);

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

1341 }

1342 buildCounterSearchJobsResponse--;

1343 }

1344

1345 buildUnnamed1158() {

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

1347 o.add("foo");

1348 o.add("foo");

1349 return o;

1350 }

1351

1352 checkUnnamed1158(core.List<core.String> o) {

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

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

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

1356 }

1357

1358 core.int buildCounterSearchReadsRequest = 0;

1359 buildSearchReadsRequest() {

1360 var o = new api.SearchReadsRequest();

1361 buildCounterSearchReadsRequest++;

1362 if (buildCounterSearchReadsRequest < 3) {

1363 o.maxResults = "foo";

1364 o.pageToken = "foo";

1365 o.readsetIds = buildUnnamed1158();

1366 o.sequenceEnd = "foo";

1367 o.sequenceName = "foo";

1368 o.sequenceStart = "foo";

1369 }

1370 buildCounterSearchReadsRequest--;

1371 return o;

1372 }

1373

1374 checkSearchReadsRequest(api.SearchReadsRequest o) {

1375 buildCounterSearchReadsRequest++;

1376 if (buildCounterSearchReadsRequest < 3) {

1377 unittest.expect(o.maxResults, unittest.equals('foo'));

1378 unittest.expect(o.pageToken, unittest.equals('foo'));

1379 checkUnnamed1158(o.readsetIds);

1380 unittest.expect(o.sequenceEnd, unittest.equals('foo'));

1381 unittest.expect(o.sequenceName, unittest.equals('foo'));

1382 unittest.expect(o.sequenceStart, unittest.equals('foo'));

1383 }

1384 buildCounterSearchReadsRequest--;

1385 }

1386

1387 buildUnnamed1159() {

1388 var o = new core.List<api.Read>();

1389 o.add(buildRead());

1390 o.add(buildRead());

1391 return o;

1392 }

1393

1394 checkUnnamed1159(core.List<api.Read> o) {

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

1396 checkRead(o[0]);

1397 checkRead(o[1]);

1398 }

1399

1400 core.int buildCounterSearchReadsResponse = 0;

1401 buildSearchReadsResponse() {

1402 var o = new api.SearchReadsResponse();

1403 buildCounterSearchReadsResponse++;

1404 if (buildCounterSearchReadsResponse < 3) {

1405 o.nextPageToken = "foo";

1406 o.reads = buildUnnamed1159();

1407 }

1408 buildCounterSearchReadsResponse--;

1409 return o;

1410 }

1411

1412 checkSearchReadsResponse(api.SearchReadsResponse o) {

1413 buildCounterSearchReadsResponse++;

1414 if (buildCounterSearchReadsResponse < 3) {

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

1416 checkUnnamed1159(o.reads);

1417 }

1418 buildCounterSearchReadsResponse--;

1419 }

1420

1421 buildUnnamed1160() {

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

1423 o.add("foo");

1424 o.add("foo");

1425 return o;

1426 }

1427

1428 checkUnnamed1160(core.List<core.String> o) {

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

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

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

1432 }

1433

1434 core.int buildCounterSearchReadsetsRequest = 0;

1435 buildSearchReadsetsRequest() {

1436 var o = new api.SearchReadsetsRequest();

1437 buildCounterSearchReadsetsRequest++;

1438 if (buildCounterSearchReadsetsRequest < 3) {

1439 o.datasetIds = buildUnnamed1160();

1440 o.maxResults = "foo";

1441 o.name = "foo";

1442 o.pageToken = "foo";

1443 }

1444 buildCounterSearchReadsetsRequest--;

1445 return o;

1446 }

1447

1448 checkSearchReadsetsRequest(api.SearchReadsetsRequest o) {

1449 buildCounterSearchReadsetsRequest++;

1450 if (buildCounterSearchReadsetsRequest < 3) {

1451 checkUnnamed1160(o.datasetIds);

1452 unittest.expect(o.maxResults, unittest.equals('foo'));

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

1454 unittest.expect(o.pageToken, unittest.equals('foo'));

1455 }

1456 buildCounterSearchReadsetsRequest--;

1457 }

1458

1459 buildUnnamed1161() {

1460 var o = new core.List<api.Readset>();

1461 o.add(buildReadset());

1462 o.add(buildReadset());

1463 return o;

1464 }

1465

1466 checkUnnamed1161(core.List<api.Readset> o) {

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

1468 checkReadset(o[0]);

1469 checkReadset(o[1]);

1470 }

1471

1472 core.int buildCounterSearchReadsetsResponse = 0;

1473 buildSearchReadsetsResponse() {

1474 var o = new api.SearchReadsetsResponse();

1475 buildCounterSearchReadsetsResponse++;

1476 if (buildCounterSearchReadsetsResponse < 3) {

1477 o.nextPageToken = "foo";

1478 o.readsets = buildUnnamed1161();

1479 }

1480 buildCounterSearchReadsetsResponse--;

1481 return o;

1482 }

1483

1484 checkSearchReadsetsResponse(api.SearchReadsetsResponse o) {

1485 buildCounterSearchReadsetsResponse++;

1486 if (buildCounterSearchReadsetsResponse < 3) {

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

1488 checkUnnamed1161(o.readsets);

1489 }

1490 buildCounterSearchReadsetsResponse--;

1491 }

1492

1493 buildUnnamed1162() {

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

1495 o.add("foo");

1496 o.add("foo");

1497 return o;

1498 }

1499

1500 checkUnnamed1162(core.List<core.String> o) {

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

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

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

1504 }

1505

1506 buildUnnamed1163() {

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

1508 o.add("foo");

1509 o.add("foo");

1510 return o;

1511 }

1512

1513 checkUnnamed1163(core.List<core.String> o) {

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

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

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

1517 }

1518

1519 core.int buildCounterSearchVariantsRequest = 0;

1520 buildSearchVariantsRequest() {

1521 var o = new api.SearchVariantsRequest();

1522 buildCounterSearchVariantsRequest++;

1523 if (buildCounterSearchVariantsRequest < 3) {

1524 o.callsetIds = buildUnnamed1162();

1525 o.callsetNames = buildUnnamed1163();

1526 o.contig = "foo";

1527 o.endPosition = "foo";

1528 o.maxResults = "foo";

1529 o.pageToken = "foo";

1530 o.startPosition = "foo";

1531 o.variantName = "foo";

1532 o.variantsetId = "foo";

1533 }

1534 buildCounterSearchVariantsRequest--;

1535 return o;

1536 }

1537

1538 checkSearchVariantsRequest(api.SearchVariantsRequest o) {

1539 buildCounterSearchVariantsRequest++;

1540 if (buildCounterSearchVariantsRequest < 3) {

1541 checkUnnamed1162(o.callsetIds);

1542 checkUnnamed1163(o.callsetNames);

1543 unittest.expect(o.contig, unittest.equals('foo'));

1544 unittest.expect(o.endPosition, unittest.equals('foo'));

1545 unittest.expect(o.maxResults, unittest.equals('foo'));

1546 unittest.expect(o.pageToken, unittest.equals('foo'));

1547 unittest.expect(o.startPosition, unittest.equals('foo'));

1548 unittest.expect(o.variantName, unittest.equals('foo'));

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

1550 }

1551 buildCounterSearchVariantsRequest--;

1552 }

1553

1554 buildUnnamed1164() {

1555 var o = new core.List<api.Variant>();

1556 o.add(buildVariant());

1557 o.add(buildVariant());

1558 return o;

1559 }

1560

1561 checkUnnamed1164(core.List<api.Variant> o) {

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

1563 checkVariant(o[0]);

1564 checkVariant(o[1]);

1565 }

1566

1567 core.int buildCounterSearchVariantsResponse = 0;

1568 buildSearchVariantsResponse() {

1569 var o = new api.SearchVariantsResponse();

1570 buildCounterSearchVariantsResponse++;

1571 if (buildCounterSearchVariantsResponse < 3) {

1572 o.nextPageToken = "foo";

1573 o.variants = buildUnnamed1164();

1574 }

1575 buildCounterSearchVariantsResponse--;

1576 return o;

1577 }

1578

1579 checkSearchVariantsResponse(api.SearchVariantsResponse o) {

1580 buildCounterSearchVariantsResponse++;

1581 if (buildCounterSearchVariantsResponse < 3) {

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

1583 checkUnnamed1164(o.variants);

1584 }

1585 buildCounterSearchVariantsResponse--;

1586 }

1587

1588 buildUnnamed1165() {

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

1590 o.add("foo");

1591 o.add("foo");

1592 return o;

1593 }

1594

1595 checkUnnamed1165(core.List<core.String> o) {

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

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

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

1599 }

1600

1601 buildUnnamed1166() {

1602 var o = new core.List<api.Call>();

1603 o.add(buildCall());

1604 o.add(buildCall());

1605 return o;

1606 }

1607

1608 checkUnnamed1166(core.List<api.Call> o) {

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

1610 checkCall(o[0]);

1611 checkCall(o[1]);

1612 }

1613

1614 buildUnnamed1167() {

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

1616 o.add("foo");

1617 o.add("foo");

1618 return o;

1619 }

1620

1621 checkUnnamed1167(core.List<core.String> o) {

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

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

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

1625 }

1626

1627 buildUnnamed1168() {

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

1629 o["x"] = buildUnnamed1167();

1630 o["y"] = buildUnnamed1167();

1631 return o;

1632 }

1633

1634 checkUnnamed1168(core.Map<core.String, core.List<core.String>> o) {

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

1636 checkUnnamed1167(o["x"]);

1637 checkUnnamed1167(o["y"]);

1638 }

1639

1640 buildUnnamed1169() {

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

1642 o.add("foo");

1643 o.add("foo");

1644 return o;

1645 }

1646

1647 checkUnnamed1169(core.List<core.String> o) {

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

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

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

1651 }

1652

1653 core.int buildCounterVariant = 0;

1654 buildVariant() {

1655 var o = new api.Variant();

1656 buildCounterVariant++;

1657 if (buildCounterVariant < 3) {

1658 o.alternateBases = buildUnnamed1165();

1659 o.calls = buildUnnamed1166();

1660 o.contig = "foo";

1661 o.created = "foo";

1662 o.end = "foo";

1663 o.id = "foo";

1664 o.info = buildUnnamed1168();

1665 o.names = buildUnnamed1169();

1666 o.position = "foo";

1667 o.referenceBases = "foo";

1668 o.variantsetId = "foo";

1669 }

1670 buildCounterVariant--;

1671 return o;

1672 }

1673

1674 checkVariant(api.Variant o) {

1675 buildCounterVariant++;

1676 if (buildCounterVariant < 3) {

1677 checkUnnamed1165(o.alternateBases);

1678 checkUnnamed1166(o.calls);

1679 unittest.expect(o.contig, unittest.equals('foo'));

1680 unittest.expect(o.created, unittest.equals('foo'));

1681 unittest.expect(o.end, unittest.equals('foo'));

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

1683 checkUnnamed1168(o.info);

1684 checkUnnamed1169(o.names);

1685 unittest.expect(o.position, unittest.equals('foo'));

1686 unittest.expect(o.referenceBases, unittest.equals('foo'));

1687 unittest.expect(o.variantsetId, unittest.equals('foo'));

1688 }

1689 buildCounterVariant--;

1690 }

1691

1692

1693 main() {

1694 unittest.group("obj-schema-Beacon", () {

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

1696 var o = buildBeacon();

1697 var od = new api.Beacon.fromJson(o.toJson());

1698 checkBeacon(od);

1699 });

1700 });

1701

1702

1703 unittest.group("obj-schema-Call", () {

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

1705 var o = buildCall();

1706 var od = new api.Call.fromJson(o.toJson());

1707 checkCall(od);

1708 });

1709 });

1710

1711

1712 unittest.group("obj-schema-Callset", () {

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

1714 var o = buildCallset();

1715 var od = new api.Callset.fromJson(o.toJson());

1716 checkCallset(od);

1717 });

1718 });

1719

1720

1721 unittest.group("obj-schema-ContigBound", () {

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

1723 var o = buildContigBound();

1724 var od = new api.ContigBound.fromJson(o.toJson());

1725 checkContigBound(od);

1726 });

1727 });

1728

1729

1730 unittest.group("obj-schema-CoverageBucket", () {

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

1732 var o = buildCoverageBucket();

1733 var od = new api.CoverageBucket.fromJson(o.toJson());

1734 checkCoverageBucket(od);

1735 });

1736 });

1737

1738

1739 unittest.group("obj-schema-Dataset", () {

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

1741 var o = buildDataset();

1742 var od = new api.Dataset.fromJson(o.toJson());

1743 checkDataset(od);

1744 });

1745 });

1746

1747

1748 unittest.group("obj-schema-ExperimentalCreateJobRequest", () {

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

1750 var o = buildExperimentalCreateJobRequest();

1751 var od = new api.ExperimentalCreateJobRequest.fromJson(o.toJson());

1752 checkExperimentalCreateJobRequest(od);

1753 });

1754 });

1755

1756

1757 unittest.group("obj-schema-ExperimentalCreateJobResponse", () {

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

1759 var o = buildExperimentalCreateJobResponse();

1760 var od = new api.ExperimentalCreateJobResponse.fromJson(o.toJson());

1761 checkExperimentalCreateJobResponse(od);

1762 });

1763 });

1764

1765

1766 unittest.group("obj-schema-ExportReadsetsRequest", () {

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

1768 var o = buildExportReadsetsRequest();

1769 var od = new api.ExportReadsetsRequest.fromJson(o.toJson());

1770 checkExportReadsetsRequest(od);

1771 });

1772 });

1773

1774

1775 unittest.group("obj-schema-ExportReadsetsResponse", () {

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

1777 var o = buildExportReadsetsResponse();

1778 var od = new api.ExportReadsetsResponse.fromJson(o.toJson());

1779 checkExportReadsetsResponse(od);

1780 });

1781 });

1782

1783

1784 unittest.group("obj-schema-ExportVariantsRequest", () {

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

1786 var o = buildExportVariantsRequest();

1787 var od = new api.ExportVariantsRequest.fromJson(o.toJson());

1788 checkExportVariantsRequest(od);

1789 });

1790 });

1791

1792

1793 unittest.group("obj-schema-ExportVariantsResponse", () {

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

1795 var o = buildExportVariantsResponse();

1796 var od = new api.ExportVariantsResponse.fromJson(o.toJson());

1797 checkExportVariantsResponse(od);

1798 });

1799 });

1800

1801

1802 unittest.group("obj-schema-GenomicRange", () {

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

1804 var o = buildGenomicRange();

1805 var od = new api.GenomicRange.fromJson(o.toJson());

1806 checkGenomicRange(od);

1807 });

1808 });

1809

1810

1811 unittest.group("obj-schema-GetVariantsSummaryResponse", () {

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

1813 var o = buildGetVariantsSummaryResponse();

1814 var od = new api.GetVariantsSummaryResponse.fromJson(o.toJson());

1815 checkGetVariantsSummaryResponse(od);

1816 });

1817 });

1818

1819

1820 unittest.group("obj-schema-Header", () {

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

1822 var o = buildHeader();

1823 var od = new api.Header.fromJson(o.toJson());

1824 checkHeader(od);

1825 });

1826 });

1827

1828

1829 unittest.group("obj-schema-HeaderSection", () {

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

1831 var o = buildHeaderSection();

1832 var od = new api.HeaderSection.fromJson(o.toJson());

1833 checkHeaderSection(od);

1834 });

1835 });

1836

1837

1838 unittest.group("obj-schema-ImportReadsetsRequest", () {

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

1840 var o = buildImportReadsetsRequest();

1841 var od = new api.ImportReadsetsRequest.fromJson(o.toJson());

1842 checkImportReadsetsRequest(od);

1843 });

1844 });

1845

1846

1847 unittest.group("obj-schema-ImportReadsetsResponse", () {

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

1849 var o = buildImportReadsetsResponse();

1850 var od = new api.ImportReadsetsResponse.fromJson(o.toJson());

1851 checkImportReadsetsResponse(od);

1852 });

1853 });

1854

1855

1856 unittest.group("obj-schema-ImportVariantsRequest", () {

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

1858 var o = buildImportVariantsRequest();

1859 var od = new api.ImportVariantsRequest.fromJson(o.toJson());

1860 checkImportVariantsRequest(od);

1861 });

1862 });

1863

1864

1865 unittest.group("obj-schema-ImportVariantsResponse", () {

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

1867 var o = buildImportVariantsResponse();

1868 var od = new api.ImportVariantsResponse.fromJson(o.toJson());

1869 checkImportVariantsResponse(od);

1870 });

1871 });

1872

1873

1874 unittest.group("obj-schema-Job", () {

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

1876 var o = buildJob();

1877 var od = new api.Job.fromJson(o.toJson());

1878 checkJob(od);

1879 });

1880 });

1881

1882

1883 unittest.group("obj-schema-JobRequest", () {

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

1885 var o = buildJobRequest();

1886 var od = new api.JobRequest.fromJson(o.toJson());

1887 checkJobRequest(od);

1888 });

1889 });

1890

1891

1892 unittest.group("obj-schema-ListCoverageBucketsResponse", () {

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

1894 var o = buildListCoverageBucketsResponse();

1895 var od = new api.ListCoverageBucketsResponse.fromJson(o.toJson());

1896 checkListCoverageBucketsResponse(od);

1897 });

1898 });

1899

1900

1901 unittest.group("obj-schema-ListDatasetsResponse", () {

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

1903 var o = buildListDatasetsResponse();

1904 var od = new api.ListDatasetsResponse.fromJson(o.toJson());

1905 checkListDatasetsResponse(od);

1906 });

1907 });

1908

1909

1910 unittest.group("obj-schema-Metadata", () {

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

1912 var o = buildMetadata();

1913 var od = new api.Metadata.fromJson(o.toJson());

1914 checkMetadata(od);

1915 });

1916 });

1917

1918

1919 unittest.group("obj-schema-Program", () {

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

1921 var o = buildProgram();

1922 var od = new api.Program.fromJson(o.toJson());

1923 checkProgram(od);

1924 });

1925 });

1926

1927

1928 unittest.group("obj-schema-Read", () {

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

1930 var o = buildRead();

1931 var od = new api.Read.fromJson(o.toJson());

1932 checkRead(od);

1933 });

1934 });

1935

1936

1937 unittest.group("obj-schema-ReadGroup", () {

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

1939 var o = buildReadGroup();

1940 var od = new api.ReadGroup.fromJson(o.toJson());

1941 checkReadGroup(od);

1942 });

1943 });

1944

1945

1946 unittest.group("obj-schema-Readset", () {

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

1948 var o = buildReadset();

1949 var od = new api.Readset.fromJson(o.toJson());

1950 checkReadset(od);

1951 });

1952 });

1953

1954

1955 unittest.group("obj-schema-ReferenceSequence", () {

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

1957 var o = buildReferenceSequence();

1958 var od = new api.ReferenceSequence.fromJson(o.toJson());

1959 checkReferenceSequence(od);

1960 });

1961 });

1962

1963

1964 unittest.group("obj-schema-SearchCallsetsRequest", () {

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

1966 var o = buildSearchCallsetsRequest();

1967 var od = new api.SearchCallsetsRequest.fromJson(o.toJson());

1968 checkSearchCallsetsRequest(od);

1969 });

1970 });

1971

1972

1973 unittest.group("obj-schema-SearchCallsetsResponse", () {

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

1975 var o = buildSearchCallsetsResponse();

1976 var od = new api.SearchCallsetsResponse.fromJson(o.toJson());

1977 checkSearchCallsetsResponse(od);

1978 });

1979 });

1980

1981

1982 unittest.group("obj-schema-SearchJobsRequest", () {

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

1984 var o = buildSearchJobsRequest();

1985 var od = new api.SearchJobsRequest.fromJson(o.toJson());

1986 checkSearchJobsRequest(od);

1987 });

1988 });

1989

1990

1991 unittest.group("obj-schema-SearchJobsResponse", () {

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

1993 var o = buildSearchJobsResponse();

1994 var od = new api.SearchJobsResponse.fromJson(o.toJson());

1995 checkSearchJobsResponse(od);

1996 });

1997 });

1998

1999

2000 unittest.group("obj-schema-SearchReadsRequest", () {

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

2002 var o = buildSearchReadsRequest();

2003 var od = new api.SearchReadsRequest.fromJson(o.toJson());

2004 checkSearchReadsRequest(od);

2005 });

2006 });

2007

2008

2009 unittest.group("obj-schema-SearchReadsResponse", () {

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

2011 var o = buildSearchReadsResponse();

2012 var od = new api.SearchReadsResponse.fromJson(o.toJson());

2013 checkSearchReadsResponse(od);

2014 });

2015 });

2016

2017

2018 unittest.group("obj-schema-SearchReadsetsRequest", () {

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

2020 var o = buildSearchReadsetsRequest();

2021 var od = new api.SearchReadsetsRequest.fromJson(o.toJson());

2022 checkSearchReadsetsRequest(od);

2023 });

2024 });

2025

2026

2027 unittest.group("obj-schema-SearchReadsetsResponse", () {

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

2029 var o = buildSearchReadsetsResponse();

2030 var od = new api.SearchReadsetsResponse.fromJson(o.toJson());

2031 checkSearchReadsetsResponse(od);

2032 });

2033 });

2034

2035

2036 unittest.group("obj-schema-SearchVariantsRequest", () {

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

2038 var o = buildSearchVariantsRequest();

2039 var od = new api.SearchVariantsRequest.fromJson(o.toJson());

2040 checkSearchVariantsRequest(od);

2041 });

2042 });

2043

2044

2045 unittest.group("obj-schema-SearchVariantsResponse", () {

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

2047 var o = buildSearchVariantsResponse();

2048 var od = new api.SearchVariantsResponse.fromJson(o.toJson());

2049 checkSearchVariantsResponse(od);

2050 });

2051 });

2052

2053

2054 unittest.group("obj-schema-Variant", () {

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

2056 var o = buildVariant();

2057 var od = new api.Variant.fromJson(o.toJson());

2058 checkVariant(od);

2059 });

2060 });

2061

2062

2063 unittest.group("resource-BeaconsResourceApi", () {

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

2065

2066 var mock = new common_test.HttpServerMock();

2067 api.BeaconsResourceApi res = new api.GenomicsApi(mock).beacons;

2068 var arg_variantsetId = "foo";

2069 var arg_allele = "foo";

2070 var arg_contig = "foo";

2071 var arg_position = "foo";

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

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

2074 var pathOffset = 0;

2075 var index;

2076 var subPart;

2077 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2078 pathOffset += 17;

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

2080 pathOffset += 8;

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

2082 pathOffset = path.length;

2083 unittest.expect(subPart, unittest.equals("$arg_variantsetId"));

2084

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

2086 var queryOffset = 0;

2087 var queryMap = {};

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

2089 parseBool(n) {

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

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

2092 if (n == null) return null;

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

2094 }

2095 if (query.length > 0) {

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

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

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

2099 }

2100 }

2101 unittest.expect(queryMap["allele"].first, unittest.equals(arg_allele));

2102 unittest.expect(queryMap["contig"].first, unittest.equals(arg_contig));

2103 unittest.expect(queryMap["position"].first, unittest.equals(arg_position ));

2104

2105

2106 var h = {

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

2108 };

2109 var resp = convert.JSON.encode(buildBeacon());

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

2111 }), true);

2112 res.get(arg_variantsetId, allele: arg_allele, contig: arg_contig, position : arg_position).then(unittest.expectAsync(((api.Beacon response) {

2113 checkBeacon(response);

2114 })));

2115 });

2116

2117 });

2118

2119

2120 unittest.group("resource-CallsetsResourceApi", () {

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

2122

2123 var mock = new common_test.HttpServerMock();

2124 api.CallsetsResourceApi res = new api.GenomicsApi(mock).callsets;

2125 var arg_request = buildCallset();

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

2127 var obj = new api.Callset.fromJson(json);

2128 checkCallset(obj);

2129

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

2131 var pathOffset = 0;

2132 var index;

2133 var subPart;

2134 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2135 pathOffset += 17;

2136 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("callsets"));

2137 pathOffset += 8;

2138

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

2140 var queryOffset = 0;

2141 var queryMap = {};

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

2143 parseBool(n) {

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

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

2146 if (n == null) return null;

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

2148 }

2149 if (query.length > 0) {

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

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

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

2153 }

2154 }

2155

2156

2157 var h = {

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

2159 };

2160 var resp = convert.JSON.encode(buildCallset());

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

2162 }), true);

2163 res.create(arg_request).then(unittest.expectAsync(((api.Callset response) {

2164 checkCallset(response);

2165 })));

2166 });

2167

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

2169

2170 var mock = new common_test.HttpServerMock();

2171 api.CallsetsResourceApi res = new api.GenomicsApi(mock).callsets;

2172 var arg_callsetId = "foo";

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

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

2175 var pathOffset = 0;

2176 var index;

2177 var subPart;

2178 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2179 pathOffset += 17;

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

2181 pathOffset += 9;

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

2183 pathOffset = path.length;

2184 unittest.expect(subPart, unittest.equals("$arg_callsetId"));

2185

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

2187 var queryOffset = 0;

2188 var queryMap = {};

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

2190 parseBool(n) {

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

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

2193 if (n == null) return null;

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

2195 }

2196 if (query.length > 0) {

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

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

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

2200 }

2201 }

2202

2203

2204 var h = {

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

2206 };

2207 var resp = "";

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

2209 }), true);

2210 res.delete(arg_callsetId).then(unittest.expectAsync((_) {}));

2211 });

2212

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

2214

2215 var mock = new common_test.HttpServerMock();

2216 api.CallsetsResourceApi res = new api.GenomicsApi(mock).callsets;

2217 var arg_callsetId = "foo";

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

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

2220 var pathOffset = 0;

2221 var index;

2222 var subPart;

2223 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2224 pathOffset += 17;

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

2226 pathOffset += 9;

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

2228 pathOffset = path.length;

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

2230

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

2232 var queryOffset = 0;

2233 var queryMap = {};

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

2235 parseBool(n) {

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

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

2238 if (n == null) return null;

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

2240 }

2241 if (query.length > 0) {

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

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

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

2245 }

2246 }

2247

2248

2249 var h = {

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

2251 };

2252 var resp = convert.JSON.encode(buildCallset());

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

2254 }), true);

2255 res.get(arg_callsetId).then(unittest.expectAsync(((api.Callset response) {

2256 checkCallset(response);

2257 })));

2258 });

2259

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

2261

2262 var mock = new common_test.HttpServerMock();

2263 api.CallsetsResourceApi res = new api.GenomicsApi(mock).callsets;

2264 var arg_request = buildCallset();

2265 var arg_callsetId = "foo";

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

2267 var obj = new api.Callset.fromJson(json);

2268 checkCallset(obj);

2269

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

2271 var pathOffset = 0;

2272 var index;

2273 var subPart;

2274 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2275 pathOffset += 17;

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

2277 pathOffset += 9;

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

2279 pathOffset = path.length;

2280 unittest.expect(subPart, unittest.equals("$arg_callsetId"));

2281

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

2283 var queryOffset = 0;

2284 var queryMap = {};

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

2286 parseBool(n) {

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

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

2289 if (n == null) return null;

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

2291 }

2292 if (query.length > 0) {

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

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

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

2296 }

2297 }

2298

2299

2300 var h = {

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

2302 };

2303 var resp = convert.JSON.encode(buildCallset());

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

2305 }), true);

2306 res.patch(arg_request, arg_callsetId).then(unittest.expectAsync(((api.Call set response) {

2307 checkCallset(response);

2308 })));

2309 });

2310

2311 unittest.test("method--search", () {

2312

2313 var mock = new common_test.HttpServerMock();

2314 api.CallsetsResourceApi res = new api.GenomicsApi(mock).callsets;

2315 var arg_request = buildSearchCallsetsRequest();

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

2317 var obj = new api.SearchCallsetsRequest.fromJson(json);

2318 checkSearchCallsetsRequest(obj);

2319

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

2321 var pathOffset = 0;

2322 var index;

2323 var subPart;

2324 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2325 pathOffset += 17;

2326 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("callsets/search"));

2327 pathOffset += 15;

2328

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

2330 var queryOffset = 0;

2331 var queryMap = {};

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

2333 parseBool(n) {

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

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

2336 if (n == null) return null;

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

2338 }

2339 if (query.length > 0) {

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

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

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

2343 }

2344 }

2345

2346

2347 var h = {

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

2349 };

2350 var resp = convert.JSON.encode(buildSearchCallsetsResponse());

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

2352 }), true);

2353 res.search(arg_request).then(unittest.expectAsync(((api.SearchCallsetsResp onse response) {

2354 checkSearchCallsetsResponse(response);

2355 })));

2356 });

2357

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

2359

2360 var mock = new common_test.HttpServerMock();

2361 api.CallsetsResourceApi res = new api.GenomicsApi(mock).callsets;

2362 var arg_request = buildCallset();

2363 var arg_callsetId = "foo";

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

2365 var obj = new api.Callset.fromJson(json);

2366 checkCallset(obj);

2367

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

2369 var pathOffset = 0;

2370 var index;

2371 var subPart;

2372 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2373 pathOffset += 17;

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

2375 pathOffset += 9;

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

2377 pathOffset = path.length;

2378 unittest.expect(subPart, unittest.equals("$arg_callsetId"));

2379

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

2381 var queryOffset = 0;

2382 var queryMap = {};

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

2384 parseBool(n) {

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

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

2387 if (n == null) return null;

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

2389 }

2390 if (query.length > 0) {

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

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

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

2394 }

2395 }

2396

2397

2398 var h = {

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

2400 };

2401 var resp = convert.JSON.encode(buildCallset());

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

2403 }), true);

2404 res.update(arg_request, arg_callsetId).then(unittest.expectAsync(((api.Cal lset response) {

2405 checkCallset(response);

2406 })));

2407 });

2408

2409 });

2410

2411

2412 unittest.group("resource-DatasetsResourceApi", () {

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

2414

2415 var mock = new common_test.HttpServerMock();

2416 api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;

2417 var arg_request = buildDataset();

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

2419 var obj = new api.Dataset.fromJson(json);

2420 checkDataset(obj);

2421

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

2423 var pathOffset = 0;

2424 var index;

2425 var subPart;

2426 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2427 pathOffset += 17;

2428 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("datasets"));

2429 pathOffset += 8;

2430

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

2432 var queryOffset = 0;

2433 var queryMap = {};

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

2435 parseBool(n) {

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

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

2438 if (n == null) return null;

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

2440 }

2441 if (query.length > 0) {

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

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

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

2445 }

2446 }

2447

2448

2449 var h = {

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

2451 };

2452 var resp = convert.JSON.encode(buildDataset());

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

2454 }), true);

2455 res.create(arg_request).then(unittest.expectAsync(((api.Dataset response) {

2456 checkDataset(response);

2457 })));

2458 });

2459

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

2461

2462 var mock = new common_test.HttpServerMock();

2463 api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;

2464 var arg_datasetId = "foo";

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

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

2467 var pathOffset = 0;

2468 var index;

2469 var subPart;

2470 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2471 pathOffset += 17;

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

2473 pathOffset += 9;

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

2475 pathOffset = path.length;

2476 unittest.expect(subPart, unittest.equals("$arg_datasetId"));

2477

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

2479 var queryOffset = 0;

2480 var queryMap = {};

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

2482 parseBool(n) {

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

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

2485 if (n == null) return null;

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

2487 }

2488 if (query.length > 0) {

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

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

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

2492 }

2493 }

2494

2495

2496 var h = {

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

2498 };

2499 var resp = "";

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

2501 }), true);

2502 res.delete(arg_datasetId).then(unittest.expectAsync((_) {}));

2503 });

2504

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

2506

2507 var mock = new common_test.HttpServerMock();

2508 api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;

2509 var arg_datasetId = "foo";

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

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

2512 var pathOffset = 0;

2513 var index;

2514 var subPart;

2515 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2516 pathOffset += 17;

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

2518 pathOffset += 9;

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

2520 pathOffset = path.length;

2521 unittest.expect(subPart, unittest.equals("$arg_datasetId"));

2522

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

2524 var queryOffset = 0;

2525 var queryMap = {};

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

2527 parseBool(n) {

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

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

2530 if (n == null) return null;

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

2532 }

2533 if (query.length > 0) {

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

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

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

2537 }

2538 }

2539

2540

2541 var h = {

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

2543 };

2544 var resp = convert.JSON.encode(buildDataset());

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

2546 }), true);

2547 res.get(arg_datasetId).then(unittest.expectAsync(((api.Dataset response) {

2548 checkDataset(response);

2549 })));

2550 });

2551

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

2553

2554 var mock = new common_test.HttpServerMock();

2555 api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;

2556 var arg_maxResults = "foo";

2557 var arg_pageToken = "foo";

2558 var arg_projectId = "foo";

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

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

2561 var pathOffset = 0;

2562 var index;

2563 var subPart;

2564 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2565 pathOffset += 17;

2566 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("datasets"));

2567 pathOffset += 8;

2568

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

2570 var queryOffset = 0;

2571 var queryMap = {};

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

2573 parseBool(n) {

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

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

2576 if (n == null) return null;

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

2578 }

2579 if (query.length > 0) {

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

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

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

2583 }

2584 }

2585 unittest.expect(queryMap["maxResults"].first, unittest.equals(arg_maxRes ults));

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

2587 unittest.expect(queryMap["projectId"].first, unittest.equals(arg_project Id));

2588

2589

2590 var h = {

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

2592 };

2593 var resp = convert.JSON.encode(buildListDatasetsResponse());

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

2595 }), true);

2596 res.list(maxResults: arg_maxResults, pageToken: arg_pageToken, projectId: arg_projectId).then(unittest.expectAsync(((api.ListDatasetsResponse response) {

2597 checkListDatasetsResponse(response);

2598 })));

2599 });

2600

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

2602

2603 var mock = new common_test.HttpServerMock();

2604 api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;

2605 var arg_request = buildDataset();

2606 var arg_datasetId = "foo";

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

2608 var obj = new api.Dataset.fromJson(json);

2609 checkDataset(obj);

2610

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

2612 var pathOffset = 0;

2613 var index;

2614 var subPart;

2615 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2616 pathOffset += 17;

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

2618 pathOffset += 9;

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

2620 pathOffset = path.length;

2621 unittest.expect(subPart, unittest.equals("$arg_datasetId"));

2622

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

2624 var queryOffset = 0;

2625 var queryMap = {};

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

2627 parseBool(n) {

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

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

2630 if (n == null) return null;

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

2632 }

2633 if (query.length > 0) {

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

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

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

2637 }

2638 }

2639

2640

2641 var h = {

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

2643 };

2644 var resp = convert.JSON.encode(buildDataset());

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

2646 }), true);

2647 res.patch(arg_request, arg_datasetId).then(unittest.expectAsync(((api.Data set response) {

2648 checkDataset(response);

2649 })));

2650 });

2651

2652 unittest.test("method--undelete", () {

2653

2654 var mock = new common_test.HttpServerMock();

2655 api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;

2656 var arg_datasetId = "foo";

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

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

2659 var pathOffset = 0;

2660 var index;

2661 var subPart;

2662 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2663 pathOffset += 17;

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

2665 pathOffset += 9;

2666 index = path.indexOf("/undelete", pathOffset);

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

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

2669 pathOffset = index;

2670 unittest.expect(subPart, unittest.equals("$arg_datasetId"));

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

2672 pathOffset += 9;

2673

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

2675 var queryOffset = 0;

2676 var queryMap = {};

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

2678 parseBool(n) {

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

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

2681 if (n == null) return null;

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

2683 }

2684 if (query.length > 0) {

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

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

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

2688 }

2689 }

2690

2691

2692 var h = {

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

2694 };

2695 var resp = convert.JSON.encode(buildDataset());

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

2697 }), true);

2698 res.undelete(arg_datasetId).then(unittest.expectAsync(((api.Dataset respon se) {

2699 checkDataset(response);

2700 })));

2701 });

2702

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

2704

2705 var mock = new common_test.HttpServerMock();

2706 api.DatasetsResourceApi res = new api.GenomicsApi(mock).datasets;

2707 var arg_request = buildDataset();

2708 var arg_datasetId = "foo";

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

2710 var obj = new api.Dataset.fromJson(json);

2711 checkDataset(obj);

2712

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

2714 var pathOffset = 0;

2715 var index;

2716 var subPart;

2717 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2718 pathOffset += 17;

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

2720 pathOffset += 9;

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

2722 pathOffset = path.length;

2723 unittest.expect(subPart, unittest.equals("$arg_datasetId"));

2724

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

2726 var queryOffset = 0;

2727 var queryMap = {};

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

2729 parseBool(n) {

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

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

2732 if (n == null) return null;

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

2734 }

2735 if (query.length > 0) {

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

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

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

2739 }

2740 }

2741

2742

2743 var h = {

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

2745 };

2746 var resp = convert.JSON.encode(buildDataset());

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

2748 }), true);

2749 res.update(arg_request, arg_datasetId).then(unittest.expectAsync(((api.Dat aset response) {

2750 checkDataset(response);

2751 })));

2752 });

2753

2754 });

2755

2756

2757 unittest.group("resource-ExperimentalJobsResourceApi", () {

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

2759

2760 var mock = new common_test.HttpServerMock();

2761 api.ExperimentalJobsResourceApi res = new api.GenomicsApi(mock).experiment al.jobs;

2762 var arg_request = buildExperimentalCreateJobRequest();

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

2764 var obj = new api.ExperimentalCreateJobRequest.fromJson(json);

2765 checkExperimentalCreateJobRequest(obj);

2766

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

2768 var pathOffset = 0;

2769 var index;

2770 var subPart;

2771 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2772 pathOffset += 17;

2773 unittest.expect(path.substring(pathOffset, pathOffset + 24), unittest.eq uals("experimental/jobs/create"));

2774 pathOffset += 24;

2775

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

2777 var queryOffset = 0;

2778 var queryMap = {};

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

2780 parseBool(n) {

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

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

2783 if (n == null) return null;

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

2785 }

2786 if (query.length > 0) {

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

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

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

2790 }

2791 }

2792

2793

2794 var h = {

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

2796 };

2797 var resp = convert.JSON.encode(buildExperimentalCreateJobResponse());

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

2799 }), true);

2800 res.create(arg_request).then(unittest.expectAsync(((api.ExperimentalCreate JobResponse response) {

2801 checkExperimentalCreateJobResponse(response);

2802 })));

2803 });

2804

2805 });

2806

2807

2808 unittest.group("resource-JobsResourceApi", () {

2809 unittest.test("method--cancel", () {

2810

2811 var mock = new common_test.HttpServerMock();

2812 api.JobsResourceApi res = new api.GenomicsApi(mock).jobs;

2813 var arg_jobId = "foo";

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

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

2816 var pathOffset = 0;

2817 var index;

2818 var subPart;

2819 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2820 pathOffset += 17;

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

2822 pathOffset += 5;

2823 index = path.indexOf("/cancel", pathOffset);

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

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

2826 pathOffset = index;

2827 unittest.expect(subPart, unittest.equals("$arg_jobId"));

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

2829 pathOffset += 7;

2830

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

2832 var queryOffset = 0;

2833 var queryMap = {};

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

2835 parseBool(n) {

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

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

2838 if (n == null) return null;

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

2840 }

2841 if (query.length > 0) {

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

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

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

2845 }

2846 }

2847

2848

2849 var h = {

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

2851 };

2852 var resp = "";

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

2854 }), true);

2855 res.cancel(arg_jobId).then(unittest.expectAsync((_) {}));

2856 });

2857

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

2859

2860 var mock = new common_test.HttpServerMock();

2861 api.JobsResourceApi res = new api.GenomicsApi(mock).jobs;

2862 var arg_jobId = "foo";

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

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

2865 var pathOffset = 0;

2866 var index;

2867 var subPart;

2868 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2869 pathOffset += 17;

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

2871 pathOffset += 5;

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

2873 pathOffset = path.length;

2874 unittest.expect(subPart, unittest.equals("$arg_jobId"));

2875

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

2877 var queryOffset = 0;

2878 var queryMap = {};

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

2880 parseBool(n) {

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

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

2883 if (n == null) return null;

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

2885 }

2886 if (query.length > 0) {

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

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

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

2890 }

2891 }

2892

2893

2894 var h = {

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

2896 };

2897 var resp = convert.JSON.encode(buildJob());

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

2899 }), true);

2900 res.get(arg_jobId).then(unittest.expectAsync(((api.Job response) {

2901 checkJob(response);

2902 })));

2903 });

2904

2905 unittest.test("method--search", () {

2906

2907 var mock = new common_test.HttpServerMock();

2908 api.JobsResourceApi res = new api.GenomicsApi(mock).jobs;

2909 var arg_request = buildSearchJobsRequest();

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

2911 var obj = new api.SearchJobsRequest.fromJson(json);

2912 checkSearchJobsRequest(obj);

2913

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

2915 var pathOffset = 0;

2916 var index;

2917 var subPart;

2918 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2919 pathOffset += 17;

2920 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("jobs/search"));

2921 pathOffset += 11;

2922

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

2924 var queryOffset = 0;

2925 var queryMap = {};

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

2927 parseBool(n) {

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

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

2930 if (n == null) return null;

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

2932 }

2933 if (query.length > 0) {

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

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

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

2937 }

2938 }

2939

2940

2941 var h = {

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

2943 };

2944 var resp = convert.JSON.encode(buildSearchJobsResponse());

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

2946 }), true);

2947 res.search(arg_request).then(unittest.expectAsync(((api.SearchJobsResponse response) {

2948 checkSearchJobsResponse(response);

2949 })));

2950 });

2951

2952 });

2953

2954

2955 unittest.group("resource-ReadsResourceApi", () {

2956 unittest.test("method--search", () {

2957

2958 var mock = new common_test.HttpServerMock();

2959 api.ReadsResourceApi res = new api.GenomicsApi(mock).reads;

2960 var arg_request = buildSearchReadsRequest();

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

2962 var obj = new api.SearchReadsRequest.fromJson(json);

2963 checkSearchReadsRequest(obj);

2964

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

2966 var pathOffset = 0;

2967 var index;

2968 var subPart;

2969 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

2970 pathOffset += 17;

2971 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("reads/search"));

2972 pathOffset += 12;

2973

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

2975 var queryOffset = 0;

2976 var queryMap = {};

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

2978 parseBool(n) {

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

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

2981 if (n == null) return null;

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

2983 }

2984 if (query.length > 0) {

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

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

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

2988 }

2989 }

2990

2991

2992 var h = {

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

2994 };

2995 var resp = convert.JSON.encode(buildSearchReadsResponse());

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

2997 }), true);

2998 res.search(arg_request).then(unittest.expectAsync(((api.SearchReadsRespons e response) {

2999 checkSearchReadsResponse(response);

3000 })));

3001 });

3002

3003 });

3004

3005

3006 unittest.group("resource-ReadsetsResourceApi", () {

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

3008

3009 var mock = new common_test.HttpServerMock();

3010 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3011 var arg_readsetId = "foo";

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

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

3014 var pathOffset = 0;

3015 var index;

3016 var subPart;

3017 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3018 pathOffset += 17;

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

3020 pathOffset += 9;

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

3022 pathOffset = path.length;

3023 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3024

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

3026 var queryOffset = 0;

3027 var queryMap = {};

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

3029 parseBool(n) {

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

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

3032 if (n == null) return null;

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

3034 }

3035 if (query.length > 0) {

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

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

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

3039 }

3040 }

3041

3042

3043 var h = {

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

3045 };

3046 var resp = "";

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

3048 }), true);

3049 res.delete(arg_readsetId).then(unittest.expectAsync((_) {}));

3050 });

3051

3052 unittest.test("method--export", () {

3053

3054 var mock = new common_test.HttpServerMock();

3055 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3056 var arg_request = buildExportReadsetsRequest();

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

3058 var obj = new api.ExportReadsetsRequest.fromJson(json);

3059 checkExportReadsetsRequest(obj);

3060

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

3062 var pathOffset = 0;

3063 var index;

3064 var subPart;

3065 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3066 pathOffset += 17;

3067 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("readsets/export"));

3068 pathOffset += 15;

3069

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

3071 var queryOffset = 0;

3072 var queryMap = {};

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

3074 parseBool(n) {

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

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

3077 if (n == null) return null;

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

3079 }

3080 if (query.length > 0) {

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

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

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

3084 }

3085 }

3086

3087

3088 var h = {

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

3090 };

3091 var resp = convert.JSON.encode(buildExportReadsetsResponse());

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

3093 }), true);

3094 res.export(arg_request).then(unittest.expectAsync(((api.ExportReadsetsResp onse response) {

3095 checkExportReadsetsResponse(response);

3096 })));

3097 });

3098

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

3100

3101 var mock = new common_test.HttpServerMock();

3102 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3103 var arg_readsetId = "foo";

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

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

3106 var pathOffset = 0;

3107 var index;

3108 var subPart;

3109 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3110 pathOffset += 17;

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

3112 pathOffset += 9;

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

3114 pathOffset = path.length;

3115 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3116

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

3118 var queryOffset = 0;

3119 var queryMap = {};

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

3121 parseBool(n) {

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

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

3124 if (n == null) return null;

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

3126 }

3127 if (query.length > 0) {

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

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

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

3131 }

3132 }

3133

3134

3135 var h = {

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

3137 };

3138 var resp = convert.JSON.encode(buildReadset());

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

3140 }), true);

3141 res.get(arg_readsetId).then(unittest.expectAsync(((api.Readset response) {

3142 checkReadset(response);

3143 })));

3144 });

3145

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

3147

3148 var mock = new common_test.HttpServerMock();

3149 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3150 var arg_request = buildImportReadsetsRequest();

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

3152 var obj = new api.ImportReadsetsRequest.fromJson(json);

3153 checkImportReadsetsRequest(obj);

3154

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

3156 var pathOffset = 0;

3157 var index;

3158 var subPart;

3159 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3160 pathOffset += 17;

3161 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("readsets/import"));

3162 pathOffset += 15;

3163

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

3165 var queryOffset = 0;

3166 var queryMap = {};

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

3168 parseBool(n) {

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

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

3171 if (n == null) return null;

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

3173 }

3174 if (query.length > 0) {

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

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

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

3178 }

3179 }

3180

3181

3182 var h = {

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

3184 };

3185 var resp = convert.JSON.encode(buildImportReadsetsResponse());

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

3187 }), true);

3188 res.import(arg_request).then(unittest.expectAsync(((api.ImportReadsetsResp onse response) {

3189 checkImportReadsetsResponse(response);

3190 })));

3191 });

3192

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

3194

3195 var mock = new common_test.HttpServerMock();

3196 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3197 var arg_request = buildReadset();

3198 var arg_readsetId = "foo";

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

3200 var obj = new api.Readset.fromJson(json);

3201 checkReadset(obj);

3202

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

3204 var pathOffset = 0;

3205 var index;

3206 var subPart;

3207 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3208 pathOffset += 17;

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

3210 pathOffset += 9;

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

3212 pathOffset = path.length;

3213 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3214

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

3216 var queryOffset = 0;

3217 var queryMap = {};

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

3219 parseBool(n) {

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

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

3222 if (n == null) return null;

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

3224 }

3225 if (query.length > 0) {

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

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

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

3229 }

3230 }

3231

3232

3233 var h = {

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

3235 };

3236 var resp = convert.JSON.encode(buildReadset());

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

3238 }), true);

3239 res.patch(arg_request, arg_readsetId).then(unittest.expectAsync(((api.Read set response) {

3240 checkReadset(response);

3241 })));

3242 });

3243

3244 unittest.test("method--search", () {

3245

3246 var mock = new common_test.HttpServerMock();

3247 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3248 var arg_request = buildSearchReadsetsRequest();

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

3250 var obj = new api.SearchReadsetsRequest.fromJson(json);

3251 checkSearchReadsetsRequest(obj);

3252

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

3254 var pathOffset = 0;

3255 var index;

3256 var subPart;

3257 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3258 pathOffset += 17;

3259 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("readsets/search"));

3260 pathOffset += 15;

3261

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

3263 var queryOffset = 0;

3264 var queryMap = {};

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

3266 parseBool(n) {

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

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

3269 if (n == null) return null;

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

3271 }

3272 if (query.length > 0) {

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

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

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

3276 }

3277 }

3278

3279

3280 var h = {

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

3282 };

3283 var resp = convert.JSON.encode(buildSearchReadsetsResponse());

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

3285 }), true);

3286 res.search(arg_request).then(unittest.expectAsync(((api.SearchReadsetsResp onse response) {

3287 checkSearchReadsetsResponse(response);

3288 })));

3289 });

3290

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

3292

3293 var mock = new common_test.HttpServerMock();

3294 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3295 var arg_request = buildReadset();

3296 var arg_readsetId = "foo";

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

3298 var obj = new api.Readset.fromJson(json);

3299 checkReadset(obj);

3300

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

3302 var pathOffset = 0;

3303 var index;

3304 var subPart;

3305 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3306 pathOffset += 17;

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

3308 pathOffset += 9;

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

3310 pathOffset = path.length;

3311 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3312

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

3314 var queryOffset = 0;

3315 var queryMap = {};

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

3317 parseBool(n) {

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

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

3320 if (n == null) return null;

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

3322 }

3323 if (query.length > 0) {

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

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

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

3327 }

3328 }

3329

3330

3331 var h = {

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

3333 };

3334 var resp = convert.JSON.encode(buildReadset());

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

3336 }), true);

3337 res.update(arg_request, arg_readsetId).then(unittest.expectAsync(((api.Rea dset response) {

3338 checkReadset(response);

3339 })));

3340 });

3341

3342 });

3343

3344

3345 unittest.group("resource-ReadsetsCoveragebucketsResourceApi", () {

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

3347

3348 var mock = new common_test.HttpServerMock();

3349 api.ReadsetsCoveragebucketsResourceApi res = new api.GenomicsApi(mock).rea dsets.coveragebuckets;

3350 var arg_readsetId = "foo";

3351 var arg_maxResults = "foo";

3352 var arg_pageToken = "foo";

3353 var arg_range_sequenceEnd = "foo";

3354 var arg_range_sequenceName = "foo";

3355 var arg_range_sequenceStart = "foo";

3356 var arg_targetBucketWidth = "foo";

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

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

3359 var pathOffset = 0;

3360 var index;

3361 var subPart;

3362 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3363 pathOffset += 17;

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

3365 pathOffset += 9;

3366 index = path.indexOf("/coveragebuckets", pathOffset);

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

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

3369 pathOffset = index;

3370 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3371 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/coveragebuckets"));

3372 pathOffset += 16;

3373

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

3375 var queryOffset = 0;

3376 var queryMap = {};

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

3378 parseBool(n) {

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

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

3381 if (n == null) return null;

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

3383 }

3384 if (query.length > 0) {

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

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

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

3388 }

3389 }

3390 unittest.expect(queryMap["maxResults"].first, unittest.equals(arg_maxRes ults));

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

3392 unittest.expect(queryMap["range.sequenceEnd"].first, unittest.equals(arg _range_sequenceEnd));

3393 unittest.expect(queryMap["range.sequenceName"].first, unittest.equals(ar g_range_sequenceName));

3394 unittest.expect(queryMap["range.sequenceStart"].first, unittest.equals(a rg_range_sequenceStart));

3395 unittest.expect(queryMap["targetBucketWidth"].first, unittest.equals(arg _targetBucketWidth));

3396

3397

3398 var h = {

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

3400 };

3401 var resp = convert.JSON.encode(buildListCoverageBucketsResponse());

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

3403 }), true);

3404 res.list(arg_readsetId, maxResults: arg_maxResults, pageToken: arg_pageTok en, range_sequenceEnd: arg_range_sequenceEnd, range_sequenceName: arg_range_sequ enceName, range_sequenceStart: arg_range_sequenceStart, targetBucketWidth: arg_t argetBucketWidth).then(unittest.expectAsync(((api.ListCoverageBucketsResponse re sponse) {

3405 checkListCoverageBucketsResponse(response);

3406 })));

3407 });

3408

3409 });

3410

3411

3412 unittest.group("resource-VariantsResourceApi", () {

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

3414

3415 var mock = new common_test.HttpServerMock();

3416 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3417 var arg_request = buildVariant();

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

3419 var obj = new api.Variant.fromJson(json);

3420 checkVariant(obj);

3421

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

3423 var pathOffset = 0;

3424 var index;

3425 var subPart;

3426 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3427 pathOffset += 17;

3428 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("variants"));

3429 pathOffset += 8;

3430

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

3432 var queryOffset = 0;

3433 var queryMap = {};

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

3435 parseBool(n) {

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

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

3438 if (n == null) return null;

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

3440 }

3441 if (query.length > 0) {

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

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

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

3445 }

3446 }

3447

3448

3449 var h = {

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

3451 };

3452 var resp = convert.JSON.encode(buildVariant());

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

3454 }), true);

3455 res.create(arg_request).then(unittest.expectAsync(((api.Variant response) {

3456 checkVariant(response);

3457 })));

3458 });

3459

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

3461

3462 var mock = new common_test.HttpServerMock();

3463 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3464 var arg_variantId = "foo";

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

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

3467 var pathOffset = 0;

3468 var index;

3469 var subPart;

3470 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3471 pathOffset += 17;

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

3473 pathOffset += 9;

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

3475 pathOffset = path.length;

3476 unittest.expect(subPart, unittest.equals("$arg_variantId"));

3477

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

3479 var queryOffset = 0;

3480 var queryMap = {};

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

3482 parseBool(n) {

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

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

3485 if (n == null) return null;

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

3487 }

3488 if (query.length > 0) {

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

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

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

3492 }

3493 }

3494

3495

3496 var h = {

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

3498 };

3499 var resp = "";

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

3501 }), true);

3502 res.delete(arg_variantId).then(unittest.expectAsync((_) {}));

3503 });

3504

3505 unittest.test("method--export", () {

3506

3507 var mock = new common_test.HttpServerMock();

3508 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3509 var arg_request = buildExportVariantsRequest();

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

3511 var obj = new api.ExportVariantsRequest.fromJson(json);

3512 checkExportVariantsRequest(obj);

3513

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

3515 var pathOffset = 0;

3516 var index;

3517 var subPart;

3518 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3519 pathOffset += 17;

3520 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("variants/export"));

3521 pathOffset += 15;

3522

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

3524 var queryOffset = 0;

3525 var queryMap = {};

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

3527 parseBool(n) {

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

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

3530 if (n == null) return null;

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

3532 }

3533 if (query.length > 0) {

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

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

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

3537 }

3538 }

3539

3540

3541 var h = {

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

3543 };

3544 var resp = convert.JSON.encode(buildExportVariantsResponse());

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

3546 }), true);

3547 res.export(arg_request).then(unittest.expectAsync(((api.ExportVariantsResp onse response) {

3548 checkExportVariantsResponse(response);

3549 })));

3550 });

3551

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

3553

3554 var mock = new common_test.HttpServerMock();

3555 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3556 var arg_variantId = "foo";

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

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

3559 var pathOffset = 0;

3560 var index;

3561 var subPart;

3562 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3563 pathOffset += 17;

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

3565 pathOffset += 9;

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

3567 pathOffset = path.length;

3568 unittest.expect(subPart, unittest.equals("$arg_variantId"));

3569

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

3571 var queryOffset = 0;

3572 var queryMap = {};

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

3574 parseBool(n) {

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

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

3577 if (n == null) return null;

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

3579 }

3580 if (query.length > 0) {

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

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

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

3584 }

3585 }

3586

3587

3588 var h = {

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

3590 };

3591 var resp = convert.JSON.encode(buildVariant());

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

3593 }), true);

3594 res.get(arg_variantId).then(unittest.expectAsync(((api.Variant response) {

3595 checkVariant(response);

3596 })));

3597 });

3598

3599 unittest.test("method--getSummary", () {

3600

3601 var mock = new common_test.HttpServerMock();

3602 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3603 var arg_variantsetId = "foo";

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

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

3606 var pathOffset = 0;

3607 var index;

3608 var subPart;

3609 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3610 pathOffset += 17;

3611 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("variants/summary"));

3612 pathOffset += 16;

3613

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

3615 var queryOffset = 0;

3616 var queryMap = {};

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

3618 parseBool(n) {

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

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

3621 if (n == null) return null;

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

3623 }

3624 if (query.length > 0) {

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

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

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

3628 }

3629 }

3630 unittest.expect(queryMap["variantsetId"].first, unittest.equals(arg_vari antsetId));

3631

3632

3633 var h = {

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

3635 };

3636 var resp = convert.JSON.encode(buildGetVariantsSummaryResponse());

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

3638 }), true);

3639 res.getSummary(variantsetId: arg_variantsetId).then(unittest.expectAsync(( (api.GetVariantsSummaryResponse response) {

3640 checkGetVariantsSummaryResponse(response);

3641 })));

3642 });

3643

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

3645

3646 var mock = new common_test.HttpServerMock();

3647 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3648 var arg_request = buildImportVariantsRequest();

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

3650 var obj = new api.ImportVariantsRequest.fromJson(json);

3651 checkImportVariantsRequest(obj);

3652

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

3654 var pathOffset = 0;

3655 var index;

3656 var subPart;

3657 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3658 pathOffset += 17;

3659 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("variants/import"));

3660 pathOffset += 15;

3661

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

3663 var queryOffset = 0;

3664 var queryMap = {};

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

3666 parseBool(n) {

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

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

3669 if (n == null) return null;

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

3671 }

3672 if (query.length > 0) {

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

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

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

3676 }

3677 }

3678

3679

3680 var h = {

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

3682 };

3683 var resp = convert.JSON.encode(buildImportVariantsResponse());

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

3685 }), true);

3686 res.import(arg_request).then(unittest.expectAsync(((api.ImportVariantsResp onse response) {

3687 checkImportVariantsResponse(response);

3688 })));

3689 });

3690

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

3692

3693 var mock = new common_test.HttpServerMock();

3694 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3695 var arg_request = buildVariant();

3696 var arg_variantId = "foo";

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

3698 var obj = new api.Variant.fromJson(json);

3699 checkVariant(obj);

3700

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

3702 var pathOffset = 0;

3703 var index;

3704 var subPart;

3705 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3706 pathOffset += 17;

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

3708 pathOffset += 9;

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

3710 pathOffset = path.length;

3711 unittest.expect(subPart, unittest.equals("$arg_variantId"));

3712

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

3714 var queryOffset = 0;

3715 var queryMap = {};

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

3717 parseBool(n) {

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

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

3720 if (n == null) return null;

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

3722 }

3723 if (query.length > 0) {

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

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

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

3727 }

3728 }

3729

3730

3731 var h = {

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

3733 };

3734 var resp = convert.JSON.encode(buildVariant());

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

3736 }), true);

3737 res.patch(arg_request, arg_variantId).then(unittest.expectAsync(((api.Vari ant response) {

3738 checkVariant(response);

3739 })));

3740 });

3741

3742 unittest.test("method--search", () {

3743

3744 var mock = new common_test.HttpServerMock();

3745 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3746 var arg_request = buildSearchVariantsRequest();

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

3748 var obj = new api.SearchVariantsRequest.fromJson(json);

3749 checkSearchVariantsRequest(obj);

3750

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

3752 var pathOffset = 0;

3753 var index;

3754 var subPart;

3755 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3756 pathOffset += 17;

3757 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("variants/search"));

3758 pathOffset += 15;

3759

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

3761 var queryOffset = 0;

3762 var queryMap = {};

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

3764 parseBool(n) {

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

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

3767 if (n == null) return null;

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

3769 }

3770 if (query.length > 0) {

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

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

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

3774 }

3775 }

3776

3777

3778 var h = {

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

3780 };

3781 var resp = convert.JSON.encode(buildSearchVariantsResponse());

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

3783 }), true);

3784 res.search(arg_request).then(unittest.expectAsync(((api.SearchVariantsResp onse response) {

3785 checkSearchVariantsResponse(response);

3786 })));

3787 });

3788

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

3790

3791 var mock = new common_test.HttpServerMock();

3792 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3793 var arg_request = buildVariant();

3794 var arg_variantId = "foo";

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

3796 var obj = new api.Variant.fromJson(json);

3797 checkVariant(obj);

3798

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

3800 var pathOffset = 0;

3801 var index;

3802 var subPart;

3803 unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.eq uals("/genomics/v1beta/"));

3804 pathOffset += 17;

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

3806 pathOffset += 9;

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

3808 pathOffset = path.length;

3809 unittest.expect(subPart, unittest.equals("$arg_variantId"));

3810

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

3812 var queryOffset = 0;

3813 var queryMap = {};

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

3815 parseBool(n) {

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

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

3818 if (n == null) return null;

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

3820 }

3821 if (query.length > 0) {

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

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

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

3825 }

3826 }

3827

3828

3829 var h = {

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

3831 };

3832 var resp = convert.JSON.encode(buildVariant());

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

3834 }), true);

3835 res.update(arg_request, arg_variantId).then(unittest.expectAsync(((api.Var iant response) {

3836 checkVariant(response);

3837 })));

3838 });

3839

3840 });

3841

3842

3843 }

3844

OLD	NEW

« no previous file with comments | « generated/googleapis_beta/test/dns/v1beta1_test.dart ('k') | generated/googleapis_beta/test/genomics/v1beta_test.dart » ('j') | no next file with comments »