public void IntersectOperationTest() { string resultfilepath = "tmp_mergeresult.bed"; string expectedresultpath = string.Empty; BedParser parser = new BedParser(); BedFormatter formatter = new BedFormatter(); SequenceRangeGrouping result = null; bool resultvalue = false; resultfilepath = "tmp_mergeresult.bed"; string reffile = @"testdata\BED\Intersect\Intersect_ref.BED"; string queryFile = @"testdata\BED\Intersect\Intersect_query.BED"; SequenceRangeGrouping refSeqRange = parser.ParseRangeGrouping(reffile); SequenceRangeGrouping querySeqRange = parser.ParseRangeGrouping(queryFile); expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap1_OverLappingBases.BED"; result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingPiecesOfIntervals); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 1, true); Assert.IsTrue(resultvalue); expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap1.BED"; result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingIntervals); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 1, false); Assert.IsTrue(resultvalue); expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap0_OverLappingBases.BED"; result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingPiecesOfIntervals); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 0, true); Assert.IsTrue(resultvalue); expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap0.BED"; result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingIntervals); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 0, false); Assert.IsTrue(resultvalue); expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap1_OverLappingBases.BED"; result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingPiecesOfIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 1, true); Assert.IsTrue(resultvalue); expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap1.BED"; result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 1, true); Assert.IsTrue(resultvalue); expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap0_OverLappingBases.BED"; result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingPiecesOfIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 0, true); Assert.IsTrue(resultvalue); expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap0.BED"; result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 0, true); Assert.IsTrue(resultvalue); }
/// <summary> /// Validate BED Operations(Merge,Intersect).. /// </summary> /// <param name="nodeName">Xml Node name for different inputs.</param> /// <param name="operationPam">Different Bed operations.</param> /// <param name="overlappingBasePair">overlapping base pair</param> /// <param name="isParentSeqRangeRequired">Is Parent Sequence Range required?</param> private void ValidateBedOperations(string nodeName, BedOperationsParameters operationPam, bool overlappingBasePair, bool isParentSeqRangeRequired) { // Get values from xml. string expectedRangeIDs = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.IDNode); string expectedStartIndex = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.StartNode); string expectedEndIndex = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.EndNode); string referenceFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode).TestDir(); string queryFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.QueryFilePath).TestDir(); string minimalOverlap = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.OverlapValue); SequenceRangeGrouping operationResult = null; // Parse a BED file. var parserObj = new BedParser(); SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(referenceFilePath); SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath); var intersectOutputType = IntersectOutputType.OverlappingIntervals; if (overlappingBasePair) { intersectOutputType = IntersectOutputType.OverlappingPiecesOfIntervals; } var subtractOutputType = SubtractOutputType.NonOverlappingPiecesOfIntervals; if (overlappingBasePair) { subtractOutputType = SubtractOutputType.IntervalsWithNoOverlap; } switch (operationPam) { case BedOperationsParameters.Merge: operationResult = referenceGroup.MergeOverlaps(); break; case BedOperationsParameters.MergeWithPam: operationResult = referenceGroup.MergeOverlaps(queryGroup, 0, isParentSeqRangeRequired); break; case BedOperationsParameters.Intersect: operationResult = referenceGroup.Intersect(queryGroup, long.Parse(minimalOverlap, null), intersectOutputType, isParentSeqRangeRequired); break; case BedOperationsParameters.MergeQueryWithReference: operationResult = queryGroup.MergeOverlaps(referenceGroup, 0, isParentSeqRangeRequired); break; case BedOperationsParameters.Subtract: operationResult = referenceGroup.Subtract(queryGroup, long.Parse(minimalOverlap, null), subtractOutputType, isParentSeqRangeRequired); break; default: break; } // Get a result SequenceGroup Id. IEnumerable <string> groupId = operationResult.GroupIDs; string[] expectedRangeIdsArray = expectedRangeIDs.Split(','); string[] expectedStartIndexArray = expectedStartIndex.Split(','); string[] expectedEndIndexArray = expectedEndIndex.Split(','); int i = 0; foreach (string grpId in groupId) { string rangeId = grpId; List <ISequenceRange> rangeList = operationResult.GetGroup(rangeId); // Validate result sequence range. foreach (ISequenceRange range in rangeList) { Assert.AreEqual(expectedRangeIdsArray[i], range.ID); Assert.AreEqual(expectedStartIndexArray[i], range.Start.ToString((IFormatProvider)null)); Assert.AreEqual(expectedEndIndexArray[i], range.End.ToString((IFormatProvider)null)); i++; } } // Validate ParentSeqRange. bool result = ValidateParentSeqRange(operationResult, referenceGroup, queryGroup, isParentSeqRangeRequired); Assert.IsTrue(result); ApplicationLog.WriteLine("Bed Operations BVT: Successfully validated the BED SequenceID, Start and End Ranges"); }
/// <summary> /// Indentify hot spot chromosomes for length anamoly regions. /// </summary> /// <param name="inputFile"> Input file</param> /// <param name="mean">Mean value</param> /// <param name="standardDeviation">Standard deviation</param> private void IdentifyLentghAnamolies(string filename, float mean = -1, float deviation = -1) { bool calculateMeanNdeviation = false; if (mean == -1 || deviation == -1) { calculateMeanNdeviation = true; } SequenceAlignmentMap alignmentMapobj = null; if (!SAMInput) { BAMParser bamParser = new BAMParser(); alignmentMapobj = bamParser.Parse(filename); } else { SAMParser samParser = new SAMParser(); alignmentMapobj = samParser.Parse(filename); } // get reads from sequence alignment map object. IList <PairedRead> pairedReads = null; if (calculateMeanNdeviation) { pairedReads = alignmentMapobj.GetPairedReads(); } else { pairedReads = alignmentMapobj.GetPairedReads(mean, deviation); } // Get the orphan regions. var orphans = pairedReads.Where(PR => PR.PairedType == PairedReadType.Orphan); if (orphans.Count() == 0) { Console.WriteLine("No Orphans to display"); } List <ISequenceRange> orphanRegions = new List <ISequenceRange>(orphans.Count()); foreach (PairedRead orphanRead in orphans) { orphanRegions.Add(GetRegion(orphanRead.Read1)); } // Get sequence range grouping for Orphan regions. SequenceRangeGrouping orphanRangegroup = new SequenceRangeGrouping(orphanRegions); // Get the Length anomalies regions. var lengthAnomalies = pairedReads.Where(PE => PE.PairedType == PairedReadType.LengthAnomaly); if (lengthAnomalies.Count() == 0) { Console.WriteLine("No Anomalies to display"); } List <ISequenceRange> lengthAnomalyRegions = new List <ISequenceRange>(lengthAnomalies.Count()); foreach (PairedRead laRead in lengthAnomalies) { SequenceRange range = new SequenceRange(); range.ID = laRead.Read1.RName; range.Start = laRead.Read1.Pos; range.End = laRead.Read1.Pos + laRead.InsertLength; lengthAnomalyRegions.Add(range); } // Get sequence range grouping for length anomaly regions. SequenceRangeGrouping lengthAnomalyRangegroup = new SequenceRangeGrouping(lengthAnomalyRegions); if (lengthAnomalyRangegroup.GroupIDs.Count() == 0) { Console.Write("\r\nNo Length anomalies reads to display"); } else { Console.Write("Region of length anomaly:"); DisplaySequenceRange(lengthAnomalyRangegroup); } if (orphanRangegroup.GroupIDs.Count() == 0) { Console.Write("\r\nNo Orphan reads to display"); } else { Console.Write("\r\nRegion of Orphan reads:"); DisplaySequenceRange(orphanRangegroup); } SequenceRangeGrouping intersectedRegions = lengthAnomalyRangegroup.Intersect(orphanRangegroup); if (intersectedRegions.GroupIDs.Count() == 0) { Console.Write("\r\nNo Hot spots found"); } else { Console.Write("\r\nChromosomal Hot spot of length anomaly and Orphan region:"); DisplaySequenceRange(intersectedRegions); } }
/// <summary> /// Validate BED Operations(Merge,Intersect).. /// </summary> /// <param name="nodeName">Xml Node name for different inputs.</param> /// <param name="operationPam">Different Bed operations.</param> /// <param name="overlappingBasePair">overlapping base pair</param> /// <param name="IsParentSeqRangeRequired">Is Parent Sequence Range required?</param> static void ValidateBedOperations(string nodeName, BedOperationsParameters operationPam, bool overlappingBasePair, bool IsParentSeqRangeRequired) { // Get values from xml. string expectedRangeIDs = Utility._xmlUtil.GetTextValue( nodeName, Constants.IDNode); string expectedStartIndex = Utility._xmlUtil.GetTextValue( nodeName, Constants.StartNode); string expectedEndIndex = Utility._xmlUtil.GetTextValue( nodeName, Constants.EndNode); string referenceFilePath = Utility._xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); string queryFilePath = Utility._xmlUtil.GetTextValue( nodeName, Constants.QueryFilePath); string minimalOverlap = Utility._xmlUtil.GetTextValue( nodeName, Constants.OverlapValue); string rangeID = string.Empty; string actualStarts = string.Empty; string actualEnds = string.Empty; string actualIDs = string.Empty; bool result = false; List <ISequenceRange> rangeList = null; SequenceRangeGrouping operationResult = null; // Parse a BED file. BedParser parserObj = new BedParser(); SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(referenceFilePath); SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath); IntersectOutputType intersectOutputType = IntersectOutputType.OverlappingIntervals; if (overlappingBasePair) { intersectOutputType = IntersectOutputType.OverlappingPiecesOfIntervals; } SubtractOutputType subtractOutputType = SubtractOutputType.NonOverlappingPiecesOfIntervals; if (overlappingBasePair) { subtractOutputType = SubtractOutputType.IntervalsWithNoOverlap; } switch (operationPam) { case BedOperationsParameters.Merge: operationResult = referenceGroup.MergeOverlaps(); break; case BedOperationsParameters.MergeWithPam: operationResult = referenceGroup.MergeOverlaps(queryGroup, 0, IsParentSeqRangeRequired); break; case BedOperationsParameters.Intersect: operationResult = referenceGroup.Intersect(queryGroup, long.Parse(minimalOverlap), intersectOutputType, IsParentSeqRangeRequired); break; case BedOperationsParameters.MergeQueryWithReference: operationResult = queryGroup.MergeOverlaps(referenceGroup, 0, IsParentSeqRangeRequired); break; case BedOperationsParameters.Subtract: operationResult = referenceGroup.Subtract(queryGroup, long.Parse(minimalOverlap), subtractOutputType, IsParentSeqRangeRequired); break; default: break; } // Get a result SequenceGroup Id. IEnumerable <string> groupId = operationResult.GroupIDs; foreach (string grpID in groupId) { rangeID = grpID; rangeList = operationResult.GetGroup(rangeID); // Validate result sequence range. foreach (ISequenceRange range in rangeList) { actualStarts = string.Concat(actualStarts, range.Start.ToString(), ","); actualEnds = string.Concat(actualEnds, range.End.ToString(), ","); actualIDs = string.Concat(actualIDs, range.ID.ToString(), ","); } } Assert.AreEqual(expectedRangeIDs, actualIDs.Substring(0, actualIDs.Length - 1)); Assert.AreEqual(expectedStartIndex, actualStarts.Substring(0, actualStarts.Length - 1)); Assert.AreEqual(expectedEndIndex, actualEnds.Substring(0, actualEnds.Length - 1)); // Validate ParentSeqRange. result = ValidateParentSeqRange(operationResult, referenceGroup, queryGroup, IsParentSeqRangeRequired); Assert.IsTrue(result); ApplicationLog.WriteLine( "Bed Parser BVT: Successfully validated the BED SequenceID, Start and End Ranges"); }
/// <summary> /// Validate Intersect SequenceRangeGrouping. /// </summary> /// <param name="nodeName">Xml Node name for different inputs.</param> /// <param name="overlappingBasePair">Value of overlappingBasePair</param> void IntersectSequenceRange(string nodeName, bool overlappingBasePair, bool IsParentSeqRangeRequired) { // Get values from xml. string[] expectedRangeIDs = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.IDNode).Split(','); string[] expectedStartIndex = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.StartNode).Split(','); string[] expectedEndIndex = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.EndNode).Split(','); string referenceFilePath = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); string queryFilePath = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.QueryFilePath); string minimalOverlap = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.OverlapValue); string rangeID = string.Empty; bool result = false; List <ISequenceRange> rangeList = null; // Parse a BED file. BedParser parserObj = new BedParser(); SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(referenceFilePath); SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath); IntersectOutputType outputType = IntersectOutputType.OverlappingIntervals; if (overlappingBasePair) { outputType = IntersectOutputType.OverlappingPiecesOfIntervals; } // Intersect a SequenceRangeGroup. SequenceRangeGrouping intersectGroup = referenceGroup.Intersect(queryGroup, long.Parse(minimalOverlap, (IFormatProvider)null), outputType); // Get a intersect SequenceGroup Id. IEnumerable <string> groupIds = intersectGroup.GroupIDs; int j = 0; foreach (string grpID in groupIds) { rangeID = grpID; rangeList = intersectGroup.GetGroup(rangeID); // Validate intersect sequence range. foreach (ISequenceRange range in rangeList) { Assert.AreEqual(expectedStartIndex[j], range.Start.ToString((IFormatProvider)null)); Assert.AreEqual(expectedEndIndex[j], range.End.ToString((IFormatProvider)null)); Assert.AreEqual(expectedRangeIDs[j], range.ID.ToString((IFormatProvider)null)); j++; } } // Validate ParentSeqRanges. result = ValidateParentSeqRange(intersectGroup, referenceGroup, queryGroup, IsParentSeqRangeRequired); Assert.IsTrue(result); ApplicationLog.WriteLine( "Bed Parser BVT: Successfully validated the intersect SequeID, Start and End Ranges"); Console.WriteLine(string.Format((IFormatProvider)null, "Bed Parser BVT: Successfully validated the merged SequeID, Start and End Ranges")); }
/// <summary> /// Tests Length Anomalies /// </summary> /// <param name="alignmentMapobj">Sequence alignment map.</param> private static void TestLengthAnomalies(SequenceAlignmentMap alignmentMapobj) { string expectedOutput; string actualOutput; expectedOutput = "9437-9447:9440-9447:"; actualOutput = string.Empty; // get reads from sequence alignment map object. IList <PairedRead> pairedReads = null; pairedReads = alignmentMapobj.GetPairedReads(200, 50); // Get the orphan regions. var orphans = pairedReads.Where(PR => PR.PairedType == PairedReadType.Orphan); if (orphans.Count() == 0) { Assert.Fail(); } List <ISequenceRange> orphanRegions = new List <ISequenceRange>(orphans.Count()); foreach (PairedRead orphanRead in orphans) { orphanRegions.Add(GetRegion(orphanRead.Read1)); } // Get sequence range grouping for Orphan regions. SequenceRangeGrouping orphanRangegroup = new SequenceRangeGrouping(orphanRegions); // Get the Length anomalies regions. var lengthAnomalies = pairedReads.Where(PE => PE.PairedType == PairedReadType.LengthAnomaly); if (lengthAnomalies.Count() == 0) { Assert.Fail(); } List <ISequenceRange> lengthAnomalyRegions = new List <ISequenceRange>(lengthAnomalies.Count()); foreach (PairedRead laRead in lengthAnomalies) { SequenceRange range = new SequenceRange(); range.ID = laRead.Read1.RName; range.Start = laRead.Read1.Pos; range.End = laRead.Read1.Pos + laRead.InsertLength; lengthAnomalyRegions.Add(range); } // Get sequence range grouping for length anomaly regions. SequenceRangeGrouping lengthAnomalyRangegroup = new SequenceRangeGrouping(lengthAnomalyRegions); SequenceRangeGrouping intersectedRegions = lengthAnomalyRangegroup.Intersect(orphanRangegroup); foreach (var range in intersectedRegions.GroupRanges) { actualOutput += range.Start + "-" + range.End + ":"; } Assert.AreEqual(expectedOutput, actualOutput); }
public void IntersectOperationTest() { string resultfilepath = "tmp_mergeresult.bed"; string expectedresultpath = string.Empty; BedParser parser = new BedParser(); BedFormatter formatter = new BedFormatter(); SequenceRangeGrouping result = null; bool resultvalue = false; resultfilepath = "tmp_mergeresult.bed"; string direc = Path.Combine("TestUtils", "BED", "Intersect"); string reffile = Path.Combine(direc, "Intersect_ref.BED").TestDir(); string queryFile = Path.Combine(direc, "Intersect_query.BED").TestDir(); SequenceRangeGrouping refSeqRange = parser.ParseRangeGrouping(reffile); SequenceRangeGrouping querySeqRange = parser.ParseRangeGrouping(queryFile); expectedresultpath = Path.Combine(direc, "Result_Intersect_MinOverlap1_OverLappingBases.BED").TestDir(); result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingPiecesOfIntervals); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Intersect_MinOverlap1.BED").TestDir(); result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingIntervals); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Intersect_MinOverlap0_OverLappingBases.BED").TestDir(); result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingPiecesOfIntervals); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Intersect_MinOverlap0.BED").TestDir(); result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingIntervals); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Intersect_MinOverlap1_OverLappingBases.BED").TestDir(); result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingPiecesOfIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Intersect_MinOverlap1.BED").TestDir(); result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Intersect_MinOverlap0_OverLappingBases.BED").TestDir(); result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingPiecesOfIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Intersect_MinOverlap0.BED").TestDir(); result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); File.Delete(resultfilepath); }