public void SupplementSupportWithClippedReads()
{
// In this test we create reads that are either normal or clipped (identified by "clip_" in their name)
// This test does not take cigar data into account.
var mockClippedReadComparator = new Mock <IMNVClippedReadComparator>();
// Mock read comparator returns true if read name starts with c
mockClippedReadComparator.Setup(x => x.DoesClippedReadSupportMNV(It.IsAny <Read>(), It.IsAny <CalledAllele>()))
.Returns((Read read, CalledAllele allele) => read.Name[0] == 'c' ? true : false);
var reads = new List <Read>();
reads.Add(CreateRead("chr1", "ACGT", 3, "read4"));
reads.Add(CreateRead("chr1", "ACGT", 3, "clip_read4", matePosition: 3)); // +1 not in neighborhood, but still gets counted because mocked ClippedReadComparator
reads.Add(CreateRead("chr1", "ACGT", 12, "read1", matePosition: 10));
reads.Add(CreateRead("chr1", "ACGT", 12, "read2", matePosition: 10));
reads.Add(CreateRead("chr1", "ACGT", 12, "read1", read2: true, matePosition: 10));
reads.Add(CreateRead("chr1", "ACGT", 12, "read_notmapped", isMapped: false, isProperPair: false, matePosition: 10));
reads.Add(CreateRead("chr1", "ACGT", 12, "read3", isProperPair: false, read2: true, matePosition: 10));
reads.Add(CreateRead("chr1", "ACGT", 12, "read2", read2: true, matePosition: 10));
reads.Add(CreateRead("chr1", "ACGT", 12, "clip_read1", matePosition: 10)); // +1 clipped read
reads.Add(CreateRead("chr1", "ACGT", 12, "clip_read2", matePosition: 10)); // +1 clipped read
reads.Add(CreateRead("chr1", "ACGT", 12, "clip_read1", read2: true, matePosition: 10)); // +1 clipped read
reads.Add(CreateRead("chr1", "ACGT", 12, "clip_read_notmapped", isMapped: false, isProperPair: false, matePosition: 10)); // +1 clipped read
reads.Add(CreateRead("chr1", "ACGT", 12, "clip_read3", isProperPair: false, read2: true, matePosition: 10)); // +1 clipped read
reads.Add(CreateRead("chr1", "ACGT", 12, "clip_read2", read2: true, matePosition: 10)); // +1 clipped read
reads.Add(CreateRead("chr1", "ACGT", 30, "read5"));
reads.Add(CreateRead("chr1", "ACGT", 30, "clip_read5", matePosition: 30)); // not in neighborhood, not counted
var mockAlignmentExtractor = new MockAlignmentExtractor(reads);
int qNoiseLevel = 20;
int maxQscore = 100;
int minMNVsize = 6;
MNVSoftClipSupportFinder mnvClippedSupportFinder = new MNVSoftClipSupportFinder(mockAlignmentExtractor, mockClippedReadComparator.Object, qNoiseLevel, maxQscore, minMNVsize);
var mnv1 = TestHelper.CreateDummyAllele("chr1", 10, "AAAAAA", "CCC", 2000, 50);
var neighbor1 = new VcfNeighborhood(0, "chr", new VariantSite(10000), new VariantSite(200000))
{
VcfVariantSites = new List <VariantSite>
{
new VariantSite(10)
{
VcfReferenceAllele = "A", VcfAlternateAllele = "C", ReferenceName = "chr"
},
new VariantSite(25)
{
VcfReferenceAllele = "T", VcfAlternateAllele = "G", ReferenceName = "chr"
},
},
};
var callableNbhd = new CallableNeighborhood(neighbor1, new VariantCallingParameters(), null);
callableNbhd.AddAcceptedPhasedVariant(mnv1);
Assert.Equal(50, callableNbhd.CandidateVariants[0].AlleleSupport);
mnvClippedSupportFinder.SupplementSupportWithClippedReads(callableNbhd);
Assert.Equal(57, callableNbhd.CandidateVariants[0].AlleleSupport);
}
public void CheckAddingFilters()
{
var originalVcfVariant = TestHelper.CreateDummyAllele("chr1", 123, "A", "T", 1000, 156);
var originalVcfVariant2 = TestHelper.CreateDummyAllele("chr1", 124, "A", "T", 1000, 156);
var vs1 = new VariantSite(originalVcfVariant);
var vs2 = new VariantSite(originalVcfVariant2);
var variantCallingParameters = new VariantCallingParameters();
//Set up filters so calls are sure to trigger them.
variantCallingParameters.LowDepthFilter = 2000;
variantCallingParameters.MinimumFrequencyFilter = 0.80F;
variantCallingParameters.MinimumVariantQScoreFilter = 300;
var caller = new VariantCaller(variantCallingParameters, new BamFilterParameters());
var nbhd = new VcfNeighborhood(0, "chr1", vs1, vs2);
var callableNeihborhood = new CallableNeighborhood(nbhd, new VariantCallingParameters());
callableNeihborhood.AddAcceptedPhasedVariant(
new CalledAllele(AlleleCategory.Snv)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = "T",
VariantQscore = 100,
TotalCoverage = 1000,
AlleleSupport = 500
});
callableNeihborhood.UsedRefCountsLookup = new Dictionary <int, SuckedUpRefRecord>()
{
};
caller.CallMNVs(callableNeihborhood);
caller.CallRefs(callableNeihborhood);
var acceptedMNVs = callableNeihborhood.CalledVariants;
var acceptedRefs = callableNeihborhood.CalledRefs;
Assert.Equal(1, acceptedMNVs.Count);
Assert.Equal(1, acceptedMNVs[123].Count);
Assert.True(acceptedMNVs[123][0].Filters.Contains(FilterType.LowDepth));
Assert.True(acceptedMNVs[123][0].Filters.Contains(FilterType.LowVariantFrequency));
Assert.True(acceptedMNVs[123][0].Filters.Contains(FilterType.LowVariantQscore));
Assert.Equal(2, acceptedRefs.Count);
Assert.True(acceptedRefs[123].Filters.Contains(FilterType.LowDepth));
Assert.True(acceptedRefs[123].Filters.Contains(FilterType.LowVariantQscore));
//note reference calls dont win the "LowVariantFrequency" flag.
}
public void VarCallsBecomeRefsAndNulls()
{
var originalVcfVariant = TestHelper.CreateDummyAllele("chr1", 123, "A", "T", 1000, 156);
var originalVcfVariant2 = TestHelper.CreateDummyAllele("chr1", 124, "A", "T", 1000, 156);
var vs1 = new VariantSite(originalVcfVariant);
var vs2 = new VariantSite(originalVcfVariant2);
var vcParams = new VariantCallingParameters();
vcParams.Validate();
var caller = new VariantCaller(vcParams, new BamFilterParameters());
//since there is an alt at position 124 ( a call of 156 alt / 1000 total, that means 844 original ref calls.
//Of which we said, 100 will get sucked up. So that leaves 744 / 1000 calls for a reference.
//So, we can still make a confident ref call.
var nbhd = new VcfNeighborhood(0, "chr1", vs1, vs2);
var callableNeighbor1 = new CallableNeighborhood(nbhd, vcParams);
callableNeighbor1.AddAcceptedPhasedVariant(
new CalledAllele(AlleleCategory.Snv)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = "T",
VariantQscore = 100,
TotalCoverage = 1000,
AlleleSupport = 500
});
callableNeighbor1.UsedRefCountsLookup = new Dictionary <int, SuckedUpRefRecord>()
{
};
caller.CallMNVs(callableNeighbor1);
caller.CallRefs(callableNeighbor1);
var acceptedMNVs = callableNeighbor1.CalledVariants;
var acceptedRefs = callableNeighbor1.CalledRefs;
Assert.Equal(1, acceptedMNVs.Count);
Assert.Equal(1, acceptedMNVs[123].Count);
Assert.Equal(2, acceptedRefs.Count);
var vcfVariant2asRef = new VcfVariant()
{
ReferenceName = "chr1",
ReferencePosition = 124,
ReferenceAllele = "A",
VariantAlleles = new[] { "." },
Genotypes = new List <Dictionary <string, string> >()
{
new Dictionary <string, string>()
{
{ "GT", "0/." }, { "DP", "1000" }, { "AD", "844" }
}
},
};
VcfMergerTests.CheckVariantsMatch(originalVcfVariant, acceptedMNVs[123][0]);
VcfMergerTests.CheckVariantsMatch(vcfVariant2asRef, acceptedRefs[124]);
// If one has been sucked up and there are refs remaining, we should output it as a ref.
var suckedUpRefRecord100 = new SuckedUpRefRecord()
{
Counts = 100, AlleleThatClaimedIt = new CalledAllele()
};
callableNeighbor1.UsedRefCountsLookup = new Dictionary <int, SuckedUpRefRecord>()
{
{ 124, suckedUpRefRecord100 }
};
caller.CallMNVs(callableNeighbor1);
caller.CallRefs(callableNeighbor1);
acceptedMNVs = callableNeighbor1.CalledVariants;
acceptedRefs = callableNeighbor1.CalledRefs;
Assert.Equal(1, acceptedMNVs.Count);
Assert.Equal(1, acceptedMNVs[123].Count);
Assert.Equal(2, acceptedRefs.Count);
vcfVariant2asRef = new VcfVariant()
{
ReferenceName = "chr1",
ReferencePosition = 124,
ReferenceAllele = "A",
VariantAlleles = new[] { "." },
Genotypes = new List <Dictionary <string, string> >()
{
new Dictionary <string, string>()
{
{ "GT", "0/." }, { "DP", "1000" }, { "AD", "744" }
}
},
};
VcfMergerTests.CheckVariantsMatch(originalVcfVariant, acceptedMNVs[123][0]);
VcfMergerTests.CheckVariantsMatch(vcfVariant2asRef, acceptedRefs[124]);
// If one has been sucked up all the way
// we should output it as a null.
var suckedUpRefRecord1000 = new SuckedUpRefRecord()
{
Counts = 1000, AlleleThatClaimedIt = new CalledAllele()
};
callableNeighbor1.UsedRefCountsLookup = new Dictionary <int, SuckedUpRefRecord>()
{
{ 124, suckedUpRefRecord1000 }
};
caller.CallMNVs(callableNeighbor1);
caller.CallRefs(callableNeighbor1);
acceptedMNVs = callableNeighbor1.CalledVariants;
acceptedRefs = callableNeighbor1.CalledRefs;
Assert.Equal(1, acceptedMNVs.Count);
Assert.Equal(1, acceptedMNVs[123].Count);
Assert.Equal(2, acceptedRefs.Count);
var vcfVariant2asNull = new VcfVariant()
{
ReferenceName = "chr1",
ReferencePosition = 124,
ReferenceAllele = "A",
VariantAlleles = new[] { "." },
Genotypes = new List <Dictionary <string, string> >()
{
new Dictionary <string, string>()
{
{ "GT", "./." }, { "DP", "1000" }, { "AD", "0" }
}
},
};
VcfMergerTests.CheckVariantsMatch(originalVcfVariant, acceptedMNVs[123][0]);
VcfMergerTests.CheckVariantsMatch(vcfVariant2asNull, acceptedRefs[124]);
}
public void CallAVariantInANewLocation()
{
//set up the original variants
var originalVcfVariant1 = TestHelper.CreateDummyAllele("chr1", 123, "A", "T", 1000, 156);
var originalVcfVariant2 = TestHelper.CreateDummyAllele("chr1", 124, "A", "T", 1000, 156);
var originalVcfVariant3 = TestHelper.CreateDummyAllele("chr1", 234, "A", "T", 1000, 156);
var originalVcfVariant4 = TestHelper.CreateDummyAllele("chr1", 234, "A", "T", 1000, 156);
var vs1 = new VariantSite(originalVcfVariant1);
var vs2 = new VariantSite(originalVcfVariant2);
var vs3 = new VariantSite(originalVcfVariant3);
var vs4 = new VariantSite(originalVcfVariant4);
var vcParams = new VariantCallingParameters();
vcParams.Validate();
var caller = new VariantCaller(vcParams, new BamFilterParameters());
var nbhd = new VcfNeighborhood(0, "chr1", vs1, vs2);
nbhd.AddVariantSite(vs3); //note, we do not add vs4, that is not going to get used for phasing. Sps it is a variant that failed filters.
var callableNbhd = new CallableNeighborhood(nbhd, vcParams, null);
//now stage one candidate MNV:
var newMNV = new CalledAllele(AlleleCategory.Snv)
{
Chromosome = "chr1",
ReferencePosition = 129,
ReferenceAllele = "A",
AlternateAllele = "TT",
VariantQscore = 100,
TotalCoverage = 1000,
AlleleSupport = 500
};
callableNbhd.AddAcceptedPhasedVariant(newMNV);
var suckedUpRefRecord1000 = new SuckedUpRefRecord()
{
Counts = 1000, AlleleThatClaimedIt = new CalledAllele()
};
callableNbhd.UsedRefCountsLookup = new Dictionary <int, SuckedUpRefRecord>()
{
{ 124, suckedUpRefRecord1000 }
};
caller.CallMNVs(callableNbhd);
caller.CallRefs(callableNbhd);
var acceptedMNVs = callableNbhd.CalledVariants;
var acceptedRefs = callableNbhd.CalledRefs;
var vcfVariant0asRef = new VcfVariant()
{
ReferenceName = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
VariantAlleles = new[] { "." },
Genotypes = new List <Dictionary <string, string> >()
{
new Dictionary <string, string>()
{
{ "GT", "0/." }
}
},
};
var vcfVariant3asRef = new VcfVariant()
{
ReferenceName = "chr1",
ReferencePosition = 234,
ReferenceAllele = "A",
VariantAlleles = new[] { "." },
Genotypes = new List <Dictionary <string, string> >()
{
new Dictionary <string, string>()
{
{ "GT", "0/." }
}
},
};
var vcfVariant2asNull = new VcfVariant()
{
ReferenceName = "chr1",
ReferencePosition = 124,
ReferenceAllele = "A",
VariantAlleles = new[] { "." },
Genotypes = new List <Dictionary <string, string> >()
{
new Dictionary <string, string>()
{
{ "GT", "./." }
}
},
};
Assert.Equal(1, acceptedMNVs.Count);
Assert.Equal(1, acceptedMNVs[129].Count);
Assert.Equal(3, acceptedRefs.Count);
VcfMergerTests.CheckVariantsMatch(vcfVariant0asRef, acceptedRefs[123]);
VcfMergerTests.CheckVariantsMatch(vcfVariant2asNull, acceptedRefs[124]);
VcfMergerTests.CheckVariantsMatch(newMNV, acceptedMNVs[129][0]);
VcfMergerTests.CheckVariantsMatch(vcfVariant3asRef, acceptedRefs[234]);
}
//this unit test was made after we found bug ScyllaLoosingRefCalls_PICS-723.
//We had a 1/. GT reported when it should be 1/0.
//The reason for this is that all the refs (the "0"s) got incorrectly sucked up.
//Ie, MNV ACG-> AG claimed 50 refs, so we (incorrectly) subtracted 50 refs from it.
//The bug is that the ref counts got subtractedfrom the exact same mnv that claimed them.
// This should never happen, and was not the intent of the alg.
//
//The affected mehtod is: CreateMnvsFromClusters in VcfNbhd
public void CreateMnvsFromClusters_TakeUpRefCount()
{
var originalVcfVariant1 = TestHelper.CreateDummyAllele("chr1", 123, "ACG", "AT", 1000, 156);
var originalVcfVariant2 = TestHelper.CreateDummyAllele("chr1", 123, "A", "TTTTTT", 1000, 200);
// var originalVcfVariant3 = TestHelper.CreateDummyAllele("chr1", 123, "AC", "TT", 1000, 100);
var vs1 = new VariantSite(originalVcfVariant1);
var vs2 = new VariantSite(originalVcfVariant2);
var caller = new VariantCaller(new VariantCallingParameters(), new BamFilterParameters());
var nbhd = new VcfNeighborhood(0, "chr1", vs1, vs2);
var callableNeighborhood = new CallableNeighborhood(nbhd, new VariantCallingParameters());
callableNeighborhood.AddAcceptedPhasedVariant(
new CalledAllele(AlleleCategory.Snv)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = "A",
VariantQscore = 100,
TotalCoverage = 1000,
AlleleSupport = 200,
ReferenceSupport = 350
});
callableNeighborhood.AddAcceptedPhasedVariant(
new CalledAllele(AlleleCategory.Mnv)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "ACG",
AlternateAllele = "AT",
VariantQscore = 100,
TotalCoverage = 1000,
AlleleSupport = 300,
ReferenceSupport = 350
});
callableNeighborhood.AddAcceptedPhasedVariant(
new CalledAllele(AlleleCategory.Insertion)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = "AAAAA",
VariantQscore = 100,
TotalCoverage = 1000,
AlleleSupport = 250,
ReferenceSupport = 350
});
//default behavior, nothing gets sucked up
callableNeighborhood.UsedRefCountsLookup = new Dictionary <int, SuckedUpRefRecord>()
{
};
vs1.VcfReferencePosition = 123;
var vead = new Vead("dummy", new VariantSite[] { vs1 });
var vg = new VeadGroup(vead);
var fakeCluster = new Cluster("test", new List <VeadGroup>()
{
vg
});
fakeCluster.ResetConsensus();
callableNeighborhood.CreateMnvsFromClusters(new List <Cluster> {
fakeCluster
},
20);
caller.CallMNVs(callableNeighborhood);
caller.CallRefs(callableNeighborhood);
var acceptedMNVs = callableNeighborhood.CalledVariants;
var acceptedRefs = callableNeighborhood.CalledRefs;
Assert.Equal(2, acceptedMNVs.Count);
Assert.Equal(3, acceptedMNVs[123].Count);
Assert.Equal(1, acceptedRefs.Count);
//check the ref counts on all the MNVs. Nothing should be sucked up.
Assert.Equal(350, acceptedMNVs[123][0].ReferenceSupport); // Previously: total depth - allele suport. overly simple for now)
Assert.Equal(350, acceptedMNVs[123][1].ReferenceSupport); // Now: explicitly set ref support
Assert.Equal(350, acceptedMNVs[123][2].ReferenceSupport); //
// now variant 0 will suck up 100 ref calls:
var suckedUpRefRecord100 = new SuckedUpRefRecord()
{
Counts = 100, AlleleThatClaimedIt = callableNeighborhood.CandidateVariants[0]
};
callableNeighborhood.UsedRefCountsLookup = new Dictionary <int, SuckedUpRefRecord>()
{
{ 123, suckedUpRefRecord100 }
};
callableNeighborhood.CreateMnvsFromClusters(new List <Cluster> {
fakeCluster
},
20);
caller.CallMNVs(callableNeighborhood);
caller.CallRefs(callableNeighborhood);
acceptedMNVs = callableNeighborhood.CalledVariants;
acceptedRefs = callableNeighborhood.CalledRefs;
//check the ref counts on all the MNVs. refs should only be taken up by the first one
Assert.Equal(350, acceptedMNVs[123][0].ReferenceSupport); //Previously: total depth - allele suport. overly simple for now)
//old result - has bug
//Assert.Equal(1000 - 300, acceptedMNVs[123][1].ReferenceSupport); // Previously: total depth - allele suport - sucked up ref)
//Assert.Equal(1000 - 250, acceptedMNVs[123][2].ReferenceSupport); // Now: explicitly set ref support
//new result, fixed
Assert.Equal(350 - 100, acceptedMNVs[123][1].ReferenceSupport); // refSupport - sucked up ref)
Assert.Equal(350 - 100, acceptedMNVs[123][2].ReferenceSupport); // refSupport - sucked up ref)
}
//this unit test was made after we found bug ScyllaShouldMergeClusters_PICS-1122.
//We had an output vcf with the following lines
//chr11 64577365 . C . 100 PASS DP=1429 GT:GQ:AD:DP:VF:NL:SB:NC:US 0/0:1:1429:1429:0.00000:65:-100.0000:0.0592:0,0,0,0,0,0,0,0,0,0,0,0
//chr11 64577366 . A T 78 PASS DP = 559 GT:GQ:AD:DP:VF:NL:SB:NC:US 0/1:78:538,2:559:0.00358:65:-100.0000:0.7509:0,0,0,0,0,0,0,0,0,0,0,0
//chr11 64577366 . A T 78 PASS DP = 559 GT:GQ:AD:DP:VF:NL:SB:NC:US 0/1:78:538,2:559:0.00358:65:-100.0000:0.7509:0,0,0,0,0,0,0,0,0,0,0,0
//chr11 64577367 . G. 100 PASS DP = 1411 GT:GQ:AD:DP:VF:NL:SB:NC:US 0/0:1:1411:1411:0.00000:65:-100.0000:0.0741:0,0,0,0,0,0,0,0,0,0,0,0
//The affected methods are "AddAcceptedPhasedVariant" and "AddRejectedPhasedVariant"
//the new fix will merge the added variant, if its the same as a varaint that already exists
public void AddAcceptedAndRejectedPhasedVariantTests()
{
//for this test we take three SNPs, two of which can be combined and 1 that cannot, and
//we take three ref calls, two of which can be combined and 1 that cannot.
//So 6 diff alleles go in, but only 4 should come out in the lists.
var originalVcfVariant1 = TestHelper.CreateDummyAllele("chr1", 123, "A", "T", 500, 156);
var originalVcfVariant2 = TestHelper.CreateDummyAllele("chr1", 123, "A", "T", 1000, 200);
var vs1 = new VariantSite(originalVcfVariant1);
var vs2 = new VariantSite(originalVcfVariant2);
var caller = new VariantCaller(new VariantCallingParameters(), new BamFilterParameters());
var nbhd = new VcfNeighborhood(0, "chr1", vs1, vs2);
var callableNeighborhood = new CallableNeighborhood(nbhd, new VariantCallingParameters());
//variants:
callableNeighborhood.AddAcceptedPhasedVariant(
new CalledAllele(AlleleCategory.Snv)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = "T",
VariantQscore = 100,
TotalCoverage = 1000,
AlleleSupport = 200,
ReferenceSupport = 350,
NoiseLevelApplied = 20
});
callableNeighborhood.AddAcceptedPhasedVariant(
new CalledAllele(AlleleCategory.Snv)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = "T",
VariantQscore = 20,
TotalCoverage = 500,
AlleleSupport = 300,
ReferenceSupport = 50,
NoiseLevelApplied = 20
});
callableNeighborhood.AddAcceptedPhasedVariant(
new CalledAllele(AlleleCategory.Snv)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = "G",
VariantQscore = 20,
TotalCoverage = 500,
AlleleSupport = 300,
ReferenceSupport = 50,
NoiseLevelApplied = 20
});
callableNeighborhood.AddAcceptedPhasedVariant(
new CalledAllele(AlleleCategory.Snv)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = "AG",
VariantQscore = 20,
TotalCoverage = 500,
AlleleSupport = 300,
ReferenceSupport = 50,
NoiseLevelApplied = 20
});
//refs:
callableNeighborhood.AddRejectedPhasedVariant(
new CalledAllele(AlleleCategory.Reference)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = ".",
VariantQscore = 100,
TotalCoverage = 1000,
AlleleSupport = 200,
ReferenceSupport = 350,
NoiseLevelApplied = 20
});
callableNeighborhood.AddRejectedPhasedVariant(
new CalledAllele(AlleleCategory.Reference)
{
Chromosome = "chr1",
ReferencePosition = 123,
ReferenceAllele = "A",
AlternateAllele = ".",
VariantQscore = 20,
TotalCoverage = 500,
AlleleSupport = 300,
ReferenceSupport = 50,
NoiseLevelApplied = 20
});
callableNeighborhood.AddRejectedPhasedVariant(
new CalledAllele(AlleleCategory.Reference)
{
Chromosome = "chr1",
ReferencePosition = 124,
ReferenceAllele = "A",
AlternateAllele = ".",
VariantQscore = 20,
TotalCoverage = 500,
AlleleSupport = 300,
ReferenceSupport = 50,
NoiseLevelApplied = 20
});
//check results.
//check we got the right number of results
Assert.Equal(3, callableNeighborhood.CandidateVariants.Count);
Assert.Equal(2, callableNeighborhood.Refs.Count);
//check the snps did what we expected
var combinedSnp = callableNeighborhood.CandidateVariants[0];
Assert.Equal(123, combinedSnp.ReferencePosition);
Assert.Equal("chr1", combinedSnp.Chromosome);
Assert.Equal("A", combinedSnp.ReferenceAllele);
Assert.Equal("T", combinedSnp.AlternateAllele);
Assert.Equal(200 + 300, combinedSnp.AlleleSupport);
Assert.Equal(0, combinedSnp.NumNoCalls);
Assert.Equal(100, combinedSnp.VariantQscore);
Assert.Equal((1000 + 500) / 2, combinedSnp.TotalCoverage);
Assert.Equal((350 + 50) / 2, combinedSnp.ReferenceSupport);
Assert.Equal(AlleleCategory.Snv, combinedSnp.Type);
Assert.Equal(20, combinedSnp.NoiseLevelApplied);
//these values should not have changed
var justAddedSnp = callableNeighborhood.CandidateVariants[1];
Assert.Equal(123, justAddedSnp.ReferencePosition);
Assert.Equal("chr1", justAddedSnp.Chromosome);
Assert.Equal("A", justAddedSnp.ReferenceAllele);
Assert.Equal("G", justAddedSnp.AlternateAllele);
Assert.Equal(300, justAddedSnp.AlleleSupport);
Assert.Equal(0, justAddedSnp.NumNoCalls);
Assert.Equal(20, justAddedSnp.VariantQscore);
Assert.Equal(500, justAddedSnp.TotalCoverage);
Assert.Equal(50, justAddedSnp.ReferenceSupport);
Assert.Equal(AlleleCategory.Snv, justAddedSnp.Type);
Assert.Equal(20, justAddedSnp.NoiseLevelApplied);
}