public void ValidateVirtualSAMAlignedSequenceListContains()
{
// Get values from XML node.
string filePath = _utilityObj._xmlUtil.GetTextValue(Constants.SAMFileWithAllFieldsNode,
Constants.FilePathNode1);
// Parse a SAM file.
using (SAMParser samParserObj = new SAMParser())
{
samParserObj.EnforceDataVirtualization = true;
SequenceAlignmentMap alignedSeqList = samParserObj.Parse(filePath);
IList <SAMAlignedSequence> samAlignedList = alignedSeqList.QuerySequences;
VirtualAlignedSequenceList <SAMAlignedSequence> virtualASeqList =
GetSAMAlignedSequence(Constants.SAMFileWithAllFieldsNode);
// Validate contains.
Assert.IsTrue(virtualASeqList.Contains(virtualASeqList.First(
Q => Q.QuerySequence.ToString().Equals(
samAlignedList[0].QuerySequence.ToString()))));
// Log to Nunit GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList P1 : VAS {0} is present in the virtualAlignedSequence List",
virtualASeqList[10]));
Console.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList P1 : VAS {0} is present in the virtualAlignedSequence List",
virtualASeqList[10]));
}
}
/// <summary>
/// Parses a sequence alignment texts from a file.
/// </summary>
/// <param name="fileName">file name.</param>
/// <param name="isReadOnly">
/// Flag to indicate whether the resulting sequences in the sequence alignment should be in
/// readonly mode or not. If this flag is set to true then the resulting sequences's
/// isReadOnly property will be set to true, otherwise it will be set to false.
/// </param>
/// <returns>SequenceAlignmentMap object.</returns>
public SequenceAlignmentMap Parse(string fileName, bool isReadOnly)
{
if (string.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentNullException("fileName");
}
_fileName = fileName;
// check if DV is required
FileInfo fileInfo = new FileInfo(_fileName);
_enforceDataVirtualizationByFileSize = EnforceDataVirtualizationByFileSize * FileLoadHelper.KBytes;
if ((_enforceDataVirtualizationByFileSize != 0 && fileInfo.Length >= _enforceDataVirtualizationByFileSize)
|| _isDataVirtualizationEnforced)
{
EnforceDataVirtualization = true;
}
SequenceAlignmentMap sequenceAlignmentMap = null;
SAMAlignmentHeader header = null;
if (IsDataVirtualizationEnabled)
{
VirtualAlignedSequenceList<SAMAlignedSequence> queries = null;
using (MBFStreamReader mbfReader = new MBFStreamReader(fileName))
{
header = ParserSAMHeader(mbfReader);
_sidecarFileProvider = new SidecarFileProvider(fileName);
// if a valid sidecar does not exist then recreate it
if (_sidecarFileProvider.SidecarFileExists && _sidecarFileProvider.IsSidecarValid == false)
{
ParseSequences(mbfReader);
}
if (_sidecarFileProvider.IsSidecarValid)
{
queries = new VirtualAlignedSequenceList<SAMAlignedSequence>(_sidecarFileProvider, this, _sidecarFileProvider.Count);
sequenceAlignmentMap = new SequenceAlignmentMap(header, queries);
return sequenceAlignmentMap;
}
}
}
using (MBFTextReader mbfReader = new MBFTextReader(fileName))
{
return Parse(mbfReader, isReadOnly);
}
}
public void ValidateIndexOfVirtualBAMAlignedSequence()
{
VirtualAlignedSequenceList <SAMAlignedSequence> virtualASeqList =
GetBAMAlignedSequence(Constants.BAMFileWithMultipleAlignedSeqsNode);
// Validate Index of Virtual Aligned Sequence items
for (int index = 0; index > virtualASeqList.Count; index++)
{
Assert.AreEqual(index, virtualASeqList[index]);
}
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList Bvt : Validated the VAS IndexOf"));
Console.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList Bvt : Validated the VAS IndexOf"));
}
public void ValidateIndexOfVirtualSAMAlignedSequenceWithMediumSizeSAMFile()
{
VirtualAlignedSequenceList <SAMAlignedSequence> virtualASeqList =
GetSAMAlignedSequence(
Constants.SAMFileWithRefNode);
// Validate Index of Virtual Aligned Sequence items
for (int index = 0; index > virtualASeqList.Count; index++)
{
Assert.AreEqual(index, virtualASeqList[index]);
}
ApplicationLog.WriteLine(string.Format(null,
"Virtual AlignedSequenceList P1 : Validated the VAS IndexOf"));
Console.WriteLine(string.Format(null,
"Virtual AlignedSequenceList P1 : Validated the VAS IndexOf"));
}
/// <summary>
/// Gets the VirtualSAMAlignedSequence.
/// </summary>
/// <param name="nodeName">XML nodename used for the different testcases</param>
/// <returns>Virtual SAM AlignedSequence list</returns>
static VirtualAlignedSequenceList <SAMAlignedSequence> GetBAMAlignedSequence(
string nodeName)
{
string filePath = Utility._xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
BAMParser bamParserObj = new BAMParser();
bamParserObj.EnforceDataVirtualization = true;
SequenceAlignmentMap alignedSeqList = bamParserObj.Parse(filePath);
IList <SAMAlignedSequence> bamAlignedList = alignedSeqList.QuerySequences;
VirtualAlignedSequenceList <SAMAlignedSequence> virtualBamAlignedSeqList =
(VirtualAlignedSequenceList <SAMAlignedSequence>)bamAlignedList;
return(virtualBamAlignedSeqList);
}
/// <summary>
/// Gets the VirtualSAMAlignedSequence.
/// </summary>
/// <param name="nodeName">XML nodename used for the different testcases</param>
/// <returns>Virtual SAM AlignedSequence list</returns>
VirtualAlignedSequenceList <SAMAlignedSequence> GetSAMAlignedSequence(
string nodeName)
{
string filePath = _utilityObj._xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode);
using (SAMParser samParserObj = new SAMParser())
{
samParserObj.EnforceDataVirtualization = true;
SequenceAlignmentMap alignedSeqList = samParserObj.Parse(filePath);
IList <SAMAlignedSequence> samAlignedList = alignedSeqList.QuerySequences;
VirtualAlignedSequenceList <SAMAlignedSequence> virtualSamAlignedSeqList =
(VirtualAlignedSequenceList <SAMAlignedSequence>)samAlignedList;
return(virtualSamAlignedSeqList);
}
}
public void ValidateVAlignedSeqListRemove()
{
VirtualAlignedSequenceList <SAMAlignedSequence> virtualASeqList =
GetSAMAlignedSequence(Constants.SAMFileWithAllFieldsNode);
try
{
virtualASeqList.Remove(virtualASeqList[0]);
Assert.Fail();
}
catch (NotSupportedException)
{
// Log to Nunit GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList P1 : Validated the RemoveAt method successfullly"));
Console.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList P1 : Validated the RemoveAt method successfullly"));
}
}
public void ValidateVAlignedSeqListProperties()
{
// Get values from XML node.
string expectedCount = _utilityObj._xmlUtil.GetTextValue(Constants.SAMFileWithAllFieldsNode,
Constants.VirtualAlignedSeqCountNode);
VirtualAlignedSequenceList <SAMAlignedSequence> virtualASeqList =
GetSAMAlignedSequence(Constants.SAMFileWithAllFieldsNode);
// Validate VirtualAlignedSequenceList properties.
Assert.AreEqual(Int32.Parse(expectedCount, (IFormatProvider)null),
virtualASeqList.Count);
Assert.IsTrue(virtualASeqList.IsReadOnly);
// Log to Nunit GUI.
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList P1 : Validated the virtualAlignedSequence properties"));
Console.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList P1 : Validated the virtualAlignedSequence properties"));
}
public void ValidateVirtualBAMAlignedSequenceListContains()
{
// Get values from XML node.
string filePath = Utility._xmlUtil.GetTextValue(
Constants.BAMFileWithMultipleAlignedSeqsNode,
Constants.FilePathNode1);
// Parse a BAM file.
BAMParser bamParserObj = new BAMParser();
bamParserObj.EnforceDataVirtualization = true;
SequenceAlignmentMap alignedSeqList = bamParserObj.Parse(filePath);
IList <SAMAlignedSequence> bamAlignedList = alignedSeqList.QuerySequences;
VirtualAlignedSequenceList <SAMAlignedSequence> virtualASeqList =
GetBAMAlignedSequence(Constants.BAMFileWithMultipleAlignedSeqsNode);
// Validate contains.
Assert.IsTrue(virtualASeqList.Contains(virtualASeqList.FirstOrDefault(
Q => Q.QuerySequence.ToString().Equals(
bamAlignedList[0].QuerySequence.ToString()))));
Assert.IsTrue(virtualASeqList.Contains(virtualASeqList.FirstOrDefault(
Q => Q.QuerySequence.ToString().Equals(
bamAlignedList[10].QuerySequence.ToString()))));
Assert.IsTrue(virtualASeqList.Contains(virtualASeqList.FirstOrDefault(
Q => Q.QName.ToString().Equals(bamAlignedList[0].QName.ToString()))));
Assert.IsTrue(virtualASeqList.Contains(virtualASeqList.FirstOrDefault(
Q => Q.QName.ToString().Equals(bamAlignedList[10].QName.ToString()))));
// Log to Nunit GUI.
ApplicationLog.WriteLine(string.Format(null,
"Virtual AlignedSequenceList Bvt : VAS {0} is present in the virtualAlignedSequence List",
virtualASeqList[10]));
Console.WriteLine(string.Format(null,
"Virtual AlignedSequenceList Bvt : VAS {0} is present in the virtualAlignedSequence List",
virtualASeqList[10]));
}
public void ValidateVirtualBAMAlignedSequenceListCopyTo()
{
VirtualAlignedSequenceList <SAMAlignedSequence> virtualASeqList =
GetBAMAlignedSequence(Constants.BAMFileWithMultipleAlignedSeqsNode);
SAMAlignedSequence[] samAlignedSeqList = new
SAMAlignedSequence[virtualASeqList.Count];
// Copy virtual aligned sequence to sam aligned sequence lilst array.
virtualASeqList.CopyTo(samAlignedSeqList, 0);
// Validate copied aligned sequences.
for (int i = 0; i < virtualASeqList.Count; i++)
{
Assert.AreEqual(samAlignedSeqList[i].QuerySequence.ToString(),
virtualASeqList[i].QuerySequence.ToString());
}
ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList Bvt : Validated the VAS CopyTo"));
Console.WriteLine(string.Format((IFormatProvider)null,
"Virtual AlignedSequenceList Bvt : Validated the VAS CopyTo"));
}
/// <summary>
/// Parses a sequence alignment texts from a file.
/// </summary>
/// <param name="fileName">file name.</param>
/// <param name="isReadOnly">
/// Flag to indicate whether the resulting sequences in the sequence alignment should be in
/// readonly mode or not. If this flag is set to true then the resulting sequences's
/// isReadOnly property will be set to true, otherwise it will be set to false.
/// </param>
/// <returns>SequenceAlignmentMap object.</returns>
public SequenceAlignmentMap Parse(string fileName, bool isReadOnly)
{
if (string.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentNullException("fileName");
}
_fileName = fileName;
// check if DV is required
FileInfo fileInfo = new FileInfo(_fileName);
_enforceDataVirtualizationByFileSize = EnforceDataVirtualizationByFileSize * FileLoadHelper.KBytes;
if ((_enforceDataVirtualizationByFileSize != 0 && fileInfo.Length >= _enforceDataVirtualizationByFileSize) ||
_isDataVirtualizationEnforced)
{
EnforceDataVirtualization = true;
}
SequenceAlignmentMap sequenceAlignmentMap = null;
SAMAlignmentHeader header = null;
if (IsDataVirtualizationEnabled)
{
VirtualAlignedSequenceList <SAMAlignedSequence> queries = null;
using (MBFStreamReader mbfReader = new MBFStreamReader(fileName))
{
header = ParseSAMHeader(mbfReader);
if (header.Comments.Count == 0 && header.RecordFields.Count == 0)
{
try
{
// verify whether this is a valid SAM file by parsing a single sequence
ParseSequence(mbfReader.Line, true, Alphabet, Encoding, RefSequences);
}
catch (IndexOutOfRangeException)
{
throw new FileFormatException(Resource.SAM_InvalidInputFile);
}
}
_sidecarFileProvider = new SidecarFileProvider(fileName);
// if a valid sidecar does not exist then recreate it
if (_sidecarFileProvider.SidecarFileExists && _sidecarFileProvider.IsSidecarValid == false)
{
ParseSequences(mbfReader);
}
if (_sidecarFileProvider.IsSidecarValid)
{
queries = new VirtualAlignedSequenceList <SAMAlignedSequence>(_sidecarFileProvider, this, _sidecarFileProvider.Count);
sequenceAlignmentMap = new SequenceAlignmentMap(header, queries);
return(sequenceAlignmentMap);
}
}
}
using (MBFTextReader mbfReader = new MBFTextReader(fileName))
{
return(Parse(mbfReader, isReadOnly));
}
}
