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;
}