public void SubtractTest() { var direc = System.IO.Path.Combine ("TestUtils", "BED", "Subtract"); string refSeqRangefile = System.IO.Path.Combine (direc, "Subtract_ref.BED"); string querySeqRangefile = System.IO.Path.Combine (direc, "Subtract_query.BED"); string resultfilepath = "tmp_mergeresult.bed"; BedParser parser = new BedParser(); BedFormatter formatter = new BedFormatter(); SequenceRangeGrouping result = null; bool resultvalue = false; SequenceRangeGrouping refSeqRange = parser.ParseRangeGrouping(refSeqRangefile); SequenceRangeGrouping querySeqRange = parser.ParseRangeGrouping(querySeqRangefile); string expectedresultpath = System.IO.Path.Combine (direc, "Result_Subtract_minoverlap1.BED"); result = refSeqRange.Subtract(querySeqRange, 1, SubtractOutputType.IntervalsWithNoOverlap); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = System.IO.Path.Combine (direc, "Result_Subtract_minoverlap0.BED"); result = refSeqRange.Subtract(querySeqRange, 0, SubtractOutputType.IntervalsWithNoOverlap); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = System.IO.Path.Combine (direc, "Result_Subtract_minoverlap1.BED"); result = refSeqRange.Subtract(querySeqRange, 1, SubtractOutputType.IntervalsWithNoOverlap, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = System.IO.Path.Combine (direc, "Result_Subtract_minoverlap0.BED"); result = refSeqRange.Subtract(querySeqRange, 0, SubtractOutputType.IntervalsWithNoOverlap, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = System.IO.Path.Combine (direc, "Result_Subtract_minoverlap1.BED"); result = refSeqRange.Subtract(querySeqRange, 1, SubtractOutputType.IntervalsWithNoOverlap, false); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, false); Assert.IsTrue(resultvalue); expectedresultpath = System.IO.Path.Combine (direc, "Result_Subtract_minoverlap0.BED"); result = refSeqRange.Subtract(querySeqRange, 0, SubtractOutputType.IntervalsWithNoOverlap, false); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, false); Assert.IsTrue(resultvalue); expectedresultpath = System.IO.Path.Combine (direc, "Result_Subtract_minoverlap0_NOnOverlappingPieces.BED"); result = refSeqRange.Subtract(querySeqRange, 0, SubtractOutputType.NonOverlappingPiecesOfIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); expectedresultpath = System.IO.Path.Combine (direc, "Result_Subtract_minoverlap1_NOnOverlappingPieces.BED"); result = refSeqRange.Subtract(querySeqRange, 1, SubtractOutputType.NonOverlappingPiecesOfIntervals, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); }
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"); string queryFile = Path.Combine(direc, "Intersect_query.BED"); SequenceRangeGrouping refSeqRange = parser.ParseRangeGrouping(reffile); SequenceRangeGrouping querySeqRange = parser.ParseRangeGrouping(queryFile); expectedresultpath = Path.Combine(direc, "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, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "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, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "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, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "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, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "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, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "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, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "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, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "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, true); Assert.IsTrue(resultvalue); File.Delete(resultfilepath); }
public void MergeOperationTest() { string direc = Path.Combine ("TestUtils", "BED", "Merge"); string filepath = Path.Combine(direc, "Merge_single.BED"); string resultfilepath = "tmp_mergeresult.bed"; string expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength0.BED"); BedParser parser = new BedParser(); BedFormatter formatter = new BedFormatter(); SequenceRangeGrouping seqGrouping = null; SequenceRangeGrouping result = null; bool resultvalue = false; resultfilepath = "tmp_mergeresult.bed"; expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength0.BED"); seqGrouping = parser.ParseRangeGrouping(filepath); result = seqGrouping.MergeOverlaps(); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, seqGrouping, null, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength0.BED"); result = seqGrouping.MergeOverlaps(0, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, seqGrouping, null, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength0.BED"); result = seqGrouping.MergeOverlaps(0, false); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, seqGrouping, null, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength0.BED"); result = seqGrouping.MergeOverlaps(0); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, seqGrouping, null, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength0.BED"); result = seqGrouping.MergeOverlaps(0, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, seqGrouping, null, true); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength0.BED"); result = seqGrouping.MergeOverlaps(0, false); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, seqGrouping, null, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength1.BED"); result = seqGrouping.MergeOverlaps(1); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, seqGrouping, null, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength-1.BED"); result = seqGrouping.MergeOverlaps(-1); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, seqGrouping, null, false); Assert.IsTrue(resultvalue); expectedresultpath = Path.Combine(direc, "Result_Merge_Single_MinLength-3.BED"); result = seqGrouping.MergeOverlaps(-3); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, seqGrouping, null, false); Assert.IsTrue(resultvalue); string firstFile = Path.Combine(direc, "Merge_twofiles_1.BED"); string secondFile = Path.Combine(direc, "Merge_twofiles_2.BED"); SequenceRangeGrouping refSeqRange = parser.ParseRangeGrouping(firstFile); SequenceRangeGrouping querySeqRange = parser.ParseRangeGrouping(secondFile); expectedresultpath = Path.Combine(direc, "Result_Merge_Two_MinLength0.BED"); result = refSeqRange.MergeOverlaps(querySeqRange); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, false); Assert.IsTrue(resultvalue); result = refSeqRange.MergeOverlaps(querySeqRange, 0, false); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, false); Assert.IsTrue(resultvalue); result = refSeqRange.MergeOverlaps(querySeqRange, 0, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); result = refSeqRange.MergeOverlaps(querySeqRange, 0); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, false); Assert.IsTrue(resultvalue); result = refSeqRange.MergeOverlaps(querySeqRange, 0, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); result = refSeqRange.MergeOverlaps(querySeqRange, 0, false); 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_Merge_Two_MinLength1.BED"); result = refSeqRange.MergeOverlaps(querySeqRange, 1, 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_Merge_Two_MinLength-1.BED"); result = refSeqRange.MergeOverlaps(querySeqRange, -1, 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_Merge_Two_MinLength-3.BED"); result = refSeqRange.MergeOverlaps(querySeqRange, -3, 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_Merge_Two_MinLength2.BED"); result = refSeqRange.MergeOverlaps(querySeqRange, 2, 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_Merge_Two_MinLength6.BED"); result = refSeqRange.MergeOverlaps(querySeqRange, 6, true); formatter.Format(result, resultfilepath); resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath); Assert.IsTrue(resultvalue); resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, true); Assert.IsTrue(resultvalue); File.Delete(resultfilepath); }
/// <summary> /// Parsers the Bed file for different test cases based /// on Additional parameter /// </summary> /// <param name="nodeName">Xml Node name</param> /// <param name="addParam">Additional parameter</param> private void ParserGeneralTestCases(string nodeName, AdditionalParameters addParam) { // Gets the Filename string filePath = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); Assert.IsFalse(string.IsNullOrEmpty(filePath)); ApplicationLog.WriteLine(string.Format(null, "Bed Parser P1: Reading the File from location '{0}'", filePath)); // Get the rangelist after parsing. var parserObj = new BedParser(); IList<ISequenceRange> rangeList = null; SequenceRangeGrouping rangeGroup = null; // Gets the Range list/Range Group based on the parameters. switch (addParam) { case AdditionalParameters.RangeFileName: rangeList = parserObj.ParseRange(filePath); break; case AdditionalParameters.RangeTextReader: using (var strObj = File.OpenRead(filePath)) { rangeList = parserObj.ParseRange(strObj); } break; case AdditionalParameters.RangeGroupFileName: rangeGroup = parserObj.ParseRangeGrouping(filePath); break; case AdditionalParameters.RangeGroupTextReader: using (var strObj = File.OpenRead(filePath)) { rangeGroup = parserObj.ParseRangeGrouping(strObj); } break; default: break; } // Gets the Range list from Group switch (addParam) { case AdditionalParameters.RangeGroupTextReader: case AdditionalParameters.RangeGroupFileName: IEnumerable<string> grpIDsObj = rangeGroup.GroupIDs; string rangeID = string.Empty; foreach (string grpID in grpIDsObj) { rangeID = grpID; } rangeList = rangeGroup.GetGroup(rangeID); break; default: break; } string[] expectedIDs = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.IDNode).Split(','); string[] expectedStarts = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.StartNode).Split(','); string[] expectedEnds = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.EndNode).Split(','); int i = 0; // Reads all the ranges with comma seperated for validation foreach (ISequenceRange range in rangeList) { Assert.AreEqual(expectedStarts[i], range.Start.ToString((IFormatProvider) null)); Assert.AreEqual(expectedEnds[i], range.End.ToString((IFormatProvider) null)); Assert.AreEqual(expectedIDs[i], range.ID.ToString(null)); i++; } ApplicationLog.WriteLine( "Bed Parser P1: Successfully validated the ID, Start and End Ranges"); }
/// <summary> /// Formats the Range/RangeGroup for different test cases based /// on Additional parameter /// </summary> /// <param name="nodeName">Xml Node name</param> /// <param name="addParam">Additional parameter</param> private void FormatterGeneralTestCases(string nodeName, AdditionalParameters addParam) { IList<ISequenceRange> rangeList = new List<ISequenceRange>(); var rangeGroup = new SequenceRangeGrouping(); // Gets the file name. string filePath = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); // Condition to check if Parse() happens before Format() switch (addParam) { case AdditionalParameters.ParseRangeGroup: case AdditionalParameters.ParseRangeGroupTextWriter: var initialParserGroupObj = new BedParser(); rangeGroup = initialParserGroupObj.ParseRangeGrouping(filePath); break; case AdditionalParameters.ParseRange: case AdditionalParameters.ParseRangeTextWriter: var initialParserObj = new BedParser(); rangeList = initialParserObj.ParseRange(filePath); break; default: // Gets all the expected values from xml. string expectedID = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.IDNode); string expectedStart = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.StartNode); string expectedEnd = utilityObj.xmlUtil.GetTextValue( nodeName, Constants.EndNode); string[] expectedIDs = expectedID.Split(','); string[] expectedStarts = expectedStart.Split(','); string[] expectedEnds = expectedEnd.Split(','); // Gets the Range Group or Range based on the additional parameter switch (addParam) { case AdditionalParameters.RangeGroupTextWriter: case AdditionalParameters.RangeGroupFileName: for (int i = 0; i < expectedIDs.Length; i++) { var rangeObj1 = new SequenceRange(expectedIDs[i], long.Parse(expectedStarts[i], null), long.Parse(expectedEnds[i], null)); rangeGroup.Add(rangeObj1); } break; default: for (int i = 0; i < expectedIDs.Length; i++) { var rangeObj2 = new SequenceRange(expectedIDs[i], long.Parse(expectedStarts[i], null), long.Parse(expectedEnds[i], null)); rangeList.Add(rangeObj2); } break; } break; } var formatterObj = new BedFormatter(); // Gets the Range list/Range Group based on the parameters. switch (addParam) { case AdditionalParameters.RangeFileName: case AdditionalParameters.ParseRange: formatterObj.Format(rangeList, Constants.BedTempFileName); break; case AdditionalParameters.RangeTextWriter: case AdditionalParameters.ParseRangeTextWriter: using (var txtWriter = File.Create(Constants.BedTempFileName)) { formatterObj.Format(txtWriter, rangeList); } break; case AdditionalParameters.RangeGroupFileName: case AdditionalParameters.ParseRangeGroup: formatterObj.Format(rangeGroup, Constants.BedTempFileName); break; case AdditionalParameters.RangeGroupTextWriter: case AdditionalParameters.ParseRangeGroupTextWriter: using (var txtWriter = File.Create(Constants.BedTempFileName)) { formatterObj.Format(txtWriter, rangeGroup); } break; default: break; } // Reparse to validate the results var parserObj = new BedParser(); IList<ISequenceRange> newRangeList = parserObj.ParseRange(Constants.BedTempFileName); // Validation of all the properties. for (int i = 0; i < rangeList.Count; i++) { Assert.AreEqual(rangeList[0].ID, newRangeList[0].ID); Assert.AreEqual(rangeList[0].Start, newRangeList[0].Start); Assert.AreEqual(rangeList[0].End, newRangeList[0].End); } ApplicationLog.WriteLine( "Bed Formatter P1: Successfully validated the ID, Start and End Ranges"); // Cleanup the file. if (File.Exists(Constants.BedTempFileName)) File.Delete(Constants.BedTempFileName); }
/// <summary> /// Validate Subtract SequenceRangeGrouping. /// </summary> /// <param name="nodeName">Xml Node name for different inputs.</param> /// <param name="overlappingBasePair">Value of overlappingBasePair</param> /// <param name="isParentSeqRangeRequired"></param> private void SubtractSequenceRange(string nodeName, bool overlappingBasePair, bool isParentSeqRangeRequired) { // Get values from xml. string[] expectedRangeIDs = this.utilityObj.xmlUtil.GetTextValue( nodeName, Constants.IDNode).Split(','); string[] expectedStartIndex = this.utilityObj.xmlUtil.GetTextValue( nodeName, Constants.StartNode).Split(','); string[] expectedEndIndex = this.utilityObj.xmlUtil.GetTextValue( nodeName, Constants.EndNode).Split(','); string referenceFilePath = this.utilityObj.xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); string queryFilePath = this.utilityObj.xmlUtil.GetTextValue( nodeName, Constants.QueryFilePath); string minimalOverlap = this.utilityObj.xmlUtil.GetTextValue( nodeName, Constants.OverlapValue); string rangeID = string.Empty; bool result = false; // Parse a BED file. var parserObj = new BedParser(); SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(referenceFilePath); SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath); var subtractOutputType = SubtractOutputType.NonOverlappingPiecesOfIntervals; if (overlappingBasePair) { subtractOutputType = SubtractOutputType.IntervalsWithNoOverlap; } // Subtract a SequenceRangeGroup. SequenceRangeGrouping subtractGroup = referenceGroup.Subtract(queryGroup, long.Parse(minimalOverlap, null), subtractOutputType, isParentSeqRangeRequired); // Get a intersect SequenceGroup Id. IEnumerable<string> groupIds = subtractGroup.GroupIDs; int j = 0; foreach (string grpID in groupIds) { rangeID = grpID; List<ISequenceRange> rangeList = subtractGroup.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(null)); j++; } } // Validate ParentSeqRanges. result = ValidateParentSeqRange(subtractGroup, referenceGroup, queryGroup, isParentSeqRangeRequired); Assert.IsTrue(result); ApplicationLog.WriteLine("Subtract SequenceRangeGrouping BVT: Successfully validated the subtract SequeID, Start and End Ranges"); }
/// <summary> /// Validate Merge SequenceRangeGrouping. /// </summary> /// <param name="nodeName">Xml Node name for different inputs.</param> /// <param name="isMergePam">Merge parameter</param> /// <param name="isParentSeqRangesRequired">Is Parent Sequence Range required?</param> private void MergeSequenceRange(string nodeName, bool isMergePam, bool isParentSeqRangesRequired) { // Get values from xml. string[] expectedRangeIDs = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.IDNode).Split(','); string[] expectedStartIndex = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.StartNode).Split(','); string[] expectedEndIndex = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.EndNode).Split(','); string filePath = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode); string queryFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.QueryFilePath); // Parse a BED file. var parserObj = new BedParser(); SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(filePath); SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath); // Merge a SequenceRangeGroup. SequenceRangeGrouping mergedGroup = isMergePam ? referenceGroup.MergeOverlaps(queryGroup, 0, isParentSeqRangesRequired) : referenceGroup.MergeOverlaps(); // Get a merged SequenceGroup Id. IEnumerable<string> groupIds = mergedGroup.GroupIDs; int j = 0; foreach (string grpId in groupIds) { string rangeId = grpId; List<ISequenceRange> rangeList = mergedGroup.GetGroup(rangeId); // Validate merged 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(null)); j++; } } // Validate Parent SequenceRanges. bool result = ValidateParentSeqRange(mergedGroup,referenceGroup, queryGroup, isParentSeqRangesRequired); Assert.IsTrue(result); ApplicationLog.WriteLine("Merge SequenceRangeGrouping BVT: Successfully validated the merged SequeID, Start and End Ranges"); }
public void BedParserValidateAllProperties() { var parserObj = new BedParser(); Assert.AreEqual(Constants.BedDescription, parserObj.Description); Assert.AreEqual(Constants.BedFileTypes, parserObj.SupportedFileTypes); Assert.AreEqual(Constants.BedName, parserObj.Name); }
/// <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); string queryFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.QueryFilePath); 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"); }
// // Read a Bed file into memory // public static SequenceRangeGrouping ReadBedFile(string filename) { var parser = new BedParser(); IList<ISequenceRange> listSequenceRange = parser.ParseRange(filename); if (verbose) { //listSequenceRange.ToString(); Console.Error.WriteLine("Processed File: {0}", filename); ListSequenceRangeToString(listSequenceRange); } var srg = new SequenceRangeGrouping(listSequenceRange); if (arguments.normalizeInputs) { srg.MergeOverlaps(); // could be called Normalize() or Cannonicalize() } return srg; }