/// <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.");
}
/// <summary>
/// Initializes a new instance of the GroupData class
/// </summary>
/// <param name="group">SequenceRangeGroup object</param>
/// <param name="name">Name of SequenceRangeGroup</param>
/// <param name="metadata">Metadata for SequenceRangeGroup</param>
public GroupData(
SequenceRangeGrouping group,
string name,
Dictionary <string, Dictionary <ISequenceRange, string> > metadata)
{
Group = group;
Name = name;
_metadata = metadata;
}
/// <summary>
/// Writes out a grouping of ISequenceRange objects to a specified
/// file location.
/// </summary>
/// <param name="rangeGroup">The range grouping to be formatted.</param>
/// <param name="fileName">The file where the formatted data is to be written.</param>
public void Format(SequenceRangeGrouping rangeGroup, string fileName)
{
if (rangeGroup == null)
{
throw new ArgumentNullException("rangeGroup");
}
Format(rangeGroup.Flatten(), fileName);
}
/// <summary>
/// Parse a set of ISequenceRange objects into a SequenceRange
/// grouping from a stream.
/// </summary>
/// <param name="stream">The stream from which the sequence range is to be parsed.</param>
/// <returns>The sequence range groups.</returns>
public SequenceRangeGrouping ParseRangeGrouping(Stream stream)
{
var result = new SequenceRangeGrouping(this.ParseRange(stream));
if (null == result.GroupIDs || !result.GroupIDs.Any())
{
string message = string.Format(CultureInfo.CurrentCulture, Resource.INVALID_INPUT_FILE, this.Name);
throw new InvalidDataException(message);
}
return(result);
}
/// <summary>
/// Parse a set of ISequenceRange objects into a SequenceRange
/// grouping from a reader.
/// </summary>
/// <param name="reader">The reader from which the sequence range is to be parsed.</param>
/// <returns>The sequence range groups.</returns>
public SequenceRangeGrouping ParseRangeGrouping(TextReader reader)
{
SequenceRangeGrouping result = new SequenceRangeGrouping(ParseRange(reader));
if (null == result.GroupIDs || !result.GroupIDs.Any())
{
string message = string.Format(CultureInfo.CurrentCulture, Properties.Resource.INVALID_INPUT_FILE, this.Name);
throw new InvalidDataException(message);
}
return(result);
}
/// <summary>
/// Writes out a grouping of ISequenceRange objects to a specified
/// stream.
/// </summary>
/// <param name="stream">The stream where the formatted data is to be written, it will be closed at the end.</param>
/// <param name="rangeGroup">The range grouping to be formatted.</param>
public void Format(Stream stream, SequenceRangeGrouping rangeGroup)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (rangeGroup == null)
{
throw new ArgumentNullException("rangeGroup");
}
this.Format(stream, rangeGroup.Flatten());
}
/// <summary>
/// Writes out a grouping of ISequenceRange objects to a specified
/// text writer.
/// </summary>
/// <param name="rangeGroup">The range grouping to be formatted.</param>
/// <param name="writer">The writer stream where the formatted data is to be written.</param>
public void Format(SequenceRangeGrouping rangeGroup, TextWriter writer)
{
if (rangeGroup == null)
{
throw new ArgumentNullException("rangeGroup");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
Format(rangeGroup.Flatten(), writer);
}
// 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();
}
public void TestSequenceRangeGroupingToString()
{
ISequenceRange range1 = new SequenceRange("chr20", 0, 3);
ISequenceRange range2 = new SequenceRange("chr21", 0, 4);
IList <ISequenceRange> ranges = new List <ISequenceRange>();
ranges.Add(range1);
ranges.Add(range2);
SequenceRangeGrouping rangegrouping = new SequenceRangeGrouping(ranges);
string actualString = rangegrouping.ToString();
string expectedString = "ID=chr20 Start=0 End=3\r\nID=chr21 Start=0 End=4\r\n".Replace("\r\n", Environment.NewLine);
Assert.AreEqual(actualString, expectedString);
}
public void ValidateSequenceRangeGroupingToString()
{
ISequenceRange range1 = new SequenceRange("chr20", 0, 3);
ISequenceRange range2 = new SequenceRange("chr21", 0, 4);
IList <ISequenceRange> ranges = new List <ISequenceRange>();
ranges.Add(range1);
ranges.Add(range2);
var rangegrouping = new SequenceRangeGrouping(ranges);
string actualString = rangegrouping.ToString();
string expectedStr = this.utilityObj.xmlUtil.GetTextValue(Constants.ToStringNodeName,
Constants.SequenceRangeGroupingExpectedNode);
Assert.AreEqual(expectedStr.Replace("\\r\\n", ""), actualString.Replace(System.Environment.NewLine, ""));
}
/// <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);
}
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;
}
public void ValidateFlatten()
{
// Get values from xml.
string expectedRangeIDs = utilityObj.xmlUtil.GetTextValue(
Constants.SmallSizeBedNodeName, Constants.IDNode);
string expectedStartIndex = utilityObj.xmlUtil.GetTextValue(
Constants.SmallSizeBedNodeName, Constants.StartNode);
string expectedEndIndex = utilityObj.xmlUtil.GetTextValue(
Constants.SmallSizeBedNodeName, Constants.EndNode);
string expectedSequenceRangeCount = utilityObj.xmlUtil.GetTextValue(
Constants.SmallSizeBedNodeName, Constants.SequenceRangeCountNode);
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], (IFormatProvider)null),
long.Parse(rangeEnds[i], (IFormatProvider)null));
seqRangeGrouping.Add(seqRange);
}
//Convert SequenceRangeGroup to SequenceRangeList.
rangeList = seqRangeGrouping.Flatten();
int j = 0;
// 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((IFormatProvider)null));
j++;
}
Assert.AreEqual(expectedSequenceRangeCount, rangeList.Count.ToString((IFormatProvider)null));
Console.WriteLine(
"SequenceRange BVT : Successfully validated the SequenceStart,SequenceID and SequenceEnd.");
}
/// <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);
}
//
// 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);
}
/// <summary>
/// Tests chromoses with orphan regions
/// </summary>
/// <param name="alignmentMapobj">Sequence alignment map.</param>
private static void TestOrphanRegions(SequenceAlignmentMap alignmentMapobj)
{
string expectedOutput;
string actualOutput;
expectedOutput = "9437-9447:";
actualOutput = string.Empty;
// get reads from sequence alignment map object.
IList <PairedRead> pairedReads = null;
pairedReads = alignmentMapobj.GetPairedReads(0, 0);
// Get the orphan regions.
var orphans = pairedReads.Where(PR => PR.PairedType == PairedReadType.Orphan);
if (orphans.Count() == 0)
{
Assert.Fail();
}
List <ISequenceRange> orphanRegions = new List <ISequenceRange>(orphans.Count());
foreach (PairedRead orphanRead in orphans)
{
orphanRegions.Add(GetRegion(orphanRead.Read1));
}
// Get sequence range grouping object.
SequenceRangeGrouping rangeGroup = new SequenceRangeGrouping(orphanRegions);
SequenceRangeGrouping mergedRegions = rangeGroup.MergeOverlaps();
foreach (var range in mergedRegions.GroupRanges)
{
actualOutput += range.Start + "-" + range.End + ":";
}
Assert.AreEqual(expectedOutput, actualOutput);
}
/// <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>
/// Parse a set of ISequenceRange objects into a SequenceRange
/// grouping from a stream.
/// </summary>
/// <param name="stream">The stream from which the sequence range is to be parsed.</param>
/// <returns>The sequence range groups.</returns>
public SequenceRangeGrouping ParseRangeGrouping(Stream stream)
{
var result = new SequenceRangeGrouping(this.ParseRange(stream));
if (null == result.GroupIDs || !result.GroupIDs.Any())
{
string message = string.Format(CultureInfo.CurrentCulture, Resource.INVALID_INPUT_FILE, this.Name);
throw new InvalidDataException(message);
}
return result;
}
//
// print
public static long SequenceRangeGroupingCBases(SequenceRangeGrouping srg)
{
var srgm = new SequenceRangeGroupingMetrics(srg);
return(srgm.bases);
}
/// <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>
void FormatterGeneralTestCases(string nodeName,
AdditionalParameters addParam)
{
IList <ISequenceRange> rangeList = new List <ISequenceRange>();
SequenceRangeGrouping 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:
BedParser initialParserGroupObj = new BedParser();
rangeGroup =
initialParserGroupObj.ParseRangeGrouping(filePath);
break;
case AdditionalParameters.ParseRange:
case AdditionalParameters.ParseRangeTextWriter:
BedParser 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++)
{
SequenceRange rangeObj1 =
new SequenceRange(expectedIDs[i],
long.Parse(expectedStarts[i], (IFormatProvider)null),
long.Parse(expectedEnds[i], (IFormatProvider)null));
rangeGroup.Add(rangeObj1);
}
break;
default:
for (int i = 0; i < expectedIDs.Length; i++)
{
SequenceRange rangeObj2 =
new SequenceRange(expectedIDs[i],
long.Parse(expectedStarts[i], (IFormatProvider)null),
long.Parse(expectedEnds[i], (IFormatProvider)null));
rangeList.Add(rangeObj2);
}
break;
}
break;
}
BedFormatter 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 (TextWriter txtWriter =
new StreamWriter(Constants.BedTempFileName))
{
formatterObj.Format(rangeList, txtWriter);
}
break;
case AdditionalParameters.RangeGroupFileName:
case AdditionalParameters.ParseRangeGroup:
formatterObj.Format(rangeGroup, Constants.BedTempFileName);
break;
case AdditionalParameters.RangeGroupTextWriter:
case AdditionalParameters.ParseRangeGroupTextWriter:
using (TextWriter txtWriter =
new StreamWriter(Constants.BedTempFileName))
{
formatterObj.Format(rangeGroup, txtWriter);
}
break;
default:
break;
}
// Reparse to validate the results
BedParser 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");
Console.WriteLine(
"Bed Formatter P1: Successfully validated the ID, Start and End Ranges");
// Cleanup the file.
if (File.Exists(Constants.BedTempFileName))
{
File.Delete(Constants.BedTempFileName);
}
}
public void IntersectOperationTest()
{
string resultfilepath = "tmp_mergeresult.bed";
string expectedresultpath = string.Empty;
BedParser parser = new BedParser();
BedFormatter formatter = new BedFormatter();
SequenceRangeGrouping result = null;
bool resultvalue = false;
resultfilepath = "tmp_mergeresult.bed";
string reffile = @"testdata\BED\Intersect\Intersect_ref.BED";
string queryFile = @"testdata\BED\Intersect\Intersect_query.BED";
SequenceRangeGrouping refSeqRange = parser.ParseRangeGrouping(reffile);
SequenceRangeGrouping querySeqRange = parser.ParseRangeGrouping(queryFile);
expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap1_OverLappingBases.BED";
result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingPiecesOfIntervals);
formatter.Format(result, resultfilepath);
resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath);
Assert.IsTrue(resultvalue);
resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 1, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap1.BED";
result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingIntervals);
formatter.Format(result, resultfilepath);
resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath);
Assert.IsTrue(resultvalue);
resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 1, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap0_OverLappingBases.BED";
result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingPiecesOfIntervals);
formatter.Format(result, resultfilepath);
resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath);
Assert.IsTrue(resultvalue);
resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 0, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap0.BED";
result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingIntervals);
formatter.Format(result, resultfilepath);
resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath);
Assert.IsTrue(resultvalue);
resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 0, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap1_OverLappingBases.BED";
result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingPiecesOfIntervals, true);
formatter.Format(result, resultfilepath);
resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath);
Assert.IsTrue(resultvalue);
resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 1, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap1.BED";
result = refSeqRange.Intersect(querySeqRange, 1, IntersectOutputType.OverlappingIntervals, true);
formatter.Format(result, resultfilepath);
resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath);
Assert.IsTrue(resultvalue);
resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 1, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap0_OverLappingBases.BED";
result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingPiecesOfIntervals, true);
formatter.Format(result, resultfilepath);
resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath);
Assert.IsTrue(resultvalue);
resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 0, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Intersect\Result_Intersect_MinOverlap0.BED";
result = refSeqRange.Intersect(querySeqRange, 0, IntersectOutputType.OverlappingIntervals, true);
formatter.Format(result, resultfilepath);
resultvalue = CompareBEDOutput(resultfilepath, expectedresultpath);
Assert.IsTrue(resultvalue);
resultvalue = ValidateParentSeqRange(result, refSeqRange, querySeqRange, 0, true);
Assert.IsTrue(resultvalue);
}
public SequenceRangeGroupingMetrics(SequenceRangeGrouping srg)
{
ComputeSequenceRangeGroupingMetrics(srg);
}
/// <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).TestDir();
// Condition to check if Parse() happens before Format()
switch (addParam)
{
case AdditionalParameters.ParseRangeGroup:
var initialParserGroupObj = new BedParser();
rangeGroup =
initialParserGroupObj.ParseRangeGrouping(filePath);
break;
case AdditionalParameters.ParseRange:
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:
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:
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[i].ID, newRangeList[i].ID);
Assert.AreEqual(rangeList[i].Start, newRangeList[i].Start);
Assert.AreEqual(rangeList[i].End, newRangeList[i].End);
// Validation of all metadata information.
if (rangeList[i].Metadata.Count > 0)
{
if (rangeList[i].Metadata.ContainsKey("Name"))
{
Assert.AreEqual(rangeList[i].Metadata["Name"],
newRangeList[i].Metadata["Name"]);
}
if (rangeList[i].Metadata.ContainsKey("Score"))
{
Assert.AreEqual(rangeList[i].Metadata["Score"],
newRangeList[i].Metadata["Score"]);
}
if (rangeList[i].Metadata.ContainsKey("Strand"))
{
Assert.AreEqual(rangeList[i].Metadata["Strand"],
newRangeList[i].Metadata["Strand"]);
}
if (rangeList[i].Metadata.ContainsKey("ThickStart"))
{
Assert.AreEqual(rangeList[i].Metadata["ThickStart"],
newRangeList[i].Metadata["ThickStart"]);
}
if (rangeList[i].Metadata.ContainsKey("ThickEnd"))
{
Assert.AreEqual(rangeList[i].Metadata["ThickEnd"],
newRangeList[i].Metadata["ThickEnd"]);
}
if (rangeList[i].Metadata.ContainsKey("ItemRGB"))
{
Assert.AreEqual(rangeList[i].Metadata["ItemRGB"],
newRangeList[i].Metadata["ItemRGB"]);
}
if (rangeList[i].Metadata.ContainsKey("BlockCount"))
{
Assert.AreEqual(rangeList[i].Metadata["BlockCount"],
newRangeList[i].Metadata["BlockCount"]);
}
if (rangeList[i].Metadata.ContainsKey("BlockSizes"))
{
Assert.AreEqual(rangeList[i].Metadata["BlockSizes"],
newRangeList[i].Metadata["BlockSizes"]);
}
if (rangeList[i].Metadata.ContainsKey("BlockStarts"))
{
Assert.AreEqual(rangeList[i].Metadata["BlockStarts"],
newRangeList[i].Metadata["BlockStarts"]);
}
ApplicationLog.WriteLine(
"Bed Formatter BVT: Successfully validated all the metadata information");
}
}
ApplicationLog.WriteLine(
"Bed Formatter BVT: Successfully validated the ID, Start and End Ranges");
// Cleanup the file.
if (File.Exists(Constants.BedTempFileName))
{
File.Delete(Constants.BedTempFileName);
}
}
/// <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");
}
public void MergeOperationTest()
{
string filepath = @"testdata\BED\Merge\Merge_single.BED";
string resultfilepath = "tmp_mergeresult.bed";
string expectedresultpath = @"testdata\BED\Merge\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 = @"testdata\BED\Merge\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, 0, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, 0, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, 0, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, 0, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, 0, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, 0, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, 1, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, -1, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, -3, false);
Assert.IsTrue(resultvalue);
string firstFile = @"testdata\BED\Merge\Merge_twofiles_1.BED";
string secondFile = @"testdata\BED\Merge\Merge_twofiles_2.BED";
SequenceRangeGrouping refSeqRange = parser.ParseRangeGrouping(firstFile);
SequenceRangeGrouping querySeqRange = parser.ParseRangeGrouping(secondFile);
expectedresultpath = @"testdata\BED\Merge\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, 0, 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, 0, 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, 0, 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, 0, 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, 0, 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, 0, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, 1, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, -1, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, -3, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, 2, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Merge\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, 6, true);
Assert.IsTrue(resultvalue);
}
public void SubtractTest()
{
string refSeqRangefile = @"testdata\BED\Subtract\Subtract_ref.BED";
string querySeqRangefile = @"testdata\BED\Subtract\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 = @"testdata\BED\Subtract\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, 1, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Subtract\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, 0, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Subtract\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, 1, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Subtract\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, 0, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Subtract\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, 1, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Subtract\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, 0, false);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Subtract\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, 0, true);
Assert.IsTrue(resultvalue);
expectedresultpath = @"testdata\BED\Subtract\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, 1, true);
Assert.IsTrue(resultvalue);
}
public void ValidateFlatten()
{
// Get values from xml.
string expectedRangeIDs = this.utilityObj.xmlUtil.GetTextValue(
Constants.SmallSizeBedNodeName, Constants.IDNode);
string expectedStartIndex = this.utilityObj.xmlUtil.GetTextValue(
Constants.SmallSizeBedNodeName, Constants.StartNode);
string expectedEndIndex = this.utilityObj.xmlUtil.GetTextValue(
Constants.SmallSizeBedNodeName, Constants.EndNode);
string expectedSequenceRangeCount = this.utilityObj.xmlUtil.GetTextValue(
Constants.SmallSizeBedNodeName, 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);
}
//Convert SequenceRangeGroup to SequenceRangeList.
rangeList = seqRangeGrouping.Flatten();
int j = 0;
// 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.");
}
public void ValidateSequenceRangeGroupingToString()
{
ISequenceRange range1 = new SequenceRange("chr20", 0, 3);
ISequenceRange range2 = new SequenceRange("chr21", 0, 4);
IList<ISequenceRange> ranges = new List<ISequenceRange>();
ranges.Add(range1);
ranges.Add(range2);
var rangegrouping = new SequenceRangeGrouping(ranges);
string actualString = rangegrouping.ToString();
string expectedStr = this.utilityObj.xmlUtil.GetTextValue(Constants.ToStringNodeName,
Constants.SequenceRangeGroupingExpectedNode);
Assert.AreEqual(expectedStr.Replace("\\r\\n", ""), actualString.Replace(System.Environment.NewLine, ""));
}
public static int Main(string[] args)
{
try
{
Splash();
arguments = ProcessCommandLineArguments(args);
if (arguments.inputFiles.Count() == 2)
{
// now read the 2 BED files and do the operation to isolate each set
SequenceRangeGrouping srg1 = ReadBedFile(arguments.inputFiles[0]);
SequenceRangeGrouping srg2 = ReadBedFile(arguments.inputFiles[1]);
SequenceRangeGrouping srgOnly_A, srgOnly_B, srgOnly_AB;
VennToNodeXL.CreateSequenceRangeGroupingsForVennDiagram(
srg1,
srg2,
out srgOnly_A,
out srgOnly_B,
out srgOnly_AB);
var srgmOnly_A = new SequenceRangeGroupingMetrics(srgOnly_A);
var srgmOnly_B = new SequenceRangeGroupingMetrics(srgOnly_B);
var srgmOnly_AB = new SequenceRangeGroupingMetrics(srgOnly_AB);
if (createVennToolInputFile)
{
Console.Error.Write("\nWriting file [{0}]", vennToolInputFileFullPath);
var VennOutput = new StreamWriter(vennToolInputFileFullPath);
VennOutput.WriteLine("{0} {1} {2}", srgmOnly_A.bases, srgmOnly_B.bases, srgmOnly_AB.bases);
VennOutput.Close();
Console.Error.Write(" ... Done.");
}
if (createExcelWorkbook)
{
// create the Excel workbook with a NodeXL Venn diagram
Console.Error.Write("\nWriting file [{0}]", excelWorkbookFullPath);
var vdd = new VennDiagramData(srgmOnly_A.bases, srgmOnly_B.bases, srgmOnly_AB.bases);
try
{
VennToNodeXL.CreateVennDiagramNodeXLFile(excelWorkbookFullPath, vdd);
Console.Error.Write(" ... Done.\n");
}
catch (Exception e)
{
Console.Error.Write("Error: Unable to create Excel workbook.");
DisplayException(e);
Environment.Exit(-1);
}
}
if (verbose)
{
Console.Error.Write("\nDump Sequence Groupings from two files\n");
SequenceRangeGroupingToString(srgOnly_A, "srgOnly_A");
SequenceRangeGroupingToString(srgOnly_B, "srgOnly_B");
SequenceRangeGroupingToString(srgOnly_AB, "srgOnly_AB");
Console.Error.Write("\nEnd Sequence group from twoe files\n");
}
Console.Write("\nOutput basepair count for each set");
Console.Write("\nGroupA,GroupB,GroupAB");
Console.Write("\n{0},{1},{2}\n", srgmOnly_A.bases, srgmOnly_B.bases, srgmOnly_AB.bases);
}
else if (arguments.inputFiles.Count() == 3)
{
// TODO: Reduce memory usage by re-using the SRGs after debugging is complete
//
// now read the 3 BED files and do the operation to isolate each set
SequenceRangeGrouping srg1 = ReadBedFile(arguments.inputFiles[0]);
SequenceRangeGrouping srg2 = ReadBedFile(arguments.inputFiles[1]);
SequenceRangeGrouping srg3 = ReadBedFile(arguments.inputFiles[2]);
SequenceRangeGrouping srgOnly_A,
srgOnly_B,
srgOnly_C,
srgOnly_AB,
srgOnly_AC,
srgOnly_BC,
srgOnly_ABC;
VennToNodeXL.CreateSequenceRangeGroupingsForVennDiagram(
srg1,
srg2,
srg3,
out srgOnly_A,
out srgOnly_B,
out srgOnly_C,
out srgOnly_AB,
out srgOnly_AC,
out srgOnly_BC,
out srgOnly_ABC);
/*
* We have the set information data for the three files.
* Now what?
*/
// generate the intersection Venn metrics
var srgmOnly_A = new SequenceRangeGroupingMetrics(srgOnly_A);
var srgmOnly_B = new SequenceRangeGroupingMetrics(srgOnly_B);
var srgmOnly_C = new SequenceRangeGroupingMetrics(srgOnly_C);
var srgmOnly_AB = new SequenceRangeGroupingMetrics(srgOnly_AB);
var srgmOnly_AC = new SequenceRangeGroupingMetrics(srgOnly_AC);
var srgmOnly_BC = new SequenceRangeGroupingMetrics(srgOnly_BC);
var srgmOnly_ABC = new SequenceRangeGroupingMetrics(srgOnly_ABC);
if (createVennToolInputFile)
{
Console.Error.Write("\nWriting file [{0}]", vennToolInputFileFullPath);
var VennOutput = new StreamWriter(vennToolInputFileFullPath);
VennOutput.WriteLine(
"{0} {1} {2} {3} {4} {5} {6}",
srgmOnly_A.bases,
srgmOnly_B.bases,
srgmOnly_C.bases,
srgmOnly_AB.bases,
srgmOnly_AC.bases,
srgmOnly_BC.bases,
srgmOnly_ABC.bases);
VennOutput.Close();
Console.Error.Write(" ... Done.");
}
if (createExcelWorkbook)
{
// create the NodeXL Venn diagram filefile
var vdd = new VennDiagramData(
srgmOnly_A.bases,
srgmOnly_B.bases,
srgmOnly_C.bases,
srgmOnly_AB.bases,
srgmOnly_AC.bases,
srgmOnly_BC.bases,
srgmOnly_ABC.bases);
// create the Excel workbook with a NodeXL Venn diagram
Console.Error.Write("\nWriting file [{0}]", excelWorkbookFullPath);
try
{
VennToNodeXL.CreateVennDiagramNodeXLFile(excelWorkbookFullPath, vdd);
Console.Error.Write(" ... Done.\n");
}
catch (Exception e)
{
Console.Error.Write("\nError: Unable to create Excel workbook.");
DisplayException(e);
Environment.Exit(-1);
}
}
if (verbose)
{
Console.Error.Write("\nDump Sequence Groupings from three files\n");
SequenceRangeGroupingToString(srgOnly_A, "srgOnly_A");
SequenceRangeGroupingToString(srgOnly_B, "srgOnly_B");
SequenceRangeGroupingToString(srgOnly_C, "srgOnly_C");
SequenceRangeGroupingToString(srgOnly_AB, "srgOnly_AB");
SequenceRangeGroupingToString(srgOnly_AC, "srgOnly_AC");
SequenceRangeGroupingToString(srgOnly_BC, "srgOnly_BC");
SequenceRangeGroupingToString(srgOnly_ABC, "srgOnly_ABC");
Console.Error.Write("\nEnd Sequence group from three files\n");
}
Console.Write("\nOutput basepair count for each set");
Console.Write("\nGroupA,GroupB,GroupC,GroupAB,GroupAC,GroupBC,GroupABC");
Console.Write(
"\n{0},{1},{2},{3},{4},{5},{6}\n",
srgmOnly_A.bases,
srgmOnly_B.bases,
srgmOnly_C.bases,
srgmOnly_AB.bases,
srgmOnly_AC.bases,
srgmOnly_BC.bases,
srgmOnly_ABC.bases);
}
}
catch (Exception ex)
{
DisplayException(ex);
}
return(0);
}
/// <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>
/// 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>
/// Writes out a grouping of ISequenceRange objects to a specified
/// stream.
/// </summary>
/// <param name="stream">The stream where the formatted data is to be written, it will be closed at the end.</param>
/// <param name="rangeGroup">The range grouping to be formatted.</param>
public void Format(Stream stream, SequenceRangeGrouping rangeGroup)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (rangeGroup == null)
{
throw new ArgumentNullException("rangeGroup");
}
this.Format(stream, rangeGroup.Flatten());
}
public static void Main(string[] args)
{
Splash();
parsedArgs = ProcessCommandLineArguments(args);
if (parsedArgs.inputFiles.Count() == 2)
{
// now read the 2 BED files and do the operation to isolate each set
SequenceRangeGrouping srg1 = ReadBedFile(parsedArgs.inputFiles[0]);
SequenceRangeGrouping srg2 = ReadBedFile(parsedArgs.inputFiles[1]);
SequenceRangeGrouping srgOnly_A, srgOnly_B, srgOnly_AB;
VennToNodeXL.CreateSequenceRangeGroupingsForVennDiagram(srg1, srg2, out srgOnly_A, out srgOnly_B, out srgOnly_AB);
if (fCreateVennToolInputFile || fCreateExcelWorkbook)
{
SequenceRangeGroupingMetrics srgmOnly_A = new SequenceRangeGroupingMetrics(srgOnly_A);
SequenceRangeGroupingMetrics srgmOnly_B = new SequenceRangeGroupingMetrics(srgOnly_B);
SequenceRangeGroupingMetrics srgmOnly_AB = new SequenceRangeGroupingMetrics(srgOnly_AB);
if (fCreateVennToolInputFile)
{
//SequenceRangeGroupingMetrics srgm = new SequenceRangeGroupingMetrics(srgOnly_A);
StreamWriter VennOutput = new StreamWriter(VennToolInputFileFullPath);
VennOutput.WriteLine("{0} {1} {2}"
, srgmOnly_A.cBases
, srgmOnly_B.cBases
, srgmOnly_AB.cBases);
VennOutput.Close();
}
if (fCreateExcelWorkbook)
{
// create the Excel workbook with a NodeXL Venn diagram
VennDiagramData vdd = new VennDiagramData(srgmOnly_A.cBases
, srgmOnly_B.cBases
, srgmOnly_AB.cBases);
VennToNodeXL.CreateVennDiagramNodeXLFile(ExcelWorkbookFullPath, vdd);
}
if (fVerbose)
{
SequenceRangeGroupingToString(srgOnly_A, "srgOnly_A");
SequenceRangeGroupingToString(srgOnly_B, "srgOnly_B");
SequenceRangeGroupingToString(srgOnly_AB, "srgOnly_AB");
Console.WriteLine("end two file dump");
}
}
}
if (parsedArgs.inputFiles.Count() == 3)
{
// TODO: Reduce memory usage by re-using the SRGs after debugging is complete
//
// now read the 3 BED files and do the operation to isolate each set
SequenceRangeGrouping srg1 = ReadBedFile(parsedArgs.inputFiles[0]);
SequenceRangeGrouping srg2 = ReadBedFile(parsedArgs.inputFiles[1]);
SequenceRangeGrouping srg3 = ReadBedFile(parsedArgs.inputFiles[2]);
SequenceRangeGrouping srgOnly_A, srgOnly_B, srgOnly_C, srgOnly_AB, srgOnly_AC, srgOnly_BC, srgOnly_ABC;
VennToNodeXL.CreateSequenceRangeGroupingsForVennDiagram(srg1, srg2, srg3,
out srgOnly_A,
out srgOnly_B,
out srgOnly_C,
out srgOnly_AB,
out srgOnly_AC,
out srgOnly_BC,
out srgOnly_ABC);
/*
* We have the set information data for the three files.
* Now what?
*/
if (fCreateVennToolInputFile || fCreateExcelWorkbook)
{
// generate the intersection Venn metrics
SequenceRangeGroupingMetrics srgmOnly_A = new SequenceRangeGroupingMetrics(srgOnly_A);
SequenceRangeGroupingMetrics srgmOnly_B = new SequenceRangeGroupingMetrics(srgOnly_B);
SequenceRangeGroupingMetrics srgmOnly_C = new SequenceRangeGroupingMetrics(srgOnly_C);
SequenceRangeGroupingMetrics srgmOnly_AB = new SequenceRangeGroupingMetrics(srgOnly_AB);
SequenceRangeGroupingMetrics srgmOnly_AC = new SequenceRangeGroupingMetrics(srgOnly_AC);
SequenceRangeGroupingMetrics srgmOnly_BC = new SequenceRangeGroupingMetrics(srgOnly_BC);
SequenceRangeGroupingMetrics srgmOnly_ABC = new SequenceRangeGroupingMetrics(srgOnly_ABC);
if (fCreateVennToolInputFile)
{
StreamWriter VennOutput = new StreamWriter(VennToolInputFileFullPath);
VennOutput.WriteLine("{0} {1} {2} {3} {4} {5} {6}"
, srgmOnly_A.cBases
, srgmOnly_B.cBases
, srgmOnly_C.cBases
, srgmOnly_AB.cBases
, srgmOnly_AC.cBases
, srgmOnly_BC.cBases
, srgmOnly_ABC.cBases);
VennOutput.Close();
}
if (fCreateExcelWorkbook)
{
// create the NodeXL Venn diagram filefile
VennDiagramData vdd = new VennDiagramData(srgmOnly_A.cBases
, srgmOnly_B.cBases
, srgmOnly_C.cBases
, srgmOnly_AB.cBases
, srgmOnly_AC.cBases
, srgmOnly_BC.cBases
, srgmOnly_ABC.cBases);
VennToNodeXL.CreateVennDiagramNodeXLFile(ExcelWorkbookFullPath, vdd);
}
if (fVerbose)
{
SequenceRangeGroupingToString(srgOnly_A, "srgOnly_A");
SequenceRangeGroupingToString(srgOnly_B, "srgOnly_B");
SequenceRangeGroupingToString(srgOnly_C, "srgOnly_C");
SequenceRangeGroupingToString(srgOnly_AB, "srgOnly_AB");
SequenceRangeGroupingToString(srgOnly_AC, "srgOnly_AC");
SequenceRangeGroupingToString(srgOnly_BC, "srgOnly_BC");
SequenceRangeGroupingToString(srgOnly_ABC, "srgOnly_ABC");
Console.Error.WriteLine("end three file dump");
}
}
}
}
/// <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>
/// Method called when the user clicks Ok button on InputSelectionDialog.
/// Takes care of parsing the selections and returning the result to the user.
/// In case there was an error parsing, it will show the input selection dialog again with the sequence highlighted.
/// </summary>
/// <param name="dialog">InputSequenceDialog object which raised this event</param>
private void OnInputSequenceRangeDialogSubmit(ISelectionDialog dialog)
{
InputSelectionDialog selectionDialog = dialog as InputSelectionDialog;
GroupData cachedData = null;
// maps sheet to its column-mapping
Dictionary <string, Dictionary <int, string> > columnMappedSheets =
new Dictionary <string, Dictionary <int, string> >();
// Goes in the cache and is the output of this method as well.
Dictionary <SequenceRangeGrouping, GroupData> groupsData =
new Dictionary <SequenceRangeGrouping, GroupData>();
List <SequenceRangeGrouping> parsedSequences = new List <SequenceRangeGrouping>();
SequenceRangeGrouping sequenceRangeGroup = null;
Dictionary <string, Dictionary <ISequenceRange, string> > sheetData = null;
Dictionary <ISequenceRange, string> rangeData = null;
List <ISequenceRange> sequenceRanges = null;
List <Range> rangesInCurrentSequenceItem;
// Regular expression to read the sheet name from address
Regex regexSheetname = new Regex(@"(?<Sheetname>^.[^!]*)", RegexOptions.IgnoreCase);
Match matchSheetname = null;
string sheetName = string.Empty;
try
{
foreach (InputSequenceItem currentSequenceItem in selectionDialog.GetSequences())
{
try
{
rangesInCurrentSequenceItem = GetRanges(currentSequenceItem.SequenceAddress);
// get from cache
cachedData = SequenceCache.TryGetSequence(rangesInCurrentSequenceItem, selectionDialog.InputParamsAsKey) as GroupData;
if (cachedData != null)
{
// got from cache
cachedData.Name = currentSequenceItem.SequenceName; // Set ID
if (currentSequenceItem.IsUseMetadataSelected)
{
parsedSequences.Insert(0, cachedData.Group);
}
else
{
parsedSequences.Add(cachedData.Group);
}
if (!groupsData.ContainsKey(cachedData.Group))
{
groupsData.Add(cachedData.Group, cachedData);
}
}
else
{
// parse it as its not in cache
sheetData = new Dictionary <string, Dictionary <ISequenceRange, string> >();
sequenceRanges = new List <ISequenceRange>();
foreach (Range currentRange in rangesInCurrentSequenceItem)
{
bool firstRowIsHeader = false;
// See if the sheet in which this range is, has a column mapping
if (!columnMappedSheets.ContainsKey(GetMappingKey(currentRange)))
{
(currentRange.Worksheet as _Worksheet).Activate();
currentRange.Select();
Dictionary <int, string> mapping = GetMappingForRange(currentRange, out firstRowIsHeader);
if (mapping == null)
{
// Could not get a proper mapping. So redirect to previous window.
selectionDialog.ShowDialog();
return;
}
if (firstRowIsHeader)
{
UpdateColumnHeaders(currentRange, mapping);
}
columnMappedSheets.Add(GetMappingKey(currentRange), mapping);
}
// If range has a header, remove first row from it before sending it for parsing.
Range rangeToParse;
if (firstRowIsHeader)
{
if (currentRange.Rows.Count == 1) // only one row which is marked as header, throw error
{
throw new InvalidOperationException(Resources.SelectionModel_ParsingFailed);
}
rangeToParse = currentRange.get_Offset(1, 0);
rangeToParse = rangeToParse.get_Resize(currentRange.Rows.Count - 1, currentRange.Columns.Count);
}
else
{
rangeToParse = currentRange;
}
Dictionary <ISequenceRange, string> srCollection =
ExcelSelectionParser.RangeToSequenceRange(
rangeToParse,
columnMappedSheets[GetMappingKey(currentRange)]);
foreach (KeyValuePair <ISequenceRange, string> sr in srCollection)
{
matchSheetname = regexSheetname.Match(sr.Value);
if (matchSheetname.Success)
{
sheetName = matchSheetname.Groups["Sheetname"].Value;
if (sheetData.TryGetValue(sheetName, out rangeData))
{
rangeData.Add(sr.Key, sr.Value);
}
else
{
rangeData = new Dictionary <ISequenceRange, string>();
sheetData.Add(sheetName, rangeData);
rangeData.Add(sr.Key, sr.Value);
}
sequenceRanges.Add(sr.Key);
}
}
}
sequenceRangeGroup = new SequenceRangeGrouping(sequenceRanges);
cachedData = new GroupData(sequenceRangeGroup,
currentSequenceItem.SequenceName,
sheetData);
SequenceCache.Add(rangesInCurrentSequenceItem, cachedData, selectionDialog.InputParamsAsKey);
if (currentSequenceItem.IsUseMetadataSelected)
{
parsedSequences.Insert(0, cachedData.Group);
}
else
{
parsedSequences.Add(cachedData.Group);
}
groupsData.Add(cachedData.Group, cachedData);
}
}
catch
{
// Set error status on the current item and re-throw the error
currentSequenceItem.SetErrorStatus(true);
throw;
}
}
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add(InputSelection.OVERLAP, selectionDialog.OverlappingBasePairs);
parameters.Add(InputSelection.MINIMUMOVERLAP, selectionDialog.MinOverLap);
// On successful completion of parsing...
if (inputSequenceRangeSelectionComplete != null)
{
InputSequenceRangeSelectionEventArg eventArg =
new InputSequenceRangeSelectionEventArg(groupsData,
parsedSequences,
parameters,
argsForCallback);
inputSequenceRangeSelectionComplete(eventArg);
}
selectionDialog.InputSelectionDialogSubmitting -= OnInputSequenceDialogSubmit;
selectionDialog.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, Resources.CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Error);
selectionDialog.ShowDialog();
}
}
/// <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>
/// 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");
}
public void TestSequenceRangeGroupingToString()
{
ISequenceRange range1 = new SequenceRange("chr20", 0, 3);
ISequenceRange range2 = new SequenceRange("chr21", 0, 4);
IList<ISequenceRange> ranges = new List<ISequenceRange>();
ranges.Add(range1);
ranges.Add(range2);
SequenceRangeGrouping rangegrouping = new SequenceRangeGrouping(ranges);
string actualString = rangegrouping.ToString();
string expectedString = "ID=chr20 Start=0 End=3\r\nID=chr21 Start=0 End=4\r\n".Replace("\r\n", Environment.NewLine);
Assert.AreEqual(actualString, expectedString);
}
