public void GenerateVcfStrings_IncludeHeaders()
{
if (MiscUtils.IsRunningAnyLinux)
{
return; // currently failing on linux :(
}
var parser = VcfVariantParserSettings.Create(ImmutableList.Create(SampleName));
var variants = VcfVariant.TryParse(Bnd1, parser).FollowedBy(VcfVariant.TryParse(Bnd2, parser)).EnumerateSuccesses().ToList();
var wittyerVariant = WittyerBndInternal.Create(variants[0],
variants[0].ToTryOfGenotypedVcfVariant(VariantNormalizer.TrimCommonBases).GetOrThrow().Samples.Values.First(),
WittyerType.IntraChromosomeBreakend, new List <uint>(), uint.MinValue, null, variants[1]);
var headerLines = WittyerVcfWriter.GenerateVcfStrings(
WittyerResult.Create(VcfHeader.CreateBuilder(VcfVersion.FourPointOne).Build(), SampleName,
variants.Select(v => v.Contig).Distinct().ToList(), false,
new Dictionary <WittyerType, IReadOnlyList <IWittyerVariant> >(),
new Dictionary <WittyerType, IReadOnlyList <IWittyerBnd> >
{
{ WittyerType.IntraChromosomeBreakend, new List <IWittyerBnd> {
wittyerVariant
} }
}, new List <IVcfVariant>()), null, null)
.TakeWhile(line => line.StartsWith(VcfConstants.Header.Prefix)).ToList();
// 11 = VcfVersion, WHO, WHAT, WHERE, WHY, WIT, WIN, WOW, date, version, column names
Assert.Equal(11, headerLines.Count);
}
public void OverlapWorks_DupDel([NotNull] string truthVar, [NotNull] string queryVar, string type, bool isTp)
{
const string sampleName = "blah";
var vcfVariantParserSettings = VcfVariantParserSettings.Create(new List <string> {
sampleName
});
var baseVariant = VcfVariant.TryParse(truthVar, vcfVariantParserSettings).GetOrThrow();
const bool isCrossTypeOn = true;
var wittyerType = WittyerType.Parse(type);
var inputSpecs = InputSpec.GenerateCustomInputSpecs(!isCrossTypeOn, new[] { wittyerType }, percentDistance: PercentDistance).ToDictionary(s => s.VariantType, s => s);
var bndSet = new Dictionary <IGeneralBnd, IVcfVariant>();
var errorList = new List <string>();
var truthV = (IMutableWittyerSimpleVariant)WittyerVcfReader.CreateVariant(baseVariant, baseVariant.Samples.First().Value, true, sampleName,
inputSpecs, bndSet, errorList, isCrossTypeOn);
baseVariant = VcfVariant.TryParse(queryVar, vcfVariantParserSettings).GetOrThrow();
var queryV = (IMutableWittyerVariant)WittyerVcfReader.CreateVariant(baseVariant, baseVariant.Samples.First().Value, false, sampleName,
inputSpecs, bndSet, errorList, isCrossTypeOn);
var tree = TruthForest.Create(sampleName, VcfHeader.CreateBuilder(VcfVersion.FourPointOne).Build());
tree.AddTarget(truthV);
OverlappingUtils.DoOverlapping(tree.VariantTrees, queryV, OverlappingUtils.IsVariantAlleleMatch, isCrossTypeOn, true);
queryV.Finalize(WitDecision.FalsePositive, EvaluationMode.CrossTypeAndSimpleCounting, null);
truthV.Finalize(WitDecision.FalseNegative, EvaluationMode.CrossTypeAndSimpleCounting, null);
Assert.Equal(isTp ? WitDecision.TruePositive : WitDecision.FalsePositive, queryV.Sample.Wit);
Assert.Equal(isTp ? WitDecision.TruePositive : WitDecision.FalseNegative, truthV.Sample.Wit);
}
public static void WittyerVariantIntervalCorrect([NotNull] string variant, uint start, uint end,
uint posStart, uint posEnd, uint endStart, uint endEnd)
{
const string sampleName = "tumor";
var vcfVariant = VcfVariant.TryParse(variant,
VcfVariantParserSettings.Create(ImmutableList.Create("normal", sampleName), GenomeAssembly.Hg38))
.GetOrThrowDebug();
var _ = WittyerType.ParseFromVariant(vcfVariant, false, sampleName, out var type);
if (type == null)
{
throw new NotSupportedException("This test does not handle svType null");
}
var wittyerVariant = WittyerVariantInternal
.Create(vcfVariant, vcfVariant.Samples[sampleName], type, Bins, PercentDistance, BasepairDistance);
var expectedStart = ContigAndInterval.Create(vcfVariant.Contig, start, end);
var expectedPos = BedInterval.Create(posStart, posEnd);
var expectedEnd = BedInterval.Create(endStart, endEnd);
MultiAssert.Equal(expectedStart, wittyerVariant);
MultiAssert.Equal(expectedPos, wittyerVariant.CiPosInterval);
MultiAssert.Equal(expectedEnd, wittyerVariant.CiEndInterval);
MultiAssert.AssertAll();
}
public void ToStringBnd()
{
var parser = VcfVariantParserSettings.Create(ImmutableList.Create(SampleName));
var variant = VcfVariant.TryParse(Bnd1, parser).GetOrThrow();
var actual = WittyerVcfWriter.ToString(variant, null);
Assert.Equal(Bnd1, actual);
}
public void ToStringNoValueWorks()
{
var parser = VcfVariantParserSettings.Create(ImmutableList.Create(SampleName));
var variant = VcfVariant.TryParse(NoValueUnsorted, parser).GetOrThrow();
var actual = WittyerVcfWriter.ToString(variant, null);
Assert.Equal(NoValueSorted, actual);
}
public void GetInsertionIntervalNoLenIns()
{
var variant = VcfVariant
.TryParse(UnknownLength, VcfVariantParserSettings.Create(ImmutableList.Create("blah"))).GetOrThrow();
var bedInterval = WittyerBndInternal.GetInsertionInterval(variant);
MultiAssert.Equal(null, bedInterval?.GetLength());
MultiAssert.AssertAll();
}
public static void ParseReferenceVariantWorks([NotNull] string inputVariant)
{
var vcfVariant = VcfVariant.TryParse(inputVariant,
VcfVariantParserSettings.Create(ImmutableList.Create("NA12878", "haha"), GenomeAssembly.Hg19))
.GetOrThrowDebug();
WittyerType.ParseFromVariant(vcfVariant, false, "NA12878", out var actualType);
Assert.Equal(WittyerType.CopyNumberReference, actualType);
}
private static IWittyerBnd CreateWittyerBnd([NotNull] string bndLine1, [NotNull] string bndLine2)
{
var variant = VcfVariant.TryParse(bndLine1,
VcfVariantParserSettings.Create(ImmutableList.Create("normal"), GenomeAssembly.Grch37))
.GetOrThrowDebug();
return(WittyerBndInternal.Create(variant, variant.Samples["normal"], WittyerType.TranslocationBreakend, Bins,
BasepairDistance, PercentDistance, VcfVariant.TryParse(bndLine2,
VcfVariantParserSettings.Create(ImmutableList.Create("normal"), GenomeAssembly.Grch37))
.GetOrThrowDebug()));
}
public static void WittyerVariantReaderWorks()
{
var vcfSettings =
VcfVariantParserSettings.Create(ImmutableList.Create("proband", "father"), GenomeAssembly.Grch37);
var ref1 = VcfVariant.TryParse(RefSiteUndeterminedGt, vcfSettings).GetOrThrowDebug();
WittyerVcfReader.CreateVariant(ref1, ref1.Samples.First().Value, false, "proband",
new Dictionary <WittyerType, InputSpec>
{
{
WittyerType.CopyNumberReference,
InputSpec.GenerateCustomInputSpecs(false, new[] { WittyerType.CopyNumberReference }, percentDistance: 0.05).First()
}
}, new Dictionary <IGeneralBnd, IVcfVariant>(), new List <string>(), true);
}
private static IWittyerSimpleVariant CreateWittyerVariant([NotNull] string vcfline)
{
var baseVariant = VcfVariant.TryParse(vcfline,
VcfVariantParserSettings.Create(ImmutableList.Create("normal"), GenomeAssembly.Grch37))
.GetOrThrowDebug();
WittyerType.ParseFromVariant(baseVariant, true, null, out var svType);
if (svType == null)
{
throw new NotSupportedException("This method does not handle svType null");
}
return(WittyerVariantInternal
.Create(baseVariant, baseVariant.Samples["normal"], svType, Bins, PercentDistance, BasepairDistance));
}
public void ComparerWorks()
{
if (MiscUtils.IsRunningAnyLinux)
{
return; // currently failing on linux :(
}
IReadOnlyList <IContigInfo> CreateHeader(string fileName) => VcfHeader
.TryCreate(Path.Combine("Resources", "VcfHeaders", fileName).ToFileInfo()).GetOrThrow()
.ColumnMetaInfoLines.ContigLines.Select(kvp => kvp.Value.Contig).ToReadOnlyList();
var comparer = WittyerVcfWriter.CreateComparer(CreateHeader("query.vcf.gz"), CreateHeader("truth.vcf.gz"));
var parser = VcfVariantParserSettings.Create(ImmutableList.Create(SampleName));
var bnd1 = VcfVariant.TryParse(Bnd1, parser).GetOrThrow();
var bnd2 = VcfVariant.TryParse(Bnd2, parser).GetOrThrow();
Assert.True(comparer.Compare(bnd1, bnd2) < 0);
}
public static void ParseWittyerVariantType_AssignCorrectType([NotNull] string vcfString, bool isCrossTypeOn,
[CanBeNull] string expected)
{
const string sampleName = "s1";
var variant = VcfVariant.TryParse(vcfString,
VcfVariantParserSettings.Create(ImmutableList.Create(sampleName, "s2"), GenomeAssembly.Hg38))
.GetOrThrowDebug();
var reason = WittyerType.ParseFromVariant(variant, isCrossTypeOn, sampleName, out var assignedType);
if (expected == null)
{
Assert.Equal(FailedReason.UndeterminedCn, reason);
}
else
{
Assert.Equal(WittyerType.Parse(expected), assignedType);
}
}
public static void WittyerIntraBndWorkCorrectly()
{
var vcfSettings =
VcfVariantParserSettings.Create(ImmutableList.Create("proband", "father"), GenomeAssembly.Grch37);
var bnd1 = VcfVariant.TryParse(GenotypedIntraBnd, vcfSettings).GetOrThrowDebug();
var bnd2 = VcfVariant.TryParse(GenotypedIntraBndPair, vcfSettings).GetOrThrowDebug();
var wittyerBnd = WittyerBndInternal
.Create(bnd2, bnd2.Samples["father"], WittyerType.IntraChromosomeBreakend, Bins, BasepairDistance,
PercentDistance, bnd1);
var distance = Math.Round(Math.Abs(bnd1.Position - bnd2.Position) * PercentDistance);
var expectedEndInterval = ContigAndInterval.Create(wittyerBnd.Contig, bnd1.Position - (uint)distance - 1,
bnd1.Position + (uint)distance);
MultiAssert.Equal(expectedEndInterval, wittyerBnd.EndInterval);
MultiAssert.Equal(10000U, wittyerBnd.Win.End);
MultiAssert.AssertAll();
Assert.IsType <WittyerGenotypedSample>(wittyerBnd.Sample);
}
private static bool ParseVariantGetTag([NotNull] string variant, WitDecision targetDecision)
{
var parser = VcfVariantParserSettings.Create(new List <string> {
"sample"
});
var vcfVariant = VcfVariant.TryParse(variant, parser).GetOrThrow();
var sampleDictionary = vcfVariant.Samples.Single().Value.SampleDictionary;
if (vcfVariant.Info.TryGetValue(WittyerConstants.WittyerMetaInfoLineKeys.Who, out var who))
{
if (who.Split(WittyerConstants.SampleValueDel).Length > WittyerConstants.MaxNumberOfAnnotations)
{
return(false);
}
}
return(sampleDictionary
.TryGetValue(WittyerConstants.WittyerMetaInfoLineKeys.Wit).Any(it =>
it != VcfConstants.MissingValueString &&
(it != targetDecision.ToStringDescription() && it != NotAssessedString || sampleDictionary
.TryGetValue(WittyerConstants.WittyerMetaInfoLineKeys.Why)
.Any(val => val != VcfConstants.MissingValueString))));
}
public static void WittyerBndCreateCorrectly()
{
var vcfSettings =
VcfVariantParserSettings.Create(ImmutableList.Create("proband", "father"), GenomeAssembly.Grch37);
var bnd1 = VcfVariant.TryParse(GenotypedBnd, vcfSettings).GetOrThrowDebug();
var bnd2 = VcfVariant.TryParse(GenotypedBndPair, vcfSettings).GetOrThrowDebug();
var wittyerBnd = WittyerBndInternal
.Create(bnd2, bnd2.Samples["father"], WittyerType.TranslocationBreakend, Bins,
BasepairDistance, PercentDistance, bnd1);
var expectedContig = ContigInfo.Create("1");
var expectedEndInterval = ContigAndInterval.Create(ContigInfo.Create("4"), 191034451, 191035452);
MultiAssert.Equal(expectedContig, wittyerBnd.Contig);
MultiAssert.Equal(expectedEndInterval, wittyerBnd.EndInterval);
MultiAssert.Equal(230675U, wittyerBnd.Start);
MultiAssert.Equal(231676U, wittyerBnd.Stop);
MultiAssert.Equal(WittyerConstants.StartingBin, wittyerBnd.Win.Start);
MultiAssert.Equal(null, wittyerBnd.Win.End);
MultiAssert.AssertAll();
}
