method2testcases stringlengths 118 6.63k |
|---|
### Question:
PatientSummaryImpl implements PatientSummary { @Override public List<PhenotypeComponent> phenoAt(Date timepoint) { return phenoSetTimeLines.stream() .map(timeLine -> timeLine.current(timepoint)) .collect(Collectors.toList()); } PatientSummaryImpl(Patient patient, UnionFind<TermId> hpoTermUnionFind); @Override Patient patient(); @Override void addTest(LabTest test); @Override void addTest(List<LabTest> tests); @Override List<LabTest> tests(); @Override List<PhenoSetTimeLine> timeLines(); @Override List<PhenotypeComponent> phenoAt(Date timepoint); @Override List<PhenotypeComponent> phenoPersistedDuring(Date start, Date end); @Override List<PhenotypeComponent> phenoOccurredDuring(Date start, Date end); @Override List<PhenotypeComponent> phenoSinceBorn(); }### Answer:
@Test public void phenoAt() throws Exception { LabTest test2 = new LabTestImpl.Builder() .effectiveStart(dateFormat.parse("2017-10-20 10:30:00")) .loincId(new LoincId("15074-7")) .outcome(new HpoTerm4TestOutcome(hypoglycemia.getId(), false)) .patient(patient) .resourceId("unknown resource id") .build(); patientSummary.addTest(test2); assertEquals(3, patientSummary.tests().size()); assertEquals(2, patientSummary.timeLines().size()); } |
### Question:
PatientSummaryImpl implements PatientSummary { @Override public List<PhenotypeComponent> phenoPersistedDuring(Date start, Date end) { return phenoSetTimeLines.stream() .map(timeline -> timeline.persistDuring(start, end)) .collect(Collectors.toList()); } PatientSummaryImpl(Patient patient, UnionFind<TermId> hpoTermUnionFind); @Override Patient patient(); @Override void addTest(LabTest test); @Override void addTest(List<LabTest> tests); @Override List<LabTest> tests(); @Override List<PhenoSetTimeLine> timeLines(); @Override List<PhenotypeComponent> phenoAt(Date timepoint); @Override List<PhenotypeComponent> phenoPersistedDuring(Date start, Date end); @Override List<PhenotypeComponent> phenoOccurredDuring(Date start, Date end); @Override List<PhenotypeComponent> phenoSinceBorn(); }### Answer:
@Test public void phenoPersistedDuring() throws Exception { LabTest test2 = new LabTestImpl.Builder() .effectiveStart(dateFormat.parse("2017-10-20 10:30:00")) .loincId(new LoincId("15074-7")) .outcome(new HpoTerm4TestOutcome(hypoglycemia.getId(), false)) .patient(patient) .resourceId("unknown resource id") .build(); patientSummary.addTest(test2); assertEquals(2, patientSummary.phenoPersistedDuring(dateFormat.parse("2016-10-22 10:00:00"), dateFormat.parse("2016-12-31 00:00:00")).size()); } |
### Question:
GitHubPopup { public String retrieveSuggestedTerm() { String newTerm = "UNKNOWN"; try { String[] lineElements = githubIssueText.split("\n")[1].split(":"); if (lineElements.length == 2) { newTerm = lineElements[1].trim(); } } catch (Exception e) { } return newTerm; } GitHubPopup(LoincEntry loincEntry); GitHubPopup(LoincEntry loincEntry, Term term, boolean childterm); void setLabels(List<String> labels); void displayWindow(Stage ownerWindow); void setupGithubUsernamePassword(String ghuname, String ghpword); boolean wasCancelled(); void setGithubIssueText(String githubIssueText); String retrieveGitHubIssue(); String retrieveSuggestedTerm(); String getGitHubUserName(); String getGitHubPassWord(); @Deprecated String getGitHubLabel(); List<String> getGitHubLabels(); void setBiocuratorId(String id); }### Answer:
@Test public void retrieveSuggestedTerm() throws Exception { String issue = "Suggest creating a new child term of %s [%s] for Loinc %s [%s]\n" + "New term label:\n" + "New term comment (if any):\n" + "Your biocurator ID for loinc2hpo (if desired): %s"; GitHubPopup popup = new GitHubPopup(null); popup.setGithubIssueText(issue); assertEquals("UNKNOWN", popup.retrieveSuggestedTerm()); } |
### Question:
PatientSummaryImpl implements PatientSummary { @Override public List<PhenotypeComponent> phenoOccurredDuring(Date start, Date end) { List<PhenotypeComponent> patientPhenotypes = new ArrayList<>(); phenoSetTimeLines.stream() .map(timeline -> timeline.occurredDuring(start, end)) .forEach(patientPhenotypes::addAll); return patientPhenotypes; } PatientSummaryImpl(Patient patient, UnionFind<TermId> hpoTermUnionFind); @Override Patient patient(); @Override void addTest(LabTest test); @Override void addTest(List<LabTest> tests); @Override List<LabTest> tests(); @Override List<PhenoSetTimeLine> timeLines(); @Override List<PhenotypeComponent> phenoAt(Date timepoint); @Override List<PhenotypeComponent> phenoPersistedDuring(Date start, Date end); @Override List<PhenotypeComponent> phenoOccurredDuring(Date start, Date end); @Override List<PhenotypeComponent> phenoSinceBorn(); }### Answer:
@Test public void phenoOccurredDuring() throws Exception { assertEquals(1, patientSummary.phenoOccurredDuring(dateFormat.parse("2015-12-31 00:00:00"), dateFormat.parse("2016-10-20 11:59:59")).size()); assertEquals(2, patientSummary.phenoOccurredDuring(dateFormat.parse("2015-12-31 00:00:00"), dateFormat.parse("2016-10-22 11:59:59")).size()); LabTest test2 = new LabTestImpl.Builder() .effectiveStart(dateFormat.parse("2017-10-20 10:30:00")) .loincId(new LoincId("15074-7")) .outcome(new HpoTerm4TestOutcome(hypoglycemia.getId(), false)) .patient(patient) .resourceId("unknown resource id") .build(); patientSummary.addTest(test2); assertEquals(3, patientSummary.phenoOccurredDuring(dateFormat.parse("2015-12-31 00:00:00"), dateFormat.parse("2018-10-22 11:59:59")).size()); } |
### Question:
PatientSummaryImpl implements PatientSummary { @Override public List<PhenotypeComponent> phenoSinceBorn() { List<PhenotypeComponent> patientPhenotypes = new ArrayList<>(); phenoSetTimeLines.forEach(timeLine -> patientPhenotypes.addAll(timeLine.getTimeLine())); return patientPhenotypes; } PatientSummaryImpl(Patient patient, UnionFind<TermId> hpoTermUnionFind); @Override Patient patient(); @Override void addTest(LabTest test); @Override void addTest(List<LabTest> tests); @Override List<LabTest> tests(); @Override List<PhenoSetTimeLine> timeLines(); @Override List<PhenotypeComponent> phenoAt(Date timepoint); @Override List<PhenotypeComponent> phenoPersistedDuring(Date start, Date end); @Override List<PhenotypeComponent> phenoOccurredDuring(Date start, Date end); @Override List<PhenotypeComponent> phenoSinceBorn(); }### Answer:
@Test public void phenoSinceBorn() throws Exception { LabTest test2 = new LabTestImpl.Builder() .effectiveStart(dateFormat.parse("2017-10-20 10:30:00")) .loincId(new LoincId("15074-7")) .outcome(new HpoTerm4TestOutcome(hypoglycemia.getId(), false)) .patient(patient) .resourceId("unknown resource id") .build(); patientSummary.addTest(test2); assertEquals(3, patientSummary.phenoSinceBorn().size()); } |
### Question:
PhenotypeComponentImpl implements PhenotypeComponent { @Override public Date effectiveStart() { return this.start; } private PhenotypeComponentImpl(); private PhenotypeComponentImpl(@NotNull Date start, @Nullable Date end, @NotNull TermId hpoTerm, boolean isNegated); @Override Date effectiveStart(); @Override Date effectiveEnd(); @Override boolean isEffective(Date timepoint); @Override boolean isPersistingDuring(Date start, Date end); @Override boolean occurredDuring(Date start, Date end); @Override TermId abnormality(); @Override boolean isNegated(); @Override void changeEffectiveStart(Date start); @Override void changeEffectiveEnd(Date end); }### Answer:
@Test public void effectiveStart() throws Exception { assertEquals("2016-09-30 09:30:00", dateFormat.format(testComponent.effectiveStart())); } |
### Question:
PhenotypeComponentImpl implements PhenotypeComponent { @Override public Date effectiveEnd() { return this.end; } private PhenotypeComponentImpl(); private PhenotypeComponentImpl(@NotNull Date start, @Nullable Date end, @NotNull TermId hpoTerm, boolean isNegated); @Override Date effectiveStart(); @Override Date effectiveEnd(); @Override boolean isEffective(Date timepoint); @Override boolean isPersistingDuring(Date start, Date end); @Override boolean occurredDuring(Date start, Date end); @Override TermId abnormality(); @Override boolean isNegated(); @Override void changeEffectiveStart(Date start); @Override void changeEffectiveEnd(Date end); }### Answer:
@Test public void effectiveEnd() throws Exception { assertTrue(testComponent.effectiveStart().before(testComponent.effectiveEnd())); } |
### Question:
PhenotypeComponentImpl implements PhenotypeComponent { @Override public boolean isEffective(Date timepoint) { if (timepoint.before(start) || timepoint.after(end)) { return false; } return true; } private PhenotypeComponentImpl(); private PhenotypeComponentImpl(@NotNull Date start, @Nullable Date end, @NotNull TermId hpoTerm, boolean isNegated); @Override Date effectiveStart(); @Override Date effectiveEnd(); @Override boolean isEffective(Date timepoint); @Override boolean isPersistingDuring(Date start, Date end); @Override boolean occurredDuring(Date start, Date end); @Override TermId abnormality(); @Override boolean isNegated(); @Override void changeEffectiveStart(Date start); @Override void changeEffectiveEnd(Date end); }### Answer:
@Test public void isEffective() throws Exception { assertFalse(testComponent.isEffective(dateFormat.parse("2016-09-29 10:00:00"))); assertTrue(testComponent.isEffective(dateFormat.parse("2016-09-30 09:30:00"))); assertTrue(testComponent.isEffective(dateFormat.parse("2016-09-30 09:30:01"))); assertTrue(testComponent.isEffective(dateFormat.parse("2016-09-30 10:30:00"))); assertTrue(testComponent.isEffective(dateFormat.parse("2020-09-30 09:30:01"))); } |
### Question:
PhenotypeComponentImpl implements PhenotypeComponent { @Override public TermId abnormality() { return this.hpoTerm; } private PhenotypeComponentImpl(); private PhenotypeComponentImpl(@NotNull Date start, @Nullable Date end, @NotNull TermId hpoTerm, boolean isNegated); @Override Date effectiveStart(); @Override Date effectiveEnd(); @Override boolean isEffective(Date timepoint); @Override boolean isPersistingDuring(Date start, Date end); @Override boolean occurredDuring(Date start, Date end); @Override TermId abnormality(); @Override boolean isNegated(); @Override void changeEffectiveStart(Date start); @Override void changeEffectiveEnd(Date end); }### Answer:
@Test public void abnormality() throws Exception { assertEquals(hyperglycemia.getId(), testComponent.abnormality()); } |
### Question:
PhenotypeComponentImpl implements PhenotypeComponent { @Override public boolean isNegated() { return this.isNegated; } private PhenotypeComponentImpl(); private PhenotypeComponentImpl(@NotNull Date start, @Nullable Date end, @NotNull TermId hpoTerm, boolean isNegated); @Override Date effectiveStart(); @Override Date effectiveEnd(); @Override boolean isEffective(Date timepoint); @Override boolean isPersistingDuring(Date start, Date end); @Override boolean occurredDuring(Date start, Date end); @Override TermId abnormality(); @Override boolean isNegated(); @Override void changeEffectiveStart(Date start); @Override void changeEffectiveEnd(Date end); }### Answer:
@Test public void isNegated() throws Exception { assertFalse(testComponent.isNegated()); } |
### Question:
PhenotypeComponentImpl implements PhenotypeComponent { @Override public void changeEffectiveStart(Date start) { this.start = start; } private PhenotypeComponentImpl(); private PhenotypeComponentImpl(@NotNull Date start, @Nullable Date end, @NotNull TermId hpoTerm, boolean isNegated); @Override Date effectiveStart(); @Override Date effectiveEnd(); @Override boolean isEffective(Date timepoint); @Override boolean isPersistingDuring(Date start, Date end); @Override boolean occurredDuring(Date start, Date end); @Override TermId abnormality(); @Override boolean isNegated(); @Override void changeEffectiveStart(Date start); @Override void changeEffectiveEnd(Date end); }### Answer:
@Test public void changeEffectiveStart() throws Exception { assertTrue(testComponent.isEffective(dateFormat.parse("2016-09-30 09:30:01"))); testComponent.changeEffectiveStart(dateFormat.parse("2016-09-30 10:30:01")); assertFalse(testComponent.isEffective(dateFormat.parse("2016-09-30 09:30:01"))); } |
### Question:
PhenotypeComponentImpl implements PhenotypeComponent { @Override public void changeEffectiveEnd(Date end) { this.end = end; } private PhenotypeComponentImpl(); private PhenotypeComponentImpl(@NotNull Date start, @Nullable Date end, @NotNull TermId hpoTerm, boolean isNegated); @Override Date effectiveStart(); @Override Date effectiveEnd(); @Override boolean isEffective(Date timepoint); @Override boolean isPersistingDuring(Date start, Date end); @Override boolean occurredDuring(Date start, Date end); @Override TermId abnormality(); @Override boolean isNegated(); @Override void changeEffectiveStart(Date start); @Override void changeEffectiveEnd(Date end); }### Answer:
@Test public void changeEffectiveEnd() throws Exception { assertTrue(testComponent.isEffective(dateFormat.parse("2020-09-30 09:30:01"))); testComponent.changeEffectiveEnd(dateFormat.parse("2018-09-30 09:30:01")); assertFalse(testComponent.isEffective(dateFormat.parse("2020-09-30 09:30:01"))); } |
### Question:
PhenotypeComponentImpl implements PhenotypeComponent { @Override public boolean occurredDuring(Date start, Date end) { return !(start.after(this.end) || end.before(this.start)); } private PhenotypeComponentImpl(); private PhenotypeComponentImpl(@NotNull Date start, @Nullable Date end, @NotNull TermId hpoTerm, boolean isNegated); @Override Date effectiveStart(); @Override Date effectiveEnd(); @Override boolean isEffective(Date timepoint); @Override boolean isPersistingDuring(Date start, Date end); @Override boolean occurredDuring(Date start, Date end); @Override TermId abnormality(); @Override boolean isNegated(); @Override void changeEffectiveStart(Date start); @Override void changeEffectiveEnd(Date end); }### Answer:
@Test public void occurredDuring() throws Exception { Date date00 = dateFormat.parse("2014-09-30 10:33:33"); Date date0 = dateFormat.parse("2016-05-30 10:33:33"); Date date1 = dateFormat.parse("2018-09-30 10:33:33"); Date date2 = dateFormat.parse("2018-10-30 10:33:33"); Date date3 = dateFormat.parse("2018-11-30 10:33:33"); Date date4 = dateFormat.parse("2018-12-30 10:33:33"); testComponent.changeEffectiveEnd(date2); assertFalse(testComponent.occurredDuring(date00, date0)); assertTrue(testComponent.occurredDuring(date0, testComponent.effectiveStart())); assertTrue(testComponent.occurredDuring(date0, date1)); assertTrue(testComponent.occurredDuring(date1, date3)); assertTrue(testComponent.occurredDuring(date2, date3)); assertFalse(testComponent.occurredDuring(date3, date4)); } |
### Question:
ColorUtils { public static String colorValue(int red, int green, int blue) { return String.format(COLORVALUEFORMAT, red, green, blue); } static String colorValue(int red, int green, int blue); static String colorValue(Color color); }### Answer:
@Test public void colorValue() throws Exception { }
@Test public void colorValue1() throws Exception { Color color = Color.AQUA; System.out.println(ColorUtils.colorValue(color)); } |
### Question:
GitHubPoster { public void setLabel(String l) { this.githubLabel = l; reformatPayloadWithLabel(githubLabel); } GitHubPoster(String uname, String passw, String title, String messagebody); String getHttpResponse(); void setLabel(String l); void setLabel(List<String> labels); String debugLabelsArray4Json(); String debugReformatpayloadWithLabel(); void postIssue(); }### Answer:
@Test public void testPayload() { GitHubPoster poster = new GitHubPoster(null, null, null, null); List<String> labels = new ArrayList<>(); labels.add("loinc"); labels.add("immunology"); poster.setLabel(labels); } |
### Question:
RandomGeneratorImpl implements RandomGenerator { @Override public char randLowerCaseChar() { return (char) (rand.nextInt(26) + 'a'); } @Override char randLowerCaseChar(); @Override char randUpperCaseChar(); @Override char randChar(); @Override List<Character> randLowerCaseChars(int num); @Override List<Character> randUpperCaseChars(int num); @Override List<Character> randChars(int num); @Override int randInt(int lowBound, int upBound); @Override List<Integer> randIntegers(int lowBount, int upBount, int length); @Override String randString(int charCount, int intCount, boolean mustSeartWithAlph); @Override List<String> randStrings(int size, int alphNum, int digitNum, boolean mustStartWithAlph); @Override double randDouble(double lowBound, double upBound); @Override List<Double> randDoubles(int size, double lowBound, double upBound); @Override boolean randBoolean(); }### Answer:
@Test public void randLowerCaseChar() throws Exception { int iter = 1000; for (int i = 0; i < iter; i++) { char c = randomGenerator.randLowerCaseChar(); assertTrue(c >= 'a' && c <='z'); } } |
### Question:
RandomGeneratorImpl implements RandomGenerator { @Override public char randUpperCaseChar() { return (char) (rand.nextInt(26) + 'A'); } @Override char randLowerCaseChar(); @Override char randUpperCaseChar(); @Override char randChar(); @Override List<Character> randLowerCaseChars(int num); @Override List<Character> randUpperCaseChars(int num); @Override List<Character> randChars(int num); @Override int randInt(int lowBound, int upBound); @Override List<Integer> randIntegers(int lowBount, int upBount, int length); @Override String randString(int charCount, int intCount, boolean mustSeartWithAlph); @Override List<String> randStrings(int size, int alphNum, int digitNum, boolean mustStartWithAlph); @Override double randDouble(double lowBound, double upBound); @Override List<Double> randDoubles(int size, double lowBound, double upBound); @Override boolean randBoolean(); }### Answer:
@Test public void randUpperCaseChar() throws Exception { int iter = 1000; for (int i = 0; i < iter; i++) { char c = randomGenerator.randUpperCaseChar(); assertTrue(c >= 'A' && c <='Z'); } } |
### Question:
ModifiableGenotypeDataInMemory extends AbstractRandomAccessGenotypeData implements ModifiableGenotypeData { @Override public List<String> getSeqNames() { return sourceGenotypeData.getSeqNames(); } ModifiableGenotypeDataInMemory(RandomAccessGenotypeData sourceGenotypeData); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Sequence getSequenceByName(String name); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override List<Annotation> getVariantAnnotations(); @Override Annotation getVariantAnnotation(String annotationId); @Override List<Sample> getSamples(); @Override Iterator<GeneticVariant> iterator(); @Override synchronized GeneticVariantId getUpdatedId(ModifiableGeneticVariant geneticVariant); @Override synchronized Allele getUpdatedRef(ModifiableGeneticVariant geneticVariant); @Override synchronized SampleVariantsProvider getUpdatedSampleVariantProvider(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateVariantId(ModifiableGeneticVariant geneticVariant,
GeneticVariantId newGeneticVariantId); @Override synchronized void updateVariantPrimaryId(ModifiableGeneticVariant geneticVariant, String newPrimaryId); @Override synchronized void swapGeneticVariant(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateRefAllele(ModifiableGeneticVariant geneticVariant, Allele newRefAllele); @Override synchronized Alleles getUpdatedAlleles(ModifiableGeneticVariant geneticVariant); @Override Iterable<ModifiableGeneticVariant> getModifiableSequenceGeneticVariants(String seqName); @Override Iterable<ModifiableGeneticVariant> getModifiableVariantsByPos(String seqName, int startPos); @Override ModifiableGeneticVariant getModifiableSnpVariantByPos(String seqName, int startPos); @Override Iterable<ModifiableGeneticVariant> getModifiableGeneticVariants(); @Override void excludeVariant(ModifiableGeneticVariant geneticVariant); @Override int getExcludedVariantCount(); @Override List<SampleAnnotation> getSampleAnnotations(); @Override Annotation getSampleAnnotation(String annotationId); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override void close(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override boolean isSwapped(GeneticVariant geneticVariant); }### Answer:
@Test public void getSeqNames() { assertEquals(modifiableGenotypeData.getSeqNames(), originalGenotypeData.getSeqNames()); } |
### Question:
ModifiableGenotypeDataInMemory extends AbstractRandomAccessGenotypeData implements ModifiableGenotypeData { @Override public Sequence getSequenceByName(String name) { return sourceGenotypeData.getSequenceByName(name); } ModifiableGenotypeDataInMemory(RandomAccessGenotypeData sourceGenotypeData); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Sequence getSequenceByName(String name); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override List<Annotation> getVariantAnnotations(); @Override Annotation getVariantAnnotation(String annotationId); @Override List<Sample> getSamples(); @Override Iterator<GeneticVariant> iterator(); @Override synchronized GeneticVariantId getUpdatedId(ModifiableGeneticVariant geneticVariant); @Override synchronized Allele getUpdatedRef(ModifiableGeneticVariant geneticVariant); @Override synchronized SampleVariantsProvider getUpdatedSampleVariantProvider(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateVariantId(ModifiableGeneticVariant geneticVariant,
GeneticVariantId newGeneticVariantId); @Override synchronized void updateVariantPrimaryId(ModifiableGeneticVariant geneticVariant, String newPrimaryId); @Override synchronized void swapGeneticVariant(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateRefAllele(ModifiableGeneticVariant geneticVariant, Allele newRefAllele); @Override synchronized Alleles getUpdatedAlleles(ModifiableGeneticVariant geneticVariant); @Override Iterable<ModifiableGeneticVariant> getModifiableSequenceGeneticVariants(String seqName); @Override Iterable<ModifiableGeneticVariant> getModifiableVariantsByPos(String seqName, int startPos); @Override ModifiableGeneticVariant getModifiableSnpVariantByPos(String seqName, int startPos); @Override Iterable<ModifiableGeneticVariant> getModifiableGeneticVariants(); @Override void excludeVariant(ModifiableGeneticVariant geneticVariant); @Override int getExcludedVariantCount(); @Override List<SampleAnnotation> getSampleAnnotations(); @Override Annotation getSampleAnnotation(String annotationId); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override void close(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override boolean isSwapped(GeneticVariant geneticVariant); }### Answer:
@Test public void getSequenceByName() { assertEquals(modifiableGenotypeData.getSequenceByName("22"), originalGenotypeData.getSequenceByName("22")); } |
### Question:
ModifiableGenotypeDataInMemory extends AbstractRandomAccessGenotypeData implements ModifiableGenotypeData { @Override public Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName) { return ModifiableGeneticVariantIterator.createGeneticVariantIterableBackByModifiable(sourceGenotypeData .getSequenceGeneticVariants(seqName).iterator(), this, filteredOutVariants); } ModifiableGenotypeDataInMemory(RandomAccessGenotypeData sourceGenotypeData); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Sequence getSequenceByName(String name); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override List<Annotation> getVariantAnnotations(); @Override Annotation getVariantAnnotation(String annotationId); @Override List<Sample> getSamples(); @Override Iterator<GeneticVariant> iterator(); @Override synchronized GeneticVariantId getUpdatedId(ModifiableGeneticVariant geneticVariant); @Override synchronized Allele getUpdatedRef(ModifiableGeneticVariant geneticVariant); @Override synchronized SampleVariantsProvider getUpdatedSampleVariantProvider(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateVariantId(ModifiableGeneticVariant geneticVariant,
GeneticVariantId newGeneticVariantId); @Override synchronized void updateVariantPrimaryId(ModifiableGeneticVariant geneticVariant, String newPrimaryId); @Override synchronized void swapGeneticVariant(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateRefAllele(ModifiableGeneticVariant geneticVariant, Allele newRefAllele); @Override synchronized Alleles getUpdatedAlleles(ModifiableGeneticVariant geneticVariant); @Override Iterable<ModifiableGeneticVariant> getModifiableSequenceGeneticVariants(String seqName); @Override Iterable<ModifiableGeneticVariant> getModifiableVariantsByPos(String seqName, int startPos); @Override ModifiableGeneticVariant getModifiableSnpVariantByPos(String seqName, int startPos); @Override Iterable<ModifiableGeneticVariant> getModifiableGeneticVariants(); @Override void excludeVariant(ModifiableGeneticVariant geneticVariant); @Override int getExcludedVariantCount(); @Override List<SampleAnnotation> getSampleAnnotations(); @Override Annotation getSampleAnnotation(String annotationId); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override void close(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override boolean isSwapped(GeneticVariant geneticVariant); }### Answer:
@Test public void getSequenceGeneticVariants() { Iterator<GeneticVariant> originalGeneticVariants = originalGenotypeData.getSequenceGeneticVariants("22") .iterator(); Iterator<GeneticVariant> modifiableGeneticVariants = modifiableGenotypeData.getSequenceGeneticVariants("22") .iterator(); assertEqualsVariantIterators(originalGeneticVariants, modifiableGeneticVariants); } |
### Question:
ModifiableGenotypeDataInMemory extends AbstractRandomAccessGenotypeData implements ModifiableGenotypeData { @Override public Iterable<Sequence> getSequences() { return sourceGenotypeData.getSequences(); } ModifiableGenotypeDataInMemory(RandomAccessGenotypeData sourceGenotypeData); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Sequence getSequenceByName(String name); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override List<Annotation> getVariantAnnotations(); @Override Annotation getVariantAnnotation(String annotationId); @Override List<Sample> getSamples(); @Override Iterator<GeneticVariant> iterator(); @Override synchronized GeneticVariantId getUpdatedId(ModifiableGeneticVariant geneticVariant); @Override synchronized Allele getUpdatedRef(ModifiableGeneticVariant geneticVariant); @Override synchronized SampleVariantsProvider getUpdatedSampleVariantProvider(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateVariantId(ModifiableGeneticVariant geneticVariant,
GeneticVariantId newGeneticVariantId); @Override synchronized void updateVariantPrimaryId(ModifiableGeneticVariant geneticVariant, String newPrimaryId); @Override synchronized void swapGeneticVariant(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateRefAllele(ModifiableGeneticVariant geneticVariant, Allele newRefAllele); @Override synchronized Alleles getUpdatedAlleles(ModifiableGeneticVariant geneticVariant); @Override Iterable<ModifiableGeneticVariant> getModifiableSequenceGeneticVariants(String seqName); @Override Iterable<ModifiableGeneticVariant> getModifiableVariantsByPos(String seqName, int startPos); @Override ModifiableGeneticVariant getModifiableSnpVariantByPos(String seqName, int startPos); @Override Iterable<ModifiableGeneticVariant> getModifiableGeneticVariants(); @Override void excludeVariant(ModifiableGeneticVariant geneticVariant); @Override int getExcludedVariantCount(); @Override List<SampleAnnotation> getSampleAnnotations(); @Override Annotation getSampleAnnotation(String annotationId); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override void close(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override boolean isSwapped(GeneticVariant geneticVariant); }### Answer:
@Test public void getSequences() { assertEquals(modifiableGenotypeData.getSequences(), originalGenotypeData.getSequences()); } |
### Question:
ModifiableGenotypeDataInMemory extends AbstractRandomAccessGenotypeData implements ModifiableGenotypeData { @Override public GeneticVariant getSnpVariantByPos(String seqName, int startPos) { return getModifiableSnpVariantByPos(seqName, startPos); } ModifiableGenotypeDataInMemory(RandomAccessGenotypeData sourceGenotypeData); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Sequence getSequenceByName(String name); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override List<Annotation> getVariantAnnotations(); @Override Annotation getVariantAnnotation(String annotationId); @Override List<Sample> getSamples(); @Override Iterator<GeneticVariant> iterator(); @Override synchronized GeneticVariantId getUpdatedId(ModifiableGeneticVariant geneticVariant); @Override synchronized Allele getUpdatedRef(ModifiableGeneticVariant geneticVariant); @Override synchronized SampleVariantsProvider getUpdatedSampleVariantProvider(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateVariantId(ModifiableGeneticVariant geneticVariant,
GeneticVariantId newGeneticVariantId); @Override synchronized void updateVariantPrimaryId(ModifiableGeneticVariant geneticVariant, String newPrimaryId); @Override synchronized void swapGeneticVariant(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateRefAllele(ModifiableGeneticVariant geneticVariant, Allele newRefAllele); @Override synchronized Alleles getUpdatedAlleles(ModifiableGeneticVariant geneticVariant); @Override Iterable<ModifiableGeneticVariant> getModifiableSequenceGeneticVariants(String seqName); @Override Iterable<ModifiableGeneticVariant> getModifiableVariantsByPos(String seqName, int startPos); @Override ModifiableGeneticVariant getModifiableSnpVariantByPos(String seqName, int startPos); @Override Iterable<ModifiableGeneticVariant> getModifiableGeneticVariants(); @Override void excludeVariant(ModifiableGeneticVariant geneticVariant); @Override int getExcludedVariantCount(); @Override List<SampleAnnotation> getSampleAnnotations(); @Override Annotation getSampleAnnotation(String annotationId); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override void close(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override boolean isSwapped(GeneticVariant geneticVariant); }### Answer:
@Test public void getSnpVariantByPos() { GeneticVariant original = originalGenotypeData.getSnpVariantByPos("22", 14433624); GeneticVariant modifiable = modifiableGenotypeData.getSnpVariantByPos("22", 14433624); assertEquals(modifiable.getSequenceName(), original.getSequenceName()); assertEquals(modifiable.getStartPos(), original.getStartPos()); original = modifiableGenotypeData.getSnpVariantByPos("22", 1); assertNull(original); } |
### Question:
ModifiableGenotypeDataInMemory extends AbstractRandomAccessGenotypeData implements ModifiableGenotypeData { @Override public Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos) { return ModifiableGeneticVariantIterator.createGeneticVariantIterableBackByModifiable(sourceGenotypeData .getVariantsByPos(seqName, startPos).iterator(), this, filteredOutVariants); } ModifiableGenotypeDataInMemory(RandomAccessGenotypeData sourceGenotypeData); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Sequence getSequenceByName(String name); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override List<Annotation> getVariantAnnotations(); @Override Annotation getVariantAnnotation(String annotationId); @Override List<Sample> getSamples(); @Override Iterator<GeneticVariant> iterator(); @Override synchronized GeneticVariantId getUpdatedId(ModifiableGeneticVariant geneticVariant); @Override synchronized Allele getUpdatedRef(ModifiableGeneticVariant geneticVariant); @Override synchronized SampleVariantsProvider getUpdatedSampleVariantProvider(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateVariantId(ModifiableGeneticVariant geneticVariant,
GeneticVariantId newGeneticVariantId); @Override synchronized void updateVariantPrimaryId(ModifiableGeneticVariant geneticVariant, String newPrimaryId); @Override synchronized void swapGeneticVariant(ModifiableGeneticVariant geneticVariant); @Override synchronized void updateRefAllele(ModifiableGeneticVariant geneticVariant, Allele newRefAllele); @Override synchronized Alleles getUpdatedAlleles(ModifiableGeneticVariant geneticVariant); @Override Iterable<ModifiableGeneticVariant> getModifiableSequenceGeneticVariants(String seqName); @Override Iterable<ModifiableGeneticVariant> getModifiableVariantsByPos(String seqName, int startPos); @Override ModifiableGeneticVariant getModifiableSnpVariantByPos(String seqName, int startPos); @Override Iterable<ModifiableGeneticVariant> getModifiableGeneticVariants(); @Override void excludeVariant(ModifiableGeneticVariant geneticVariant); @Override int getExcludedVariantCount(); @Override List<SampleAnnotation> getSampleAnnotations(); @Override Annotation getSampleAnnotation(String annotationId); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override void close(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override boolean isSwapped(GeneticVariant geneticVariant); }### Answer:
@Test public void getVariantsByPos() { Iterator<GeneticVariant> originalGeneticVariants = originalGenotypeData.getVariantsByPos("22", 14433624) .iterator(); Iterator<GeneticVariant> modifiableGeneticVariants = modifiableGenotypeData.getVariantsByPos("22", 14433624) .iterator(); assertEqualsVariantIterators(originalGeneticVariants, modifiableGeneticVariants); } |
### Question:
ModifiableGeneticVariantIterator implements Iterator<E> { public static Iterable<ModifiableGeneticVariant> createModifiableGeneticVariantIterable( Iterator<GeneticVariant> originalIterator, ModifiableGenotypeData modifiableGenotypeData, HashSet<ModifiableGeneticVariant> excludeList) { return new ModifiableGeneticVariantIterable<ModifiableGeneticVariant>( new ModifiableGeneticVariantIterator<ModifiableGeneticVariant>(originalIterator, modifiableGenotypeData, excludeList)); } ModifiableGeneticVariantIterator(Iterator<GeneticVariant> originalIterator,
ModifiableGenotypeData modifiableGenotypeData, HashSet<ModifiableGeneticVariant> excludeList); @Override boolean hasNext(); @SuppressWarnings("unchecked") @Override E next(); @Override void remove(); static Iterable<ModifiableGeneticVariant> createModifiableGeneticVariantIterable(
Iterator<GeneticVariant> originalIterator, ModifiableGenotypeData modifiableGenotypeData,
HashSet<ModifiableGeneticVariant> excludeList); static Iterable<GeneticVariant> createGeneticVariantIterableBackByModifiable(
Iterator<GeneticVariant> originalIterator, ModifiableGenotypeData modifiableGenotypeData,
HashSet<ModifiableGeneticVariant> excludeList); }### Answer:
@Test public void createModifiableGeneticVariantIterable() { GeneticVariant variant1 = ReadOnlyGeneticVariant.createSnp(variantMeta, "Rs1", 1, "chr1", null, 'A', 'T'); GeneticVariant variant2 = ReadOnlyGeneticVariant.createSnp(variantMeta, "Rs2", 20, "chr1", null, 'G', 'C'); ArrayList<GeneticVariant> variants = new ArrayList<GeneticVariant>(2); variants.add(variant1); variants.add(variant2); HashSet<ModifiableGeneticVariant> excludeList = new HashSet<ModifiableGeneticVariant>(); Iterable<ModifiableGeneticVariant> modifiableVariants = ModifiableGeneticVariantIterator .createModifiableGeneticVariantIterable(variants.iterator(), dummyModifiableGenotypeData, excludeList); Iterator<ModifiableGeneticVariant> modifiableVariantsIterator = modifiableVariants.iterator(); assertEquals(modifiableVariantsIterator.next().getOriginalVariant(), variant1); assertEquals(modifiableVariantsIterator.next().getOriginalVariant(), variant2); assertEquals(modifiableVariantsIterator.hasNext(), false); } |
### Question:
CachedSampleVariantProvider implements SampleVariantsProvider { @Override public FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant) { if (genotypeRecordCache.containsKey(variant)) { return genotypeRecordCache.get(variant); } FixedSizeIterable<GenotypeRecord> sampleGenotypeRecords = sampleVariantProvider.getSampleGenotypeRecords(variant); genotypeRecordCache.put(variant, sampleGenotypeRecords); return sampleGenotypeRecords; } CachedSampleVariantProvider(SampleVariantsProvider sampleVariantProvider, int cacheSize); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void getSampleGenotypeRecords() { SampleVariantsProvider sampleVariantProvider = mock(SampleVariantsProvider.class); CachedSampleVariantProvider cachedSampleVariantProvider = new CachedSampleVariantProvider(sampleVariantProvider , 1); GeneticVariant variant = mock(GeneticVariant.class); cachedSampleVariantProvider.getSampleGenotypeRecords(variant); cachedSampleVariantProvider.getSampleGenotypeRecords(variant); verify(sampleVariantProvider, times(1)).getSampleGenotypeRecords(variant); } |
### Question:
AbstractGeneticVariant implements GeneticVariant { @Override public final int compareTo(GeneticVariant other) { if (other == null) { return 0; } if (this == other) { return 0; } if (this.equals(other)) { return 0; } if (!this.getSequenceName().equals(other.getSequenceName())) { return chrComparator.compare(this.getSequenceName(), other.getSequenceName()); } else { if (this.getStartPos() != other.getStartPos()) { return this.getStartPos() < other.getStartPos() ? -1 : (this.getStartPos() == other.getStartPos() ? 0 : 1); } else { if (ReadOnlyGeneticVariantTriTyper.class.isInstance(this)) { if (!ReadOnlyGeneticVariantTriTyper.class.isInstance(other)) { return 1; } else { return this.getSampleVariantsProvider().getSampleVariantProviderUniqueId() - other.getSampleVariantsProvider().getSampleVariantProviderUniqueId(); } } if (ReadOnlyGeneticVariantTriTyper.class.isInstance(other)) { return -1; } if (!this.getVariantAlleles().equals(other.getVariantAlleles())) { return this.getVariantAlleles().compareTo(other.getVariantAlleles()); } else { return this.getSampleVariantsProvider().getSampleVariantProviderUniqueId() - other.getSampleVariantsProvider().getSampleVariantProviderUniqueId(); } } } } @Override final int compareTo(GeneticVariant other); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isMapped(); @Override double getCallRate(); @Override double getHwePvalue(); @Override boolean isSnp(); @Override boolean isAtOrGcSnp(); @Override Ld calculateLd(GeneticVariant other); @Override boolean isBiallelic(); @Override boolean hasPhasedGenotypes(); @Override double getMachR2(); }### Answer:
@Test public void compareTo() { assertEquals(variant1.compareTo(variant3) < 0, true); assertEquals(variant3.compareTo(variant1) > 0, true); assertEquals(variant1.compareTo(variant4) < 0, true); assertEquals(variant4.compareTo(variant1) > 0, true); assertEquals(variant3.compareTo(variant4) < 0, true); assertEquals(variant4.compareTo(variant3) > 0, true); assertEquals(variant3.compareTo(variant8) < 0, true); assertEquals(variant8.compareTo(variant3) > 0, true); assertEquals(variant1.compareTo(variant10) < 0, true); assertEquals(variant10.compareTo(variant1) > 0, true); } |
### Question:
AbstractGeneticVariant implements GeneticVariant { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof GeneticVariant)) { return false; } GeneticVariant other = (GeneticVariant) obj; if (getSequenceName() == null) { if (other.getSequenceName() != null) { return false; } } else if (!getSequenceName().equals(other.getSequenceName())) { return false; } if (getStartPos() != other.getStartPos()) { return false; } if (!other.getClass().equals(obj.getClass())) { return false; } if (getVariantAlleles() == null) { if (other.getVariantAlleles() != null) { return false; } } else if (!getVariantAlleles().equals(other.getVariantAlleles())) { return false; } if (getSampleVariantsProvider() == null) { if (other.getSampleVariantsProvider() != null) { return false; } } else if (!getSampleVariantsProvider().equals(other.getSampleVariantsProvider())) { return false; } return true; } @Override final int compareTo(GeneticVariant other); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isMapped(); @Override double getCallRate(); @Override double getHwePvalue(); @Override boolean isSnp(); @Override boolean isAtOrGcSnp(); @Override Ld calculateLd(GeneticVariant other); @Override boolean isBiallelic(); @Override boolean hasPhasedGenotypes(); @Override double getMachR2(); }### Answer:
@Test public void equals() { assertEquals(variant1.equals(variant1), true); assertEquals(variant1.equals(variant2), true); assertEquals(variant1.equals(variant3), false); assertEquals(variant1.equals(variant4), false); assertEquals(variant1.equals(variant5), false); assertEquals(variant1.equals(variant6), false); assertEquals(variant1.equals(variant7), false); assertEquals(variant1.equals(variant8), false); assertEquals(variant1.equals(variant9), false); assertEquals(variant2.equals(variant3), false); assertEquals(variant5.equals(variant6), false); assertEquals(variant7.equals(variant8), false); } |
### Question:
MultiPartGenotypeData extends AbstractRandomAccessGenotypeData { @Override public Map<String, Annotation> getVariantAnnotationsMap() { return variantAnnotationsMap; } MultiPartGenotypeData(Collection<RandomAccessGenotypeData> genotypeDataCollection); MultiPartGenotypeData(RandomAccessGenotypeData... genotypeDataCollection); MultiPartGenotypeData(Set<RandomAccessGenotypeData> genotypeDataCollection); static MultiPartGenotypeData createFromVcfFolder(File vcfFolder, int cacheSize, double minimumPosteriorProbabilityToCall); static MultiPartGenotypeData createFromGenFolder(File genFolder, int cacheSize, double minimumPosteriorProbabilityToCall); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Sequence getSequenceByName(String name); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override List<Sample> getSamples(); @Override Iterator<GeneticVariant> iterator(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override void close(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); }### Answer:
@Test public void testGetVariantAnnotationsMap() { assertEquals(chr1VarAnnotated.getVariantAnnotationsMap(), expectedVariantAnnotationMap); assertEquals(chr2VarAnnotated.getVariantAnnotationsMap(), expectedVariantAnnotationMap); assertEquals(multiPartVarAnnotated.getVariantAnnotationsMap(), expectedVariantAnnotationMap); } |
### Question:
MultiPartGenotypeData extends AbstractRandomAccessGenotypeData { @Override public Map<String, SampleAnnotation> getSampleAnnotationsMap() { return sampleAnnotationsMap; } MultiPartGenotypeData(Collection<RandomAccessGenotypeData> genotypeDataCollection); MultiPartGenotypeData(RandomAccessGenotypeData... genotypeDataCollection); MultiPartGenotypeData(Set<RandomAccessGenotypeData> genotypeDataCollection); static MultiPartGenotypeData createFromVcfFolder(File vcfFolder, int cacheSize, double minimumPosteriorProbabilityToCall); static MultiPartGenotypeData createFromGenFolder(File genFolder, int cacheSize, double minimumPosteriorProbabilityToCall); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Sequence getSequenceByName(String name); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override List<Sample> getSamples(); @Override Iterator<GeneticVariant> iterator(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override void close(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); }### Answer:
@Test public void testGetSampleAnnotationsMap() { assertEquals(chr1SampleAnnotated.getSampleAnnotationsMap(), expectedSampleAnnotationMap); assertEquals(chr2SampleAnnotated.getSampleAnnotationsMap(), expectedSampleAnnotationMap); assertEquals(multiPartSampleAnnotated.getSampleAnnotationsMap(), expectedSampleAnnotationMap); } |
### Question:
BedBimFamGenotypeWriter implements GenotypeWriter { @Override public void write(String path) throws IOException, NotASnpException { write(new File(path + ".bed"), new File(path + ".bim"), new File(path + ".fam")); } BedBimFamGenotypeWriter(GenotypeData genotypeData); @Override void write(String path); void write(File bedFile, File bimFile, File famFile); }### Answer:
@Test public void testWrite_String() throws Exception { GenotypeData genotypeData = new BedBimFamGenotypeData(getTestBed6(), getTestBim6(), getTestFam6(), 0); BedBimFamGenotypeWriter writer = new BedBimFamGenotypeWriter(genotypeData); writer.write(tmpOutputFolder.getAbsolutePath() + fileSep + "test6samples"); GenotypeData genotypeDataWritten = RandomAccessGenotypeDataReaderFormats.PLINK_BED.createGenotypeData(tmpOutputFolder.getAbsolutePath() + fileSep + "test6samples", 0); assertTrue(GenotypeDataCompareTool.same(genotypeData, genotypeDataWritten)); }
@Test public void testWrite_String2() throws Exception { GenotypeData genotypeData = new BedBimFamGenotypeData(getTestBed7(), getTestBim7(), getTestFam7(), 0); BedBimFamGenotypeWriter writer = new BedBimFamGenotypeWriter(genotypeData); writer.write(tmpOutputFolder.getAbsolutePath() + fileSep + "test7samples"); GenotypeData genotypeDataWritten = RandomAccessGenotypeDataReaderFormats.PLINK_BED.createGenotypeData(tmpOutputFolder.getAbsolutePath() + fileSep + "test7samples", 0); assertTrue(GenotypeDataCompareTool.same(genotypeData, genotypeDataWritten)); }
@Test public void testWrite_String3() throws Exception { GenotypeData genotypeData = new BedBimFamGenotypeData(getTestBed8(), getTestBim8(), getTestFam8(), 0); BedBimFamGenotypeWriter writer = new BedBimFamGenotypeWriter(genotypeData); writer.write(tmpOutputFolder.getAbsolutePath() + fileSep + "test8samples"); GenotypeData genotypeDataWritten = RandomAccessGenotypeDataReaderFormats.PLINK_BED.createGenotypeData(tmpOutputFolder.getAbsolutePath() + fileSep + "test8samples", 0); assertTrue(GenotypeDataCompareTool.same(genotypeData, genotypeDataWritten)); }
@Test public void testWrite_String4() throws Exception { GenotypeData genotypeData = new BedBimFamGenotypeData(getTestBed9(), getTestBim9(), getTestFam9(), 0); BedBimFamGenotypeWriter writer = new BedBimFamGenotypeWriter(genotypeData); writer.write(tmpOutputFolder.getAbsolutePath() + fileSep + "test9samples"); GenotypeData genotypeDataWritten = RandomAccessGenotypeDataReaderFormats.PLINK_BED.createGenotypeData(tmpOutputFolder.getAbsolutePath() + fileSep + "test9samples", 0); assertTrue(GenotypeDataCompareTool.same(genotypeData, genotypeDataWritten)); genotypeData.close(); genotypeDataWritten.close(); } |
### Question:
PedFileDriver implements PlinkFileParser, Iterable<PedEntry> { public long getNrOfElements() throws IOException { if (nrElements == -1) nrElements = getNumberOfNonEmptyLines(file, FILE_ENCODING); return nrElements; } PedFileDriver(File pedFile); PedFileDriver(File pedFile, char separator); PedFileDriver(File pedFile, String separators); List<PedEntry> getAllEntries(); @Override Iterator<PedEntry> iterator(); List<PedEntry> getEntries(final long from, final long to); long getNrOfElements(); @Override void close(); void reset(); }### Answer:
@Test public void PED_construct() throws Exception { assertEquals(9, pedfd.getNrOfElements()); } |
### Question:
MapFileDriver implements PlinkFileParser { public long getNrOfElements() throws IOException { if (nrElements == -1) nrElements = getNumberOfNonEmptyLines(file, FILE_ENCODING); return nrElements; } MapFileDriver(File mapFile); MapFileDriver(File mapFile, char separator); MapFileDriver(File mapFile, String separators); List<MapEntry> getEntries(final long from, final long to); List<MapEntry> getAllEntries(); static MapEntry parseEntry(String line, String separators); long getNrOfElements(); @Override void close(); void reset(); }### Answer:
@Test public void MAP_construct() throws Exception { assertEquals(10, mapfd.getNrOfElements()); } |
### Question:
PedMapGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<String> getSeqNames() { return new ArrayList<String>(seqNames); } PedMapGenotypeData(String basePath); PedMapGenotypeData(File pedFile, File mapFile); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterator<GeneticVariant> iterator(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void getSeqNames() { List<String> seqNames = genotypeData.getSeqNames(); assertNotNull(seqNames); assertEquals(seqNames.size(), 2); assertEquals(seqNames.get(0), "22"); assertEquals(seqNames.get(1), "23"); } |
### Question:
PedMapGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Sequence> getSequences() { List<Sequence> sequences = new ArrayList<Sequence>(seqNames.size()); for (String seqName : seqNames) { sequences.add(new SimpleSequence(seqName, null, this)); } return sequences; } PedMapGenotypeData(String basePath); PedMapGenotypeData(File pedFile, File mapFile); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterator<GeneticVariant> iterator(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSequences() { List<Sequence> sequences = genotypeData.getSequences(); assertNotNull(sequences); assertEquals(sequences.size(), 2); } |
### Question:
PedMapGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Sample> getSamples() { return samples; } PedMapGenotypeData(String basePath); PedMapGenotypeData(File pedFile, File mapFile); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterator<GeneticVariant> iterator(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSamples() { List<Sample> samples = genotypeData.getSamples(); assertNotNull(samples); assertEquals(samples.size(), 9); assertEquals(samples.get(0).getId(), "1042"); assertEquals(samples.get(0).getFamilyId(), "F1042"); } |
### Question:
PedMapGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Boolean> getSamplePhasing(GeneticVariant variant) { List<Boolean> phasing = Collections.nCopies(getSampleVariants(variant).size(), false); return phasing; } PedMapGenotypeData(String basePath); PedMapGenotypeData(File pedFile, File mapFile); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterator<GeneticVariant> iterator(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSamplePhasing() { List<GeneticVariant> variants = Utils.iteratorToList(genotypeData.getVariantsByPos("22", 14431347).iterator()); assertEquals(variants.size(), 1); assertEquals(genotypeData.getSamplePhasing(variants.get(0)), Arrays.asList(false, false, false, false, false, false, false, false, false)); } |
### Question:
PedMapGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Alleles> getSampleVariants(GeneticVariant variant) { if (variant.getPrimaryVariantId() == null) { throw new IllegalArgumentException("Not a snp, missing primaryVariantId"); } int index = snpIndexById.get(variant.getPrimaryVariantId()); if (index == -1) { throw new IllegalArgumentException("Unknown primaryVariantId [" + variant.getPrimaryVariantId() + "]"); } List<Alleles> bialleles = sampleAllelesBySnpIndex.get(index); return Collections.unmodifiableList(bialleles); } PedMapGenotypeData(String basePath); PedMapGenotypeData(File pedFile, File mapFile); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterator<GeneticVariant> iterator(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSnpVariantByPos() { int pos = 14433624; GeneticVariant variant = genotypeData.getSnpVariantByPos("22", pos); assertNotNull(variant); assertEquals(variant.getStartPos(), pos); ArrayList<Alleles> expectedSampleAlleles = new ArrayList<Alleles>(9); expectedSampleAlleles.add(Alleles.createBasedOnChars('G', 'G')); expectedSampleAlleles.add(Alleles.createBasedOnChars('A', 'G')); expectedSampleAlleles.add(Alleles.createBasedOnChars('G', 'G')); expectedSampleAlleles.add(Alleles.createBasedOnChars('G', 'G')); expectedSampleAlleles.add(Alleles.createBasedOnChars('G', 'G')); expectedSampleAlleles.add(Alleles.createBasedOnChars('A', 'G')); expectedSampleAlleles.add(Alleles.createBasedOnChars('G', 'G')); expectedSampleAlleles.add(Alleles.createBasedOnChars('G', 'G')); expectedSampleAlleles.add(Alleles.createBasedOnChars('A', 'G')); assertEquals(variant.getSampleVariants(), expectedSampleAlleles); assertEquals(variant.getVariantAlleles(), Alleles.createBasedOnChars('G', 'A')); byte[] expectedCalledDosage = new byte[] { 2, 1, 2, 2, 2, 1, 2, 2, 1 }; assertEquals(variant.getSampleCalledDosages(), expectedCalledDosage); } |
### Question:
Deconvolution { public void readInputData() throws IllegalAccessException, IOException { outputFolder = commandLineOptions.getOutfolder(); cellCounts = new CellCount(); cellCounts.readCellCountData(commandLineOptions.getCellcountFile()); geneSnpPairs = Utils.parseSnpPerGeneFile(commandLineOptions.getSnpsToTestFile()); String expressionFile = commandLineOptions.getExpressionFile(); DeconvolutionLogger.log.info(String.format("Parse expression data from %s",expressionFile)); expressionData = new ExpressionData(expressionFile); DeconvolutionLogger.log.info("Done"); String genotypeFile = commandLineOptions.getGenotypeFile(); DeconvolutionLogger.log.info(String.format("Parse genotype data from %s",genotypeFile)); genotypeData = new GenotypeData(genotypeFile); DeconvolutionLogger.log.info("Done"); if (!expressionData.getSampleNames().equals(genotypeData.getSampleNames())){ ArrayList<String> differences = Utils.getDifferencesBetweenLists(expressionData.getSampleNames(), genotypeData.getSampleNames()); throw new RuntimeException(String.format("Samplenames not the same in expression and genotype file, or not in the same order."+ "\nexpression samples not in genotypes (%d): %s\ngenotype samples not in expression (%d): %s\n", differences.get(0).length(), differences.get(0), differences.get(1).length(), differences.get(1))); } } Deconvolution(CommandLineOptions commandLineOptions); void readInputData(); List<DeconvolutionResult> runDeconPerGeneSnpPair(); void writeDeconvolutionResults(List<DeconvolutionResult> deconvolutionResults); public CellCount cellCounts; public ExpressionData expressionData; public HashMap<String,ArrayList<String>> geneSnpPairs; public GenotypeData genotypeData; }### Answer:
@Test public void readInputDataTest() throws Exception { File cellCountsSmall = new File("src/test/resources/cellcount_files/cellcounts_small.txt"); String[] args = {"-o",outputDir+"deconvolutionTestResults","-c",counts,cellCountsSmall.getAbsolutePath(), "-e",expression, "-g", genotypes, "-sn", geneSnpList}; commandLineOptions.parseCommandLine(args); Deconvolution deconvolution = new Deconvolution(commandLineOptions); deconvolution.readInputData(); }
@Test public void readInputDataWrongNamesTest() throws Exception { File expTableWrongNames = new File("src/test/resources/expression_files/expression_levels_wrong_names.txt"); String[] args = {"-o",outputDir+"deconvolutionTestResults","-c",counts,"-e", expTableWrongNames.getAbsolutePath(), "-g", genotypes, "-sn", geneSnpList}; commandLineOptions.parseCommandLine(args); Deconvolution deconvolution = new Deconvolution(commandLineOptions); try { deconvolution.readInputData(); fail( "My method didn't throw when I expected it to" ); } catch (RuntimeException expectedException) { assertThat(expectedException.getMessage(), CoreMatchers.containsString("Samplenames not the same in expression and genotype file, or not in the same order")); } } |
### Question:
Statistics { public static double calculateSpearmanTwoTailedPvalue(double spearmanCorrelation, int sampleSize){ double z = Math.sqrt((sampleSize-3)/1.06) * atanh(spearmanCorrelation); NormalDistribution normalDistribution = new NormalDistribution(); double p = 2*normalDistribution.cumulativeProbability(-Math.abs(z)); if (Double.isNaN(z)){ p = 0; } if (Double.isNaN(spearmanCorrelation)){ p = 1; } return p; } static double calculateSpearmanTwoTailedPvalue(double spearmanCorrelation, int sampleSize); static double anova(double sumOfSquaresModelA, double sumOfSquaresModelB, int degreesOfFreedomA,
int degreesOfFreedomB, Boolean no_intercept); }### Answer:
@Test public void calculateSpearmanTwoTailedPvalueTest() throws Exception { double expectedPval = 1.773084e-06; double observedPval = Statistics.calculateSpearmanTwoTailedPvalue(0.1504121, 1000); assertEquals(expectedPval,observedPval, 0.001); expectedPval = 1; observedPval = Statistics.calculateSpearmanTwoTailedPvalue(0, 1000); assertEquals(expectedPval,observedPval, 0.001); }
@Test public void calculateSpearmanTwoTailedPvalueNaNTest() throws Exception { double expectedPval = 0; double observedPval = Statistics.calculateSpearmanTwoTailedPvalue(1000000, 1000); assertEquals(expectedPval,observedPval, 0.001); } |
### Question:
Statistics { public static double anova(double sumOfSquaresModelA, double sumOfSquaresModelB, int degreesOfFreedomA, int degreesOfFreedomB, Boolean no_intercept) { if (no_intercept) { ++degreesOfFreedomA; ++degreesOfFreedomB; } double meanSquareError = sumOfSquaresModelA / degreesOfFreedomA; int degreesOfFreedomDifference = Math.abs(degreesOfFreedomB - degreesOfFreedomA); double meanSquareErrorDiff = Math.abs((sumOfSquaresModelA - sumOfSquaresModelB) / (degreesOfFreedomDifference)); if(meanSquareError == 0){ throw new RuntimeException("meanSquareError should not be 0, no variance in the data?"); } double Fval = meanSquareErrorDiff / meanSquareError; FDistribution Fdist = new FDistribution(degreesOfFreedomDifference, degreesOfFreedomB); double pval = 1 - Fdist.cumulative(Fval); return pval; } static double calculateSpearmanTwoTailedPvalue(double spearmanCorrelation, int sampleSize); static double anova(double sumOfSquaresModelA, double sumOfSquaresModelB, int degreesOfFreedomA,
int degreesOfFreedomB, Boolean no_intercept); }### Answer:
@Test public void anovaTest() throws Exception { double expectedPval = 4.09E-7; double observedPval = Statistics.anova(31, 22, 100, 101, true); assertEquals(expectedPval, observedPval, 0.000000001); expectedPval = 4.67E-7; observedPval = Statistics.anova(31, 22, 100, 101, false); assertEquals(expectedPval, observedPval, 0.000000001); }
@Test public void anovaErrorTest() throws Exception { try { Statistics.anova(0, 10, 100, 100, true); fail( "My method didn't throw when I expected it to" ); } catch (RuntimeException expectedException) { assertEquals(expectedException.getMessage(), "meanSquareError should not be 0, no variance in the data?"); } } |
### Question:
SmoothSort { public static <C extends Comparable<? super C>> void sort(C[] m) { sortInternaly(m,0,m.length-1); } static void sort(C[] m); static void sort(C[] m, int fromIndex, int toIndex); }### Answer:
@Test public void testSort() { Integer[] l1 = { 5, 1024, 1, 88, 0, 1024 }; Integer[] l1c = { 5, 1024, 1, 88, 0, 1024 }; SmoothSort.sort(l1); Arrays.sort(l1c); boolean correct=true; for(int i=0;i<l1.length;i++){ if(!l1[i].equals(l1c[i])){ correct = false; break; } } assertEquals(correct, true); Double[] l3 = { 5.0d, 1024.5d, 1.0d, 88.0d, 0.0d, 1024.0d }; Double[] l3c = { 5.0d, 1024.5d, 1.0d, 88.0d, 0.0d, 1024.0d }; SmoothSort.sort(l3,1,5); Arrays.sort(l3c,1,5); correct=true; for(int i=0;i<l3.length;i++){ if(!l3[i].equals(l3c[i])){ correct = false; break; } } assertEquals(correct, true); String[] l2 = { "gamma", "beta", "alpha", "zoolander" }; String[] l2c = { "gamma", "beta", "alpha", "zoolander" }; SmoothSort.sort(l2); Arrays.sort(l2c); correct=true; for(int i=0;i<l2.length;i++){ if(!l2[i].equals(l2c[i])){ correct = false; break; } } assertEquals(correct, true); } |
### Question:
GenomicBoundaries implements Iterable<GenomicBoundary<V>> { public final void addBoundary(String chromosome, Integer beginPoint, int endPoint){ chromosome = removeChr(chromosome); TreeMap<Integer, ArrayList<GenomicBoundary<V>>> chromosomeBoundaries; if(!genomicsBoundaries.containsKey(chromosome)){ chromosomeBoundaries = new TreeMap<Integer, ArrayList<GenomicBoundary<V>>>(); genomicsBoundaries.put(chromosome, chromosomeBoundaries); } else { chromosomeBoundaries = genomicsBoundaries.get(chromosome); } GenomicBoundary genomicBoundary; genomicBoundary = new GenomicBoundary(chromosome, beginPoint, endPoint); ArrayList<GenomicBoundary<V>> boundaries; if(chromosomeBoundaries.containsKey(beginPoint)){ boundaries = chromosomeBoundaries.get(beginPoint); } else { boundaries = new ArrayList<GenomicBoundary<V>>(); chromosomeBoundaries.put(beginPoint, boundaries); } boundaries.add(genomicBoundary); removedSubBoundaries = false; } GenomicBoundaries(String genomicsBoundarysFilePath); GenomicBoundaries(); GenomicBoundaries(String genomicsBoundarysFilePath, int margin); final void addBoundary(String chromosome, Integer beginPoint, int endPoint); final void removeSubBoundaries(); final void mergeOverlappingBoundaries(); boolean isChromosomeInBoundary(String chromosome); Set<String> getChromosomes(); boolean isInBoundary(String chromosome, int position, int listIndex); GenomicBoundary getBoundary(String chromosome, int position, int listIndex); Iterator<GenomicBoundary<V>> iterator(); int getBoundaryCountChromosome(String chromosome); int getBoudaryCount(); void writeBoundariesToBedFile(String bedFilePath, String trackName); TreeMap<Integer, ArrayList<GenomicBoundary<V>>> getGenomicBoundariesMap(String chromosome); Collection<ArrayList<GenomicBoundary<V>>> getGenomicBoundaries(String chromosome); void mergeGenomicBoundaries(GenomicBoundaries otherGenomicBoundariesSet); HashMap<String, TreeMap<Integer, ArrayList<GenomicBoundary<V>>>> getGenomicBoundaries(); final void addBoundary(String chromosome, Integer beginPoint, int endPoint, V annotation); }### Answer:
@Test public void testAddBoundary() { String chromosome = "1"; Integer beginPoint = 1; int endPoint = 3; GenomicBoundaries instance = new GenomicBoundaries(); instance.addBoundary(chromosome, beginPoint, endPoint); boolean expResult = true; boolean result = instance.isInBoundary(chromosome, beginPoint, 0); assertEquals(result, expResult); }
@Test public void testIteratorNew(){ String chromosome = "1"; Integer beginPoint = 1; int endPoint = 3; GenomicBoundaries<Object> instance = new GenomicBoundaries(); instance.addBoundary(chromosome, 1, 8); instance.addBoundary(chromosome, 1, 12); instance.addBoundary(chromosome, 1, 15); instance.addBoundary(chromosome, 1, 20); instance.addBoundary(chromosome, 2, 11); instance.addBoundary(chromosome, 3, 14); instance.addBoundary("2", 64, 128); GenomicBoundary boundary; } |
### Question:
GenomicBoundaries implements Iterable<GenomicBoundary<V>> { public final void removeSubBoundaries(){ GenomicBoundary previousGenomicBoundary = null; GenomicBoundary genomicBoundary; Iterator<GenomicBoundary<V>> gboit = this.iterator(); while(gboit.hasNext()){ genomicBoundary = gboit.next(); if(genomicBoundary.isPartOfBoundary(previousGenomicBoundary)){ gboit.remove(); } previousGenomicBoundary = genomicBoundary; } removedSubBoundaries = true; } GenomicBoundaries(String genomicsBoundarysFilePath); GenomicBoundaries(); GenomicBoundaries(String genomicsBoundarysFilePath, int margin); final void addBoundary(String chromosome, Integer beginPoint, int endPoint); final void removeSubBoundaries(); final void mergeOverlappingBoundaries(); boolean isChromosomeInBoundary(String chromosome); Set<String> getChromosomes(); boolean isInBoundary(String chromosome, int position, int listIndex); GenomicBoundary getBoundary(String chromosome, int position, int listIndex); Iterator<GenomicBoundary<V>> iterator(); int getBoundaryCountChromosome(String chromosome); int getBoudaryCount(); void writeBoundariesToBedFile(String bedFilePath, String trackName); TreeMap<Integer, ArrayList<GenomicBoundary<V>>> getGenomicBoundariesMap(String chromosome); Collection<ArrayList<GenomicBoundary<V>>> getGenomicBoundaries(String chromosome); void mergeGenomicBoundaries(GenomicBoundaries otherGenomicBoundariesSet); HashMap<String, TreeMap<Integer, ArrayList<GenomicBoundary<V>>>> getGenomicBoundaries(); final void addBoundary(String chromosome, Integer beginPoint, int endPoint, V annotation); }### Answer:
@Test public void testRemoveSubBoundaries() { GenomicBoundaries instance = new GenomicBoundaries(); instance.addBoundary("1", 2, 3); instance.addBoundary("1", 1, 4); instance.removeSubBoundaries(); boolean expResult = true; boolean result = instance.isInBoundary("1", 1, 0); assertEquals(result, expResult); expResult = true; result = instance.isInBoundary("1", 2, 0); assertEquals(result, expResult); expResult = true; result = instance.isInBoundary("1", 3, 0); assertEquals(result, expResult); expResult = false; result = instance.isInBoundary("1", 5, 0); assertEquals(result, expResult); int expBoundaryCount = 1; int boundaryCount = instance.getBoundaryCountChromosome("1"); assertEquals(expBoundaryCount, boundaryCount); } |
### Question:
GenomicBoundaries implements Iterable<GenomicBoundary<V>> { public Iterator<GenomicBoundary<V>> iterator() { return new GenomicBoundariesIterator<V>(genomicsBoundaries); } GenomicBoundaries(String genomicsBoundarysFilePath); GenomicBoundaries(); GenomicBoundaries(String genomicsBoundarysFilePath, int margin); final void addBoundary(String chromosome, Integer beginPoint, int endPoint); final void removeSubBoundaries(); final void mergeOverlappingBoundaries(); boolean isChromosomeInBoundary(String chromosome); Set<String> getChromosomes(); boolean isInBoundary(String chromosome, int position, int listIndex); GenomicBoundary getBoundary(String chromosome, int position, int listIndex); Iterator<GenomicBoundary<V>> iterator(); int getBoundaryCountChromosome(String chromosome); int getBoudaryCount(); void writeBoundariesToBedFile(String bedFilePath, String trackName); TreeMap<Integer, ArrayList<GenomicBoundary<V>>> getGenomicBoundariesMap(String chromosome); Collection<ArrayList<GenomicBoundary<V>>> getGenomicBoundaries(String chromosome); void mergeGenomicBoundaries(GenomicBoundaries otherGenomicBoundariesSet); HashMap<String, TreeMap<Integer, ArrayList<GenomicBoundary<V>>>> getGenomicBoundaries(); final void addBoundary(String chromosome, Integer beginPoint, int endPoint, V annotation); }### Answer:
@Test public void testIterator(){ String chromosome = "1"; Integer beginPoint = 1; int endPoint = 3; GenomicBoundaries<Object> instance = new GenomicBoundaries(); instance.addBoundary(chromosome, 1, 8); instance.addBoundary(chromosome, 2, 11); instance.addBoundary(chromosome, 3, 14); int[] expectedResults = new int[3]; expectedResults[0] = 1; expectedResults[1] = 2; expectedResults[2] = 3; int n=0; } |
### Question:
GenomicBoundary implements Comparable<GenomicBoundary> { public String getChromosome() { return chromosome; } GenomicBoundary(String chromosome, Integer start, int stop); GenomicBoundary(String chromosome, Integer start, int stop, V annotation); String getChromosome(); Integer getStart(); int getStop(); @Override int compareTo(GenomicBoundary other); boolean isInBoundarie(int position); boolean isInBoundarie(int position, int margin); boolean isPartOfBoundary(GenomicBoundary other); boolean isOverlaping(GenomicBoundary other); V getAnnotation(); int getLength(boolean isInclusive); }### Answer:
@Test public void testGetChromosome() { GenomicBoundary instance = new GenomicBoundary("1", 1, 2); String expResult = "1"; String result = instance.getChromosome(); assertEquals(result, expResult); } |
### Question:
GenomicBoundary implements Comparable<GenomicBoundary> { public Integer getStart() { return start; } GenomicBoundary(String chromosome, Integer start, int stop); GenomicBoundary(String chromosome, Integer start, int stop, V annotation); String getChromosome(); Integer getStart(); int getStop(); @Override int compareTo(GenomicBoundary other); boolean isInBoundarie(int position); boolean isInBoundarie(int position, int margin); boolean isPartOfBoundary(GenomicBoundary other); boolean isOverlaping(GenomicBoundary other); V getAnnotation(); int getLength(boolean isInclusive); }### Answer:
@Test public void testGetStart() { GenomicBoundary instance = new GenomicBoundary("1", 1, 2); Integer expResult = 1; Integer result = instance.getStart(); assertEquals(result, expResult); } |
### Question:
GenomicBoundary implements Comparable<GenomicBoundary> { public int getStop() { return stop; } GenomicBoundary(String chromosome, Integer start, int stop); GenomicBoundary(String chromosome, Integer start, int stop, V annotation); String getChromosome(); Integer getStart(); int getStop(); @Override int compareTo(GenomicBoundary other); boolean isInBoundarie(int position); boolean isInBoundarie(int position, int margin); boolean isPartOfBoundary(GenomicBoundary other); boolean isOverlaping(GenomicBoundary other); V getAnnotation(); int getLength(boolean isInclusive); }### Answer:
@Test public void testGetStop() { GenomicBoundary instance = new GenomicBoundary("1", 1, 2); int expResult = 2; int result = instance.getStop(); assertEquals(result, expResult); } |
### Question:
GenomicBoundary implements Comparable<GenomicBoundary> { public boolean isInBoundarie(int position){ return isInBoundarie(position, 0); } GenomicBoundary(String chromosome, Integer start, int stop); GenomicBoundary(String chromosome, Integer start, int stop, V annotation); String getChromosome(); Integer getStart(); int getStop(); @Override int compareTo(GenomicBoundary other); boolean isInBoundarie(int position); boolean isInBoundarie(int position, int margin); boolean isPartOfBoundary(GenomicBoundary other); boolean isOverlaping(GenomicBoundary other); V getAnnotation(); int getLength(boolean isInclusive); }### Answer:
@Test public void testIsInBoundarie_int() { int position = 1; GenomicBoundary instance = new GenomicBoundary("1", 1, 2); boolean expResult = true; boolean result = instance.isInBoundarie(position); assertEquals(result, expResult); position = 2; expResult = true; result = instance.isInBoundarie(position); assertEquals(result, expResult); position = 3; expResult = false; result = instance.isInBoundarie(position); assertEquals(result, expResult); position = 0; expResult = false; result = instance.isInBoundarie(position); assertEquals(result, expResult); }
@Test public void testIsInBoundarie_int_int() { int margin = 2; GenomicBoundary instance= new GenomicBoundary("1", 10, 12); int position = 7; boolean expResult = false; boolean result = instance.isInBoundarie(position, margin); assertEquals(result, expResult); position = 8; expResult = true; result = instance.isInBoundarie(position, margin); assertEquals(result, expResult); position = 9; expResult = true; result = instance.isInBoundarie(position, margin); assertEquals(result, expResult); position = 14; expResult = true; result = instance.isInBoundarie(position, margin); assertEquals(result, expResult); position = 15; expResult = false; result = instance.isInBoundarie(position, margin); assertEquals(result, expResult); } |
### Question:
TriTyperGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<String> getSeqNames() { return new ArrayList<String>(sequences.keySet()); } TriTyperGenotypeData(String location); TriTyperGenotypeData(String location, int cacheSize); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter); TriTyperGenotypeData(File genotypeDataFile, File imputedDosageDataFile, File snpFile, File snpMapFile, File individualFile, File phenotypeAnnotationFile, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter, File allelRecoding); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override List<Sample> getSamples(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override void close(); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override Iterator<GeneticVariant> iterator(); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void getSeqNames() { List<String> seqNames = genotypeData.getSeqNames(); assertNotNull(seqNames); assertEquals(seqNames.size(), 2); assertEquals(seqNames.get(0), "22"); assertEquals(seqNames.get(1), "23"); } |
### Question:
GenomicBoundary implements Comparable<GenomicBoundary> { public boolean isPartOfBoundary(GenomicBoundary other){ if(other == null){ return false; } return other.start <= this.start && other.stop >= this.stop ? true : false; } GenomicBoundary(String chromosome, Integer start, int stop); GenomicBoundary(String chromosome, Integer start, int stop, V annotation); String getChromosome(); Integer getStart(); int getStop(); @Override int compareTo(GenomicBoundary other); boolean isInBoundarie(int position); boolean isInBoundarie(int position, int margin); boolean isPartOfBoundary(GenomicBoundary other); boolean isOverlaping(GenomicBoundary other); V getAnnotation(); int getLength(boolean isInclusive); }### Answer:
@Test public void testIsPartOfBoundary() { GenomicBoundary other = new GenomicBoundary("1", 1, 5); GenomicBoundary instance = new GenomicBoundary("1", 1, 5); boolean expResult = true; boolean result = instance.isPartOfBoundary(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 1, 6); expResult = true; result = instance.isPartOfBoundary(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 1, 4); expResult = false; result = instance.isPartOfBoundary(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 2, 6); expResult = false; result = instance.isPartOfBoundary(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 2, 7); expResult = false; result = instance.isPartOfBoundary(other); assertEquals(result, expResult); } |
### Question:
GenomicBoundary implements Comparable<GenomicBoundary> { public boolean isOverlaping(GenomicBoundary other){ if(other == null){ return false; } if( ! this.chromosome.equals(other.chromosome)){ return false; } if(this.start <= other.start && this.stop >= other.start){ return true; } else if(other.start <= this.start && other.stop >= this.start){ return true; } else { return false; } } GenomicBoundary(String chromosome, Integer start, int stop); GenomicBoundary(String chromosome, Integer start, int stop, V annotation); String getChromosome(); Integer getStart(); int getStop(); @Override int compareTo(GenomicBoundary other); boolean isInBoundarie(int position); boolean isInBoundarie(int position, int margin); boolean isPartOfBoundary(GenomicBoundary other); boolean isOverlaping(GenomicBoundary other); V getAnnotation(); int getLength(boolean isInclusive); }### Answer:
@Test public void isOverlaping() { GenomicBoundary other = new GenomicBoundary("1", 3, 5); GenomicBoundary instance = new GenomicBoundary("1", 3, 5); boolean expResult = true; boolean result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 1, 6); expResult = true; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 1, 4); expResult = true; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 2, 6); expResult = true; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 2, 7); expResult = true; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 5, 7); expResult = true; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 6, 7); expResult = false; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 7, 7); expResult = false; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 7, 8); expResult = false; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 2, 3); expResult = true; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 1, 2); expResult = false; result = instance.isOverlaping(other); assertEquals(result, expResult); other = new GenomicBoundary("1", 1, 1); expResult = false; result = instance.isOverlaping(other); assertEquals(result, expResult); } |
### Question:
PileupEntry { public String getChr() { return chr; } PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, int minimumBaseQuality); PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, String basesQualityString, int minimumBaseQuality); String getChr(); int getPos(); Allele getRefAllele(); int getReadDepth(); TObjectIntHashMap<Allele> getAlleleCounts(); int getAlleleCount(Allele allele); TObjectDoubleHashMap<Allele> getAlleleAverageQualities(); double getAlleleAverageQuality(Allele allele); int getMinimumBaseQuality(); }### Answer:
@Test public void testGetChr() { assertEquals(entry1.getChr(), "1"); } |
### Question:
PileupEntry { public int getPos() { return pos; } PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, int minimumBaseQuality); PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, String basesQualityString, int minimumBaseQuality); String getChr(); int getPos(); Allele getRefAllele(); int getReadDepth(); TObjectIntHashMap<Allele> getAlleleCounts(); int getAlleleCount(Allele allele); TObjectDoubleHashMap<Allele> getAlleleAverageQualities(); double getAlleleAverageQuality(Allele allele); int getMinimumBaseQuality(); }### Answer:
@Test public void testGetPos() { assertEquals(entry1.getPos(), 1); } |
### Question:
PileupEntry { public Allele getRefAllele() { return refAllele; } PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, int minimumBaseQuality); PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, String basesQualityString, int minimumBaseQuality); String getChr(); int getPos(); Allele getRefAllele(); int getReadDepth(); TObjectIntHashMap<Allele> getAlleleCounts(); int getAlleleCount(Allele allele); TObjectDoubleHashMap<Allele> getAlleleAverageQualities(); double getAlleleAverageQuality(Allele allele); int getMinimumBaseQuality(); }### Answer:
@Test public void testGetRefAllele() { assertEquals(entry1.getRefAllele(), Allele.G); } |
### Question:
PileupEntry { public int getReadDepth() { return readDepth; } PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, int minimumBaseQuality); PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, String basesQualityString, int minimumBaseQuality); String getChr(); int getPos(); Allele getRefAllele(); int getReadDepth(); TObjectIntHashMap<Allele> getAlleleCounts(); int getAlleleCount(Allele allele); TObjectDoubleHashMap<Allele> getAlleleAverageQualities(); double getAlleleAverageQuality(Allele allele); int getMinimumBaseQuality(); }### Answer:
@Test public void testGetReadDepth() { assertEquals(entry1.getReadDepth(), 10); } |
### Question:
PileupEntry { public TObjectIntHashMap<Allele> getAlleleCounts() { return alleleCounts; } PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, int minimumBaseQuality); PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, String basesQualityString, int minimumBaseQuality); String getChr(); int getPos(); Allele getRefAllele(); int getReadDepth(); TObjectIntHashMap<Allele> getAlleleCounts(); int getAlleleCount(Allele allele); TObjectDoubleHashMap<Allele> getAlleleAverageQualities(); double getAlleleAverageQuality(Allele allele); int getMinimumBaseQuality(); }### Answer:
@Test public void testGetAlleleCounts() { assertEquals(entry1.getAlleleCounts().get(Allele.A), 1); assertEquals(entry1.getAlleleCounts().get(Allele.C), 0); assertEquals(entry1.getAlleleCounts().get(Allele.G), 11); assertEquals(entry1.getAlleleCounts().get(Allele.T), 0); assertEquals(entry2.getAlleleCounts().get(Allele.A), 0); assertEquals(entry2.getAlleleCounts().get(Allele.C), 0); assertEquals(entry2.getAlleleCounts().get(Allele.G), 13); assertEquals(entry2.getAlleleCounts().get(Allele.T), 0); assertEquals(entry3.getAlleleCounts().get(Allele.A), 9); assertEquals(entry3.getAlleleCounts().get(Allele.C), 0); assertEquals(entry3.getAlleleCounts().get(Allele.G), 2); assertEquals(entry3.getAlleleCounts().get(Allele.T), 0); assertEquals(entry4.getAlleleCounts().get(Allele.A), 4); assertEquals(entry4.getAlleleCounts().get(Allele.C), 2); assertEquals(entry4.getAlleleCounts().get(Allele.G), 2); assertEquals(entry4.getAlleleCounts().get(Allele.T), 2); assertEquals(entry5.getAlleleCount(Allele.A), 9); assertEquals(entry5.getAlleleCount(Allele.C), 0); assertEquals(entry5.getAlleleCount(Allele.G), 2); assertEquals(entry5.getAlleleCount(Allele.T), 0); assertEquals(entry6.getAlleleCount(Allele.A), 2); assertEquals(entry6.getAlleleCount(Allele.C), 0); assertEquals(entry6.getAlleleCount(Allele.G), 0); assertEquals(entry6.getAlleleCount(Allele.T), 0); } |
### Question:
PileupEntry { public double getAlleleAverageQuality(Allele allele) { return alleleAverageQualities.get(allele); } PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, int minimumBaseQuality); PileupEntry(String chr, int pos, Allele refAllele, int readDepth, String basesString, String basesQualityString, int minimumBaseQuality); String getChr(); int getPos(); Allele getRefAllele(); int getReadDepth(); TObjectIntHashMap<Allele> getAlleleCounts(); int getAlleleCount(Allele allele); TObjectDoubleHashMap<Allele> getAlleleAverageQualities(); double getAlleleAverageQuality(Allele allele); int getMinimumBaseQuality(); }### Answer:
@Test public void testGetAlleleAverageQuality(){ assertTrue(Double.isNaN(entry1.getAlleleAverageQuality(Allele.A))); assertTrue(Double.isNaN(entry1.getAlleleAverageQuality(Allele.C))); assertTrue(Double.isNaN(entry1.getAlleleAverageQuality(Allele.G))); assertTrue(Double.isNaN(entry1.getAlleleAverageQuality(Allele.T))); assertEquals(entry5.getAlleleAverageQuality(Allele.A), 25d); assertTrue(Double.isNaN(entry5.getAlleleAverageQuality(Allele.C))); assertEquals(entry5.getAlleleAverageQuality(Allele.G), 27d); assertTrue(Double.isNaN(entry5.getAlleleAverageQuality(Allele.T))); assertEquals(entry6.getAlleleAverageQuality(Allele.A), 2.5); assertTrue(Double.isNaN(entry6.getAlleleAverageQuality(Allele.C))); assertTrue(Double.isNaN(entry6.getAlleleAverageQuality(Allele.G))); assertTrue(Double.isNaN(entry6.getAlleleAverageQuality(Allele.T))); } |
### Question:
BedGraphFile implements Iterable<BedGraphEntry> { public PerChrIntervalTree<BedGraphEntry> createIntervalTree() throws Exception{ return PerChrIntervalTree.createFromChrGroupedIterable(this, BedGraphEntry.class); } BedGraphFile(String bedGraphFilePath); BedGraphFile(String bedGraphFilePath, boolean omitChr, boolean makeOneBased); BedGraphFile(File bedGraphFile); BedGraphFile(File bedGraphFile, boolean omitChr, boolean makeOneBased); @Override Iterator<BedGraphEntry> iterator(); PerChrIntervalTree<BedGraphEntry> createIntervalTree(); }### Answer:
@Test public void testCreateIntervalTree() throws Exception { BedGraphFile testBedGraphFile = new BedGraphFile(new File(this.getClass().getResource("/wgEncodeCrgMapabilityAlign50mer.bedGraph").toURI()), true, true); PerChrIntervalTree<BedGraphEntry> bedGraphIntervalTree = testBedGraphFile.createIntervalTree(); testIntervalForMapability(bedGraphIntervalTree.searchPosition("1", 10001), 0.00172712); testIntervalForMapability(bedGraphIntervalTree.searchPosition("1", 10062), 0.00172712); testIntervalForMapability(bedGraphIntervalTree.searchPosition("1", 10064), 0.00172712); testIntervalForMapability(bedGraphIntervalTree.searchPosition("1", 10102), 0.0769231); testIntervalForMapability(bedGraphIntervalTree.searchPosition("1", 10102), 0.0769231); testIntervalForMapability(bedGraphIntervalTree.searchPosition("1", 10102), 0.0769231); testIntervalForMapability(bedGraphIntervalTree.searchPosition("2", 1), 0.0384615); testIntervalForMapability(bedGraphIntervalTree.searchPosition("2", 2), 0.0384615); testIntervalForMapability(bedGraphIntervalTree.searchPosition("2", 10), 0.0384615); testIntervalForMapability(bedGraphIntervalTree.searchPosition("2", 10108), 0.047619); testIntervalForMapability(bedGraphIntervalTree.searchPosition("2", 10121), 0.047619); assertTrue(bedGraphIntervalTree.searchPosition("1", 10000).isEmpty()); assertTrue(bedGraphIntervalTree.searchPosition("1", 10103).isEmpty()); assertTrue(bedGraphIntervalTree.searchPosition("2", 0).isEmpty()); assertTrue(bedGraphIntervalTree.searchPosition("2", 11).isEmpty()); assertTrue(bedGraphIntervalTree.searchPosition("3", 1).isEmpty()); } |
### Question:
TriTyperGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public Iterable<Sequence> getSequences() { return sequences.values(); } TriTyperGenotypeData(String location); TriTyperGenotypeData(String location, int cacheSize); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter); TriTyperGenotypeData(File genotypeDataFile, File imputedDosageDataFile, File snpFile, File snpMapFile, File individualFile, File phenotypeAnnotationFile, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter, File allelRecoding); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override List<Sample> getSamples(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override void close(); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override Iterator<GeneticVariant> iterator(); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSequences() { Iterable<Sequence> sequences = genotypeData.getSequences(); assertNotNull(sequences); int count = 0; for(Sequence s : sequences){ ++count; } assertEquals(count, 2); } |
### Question:
ZScores { public static double zToP(double z) { double p; if (z > 0) { p = NORM_DIST.cumulative(-z); } else { p = NORM_DIST.cumulative(z); } if (p > 0.5) { p = 1 - p; } p *= 2.0d; return p; } static double zToR(double z, int n); static double getWeightedZ(float[] zScores, int[] sampleSizes); static double getWeightedZ(double[] zScores, int[] sampleSizes); static double getWeightedZ(float[] zScores, int[] sampleSizes, double[] weights); static double getDatasetSizeWeightedZ(float[] zScores, int[] sampleSizes, double[] weights); static double getWeightedZ(double[] zScores, int[] sampleSizes, double[] weights); static double zToP(double z); static double pToZ(double p); static double pToZTwoTailed(double p); static double correlationToZ(double correlation, int nrSamples, StudentT tDist); static double correlationToP(double correlation, int nrSamples, StudentT tDist); static double zScoreToCorrelation(double obsZ, int nrSamples); static double extrapolateZScore(int originalSampleSize, int newSampleSize, double originalZ); static double betaToZ(double b, double se, double n); static double[] zToBeta(double z, double maf, int n); }### Answer:
@Test public void testZToP() { assertEquals(ZScores.zToP(10), 1.523971e-23, 0.00000001); assertEquals(ZScores.zToP(-10), 1.523971e-23, 0.00000001); assertEquals(ZScores.zToP(0), 1, 0.00000001); assertEquals(ZScores.zToP(2), 0.04550026, 0.00000001); assertEquals(ZScores.zToP(-2), 0.04550026, 0.00000001); } |
### Question:
ZScores { public static double pToZTwoTailed(double p) { p = p / 2; return pToZ(p); } static double zToR(double z, int n); static double getWeightedZ(float[] zScores, int[] sampleSizes); static double getWeightedZ(double[] zScores, int[] sampleSizes); static double getWeightedZ(float[] zScores, int[] sampleSizes, double[] weights); static double getDatasetSizeWeightedZ(float[] zScores, int[] sampleSizes, double[] weights); static double getWeightedZ(double[] zScores, int[] sampleSizes, double[] weights); static double zToP(double z); static double pToZ(double p); static double pToZTwoTailed(double p); static double correlationToZ(double correlation, int nrSamples, StudentT tDist); static double correlationToP(double correlation, int nrSamples, StudentT tDist); static double zScoreToCorrelation(double obsZ, int nrSamples); static double extrapolateZScore(int originalSampleSize, int newSampleSize, double originalZ); static double betaToZ(double b, double se, double n); static double[] zToBeta(double z, double maf, int n); }### Answer:
@Test public void pToZTwoTailed() { assertEquals(ZScores.pToZTwoTailed(0), -40, 0.00000001); assertEquals(ZScores.pToZTwoTailed(1), 0, 0.00000001); assertEquals(ZScores.pToZTwoTailed(1.523971e-23), -10, 0.00001); assertEquals(ZScores.pToZTwoTailed(1e-308), -37.55912122001427, 0.00001); assertEquals(ZScores.pToZTwoTailed(0.04550026), -2, 0.00001); } |
### Question:
Correlation { public static double correlateMeanCenteredData(double[] x, double[] y, double varX, double varY) { double covarianceInterim = 0; for (int i = 0; i < x.length; i++) { covarianceInterim += x[i] * y[i]; } return (covarianceInterim / (x.length - 1)) / Math.sqrt(varX * varY); } static double rankCorrelate(double[] x, double[] y); static void correlationToZScore(int maxNrSamples, int granularity); static void correlationToZScore(int maxNrSamples); static double correlateMeanCenteredData(double[] x, double[] y, double varX, double varY); static double correlateMeanCenteredData(double[] x, double[] y, double sdXsdY); static double correlate(double[] x, double[] y); static double correlate(double meanX, double meanY, double[] x, double[] y); static double covariate(double[] x, double[] y); static double covariate(double meanX, double meanY, double[] x, double[] y); static double convertCorrelationToZScore(int length, double correlation); static double correlate(double[] a1, double[] a2, double mean1, double mean2, double var1, double var2); static double correlate(DoubleMatrix1D x, DoubleMatrix1D y); static double[][] m_correlationToZScore; }### Answer:
@Test public void testCorrelateMeanCenteredData_3args() { System.out.println("correlateMeanCenteredData"); double[] x = new double[]{4.5, -0.5, -1.5, -2.5}; double[] y = new double[]{5,7,6,2}; double varX = 3.109126; double varY = 2.160247; double sdXsdY = varX * varY; double expResult = 0.2481458; double result = Correlation.correlateMeanCenteredData(x, y, sdXsdY); assertEquals(result, expResult, 0.000001); } |
### Question:
TriTyperGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Sample> getSamples() { return includedSamples; } TriTyperGenotypeData(String location); TriTyperGenotypeData(String location, int cacheSize); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter); TriTyperGenotypeData(File genotypeDataFile, File imputedDosageDataFile, File snpFile, File snpMapFile, File individualFile, File phenotypeAnnotationFile, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter, File allelRecoding); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override List<Sample> getSamples(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override void close(); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override Iterator<GeneticVariant> iterator(); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSamples() { List<Sample> samples = genotypeData.getSamples(); assertNotNull(samples); assertEquals(samples.size(), 9); assertEquals(samples.get(0).getId(), "F1042-1042"); assertNull(samples.get(0).getFamilyId()); } |
### Question:
IntervalTree { public ArrayList<E> getElementsOverlappingQuery(final int query) { final ArrayList<E> results = new ArrayList<E>(); rootNode.queryNode(results, query); return results; } IntervalTree(final E[] elements, Class<E> classE); IntervalTree(final List<E> elements, Class<E> classE); ArrayList<E> getElementsOverlappingQuery(final int query); int size(); boolean isEmpty(); }### Answer:
@Test public void testGetElementsOverlappingQuery() { ArrayList result = testIntervalTree.getElementsOverlappingQuery(0); assertEquals(result.size(), 2); assertTrue(result.contains(elements.get(0))); assertTrue(result.contains(elements.get(4))); result = testIntervalTree.getElementsOverlappingQuery(2); assertEquals(result.size(), 2); assertTrue(result.contains(elements.get(0))); assertTrue(result.contains(elements.get(4))); result = testIntervalTree.getElementsOverlappingQuery(5); assertEquals(result.size(), 4); assertTrue(result.contains(elements.get(0))); assertTrue(result.contains(elements.get(4))); assertTrue(result.contains(elements.get(1))); assertTrue(result.contains(elements.get(5))); result = testIntervalTree.getElementsOverlappingQuery(10); assertEquals(result.size(), 6); assertTrue(result.contains(elements.get(0))); assertTrue(result.contains(elements.get(4))); assertTrue(result.contains(elements.get(1))); assertTrue(result.contains(elements.get(5))); assertTrue(result.contains(elements.get(2))); assertTrue(result.contains(elements.get(3))); result = testIntervalTree.getElementsOverlappingQuery(11); assertEquals(result.size(), 2); assertTrue(result.contains(elements.get(4))); assertTrue(result.contains(elements.get(2))); result = testIntervalTree.getElementsOverlappingQuery(25); assertEquals(result.size(), 0); result = testIntervalTree.getElementsOverlappingQuery(20); assertEquals(result.size(), 1); assertTrue(result.contains(elements.get(4))); } |
### Question:
BinaryInteractionMetaAnalysis { protected static double weightedZscore(double[] zscores, int[] samples) throws MetaZscoreException { double numerator = 0; double denominator = 0; for (int i = 0; i < zscores.length; ++i) { if (samples[i] == 0) { continue; } else if (samples[i] < 0) { throw new MetaZscoreException(i, "Sample count < 0"); } else if (Double.isNaN(zscores[i])) { throw new MetaZscoreException(i, "Z-score = NaN"); } else if (Double.isInfinite(zscores[i])) { throw new MetaZscoreException(i, "Z-score = Inf"); } else { numerator += zscores[i] * samples[i]; denominator += samples[i] * samples[i]; } } if (denominator < 1) { return Double.NaN; } else { return numerator / Math.sqrt(denominator); } } static void main(String[] args); }### Answer:
@Test public void testweightedZscore1() throws Exception { double[] zscore = {2.3263479, 0.8416212, 0.5244005}; int[] samples = {1,1,1}; double expected = 2.13179059; double result = BinaryInteractionMetaAnalysis.weightedZscore(zscore, samples); assertEquals(result, expected, 0.0000001); }
@Test public void testweightedZscore2() throws Exception { double[] zscore = {2.3263479, 0.8416212, 0.5244005}; int[] samples = {10,1,1}; double expected = 2.438683939; double result = BinaryInteractionMetaAnalysis.weightedZscore(zscore, samples); assertEquals(result, expected, 0.0000001); }
@Test public void testweightedZscore3() throws Exception { double[] zscore = {2.3263479, 0.8416212, 0.5244005}; int[] samples = {10,1,0}; double expected = 2.39854709; double result = BinaryInteractionMetaAnalysis.weightedZscore(zscore, samples); assertEquals(result, expected, 0.0000001); }
@Test public void testweightedZscore4() throws Exception { double[] zscore = {2.3263479}; int[] samples = {10}; double expected = 2.3263479; double result = BinaryInteractionMetaAnalysis.weightedZscore(zscore, samples); assertEquals(result, expected, 0.0000001); } |
### Question:
AseMle { protected static double lnbico(final int n, final int k) { if (n < 0 || k < 0 || k > n) { throw new IllegalArgumentException("bad args in bico"); } if (n < 171) { return Math.log(Math.floor(0.5 + factrl(n) / (factrl(k) * factrl(n - k)))); } return factln(n) - factln(k) - factln(n - k); } AseMle(IntArrayList a1Counts, IntArrayList a2Counts); double getMaxLikelihood(); double getMaxLikelihoodP(); double getRatioD(); double getRatioP(); }### Answer:
@Test public void testLnBico() { assertEquals(AseMle.lnbico(1369, 689), 945.052036055064, 0.000001); assertEquals(AseMle.lnbico(12345, 6789), 8490.2927640914, 0.000001); assertEquals(AseMle.lnbico(123456, 67890), 84950.948114749, 0.000001); assertEquals(AseMle.lnbico(20, 10), 12.126791314602454, 0.000001); assertEquals(AseMle.lnbico(200, 10), 37.6501117434664266, 0.000001); } |
### Question:
TriTyperGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Boolean> getSamplePhasing(GeneticVariant variant) { return samplePhasing; } TriTyperGenotypeData(String location); TriTyperGenotypeData(String location, int cacheSize); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter); TriTyperGenotypeData(File genotypeDataFile, File imputedDosageDataFile, File snpFile, File snpMapFile, File individualFile, File phenotypeAnnotationFile, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter, File allelRecoding); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override List<Sample> getSamples(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override void close(); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override Iterator<GeneticVariant> iterator(); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSamplePhasing() { Iterable <GeneticVariant> variants = genotypeData.getVariantsByPos("22", 14431347); List<Boolean> phasing = genotypeData.getSamplePhasing(variants.iterator().next()); assertEquals(phasing, Arrays.asList(false, false, false, false, false, false, false, false, false)); } |
### Question:
TriTyperGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public Iterator<GeneticVariant> iterator() { return snps.iterator(); } TriTyperGenotypeData(String location); TriTyperGenotypeData(String location, int cacheSize); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter); TriTyperGenotypeData(String location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, boolean readOnlyIncludedIndividuals); TriTyperGenotypeData(File location, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter); TriTyperGenotypeData(File genotypeDataFile, File imputedDosageDataFile, File snpFile, File snpMapFile, File individualFile, File phenotypeAnnotationFile, int cacheSize, VariantFilter variantFilter, SampleFilter sampleFilter, File allelRecoding); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override List<Sample> getSamples(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override void close(); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<String> getSeqNames(); @Override Iterable<Sequence> getSequences(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override Iterator<GeneticVariant> iterator(); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testIterator() { int counter = 0; for(GeneticVariant variant : genotypeData){ if(variant.getPrimaryVariantId().equals("rs11089130")){ testFilteredRs11089130(variant); } ++counter; } assertEquals(counter, 10); } |
### Question:
ChromosomeComparator implements Comparator<String>, Serializable { @Override public int compare(String arg0, String arg1) { if (arg0.equals(arg1)) { return 0; } if (arg0.equals("MT")) { return 1; } if (arg1.equals("MT")) { return -1; } if (arg0.length() == 1) { if (arg1.length() == 1) { return arg0.charAt(0) - arg1.charAt(0); } else if (arg0.charAt(0) == 'X') { return 1; } else if (arg0.charAt(0) == 'Y') { return 1; } else { return -1; } } if (arg1.length() == 1) { if (arg1.charAt(0) == 'X') { return -1; } else if (arg1.charAt(0) == 'Y') { return -1; } else { return 1; } } return arg0.compareTo(arg1); } static boolean chrASmallerChrB(String chrA, String chrB); static boolean chrASmallerEqualChrB(String chrA, String chrB); static boolean chrALargerChrB(String chrA, String chrB); @Override int compare(String arg0, String arg1); static final ChromosomeComparator comparator; }### Answer:
@Test public void compare() { Comparator<String> testComparator = new ChromosomeComparator(); assertEquals(testComparator.compare("1", "2") < 0, true); assertEquals(testComparator.compare("1", "1") == 0, true); assertEquals(testComparator.compare("3", "1") > 0, true); assertEquals(testComparator.compare("3", "13") < 0, true); assertEquals(testComparator.compare("13", "3") > 0, true); assertEquals(testComparator.compare("9", "10") < 0, true); assertEquals(testComparator.compare("10", "11") < 0, true); assertEquals(testComparator.compare("9", "21") < 0, true); assertEquals(testComparator.compare("19", "20") < 0, true); assertEquals(testComparator.compare("22", "X") < 0, true); assertEquals(testComparator.compare("10", "X") < 0, true); assertEquals(testComparator.compare("1", "X") < 0, true); assertEquals(testComparator.compare("X", "5") > 0, true); assertEquals(testComparator.compare("5", "X") < 0, true); assertEquals(testComparator.compare("X", "13") > 0, true); assertEquals(testComparator.compare("13", "X") < 0, true); assertEquals(testComparator.compare("X", "X") == 0, true); assertEquals(testComparator.compare("Y", "X") > 0, true); assertEquals(testComparator.compare("MT", "X") > 0, true); assertEquals(testComparator.compare("X", "MT") < 0, true); assertEquals(testComparator.compare("MT", "Y") > 0, true); assertEquals(testComparator.compare("Y", "MT") < 0, true); assertEquals(testComparator.compare("MT", "1") > 0, true); assertEquals(testComparator.compare("1", "MT") < 0, true); assertEquals(testComparator.compare("MT", "10") > 0, true); assertEquals(testComparator.compare("10", "MT") < 0, true); assertEquals(testComparator.compare("22", "23") < 0, true); assertEquals(testComparator.compare("23", "22") > 0, true); } |
### Question:
ProbabilitiesConvertor { public static float[] convertProbabilitiesToDosage(float[][] probs, double minProbability) { float[] dosages = new float[probs.length]; for (int i = 0; i < probs.length; ++i) { boolean containsMinProbability = false; for (float prob : probs[i]) { if (prob >= minProbability) { containsMinProbability = true; break; } } if (containsMinProbability) { dosages[i] = (probs[i][0] * 2) + probs[i][1]; if (dosages[i] > 2) { dosages[i] = 2; } } else { dosages[i] = -1; } } return dosages; } static float[][] convertCalledAllelesToProbability(List<Alleles> sampleAlleles, Alleles alleles); static float[][] convertDosageToProbabilityHeuristic(float[] sampleDosages); static List<Alleles> convertProbabilitiesToAlleles(float[][] probs, Alleles variantAlleles, double minProbability); static float[] convertProbabilitiesToDosage(float[][] probs, double minProbability); static float[][] convertBiallelicComplexProbabilitiesToProbabilities(double[][] complexProbabilities); static double[][] convertProbabilitiesToComplexProbabilities(float[][] probabilities); static double[][] convertPhasedProbabilitiesToComplexProbabilities(double[][][] haplotypeProbabilities); static double[][][] haplotypeDosagesToHaplotypeProbabilities(double[][] haplotypeDosages); static double[][][] convertCalledAllelesToPhasedProbabilities(List<Alleles> sampleAlleles, Alleles alleles); static double[][] convertCalledAllelesToComplexProbabilities(
List<Alleles> allelesPerSample, Alleles variantAlleles); }### Answer:
@Test public void testConvertProbabilitiesToDosage() { System.out.println("convertProbabilitiesToAlleles"); float[][] probs = new float[8][3]; probs[0] = new float[]{1, 0, 0}; probs[1] = new float[]{1, 0, 0}; probs[2] = new float[]{0, 1, 0}; probs[3] = new float[]{0, 1, 0}; probs[4] = new float[]{0, 0, 1}; probs[5] = new float[]{0, 1, 0}; probs[6] = new float[]{0.3f, 0.3f, 0.3f}; probs[7] = new float[]{0.3f, 0.3f, 0.4f}; float[] expectedDosage = new float[]{2,2,1,1,0,1,-1,0.9f}; float[] dosage = ProbabilitiesConvertor.convertProbabilitiesToDosage(probs, 0.4); assertEquals(dosage, expectedDosage, 0.00001f, ""); } |
### Question:
ProbabilitiesConvertor { public static float[][] convertBiallelicComplexProbabilitiesToProbabilities(double[][] complexProbabilities) { float[][] probabilities = new float[complexProbabilities.length][3]; for (int sampleIndex = 0; sampleIndex < complexProbabilities.length; sampleIndex++) { double[] sampleProbabilitiesBgen = complexProbabilities[sampleIndex]; int probabilitiesArrayLength = sampleProbabilitiesBgen.length; float[] sampleProbabilities = new float[3]; if (probabilitiesArrayLength == 3) { IntStream.range(0, probabilitiesArrayLength) .forEach(index -> sampleProbabilities[index] = (float) sampleProbabilitiesBgen[index]); } probabilities[sampleIndex] = sampleProbabilities; } return probabilities; } static float[][] convertCalledAllelesToProbability(List<Alleles> sampleAlleles, Alleles alleles); static float[][] convertDosageToProbabilityHeuristic(float[] sampleDosages); static List<Alleles> convertProbabilitiesToAlleles(float[][] probs, Alleles variantAlleles, double minProbability); static float[] convertProbabilitiesToDosage(float[][] probs, double minProbability); static float[][] convertBiallelicComplexProbabilitiesToProbabilities(double[][] complexProbabilities); static double[][] convertProbabilitiesToComplexProbabilities(float[][] probabilities); static double[][] convertPhasedProbabilitiesToComplexProbabilities(double[][][] haplotypeProbabilities); static double[][][] haplotypeDosagesToHaplotypeProbabilities(double[][] haplotypeDosages); static double[][][] convertCalledAllelesToPhasedProbabilities(List<Alleles> sampleAlleles, Alleles alleles); static double[][] convertCalledAllelesToComplexProbabilities(
List<Alleles> allelesPerSample, Alleles variantAlleles); }### Answer:
@Test public void testBiallelicComplexProbabilitiesToProbabilities() { System.out.println("convertBiallelicComplexProbabilitiesToProbabilities"); double[][] probs = new double[6][]; probs[0] = new double[]{1, 0}; probs[1] = new double[]{1, 0, 0}; probs[2] = new double[]{0, 1, 0}; probs[3] = new double[]{0, 1, 0}; probs[4] = new double[]{0, 0, 1}; probs[5] = new double[]{1, 0, 0, 0}; float[][] expectedProbs = new float[6][]; expectedProbs[0] = new float[]{0, 0, 0}; expectedProbs[1] = new float[]{1, 0, 0}; expectedProbs[2] = new float[]{0, 1, 0}; expectedProbs[3] = new float[]{0, 1, 0}; expectedProbs[4] = new float[]{0, 0, 1}; expectedProbs[5] = new float[]{0, 0, 0}; float[][] actualProbabilities = ProbabilitiesConvertor .convertBiallelicComplexProbabilitiesToProbabilities(probs); for (int i = 0; i < actualProbabilities.length; i++) { float[] actualProbs = actualProbabilities[i]; assertEquals(actualProbs, expectedProbs[i]); } } |
### Question:
ProbabilitiesConvertor { public static double[][] convertProbabilitiesToComplexProbabilities(float[][] probabilities) { double[][] bgenProbabilities = new double[probabilities.length][probabilities[0].length]; for (int i = 0; i < probabilities.length; i++) { for (int j = 0; j < probabilities[0].length; j++) { bgenProbabilities[i][j] = probabilities[i][j]; } } return bgenProbabilities; } static float[][] convertCalledAllelesToProbability(List<Alleles> sampleAlleles, Alleles alleles); static float[][] convertDosageToProbabilityHeuristic(float[] sampleDosages); static List<Alleles> convertProbabilitiesToAlleles(float[][] probs, Alleles variantAlleles, double minProbability); static float[] convertProbabilitiesToDosage(float[][] probs, double minProbability); static float[][] convertBiallelicComplexProbabilitiesToProbabilities(double[][] complexProbabilities); static double[][] convertProbabilitiesToComplexProbabilities(float[][] probabilities); static double[][] convertPhasedProbabilitiesToComplexProbabilities(double[][][] haplotypeProbabilities); static double[][][] haplotypeDosagesToHaplotypeProbabilities(double[][] haplotypeDosages); static double[][][] convertCalledAllelesToPhasedProbabilities(List<Alleles> sampleAlleles, Alleles alleles); static double[][] convertCalledAllelesToComplexProbabilities(
List<Alleles> allelesPerSample, Alleles variantAlleles); }### Answer:
@Test public void testProbabilitiesToComplexProbabilities() { System.out.println("convertProbabilitiesToComplexProbabilities"); float[][] probs = new float[3][]; probs[0] = new float[]{0, 0, 1}; probs[1] = new float[]{1, 0, 0}; probs[2] = new float[]{0, 1, 0}; double[][] expectedProbs = new double[3][]; expectedProbs[0] = new double[]{0 ,0, 1}; expectedProbs[1] = new double[]{1, 0, 0}; expectedProbs[2] = new double[]{0, 1, 0}; double[][] actualProbabilities = ProbabilitiesConvertor .convertProbabilitiesToComplexProbabilities(probs); for (int i = 0; i < actualProbabilities.length; i++) { double[] actualProbs = actualProbabilities[i]; assertEquals(actualProbs, expectedProbs[i]); } } |
### Question:
ProbabilitiesConvertor { public static double[][][] convertCalledAllelesToPhasedProbabilities(List<Alleles> sampleAlleles, Alleles alleles) { double[][][] probs = new double[sampleAlleles.size()][][]; if (alleles.getAlleleCount() == 0) { throw new GenotypeDataException("Error converting alleles to probabilities. No alleles detected"); } for (int sampleIndex = 0; sampleIndex < sampleAlleles.size(); sampleIndex++) { Alleles allelesForSample = sampleAlleles.get(sampleIndex); int ploidy = allelesForSample.getAlleleCount(); double[][] sampleProbabilities = new double[ploidy][alleles.getAlleleCount()]; for (int i = 0; i < ploidy; i++) { Allele allele = allelesForSample.get(i); int indexOfSampleAllele = alleles.getAlleles().indexOf(allele); if (indexOfSampleAllele != -1) { sampleProbabilities[i][indexOfSampleAllele] = 1; } } probs[sampleIndex] = sampleProbabilities; } return probs; } static float[][] convertCalledAllelesToProbability(List<Alleles> sampleAlleles, Alleles alleles); static float[][] convertDosageToProbabilityHeuristic(float[] sampleDosages); static List<Alleles> convertProbabilitiesToAlleles(float[][] probs, Alleles variantAlleles, double minProbability); static float[] convertProbabilitiesToDosage(float[][] probs, double minProbability); static float[][] convertBiallelicComplexProbabilitiesToProbabilities(double[][] complexProbabilities); static double[][] convertProbabilitiesToComplexProbabilities(float[][] probabilities); static double[][] convertPhasedProbabilitiesToComplexProbabilities(double[][][] haplotypeProbabilities); static double[][][] haplotypeDosagesToHaplotypeProbabilities(double[][] haplotypeDosages); static double[][][] convertCalledAllelesToPhasedProbabilities(List<Alleles> sampleAlleles, Alleles alleles); static double[][] convertCalledAllelesToComplexProbabilities(
List<Alleles> allelesPerSample, Alleles variantAlleles); }### Answer:
@Test public void testCalledAllelesToPhasedProbabilities() { System.out.println("convertCalledAllelesToPhasedProbabilities"); double[][][] expectedProbs = new double[4][][]; expectedProbs[0] = new double[][]{{0, 1},{0, 1}}; expectedProbs[1] = new double[][]{{1, 0},{1, 0}}; expectedProbs[2] = new double[][]{{1, 0},{0, 1}}; expectedProbs[3] = new double[][]{{0, 1},{1, 0}}; List<Alleles> sampleAlleles = Arrays.asList( Alleles.createAlleles(Allele.G, Allele.G), Alleles.createAlleles(Allele.A, Allele.A), Alleles.createAlleles(Allele.A, Allele.G), Alleles.createAlleles(Allele.G, Allele.A)); Alleles alleles = Alleles.createAlleles(Allele.A, Allele.G); double[][][] actualProbs = ProbabilitiesConvertor .convertCalledAllelesToPhasedProbabilities( sampleAlleles, alleles); assertEquals(actualProbs, expectedProbs); } |
### Question:
GenotypeDataCompareTool { public static boolean same(GenotypeData gd1, GenotypeData gd2) { if (gd1.getSamples().equals(gd2.getSamples())) { if (gd1.getVariantAnnotations().equals(gd2.getVariantAnnotations())) { Iterator<GeneticVariant> it1 = gd1.iterator(); Iterator<GeneticVariant> it2 = gd2.iterator(); while (it1.hasNext()) { if (!it2.hasNext()) { return false; } GeneticVariant v1 = it1.next(); GeneticVariant v2 = it2.next(); if (!same(v1, v2)) { return false; } } if (it2.hasNext()) { return false; } else { return true; } } } return false; } static boolean same(GenotypeData gd1, GenotypeData gd2); static boolean same(GeneticVariant v1, GeneticVariant v2); }### Answer:
@Test public void testPedMap() throws FileNotFoundException, IOException, URISyntaxException { try { GenotypeData genotypeData1 = new PedMapGenotypeData(getTestPed(), getTestMap()); new PedMapGenotypeWriter(genotypeData1).write("pedmapcomparetest"); GenotypeData genotypeData2 = new PedMapGenotypeData("pedmapcomparetest"); assertTrue(GenotypeDataCompareTool.same(genotypeData1, genotypeData2)); } finally { new File("pedmapcomparetest.ped").delete(); new File("pedmapcomparetest.map").delete(); } } |
### Question:
Utils { public static <T> List<T> iteratorToList(Iterator<T> iterator) { List<T> result = new ArrayList<T>(); while (iterator.hasNext()) { result.add(iterator.next()); } return result; } static List<T> iteratorToList(Iterator<T> iterator); static boolean isSnp(List<String> alleles); static char getComplementNucleotide(char allele); static void createEmptyFile(File file, String fileName); static final Map<Character, Character> COMPLEMENTAL_NUCLEOTIDES; }### Answer:
@Test public void iteratorToList() { List<String> list = Arrays.asList("1", "2", null); assertEquals(Utils.iteratorToList(list.iterator()), list); } |
### Question:
GenGenotypeWriter implements GenotypeWriter { @Override public void write(String basePath) throws IOException { if (!genotypeData.isOnlyContaingSaveProbabilityGenotypes()) { LOGGER.warn("WARNING!!! writing dosage genotype data to .gen posterior probabilities file. Using heuristic method to convert to probabilities, this is not guaranteed to be accurate. See manual for more details."); } write(new File(basePath + ".gen"), new File(basePath + ".sample")); } GenGenotypeWriter(GenotypeData genotypeData); @Override void write(String basePath); void write(File genFile, File sampleFile); static final Charset FILE_ENCODING; static final char LINE_ENDING; }### Answer:
@Test public void write() throws IOException, URISyntaxException { writer.write(tmpOutputFolder.getAbsolutePath() + fileSep + "test"); GenotypeData genotypeDataWritten = RandomAccessGenotypeDataReaderFormats.GEN.createGenotypeData(tmpOutputFolder.getAbsolutePath() + fileSep + "test", 0); assertTrue(GenotypeDataCompareTool.same(genotypeData, genotypeDataWritten)); } |
### Question:
HapsGenotypeWriter implements GenotypeWriter { @Override public void write(String basePath) throws IOException { write(new File(basePath + ".haps"), new File(basePath + ".sample")); } HapsGenotypeWriter(GenotypeData genotypeData); @Override void write(String basePath); void write(File hapsFile, File sampleFile); static final Charset FILE_ENCODING; static final char LINE_ENDING; }### Answer:
@Test public void write() throws IOException, URISyntaxException { writer.write(tmpOutputFolder.getAbsolutePath() + fileSep + "test"); GenotypeData genotypeDataWritten = RandomAccessGenotypeDataReaderFormats.SHAPEIT2.createGenotypeData(tmpOutputFolder.getAbsolutePath() + fileSep + "test", 0); assertTrue(GenotypeDataCompareTool.same(genotypeData, genotypeDataWritten)); assertEquals(genotypeData.getSamples().get(0).getMissingRate(), 0.25, 0.000001); assertEquals(genotypeData.getSamples().get(1).getMissingRate(), 0, 0.000001); assertEquals(genotypeData.getSamples().get(2).getMissingRate(), 0, 0.000001); assertEquals(genotypeData.getSamples().get(3).getMissingRate(), 0, 0.000001); assertEquals(genotypeData.getSamples().get(0).getAnnotationValues().get("bin1"), Boolean.TRUE); assertEquals(genotypeData.getSamples().get(1).getAnnotationValues().get("bin1"), Boolean.FALSE); assertEquals(genotypeData.getSamples().get(2).getAnnotationValues().get("bin1"), Boolean.TRUE); assertEquals(genotypeData.getSamples().get(3).getAnnotationValues().get("bin1"), Boolean.TRUE); genotypeData.close(); } |
### Question:
GenGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Sequence> getSequences() { List<Sequence> sequences = new ArrayList<Sequence>(); for (String seqName : getSeqNames()) { sequences.add(new SimpleSequence(seqName, null, this)); } return sequences; } GenGenotypeData(String path); GenGenotypeData(String path, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile); GenGenotypeData(File genFile, File sampleFile, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, int cacheSize); GenGenotypeData(File genFile, File sampleFile, int cacheSize, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, String forceSeqName); GenGenotypeData(File genFile, File sampleFile, int cacheSize, String forceSeqName, double minimumPosteriorProbabilityToCall); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSequences() { List<Sequence> sequences = genotypeData.getSequences(); assertNotNull(sequences); assertEquals(sequences.size(), 3); } |
### Question:
GenGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Sample> getSamples() { return Collections.unmodifiableList(samples); } GenGenotypeData(String path); GenGenotypeData(String path, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile); GenGenotypeData(File genFile, File sampleFile, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, int cacheSize); GenGenotypeData(File genFile, File sampleFile, int cacheSize, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, String forceSeqName); GenGenotypeData(File genFile, File sampleFile, int cacheSize, String forceSeqName, double minimumPosteriorProbabilityToCall); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSamples() { List<Sample> samples = genotypeData.getSamples(); assertNotNull(samples); assertEquals(samples.size(), 9); assertEquals(samples.get(0).getId(), "1042"); assertEquals(samples.get(0).getFamilyId(), "F1042"); assertEquals(samples.get(8).getMissingRate(), 0.1f); assertEquals(samples.get(0).getMissingRate(), 0f); assertEquals((Float) samples.get(0).getAnnotationValues().get("phenotype"), 0f); assertEquals((Float) samples.get(1).getAnnotationValues().get("phenotype"), 1f); assertEquals((Float) samples.get(2).getAnnotationValues().get("phenotype"), 2f); assertTrue(Float.isNaN((Float) samples.get(3).getAnnotationValues().get("phenotype"))); } |
### Question:
GenGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public Map<String, SampleAnnotation> getSampleAnnotationsMap() { return sampleAnnotations; } GenGenotypeData(String path); GenGenotypeData(String path, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile); GenGenotypeData(File genFile, File sampleFile, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, int cacheSize); GenGenotypeData(File genFile, File sampleFile, int cacheSize, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, String forceSeqName); GenGenotypeData(File genFile, File sampleFile, int cacheSize, String forceSeqName, double minimumPosteriorProbabilityToCall); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSampleAnnotationsMap() { Map<String, SampleAnnotation> annotationMap = genotypeData.getSampleAnnotationsMap(); int i = 0; for(Map.Entry<String, SampleAnnotation> annotation : annotationMap.entrySet()){ switch(i){ case 0: assertEquals(annotation.getKey(), GenotypeData.SAMPLE_MISSING_RATE_FLOAT); assertEquals(annotation.getValue().getName(), "missing"); assertEquals(annotation.getValue().getSampleAnnotationType(), SampleAnnotation.SampleAnnotationType.OTHER); assertEquals(annotation.getValue().getType(), Annotation.Type.FLOAT); assertFalse(annotation.getValue().isList()); break; case 1: assertEquals(annotation.getKey(), "sex"); assertEquals(annotation.getValue().getName(), "sex"); assertEquals(annotation.getValue().getSampleAnnotationType(), SampleAnnotation.SampleAnnotationType.COVARIATE); assertEquals(annotation.getValue().getType(), Annotation.Type.STRING); assertFalse(annotation.getValue().isList()); break; case 2: assertEquals(annotation.getKey(), "phenotype"); assertEquals(annotation.getValue().getName(), "phenotype"); assertEquals(annotation.getValue().getSampleAnnotationType(), SampleAnnotation.SampleAnnotationType.PHENOTYPE); assertEquals(annotation.getValue().getType(), Annotation.Type.FLOAT); assertFalse(annotation.getValue().isList()); break; default: fail("Error expected only 3 annotations"); } ++i; } } |
### Question:
GenGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Boolean> getSamplePhasing(GeneticVariant variant) { return phasing; } GenGenotypeData(String path); GenGenotypeData(String path, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile); GenGenotypeData(File genFile, File sampleFile, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, int cacheSize); GenGenotypeData(File genFile, File sampleFile, int cacheSize, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, String forceSeqName); GenGenotypeData(File genFile, File sampleFile, int cacheSize, String forceSeqName, double minimumPosteriorProbabilityToCall); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSamplePhasing() { Iterable<GeneticVariant> variants = genotypeData.getVariantsByPos("22", 14431347); int counted = 0; for (GeneticVariant variant : variants) { assertEquals(variant.getSamplePhasing(), Arrays.asList(false, false, false, false, false, false, false, false, false)); ++counted; } assertEquals(counted, 1); } |
### Question:
GenGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<String> getSeqNames() { return new ArrayList<String>(sequenceNames); } GenGenotypeData(String path); GenGenotypeData(String path, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile); GenGenotypeData(File genFile, File sampleFile, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, int cacheSize); GenGenotypeData(File genFile, File sampleFile, int cacheSize, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, String forceSeqName); GenGenotypeData(File genFile, File sampleFile, int cacheSize, String forceSeqName, double minimumPosteriorProbabilityToCall); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testGetSeqNames() { List<String> seqNames = genotypeData.getSeqNames(); assertNotNull(seqNames); assertEquals(seqNames.size(), 3); assertEquals(seqNames.get(0), "22"); assertEquals(seqNames.get(1), "23"); assertEquals(seqNames.get(2), "1"); } |
### Question:
GenGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public boolean isOnlyContaingSaveProbabilityGenotypes() { return true; } GenGenotypeData(String path); GenGenotypeData(String path, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile); GenGenotypeData(File genFile, File sampleFile, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, int cacheSize); GenGenotypeData(File genFile, File sampleFile, int cacheSize, double minimumPosteriorProbabilityToCall); GenGenotypeData(File genFile, File sampleFile, String forceSeqName); GenGenotypeData(File genFile, File sampleFile, int cacheSize, String forceSeqName, double minimumPosteriorProbabilityToCall); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override List<Alleles> getSampleVariants(GeneticVariant variant); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void testIsOnlyContaingSaveProbabilityGenotypes() { assertTrue(genotypeData.isOnlyContaingSaveProbabilityGenotypes()); } |
### Question:
HapsGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<String> getSeqNames() { return new ArrayList<String>(sequenceNames); } HapsGenotypeData(String path); HapsGenotypeData(File hapsFile, File sampleFile); HapsGenotypeData(File hapsFile, File sampleFile, int cacheSize); HapsGenotypeData(File hapsFile, File sampleFile, String forceSeqName); HapsGenotypeData(File hapsFile, File sampleFile, int cacheSize, String forceSeqName); @Override Iterable<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override synchronized List<Alleles> getSampleVariants(GeneticVariant variant); @Override synchronized List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void getSeqNames() { List<String> seqNames = genotypeData.getSeqNames(); assertNotNull(seqNames); assertEquals(seqNames, Arrays.asList("7", "8")); } |
### Question:
HapsGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public Iterator<GeneticVariant> iterator() { return variants.iterator(); } HapsGenotypeData(String path); HapsGenotypeData(File hapsFile, File sampleFile); HapsGenotypeData(File hapsFile, File sampleFile, int cacheSize); HapsGenotypeData(File hapsFile, File sampleFile, String forceSeqName); HapsGenotypeData(File hapsFile, File sampleFile, int cacheSize, String forceSeqName); @Override Iterable<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override synchronized List<Alleles> getSampleVariants(GeneticVariant variant); @Override synchronized List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void iterator() { Iterator<GeneticVariant> it = genotypeData.iterator(); assertNotNull(it); GeneticVariant var = it.next(); assertNotNull(var); assertEquals(var.getPrimaryVariantId(), "SNP1"); assertEquals(var.getSequenceName(), "7"); assertEquals(var.getStartPos(), 123); assertEquals(var.getAlleleCount(), 2); assertEquals(var.getAllIds(), Arrays.asList("SNP1")); assertEquals(var.getVariantAlleles(), Alleles.createBasedOnChars('A', 'G')); assertEquals( var.getSampleVariants(), Arrays.asList(Alleles.createBasedOnChars('A', 'A'), Alleles.createBasedOnChars('G', 'A'), Alleles.createBasedOnChars('A', 'A'), Alleles.createBasedOnChars('G', 'G'))); assertEquals(var.getMinorAllele(), Allele.G); assertEquals(var.getMinorAlleleFrequency(), 0.375, 0.001); assertEquals(Utils.iteratorToList(genotypeData.iterator()).size(), 4); } |
### Question:
HapsGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Sample> getSamples() { return Collections.unmodifiableList(samples); } HapsGenotypeData(String path); HapsGenotypeData(File hapsFile, File sampleFile); HapsGenotypeData(File hapsFile, File sampleFile, int cacheSize); HapsGenotypeData(File hapsFile, File sampleFile, String forceSeqName); HapsGenotypeData(File hapsFile, File sampleFile, int cacheSize, String forceSeqName); @Override Iterable<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override synchronized List<Alleles> getSampleVariants(GeneticVariant variant); @Override synchronized List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void getSamples() { List<Sample> samples = genotypeData.getSamples(); assertEquals(samples.size(), 4); Sample sample = samples.get(0); assertEquals(sample.getId(), "1"); assertEquals(sample.getFamilyId(), "1"); Map<String, ?> annotations = sample.getAnnotationValues(); assertEquals(annotations.size(), 7); assertEquals((Float) annotations.get(GenotypeData.SAMPLE_MISSING_RATE_FLOAT), 0.25f, 0.0001); assertEquals(annotations.get("cov_1"), "1"); assertEquals(annotations.get("cov_2"), "2"); assertEquals((Float) annotations.get("cov_3"), 0.0019f, 0.00001); assertTrue(Float.isNaN((Float) annotations.get("cov_4"))); assertEquals((Float) annotations.get("pheno1"), 1.233f, 0.0001); assertEquals(annotations.get("bin1"), true); } |
### Question:
HapsGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName) { return variants.getVariantsBySequence(seqName); } HapsGenotypeData(String path); HapsGenotypeData(File hapsFile, File sampleFile); HapsGenotypeData(File hapsFile, File sampleFile, int cacheSize); HapsGenotypeData(File hapsFile, File sampleFile, String forceSeqName); HapsGenotypeData(File hapsFile, File sampleFile, int cacheSize, String forceSeqName); @Override Iterable<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override synchronized List<Alleles> getSampleVariants(GeneticVariant variant); @Override synchronized List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int cacheSize(); @Override int getSampleVariantProviderUniqueId(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override Iterator<GeneticVariant> iterator(); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getVariantsByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByRange(String seqName, int rangeStart, int rangeEnd); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); }### Answer:
@Test public void getSequenceGeneticVariants() { Iterator<GeneticVariant> it = genotypeData.getSequenceGeneticVariants("7").iterator(); List<GeneticVariant> variants = Utils.iteratorToList(it); assertEquals(variants.size(), 3); GeneticVariant var = variants.get(0); assertEquals(var.getPrimaryVariantId(), "SNP1"); assertEquals(var.getSequenceName(), "7"); assertEquals(var.getStartPos(), 123); assertEquals(var.getVariantAlleles(), Alleles.createBasedOnChars('A', 'G')); assertEquals( var.getSampleVariants(), Arrays.asList(Alleles.createBasedOnChars('A', 'A'), Alleles.createBasedOnChars('G', 'A'), Alleles.createBasedOnChars('A', 'A'), Alleles.createBasedOnChars('G', 'G'))); List<Boolean> expectedPhasing = Arrays.asList(true,false,true,true); assertEquals(var.getSamplePhasing(), expectedPhasing); } |
### Question:
Allele implements Comparable<Allele> { public Allele getComplement() { if (isSnpAllele()) { return complement; } else { throw new RuntimeException("Complement currently only supported for SNPs"); } } private Allele(String allele); private Allele(char allele); boolean isSnpAllele(); String getAlleleAsString(); char getAlleleAsSnp(); Allele getComplement(); static Allele create(String alleleString); static Allele create(char alleleChar); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override int compareTo(Allele other); final static Allele A; final static Allele C; final static Allele G; final static Allele T; final static Allele ZERO; }### Answer:
@Test public void getComplement() { assertEquals(Allele.A.getComplement().getAlleleAsString(), "T"); } |
### Question:
Allele implements Comparable<Allele> { public char getAlleleAsSnp() { return snpAllele; } private Allele(String allele); private Allele(char allele); boolean isSnpAllele(); String getAlleleAsString(); char getAlleleAsSnp(); Allele getComplement(); static Allele create(String alleleString); static Allele create(char alleleChar); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override int compareTo(Allele other); final static Allele A; final static Allele C; final static Allele G; final static Allele T; final static Allele ZERO; }### Answer:
@Test public void getSnpAllele() { assertEquals(Allele.A.getAlleleAsSnp(), 'A'); } |
### Question:
Allele implements Comparable<Allele> { public String getAlleleAsString() { return allele; } private Allele(String allele); private Allele(char allele); boolean isSnpAllele(); String getAlleleAsString(); char getAlleleAsSnp(); Allele getComplement(); static Allele create(String alleleString); static Allele create(char alleleChar); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override int compareTo(Allele other); final static Allele A; final static Allele C; final static Allele G; final static Allele T; final static Allele ZERO; }### Answer:
@Test public void getStringAllele() { assertEquals(Allele.A.getAlleleAsString(), "A"); } |
### Question:
Allele implements Comparable<Allele> { public boolean isSnpAllele() { return (byte) snpAllele != -1; } private Allele(String allele); private Allele(char allele); boolean isSnpAllele(); String getAlleleAsString(); char getAlleleAsSnp(); Allele getComplement(); static Allele create(String alleleString); static Allele create(char alleleChar); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override int compareTo(Allele other); final static Allele A; final static Allele C; final static Allele G; final static Allele T; final static Allele ZERO; }### Answer:
@Test public void isSnpAllele() { assertEquals(Allele.A.isSnpAllele(), true); } |
### Question:
TabixIndex implements GenotypeDataIndex { @Override public List<String> getSeqNames() { return Collections.unmodifiableList(Arrays.asList(seqNames)); } TabixIndex(File tabixIndexFile, File bzipFile, VariantLineMapper variantLineMapper); @Override List<String> getSeqNames(); TIndex[] getIndex(); @Override VariantQuery createQuery(); @Override RawLineQuery createRawLineQuery(); TabixIterator queryTabixIndex(String sequence, final int beg, final int end,
BlockCompressedInputStream bzipInputStream); }### Answer:
@Test public void getSeqNames() { List<String> seqNames = index.getSeqNames(); assertNotNull(seqNames); assertEquals(seqNames.size(), 3); assertEquals(seqNames.get(0), "1"); assertEquals(seqNames.get(1), "2"); assertEquals(seqNames.get(2), "3"); } |
### Question:
TabixQuery implements VariantQuery { @Override public VariantQueryResult executeQuery(String sequence, int startPos, int stopPos) { if (startPos < 0) throw new IllegalArgumentException("StartPos must be bigger then 0"); if (stopPos <= startPos) throw new IllegalArgumentException("StopPos must be bigger then startPos "); try { TabixIterator tabixIterator = index.queryTabixIndex(sequence, startPos, stopPos, inputStream); return new TabixQueryResult(inputStream, new TabixQueryIterator(tabixIterator, variantLineMapper)); } catch (IOException e) { throw new GenotypeDataException(e); } } TabixQuery(File bzipFile, TabixIndex index, VariantLineMapper variantLineMapper); @Override VariantQueryResult executeQuery(String sequence, int startPos, int stopPos); @Override VariantQueryResult executeQuery(String sequence); @Override VariantQueryResult executeQuery(String sequence, int startPos); }### Answer:
@Test public void queryPos() throws IOException { result = query.executeQuery("1", 565286, 6097450); Iterator<GeneticVariant> it = result.iterator(); int i = 0; while (it.hasNext()) { i++; GeneticVariant variant = it.next(); assertNotNull(variant); assertEquals(variant.getSequenceName(), "1"); } assertEquals(i, 5); }
@Test public void querySeq1() throws IOException { result = query.executeQuery("1"); Iterator<GeneticVariant> it = result.iterator(); int i = 0; while (it.hasNext()) { i++; GeneticVariant variant = it.next(); assertNotNull(variant); assertEquals(variant.getSequenceName(), "1"); } assertEquals(i, 6); }
@Test public void querySeq2() throws IOException { result = query.executeQuery("2"); Iterator<GeneticVariant> it = result.iterator(); int i = 0; while (it.hasNext()) { i++; GeneticVariant variant = it.next(); assertNotNull(variant); assertEquals(variant.getSequenceName(), "2"); } assertEquals(i, 1); }
@Test public void queryStartPos() { result = query.executeQuery("1", 3172273); Iterator<GeneticVariant> variants = result.iterator(); assertNotNull(variants); assertTrue(variants.hasNext()); assertEquals(variants.next().getPrimaryVariantId(), "rs2455100"); assertFalse(variants.hasNext()); assertNotNull(query.executeQuery("x", 3172273)); assertFalse(query.executeQuery("x", 3172273).iterator().hasNext()); assertNotNull(query.executeQuery("1", 31722730)); assertFalse(query.executeQuery("1", 31722730).iterator().hasNext()); } |
### Question:
VcfGeneticVariantMeta implements GeneticVariantMeta { public VcfGeneticVariantMeta(VcfMeta vcfMeta, Iterable<String> vcfRecordFormat) { if (vcfMeta == null) { throw new IllegalArgumentException("vcfMeta is null"); } if (vcfRecordFormat == null) { throw new IllegalArgumentException("vcfRecord is null"); } this.vcfMeta = vcfMeta; this.vcfRecordFormat = vcfRecordFormat; } VcfGeneticVariantMeta(VcfMeta vcfMeta, Iterable<String> vcfRecordFormat); @Override Iterable<String> getRecordIds(); @Override Type getRecordType(String recordId); }### Answer:
@Test(expectedExceptions = IllegalArgumentException.class) public void VcfGeneticVariantMeta() { new VcfGeneticVariantMeta(null, null); } |
### Question:
VcfGeneticVariantMeta implements GeneticVariantMeta { @Override public Iterable<String> getRecordIds() { return vcfRecordFormat; } VcfGeneticVariantMeta(VcfMeta vcfMeta, Iterable<String> vcfRecordFormat); @Override Iterable<String> getRecordIds(); @Override Type getRecordType(String recordId); }### Answer:
@Test public void getRecordIds() { List<String> ids = Lists.newArrayList(vcfGeneticVariantMeta.getRecordIds()); assertEquals(ids, Arrays.asList("GT", "DP", "EC", "CONFS")); } |
### Question:
VcfGeneticVariantMeta implements GeneticVariantMeta { @Override public Type getRecordType(String recordId) { boolean found = false; for (String record : vcfRecordFormat) { found = record.equals(recordId); if (found) { break; } } if (!found) { return null; } VcfMetaFormat format = vcfMeta.getFormatMeta(recordId); if (format == null) { return null; } String number = format.getNumber(); boolean isListValue = number.equals("A") || number.equals("R") || number.equals("G") || number.equals(".") || Integer.valueOf(number) > 1; switch (format.getType()) { case CHARACTER: return isListValue ? Type.CHAR_LIST : Type.CHAR; case FLOAT: return isListValue ? Type.FLOAT_LIST : Type.FLOAT; case INTEGER: return isListValue ? Type.INTEGER_LIST : Type.INTEGER; case STRING: return isListValue ? Type.STRING_LIST : Type.STRING; default: throw new IllegalArgumentException("invalid vcf format type [" + format.getType() + "]"); } } VcfGeneticVariantMeta(VcfMeta vcfMeta, Iterable<String> vcfRecordFormat); @Override Iterable<String> getRecordIds(); @Override Type getRecordType(String recordId); }### Answer:
@Test public void getRecordType() { assertEquals(GeneticVariantMeta.Type.STRING, vcfGeneticVariantMeta.getRecordType("GT")); assertEquals(GeneticVariantMeta.Type.INTEGER, vcfGeneticVariantMeta.getRecordType("DP")); assertEquals(GeneticVariantMeta.Type.INTEGER_LIST, vcfGeneticVariantMeta.getRecordType("EC")); assertEquals(GeneticVariantMeta.Type.FLOAT_LIST, vcfGeneticVariantMeta.getRecordType("CONFS")); assertNull(vcfGeneticVariantMeta.getRecordType("invalid")); } |
### Question:
VcfGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<String> getSeqNames() { return new ArrayList<String>(tabixIndex.getSeqNames()); } VcfGenotypeData(File bzipVcfFile, int cacheSize, double minimumPosteriorProbabilityToCall); VcfGenotypeData(File bzipVcfFile, File tabixIndexFile, double minimumPosteriorProbabilityToCall); VcfGenotypeData(File bzipVcfFile, File tabixIndexFile, int cacheSize, double minimumPosteriorProbabilityToCall); @Override Iterator<GeneticVariant> iterator(); @Override List<Alleles> getSampleVariants(final GeneticVariant variant); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByPos(final String seqName, final int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getVariantsByRange(final String seqName, final int rangeStart, final int rangeEnd); MappedGenotypeField getPreferredGenotypeField(); void setPreferredGenotypeField(String preferredGenotypeField); }### Answer:
@Test public void getSeqNames() { List<String> seqNames = genotypeData.getSeqNames(); assertNotNull(seqNames); assertEquals(seqNames.size(), 3); assertEquals(seqNames.get(0), "1"); assertEquals(seqNames.get(1), "2"); assertEquals(seqNames.get(2), "3"); } |
### Question:
VcfGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public Map<String, Annotation> getVariantAnnotationsMap() { if (cachedSampleAnnotationsMap == null) { cachedSampleAnnotationsMap = new LinkedHashMap<String, Annotation>(); for (VcfMetaInfo info : vcfMeta.getInfoMeta()) { cachedSampleAnnotationsMap.put(info.getId(), VcfAnnotation.fromVcfInfo(info)); } } return cachedSampleAnnotationsMap; } VcfGenotypeData(File bzipVcfFile, int cacheSize, double minimumPosteriorProbabilityToCall); VcfGenotypeData(File bzipVcfFile, File tabixIndexFile, double minimumPosteriorProbabilityToCall); VcfGenotypeData(File bzipVcfFile, File tabixIndexFile, int cacheSize, double minimumPosteriorProbabilityToCall); @Override Iterator<GeneticVariant> iterator(); @Override List<Alleles> getSampleVariants(final GeneticVariant variant); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByPos(final String seqName, final int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getVariantsByRange(final String seqName, final int rangeStart, final int rangeEnd); MappedGenotypeField getPreferredGenotypeField(); void setPreferredGenotypeField(String preferredGenotypeField); }### Answer:
@Test public void getVariantAnnotationsMap() { Map<String, Annotation> annotations = genotypeData.getVariantAnnotationsMap(); assertNotNull(annotations); assertEquals(annotations.size(), 21); Annotation annotation = annotations.get("NS"); assertNotNull(annotation); assertEquals(annotation.getId(), "NS"); assertTrue(annotation instanceof VcfAnnotation); } |
### Question:
VcfGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public List<Sequence> getSequences() { List<String> seqNames = getSeqNames(); Map<String, Integer> sequenceLengthById = new HashMap<String, Integer>(); for (VcfMetaContig contig : vcfMeta.getContigMeta()) { sequenceLengthById.put(contig.getId(), contig.getLength()); } List<Sequence> sequences = new ArrayList<Sequence>(seqNames.size()); for (String seqName : seqNames) { sequences.add(new SimpleSequence(seqName, sequenceLengthById.get(seqName), this)); } return sequences; } VcfGenotypeData(File bzipVcfFile, int cacheSize, double minimumPosteriorProbabilityToCall); VcfGenotypeData(File bzipVcfFile, File tabixIndexFile, double minimumPosteriorProbabilityToCall); VcfGenotypeData(File bzipVcfFile, File tabixIndexFile, int cacheSize, double minimumPosteriorProbabilityToCall); @Override Iterator<GeneticVariant> iterator(); @Override List<Alleles> getSampleVariants(final GeneticVariant variant); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByPos(final String seqName, final int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getVariantsByRange(final String seqName, final int rangeStart, final int rangeEnd); MappedGenotypeField getPreferredGenotypeField(); void setPreferredGenotypeField(String preferredGenotypeField); }### Answer:
@Test public void testGetSequences() { List<Sequence> sequences = genotypeData.getSequences(); assertNotNull(sequences); assertEquals(sequences.size(), 3); } |
### Question:
VcfGenotypeData extends AbstractRandomAccessGenotypeData implements SampleVariantsProvider { @Override public Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName) { return getVariantsByRange(seqName, 0, Integer.MAX_VALUE); } VcfGenotypeData(File bzipVcfFile, int cacheSize, double minimumPosteriorProbabilityToCall); VcfGenotypeData(File bzipVcfFile, File tabixIndexFile, double minimumPosteriorProbabilityToCall); VcfGenotypeData(File bzipVcfFile, File tabixIndexFile, int cacheSize, double minimumPosteriorProbabilityToCall); @Override Iterator<GeneticVariant> iterator(); @Override List<Alleles> getSampleVariants(final GeneticVariant variant); @Override Map<String, Annotation> getVariantAnnotationsMap(); @Override List<Sequence> getSequences(); @Override List<Sample> getSamples(); @Override int cacheSize(); @Override List<Boolean> getSamplePhasing(GeneticVariant variant); @Override boolean arePhasedProbabilitiesPresent(GeneticVariant variant); @Override int getSampleVariantProviderUniqueId(); @Override Map<String, SampleAnnotation> getSampleAnnotationsMap(); @Override byte[] getSampleCalledDosage(GeneticVariant variant); @Override float[] getSampleDosage(GeneticVariant variant); @Override void close(); @Override boolean isOnlyContaingSaveProbabilityGenotypes(); @Override float[][] getSampleProbilities(GeneticVariant variant); @Override double[][] getSampleProbabilitiesComplex(GeneticVariant variant); @Override double[][][] getSampleProbabilitiesPhased(GeneticVariant variant); @Override FixedSizeIterable<GenotypeRecord> getSampleGenotypeRecords(GeneticVariant variant); @Override List<String> getSeqNames(); @Override Iterable<GeneticVariant> getSequenceGeneticVariants(String seqName); @Override Iterable<GeneticVariant> getVariantsByPos(final String seqName, final int startPos); @Override GeneticVariant getSnpVariantByPos(String seqName, int startPos); @Override Iterable<GeneticVariant> getVariantsByRange(final String seqName, final int rangeStart, final int rangeEnd); MappedGenotypeField getPreferredGenotypeField(); void setPreferredGenotypeField(String preferredGenotypeField); }### Answer:
@Test public void testgetSequenceGeneticVariants() throws IOException { List<GeneticVariant> variants = Utils.iteratorToList(genotypeData.getSequenceGeneticVariants("1").iterator()); assertEquals(variants.size(), 6); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.