private Genotype makeG(String sample, Allele a1, Allele a2) { return GenotypeBuilder.create(sample, Arrays.asList(a1, a2)); }
@BeforeSuite public void before() { C = Allele.create("C"); Aref = Allele.create("A", true); T = Allele.create("T"); AA = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref)); AT = GenotypeBuilder.create("AT", Arrays.asList(Aref, T)); TT = GenotypeBuilder.create("TT", Arrays.asList(T, T)); AC = GenotypeBuilder.create("AC", Arrays.asList(Aref, C)); CT = GenotypeBuilder.create("CT", Arrays.asList(C, T)); CC = GenotypeBuilder.create("CC", Arrays.asList(C, C)); MISSING = GenotypeBuilder.create("MISSING", Arrays.asList(C, C)); allGenotypes = Arrays.asList(AA, AT, TT, AC, CT, CC); }
public VariantContext createEmptyContext(VariantContext other, List<String> samples) { VariantContextBuilder builder = new VariantContextBuilder(); // set the alleles to be the same builder.alleles(other.getAlleles()); builder.loc(other.getChr(),other.getStart(),other.getEnd()); // set all genotypes to empty List<Genotype> genotypes = new ArrayList<Genotype>(samples.size()); for ( String sample : samples ) genotypes.add(GenotypeBuilder.create(sample, new ArrayList<Allele>(0))); builder.genotypes(genotypes); return builder.make(); }
@DataProvider public Object[][] testValidateAlternateAllelesFailureDataProvider() { final Genotype homRef = GenotypeBuilder.create("homRef", Arrays.asList(Aref, Aref)); final Genotype homVarA = GenotypeBuilder.create("homVarA", Arrays.asList(A, A)); // alts not observed in the genotypes will fail validation // this is the throw in VariantContext from: if ( reportedAlleles.size() != observedAlleles.size() ) final VariantContext vcHasAltNotObservedInGT = // A-ref/T vs A-ref/A-ref createValidateAlternateAllelesContext(Arrays.asList(Aref, T), homRef); // alts not observed in the genotypes will fail validation // but this time it is the second throw in VariantContext after: observedAlleles.retainAll(reportedAlleles); final VariantContext vcHasAltNotObservedInGTIntersection = // A-ref/T vs A/A createValidateAlternateAllelesContext(Arrays.asList(Aref, T), homVarA); return new Object[][]{ {vcHasAltNotObservedInGT}, {vcHasAltNotObservedInGTIntersection} }; } @Test(dataProvider = "testValidateAlternateAllelesFailureDataProvider", expectedExceptions = TribbleException.class)
@Test public void testMonomorphicVariant() { Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref)); Genotype g2 = GenotypeBuilder.create("BB", Arrays.asList(Aref, Allele.NO_CALL)); Genotype g3 = GenotypeBuilder.create("CC", Arrays.asList(Allele.NO_CALL,Allele.NO_CALL)); GenotypesContext gc = GenotypesContext.create(g1, g2, g3); VariantContext vc = new VariantContextBuilder("genotypes", snpLoc, snpLocStart, snpLocStop, Collections.singletonList(Aref)).genotypes(gc).make(); Assert.assertEquals(vc.getType(), VariantContext.Type.NO_VARIATION); Assert.assertNull(vc.getAltAlleleWithHighestAlleleCount()); Assert.assertEquals(vc.getCalledChrCount(Aref), 3); }
@DataProvider(name = "SitesAndGenotypesVC") public Object[][] MakeSitesAndGenotypesVCs() { Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref)); Genotype g2 = GenotypeBuilder.create("AT", Arrays.asList(Aref, T)); Genotype g3 = GenotypeBuilder.create("TT", Arrays.asList(T, T)); VariantContext sites = new VariantContextBuilder("sites", snpLoc, snpLocStart, snpLocStop, Arrays.asList(Aref, T)).make(); VariantContext genotypes = new VariantContextBuilder(sites).source("genotypes").genotypes(g1, g2, g3).make(); List<Object[]> tests = new ArrayList<>(); tests.add(new Object[]{new SitesAndGenotypesVC("sites", sites)}); tests.add(new Object[]{new SitesAndGenotypesVC("genotypes", genotypes)}); return tests.toArray(new Object[][]{}); }
@DataProvider public Object[][] testValidateAlternateAllelesDataProvider() { final Genotype homVarT = GenotypeBuilder.create("homVarT", Arrays.asList(T, T)); // no genotypes passes validateAlternateAlleles final VariantContext vcNoGenotypes = // A-ref/T with no GT createValidateAlternateAllelesContext(Arrays.asList(Aref, T)); // genotypes that match ALTs will pass final VariantContext vcHasGenotypes = // A-ref/T vs T/T createValidateAlternateAllelesContext(Arrays.asList(Aref, T), homVarT); return new Object[][]{ {vcNoGenotypes}, {vcHasGenotypes} }; } @Test(dataProvider = "testValidateAlternateAllelesDataProvider")
private static Genotype attr(final String name, final Allele ref, final String key, final Object ... value) { if ( value.length == 0 ) return GenotypeBuilder.create(name, Arrays.asList(ref, ref)); else { final Object toAdd = value.length == 1 ? value[0] : Arrays.asList(value); return new GenotypeBuilder(name, Arrays.asList(ref, ref)).attribute(key, toAdd).make(); } }
@Test(enabled = true, dataProvider = "GenotypesContextProvider") public void testSet(GenotypesContextProvider cfg) { Genotype set = GenotypeBuilder.create("replace", Arrays.asList(Aref, Aref)); int n = cfg.makeContext().size(); for ( int i = 0; i < n; i++ ) { GenotypesContext gc = cfg.makeContext(); Genotype setted = gc.set(i, set); Assert.assertNotNull(setted); ArrayList<Genotype> l = new ArrayList<Genotype>(cfg.initialSamples); l.set(i, set); testGenotypesContextContainsExpectedSamples(gc, l); } }
public void testGetGenotypeMethods() { Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref)); Genotype g2 = GenotypeBuilder.create("AT", Arrays.asList(Aref, T)); Genotype g3 = GenotypeBuilder.create("TT", Arrays.asList(T, T)); GenotypesContext gc = GenotypesContext.create(g1, g2, g3); VariantContext vc = new VariantContextBuilder("genotypes", snpLoc, snpLocStart, snpLocStop, Arrays.asList(Aref, T)).genotypes(gc).make(); Assert.assertEquals(vc.getGenotype("AA"), g1); Assert.assertEquals(vc.getGenotype("AT"), g2); Assert.assertEquals(vc.getGenotype("TT"), g3); Assert.assertEquals(vc.getGenotype("CC"), null); Assert.assertEquals(vc.getGenotypes(), gc); Assert.assertEquals(vc.getGenotypes(Arrays.asList("AA", "AT")), Arrays.asList(g1, g2)); Assert.assertEquals(vc.getGenotypes(Arrays.asList("AA", "TT")), Arrays.asList(g1, g3)); Assert.assertEquals(vc.getGenotypes(Arrays.asList("AA", "AT", "TT")), Arrays.asList(g1, g2, g3)); Assert.assertEquals(vc.getGenotypes(Arrays.asList("AA", "AT", "CC")), Arrays.asList(g1, g2)); Assert.assertEquals(vc.getGenotype(0), g1); Assert.assertEquals(vc.getGenotype(1), g2); Assert.assertEquals(vc.getGenotype(2), g3); }
@Test(dataProvider = "genotypeConcordanceDetermineStateDataProvider") public void testGenotypeConcordanceDetermineState(final Allele truthAllele1, final Allele truthAllele2, final TruthState expectedTruthState, final Allele callAllele1, final Allele callAllele2, final CallState expectedCallState) throws Exception { final List<Allele> truthAlleles = makeUniqueListOfAlleles(truthAllele1, truthAllele2); final Genotype truthGt = GenotypeBuilder.create(TRUTH_SAMPLE_NAME, Arrays.asList(truthAllele1, truthAllele2)); final VariantContext truthVariantContext = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, truthAlleles).genotypes(truthGt).make(); final List<Allele> callAlleles = makeUniqueListOfAlleles(callAllele1, callAllele2); final Genotype callGt = GenotypeBuilder.create(CALL_SAMPLE_NAME, Arrays.asList(callAllele1, callAllele2)); final VariantContext callVariantContext = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, callAlleles).genotypes(callGt).make(); testGenotypeConcordanceDetermineState(truthVariantContext, expectedTruthState, callVariantContext, expectedCallState, 0, 0); }
@Test(enabled = true, dataProvider = "GenotypesContextProvider") public void testReplace(GenotypesContextProvider cfg) { int n = cfg.makeContext().size(); for ( int i = 0; i < n; i++ ) { GenotypesContext gc = cfg.makeContext(); Genotype toReplace = gc.get(i); Genotype replacement = GenotypeBuilder.create(toReplace.getSampleName(), Arrays.asList(Aref, Aref)); gc.replace(replacement); ArrayList<Genotype> l = new ArrayList<Genotype>(cfg.initialSamples); l.set(i, replacement); Assert.assertEquals(replacement, gc.get(i)); testGenotypesContextContainsExpectedSamples(gc, l); } }
@Test public void testGetGenotypeCounts() { List<Allele> alleles = Arrays.asList(Aref, T); Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref)); Genotype g2 = GenotypeBuilder.create("AT", Arrays.asList(Aref, T)); Genotype g3 = GenotypeBuilder.create("TT", Arrays.asList(T, T)); Genotype g4 = GenotypeBuilder.create("A.", Arrays.asList(Aref, Allele.NO_CALL)); Genotype g5 = GenotypeBuilder.create("..", Arrays.asList(Allele.NO_CALL, Allele.NO_CALL)); // we need to create a new VariantContext each time VariantContext vc = new VariantContextBuilder("foo", snpLoc, snpLocStart, snpLocStop, alleles).genotypes(g1,g2,g3,g4,g5).make(); Assert.assertEquals(1, vc.getHetCount()); vc = new VariantContextBuilder("foo", snpLoc, snpLocStart, snpLocStop, alleles).genotypes(g1,g2,g3,g4,g5).make(); Assert.assertEquals(1, vc.getHomRefCount()); vc = new VariantContextBuilder("foo", snpLoc, snpLocStart, snpLocStop, alleles).genotypes(g1,g2,g3,g4,g5).make(); Assert.assertEquals(1, vc.getHomVarCount()); vc = new VariantContextBuilder("foo", snpLoc, snpLocStart, snpLocStop, alleles).genotypes(g1,g2,g3,g4,g5).make(); Assert.assertEquals(1, vc.getMixedCount()); vc = new VariantContextBuilder("foo", snpLoc, snpLocStart, snpLocStop, alleles).genotypes(g1,g2,g3,g4,g5).make(); Assert.assertEquals(1, vc.getNoCallCount()); }
@Test(dataProvider = "SampleNamesTest") public void runSampleNamesTest(SampleNamesTest cfg) { GenotypesContext gc = GenotypesContext.create(cfg.sampleNames.size()); for ( final String name : cfg.sampleNames ) { gc.add(GenotypeBuilder.create(name, Arrays.asList(Aref, T))); } VariantContext vc = new VariantContextBuilder("genotypes", snpLoc, snpLocStart, snpLocStop, Arrays.asList(Aref, T)).genotypes(gc).make(); // same sample names => success Assert.assertTrue(vc.getSampleNames().equals(new HashSet<>(cfg.sampleNames)), "vc.getSampleNames() = " + vc.getSampleNames()); Assert.assertEquals(vc.getSampleNamesOrderedByName(), cfg.sampleNamesInOrder, "vc.getSampleNamesOrderedByName() = " + vc.getSampleNamesOrderedByName()); assertGenotypesAreInOrder(vc.getGenotypesOrderedByName(), cfg.sampleNamesInOrder); assertGenotypesAreInOrder(vc.getGenotypesOrderedBy(cfg.sampleNames), cfg.sampleNames); }
@Test public void testGenotypeConcordanceDetermineStateNull() throws Exception { final List<Allele> alleles = makeUniqueListOfAlleles(Aref, C); final Genotype gt1 = GenotypeBuilder.create(TRUTH_SAMPLE_NAME, Arrays.asList(Aref, C)); final VariantContext vc1 = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, alleles).genotypes(gt1).make(); testGenotypeConcordanceDetermineState(null, TruthState.MISSING, null, CallState.MISSING, 0, 0); testGenotypeConcordanceDetermineState(vc1, TruthState.HET_REF_VAR1, null, CallState.MISSING, 0, 0); testGenotypeConcordanceDetermineState(null, TruthState.MISSING, vc1, CallState.HET_REF_VAR1, 0, 0); }
@Test(enabled = true, dataProvider = "GenotypesContextProvider") public void testAdds(GenotypesContextProvider cfg) { Genotype add1 = GenotypeBuilder.create("add1", Arrays.asList(Aref, Aref)); Genotype add2 = GenotypeBuilder.create("add2", Arrays.asList(Aref, Aref)); GenotypesContext gc = cfg.makeContext(); gc.add(add1); testGenotypesContextContainsExpectedSamples(gc, with(cfg.initialSamples, add1)); gc = cfg.makeContext(); gc.add(add1); gc.add(add2); testGenotypesContextContainsExpectedSamples(gc, with(cfg.initialSamples, add1, add2)); gc = cfg.makeContext(); gc.addAll(Arrays.asList(add1, add2)); testGenotypesContextContainsExpectedSamples(gc, with(cfg.initialSamples, add1, add2)); }
private Pair<VariantContext,VariantContext> getMonoallelicData() { final Allele ref = Allele.create(BaseUtils.Base.T.base,true); final Allele alt = Allele.create(BaseUtils.Base.C.base); //Site in eval is monoallelic, both samples are HOM_REF //sample1 in comp is HOM_VAR, sample2 is NO_CALL //None of these should trigger mismatching alleles final GenomeLoc loc = genomeLocParser.createGenomeLoc("chr1",1,1); final VariantContextBuilder site1Comp = new VariantContextBuilder(); final VariantContextBuilder site1Eval = new VariantContextBuilder(); site1Comp.loc(loc.getContig(), loc.getStart(), loc.getStop()); site1Eval.loc(loc.getContig(), loc.getStart(), loc.getStop()); site1Comp.alleles(Arrays.asList(ref)); site1Eval.alleles(Arrays.asList(ref, alt)); site1Comp.genotypes(GenotypeBuilder.create("test2_sample1", Arrays.asList(ref, ref)), GenotypeBuilder.create("test2_sample2", Arrays.asList(ref, ref))); site1Eval.genotypes(GenotypeBuilder.create("test2_sample1",Arrays.asList(alt,alt)), GenotypeBuilder.create("test2_sample2",Arrays.asList(Allele.NO_CALL,Allele.NO_CALL))); return new Pair<>(site1Eval.make(), site1Comp.make()); }
@Test public void testCreatingPartiallyCalledGenotype() { List<Allele> alleles = Arrays.asList(Aref, C); Genotype g = GenotypeBuilder.create("foo", Arrays.asList(C, Allele.NO_CALL)); VariantContext vc = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, alleles).genotypes(g).make(); Assert.assertTrue(vc.isSNP()); Assert.assertEquals(vc.getNAlleles(), 2); Assert.assertTrue(vc.hasGenotypes()); Assert.assertFalse(vc.isMonomorphicInSamples()); Assert.assertTrue(vc.isPolymorphicInSamples()); Assert.assertEquals(vc.getGenotype("foo"), g); Assert.assertEquals(vc.getCalledChrCount(), 1); // we only have 1 called chromosomes, we exclude the NO_CALL one isn't called Assert.assertEquals(vc.getCalledChrCount(Aref), 0); Assert.assertEquals(vc.getCalledChrCount(C), 1); Assert.assertFalse(vc.getGenotype("foo").isHet()); Assert.assertFalse(vc.getGenotype("foo").isHom()); Assert.assertFalse(vc.getGenotype("foo").isNoCall()); Assert.assertFalse(vc.getGenotype("foo").isHom()); Assert.assertTrue(vc.getGenotype("foo").isMixed()); Assert.assertEquals(vc.getGenotype("foo").getType(), GenotypeType.MIXED); }
@Test public void testGenotypeConcordanceDetermineStateDp() throws Exception { final List<Allele> allelesNormal = makeUniqueListOfAlleles(Aref, C); final Genotype gtNormal = GenotypeBuilder.create(TRUTH_SAMPLE_NAME, Arrays.asList(Aref, C)); final VariantContext vcNormal = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, allelesNormal).genotypes(gtNormal).make(); final List<Allele> allelesLowDp = makeUniqueListOfAlleles(Aref, C); final Genotype gtLowDp = new GenotypeBuilder(TRUTH_SAMPLE_NAME, Arrays.asList(Aref, C)).DP(4).make(); final VariantContext vcLowDp = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, allelesLowDp).genotypes(gtLowDp).make(); testGenotypeConcordanceDetermineState(vcLowDp, TruthState.LOW_DP, vcNormal, CallState.HET_REF_VAR1, 0, 20); testGenotypeConcordanceDetermineState(vcLowDp, TruthState.HET_REF_VAR1, vcLowDp, CallState.HET_REF_VAR1, 0, 2); testGenotypeConcordanceDetermineState(vcNormal, TruthState.HET_REF_VAR1, vcLowDp, CallState.LOW_DP, 0, 20); testGenotypeConcordanceDetermineState(vcNormal, TruthState.HET_REF_VAR1, vcLowDp, CallState.HET_REF_VAR1, 0, 2); testGenotypeConcordanceDetermineState(vcLowDp, TruthState.LOW_DP, vcLowDp, CallState.LOW_DP, 0, 20); testGenotypeConcordanceDetermineState(vcLowDp, TruthState.HET_REF_VAR1, vcLowDp, CallState.HET_REF_VAR1, 0, 2); }
@Test public void testGenotypeConcordanceDetermineStateGq() throws Exception { final List<Allele> allelesNormal = makeUniqueListOfAlleles(Aref, C); final Genotype gtNormal = GenotypeBuilder.create(TRUTH_SAMPLE_NAME, Arrays.asList(Aref, C)); final VariantContext vcNormal = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, allelesNormal).genotypes(gtNormal).make(); final List<Allele> allelesLowGq = makeUniqueListOfAlleles(Aref, C); final Genotype gtLowGq = new GenotypeBuilder(TRUTH_SAMPLE_NAME, Arrays.asList(Aref, C)).GQ(4).make(); final VariantContext vcLowGq = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, allelesLowGq).genotypes(gtLowGq).make(); testGenotypeConcordanceDetermineState(vcLowGq, TruthState.LOW_GQ, vcNormal, CallState.HET_REF_VAR1, 20, 0); testGenotypeConcordanceDetermineState(vcLowGq, TruthState.HET_REF_VAR1, vcLowGq, CallState.HET_REF_VAR1, 2, 0); testGenotypeConcordanceDetermineState(vcNormal, TruthState.HET_REF_VAR1, vcLowGq, CallState.LOW_GQ, 20, 0); testGenotypeConcordanceDetermineState(vcNormal, TruthState.HET_REF_VAR1, vcLowGq, CallState.HET_REF_VAR1, 2, 0); testGenotypeConcordanceDetermineState(vcLowGq, TruthState.LOW_GQ, vcLowGq, CallState.LOW_GQ, 20, 0); testGenotypeConcordanceDetermineState(vcLowGq, TruthState.HET_REF_VAR1, vcLowGq, CallState.HET_REF_VAR1, 2, 0); }