generated/googleapis_beta/test/genomics/v1beta_test.dart - Issue 1078053002: Roll of googleapis as of 4/7/2015.

Side by Side Diff: generated/googleapis_beta/test/genomics/v1beta_test.dart

Issue 1078053002: Roll of googleapis as of 4/7/2015. (Closed) Base URL: https://github.com/dart-lang/googleapis.git@master

Patch Set: Created 5 years, 8 months ago

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

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 library googleapis_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 buildUnnamed1716() {

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

21 o.add(42);

22 o.add(42);

23 return o;

24 }

25

26 checkUnnamed1716(core.List<core.int> o) {

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

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

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

30 }

31

32 buildUnnamed1717() {

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

34 o.add(42.0);

35 o.add(42.0);

36 return o;

37 }

38

39 checkUnnamed1717(core.List<core.double> o) {

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

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

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

43 }

44

45 buildUnnamed1718() {

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

47 o.add("foo");

48 o.add("foo");

49 return o;

50 }

51

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

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

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

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

56 }

57

58 buildUnnamed1719() {

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

60 o["x"] = buildUnnamed1718();

61 o["y"] = buildUnnamed1718();

62 return o;

63 }

64

65 checkUnnamed1719(core.Map<core.String, core.List<core.String>> o) {

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

67 checkUnnamed1718(o["x"]);

68 checkUnnamed1718(o["y"]);

69 }

70

71 core.int buildCounterCall = 0;

72 buildCall() {

73 var o = new api.Call();

74 buildCounterCall++;

75 if (buildCounterCall < 3) {

76 o.callSetId = "foo";

77 o.callSetName = "foo";

78 o.genotype = buildUnnamed1716();

79 o.genotypeLikelihood = buildUnnamed1717();

80 o.info = buildUnnamed1719();

81 o.phaseset = "foo";

82 }

83 buildCounterCall--;

84 return o;

85 }

86

87 checkCall(api.Call o) {

88 buildCounterCall++;

89 if (buildCounterCall < 3) {

90 unittest.expect(o.callSetId, unittest.equals('foo'));

91 unittest.expect(o.callSetName, unittest.equals('foo'));

92 checkUnnamed1716(o.genotype);

93 checkUnnamed1717(o.genotypeLikelihood);

94 checkUnnamed1719(o.info);

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

96 }

97 buildCounterCall--;

98 }

99

100 buildUnnamed1720() {

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

102 o.add("foo");

103 o.add("foo");

104 return o;

105 }

106

107 checkUnnamed1720(core.List<core.String> o) {

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

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

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

111 }

112

113 buildUnnamed1721() {

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

115 o["x"] = buildUnnamed1720();

116 o["y"] = buildUnnamed1720();

117 return o;

118 }

119

120 checkUnnamed1721(core.Map<core.String, core.List<core.String>> o) {

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

122 checkUnnamed1720(o["x"]);

123 checkUnnamed1720(o["y"]);

124 }

125

126 buildUnnamed1722() {

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

128 o.add("foo");

129 o.add("foo");

130 return o;

131 }

132

133 checkUnnamed1722(core.List<core.String> o) {

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

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

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

137 }

138

139 core.int buildCounterCallSet = 0;

140 buildCallSet() {

141 var o = new api.CallSet();

142 buildCounterCallSet++;

143 if (buildCounterCallSet < 3) {

144 o.created = "foo";

145 o.id = "foo";

146 o.info = buildUnnamed1721();

147 o.name = "foo";

148 o.sampleId = "foo";

149 o.variantSetIds = buildUnnamed1722();

150 }

151 buildCounterCallSet--;

152 return o;

153 }

154

155 checkCallSet(api.CallSet o) {

156 buildCounterCallSet++;

157 if (buildCounterCallSet < 3) {

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

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

160 checkUnnamed1721(o.info);

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

162 unittest.expect(o.sampleId, unittest.equals('foo'));

163 checkUnnamed1722(o.variantSetIds);

164 }

165 buildCounterCallSet--;

166 }

167

168 core.int buildCounterCoverageBucket = 0;

169 buildCoverageBucket() {

170 var o = new api.CoverageBucket();

171 buildCounterCoverageBucket++;

172 if (buildCounterCoverageBucket < 3) {

173 o.meanCoverage = 42.0;

174 o.range = buildGenomicRange();

175 }

176 buildCounterCoverageBucket--;

177 return o;

178 }

179

180 checkCoverageBucket(api.CoverageBucket o) {

181 buildCounterCoverageBucket++;

182 if (buildCounterCoverageBucket < 3) {

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

184 checkGenomicRange(o.range);

185 }

186 buildCounterCoverageBucket--;

187 }

188

189 core.int buildCounterDataset = 0;

190 buildDataset() {

191 var o = new api.Dataset();

192 buildCounterDataset++;

193 if (buildCounterDataset < 3) {

194 o.id = "foo";

195 o.isPublic = true;

196 o.name = "foo";

197 o.projectId = "foo";

198 }

199 buildCounterDataset--;

200 return o;

201 }

202

203 checkDataset(api.Dataset o) {

204 buildCounterDataset++;

205 if (buildCounterDataset < 3) {

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

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

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

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

210 }

211 buildCounterDataset--;

212 }

213

214 buildUnnamed1723() {

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

216 o.add("foo");

217 o.add("foo");

218 return o;

219 }

220

221 checkUnnamed1723(core.List<core.String> o) {

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

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

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

225 }

226

227 buildUnnamed1724() {

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

229 o.add("foo");

230 o.add("foo");

231 return o;

232 }

233

234 checkUnnamed1724(core.List<core.String> o) {

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

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

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

238 }

239

240 core.int buildCounterExperimentalCreateJobRequest = 0;

241 buildExperimentalCreateJobRequest() {

242 var o = new api.ExperimentalCreateJobRequest();

243 buildCounterExperimentalCreateJobRequest++;

244 if (buildCounterExperimentalCreateJobRequest < 3) {

245 o.align = true;

246 o.callVariants = true;

247 o.gcsOutputPath = "foo";

248 o.pairedSourceUris = buildUnnamed1723();

249 o.projectId = "foo";

250 o.sourceUris = buildUnnamed1724();

251 }

252 buildCounterExperimentalCreateJobRequest--;

253 return o;

254 }

255

256 checkExperimentalCreateJobRequest(api.ExperimentalCreateJobRequest o) {

257 buildCounterExperimentalCreateJobRequest++;

258 if (buildCounterExperimentalCreateJobRequest < 3) {

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

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

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

262 checkUnnamed1723(o.pairedSourceUris);

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

264 checkUnnamed1724(o.sourceUris);

265 }

266 buildCounterExperimentalCreateJobRequest--;

267 }

268

269 core.int buildCounterExperimentalCreateJobResponse = 0;

270 buildExperimentalCreateJobResponse() {

271 var o = new api.ExperimentalCreateJobResponse();

272 buildCounterExperimentalCreateJobResponse++;

273 if (buildCounterExperimentalCreateJobResponse < 3) {

274 o.jobId = "foo";

275 }

276 buildCounterExperimentalCreateJobResponse--;

277 return o;

278 }

279

280 checkExperimentalCreateJobResponse(api.ExperimentalCreateJobResponse o) {

281 buildCounterExperimentalCreateJobResponse++;

282 if (buildCounterExperimentalCreateJobResponse < 3) {

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

284 }

285 buildCounterExperimentalCreateJobResponse--;

286 }

287

288 buildUnnamed1725() {

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

290 o.add("foo");

291 o.add("foo");

292 return o;

293 }

294

295 checkUnnamed1725(core.List<core.String> o) {

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

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

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

299 }

300

301 buildUnnamed1726() {

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

303 o.add("foo");

304 o.add("foo");

305 return o;

306 }

307

308 checkUnnamed1726(core.List<core.String> o) {

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

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

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

312 }

313

314 core.int buildCounterExportReadsetsRequest = 0;

315 buildExportReadsetsRequest() {

316 var o = new api.ExportReadsetsRequest();

317 buildCounterExportReadsetsRequest++;

318 if (buildCounterExportReadsetsRequest < 3) {

319 o.exportUri = "foo";

320 o.projectId = "foo";

321 o.readsetIds = buildUnnamed1725();

322 o.referenceNames = buildUnnamed1726();

323 }

324 buildCounterExportReadsetsRequest--;

325 return o;

326 }

327

328 checkExportReadsetsRequest(api.ExportReadsetsRequest o) {

329 buildCounterExportReadsetsRequest++;

330 if (buildCounterExportReadsetsRequest < 3) {

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

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

333 checkUnnamed1725(o.readsetIds);

334 checkUnnamed1726(o.referenceNames);

335 }

336 buildCounterExportReadsetsRequest--;

337 }

338

339 core.int buildCounterExportReadsetsResponse = 0;

340 buildExportReadsetsResponse() {

341 var o = new api.ExportReadsetsResponse();

342 buildCounterExportReadsetsResponse++;

343 if (buildCounterExportReadsetsResponse < 3) {

344 o.jobId = "foo";

345 }

346 buildCounterExportReadsetsResponse--;

347 return o;

348 }

349

350 checkExportReadsetsResponse(api.ExportReadsetsResponse o) {

351 buildCounterExportReadsetsResponse++;

352 if (buildCounterExportReadsetsResponse < 3) {

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

354 }

355 buildCounterExportReadsetsResponse--;

356 }

357

358 buildUnnamed1727() {

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

360 o.add("foo");

361 o.add("foo");

362 return o;

363 }

364

365 checkUnnamed1727(core.List<core.String> o) {

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

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

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

369 }

370

371 core.int buildCounterExportVariantsRequest = 0;

372 buildExportVariantsRequest() {

373 var o = new api.ExportVariantsRequest();

374 buildCounterExportVariantsRequest++;

375 if (buildCounterExportVariantsRequest < 3) {

376 o.bigqueryDataset = "foo";

377 o.bigqueryTable = "foo";

378 o.callSetIds = buildUnnamed1727();

379 o.format = "foo";

380 o.projectId = "foo";

381 o.variantSetId = "foo";

382 }

383 buildCounterExportVariantsRequest--;

384 return o;

385 }

386

387 checkExportVariantsRequest(api.ExportVariantsRequest o) {

388 buildCounterExportVariantsRequest++;

389 if (buildCounterExportVariantsRequest < 3) {

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

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

392 checkUnnamed1727(o.callSetIds);

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

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

395 unittest.expect(o.variantSetId, unittest.equals('foo'));

396 }

397 buildCounterExportVariantsRequest--;

398 }

399

400 core.int buildCounterExportVariantsResponse = 0;

401 buildExportVariantsResponse() {

402 var o = new api.ExportVariantsResponse();

403 buildCounterExportVariantsResponse++;

404 if (buildCounterExportVariantsResponse < 3) {

405 o.jobId = "foo";

406 }

407 buildCounterExportVariantsResponse--;

408 return o;

409 }

410

411 checkExportVariantsResponse(api.ExportVariantsResponse o) {

412 buildCounterExportVariantsResponse++;

413 if (buildCounterExportVariantsResponse < 3) {

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

415 }

416 buildCounterExportVariantsResponse--;

417 }

418

419 core.int buildCounterGenomicRange = 0;

420 buildGenomicRange() {

421 var o = new api.GenomicRange();

422 buildCounterGenomicRange++;

423 if (buildCounterGenomicRange < 3) {

424 o.sequenceEnd = "foo";

425 o.sequenceName = "foo";

426 o.sequenceStart = "foo";

427 }

428 buildCounterGenomicRange--;

429 return o;

430 }

431

432 checkGenomicRange(api.GenomicRange o) {

433 buildCounterGenomicRange++;

434 if (buildCounterGenomicRange < 3) {

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

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

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

438 }

439 buildCounterGenomicRange--;

440 }

441

442 core.int buildCounterHeader = 0;

443 buildHeader() {

444 var o = new api.Header();

445 buildCounterHeader++;

446 if (buildCounterHeader < 3) {

447 o.sortingOrder = "foo";

448 o.version = "foo";

449 }

450 buildCounterHeader--;

451 return o;

452 }

453

454 checkHeader(api.Header o) {

455 buildCounterHeader++;

456 if (buildCounterHeader < 3) {

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

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

459 }

460 buildCounterHeader--;

461 }

462

463 buildUnnamed1728() {

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

465 o.add("foo");

466 o.add("foo");

467 return o;

468 }

469

470 checkUnnamed1728(core.List<core.String> o) {

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

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

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

474 }

475

476 buildUnnamed1729() {

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

478 o.add(buildHeader());

479 o.add(buildHeader());

480 return o;

481 }

482

483 checkUnnamed1729(core.List<api.Header> o) {

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

485 checkHeader(o[0]);

486 checkHeader(o[1]);

487 }

488

489 buildUnnamed1730() {

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

491 o.add(buildProgram());

492 o.add(buildProgram());

493 return o;

494 }

495

496 checkUnnamed1730(core.List<api.Program> o) {

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

498 checkProgram(o[0]);

499 checkProgram(o[1]);

500 }

501

502 buildUnnamed1731() {

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

504 o.add(buildReadGroup());

505 o.add(buildReadGroup());

506 return o;

507 }

508

509 checkUnnamed1731(core.List<api.ReadGroup> o) {

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

511 checkReadGroup(o[0]);

512 checkReadGroup(o[1]);

513 }

514

515 buildUnnamed1732() {

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

517 o.add(buildReferenceSequence());

518 o.add(buildReferenceSequence());

519 return o;

520 }

521

522 checkUnnamed1732(core.List<api.ReferenceSequence> o) {

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

524 checkReferenceSequence(o[0]);

525 checkReferenceSequence(o[1]);

526 }

527

528 core.int buildCounterHeaderSection = 0;

529 buildHeaderSection() {

530 var o = new api.HeaderSection();

531 buildCounterHeaderSection++;

532 if (buildCounterHeaderSection < 3) {

533 o.comments = buildUnnamed1728();

534 o.fileUri = "foo";

535 o.filename = "foo";

536 o.headers = buildUnnamed1729();

537 o.programs = buildUnnamed1730();

538 o.readGroups = buildUnnamed1731();

539 o.refSequences = buildUnnamed1732();

540 }

541 buildCounterHeaderSection--;

542 return o;

543 }

544

545 checkHeaderSection(api.HeaderSection o) {

546 buildCounterHeaderSection++;

547 if (buildCounterHeaderSection < 3) {

548 checkUnnamed1728(o.comments);

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

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

551 checkUnnamed1729(o.headers);

552 checkUnnamed1730(o.programs);

553 checkUnnamed1731(o.readGroups);

554 checkUnnamed1732(o.refSequences);

555 }

556 buildCounterHeaderSection--;

557 }

558

559 buildUnnamed1733() {

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

561 o.add("foo");

562 o.add("foo");

563 return o;

564 }

565

566 checkUnnamed1733(core.List<core.String> o) {

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

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

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

570 }

571

572 core.int buildCounterImportReadsetsRequest = 0;

573 buildImportReadsetsRequest() {

574 var o = new api.ImportReadsetsRequest();

575 buildCounterImportReadsetsRequest++;

576 if (buildCounterImportReadsetsRequest < 3) {

577 o.datasetId = "foo";

578 o.sourceUris = buildUnnamed1733();

579 }

580 buildCounterImportReadsetsRequest--;

581 return o;

582 }

583

584 checkImportReadsetsRequest(api.ImportReadsetsRequest o) {

585 buildCounterImportReadsetsRequest++;

586 if (buildCounterImportReadsetsRequest < 3) {

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

588 checkUnnamed1733(o.sourceUris);

589 }

590 buildCounterImportReadsetsRequest--;

591 }

592

593 core.int buildCounterImportReadsetsResponse = 0;

594 buildImportReadsetsResponse() {

595 var o = new api.ImportReadsetsResponse();

596 buildCounterImportReadsetsResponse++;

597 if (buildCounterImportReadsetsResponse < 3) {

598 o.jobId = "foo";

599 }

600 buildCounterImportReadsetsResponse--;

601 return o;

602 }

603

604 checkImportReadsetsResponse(api.ImportReadsetsResponse o) {

605 buildCounterImportReadsetsResponse++;

606 if (buildCounterImportReadsetsResponse < 3) {

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

608 }

609 buildCounterImportReadsetsResponse--;

610 }

611

612 buildUnnamed1734() {

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

614 o.add("foo");

615 o.add("foo");

616 return o;

617 }

618

619 checkUnnamed1734(core.List<core.String> o) {

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

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

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

623 }

624

625 core.int buildCounterImportVariantsRequest = 0;

626 buildImportVariantsRequest() {

627 var o = new api.ImportVariantsRequest();

628 buildCounterImportVariantsRequest++;

629 if (buildCounterImportVariantsRequest < 3) {

630 o.format = "foo";

631 o.sourceUris = buildUnnamed1734();

632 o.variantSetId = "foo";

633 }

634 buildCounterImportVariantsRequest--;

635 return o;

636 }

637

638 checkImportVariantsRequest(api.ImportVariantsRequest o) {

639 buildCounterImportVariantsRequest++;

640 if (buildCounterImportVariantsRequest < 3) {

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

642 checkUnnamed1734(o.sourceUris);

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

644 }

645 buildCounterImportVariantsRequest--;

646 }

647

648 core.int buildCounterImportVariantsResponse = 0;

649 buildImportVariantsResponse() {

650 var o = new api.ImportVariantsResponse();

651 buildCounterImportVariantsResponse++;

652 if (buildCounterImportVariantsResponse < 3) {

653 o.jobId = "foo";

654 }

655 buildCounterImportVariantsResponse--;

656 return o;

657 }

658

659 checkImportVariantsResponse(api.ImportVariantsResponse o) {

660 buildCounterImportVariantsResponse++;

661 if (buildCounterImportVariantsResponse < 3) {

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

663 }

664 buildCounterImportVariantsResponse--;

665 }

666

667 buildUnnamed1735() {

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

669 o.add("foo");

670 o.add("foo");

671 return o;

672 }

673

674 checkUnnamed1735(core.List<core.String> o) {

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

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

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

678 }

679

680 buildUnnamed1736() {

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

682 o.add("foo");

683 o.add("foo");

684 return o;

685 }

686

687 checkUnnamed1736(core.List<core.String> o) {

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

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

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

691 }

692

693 buildUnnamed1737() {

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

695 o.add("foo");

696 o.add("foo");

697 return o;

698 }

699

700 checkUnnamed1737(core.List<core.String> o) {

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

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

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

704 }

705

706 core.int buildCounterJob = 0;

707 buildJob() {

708 var o = new api.Job();

709 buildCounterJob++;

710 if (buildCounterJob < 3) {

711 o.created = "foo";

712 o.description = "foo";

713 o.errors = buildUnnamed1735();

714 o.id = "foo";

715 o.importedIds = buildUnnamed1736();

716 o.projectId = "foo";

717 o.request = buildJobRequest();

718 o.status = "foo";

719 o.warnings = buildUnnamed1737();

720 }

721 buildCounterJob--;

722 return o;

723 }

724

725 checkJob(api.Job o) {

726 buildCounterJob++;

727 if (buildCounterJob < 3) {

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

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

730 checkUnnamed1735(o.errors);

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

732 checkUnnamed1736(o.importedIds);

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

734 checkJobRequest(o.request);

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

736 checkUnnamed1737(o.warnings);

737 }

738 buildCounterJob--;

739 }

740

741 buildUnnamed1738() {

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

743 o.add("foo");

744 o.add("foo");

745 return o;

746 }

747

748 checkUnnamed1738(core.List<core.String> o) {

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

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

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

752 }

753

754 buildUnnamed1739() {

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

756 o.add("foo");

757 o.add("foo");

758 return o;

759 }

760

761 checkUnnamed1739(core.List<core.String> o) {

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

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

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

765 }

766

767 core.int buildCounterJobRequest = 0;

768 buildJobRequest() {

769 var o = new api.JobRequest();

770 buildCounterJobRequest++;

771 if (buildCounterJobRequest < 3) {

772 o.destination = buildUnnamed1738();

773 o.source = buildUnnamed1739();

774 o.type = "foo";

775 }

776 buildCounterJobRequest--;

777 return o;

778 }

779

780 checkJobRequest(api.JobRequest o) {

781 buildCounterJobRequest++;

782 if (buildCounterJobRequest < 3) {

783 checkUnnamed1738(o.destination);

784 checkUnnamed1739(o.source);

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

786 }

787 buildCounterJobRequest--;

788 }

789

790 buildUnnamed1740() {

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

792 o.add(buildCoverageBucket());

793 o.add(buildCoverageBucket());

794 return o;

795 }

796

797 checkUnnamed1740(core.List<api.CoverageBucket> o) {

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

799 checkCoverageBucket(o[0]);

800 checkCoverageBucket(o[1]);

801 }

802

803 core.int buildCounterListCoverageBucketsResponse = 0;

804 buildListCoverageBucketsResponse() {

805 var o = new api.ListCoverageBucketsResponse();

806 buildCounterListCoverageBucketsResponse++;

807 if (buildCounterListCoverageBucketsResponse < 3) {

808 o.bucketWidth = "foo";

809 o.coverageBuckets = buildUnnamed1740();

810 o.nextPageToken = "foo";

811 }

812 buildCounterListCoverageBucketsResponse--;

813 return o;

814 }

815

816 checkListCoverageBucketsResponse(api.ListCoverageBucketsResponse o) {

817 buildCounterListCoverageBucketsResponse++;

818 if (buildCounterListCoverageBucketsResponse < 3) {

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

820 checkUnnamed1740(o.coverageBuckets);

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

822 }

823 buildCounterListCoverageBucketsResponse--;

824 }

825

826 buildUnnamed1741() {

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

828 o.add(buildDataset());

829 o.add(buildDataset());

830 return o;

831 }

832

833 checkUnnamed1741(core.List<api.Dataset> o) {

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

835 checkDataset(o[0]);

836 checkDataset(o[1]);

837 }

838

839 core.int buildCounterListDatasetsResponse = 0;

840 buildListDatasetsResponse() {

841 var o = new api.ListDatasetsResponse();

842 buildCounterListDatasetsResponse++;

843 if (buildCounterListDatasetsResponse < 3) {

844 o.datasets = buildUnnamed1741();

845 o.nextPageToken = "foo";

846 }

847 buildCounterListDatasetsResponse--;

848 return o;

849 }

850

851 checkListDatasetsResponse(api.ListDatasetsResponse o) {

852 buildCounterListDatasetsResponse++;

853 if (buildCounterListDatasetsResponse < 3) {

854 checkUnnamed1741(o.datasets);

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

856 }

857 buildCounterListDatasetsResponse--;

858 }

859

860 buildUnnamed1742() {

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

862 o.add(buildVariant());

863 o.add(buildVariant());

864 return o;

865 }

866

867 checkUnnamed1742(core.List<api.Variant> o) {

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

869 checkVariant(o[0]);

870 checkVariant(o[1]);

871 }

872

873 core.int buildCounterMergeVariantsRequest = 0;

874 buildMergeVariantsRequest() {

875 var o = new api.MergeVariantsRequest();

876 buildCounterMergeVariantsRequest++;

877 if (buildCounterMergeVariantsRequest < 3) {

878 o.variants = buildUnnamed1742();

879 }

880 buildCounterMergeVariantsRequest--;

881 return o;

882 }

883

884 checkMergeVariantsRequest(api.MergeVariantsRequest o) {

885 buildCounterMergeVariantsRequest++;

886 if (buildCounterMergeVariantsRequest < 3) {

887 checkUnnamed1742(o.variants);

888 }

889 buildCounterMergeVariantsRequest--;

890 }

891

892 buildUnnamed1743() {

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

894 o.add("foo");

895 o.add("foo");

896 return o;

897 }

898

899 checkUnnamed1743(core.List<core.String> o) {

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

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

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

903 }

904

905 buildUnnamed1744() {

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

907 o["x"] = buildUnnamed1743();

908 o["y"] = buildUnnamed1743();

909 return o;

910 }

911

912 checkUnnamed1744(core.Map<core.String, core.List<core.String>> o) {

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

914 checkUnnamed1743(o["x"]);

915 checkUnnamed1743(o["y"]);

916 }

917

918 core.int buildCounterMetadata = 0;

919 buildMetadata() {

920 var o = new api.Metadata();

921 buildCounterMetadata++;

922 if (buildCounterMetadata < 3) {

923 o.description = "foo";

924 o.id = "foo";

925 o.info = buildUnnamed1744();

926 o.key = "foo";

927 o.number = "foo";

928 o.type = "foo";

929 o.value = "foo";

930 }

931 buildCounterMetadata--;

932 return o;

933 }

934

935 checkMetadata(api.Metadata o) {

936 buildCounterMetadata++;

937 if (buildCounterMetadata < 3) {

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

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

940 checkUnnamed1744(o.info);

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

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

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

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

945 }

946 buildCounterMetadata--;

947 }

948

949 core.int buildCounterProgram = 0;

950 buildProgram() {

951 var o = new api.Program();

952 buildCounterProgram++;

953 if (buildCounterProgram < 3) {

954 o.commandLine = "foo";

955 o.id = "foo";

956 o.name = "foo";

957 o.prevProgramId = "foo";

958 o.version = "foo";

959 }

960 buildCounterProgram--;

961 return o;

962 }

963

964 checkProgram(api.Program o) {

965 buildCounterProgram++;

966 if (buildCounterProgram < 3) {

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

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

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

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

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

972 }

973 buildCounterProgram--;

974 }

975

976 buildUnnamed1745() {

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

978 o.add("foo");

979 o.add("foo");

980 return o;

981 }

982

983 checkUnnamed1745(core.List<core.String> o) {

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

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

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

987 }

988

989 buildUnnamed1746() {

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

991 o["x"] = buildUnnamed1745();

992 o["y"] = buildUnnamed1745();

993 return o;

994 }

995

996 checkUnnamed1746(core.Map<core.String, core.List<core.String>> o) {

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

998 checkUnnamed1745(o["x"]);

999 checkUnnamed1745(o["y"]);

1000 }

1001

1002 core.int buildCounterRead = 0;

1003 buildRead() {

1004 var o = new api.Read();

1005 buildCounterRead++;

1006 if (buildCounterRead < 3) {

1007 o.alignedBases = "foo";

1008 o.baseQuality = "foo";

1009 o.cigar = "foo";

1010 o.flags = 42;

1011 o.id = "foo";

1012 o.mappingQuality = 42;

1013 o.matePosition = 42;

1014 o.mateReferenceSequenceName = "foo";

1015 o.name = "foo";

1016 o.originalBases = "foo";

1017 o.position = 42;

1018 o.readsetId = "foo";

1019 o.referenceSequenceName = "foo";

1020 o.tags = buildUnnamed1746();

1021 o.templateLength = 42;

1022 }

1023 buildCounterRead--;

1024 return o;

1025 }

1026

1027 checkRead(api.Read o) {

1028 buildCounterRead++;

1029 if (buildCounterRead < 3) {

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

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

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

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

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

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

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

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

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

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

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

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

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

1043 checkUnnamed1746(o.tags);

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

1045 }

1046 buildCounterRead--;

1047 }

1048

1049 core.int buildCounterReadGroup = 0;

1050 buildReadGroup() {

1051 var o = new api.ReadGroup();

1052 buildCounterReadGroup++;

1053 if (buildCounterReadGroup < 3) {

1054 o.date = "foo";

1055 o.description = "foo";

1056 o.flowOrder = "foo";

1057 o.id = "foo";

1058 o.keySequence = "foo";

1059 o.library = "foo";

1060 o.platformUnit = "foo";

1061 o.predictedInsertSize = 42;

1062 o.processingProgram = "foo";

1063 o.sample = "foo";

1064 o.sequencingCenterName = "foo";

1065 o.sequencingTechnology = "foo";

1066 }

1067 buildCounterReadGroup--;

1068 return o;

1069 }

1070

1071 checkReadGroup(api.ReadGroup o) {

1072 buildCounterReadGroup++;

1073 if (buildCounterReadGroup < 3) {

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

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

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

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

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

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

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

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

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

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

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

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

1086 }

1087 buildCounterReadGroup--;

1088 }

1089

1090 buildUnnamed1747() {

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

1092 o.add(buildHeaderSection());

1093 o.add(buildHeaderSection());

1094 return o;

1095 }

1096

1097 checkUnnamed1747(core.List<api.HeaderSection> o) {

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

1099 checkHeaderSection(o[0]);

1100 checkHeaderSection(o[1]);

1101 }

1102

1103 core.int buildCounterReadset = 0;

1104 buildReadset() {

1105 var o = new api.Readset();

1106 buildCounterReadset++;

1107 if (buildCounterReadset < 3) {

1108 o.datasetId = "foo";

1109 o.fileData = buildUnnamed1747();

1110 o.id = "foo";

1111 o.name = "foo";

1112 }

1113 buildCounterReadset--;

1114 return o;

1115 }

1116

1117 checkReadset(api.Readset o) {

1118 buildCounterReadset++;

1119 if (buildCounterReadset < 3) {

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

1121 checkUnnamed1747(o.fileData);

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

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

1124 }

1125 buildCounterReadset--;

1126 }

1127

1128 core.int buildCounterReferenceBound = 0;

1129 buildReferenceBound() {

1130 var o = new api.ReferenceBound();

1131 buildCounterReferenceBound++;

1132 if (buildCounterReferenceBound < 3) {

1133 o.referenceName = "foo";

1134 o.upperBound = "foo";

1135 }

1136 buildCounterReferenceBound--;

1137 return o;

1138 }

1139

1140 checkReferenceBound(api.ReferenceBound o) {

1141 buildCounterReferenceBound++;

1142 if (buildCounterReferenceBound < 3) {

1143 unittest.expect(o.referenceName, unittest.equals('foo'));

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

1145 }

1146 buildCounterReferenceBound--;

1147 }

1148

1149 core.int buildCounterReferenceSequence = 0;

1150 buildReferenceSequence() {

1151 var o = new api.ReferenceSequence();

1152 buildCounterReferenceSequence++;

1153 if (buildCounterReferenceSequence < 3) {

1154 o.assemblyId = "foo";

1155 o.length = 42;

1156 o.md5Checksum = "foo";

1157 o.name = "foo";

1158 o.species = "foo";

1159 o.uri = "foo";

1160 }

1161 buildCounterReferenceSequence--;

1162 return o;

1163 }

1164

1165 checkReferenceSequence(api.ReferenceSequence o) {

1166 buildCounterReferenceSequence++;

1167 if (buildCounterReferenceSequence < 3) {

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

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

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

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

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

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

1174 }

1175 buildCounterReferenceSequence--;

1176 }

1177

1178 buildUnnamed1748() {

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

1180 o.add("foo");

1181 o.add("foo");

1182 return o;

1183 }

1184

1185 checkUnnamed1748(core.List<core.String> o) {

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

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

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

1189 }

1190

1191 core.int buildCounterSearchCallSetsRequest = 0;

1192 buildSearchCallSetsRequest() {

1193 var o = new api.SearchCallSetsRequest();

1194 buildCounterSearchCallSetsRequest++;

1195 if (buildCounterSearchCallSetsRequest < 3) {

1196 o.name = "foo";

1197 o.pageSize = 42;

1198 o.pageToken = "foo";

1199 o.variantSetIds = buildUnnamed1748();

1200 }

1201 buildCounterSearchCallSetsRequest--;

1202 return o;

1203 }

1204

1205 checkSearchCallSetsRequest(api.SearchCallSetsRequest o) {

1206 buildCounterSearchCallSetsRequest++;

1207 if (buildCounterSearchCallSetsRequest < 3) {

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

1209 unittest.expect(o.pageSize, unittest.equals(42));

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

1211 checkUnnamed1748(o.variantSetIds);

1212 }

1213 buildCounterSearchCallSetsRequest--;

1214 }

1215

1216 buildUnnamed1749() {

1217 var o = new core.List<api.CallSet>();

1218 o.add(buildCallSet());

1219 o.add(buildCallSet());

1220 return o;

1221 }

1222

1223 checkUnnamed1749(core.List<api.CallSet> o) {

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

1225 checkCallSet(o[0]);

1226 checkCallSet(o[1]);

1227 }

1228

1229 core.int buildCounterSearchCallSetsResponse = 0;

1230 buildSearchCallSetsResponse() {

1231 var o = new api.SearchCallSetsResponse();

1232 buildCounterSearchCallSetsResponse++;

1233 if (buildCounterSearchCallSetsResponse < 3) {

1234 o.callSets = buildUnnamed1749();

1235 o.nextPageToken = "foo";

1236 }

1237 buildCounterSearchCallSetsResponse--;

1238 return o;

1239 }

1240

1241 checkSearchCallSetsResponse(api.SearchCallSetsResponse o) {

1242 buildCounterSearchCallSetsResponse++;

1243 if (buildCounterSearchCallSetsResponse < 3) {

1244 checkUnnamed1749(o.callSets);

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

1246 }

1247 buildCounterSearchCallSetsResponse--;

1248 }

1249

1250 buildUnnamed1750() {

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

1252 o.add("foo");

1253 o.add("foo");

1254 return o;

1255 }

1256

1257 checkUnnamed1750(core.List<core.String> o) {

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

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

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

1261 }

1262

1263 core.int buildCounterSearchJobsRequest = 0;

1264 buildSearchJobsRequest() {

1265 var o = new api.SearchJobsRequest();

1266 buildCounterSearchJobsRequest++;

1267 if (buildCounterSearchJobsRequest < 3) {

1268 o.createdAfter = "foo";

1269 o.createdBefore = "foo";

1270 o.maxResults = "foo";

1271 o.pageToken = "foo";

1272 o.projectId = "foo";

1273 o.status = buildUnnamed1750();

1274 }

1275 buildCounterSearchJobsRequest--;

1276 return o;

1277 }

1278

1279 checkSearchJobsRequest(api.SearchJobsRequest o) {

1280 buildCounterSearchJobsRequest++;

1281 if (buildCounterSearchJobsRequest < 3) {

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

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

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

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

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

1287 checkUnnamed1750(o.status);

1288 }

1289 buildCounterSearchJobsRequest--;

1290 }

1291

1292 buildUnnamed1751() {

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

1294 o.add(buildJob());

1295 o.add(buildJob());

1296 return o;

1297 }

1298

1299 checkUnnamed1751(core.List<api.Job> o) {

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

1301 checkJob(o[0]);

1302 checkJob(o[1]);

1303 }

1304

1305 core.int buildCounterSearchJobsResponse = 0;

1306 buildSearchJobsResponse() {

1307 var o = new api.SearchJobsResponse();

1308 buildCounterSearchJobsResponse++;

1309 if (buildCounterSearchJobsResponse < 3) {

1310 o.jobs = buildUnnamed1751();

1311 o.nextPageToken = "foo";

1312 }

1313 buildCounterSearchJobsResponse--;

1314 return o;

1315 }

1316

1317 checkSearchJobsResponse(api.SearchJobsResponse o) {

1318 buildCounterSearchJobsResponse++;

1319 if (buildCounterSearchJobsResponse < 3) {

1320 checkUnnamed1751(o.jobs);

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

1322 }

1323 buildCounterSearchJobsResponse--;

1324 }

1325

1326 buildUnnamed1752() {

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

1328 o.add("foo");

1329 o.add("foo");

1330 return o;

1331 }

1332

1333 checkUnnamed1752(core.List<core.String> o) {

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

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

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

1337 }

1338

1339 core.int buildCounterSearchReadsRequest = 0;

1340 buildSearchReadsRequest() {

1341 var o = new api.SearchReadsRequest();

1342 buildCounterSearchReadsRequest++;

1343 if (buildCounterSearchReadsRequest < 3) {

1344 o.maxResults = "foo";

1345 o.pageToken = "foo";

1346 o.readsetIds = buildUnnamed1752();

1347 o.sequenceEnd = "foo";

1348 o.sequenceName = "foo";

1349 o.sequenceStart = "foo";

1350 }

1351 buildCounterSearchReadsRequest--;

1352 return o;

1353 }

1354

1355 checkSearchReadsRequest(api.SearchReadsRequest o) {

1356 buildCounterSearchReadsRequest++;

1357 if (buildCounterSearchReadsRequest < 3) {

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

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

1360 checkUnnamed1752(o.readsetIds);

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

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

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

1364 }

1365 buildCounterSearchReadsRequest--;

1366 }

1367

1368 buildUnnamed1753() {

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

1370 o.add(buildRead());

1371 o.add(buildRead());

1372 return o;

1373 }

1374

1375 checkUnnamed1753(core.List<api.Read> o) {

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

1377 checkRead(o[0]);

1378 checkRead(o[1]);

1379 }

1380

1381 core.int buildCounterSearchReadsResponse = 0;

1382 buildSearchReadsResponse() {

1383 var o = new api.SearchReadsResponse();

1384 buildCounterSearchReadsResponse++;

1385 if (buildCounterSearchReadsResponse < 3) {

1386 o.nextPageToken = "foo";

1387 o.reads = buildUnnamed1753();

1388 }

1389 buildCounterSearchReadsResponse--;

1390 return o;

1391 }

1392

1393 checkSearchReadsResponse(api.SearchReadsResponse o) {

1394 buildCounterSearchReadsResponse++;

1395 if (buildCounterSearchReadsResponse < 3) {

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

1397 checkUnnamed1753(o.reads);

1398 }

1399 buildCounterSearchReadsResponse--;

1400 }

1401

1402 buildUnnamed1754() {

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

1404 o.add("foo");

1405 o.add("foo");

1406 return o;

1407 }

1408

1409 checkUnnamed1754(core.List<core.String> o) {

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

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

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

1413 }

1414

1415 core.int buildCounterSearchReadsetsRequest = 0;

1416 buildSearchReadsetsRequest() {

1417 var o = new api.SearchReadsetsRequest();

1418 buildCounterSearchReadsetsRequest++;

1419 if (buildCounterSearchReadsetsRequest < 3) {

1420 o.datasetIds = buildUnnamed1754();

1421 o.maxResults = "foo";

1422 o.name = "foo";

1423 o.pageToken = "foo";

1424 }

1425 buildCounterSearchReadsetsRequest--;

1426 return o;

1427 }

1428

1429 checkSearchReadsetsRequest(api.SearchReadsetsRequest o) {

1430 buildCounterSearchReadsetsRequest++;

1431 if (buildCounterSearchReadsetsRequest < 3) {

1432 checkUnnamed1754(o.datasetIds);

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

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

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

1436 }

1437 buildCounterSearchReadsetsRequest--;

1438 }

1439

1440 buildUnnamed1755() {

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

1442 o.add(buildReadset());

1443 o.add(buildReadset());

1444 return o;

1445 }

1446

1447 checkUnnamed1755(core.List<api.Readset> o) {

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

1449 checkReadset(o[0]);

1450 checkReadset(o[1]);

1451 }

1452

1453 core.int buildCounterSearchReadsetsResponse = 0;

1454 buildSearchReadsetsResponse() {

1455 var o = new api.SearchReadsetsResponse();

1456 buildCounterSearchReadsetsResponse++;

1457 if (buildCounterSearchReadsetsResponse < 3) {

1458 o.nextPageToken = "foo";

1459 o.readsets = buildUnnamed1755();

1460 }

1461 buildCounterSearchReadsetsResponse--;

1462 return o;

1463 }

1464

1465 checkSearchReadsetsResponse(api.SearchReadsetsResponse o) {

1466 buildCounterSearchReadsetsResponse++;

1467 if (buildCounterSearchReadsetsResponse < 3) {

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

1469 checkUnnamed1755(o.readsets);

1470 }

1471 buildCounterSearchReadsetsResponse--;

1472 }

1473

1474 buildUnnamed1756() {

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

1476 o.add("foo");

1477 o.add("foo");

1478 return o;

1479 }

1480

1481 checkUnnamed1756(core.List<core.String> o) {

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

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

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

1485 }

1486

1487 core.int buildCounterSearchVariantSetsRequest = 0;

1488 buildSearchVariantSetsRequest() {

1489 var o = new api.SearchVariantSetsRequest();

1490 buildCounterSearchVariantSetsRequest++;

1491 if (buildCounterSearchVariantSetsRequest < 3) {

1492 o.datasetIds = buildUnnamed1756();

1493 o.pageSize = 42;

1494 o.pageToken = "foo";

1495 }

1496 buildCounterSearchVariantSetsRequest--;

1497 return o;

1498 }

1499

1500 checkSearchVariantSetsRequest(api.SearchVariantSetsRequest o) {

1501 buildCounterSearchVariantSetsRequest++;

1502 if (buildCounterSearchVariantSetsRequest < 3) {

1503 checkUnnamed1756(o.datasetIds);

1504 unittest.expect(o.pageSize, unittest.equals(42));

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

1506 }

1507 buildCounterSearchVariantSetsRequest--;

1508 }

1509

1510 buildUnnamed1757() {

1511 var o = new core.List<api.VariantSet>();

1512 o.add(buildVariantSet());

1513 o.add(buildVariantSet());

1514 return o;

1515 }

1516

1517 checkUnnamed1757(core.List<api.VariantSet> o) {

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

1519 checkVariantSet(o[0]);

1520 checkVariantSet(o[1]);

1521 }

1522

1523 core.int buildCounterSearchVariantSetsResponse = 0;

1524 buildSearchVariantSetsResponse() {

1525 var o = new api.SearchVariantSetsResponse();

1526 buildCounterSearchVariantSetsResponse++;

1527 if (buildCounterSearchVariantSetsResponse < 3) {

1528 o.nextPageToken = "foo";

1529 o.variantSets = buildUnnamed1757();

1530 }

1531 buildCounterSearchVariantSetsResponse--;

1532 return o;

1533 }

1534

1535 checkSearchVariantSetsResponse(api.SearchVariantSetsResponse o) {

1536 buildCounterSearchVariantSetsResponse++;

1537 if (buildCounterSearchVariantSetsResponse < 3) {

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

1539 checkUnnamed1757(o.variantSets);

1540 }

1541 buildCounterSearchVariantSetsResponse--;

1542 }

1543

1544 buildUnnamed1758() {

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

1546 o.add("foo");

1547 o.add("foo");

1548 return o;

1549 }

1550

1551 checkUnnamed1758(core.List<core.String> o) {

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

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

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

1555 }

1556

1557 buildUnnamed1759() {

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

1559 o.add("foo");

1560 o.add("foo");

1561 return o;

1562 }

1563

1564 checkUnnamed1759(core.List<core.String> o) {

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

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

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

1568 }

1569

1570 core.int buildCounterSearchVariantsRequest = 0;

1571 buildSearchVariantsRequest() {

1572 var o = new api.SearchVariantsRequest();

1573 buildCounterSearchVariantsRequest++;

1574 if (buildCounterSearchVariantsRequest < 3) {

1575 o.callSetIds = buildUnnamed1758();

1576 o.end = "foo";

1577 o.maxCalls = 42;

1578 o.pageSize = 42;

1579 o.pageToken = "foo";

1580 o.referenceName = "foo";

1581 o.start = "foo";

1582 o.variantName = "foo";

1583 o.variantSetIds = buildUnnamed1759();

1584 }

1585 buildCounterSearchVariantsRequest--;

1586 return o;

1587 }

1588

1589 checkSearchVariantsRequest(api.SearchVariantsRequest o) {

1590 buildCounterSearchVariantsRequest++;

1591 if (buildCounterSearchVariantsRequest < 3) {

1592 checkUnnamed1758(o.callSetIds);

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

1594 unittest.expect(o.maxCalls, unittest.equals(42));

1595 unittest.expect(o.pageSize, unittest.equals(42));

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

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

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

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

1600 checkUnnamed1759(o.variantSetIds);

1601 }

1602 buildCounterSearchVariantsRequest--;

1603 }

1604

1605 buildUnnamed1760() {

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

1607 o.add(buildVariant());

1608 o.add(buildVariant());

1609 return o;

1610 }

1611

1612 checkUnnamed1760(core.List<api.Variant> o) {

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

1614 checkVariant(o[0]);

1615 checkVariant(o[1]);

1616 }

1617

1618 core.int buildCounterSearchVariantsResponse = 0;

1619 buildSearchVariantsResponse() {

1620 var o = new api.SearchVariantsResponse();

1621 buildCounterSearchVariantsResponse++;

1622 if (buildCounterSearchVariantsResponse < 3) {

1623 o.nextPageToken = "foo";

1624 o.variants = buildUnnamed1760();

1625 }

1626 buildCounterSearchVariantsResponse--;

1627 return o;

1628 }

1629

1630 checkSearchVariantsResponse(api.SearchVariantsResponse o) {

1631 buildCounterSearchVariantsResponse++;

1632 if (buildCounterSearchVariantsResponse < 3) {

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

1634 checkUnnamed1760(o.variants);

1635 }

1636 buildCounterSearchVariantsResponse--;

1637 }

1638

1639 buildUnnamed1761() {

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

1641 o.add("foo");

1642 o.add("foo");

1643 return o;

1644 }

1645

1646 checkUnnamed1761(core.List<core.String> o) {

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

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

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

1650 }

1651

1652 buildUnnamed1762() {

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

1654 o.add(buildCall());

1655 o.add(buildCall());

1656 return o;

1657 }

1658

1659 checkUnnamed1762(core.List<api.Call> o) {

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

1661 checkCall(o[0]);

1662 checkCall(o[1]);

1663 }

1664

1665 buildUnnamed1763() {

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

1667 o.add("foo");

1668 o.add("foo");

1669 return o;

1670 }

1671

1672 checkUnnamed1763(core.List<core.String> o) {

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

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

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

1676 }

1677

1678 buildUnnamed1764() {

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

1680 o.add("foo");

1681 o.add("foo");

1682 return o;

1683 }

1684

1685 checkUnnamed1764(core.List<core.String> o) {

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

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

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

1689 }

1690

1691 buildUnnamed1765() {

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

1693 o["x"] = buildUnnamed1764();

1694 o["y"] = buildUnnamed1764();

1695 return o;

1696 }

1697

1698 checkUnnamed1765(core.Map<core.String, core.List<core.String>> o) {

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

1700 checkUnnamed1764(o["x"]);

1701 checkUnnamed1764(o["y"]);

1702 }

1703

1704 buildUnnamed1766() {

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

1706 o.add("foo");

1707 o.add("foo");

1708 return o;

1709 }

1710

1711 checkUnnamed1766(core.List<core.String> o) {

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

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

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

1715 }

1716

1717 core.int buildCounterVariant = 0;

1718 buildVariant() {

1719 var o = new api.Variant();

1720 buildCounterVariant++;

1721 if (buildCounterVariant < 3) {

1722 o.alternateBases = buildUnnamed1761();

1723 o.calls = buildUnnamed1762();

1724 o.created = "foo";

1725 o.end = "foo";

1726 o.filter = buildUnnamed1763();

1727 o.id = "foo";

1728 o.info = buildUnnamed1765();

1729 o.names = buildUnnamed1766();

1730 o.quality = 42.0;

1731 o.referenceBases = "foo";

1732 o.referenceName = "foo";

1733 o.start = "foo";

1734 o.variantSetId = "foo";

1735 }

1736 buildCounterVariant--;

1737 return o;

1738 }

1739

1740 checkVariant(api.Variant o) {

1741 buildCounterVariant++;

1742 if (buildCounterVariant < 3) {

1743 checkUnnamed1761(o.alternateBases);

1744 checkUnnamed1762(o.calls);

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

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

1747 checkUnnamed1763(o.filter);

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

1749 checkUnnamed1765(o.info);

1750 checkUnnamed1766(o.names);

1751 unittest.expect(o.quality, unittest.equals(42.0));

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

1753 unittest.expect(o.referenceName, unittest.equals('foo'));

1754 unittest.expect(o.start, unittest.equals('foo'));

1755 unittest.expect(o.variantSetId, unittest.equals('foo'));

1756 }

1757 buildCounterVariant--;

1758 }

1759

1760 buildUnnamed1767() {

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

1762 o.add(buildMetadata());

1763 o.add(buildMetadata());

1764 return o;

1765 }

1766

1767 checkUnnamed1767(core.List<api.Metadata> o) {

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

1769 checkMetadata(o[0]);

1770 checkMetadata(o[1]);

1771 }

1772

1773 buildUnnamed1768() {

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

1775 o.add(buildReferenceBound());

1776 o.add(buildReferenceBound());

1777 return o;

1778 }

1779

1780 checkUnnamed1768(core.List<api.ReferenceBound> o) {

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

1782 checkReferenceBound(o[0]);

1783 checkReferenceBound(o[1]);

1784 }

1785

1786 core.int buildCounterVariantSet = 0;

1787 buildVariantSet() {

1788 var o = new api.VariantSet();

1789 buildCounterVariantSet++;

1790 if (buildCounterVariantSet < 3) {

1791 o.datasetId = "foo";

1792 o.id = "foo";

1793 o.metadata = buildUnnamed1767();

1794 o.referenceBounds = buildUnnamed1768();

1795 }

1796 buildCounterVariantSet--;

1797 return o;

1798 }

1799

1800 checkVariantSet(api.VariantSet o) {

1801 buildCounterVariantSet++;

1802 if (buildCounterVariantSet < 3) {

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

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

1805 checkUnnamed1767(o.metadata);

1806 checkUnnamed1768(o.referenceBounds);

1807 }

1808 buildCounterVariantSet--;

1809 }

1810

1811

1812 main() {

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

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

1815 var o = buildCall();

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

1817 checkCall(od);

1818 });

1819 });

1820

1821

1822 unittest.group("obj-schema-CallSet", () {

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

1824 var o = buildCallSet();

1825 var od = new api.CallSet.fromJson(o.toJson());

1826 checkCallSet(od);

1827 });

1828 });

1829

1830

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

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

1833 var o = buildCoverageBucket();

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

1835 checkCoverageBucket(od);

1836 });

1837 });

1838

1839

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

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

1842 var o = buildDataset();

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

1844 checkDataset(od);

1845 });

1846 });

1847

1848

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

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

1851 var o = buildExperimentalCreateJobRequest();

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

1853 checkExperimentalCreateJobRequest(od);

1854 });

1855 });

1856

1857

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

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

1860 var o = buildExperimentalCreateJobResponse();

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

1862 checkExperimentalCreateJobResponse(od);

1863 });

1864 });

1865

1866

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

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

1869 var o = buildExportReadsetsRequest();

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

1871 checkExportReadsetsRequest(od);

1872 });

1873 });

1874

1875

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

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

1878 var o = buildExportReadsetsResponse();

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

1880 checkExportReadsetsResponse(od);

1881 });

1882 });

1883

1884

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

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

1887 var o = buildExportVariantsRequest();

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

1889 checkExportVariantsRequest(od);

1890 });

1891 });

1892

1893

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

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

1896 var o = buildExportVariantsResponse();

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

1898 checkExportVariantsResponse(od);

1899 });

1900 });

1901

1902

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

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

1905 var o = buildGenomicRange();

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

1907 checkGenomicRange(od);

1908 });

1909 });

1910

1911

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

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

1914 var o = buildHeader();

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

1916 checkHeader(od);

1917 });

1918 });

1919

1920

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

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

1923 var o = buildHeaderSection();

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

1925 checkHeaderSection(od);

1926 });

1927 });

1928

1929

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

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

1932 var o = buildImportReadsetsRequest();

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

1934 checkImportReadsetsRequest(od);

1935 });

1936 });

1937

1938

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

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

1941 var o = buildImportReadsetsResponse();

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

1943 checkImportReadsetsResponse(od);

1944 });

1945 });

1946

1947

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

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

1950 var o = buildImportVariantsRequest();

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

1952 checkImportVariantsRequest(od);

1953 });

1954 });

1955

1956

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

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

1959 var o = buildImportVariantsResponse();

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

1961 checkImportVariantsResponse(od);

1962 });

1963 });

1964

1965

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

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

1968 var o = buildJob();

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

1970 checkJob(od);

1971 });

1972 });

1973

1974

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

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

1977 var o = buildJobRequest();

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

1979 checkJobRequest(od);

1980 });

1981 });

1982

1983

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

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

1986 var o = buildListCoverageBucketsResponse();

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

1988 checkListCoverageBucketsResponse(od);

1989 });

1990 });

1991

1992

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

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

1995 var o = buildListDatasetsResponse();

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

1997 checkListDatasetsResponse(od);

1998 });

1999 });

2000

2001

2002 unittest.group("obj-schema-MergeVariantsRequest", () {

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

2004 var o = buildMergeVariantsRequest();

2005 var od = new api.MergeVariantsRequest.fromJson(o.toJson());

2006 checkMergeVariantsRequest(od);

2007 });

2008 });

2009

2010

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

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

2013 var o = buildMetadata();

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

2015 checkMetadata(od);

2016 });

2017 });

2018

2019

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

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

2022 var o = buildProgram();

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

2024 checkProgram(od);

2025 });

2026 });

2027

2028

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

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

2031 var o = buildRead();

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

2033 checkRead(od);

2034 });

2035 });

2036

2037

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

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

2040 var o = buildReadGroup();

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

2042 checkReadGroup(od);

2043 });

2044 });

2045

2046

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

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

2049 var o = buildReadset();

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

2051 checkReadset(od);

2052 });

2053 });

2054

2055

2056 unittest.group("obj-schema-ReferenceBound", () {

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

2058 var o = buildReferenceBound();

2059 var od = new api.ReferenceBound.fromJson(o.toJson());

2060 checkReferenceBound(od);

2061 });

2062 });

2063

2064

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

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

2067 var o = buildReferenceSequence();

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

2069 checkReferenceSequence(od);

2070 });

2071 });

2072

2073

2074 unittest.group("obj-schema-SearchCallSetsRequest", () {

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

2076 var o = buildSearchCallSetsRequest();

2077 var od = new api.SearchCallSetsRequest.fromJson(o.toJson());

2078 checkSearchCallSetsRequest(od);

2079 });

2080 });

2081

2082

2083 unittest.group("obj-schema-SearchCallSetsResponse", () {

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

2085 var o = buildSearchCallSetsResponse();

2086 var od = new api.SearchCallSetsResponse.fromJson(o.toJson());

2087 checkSearchCallSetsResponse(od);

2088 });

2089 });

2090

2091

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

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

2094 var o = buildSearchJobsRequest();

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

2096 checkSearchJobsRequest(od);

2097 });

2098 });

2099

2100

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

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

2103 var o = buildSearchJobsResponse();

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

2105 checkSearchJobsResponse(od);

2106 });

2107 });

2108

2109

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

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

2112 var o = buildSearchReadsRequest();

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

2114 checkSearchReadsRequest(od);

2115 });

2116 });

2117

2118

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

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

2121 var o = buildSearchReadsResponse();

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

2123 checkSearchReadsResponse(od);

2124 });

2125 });

2126

2127

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

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

2130 var o = buildSearchReadsetsRequest();

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

2132 checkSearchReadsetsRequest(od);

2133 });

2134 });

2135

2136

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

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

2139 var o = buildSearchReadsetsResponse();

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

2141 checkSearchReadsetsResponse(od);

2142 });

2143 });

2144

2145

2146 unittest.group("obj-schema-SearchVariantSetsRequest", () {

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

2148 var o = buildSearchVariantSetsRequest();

2149 var od = new api.SearchVariantSetsRequest.fromJson(o.toJson());

2150 checkSearchVariantSetsRequest(od);

2151 });

2152 });

2153

2154

2155 unittest.group("obj-schema-SearchVariantSetsResponse", () {

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

2157 var o = buildSearchVariantSetsResponse();

2158 var od = new api.SearchVariantSetsResponse.fromJson(o.toJson());

2159 checkSearchVariantSetsResponse(od);

2160 });

2161 });

2162

2163

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

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

2166 var o = buildSearchVariantsRequest();

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

2168 checkSearchVariantsRequest(od);

2169 });

2170 });

2171

2172

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

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

2175 var o = buildSearchVariantsResponse();

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

2177 checkSearchVariantsResponse(od);

2178 });

2179 });

2180

2181

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

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

2184 var o = buildVariant();

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

2186 checkVariant(od);

2187 });

2188 });

2189

2190

2191 unittest.group("obj-schema-VariantSet", () {

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

2193 var o = buildVariantSet();

2194 var od = new api.VariantSet.fromJson(o.toJson());

2195 checkVariantSet(od);

2196 });

2197 });

2198

2199

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

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

2202

2203 var mock = new common_test.HttpServerMock();

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

2205 var arg_request = buildCallSet();

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

2207 var obj = new api.CallSet.fromJson(json);

2208 checkCallSet(obj);

2209

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

2211 var pathOffset = 0;

2212 var index;

2213 var subPart;

2214 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2215 pathOffset += 1;

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

2217 pathOffset += 16;

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

2219 pathOffset += 8;

2220

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

2222 var queryOffset = 0;

2223 var queryMap = {};

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

2225 parseBool(n) {

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

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

2228 if (n == null) return null;

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

2230 }

2231 if (query.length > 0) {

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

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

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

2235 }

2236 }

2237

2238

2239 var h = {

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

2241 };

2242 var resp = convert.JSON.encode(buildCallSet());

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

2244 }), true);

2245 res.create(arg_request).then(unittest.expectAsync(((api.CallSet response) {

2246 checkCallSet(response);

2247 })));

2248 });

2249

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

2251

2252 var mock = new common_test.HttpServerMock();

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

2254 var arg_callSetId = "foo";

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

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

2257 var pathOffset = 0;

2258 var index;

2259 var subPart;

2260 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2261 pathOffset += 1;

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

2263 pathOffset += 16;

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

2265 pathOffset += 9;

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

2267 pathOffset = path.length;

2268 unittest.expect(subPart, unittest.equals("$arg_callSetId"));

2269

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

2271 var queryOffset = 0;

2272 var queryMap = {};

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

2274 parseBool(n) {

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

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

2277 if (n == null) return null;

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

2279 }

2280 if (query.length > 0) {

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

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

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

2284 }

2285 }

2286

2287

2288 var h = {

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

2290 };

2291 var resp = "";

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

2293 }), true);

2294 res.delete(arg_callSetId).then(unittest.expectAsync((_) {}));

2295 });

2296

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

2298

2299 var mock = new common_test.HttpServerMock();

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

2301 var arg_callSetId = "foo";

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

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

2304 var pathOffset = 0;

2305 var index;

2306 var subPart;

2307 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2308 pathOffset += 1;

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

2310 pathOffset += 16;

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

2312 pathOffset += 9;

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

2314 pathOffset = path.length;

2315 unittest.expect(subPart, unittest.equals("$arg_callSetId"));

2316

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

2318 var queryOffset = 0;

2319 var queryMap = {};

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

2321 parseBool(n) {

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

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

2324 if (n == null) return null;

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

2326 }

2327 if (query.length > 0) {

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

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

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

2331 }

2332 }

2333

2334

2335 var h = {

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

2337 };

2338 var resp = convert.JSON.encode(buildCallSet());

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

2340 }), true);

2341 res.get(arg_callSetId).then(unittest.expectAsync(((api.CallSet response) {

2342 checkCallSet(response);

2343 })));

2344 });

2345

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

2347

2348 var mock = new common_test.HttpServerMock();

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

2350 var arg_request = buildCallSet();

2351 var arg_callSetId = "foo";

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

2353 var obj = new api.CallSet.fromJson(json);

2354 checkCallSet(obj);

2355

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

2357 var pathOffset = 0;

2358 var index;

2359 var subPart;

2360 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2361 pathOffset += 1;

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

2363 pathOffset += 16;

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

2365 pathOffset += 9;

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

2367 pathOffset = path.length;

2368 unittest.expect(subPart, unittest.equals("$arg_callSetId"));

2369

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

2371 var queryOffset = 0;

2372 var queryMap = {};

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

2374 parseBool(n) {

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

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

2377 if (n == null) return null;

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

2379 }

2380 if (query.length > 0) {

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

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

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

2384 }

2385 }

2386

2387

2388 var h = {

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

2390 };

2391 var resp = convert.JSON.encode(buildCallSet());

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

2393 }), true);

2394 res.patch(arg_request, arg_callSetId).then(unittest.expectAsync(((api.Call Set response) {

2395 checkCallSet(response);

2396 })));

2397 });

2398

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

2400

2401 var mock = new common_test.HttpServerMock();

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

2403 var arg_request = buildSearchCallSetsRequest();

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

2405 var obj = new api.SearchCallSetsRequest.fromJson(json);

2406 checkSearchCallSetsRequest(obj);

2407

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

2409 var pathOffset = 0;

2410 var index;

2411 var subPart;

2412 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2413 pathOffset += 1;

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

2415 pathOffset += 16;

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

2417 pathOffset += 15;

2418

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

2420 var queryOffset = 0;

2421 var queryMap = {};

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

2423 parseBool(n) {

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

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

2426 if (n == null) return null;

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

2428 }

2429 if (query.length > 0) {

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

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

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

2433 }

2434 }

2435

2436

2437 var h = {

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

2439 };

2440 var resp = convert.JSON.encode(buildSearchCallSetsResponse());

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

2442 }), true);

2443 res.search(arg_request).then(unittest.expectAsync(((api.SearchCallSetsResp onse response) {

2444 checkSearchCallSetsResponse(response);

2445 })));

2446 });

2447

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

2449

2450 var mock = new common_test.HttpServerMock();

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

2452 var arg_request = buildCallSet();

2453 var arg_callSetId = "foo";

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

2455 var obj = new api.CallSet.fromJson(json);

2456 checkCallSet(obj);

2457

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

2459 var pathOffset = 0;

2460 var index;

2461 var subPart;

2462 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2463 pathOffset += 1;

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

2465 pathOffset += 16;

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

2467 pathOffset += 9;

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

2469 pathOffset = path.length;

2470 unittest.expect(subPart, unittest.equals("$arg_callSetId"));

2471

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

2473 var queryOffset = 0;

2474 var queryMap = {};

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

2476 parseBool(n) {

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

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

2479 if (n == null) return null;

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

2481 }

2482 if (query.length > 0) {

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

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

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

2486 }

2487 }

2488

2489

2490 var h = {

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

2492 };

2493 var resp = convert.JSON.encode(buildCallSet());

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

2495 }), true);

2496 res.update(arg_request, arg_callSetId).then(unittest.expectAsync(((api.Cal lSet response) {

2497 checkCallSet(response);

2498 })));

2499 });

2500

2501 });

2502

2503

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

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

2506

2507 var mock = new common_test.HttpServerMock();

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

2509 var arg_request = buildDataset();

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

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

2512 checkDataset(obj);

2513

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

2515 var pathOffset = 0;

2516 var index;

2517 var subPart;

2518 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2519 pathOffset += 1;

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

2521 pathOffset += 16;

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

2523 pathOffset += 8;

2524

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

2526 var queryOffset = 0;

2527 var queryMap = {};

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

2529 parseBool(n) {

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

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

2532 if (n == null) return null;

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

2534 }

2535 if (query.length > 0) {

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

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

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

2539 }

2540 }

2541

2542

2543 var h = {

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

2545 };

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

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

2548 }), true);

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

2550 checkDataset(response);

2551 })));

2552 });

2553

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

2555

2556 var mock = new common_test.HttpServerMock();

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

2558 var arg_datasetId = "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 + 1), unittest.equ als("/"));

2565 pathOffset += 1;

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

2567 pathOffset += 16;

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

2569 pathOffset += 9;

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

2571 pathOffset = path.length;

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

2573

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

2575 var queryOffset = 0;

2576 var queryMap = {};

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

2578 parseBool(n) {

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

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

2581 if (n == null) return null;

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

2583 }

2584 if (query.length > 0) {

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

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

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

2588 }

2589 }

2590

2591

2592 var h = {

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

2594 };

2595 var resp = "";

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

2597 }), true);

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

2599 });

2600

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

2602

2603 var mock = new common_test.HttpServerMock();

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

2605 var arg_datasetId = "foo";

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

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

2608 var pathOffset = 0;

2609 var index;

2610 var subPart;

2611 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2612 pathOffset += 1;

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

2614 pathOffset += 16;

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

2616 pathOffset += 9;

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

2618 pathOffset = path.length;

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

2620

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

2622 var queryOffset = 0;

2623 var queryMap = {};

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

2625 parseBool(n) {

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

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

2628 if (n == null) return null;

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

2630 }

2631 if (query.length > 0) {

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

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

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

2635 }

2636 }

2637

2638

2639 var h = {

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

2641 };

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

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

2644 }), true);

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

2646 checkDataset(response);

2647 })));

2648 });

2649

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

2651

2652 var mock = new common_test.HttpServerMock();

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

2654 var arg_maxResults = "foo";

2655 var arg_pageToken = "foo";

2656 var arg_projectId = "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 + 1), unittest.equ als("/"));

2663 pathOffset += 1;

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

2665 pathOffset += 16;

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

2667 pathOffset += 8;

2668

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

2670 var queryOffset = 0;

2671 var queryMap = {};

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

2673 parseBool(n) {

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

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

2676 if (n == null) return null;

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

2678 }

2679 if (query.length > 0) {

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

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

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

2683 }

2684 }

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

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

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

2688

2689

2690 var h = {

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

2692 };

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

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

2695 }), true);

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

2697 checkListDatasetsResponse(response);

2698 })));

2699 });

2700

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

2702

2703 var mock = new common_test.HttpServerMock();

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

2705 var arg_request = buildDataset();

2706 var arg_datasetId = "foo";

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

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

2709 checkDataset(obj);

2710

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

2712 var pathOffset = 0;

2713 var index;

2714 var subPart;

2715 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2716 pathOffset += 1;

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

2718 pathOffset += 16;

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.patch(arg_request, arg_datasetId).then(unittest.expectAsync(((api.Data set response) {

2750 checkDataset(response);

2751 })));

2752 });

2753

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

2755

2756 var mock = new common_test.HttpServerMock();

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

2758 var arg_datasetId = "foo";

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

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

2761 var pathOffset = 0;

2762 var index;

2763 var subPart;

2764 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2765 pathOffset += 1;

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

2767 pathOffset += 16;

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

2769 pathOffset += 9;

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

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

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

2773 pathOffset = index;

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

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

2776 pathOffset += 9;

2777

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

2779 var queryOffset = 0;

2780 var queryMap = {};

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

2782 parseBool(n) {

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

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

2785 if (n == null) return null;

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

2787 }

2788 if (query.length > 0) {

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

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

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

2792 }

2793 }

2794

2795

2796 var h = {

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

2798 };

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

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

2801 }), true);

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

2803 checkDataset(response);

2804 })));

2805 });

2806

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

2808

2809 var mock = new common_test.HttpServerMock();

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

2811 var arg_request = buildDataset();

2812 var arg_datasetId = "foo";

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

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

2815 checkDataset(obj);

2816

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

2818 var pathOffset = 0;

2819 var index;

2820 var subPart;

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

2822 pathOffset += 1;

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

2824 pathOffset += 16;

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

2826 pathOffset += 9;

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

2828 pathOffset = path.length;

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

2830

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

2832 var queryOffset = 0;

2833 var queryMap = {};

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

2835 parseBool(n) {

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

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

2838 if (n == null) return null;

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

2840 }

2841 if (query.length > 0) {

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

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

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

2845 }

2846 }

2847

2848

2849 var h = {

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

2851 };

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

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

2854 }), true);

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

2856 checkDataset(response);

2857 })));

2858 });

2859

2860 });

2861

2862

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

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

2865

2866 var mock = new common_test.HttpServerMock();

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

2868 var arg_request = buildExperimentalCreateJobRequest();

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

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

2871 checkExperimentalCreateJobRequest(obj);

2872

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

2874 var pathOffset = 0;

2875 var index;

2876 var subPart;

2877 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2878 pathOffset += 1;

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

2880 pathOffset += 16;

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

2882 pathOffset += 24;

2883

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

2885 var queryOffset = 0;

2886 var queryMap = {};

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

2888 parseBool(n) {

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

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

2891 if (n == null) return null;

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

2893 }

2894 if (query.length > 0) {

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

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

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

2898 }

2899 }

2900

2901

2902 var h = {

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

2904 };

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

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

2907 }), true);

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

2909 checkExperimentalCreateJobResponse(response);

2910 })));

2911 });

2912

2913 });

2914

2915

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

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

2918

2919 var mock = new common_test.HttpServerMock();

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

2921 var arg_jobId = "foo";

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

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

2924 var pathOffset = 0;

2925 var index;

2926 var subPart;

2927 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2928 pathOffset += 1;

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

2930 pathOffset += 16;

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

2932 pathOffset += 5;

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

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

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

2936 pathOffset = index;

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

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

2939 pathOffset += 7;

2940

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

2942 var queryOffset = 0;

2943 var queryMap = {};

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

2945 parseBool(n) {

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

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

2948 if (n == null) return null;

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

2950 }

2951 if (query.length > 0) {

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

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

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

2955 }

2956 }

2957

2958

2959 var h = {

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

2961 };

2962 var resp = "";

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

2964 }), true);

2965 res.cancel(arg_jobId).then(unittest.expectAsync((_) {}));

2966 });

2967

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

2969

2970 var mock = new common_test.HttpServerMock();

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

2972 var arg_jobId = "foo";

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

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

2975 var pathOffset = 0;

2976 var index;

2977 var subPart;

2978 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

2979 pathOffset += 1;

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

2981 pathOffset += 16;

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

2983 pathOffset += 5;

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

2985 pathOffset = path.length;

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

2987

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

2989 var queryOffset = 0;

2990 var queryMap = {};

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

2992 parseBool(n) {

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

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

2995 if (n == null) return null;

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

2997 }

2998 if (query.length > 0) {

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

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

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

3002 }

3003 }

3004

3005

3006 var h = {

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

3008 };

3009 var resp = convert.JSON.encode(buildJob());

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

3011 }), true);

3012 res.get(arg_jobId).then(unittest.expectAsync(((api.Job response) {

3013 checkJob(response);

3014 })));

3015 });

3016

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

3018

3019 var mock = new common_test.HttpServerMock();

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

3021 var arg_request = buildSearchJobsRequest();

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

3023 var obj = new api.SearchJobsRequest.fromJson(json);

3024 checkSearchJobsRequest(obj);

3025

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

3027 var pathOffset = 0;

3028 var index;

3029 var subPart;

3030 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3031 pathOffset += 1;

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

3033 pathOffset += 16;

3034 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("jobs/search"));

3035 pathOffset += 11;

3036

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

3038 var queryOffset = 0;

3039 var queryMap = {};

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

3041 parseBool(n) {

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

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

3044 if (n == null) return null;

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

3046 }

3047 if (query.length > 0) {

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

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

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

3051 }

3052 }

3053

3054

3055 var h = {

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

3057 };

3058 var resp = convert.JSON.encode(buildSearchJobsResponse());

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

3060 }), true);

3061 res.search(arg_request).then(unittest.expectAsync(((api.SearchJobsResponse response) {

3062 checkSearchJobsResponse(response);

3063 })));

3064 });

3065

3066 });

3067

3068

3069 unittest.group("resource-ReadsResourceApi", () {

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

3071

3072 var mock = new common_test.HttpServerMock();

3073 api.ReadsResourceApi res = new api.GenomicsApi(mock).reads;

3074 var arg_request = buildSearchReadsRequest();

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

3076 var obj = new api.SearchReadsRequest.fromJson(json);

3077 checkSearchReadsRequest(obj);

3078

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

3080 var pathOffset = 0;

3081 var index;

3082 var subPart;

3083 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3084 pathOffset += 1;

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

3086 pathOffset += 16;

3087 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("reads/search"));

3088 pathOffset += 12;

3089

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

3091 var queryOffset = 0;

3092 var queryMap = {};

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

3094 parseBool(n) {

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

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

3097 if (n == null) return null;

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

3099 }

3100 if (query.length > 0) {

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

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

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

3104 }

3105 }

3106

3107

3108 var h = {

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

3110 };

3111 var resp = convert.JSON.encode(buildSearchReadsResponse());

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

3113 }), true);

3114 res.search(arg_request).then(unittest.expectAsync(((api.SearchReadsRespons e response) {

3115 checkSearchReadsResponse(response);

3116 })));

3117 });

3118

3119 });

3120

3121

3122 unittest.group("resource-ReadsetsResourceApi", () {

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

3124

3125 var mock = new common_test.HttpServerMock();

3126 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3127 var arg_readsetId = "foo";

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

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

3130 var pathOffset = 0;

3131 var index;

3132 var subPart;

3133 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3134 pathOffset += 1;

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

3136 pathOffset += 16;

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

3138 pathOffset += 9;

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

3140 pathOffset = path.length;

3141 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3142

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

3144 var queryOffset = 0;

3145 var queryMap = {};

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

3147 parseBool(n) {

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

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

3150 if (n == null) return null;

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

3152 }

3153 if (query.length > 0) {

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

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

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

3157 }

3158 }

3159

3160

3161 var h = {

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

3163 };

3164 var resp = "";

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

3166 }), true);

3167 res.delete(arg_readsetId).then(unittest.expectAsync((_) {}));

3168 });

3169

3170 unittest.test("method--export", () {

3171

3172 var mock = new common_test.HttpServerMock();

3173 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3174 var arg_request = buildExportReadsetsRequest();

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

3176 var obj = new api.ExportReadsetsRequest.fromJson(json);

3177 checkExportReadsetsRequest(obj);

3178

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

3180 var pathOffset = 0;

3181 var index;

3182 var subPart;

3183 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3184 pathOffset += 1;

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

3186 pathOffset += 16;

3187 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("readsets/export"));

3188 pathOffset += 15;

3189

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

3191 var queryOffset = 0;

3192 var queryMap = {};

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

3194 parseBool(n) {

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

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

3197 if (n == null) return null;

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

3199 }

3200 if (query.length > 0) {

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

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

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

3204 }

3205 }

3206

3207

3208 var h = {

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

3210 };

3211 var resp = convert.JSON.encode(buildExportReadsetsResponse());

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

3213 }), true);

3214 res.export(arg_request).then(unittest.expectAsync(((api.ExportReadsetsResp onse response) {

3215 checkExportReadsetsResponse(response);

3216 })));

3217 });

3218

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

3220

3221 var mock = new common_test.HttpServerMock();

3222 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3223 var arg_readsetId = "foo";

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

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

3226 var pathOffset = 0;

3227 var index;

3228 var subPart;

3229 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3230 pathOffset += 1;

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

3232 pathOffset += 16;

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

3234 pathOffset += 9;

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

3236 pathOffset = path.length;

3237 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3238

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

3240 var queryOffset = 0;

3241 var queryMap = {};

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

3243 parseBool(n) {

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

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

3246 if (n == null) return null;

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

3248 }

3249 if (query.length > 0) {

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

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

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

3253 }

3254 }

3255

3256

3257 var h = {

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

3259 };

3260 var resp = convert.JSON.encode(buildReadset());

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

3262 }), true);

3263 res.get(arg_readsetId).then(unittest.expectAsync(((api.Readset response) {

3264 checkReadset(response);

3265 })));

3266 });

3267

3268 unittest.test("method--import", () {

3269

3270 var mock = new common_test.HttpServerMock();

3271 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3272 var arg_request = buildImportReadsetsRequest();

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

3274 var obj = new api.ImportReadsetsRequest.fromJson(json);

3275 checkImportReadsetsRequest(obj);

3276

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

3278 var pathOffset = 0;

3279 var index;

3280 var subPart;

3281 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3282 pathOffset += 1;

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

3284 pathOffset += 16;

3285 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("readsets/import"));

3286 pathOffset += 15;

3287

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

3289 var queryOffset = 0;

3290 var queryMap = {};

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

3292 parseBool(n) {

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

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

3295 if (n == null) return null;

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

3297 }

3298 if (query.length > 0) {

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

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

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

3302 }

3303 }

3304

3305

3306 var h = {

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

3308 };

3309 var resp = convert.JSON.encode(buildImportReadsetsResponse());

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

3311 }), true);

3312 res.import(arg_request).then(unittest.expectAsync(((api.ImportReadsetsResp onse response) {

3313 checkImportReadsetsResponse(response);

3314 })));

3315 });

3316

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

3318

3319 var mock = new common_test.HttpServerMock();

3320 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3321 var arg_request = buildReadset();

3322 var arg_readsetId = "foo";

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

3324 var obj = new api.Readset.fromJson(json);

3325 checkReadset(obj);

3326

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

3328 var pathOffset = 0;

3329 var index;

3330 var subPart;

3331 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3332 pathOffset += 1;

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

3334 pathOffset += 16;

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

3336 pathOffset += 9;

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

3338 pathOffset = path.length;

3339 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3340

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

3342 var queryOffset = 0;

3343 var queryMap = {};

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

3345 parseBool(n) {

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

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

3348 if (n == null) return null;

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

3350 }

3351 if (query.length > 0) {

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

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

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

3355 }

3356 }

3357

3358

3359 var h = {

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

3361 };

3362 var resp = convert.JSON.encode(buildReadset());

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

3364 }), true);

3365 res.patch(arg_request, arg_readsetId).then(unittest.expectAsync(((api.Read set response) {

3366 checkReadset(response);

3367 })));

3368 });

3369

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

3371

3372 var mock = new common_test.HttpServerMock();

3373 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3374 var arg_request = buildSearchReadsetsRequest();

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

3376 var obj = new api.SearchReadsetsRequest.fromJson(json);

3377 checkSearchReadsetsRequest(obj);

3378

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

3380 var pathOffset = 0;

3381 var index;

3382 var subPart;

3383 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3384 pathOffset += 1;

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

3386 pathOffset += 16;

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

3388 pathOffset += 15;

3389

3390 var query = (req.url).query;

3391 var queryOffset = 0;

3392 var queryMap = {};

3393 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3394 parseBool(n) {

3395 if (n == "true") return true;

3396 if (n == "false") return false;

3397 if (n == null) return null;

3398 throw new core.ArgumentError("Invalid boolean: $n");

3399 }

3400 if (query.length > 0) {

3401 for (var part in query.split("&")) {

3402 var keyvalue = part.split("=");

3403 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3404 }

3405 }

3406

3407

3408 var h = {

3409 "content-type" : "application/json; charset=utf-8",

3410 };

3411 var resp = convert.JSON.encode(buildSearchReadsetsResponse());

3412 return new async.Future.value(common_test.stringResponse(200, h, resp));

3413 }), true);

3414 res.search(arg_request).then(unittest.expectAsync(((api.SearchReadsetsResp onse response) {

3415 checkSearchReadsetsResponse(response);

3416 })));

3417 });

3418

3419 unittest.test("method--update", () {

3420

3421 var mock = new common_test.HttpServerMock();

3422 api.ReadsetsResourceApi res = new api.GenomicsApi(mock).readsets;

3423 var arg_request = buildReadset();

3424 var arg_readsetId = "foo";

3425 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3426 var obj = new api.Readset.fromJson(json);

3427 checkReadset(obj);

3428

3429 var path = (req.url).path;

3430 var pathOffset = 0;

3431 var index;

3432 var subPart;

3433 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3434 pathOffset += 1;

3435 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3436 pathOffset += 16;

3437 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("readsets/"));

3438 pathOffset += 9;

3439 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3440 pathOffset = path.length;

3441 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3442

3443 var query = (req.url).query;

3444 var queryOffset = 0;

3445 var queryMap = {};

3446 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3447 parseBool(n) {

3448 if (n == "true") return true;

3449 if (n == "false") return false;

3450 if (n == null) return null;

3451 throw new core.ArgumentError("Invalid boolean: $n");

3452 }

3453 if (query.length > 0) {

3454 for (var part in query.split("&")) {

3455 var keyvalue = part.split("=");

3456 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3457 }

3458 }

3459

3460

3461 var h = {

3462 "content-type" : "application/json; charset=utf-8",

3463 };

3464 var resp = convert.JSON.encode(buildReadset());

3465 return new async.Future.value(common_test.stringResponse(200, h, resp));

3466 }), true);

3467 res.update(arg_request, arg_readsetId).then(unittest.expectAsync(((api.Rea dset response) {

3468 checkReadset(response);

3469 })));

3470 });

3471

3472 });

3473

3474

3475 unittest.group("resource-ReadsetsCoveragebucketsResourceApi", () {

3476 unittest.test("method--list", () {

3477

3478 var mock = new common_test.HttpServerMock();

3479 api.ReadsetsCoveragebucketsResourceApi res = new api.GenomicsApi(mock).rea dsets.coveragebuckets;

3480 var arg_readsetId = "foo";

3481 var arg_maxResults = "foo";

3482 var arg_pageToken = "foo";

3483 var arg_range_sequenceEnd = "foo";

3484 var arg_range_sequenceName = "foo";

3485 var arg_range_sequenceStart = "foo";

3486 var arg_targetBucketWidth = "foo";

3487 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3488 var path = (req.url).path;

3489 var pathOffset = 0;

3490 var index;

3491 var subPart;

3492 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3493 pathOffset += 1;

3494 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3495 pathOffset += 16;

3496 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("readsets/"));

3497 pathOffset += 9;

3498 index = path.indexOf("/coveragebuckets", pathOffset);

3499 unittest.expect(index >= 0, unittest.isTrue);

3500 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3501 pathOffset = index;

3502 unittest.expect(subPart, unittest.equals("$arg_readsetId"));

3503 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/coveragebuckets"));

3504 pathOffset += 16;

3505

3506 var query = (req.url).query;

3507 var queryOffset = 0;

3508 var queryMap = {};

3509 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3510 parseBool(n) {

3511 if (n == "true") return true;

3512 if (n == "false") return false;

3513 if (n == null) return null;

3514 throw new core.ArgumentError("Invalid boolean: $n");

3515 }

3516 if (query.length > 0) {

3517 for (var part in query.split("&")) {

3518 var keyvalue = part.split("=");

3519 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3520 }

3521 }

3522 unittest.expect(queryMap["maxResults"].first, unittest.equals(arg_maxRes ults));

3523 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3524 unittest.expect(queryMap["range.sequenceEnd"].first, unittest.equals(arg _range_sequenceEnd));

3525 unittest.expect(queryMap["range.sequenceName"].first, unittest.equals(ar g_range_sequenceName));

3526 unittest.expect(queryMap["range.sequenceStart"].first, unittest.equals(a rg_range_sequenceStart));

3527 unittest.expect(queryMap["targetBucketWidth"].first, unittest.equals(arg _targetBucketWidth));

3528

3529

3530 var h = {

3531 "content-type" : "application/json; charset=utf-8",

3532 };

3533 var resp = convert.JSON.encode(buildListCoverageBucketsResponse());

3534 return new async.Future.value(common_test.stringResponse(200, h, resp));

3535 }), true);

3536 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) {

3537 checkListCoverageBucketsResponse(response);

3538 })));

3539 });

3540

3541 });

3542

3543

3544 unittest.group("resource-VariantsResourceApi", () {

3545 unittest.test("method--create", () {

3546

3547 var mock = new common_test.HttpServerMock();

3548 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3549 var arg_request = buildVariant();

3550 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3551 var obj = new api.Variant.fromJson(json);

3552 checkVariant(obj);

3553

3554 var path = (req.url).path;

3555 var pathOffset = 0;

3556 var index;

3557 var subPart;

3558 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3559 pathOffset += 1;

3560 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3561 pathOffset += 16;

3562 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("variants"));

3563 pathOffset += 8;

3564

3565 var query = (req.url).query;

3566 var queryOffset = 0;

3567 var queryMap = {};

3568 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3569 parseBool(n) {

3570 if (n == "true") return true;

3571 if (n == "false") return false;

3572 if (n == null) return null;

3573 throw new core.ArgumentError("Invalid boolean: $n");

3574 }

3575 if (query.length > 0) {

3576 for (var part in query.split("&")) {

3577 var keyvalue = part.split("=");

3578 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3579 }

3580 }

3581

3582

3583 var h = {

3584 "content-type" : "application/json; charset=utf-8",

3585 };

3586 var resp = convert.JSON.encode(buildVariant());

3587 return new async.Future.value(common_test.stringResponse(200, h, resp));

3588 }), true);

3589 res.create(arg_request).then(unittest.expectAsync(((api.Variant response) {

3590 checkVariant(response);

3591 })));

3592 });

3593

3594 unittest.test("method--delete", () {

3595

3596 var mock = new common_test.HttpServerMock();

3597 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3598 var arg_variantId = "foo";

3599 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3600 var path = (req.url).path;

3601 var pathOffset = 0;

3602 var index;

3603 var subPart;

3604 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3605 pathOffset += 1;

3606 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3607 pathOffset += 16;

3608 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("variants/"));

3609 pathOffset += 9;

3610 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3611 pathOffset = path.length;

3612 unittest.expect(subPart, unittest.equals("$arg_variantId"));

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

3631

3632 var h = {

3633 "content-type" : "application/json; charset=utf-8",

3634 };

3635 var resp = "";

3636 return new async.Future.value(common_test.stringResponse(200, h, resp));

3637 }), true);

3638 res.delete(arg_variantId).then(unittest.expectAsync((_) {}));

3639 });

3640

3641 unittest.test("method--export", () {

3642

3643 var mock = new common_test.HttpServerMock();

3644 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3645 var arg_request = buildExportVariantsRequest();

3646 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3647 var obj = new api.ExportVariantsRequest.fromJson(json);

3648 checkExportVariantsRequest(obj);

3649

3650 var path = (req.url).path;

3651 var pathOffset = 0;

3652 var index;

3653 var subPart;

3654 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3655 pathOffset += 1;

3656 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3657 pathOffset += 16;

3658 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("variants/export"));

3659 pathOffset += 15;

3660

3661 var query = (req.url).query;

3662 var queryOffset = 0;

3663 var queryMap = {};

3664 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3665 parseBool(n) {

3666 if (n == "true") return true;

3667 if (n == "false") return false;

3668 if (n == null) return null;

3669 throw new core.ArgumentError("Invalid boolean: $n");

3670 }

3671 if (query.length > 0) {

3672 for (var part in query.split("&")) {

3673 var keyvalue = part.split("=");

3674 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3675 }

3676 }

3677

3678

3679 var h = {

3680 "content-type" : "application/json; charset=utf-8",

3681 };

3682 var resp = convert.JSON.encode(buildExportVariantsResponse());

3683 return new async.Future.value(common_test.stringResponse(200, h, resp));

3684 }), true);

3685 res.export(arg_request).then(unittest.expectAsync(((api.ExportVariantsResp onse response) {

3686 checkExportVariantsResponse(response);

3687 })));

3688 });

3689

3690 unittest.test("method--get", () {

3691

3692 var mock = new common_test.HttpServerMock();

3693 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3694 var arg_variantId = "foo";

3695 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3696 var path = (req.url).path;

3697 var pathOffset = 0;

3698 var index;

3699 var subPart;

3700 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3701 pathOffset += 1;

3702 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3703 pathOffset += 16;

3704 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("variants/"));

3705 pathOffset += 9;

3706 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3707 pathOffset = path.length;

3708 unittest.expect(subPart, unittest.equals("$arg_variantId"));

3709

3710 var query = (req.url).query;

3711 var queryOffset = 0;

3712 var queryMap = {};

3713 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3714 parseBool(n) {

3715 if (n == "true") return true;

3716 if (n == "false") return false;

3717 if (n == null) return null;

3718 throw new core.ArgumentError("Invalid boolean: $n");

3719 }

3720 if (query.length > 0) {

3721 for (var part in query.split("&")) {

3722 var keyvalue = part.split("=");

3723 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3724 }

3725 }

3726

3727

3728 var h = {

3729 "content-type" : "application/json; charset=utf-8",

3730 };

3731 var resp = convert.JSON.encode(buildVariant());

3732 return new async.Future.value(common_test.stringResponse(200, h, resp));

3733 }), true);

3734 res.get(arg_variantId).then(unittest.expectAsync(((api.Variant response) {

3735 checkVariant(response);

3736 })));

3737 });

3738

3739 unittest.test("method--import", () {

3740

3741 var mock = new common_test.HttpServerMock();

3742 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3743 var arg_request = buildImportVariantsRequest();

3744 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3745 var obj = new api.ImportVariantsRequest.fromJson(json);

3746 checkImportVariantsRequest(obj);

3747

3748 var path = (req.url).path;

3749 var pathOffset = 0;

3750 var index;

3751 var subPart;

3752 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3753 pathOffset += 1;

3754 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3755 pathOffset += 16;

3756 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("variants/import"));

3757 pathOffset += 15;

3758

3759 var query = (req.url).query;

3760 var queryOffset = 0;

3761 var queryMap = {};

3762 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3763 parseBool(n) {

3764 if (n == "true") return true;

3765 if (n == "false") return false;

3766 if (n == null) return null;

3767 throw new core.ArgumentError("Invalid boolean: $n");

3768 }

3769 if (query.length > 0) {

3770 for (var part in query.split("&")) {

3771 var keyvalue = part.split("=");

3772 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3773 }

3774 }

3775

3776

3777 var h = {

3778 "content-type" : "application/json; charset=utf-8",

3779 };

3780 var resp = convert.JSON.encode(buildImportVariantsResponse());

3781 return new async.Future.value(common_test.stringResponse(200, h, resp));

3782 }), true);

3783 res.import(arg_request).then(unittest.expectAsync(((api.ImportVariantsResp onse response) {

3784 checkImportVariantsResponse(response);

3785 })));

3786 });

3787

3788 unittest.test("method--search", () {

3789

3790 var mock = new common_test.HttpServerMock();

3791 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3792 var arg_request = buildSearchVariantsRequest();

3793 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3794 var obj = new api.SearchVariantsRequest.fromJson(json);

3795 checkSearchVariantsRequest(obj);

3796

3797 var path = (req.url).path;

3798 var pathOffset = 0;

3799 var index;

3800 var subPart;

3801 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3802 pathOffset += 1;

3803 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3804 pathOffset += 16;

3805 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("variants/search"));

3806 pathOffset += 15;

3807

3808 var query = (req.url).query;

3809 var queryOffset = 0;

3810 var queryMap = {};

3811 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3812 parseBool(n) {

3813 if (n == "true") return true;

3814 if (n == "false") return false;

3815 if (n == null) return null;

3816 throw new core.ArgumentError("Invalid boolean: $n");

3817 }

3818 if (query.length > 0) {

3819 for (var part in query.split("&")) {

3820 var keyvalue = part.split("=");

3821 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3822 }

3823 }

3824

3825

3826 var h = {

3827 "content-type" : "application/json; charset=utf-8",

3828 };

3829 var resp = convert.JSON.encode(buildSearchVariantsResponse());

3830 return new async.Future.value(common_test.stringResponse(200, h, resp));

3831 }), true);

3832 res.search(arg_request).then(unittest.expectAsync(((api.SearchVariantsResp onse response) {

3833 checkSearchVariantsResponse(response);

3834 })));

3835 });

3836

3837 unittest.test("method--update", () {

3838

3839 var mock = new common_test.HttpServerMock();

3840 api.VariantsResourceApi res = new api.GenomicsApi(mock).variants;

3841 var arg_request = buildVariant();

3842 var arg_variantId = "foo";

3843 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3844 var obj = new api.Variant.fromJson(json);

3845 checkVariant(obj);

3846

3847 var path = (req.url).path;

3848 var pathOffset = 0;

3849 var index;

3850 var subPart;

3851 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3852 pathOffset += 1;

3853 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3854 pathOffset += 16;

3855 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("variants/"));

3856 pathOffset += 9;

3857 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3858 pathOffset = path.length;

3859 unittest.expect(subPart, unittest.equals("$arg_variantId"));

3860

3861 var query = (req.url).query;

3862 var queryOffset = 0;

3863 var queryMap = {};

3864 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3865 parseBool(n) {

3866 if (n == "true") return true;

3867 if (n == "false") return false;

3868 if (n == null) return null;

3869 throw new core.ArgumentError("Invalid boolean: $n");

3870 }

3871 if (query.length > 0) {

3872 for (var part in query.split("&")) {

3873 var keyvalue = part.split("=");

3874 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3875 }

3876 }

3877

3878

3879 var h = {

3880 "content-type" : "application/json; charset=utf-8",

3881 };

3882 var resp = convert.JSON.encode(buildVariant());

3883 return new async.Future.value(common_test.stringResponse(200, h, resp));

3884 }), true);

3885 res.update(arg_request, arg_variantId).then(unittest.expectAsync(((api.Var iant response) {

3886 checkVariant(response);

3887 })));

3888 });

3889

3890 });

3891

3892

3893 unittest.group("resource-VariantsetsResourceApi", () {

3894 unittest.test("method--delete", () {

3895

3896 var mock = new common_test.HttpServerMock();

3897 api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;

3898 var arg_variantSetId = "foo";

3899 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3900 var path = (req.url).path;

3901 var pathOffset = 0;

3902 var index;

3903 var subPart;

3904 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3905 pathOffset += 1;

3906 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3907 pathOffset += 16;

3908 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("variantsets/"));

3909 pathOffset += 12;

3910 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3911 pathOffset = path.length;

3912 unittest.expect(subPart, unittest.equals("$arg_variantSetId"));

3913

3914 var query = (req.url).query;

3915 var queryOffset = 0;

3916 var queryMap = {};

3917 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3918 parseBool(n) {

3919 if (n == "true") return true;

3920 if (n == "false") return false;

3921 if (n == null) return null;

3922 throw new core.ArgumentError("Invalid boolean: $n");

3923 }

3924 if (query.length > 0) {

3925 for (var part in query.split("&")) {

3926 var keyvalue = part.split("=");

3927 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3928 }

3929 }

3930

3931

3932 var h = {

3933 "content-type" : "application/json; charset=utf-8",

3934 };

3935 var resp = "";

3936 return new async.Future.value(common_test.stringResponse(200, h, resp));

3937 }), true);

3938 res.delete(arg_variantSetId).then(unittest.expectAsync((_) {}));

3939 });

3940

3941 unittest.test("method--get", () {

3942

3943 var mock = new common_test.HttpServerMock();

3944 api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;

3945 var arg_variantSetId = "foo";

3946 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3947 var path = (req.url).path;

3948 var pathOffset = 0;

3949 var index;

3950 var subPart;

3951 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

3952 pathOffset += 1;

3953 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

3954 pathOffset += 16;

3955 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("variantsets/"));

3956 pathOffset += 12;

3957 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3958 pathOffset = path.length;

3959 unittest.expect(subPart, unittest.equals("$arg_variantSetId"));

3960

3961 var query = (req.url).query;

3962 var queryOffset = 0;

3963 var queryMap = {};

3964 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3965 parseBool(n) {

3966 if (n == "true") return true;

3967 if (n == "false") return false;

3968 if (n == null) return null;

3969 throw new core.ArgumentError("Invalid boolean: $n");

3970 }

3971 if (query.length > 0) {

3972 for (var part in query.split("&")) {

3973 var keyvalue = part.split("=");

3974 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3975 }

3976 }

3977

3978

3979 var h = {

3980 "content-type" : "application/json; charset=utf-8",

3981 };

3982 var resp = convert.JSON.encode(buildVariantSet());

3983 return new async.Future.value(common_test.stringResponse(200, h, resp));

3984 }), true);

3985 res.get(arg_variantSetId).then(unittest.expectAsync(((api.VariantSet respo nse) {

3986 checkVariantSet(response);

3987 })));

3988 });

3989

3990 unittest.test("method--mergeVariants", () {

3991

3992 var mock = new common_test.HttpServerMock();

3993 api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;

3994 var arg_request = buildMergeVariantsRequest();

3995 var arg_variantSetId = "foo";

3996 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3997 var obj = new api.MergeVariantsRequest.fromJson(json);

3998 checkMergeVariantsRequest(obj);

3999

4000 var path = (req.url).path;

4001 var pathOffset = 0;

4002 var index;

4003 var subPart;

4004 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4005 pathOffset += 1;

4006 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

4007 pathOffset += 16;

4008 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("variantsets/"));

4009 pathOffset += 12;

4010 index = path.indexOf("/mergeVariants", pathOffset);

4011 unittest.expect(index >= 0, unittest.isTrue);

4012 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

4013 pathOffset = index;

4014 unittest.expect(subPart, unittest.equals("$arg_variantSetId"));

4015 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/mergeVariants"));

4016 pathOffset += 14;

4017

4018 var query = (req.url).query;

4019 var queryOffset = 0;

4020 var queryMap = {};

4021 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4022 parseBool(n) {

4023 if (n == "true") return true;

4024 if (n == "false") return false;

4025 if (n == null) return null;

4026 throw new core.ArgumentError("Invalid boolean: $n");

4027 }

4028 if (query.length > 0) {

4029 for (var part in query.split("&")) {

4030 var keyvalue = part.split("=");

4031 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4032 }

4033 }

4034

4035

4036 var h = {

4037 "content-type" : "application/json; charset=utf-8",

4038 };

4039 var resp = "";

4040 return new async.Future.value(common_test.stringResponse(200, h, resp));

4041 }), true);

4042 res.mergeVariants(arg_request, arg_variantSetId).then(unittest.expectAsync ((_) {}));

4043 });

4044

4045 unittest.test("method--patch", () {

4046

4047 var mock = new common_test.HttpServerMock();

4048 api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;

4049 var arg_request = buildVariantSet();

4050 var arg_variantSetId = "foo";

4051 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4052 var obj = new api.VariantSet.fromJson(json);

4053 checkVariantSet(obj);

4054

4055 var path = (req.url).path;

4056 var pathOffset = 0;

4057 var index;

4058 var subPart;

4059 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4060 pathOffset += 1;

4061 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

4062 pathOffset += 16;

4063 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("variantsets/"));

4064 pathOffset += 12;

4065 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4066 pathOffset = path.length;

4067 unittest.expect(subPart, unittest.equals("$arg_variantSetId"));

4068

4069 var query = (req.url).query;

4070 var queryOffset = 0;

4071 var queryMap = {};

4072 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4073 parseBool(n) {

4074 if (n == "true") return true;

4075 if (n == "false") return false;

4076 if (n == null) return null;

4077 throw new core.ArgumentError("Invalid boolean: $n");

4078 }

4079 if (query.length > 0) {

4080 for (var part in query.split("&")) {

4081 var keyvalue = part.split("=");

4082 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4083 }

4084 }

4085

4086

4087 var h = {

4088 "content-type" : "application/json; charset=utf-8",

4089 };

4090 var resp = convert.JSON.encode(buildVariantSet());

4091 return new async.Future.value(common_test.stringResponse(200, h, resp));

4092 }), true);

4093 res.patch(arg_request, arg_variantSetId).then(unittest.expectAsync(((api.V ariantSet response) {

4094 checkVariantSet(response);

4095 })));

4096 });

4097

4098 unittest.test("method--search", () {

4099

4100 var mock = new common_test.HttpServerMock();

4101 api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;

4102 var arg_request = buildSearchVariantSetsRequest();

4103 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4104 var obj = new api.SearchVariantSetsRequest.fromJson(json);

4105 checkSearchVariantSetsRequest(obj);

4106

4107 var path = (req.url).path;

4108 var pathOffset = 0;

4109 var index;

4110 var subPart;

4111 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4112 pathOffset += 1;

4113 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

4114 pathOffset += 16;

4115 unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.eq uals("variantsets/search"));

4116 pathOffset += 18;

4117

4118 var query = (req.url).query;

4119 var queryOffset = 0;

4120 var queryMap = {};

4121 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4122 parseBool(n) {

4123 if (n == "true") return true;

4124 if (n == "false") return false;

4125 if (n == null) return null;

4126 throw new core.ArgumentError("Invalid boolean: $n");

4127 }

4128 if (query.length > 0) {

4129 for (var part in query.split("&")) {

4130 var keyvalue = part.split("=");

4131 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4132 }

4133 }

4134

4135

4136 var h = {

4137 "content-type" : "application/json; charset=utf-8",

4138 };

4139 var resp = convert.JSON.encode(buildSearchVariantSetsResponse());

4140 return new async.Future.value(common_test.stringResponse(200, h, resp));

4141 }), true);

4142 res.search(arg_request).then(unittest.expectAsync(((api.SearchVariantSetsR esponse response) {

4143 checkSearchVariantSetsResponse(response);

4144 })));

4145 });

4146

4147 unittest.test("method--update", () {

4148

4149 var mock = new common_test.HttpServerMock();

4150 api.VariantsetsResourceApi res = new api.GenomicsApi(mock).variantsets;

4151 var arg_request = buildVariantSet();

4152 var arg_variantSetId = "foo";

4153 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

4154 var obj = new api.VariantSet.fromJson(json);

4155 checkVariantSet(obj);

4156

4157 var path = (req.url).path;

4158 var pathOffset = 0;

4159 var index;

4160 var subPart;

4161 unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equ als("/"));

4162 pathOffset += 1;

4163 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("genomics/v1beta/"));

4164 pathOffset += 16;

4165 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("variantsets/"));

4166 pathOffset += 12;

4167 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

4168 pathOffset = path.length;

4169 unittest.expect(subPart, unittest.equals("$arg_variantSetId"));

4170

4171 var query = (req.url).query;

4172 var queryOffset = 0;

4173 var queryMap = {};

4174 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

4175 parseBool(n) {

4176 if (n == "true") return true;

4177 if (n == "false") return false;

4178 if (n == null) return null;

4179 throw new core.ArgumentError("Invalid boolean: $n");

4180 }

4181 if (query.length > 0) {

4182 for (var part in query.split("&")) {

4183 var keyvalue = part.split("=");

4184 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

4185 }

4186 }

4187

4188

4189 var h = {

4190 "content-type" : "application/json; charset=utf-8",

4191 };

4192 var resp = convert.JSON.encode(buildVariantSet());

4193 return new async.Future.value(common_test.stringResponse(200, h, resp));

4194 }), true);

4195 res.update(arg_request, arg_variantSetId).then(unittest.expectAsync(((api. VariantSet response) {

4196 checkVariantSet(response);

4197 })));

4198 });

4199

4200 });

4201

4202

4203 }

4204

OLD	NEW