// default printing of SequenceRangeGrouping // public static void SequenceRangeGroupingToString(SequenceRangeGrouping srg, string name) { Console.Error.Write("[{0}] : SeqeuenceRangeGrouping: ", name); var srgm = new SequenceRangeGroupingMetrics(srg); Console.Error.WriteLine("{0}, {1}, {2}", srgm.groups, srgm.ranges, srgm.bases); foreach (string id in srg.GroupIDs) { Console.Error.WriteLine("--GroupID: {0}, {1}", id, srg.GetGroup(id).Count()); ListSequenceRangeToString(srg.GetGroup(id)); } Console.Error.WriteLine(); }
/// <summary> /// Create a SequenceRangeGrouping by passing RangeID,Start and End Index. /// and validate created SequenceRange. /// </summary> /// <param name="nodeName">Xml Node name for different inputs.</param> static void CreateSequenceRangeGrouping(string nodeName) { // 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 expectedSequenceRangeCount = Utility._xmlUtil.GetTextValue( nodeName, Constants.SequenceRangeCountNode); string actualRangeStarts = string.Empty; string actualRangeEnds = string.Empty; string actualRangeIDs = string.Empty; string[] rangeIDs = expectedRangeIDs.Split(','); string[] rangeStarts = expectedStartIndex.Split(','); string[] rangeEnds = expectedEndIndex.Split(','); SequenceRangeGrouping seqRangeGrouping = new SequenceRangeGrouping(); List <ISequenceRange> rangeList = null; // Create a SequenceRange and add to SequenceRangeList. for (int i = 0; i < rangeIDs.Length; i++) { SequenceRange seqRange = new SequenceRange(rangeIDs[i], long.Parse(rangeStarts[i]), long.Parse(rangeEnds[i])); seqRangeGrouping.Add(seqRange); } IEnumerable <string> rangeGroupIds = seqRangeGrouping.GroupIDs; string rangeID = string.Empty; foreach (string groupID in rangeGroupIds) { rangeID = groupID; // Get SequenceRangeIds. rangeList = seqRangeGrouping.GetGroup(rangeID); // Validate created SequenceRanges. foreach (ISequenceRange seqRange in rangeList) { actualRangeIDs = string.Concat(actualRangeIDs, seqRange.ID.ToString(), ","); actualRangeStarts = string.Concat(actualRangeStarts, seqRange.Start.ToString(), ","); actualRangeEnds = string.Concat(actualRangeEnds, seqRange.End.ToString(), ","); } } Assert.AreEqual(expectedSequenceRangeCount, rangeList.Count.ToString()); Assert.AreEqual(expectedRangeIDs, actualRangeIDs.Substring(0, actualRangeIDs.Length - 1)); Assert.AreEqual(expectedStartIndex, actualRangeStarts.Substring(0, actualRangeStarts.Length - 1)); Assert.AreEqual(expectedEndIndex, actualRangeEnds.Substring(0, actualRangeEnds.Length - 1)); Console.WriteLine( "SequenceRange BVT : Successfully validated the SequenceStart, SequenceID and SequenceEnd."); }
public void ComputeSequenceRangeGroupingMetrics(SequenceRangeGrouping srg) { cGroups = 0L; cRanges = 0L; cBases = 0L; foreach (string id in srg.GroupIDs) { ++cGroups; cRanges += srg.GetGroup(id).Count; foreach (SequenceRange sr in srg.GetGroup(id)) { cBases += sr.Length; } } return; }
/// <summary> /// Validate Parent Sequence ranges in result sequence range. /// </summary> /// <param name="resultSeq">Result seq range group.</param> /// <param name="refSeqRange">Reference seq range group.</param> /// <param name="querySeqRange">Query seq range group.</param> /// <param name="minOverlap">Minimum overlap.</param> /// <param name="isParentSeqRangeRequired">Flag to indicate whether /// result should contain parent seq ranges or not.</param> /// <returns>Returns true if the parent seq ranges are valid; otherwise returns false.</returns> private static bool ValidateParentSeqRange(SequenceRangeGrouping resultSeq, SequenceRangeGrouping refSeq, SequenceRangeGrouping querySeq, bool IsParentSeqRangeRequired) { IList <ISequenceRange> refSeqRangeList = new List <ISequenceRange>(); IList <ISequenceRange> querySeqRangeList = new List <ISequenceRange>(); IEnumerable <string> groupIds = resultSeq.GroupIDs; foreach (string groupId in groupIds) { if (null != refSeq) { refSeqRangeList = refSeq.GetGroup(groupId); } if (null != querySeq) { querySeqRangeList = querySeq.GetGroup(groupId); } foreach (ISequenceRange resultRange in resultSeq.GetGroup(groupId)) { if (!IsParentSeqRangeRequired) { if (0 != resultRange.ParentSeqRanges.Count) { return(false); } } else { int refSeqRangeCount = refSeqRangeList.Where(S => resultRange.ParentSeqRanges.Contains(S)).Count(); int querySeqRangeCount = querySeqRangeList.Where(S => resultRange.ParentSeqRanges.Contains(S)).Count(); if (resultRange.ParentSeqRanges.Count != refSeqRangeCount + querySeqRangeCount) { return(false); } } } } return(true); }
/// <summary> /// Method to validate parent seq ranges in result. /// </summary> /// <param name="resultSeqRange">Result seq range group.</param> /// <param name="refSeqRange">Reference seq range group.</param> /// <param name="querySeqRange">Query seq range group.</param> /// <param name="isParentSeqRangeRequired">Flag to indicate whether result should contain parent seq ranges or not.</param> /// <returns>Returns true if the parent seq ranges are valid; otherwise returns false.</returns> private static bool ValidateParentSeqRange(SequenceRangeGrouping resultSeqRange, SequenceRangeGrouping refSeqRange, SequenceRangeGrouping querySeqRange, bool isParentSeqRangeRequired) { IList <ISequenceRange> refSeqRangeList = new List <ISequenceRange>(); IList <ISequenceRange> querySeqRangeList = new List <ISequenceRange>(); foreach (string groupid in resultSeqRange.GroupIDs) { if (refSeqRange != null) { refSeqRangeList = refSeqRange.GetGroup(groupid); } if (querySeqRange != null) { querySeqRangeList = querySeqRange.GetGroup(groupid); } foreach (ISequenceRange resultRange in resultSeqRange.GetGroup(groupid)) { if (!isParentSeqRangeRequired) { if (resultRange.ParentSeqRanges.Count != 0) { return(false); } } else { int refCount = refSeqRangeList.Where(R => resultRange.ParentSeqRanges.Contains(R)).Count(); int queryCount = querySeqRangeList.Where(R => resultRange.ParentSeqRanges.Contains(R)).Count(); if (refCount + queryCount != resultRange.ParentSeqRanges.Count) { return(false); } } } } return(true); }
/// <summary> /// Display Sequence range grops /// </summary> /// <param name="seqRangeGrops">Sequence Ranges grops</param> private static void DisplaySequenceRange(SequenceRangeGrouping seqRangeGrop) { IEnumerable <string> rangeGroupIds = seqRangeGrop.GroupIDs; string rangeID = string.Empty; // Display Sequence Ranges Console.Write("\r\nChromosome\t\tStart\tEnd"); foreach (string groupID in rangeGroupIds) { rangeID = groupID; // Get SequenceRangeIds. List <ISequenceRange> rangeList = seqRangeGrop.GetGroup(rangeID); foreach (ISequenceRange seqRange in rangeList) { Console.Write("\n{0}\t\t\t{1}\t{2}", seqRange.ID.ToString(), seqRange.Start.ToString(), seqRange.End.ToString()); } } }
/// <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> /// 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).TestDir(); Assert.IsFalse(string.IsNullOrEmpty(filePath)); ApplicationLog.WriteLine($"Bed Parser BVT: Reading the File from location '{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; } // Gets all the expected values from xml. 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 BVT: Successfully validated the ID, Start and End Ranges"); }
/// <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> static void ParserGeneralTestCases(string nodeName, AdditionalParameters addParam) { // Gets the Filename string filePath = Utility._xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); Assert.IsNotEmpty(filePath); ApplicationLog.WriteLine(string.Format( "Bed Parser BVT: Reading the File from location '{0}'", filePath)); // Get the rangelist after parsing. BedParser 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: rangeList = parserObj.ParseRange(new StreamReader(filePath)); break; case AdditionalParameters.RangeGroupFileName: rangeGroup = parserObj.ParseRangeGrouping(filePath); break; case AdditionalParameters.RangeGroupTextReader: rangeGroup = parserObj.ParseRangeGrouping( new StreamReader(filePath)); 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; } // Gets all the expected values from xml. string expectedIDs = Utility._xmlUtil.GetTextValue( nodeName, Constants.IDNode); string expectedStarts = Utility._xmlUtil.GetTextValue( nodeName, Constants.StartNode); string expectedEnds = Utility._xmlUtil.GetTextValue( nodeName, Constants.EndNode); string actualStarts = string.Empty; string actualEnds = string.Empty; string actualIDs = string.Empty; // Reads all the ranges with comma seperated for validation 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(expectedIDs, actualIDs.Substring(0, actualIDs.Length - 1)); Assert.AreEqual(expectedStarts, actualStarts.Substring(0, actualStarts.Length - 1)); Assert.AreEqual(expectedEnds, actualEnds.Substring(0, actualEnds.Length - 1)); ApplicationLog.WriteLine( "Bed Parser BVT: Successfully validated the ID, Start and End Ranges"); Console.WriteLine( "Bed Parser BVT: Successfully validated the ID, Start and End Ranges"); }
/// <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 Subtract SequenceRangeGrouping. /// </summary> /// <param name="nodeName">Xml Node name for different inputs.</param> /// <param name="overlappingBasePair">Value of overlappingBasePair</param> /// <param name="IsParentSeqRangesRequired">Is Parent Sequence Range required?</param> void SubtractSequenceRange(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); SubtractOutputType subtractOutputType = SubtractOutputType.NonOverlappingPiecesOfIntervals; if (overlappingBasePair) { subtractOutputType = SubtractOutputType.IntervalsWithNoOverlap; } // Subtract a SequenceRangeGroup. SequenceRangeGrouping subtractGroup = referenceGroup.Subtract(queryGroup, long.Parse(minimalOverlap, (IFormatProvider)null), subtractOutputType, IsParentSeqRangeRequired); // Get a intersect SequenceGroup Id. IEnumerable <string> groupIds = subtractGroup.GroupIDs; int j = 0; foreach (string grpID in groupIds) { rangeID = grpID; 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((IFormatProvider)null)); j++; } } // Validate ParentSeqRanges. result = ValidateParentSeqRange( subtractGroup, referenceGroup, queryGroup, IsParentSeqRangeRequired); Assert.IsTrue(result); ApplicationLog.WriteLine( "Bed Parser BVT: Successfully validated the subtract SequeID, Start and End Ranges"); Console.WriteLine(string.Format((IFormatProvider)null, "Bed Parser BVT: Successfully validated the subtracted 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> void MergeSequenceRange(string nodeName, bool IsMergePam, bool IsParentSeqRangesRequired) { // 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 filePath = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.FilePathNode); string queryFilePath = _utilityObj._xmlUtil.GetTextValue( nodeName, Constants.QueryFilePath); string rangeID = string.Empty; bool result = false; List <ISequenceRange> rangeList = null; SequenceRangeGrouping mergedGroup = null; // Parse a BED file. BedParser parserObj = new BedParser(); SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(filePath); SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath); // Merge a SequenceRangeGroup. if (IsMergePam) { mergedGroup = referenceGroup.MergeOverlaps(queryGroup, 0, IsParentSeqRangesRequired); } else { mergedGroup = referenceGroup.MergeOverlaps(); } // Get a merged SequenceGroup Id. IEnumerable <string> groupIds = mergedGroup.GroupIDs; int j = 0; foreach (string grpID in groupIds) { rangeID = grpID; 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((IFormatProvider)null)); j++; } } // Validate Parent SequenceRanges. result = ValidateParentSeqRange(mergedGroup, referenceGroup, queryGroup, IsParentSeqRangesRequired); Assert.IsTrue(result); ApplicationLog.WriteLine( "Bed Parser BVT: Successfully validated the merged SequeID, Start and End Ranges"); Console.WriteLine(string.Format((IFormatProvider)null, "Bed Parser BVT: Successfully validated the merged SequeID, Start and End Ranges")); }
/// <summary> /// Validate Parent Sequence ranges in result sequence range. /// </summary> /// <param name="resultSeq">Result seq range group.</param> /// <param name="refSeq">Reference seq range group.</param> /// <param name="querySeq">Query seq range group.</param> /// <param name="isParentSeqRangeRequired"> /// Flag to indicate whether result should contain parent seq ranges or not. /// </param> /// <returns>Returns true if the parent seq ranges are valid; otherwise returns false.</returns> private static bool ValidateParentSeqRange(SequenceRangeGrouping resultSeq, SequenceRangeGrouping refSeq, SequenceRangeGrouping querySeq, bool isParentSeqRangeRequired) { IList<ISequenceRange> refSeqRangeList = new List<ISequenceRange>(); IList<ISequenceRange> querySeqRangeList = new List<ISequenceRange>(); IEnumerable<string> groupIds = resultSeq.GroupIDs; foreach (string groupId in groupIds) { if (null != refSeq) { refSeqRangeList = refSeq.GetGroup(groupId); } if (null != querySeq) { querySeqRangeList = querySeq.GetGroup(groupId); } foreach (ISequenceRange resultRange in resultSeq.GetGroup(groupId)) { if (!isParentSeqRangeRequired) { if (resultRange.ParentSeqRanges.Count != 0) { return false; } } else { int refSeqRangeCount = refSeqRangeList.Count(s => resultRange.ParentSeqRanges.Contains(s)); int querySeqRangeCount = querySeqRangeList.Count(s => resultRange.ParentSeqRanges.Contains(s)); if (resultRange.ParentSeqRanges.Count != refSeqRangeCount + querySeqRangeCount) { return false; } } } } return true; }
/// <summary> /// Create a SequenceRangeGrouping by passing RangeID,Start and End Index. /// and validate created SequenceRange. /// </summary> /// <param name="nodeName">Xml Node name for different inputs.</param> private void CreateSequenceRangeGrouping(string nodeName) { // 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 expectedSequenceRangeCount = this.utilityObj.xmlUtil.GetTextValue( nodeName, Constants.SequenceRangeCountNode); string[] rangeIDs = expectedRangeIDs.Split(','); string[] rangeStarts = expectedStartIndex.Split(','); string[] rangeEnds = expectedEndIndex.Split(','); var seqRangeGrouping = new SequenceRangeGrouping(); List<ISequenceRange> rangeList = null; // Create a SequenceRange and add to SequenceRangeList. for (int i = 0; i < rangeIDs.Length; i++) { var seqRange = new SequenceRange(rangeIDs[i], long.Parse(rangeStarts[i], null), long.Parse(rangeEnds[i], null)); seqRangeGrouping.Add(seqRange); } IEnumerable<string> rangeGroupIds = seqRangeGrouping.GroupIDs; string rangeID = string.Empty; int j = 0; foreach (string groupID in rangeGroupIds) { rangeID = groupID; // Get SequenceRangeIds. rangeList = seqRangeGrouping.GetGroup(rangeID); // Validate created SequenceRanges. foreach (ISequenceRange seqRange in rangeList) { Assert.AreEqual(rangeStarts[j], seqRange.Start.ToString((IFormatProvider) null)); Assert.AreEqual(rangeEnds[j], seqRange.End.ToString((IFormatProvider) null)); Assert.AreEqual(rangeIDs[j], seqRange.ID.ToString(null)); j++; } } Assert.AreEqual(expectedSequenceRangeCount, rangeList.Count.ToString((IFormatProvider) null)); ApplicationLog.WriteLine( "SequenceRange BVT : Successfully validated the SequenceStart, SequenceID and SequenceEnd."); }
/// <summary> /// Validate Intersect SequenceRangeGrouping. /// </summary> /// <param name="nodeName">Xml Node name for different inputs.</param> /// <param name="overlappingBasePair">Value of overlappingBasePair</param> static void IntersectSequenceRange(string nodeName, 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; // 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), outputType); // Get a intersect SequenceGroup Id. IEnumerable <string> groupIds = intersectGroup.GroupIDs; foreach (string grpID in groupIds) { rangeID = grpID; rangeList = intersectGroup.GetGroup(rangeID); // Validate intersect 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 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(null, "Bed Parser BVT: Successfully validated the merged SequeID, Start and End Ranges")); }