/// <summary>
/// Gets the expected error message for invalid similarity matrix type.
/// </summary>
/// <param name="nodeName">xml node</param>
/// <param name="invalidType">similarity matrix invalid type.</param>
/// <returns>Returns expected error message</returns>
private string GetExpectedErrorMeesageWithInvalidSimilarityMatrixType(string nodeName,
SimilarityMatrixInvalidTypes invalidType)
{
string expectedErrorMessage = string.Empty;
switch (invalidType)
{
case SimilarityMatrixInvalidTypes.FewAlphabetsSimilarityMatrix:
case SimilarityMatrixInvalidTypes.NonMatchingSimilarityMatrix:
expectedErrorMessage = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.ExpectedErrorMessage);
break;
case SimilarityMatrixInvalidTypes.EmptySimilaityMatrix:
expectedErrorMessage = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.EmptyMatrixErrorMessage);
break;
case SimilarityMatrixInvalidTypes.OnlyAlphabetSimilarityMatrix:
expectedErrorMessage = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.SimilarityMatrixFewerLinesException);
break;
case SimilarityMatrixInvalidTypes.ModifiedSimilarityMatrix:
expectedErrorMessage = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.ModifiedMatrixErrorMessage);
break;
case SimilarityMatrixInvalidTypes.NullSimilarityMatrix:
expectedErrorMessage = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.NullErrorMessage);
break;
case SimilarityMatrixInvalidTypes.EmptySequence:
expectedErrorMessage = this.utilityObj.xmlUtil.GetFileTextValue(nodeName,
Constants.EmptySequenceErrorMessage);
break;
case SimilarityMatrixInvalidTypes.ExpectedErrorMessage:
expectedErrorMessage = this.utilityObj.xmlUtil.GetFileTextValue(nodeName,
Constants.ExpectedErrorMessage);
break;
default:
break;
}
return expectedErrorMessage;
}
/// <summary>
/// Gets the similarity matrix file name for a given invalid similarity matrix type.
/// </summary>
/// <param name="nodeName">xml node.</param>
/// <param name="invalidType">similarity matrix invalid type.</param>
/// <returns>Returns similarity matrix file name.</returns>
private string GetSimilarityMatrixFileWithInvalidType(string nodeName,
SimilarityMatrixInvalidTypes invalidType)
{
string invalidFileNode = string.Empty;
string invalidFilePath = string.Empty;
switch (invalidType)
{
case SimilarityMatrixInvalidTypes.NonMatchingSimilarityMatrix:
invalidFileNode = Constants.BlosumInvalidFilePathNode;
break;
case SimilarityMatrixInvalidTypes.EmptySimilaityMatrix:
invalidFileNode = Constants.BlosumEmptyFilePathNode;
break;
case SimilarityMatrixInvalidTypes.OnlyAlphabetSimilarityMatrix:
invalidFileNode = Constants.BlosumOnlyAlphabetFilePathNode;
break;
case SimilarityMatrixInvalidTypes.FewAlphabetsSimilarityMatrix:
invalidFileNode = Constants.BlosumFewAlphabetsFilePathNode;
break;
case SimilarityMatrixInvalidTypes.ModifiedSimilarityMatrix:
invalidFileNode = Constants.BlosumModifiedFilePathNode;
break;
default:
break;
}
if (1 == string.Compare(invalidFileNode, string.Empty, StringComparison.CurrentCulture))
{
invalidFilePath = this.utilityObj.xmlUtil.GetTextValue(nodeName, invalidFileNode);
}
return invalidFilePath;
}
private void InValidateSmithWatermanAlignmentWithInvalidSimilarityMatrix(string nodeName,
bool isTextFile,
SimilarityMatrixInvalidTypes
invalidType,
AlignParameters additionalParameter,
AlignmentType alignType)
{
Sequence aInput = null;
Sequence bInput = null;
ISequence inputSequence1;
ISequence inputSequence2;
IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.AlphabetNameNode));
if (isTextFile)
{
// Read the xml file for getting both the files for aligning.
string firstInputFilepath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode1);
string secondInputFilepath = this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.FilePathNode2);
// Parse the files and get the sequence.
var parseObjectForFile1 = new FastAParser { Alphabet = alphabet };
inputSequence1 = parseObjectForFile1.Parse(firstInputFilepath).ElementAt(0);
inputSequence2 = parseObjectForFile1.Parse(secondInputFilepath).ElementAt(0);
// Create input sequence for sequence string in different cases.
GetSequenceWithCaseType(new string(inputSequence1.Select(a => (char) a).ToArray()),
new string(inputSequence2.Select(a => (char) a).ToArray()),
alphabet, SequenceCaseType.LowerCase, out aInput, out bInput);
}
else
{
string firstInputSequence = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.SequenceNode1);
string secondInputSequence = this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.SequenceNode2);
// Create input sequence for sequence string in different cases.
GetSequenceWithCaseType(firstInputSequence, secondInputSequence,
alphabet, SequenceCaseType.LowerCase, out aInput, out bInput);
}
ApplicationLog.WriteLine(string.Concat(
"SmithWatermanAligner P2 : First sequence used is '{0}'.",
new string(aInput.Select(a => (char) a).ToArray())));
ApplicationLog.WriteLine(string.Concat(
"SmithWatermanAligner P2 : Second sequence used is '{0}'.",
new string(bInput.Select(a => (char) a).ToArray())));
// Create similarity matrix object for a invalid file.
string blosumFilePath = this.GetSimilarityMatrixFileWithInvalidType(nodeName, invalidType);
Exception actualExpection = null;
// For invalid similarity matrix data format; exception will be thrown while instantiating
SimilarityMatrix sm = null;
try
{
if (invalidType != SimilarityMatrixInvalidTypes.NullSimilarityMatrix)
{
sm = new SimilarityMatrix(new StreamReader(blosumFilePath));
}
}
catch (InvalidDataException ex)
{
actualExpection = ex;
}
// For non matching similarity matrix exception will be thrown while alignment
if (actualExpection == null)
{
int gapOpenCost = int.Parse(this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.GapOpenCostNode), null);
int gapExtensionCost = int.Parse(this.utilityObj.xmlUtil.GetTextValue(nodeName,
Constants.GapExtensionCostNode), null);
// Create SmithWatermanAligner instance and set its values.
var smithWatermanObj = new SmithWatermanAligner();
if (additionalParameter != AlignParameters.AllParam)
{
smithWatermanObj.SimilarityMatrix = sm;
smithWatermanObj.GapOpenCost = gapOpenCost;
smithWatermanObj.GapExtensionCost = gapExtensionCost;
}
// Align the input sequences and catch the exception.
switch (additionalParameter)
{
case AlignParameters.AlignList:
switch (alignType)
{
case AlignmentType.Align:
try
{
smithWatermanObj.Align(new List<ISequence> {aInput, bInput});
}
catch (ArgumentException ex)
{
actualExpection = ex;
}
break;
default:
try
{
smithWatermanObj.AlignSimple(new List<ISequence> {aInput, bInput});
}
catch (ArgumentException ex)
{
actualExpection = ex;
}
break;
}
break;
case AlignParameters.AlignTwo:
switch (alignType)
{
case AlignmentType.Align:
try
{
smithWatermanObj.Align(aInput, bInput);
}
catch (ArgumentException ex)
{
actualExpection = ex;
}
break;
default:
try
{
smithWatermanObj.AlignSimple(aInput, bInput);
}
catch (ArgumentException ex)
{
actualExpection = ex;
}
break;
}
break;
case AlignParameters.AllParam:
switch (alignType)
{
case AlignmentType.Align:
try
{
smithWatermanObj.Align(sm, gapOpenCost, gapExtensionCost,
aInput, bInput);
}
catch (ArgumentException ex)
{
actualExpection = ex;
}
break;
default:
try
{
smithWatermanObj.AlignSimple(sm, gapOpenCost, aInput, bInput);
}
catch (ArgumentException ex)
{
actualExpection = ex;
}
break;
}
break;
default:
break;
}
}
// Validate that expected exception is thrown using error message.
string expectedErrorMessage = this.GetExpectedErrorMeesageWithInvalidSimilarityMatrixType(nodeName,
invalidType);
Assert.AreEqual(expectedErrorMessage, actualExpection.Message);
ApplicationLog.WriteLine(string.Concat(
"SmithWatermanAligner P2 : Expected Error message is thrown ", expectedErrorMessage));
}
