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);
}
/// <summary>
/// Validate BED Operations(Merge,Intersect)..
/// </summary>
/// <param name="nodeName">Xml Node name for different inputs.</param>
/// <param name="operationPam">Different Bed operations.</param>
/// <param name="overlappingBasePair">overlapping base pair</param>
/// <param name="isParentSeqRangeRequired">Is Parent Sequence Range required?</param>
private void ValidateBedOperations(string nodeName,
BedOperationsParameters operationPam,
bool overlappingBasePair, bool isParentSeqRangeRequired)
{
// Get values from xml.
string expectedRangeIDs = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.IDNode);
string expectedStartIndex = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.StartNode);
string expectedEndIndex = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.EndNode);
string referenceFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FilePathNode).TestDir();
string queryFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.QueryFilePath).TestDir();
string minimalOverlap = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.OverlapValue);
SequenceRangeGrouping operationResult = null;
// Parse a BED file.
var parserObj = new BedParser();
SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(referenceFilePath);
SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath);
var intersectOutputType = IntersectOutputType.OverlappingIntervals;
if (overlappingBasePair)
{
intersectOutputType = IntersectOutputType.OverlappingPiecesOfIntervals;
}
var subtractOutputType = SubtractOutputType.NonOverlappingPiecesOfIntervals;
if (overlappingBasePair)
{
subtractOutputType = SubtractOutputType.IntervalsWithNoOverlap;
}
switch (operationPam)
{
case BedOperationsParameters.Merge:
operationResult = referenceGroup.MergeOverlaps();
break;
case BedOperationsParameters.MergeWithPam:
operationResult = referenceGroup.MergeOverlaps(queryGroup,
0, isParentSeqRangeRequired);
break;
case BedOperationsParameters.Intersect:
operationResult = referenceGroup.Intersect(queryGroup,
long.Parse(minimalOverlap, null), intersectOutputType,
isParentSeqRangeRequired);
break;
case BedOperationsParameters.MergeQueryWithReference:
operationResult = queryGroup.MergeOverlaps(referenceGroup,
0, isParentSeqRangeRequired);
break;
case BedOperationsParameters.Subtract:
operationResult = referenceGroup.Subtract(queryGroup,
long.Parse(minimalOverlap, null), subtractOutputType,
isParentSeqRangeRequired);
break;
default:
break;
}
// Get a result SequenceGroup Id.
IEnumerable <string> groupId = operationResult.GroupIDs;
string[] expectedRangeIdsArray = expectedRangeIDs.Split(',');
string[] expectedStartIndexArray = expectedStartIndex.Split(',');
string[] expectedEndIndexArray = expectedEndIndex.Split(',');
int i = 0;
foreach (string grpId in groupId)
{
string rangeId = grpId;
List <ISequenceRange> rangeList = operationResult.GetGroup(rangeId);
// Validate result sequence range.
foreach (ISequenceRange range in rangeList)
{
Assert.AreEqual(expectedRangeIdsArray[i], range.ID);
Assert.AreEqual(expectedStartIndexArray[i], range.Start.ToString((IFormatProvider)null));
Assert.AreEqual(expectedEndIndexArray[i], range.End.ToString((IFormatProvider)null));
i++;
}
}
// Validate ParentSeqRange.
bool result = ValidateParentSeqRange(operationResult, referenceGroup, queryGroup, isParentSeqRangeRequired);
Assert.IsTrue(result);
ApplicationLog.WriteLine("Bed Operations BVT: Successfully validated the BED SequenceID, Start and End Ranges");
}
/// <summary>
/// Indentify hot spot chromosomes for length anamoly regions.
/// </summary>
/// <param name="inputFile"> Input file</param>
/// <param name="mean">Mean value</param>
/// <param name="standardDeviation">Standard deviation</param>
private void IdentifyLentghAnamolies(string filename,
float mean = -1, float deviation = -1)
{
bool calculateMeanNdeviation = false;
if (mean == -1 || deviation == -1)
{
calculateMeanNdeviation = true;
}
SequenceAlignmentMap alignmentMapobj = null;
if (!SAMInput)
{
BAMParser bamParser = new BAMParser();
alignmentMapobj = bamParser.Parse(filename);
}
else
{
SAMParser samParser = new SAMParser();
alignmentMapobj = samParser.Parse(filename);
}
// get reads from sequence alignment map object.
IList <PairedRead> pairedReads = null;
if (calculateMeanNdeviation)
{
pairedReads = alignmentMapobj.GetPairedReads();
}
else
{
pairedReads = alignmentMapobj.GetPairedReads(mean, deviation);
}
// Get the orphan regions.
var orphans = pairedReads.Where(PR => PR.PairedType == PairedReadType.Orphan);
if (orphans.Count() == 0)
{
Console.WriteLine("No Orphans to display");
}
List <ISequenceRange> orphanRegions = new List <ISequenceRange>(orphans.Count());
foreach (PairedRead orphanRead in orphans)
{
orphanRegions.Add(GetRegion(orphanRead.Read1));
}
// Get sequence range grouping for Orphan regions.
SequenceRangeGrouping orphanRangegroup = new SequenceRangeGrouping(orphanRegions);
// Get the Length anomalies regions.
var lengthAnomalies = pairedReads.Where(PE => PE.PairedType == PairedReadType.LengthAnomaly);
if (lengthAnomalies.Count() == 0)
{
Console.WriteLine("No Anomalies to display");
}
List <ISequenceRange> lengthAnomalyRegions = new List <ISequenceRange>(lengthAnomalies.Count());
foreach (PairedRead laRead in lengthAnomalies)
{
SequenceRange range = new SequenceRange();
range.ID = laRead.Read1.RName;
range.Start = laRead.Read1.Pos;
range.End = laRead.Read1.Pos + laRead.InsertLength;
lengthAnomalyRegions.Add(range);
}
// Get sequence range grouping for length anomaly regions.
SequenceRangeGrouping lengthAnomalyRangegroup =
new SequenceRangeGrouping(lengthAnomalyRegions);
if (lengthAnomalyRangegroup.GroupIDs.Count() == 0)
{
Console.Write("\r\nNo Length anomalies reads to display");
}
else
{
Console.Write("Region of length anomaly:");
DisplaySequenceRange(lengthAnomalyRangegroup);
}
if (orphanRangegroup.GroupIDs.Count() == 0)
{
Console.Write("\r\nNo Orphan reads to display");
}
else
{
Console.Write("\r\nRegion of Orphan reads:");
DisplaySequenceRange(orphanRangegroup);
}
SequenceRangeGrouping intersectedRegions =
lengthAnomalyRangegroup.Intersect(orphanRangegroup);
if (intersectedRegions.GroupIDs.Count() == 0)
{
Console.Write("\r\nNo Hot spots found");
}
else
{
Console.Write("\r\nChromosomal Hot spot of length anomaly and Orphan region:");
DisplaySequenceRange(intersectedRegions);
}
}
/// <summary>
/// Validate BED Operations(Merge,Intersect)..
/// </summary>
/// <param name="nodeName">Xml Node name for different inputs.</param>
/// <param name="operationPam">Different Bed operations.</param>
/// <param name="overlappingBasePair">overlapping base pair</param>
/// <param name="IsParentSeqRangeRequired">Is Parent Sequence Range required?</param>
static void ValidateBedOperations(string nodeName,
BedOperationsParameters operationPam,
bool overlappingBasePair, bool IsParentSeqRangeRequired)
{
// Get values from xml.
string expectedRangeIDs = Utility._xmlUtil.GetTextValue(
nodeName, Constants.IDNode);
string expectedStartIndex = Utility._xmlUtil.GetTextValue(
nodeName, Constants.StartNode);
string expectedEndIndex = Utility._xmlUtil.GetTextValue(
nodeName, Constants.EndNode);
string referenceFilePath = Utility._xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string queryFilePath = Utility._xmlUtil.GetTextValue(
nodeName, Constants.QueryFilePath);
string minimalOverlap = Utility._xmlUtil.GetTextValue(
nodeName, Constants.OverlapValue);
string rangeID = string.Empty;
string actualStarts = string.Empty;
string actualEnds = string.Empty;
string actualIDs = string.Empty;
bool result = false;
List <ISequenceRange> rangeList = null;
SequenceRangeGrouping operationResult = null;
// Parse a BED file.
BedParser parserObj = new BedParser();
SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(referenceFilePath);
SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath);
IntersectOutputType intersectOutputType = IntersectOutputType.OverlappingIntervals;
if (overlappingBasePair)
{
intersectOutputType = IntersectOutputType.OverlappingPiecesOfIntervals;
}
SubtractOutputType subtractOutputType = SubtractOutputType.NonOverlappingPiecesOfIntervals;
if (overlappingBasePair)
{
subtractOutputType = SubtractOutputType.IntervalsWithNoOverlap;
}
switch (operationPam)
{
case BedOperationsParameters.Merge:
operationResult = referenceGroup.MergeOverlaps();
break;
case BedOperationsParameters.MergeWithPam:
operationResult = referenceGroup.MergeOverlaps(queryGroup,
0, IsParentSeqRangeRequired);
break;
case BedOperationsParameters.Intersect:
operationResult = referenceGroup.Intersect(queryGroup,
long.Parse(minimalOverlap), intersectOutputType, IsParentSeqRangeRequired);
break;
case BedOperationsParameters.MergeQueryWithReference:
operationResult = queryGroup.MergeOverlaps(referenceGroup,
0, IsParentSeqRangeRequired);
break;
case BedOperationsParameters.Subtract:
operationResult = referenceGroup.Subtract(queryGroup,
long.Parse(minimalOverlap), subtractOutputType, IsParentSeqRangeRequired);
break;
default:
break;
}
// Get a result SequenceGroup Id.
IEnumerable <string> groupId = operationResult.GroupIDs;
foreach (string grpID in groupId)
{
rangeID = grpID;
rangeList = operationResult.GetGroup(rangeID);
// Validate result sequence range.
foreach (ISequenceRange range in rangeList)
{
actualStarts = string.Concat(actualStarts, range.Start.ToString(), ",");
actualEnds = string.Concat(actualEnds, range.End.ToString(), ",");
actualIDs = string.Concat(actualIDs, range.ID.ToString(), ",");
}
}
Assert.AreEqual(expectedRangeIDs, actualIDs.Substring(0, actualIDs.Length - 1));
Assert.AreEqual(expectedStartIndex, actualStarts.Substring(0, actualStarts.Length - 1));
Assert.AreEqual(expectedEndIndex, actualEnds.Substring(0, actualEnds.Length - 1));
// Validate ParentSeqRange.
result = ValidateParentSeqRange(operationResult, referenceGroup,
queryGroup, IsParentSeqRangeRequired);
Assert.IsTrue(result);
ApplicationLog.WriteLine(
"Bed Parser BVT: Successfully validated the BED SequenceID, Start and End Ranges");
}
/// <summary>
/// Validate Intersect SequenceRangeGrouping.
/// </summary>
/// <param name="nodeName">Xml Node name for different inputs.</param>
/// <param name="overlappingBasePair">Value of overlappingBasePair</param>
void IntersectSequenceRange(string nodeName,
bool overlappingBasePair, bool IsParentSeqRangeRequired)
{
// Get values from xml.
string[] expectedRangeIDs = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.IDNode).Split(',');
string[] expectedStartIndex = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.StartNode).Split(',');
string[] expectedEndIndex = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.EndNode).Split(',');
string referenceFilePath = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string queryFilePath = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.QueryFilePath);
string minimalOverlap = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.OverlapValue);
string rangeID = string.Empty;
bool result = false;
List <ISequenceRange> rangeList = null;
// Parse a BED file.
BedParser parserObj = new BedParser();
SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(referenceFilePath);
SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath);
IntersectOutputType outputType = IntersectOutputType.OverlappingIntervals;
if (overlappingBasePair)
{
outputType = IntersectOutputType.OverlappingPiecesOfIntervals;
}
// Intersect a SequenceRangeGroup.
SequenceRangeGrouping intersectGroup = referenceGroup.Intersect(queryGroup,
long.Parse(minimalOverlap, (IFormatProvider)null), outputType);
// Get a intersect SequenceGroup Id.
IEnumerable <string> groupIds = intersectGroup.GroupIDs;
int j = 0;
foreach (string grpID in groupIds)
{
rangeID = grpID;
rangeList = intersectGroup.GetGroup(rangeID);
// Validate intersect sequence range.
foreach (ISequenceRange range in rangeList)
{
Assert.AreEqual(expectedStartIndex[j], range.Start.ToString((IFormatProvider)null));
Assert.AreEqual(expectedEndIndex[j], range.End.ToString((IFormatProvider)null));
Assert.AreEqual(expectedRangeIDs[j], range.ID.ToString((IFormatProvider)null));
j++;
}
}
// Validate ParentSeqRanges.
result = ValidateParentSeqRange(intersectGroup,
referenceGroup, queryGroup, IsParentSeqRangeRequired);
Assert.IsTrue(result);
ApplicationLog.WriteLine(
"Bed Parser BVT: Successfully validated the intersect SequeID, Start and End Ranges");
Console.WriteLine(string.Format((IFormatProvider)null,
"Bed Parser BVT: Successfully validated the merged SequeID, Start and End Ranges"));
}
/// <summary>
/// Tests Length Anomalies
/// </summary>
/// <param name="alignmentMapobj">Sequence alignment map.</param>
private static void TestLengthAnomalies(SequenceAlignmentMap alignmentMapobj)
{
string expectedOutput;
string actualOutput;
expectedOutput = "9437-9447:9440-9447:";
actualOutput = string.Empty;
// get reads from sequence alignment map object.
IList <PairedRead> pairedReads = null;
pairedReads = alignmentMapobj.GetPairedReads(200, 50);
// 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 for Orphan regions.
SequenceRangeGrouping orphanRangegroup = new SequenceRangeGrouping(orphanRegions);
// Get the Length anomalies regions.
var lengthAnomalies = pairedReads.Where(PE => PE.PairedType == PairedReadType.LengthAnomaly);
if (lengthAnomalies.Count() == 0)
{
Assert.Fail();
}
List <ISequenceRange> lengthAnomalyRegions = new List <ISequenceRange>(lengthAnomalies.Count());
foreach (PairedRead laRead in lengthAnomalies)
{
SequenceRange range = new SequenceRange();
range.ID = laRead.Read1.RName;
range.Start = laRead.Read1.Pos;
range.End = laRead.Read1.Pos + laRead.InsertLength;
lengthAnomalyRegions.Add(range);
}
// Get sequence range grouping for length anomaly regions.
SequenceRangeGrouping lengthAnomalyRangegroup =
new SequenceRangeGrouping(lengthAnomalyRegions);
SequenceRangeGrouping intersectedRegions =
lengthAnomalyRangegroup.Intersect(orphanRangegroup);
foreach (var range in intersectedRegions.GroupRanges)
{
actualOutput += range.Start + "-" + range.End + ":";
}
Assert.AreEqual(expectedOutput, actualOutput);
}
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").TestDir();
string queryFile = Path.Combine(direc, "Intersect_query.BED").TestDir();
SequenceRangeGrouping refSeqRange = parser.ParseRangeGrouping(reffile);
SequenceRangeGrouping querySeqRange = parser.ParseRangeGrouping(queryFile);
expectedresultpath = Path.Combine(direc, "Result_Intersect_MinOverlap1_OverLappingBases.BED").TestDir();
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").TestDir();
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").TestDir();
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").TestDir();
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").TestDir();
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").TestDir();
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").TestDir();
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").TestDir();
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);
}