// 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"));
}