public void ValidateVQSLProperties()
{
VirtualQualitativeSequenceList seqList =
GetVirtualQualitativeSequenceList(
Constants.LargeSizeDnaIlluminaFastQNode);
seqList.CreateSequenceAsReadOnly = true;
Assert.IsTrue(seqList.CreateSequenceAsReadOnly);
ICollection <ISequence> seqProp = seqList;
Assert.IsTrue(seqProp.IsReadOnly);
ICollection <IQualitativeSequence> seqQualProp = seqList;
Assert.IsTrue(seqQualProp.IsReadOnly);
IList <ISequence> seq = seqList;
Assert.IsNotNull(seq[0]);
ApplicationLog.WriteLine(
"VQSL Bvt : Successfully validated the all properties");
Console.WriteLine(
"VQSL Bvt : Successfully validated the all properties");
}
public void ValidateVQSLContains()
{
VirtualQualitativeSequenceList seqList =
GetVirtualQualitativeSequenceList(
Constants.LargeSizeDnaIlluminaFastQFileNode);
Assert.IsTrue(seqList.Contains(seqList[0]));
Assert.IsTrue(seqList.Contains(seqList[10]));
// Cleanup the weak reference dictionary
for (int i = 0; i < Constants.MaximumDictionaryLength; i++)
{
Assert.IsTrue(seqList.Contains(seqList[i]));
}
Assert.IsFalse(seqList.Contains(null));
ICollection <ISequence> seqContains = seqList;
Assert.IsTrue(seqContains.Contains(seqList[0]));
ApplicationLog.WriteLine(
"VQSL Bvt : Successfully validated the Contains() method");
Console.WriteLine(
"VQSL Bvt : Successfully validated the Contains() method");
}
public void ValidateVQSLCopyTo()
{
VirtualQualitativeSequenceList seqList =
GetVirtualQualitativeSequenceList(
Constants.LargeSizeDnaIlluminaFastQNode);
ICollection <ISequence> seqCopy = seqList;
int i = seqCopy.Count;
IQualitativeSequence[] seqArray = new IQualitativeSequence[i];
seqList.CopyTo(seqArray, 0);
Assert.AreEqual(seqList[0].ToString(),
seqArray[0].ToString());
Assert.AreEqual(seqList[i - 1].ToString(),
seqArray[i - 1].ToString());
seqCopy.CopyTo(seqArray, 0);
Assert.AreEqual(seqList[0].ToString(),
seqArray[0].ToString());
Assert.AreEqual(seqList[i - 1].ToString(),
seqArray[i - 1].ToString());
ApplicationLog.WriteLine(
"VQSL Bvt : Successfully validated the CopyTo() method");
Console.WriteLine(
"VQSL Bvt : Successfully validated the CopyTo() method");
}
public void ValidateVQSLGetEnum()
{
VirtualQualitativeSequenceList seqList =
GetVirtualQualitativeSequenceList(
Constants.LargeSizeDnaIlluminaFastQFileNode);
IEnumerator <IQualitativeSequence> getEnum = seqList.GetEnumerator();
Assert.IsNull(getEnum.Current);
IEnumerable <ISequence> getEnumSeq = seqList;
getEnumSeq.GetEnumerator();
Assert.IsNull(getEnum.Current);
IEnumerable getQualSeq = seqList;
getQualSeq.GetEnumerator();
Assert.IsNull(getEnum.Current);
ApplicationLog.WriteLine(
"VQSL Bvt : Successfully validated the GetEnumerator() method");
Console.WriteLine(
"VQSL Bvt : Successfully validated the GetEnumerator() method");
}
/// <summary>
/// Parses file with DV and returns Virtual Qualitative Sequences list.
/// </summary>
/// <param name="isReadOnly">Flag to indicate whether the sequences returned should be set to readonly or not.</param>
private VirtualQualitativeSequenceList ParseWithDV(bool isReadOnly)
{
SidecarFileProvider sidecarFileProvider = null;
sidecarFileProvider = new SidecarFileProvider(_fileName);
sidecarFileProvider.Close();
// if valid sidecar file exists
if (sidecarFileProvider.IsSidecarValid)
{
// Create virtual list and return
return(new VirtualQualitativeSequenceList(sidecarFileProvider, this, sidecarFileProvider.Count)
{
CreateSequenceAsReadOnly = isReadOnly
});
}
// else create new sidecar
using (sidecarFileProvider = new SidecarFileProvider(_fileName, true))
{
using (_mbfStreamReader = new MBFStreamReader(_fileName))
{
if (sidecarFileProvider.SidecarFileExists)
{
try
{
while (_mbfStreamReader.HasLines)
{
ParseOne(_mbfStreamReader, isReadOnly);
}
// Create sidecar
sidecarFileProvider.CreateSidecarFile(_mbfStreamReader.FileName, _sequencePointers);
VirtualQualitativeSequenceList virtualSequences =
new VirtualQualitativeSequenceList(sidecarFileProvider, this, _sequencePointers.Count)
{
CreateSequenceAsReadOnly = isReadOnly
};
_sequencePointers.Clear();
return(virtualSequences);
}
catch (Exception)
{
sidecarFileProvider.Cleanup();
}
}
}
}
return(null);
}
/// <summary>
/// Parses a list of biological sequence data from a BioTextReader.
/// </summary>
/// <param name="bioReader">BioTextReader instance for a biological sequence data.</param>
/// <param name="isReadOnly">
/// Flag to indicate whether the resulting QualitativeSequences should be in readonly mode or not.
/// If this flag is set to true then the resulting QualitativeSequences's isReadOnly property
/// will be set to true, otherwise it will be set to false.
/// </param>
/// <returns>The list of parsed IQualitativeSequence objects.</returns>
new protected IList <IQualitativeSequence> Parse(BioTextReader bioReader, bool isReadOnly)
{
if (bioReader == null)
{
throw new ArgumentNullException("bioReader");
}
// no empty files allowed
if (!bioReader.HasLines)
{
string message = string.Format(CultureInfo.CurrentCulture, Resource.IOFormatErrorMessage, Name, Resource.IONoTextToParse);
Trace.Report(message);
throw new FileFormatException(message);
}
if (!string.IsNullOrEmpty(bioReader.FileName) &&
IsDataVirtualizationEnabled && SidecarFileProvider.IsIndexFileExists(bioReader.FileName))
{
while (bioReader.HasLines)
{
ParseOne(bioReader, isReadOnly);
}
// Create sidecar
SidecarFileProvider provider = SidecarFileProvider.CreateIndexFile(bioReader.FileName, _sequencePointers);
VirtualQualitativeSequenceList virtualSequences =
new VirtualQualitativeSequenceList(provider, this, _sequencePointers.Count)
{
CreateSequenceAsReadOnly = isReadOnly
};
_sequencePointers.Clear();
return(virtualSequences);
}
else
{
List <IQualitativeSequence> qualSequences = new List <IQualitativeSequence>();
while (bioReader.HasLines)
{
qualSequences.Add(ParseOne(bioReader, isReadOnly));
}
return(qualSequences);
}
}
GetVirtualQualitativeSequenceList(string nodeName)
{
// Gets the expected sequence from the Xml
string filePath = Utility._xmlUtil.GetTextValue(
nodeName,
Constants.FilePathNode);
FastQParser parserObj = new FastQParser();
parserObj.EnforceDataVirtualization = true;
VirtualQualitativeSequenceList seqList =
(VirtualQualitativeSequenceList)parserObj.Parse(filePath);
return(seqList);
}
public void ValidateVQSLCount()
{
VirtualQualitativeSequenceList seqList =
GetVirtualQualitativeSequenceList(
Constants.LargeSizeDnaIlluminaFastQNode);
ICollection <ISequence> seqCount = seqList;
Assert.AreEqual(Constants.VirtualQualSeqCount, seqCount.Count);
ICollection <IQualitativeSequence> seqCountQual = seqList;
Assert.AreEqual(Constants.VirtualQualSeqCount, seqCountQual.Count);
ApplicationLog.WriteLine(
"VQSL Bvt : Successfully validated the Count() method");
Console.WriteLine(
"VQSL Bvt : Successfully validated the Count() method");
}
public void ValidateVQSLIndexOf()
{
VirtualQualitativeSequenceList seqList =
GetVirtualQualitativeSequenceList(
Constants.LargeSizeDnaIlluminaFastQNode);
Assert.AreEqual(
Constants.SeqIndexNumber, seqList.IndexOf(seqList[10]));
IList <ISequence> seqIndexOf = seqList;
Assert.AreEqual(
Constants.SeqIndexNumber, seqIndexOf.IndexOf(seqList[10]));
ApplicationLog.WriteLine(
"VQSL Bvt : Successfully validated the IndexOf() method");
Console.WriteLine(
"VQSL Bvt : Successfully validated the IndexOf() method");
}
/// <summary>
/// Parses a list of biological sequence data from a file.
/// </summary>
/// <param name="filename">The name of a biological sequence file.</param>
/// <param name="isReadOnly">
/// Flag to indicate whether the resulting QualitativeSequences should be in readonly mode or not.
/// If this flag is set to true then the resulting QualitativeSequences's isReadOnly property
/// will be set to true, otherwise it will be set to false.
/// </param>
/// <returns>The list of parsed IQualitativeSequence objects.</returns>
public IList <IQualitativeSequence> Parse(string filename, bool isReadOnly)
{
VerifyForDV(filename);
VirtualQualitativeSequenceList virList = null;
// Check for sidecar
if (IsDataVirtualizationEnabled)
{
virList = ParseWithDV(isReadOnly);
if (virList != null)
{
return(virList);
}
}
// non-DV parsing
using (MBFTextReader mbfReader = new MBFTextReader(filename))
{
return(ParseQualSeqs(mbfReader, isReadOnly));
}
}
/// <summary>
/// Genral method to validate virtual quality sequence list
/// </summary>
/// <param name="param">Method Name</param>
static void ValidateVirtualQualitativeSequenceList(
VirtualQualSeqListTestAttributes param)
{
VirtualQualitativeSequenceList seqList =
GetVirtualQualitativeSequenceList(
Constants.LargeSizeDnaIlluminaFastQNode);
ICollection <ISequence> seqCollection = seqList;
ICollection <IQualitativeSequence> seqQual = seqList;
IList <ISequence> listSeq = seqList;
IList <IQualitativeSequence> listQual = seqList;
try
{
switch (param)
{
case VirtualQualSeqListTestAttributes.Add:
seqList.Add((IQualitativeSequence)
new QualitativeSequence(
Alphabets.DNA,
FastQFormatType.Illumina, "ACCTT"));
break;
case VirtualQualSeqListTestAttributes.AddCollection:
seqCollection.Add(null as ISequence);
break;
case VirtualQualSeqListTestAttributes.ClearQual:
seqQual.Clear();
break;
case VirtualQualSeqListTestAttributes.ClearSeq:
seqCollection.Clear();
break;
case VirtualQualSeqListTestAttributes.CopyTo:
seqList.CopyTo(null, 1);
break;
case VirtualQualSeqListTestAttributes.Indexer:
seqList[0] = null;
break;
case VirtualQualSeqListTestAttributes.IndexerSeq:
listSeq[0] = null;
break;
case VirtualQualSeqListTestAttributes.Insert:
seqList.Insert(0,
(IQualitativeSequence) new QualitativeSequence(
Alphabets.DNA,
FastQFormatType.Illumina, "ACCTT"));
break;
case VirtualQualSeqListTestAttributes.InsertSeq:
listSeq.Insert(0,
(IQualitativeSequence) new QualitativeSequence(
Alphabets.DNA,
FastQFormatType.Illumina, "ACCTT"));
break;
case VirtualQualSeqListTestAttributes.Remove:
seqList.Remove(
(IQualitativeSequence)
new QualitativeSequence(
Alphabets.DNA,
FastQFormatType.Illumina, "ACCTT"));
break;
case VirtualQualSeqListTestAttributes.RemoveCollection:
seqCollection.Remove(
(IQualitativeSequence)
new QualitativeSequence(
Alphabets.DNA,
FastQFormatType.Illumina, "ACCTT"));
break;
case VirtualQualSeqListTestAttributes.RemoveAtQual:
listQual.RemoveAt(-1);
break;
case VirtualQualSeqListTestAttributes.RemoveAtSeq:
listSeq.RemoveAt(-1);
break;
}
Assert.Fail();
}
catch (NotSupportedException)
{
ApplicationLog.WriteLine(
"VQSL P2 : Successfully validated the method");
Console.WriteLine(
"VQSL P2 : Successfully validated the method");
}
catch (ArgumentNullException)
{
ApplicationLog.WriteLine(
"VQSL P2 : Successfully validated the method");
Console.WriteLine(
"VQSL P2 : Successfully validated the method");
}
}
