/// <summary>
        /// General method to validate default score for different FastQ 
        /// format with different sequence.
        /// <param name="nodeName">xml node name.</param>
        /// <param name="parameters">Different Qualitative Score method parameter.</param>
        /// </summary>
        void ValidateFastQDefaultScores(string nodeName, QualitativeSequenceParameters parameters)
        {
            // Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedMaxScore = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.DefualtMaxScore);
            string expectedMinScore = this.utilityObj.xmlUtil.GetTextValue(
                 nodeName, Constants.DefaultMinScore);

            QualitativeSequence createdQualitativeSequence = null;
            string qualityScoresString = Utility.GetDefaultEncodedQualityScores(expectedFormatType, inputSequence.Length);
            byte[] expectedMaxScores = Utility.GetEncodedQualityScores((byte)int.Parse(expectedMaxScore, null as IFormatProvider), inputSequence.Length);
            byte[] expectedMinScores = Utility.GetEncodedQualityScores((byte)int.Parse(expectedMinScore, null as IFormatProvider), inputSequence.Length);
            int i = 0;
            switch (parameters)
            {
                case QualitativeSequenceParameters.DefaultScoreWithAlphabets:
                    createdQualitativeSequence = new QualitativeSequence(
                        alphabet, expectedFormatType, inputSequence,
                         qualityScoresString);

                    // Validate default score.
                    i = 0;
                    foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
                    {
                        Assert.AreEqual(qualitativeScore,
                            (byte)(qualityScoresString[i]));
                        i++;
                    }

                    // Log VSTest GUI.
                    ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
                        "Qualitative Sequence P1:Qualitative Sequence Default score {0} is as expected.",
                        qualityScoresString[0]));
                    break;
                case QualitativeSequenceParameters.DefaultScoreWithSequence:
                    createdQualitativeSequence = new QualitativeSequence(alphabet,
                        expectedFormatType, inputSequence,
                        qualityScoresString);

                    i = 0;
                    // Validate default score.
                    foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
                    {
                        Assert.AreEqual(qualitativeScore,
                            (byte)(qualityScoresString[i]));
                        i++;
                    }

                    // Log VSTest GUI.
                    ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
                        "Qualitative Sequence P1:Qualitative Sequence Default score {0} is as expected.",
                        qualityScoresString[0]));
                    break;
                case QualitativeSequenceParameters.MaxDefaultScore:
                    createdQualitativeSequence = new QualitativeSequence(
                        alphabet, expectedFormatType, Encoding.UTF8.GetBytes(inputSequence),
                        expectedMaxScores);
                    i = 0;
                    // Validate default maximum score.
                    foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
                    {
                        Assert.AreEqual(qualitativeScore,
                            expectedMaxScores[i]);
                        i++;
                    }

                    // Log VSTest GUI.
                    ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
                        "Qualitative Sequence P1:Qualitative Sequence Maximum score {0} is as expected.",
                        QualitativeSequence.GetMaxEncodedQualScore(expectedFormatType)));
                    break;
                case QualitativeSequenceParameters.MinDefaultScore:
                    createdQualitativeSequence = new QualitativeSequence(
                        alphabet, expectedFormatType, Encoding.UTF8.GetBytes(inputSequence),
                       expectedMinScores);

                    i = 0;
                    // Validate default minimum score.
                    foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
                    {
                        Assert.AreEqual(qualitativeScore,
                            expectedMinScores[i]);
                        i++;
                    }

                    // Log VSTest GUI.
                    ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative Sequence Minimum score {0} is as expected.",
                        QualitativeSequence.GetMinEncodedQualScore(expectedFormatType)));
                    break;
                default:
                    break;
            }
        }
Example #2
0
        void GeneralQualitativeSequence(
            string nodeName, QualitativeSequenceParameters parameters)
        {
            // Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(
                                                         nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            string expectedScore = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.ExpectedScore);
            QualitativeSequence createdQualitativeSequence = null;
            string inputSequence = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedSequence = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.ExpectedSequenceNode);
            string expectedSequenceCount = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.QSequenceCount);
            string expectedMaxScore = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.MaxScoreNode);
            string inputScore = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.InputScoreNode);
            string expectedOuptutScore = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.InputScoreNode);
            string inputQuality = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.InputByteArrayNode);

            byte[] byteArray       = ASCIIEncoding.ASCII.GetBytes(inputQuality);
            Byte[] inputScoreArray = encodingObj.GetBytes(inputQuality);


            // Create and validate Qualitative Sequence.
            switch (parameters)
            {
            case QualitativeSequenceParameters.Score:
                createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                                                                     inputSequence, inputQuality);
                int count = 0;
                // Validate score
                foreach (byte qualScore in createdQualitativeSequence.QualityScores)
                {
                    Assert.AreEqual(qualScore, inputScoreArray[count]);
                    count++;
                }
                break;

            case QualitativeSequenceParameters.ByteArray:
                byte[] scoreValue = ASCIIEncoding.ASCII.GetBytes(inputSequence);
                int    index      = 0;
                createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                                                                     scoreValue, inputScoreArray);

                // Validate score
                foreach (byte qualScore in createdQualitativeSequence.QualityScores)
                {
                    Assert.AreEqual(qualScore, inputScoreArray[index]);
                    index++;
                }
                break;

            default:
                break;
            }

            string qualitativeSequence = new string(createdQualitativeSequence.Select(a => (char)a).ToArray());

            // Validate createdSequence qualitative sequence.
            Assert.IsNotNull(createdQualitativeSequence);
            Assert.AreEqual(alphabet, createdQualitativeSequence.Alphabet);
            Assert.AreEqual(expectedSequence, qualitativeSequence);
            Assert.AreEqual(expectedSequenceCount, createdQualitativeSequence.Count.ToString((IFormatProvider)null));
            Assert.AreEqual(expectedScore, createdQualitativeSequence.QualityScores.Count().ToString((IFormatProvider)null));
            Assert.AreEqual(expectedFormatType, createdQualitativeSequence.FormatType);

            // Logs to the NUnit GUI (Console.Out) window
            Console.WriteLine(string.Format((IFormatProvider)null,
                                            "Qualitative Sequence BVT:Qualitative Sequence {0} is as expected.",
                                            qualitativeSequence));

            Console.WriteLine(string.Format((IFormatProvider)null,
                                            "Qualitative Sequence BVT:Qualitative Sequence Score {0} is as expected.",
                                            createdQualitativeSequence.Count().ToString((IFormatProvider)null)));

            Console.WriteLine(string.Format((IFormatProvider)null,
                                            "Qualitative Sequence BVT:Qualitative format type {0} is as expected.",
                                            createdQualitativeSequence.FormatType));
        }
        /// <summary>
        /// General method to validate creation of Qualitative sequence.
        /// <param name="nodeName">xml node name.</param>
        /// <param name="parameters">Different Qualitative Sequence parameters.</param>
        /// </summary>
        void GeneralQualitativeSequence(
            string nodeName, QualitativeSequenceParameters parameters)
        {
            // Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            QualitativeSequence createdQualitativeSequence = null;
            string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedSequence = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.ExpectedSequenceNode);
            string expectedSequenceCount = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.QSequenceCount);
            string inputScoreforIUPAC = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.MaxScoreNode);
            string inputQuality = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.InputByteArrayNode);
            byte[] byteArray = Encoding.UTF8.GetBytes(inputQuality);
            int index = 0;

            // Create and validate Qualitative Sequence.
            switch (parameters)
            {
                case QualitativeSequenceParameters.Score:
                    createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                        inputSequence, Utility.GetDefaultEncodedQualityScores(expectedFormatType, inputSequence.Length));
                    // Validate score
                    foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
                    {
                        Assert.AreEqual(qualScore, Convert.ToInt32(inputScoreforIUPAC, (IFormatProvider)null));
                    }
                    break;
                case QualitativeSequenceParameters.ByteArray:
                    createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                       Encoding.UTF8.GetBytes(inputSequence), byteArray);

                    // Validate score
                    foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
                    {
                        Assert.AreEqual(qualScore, Convert.ToInt32(byteArray[index], (IFormatProvider)null));
                        index++;
                    }
                    break;
                default:
                    break;
            }

            // Validate createdSequence qualitative sequence.
            Assert.IsNotNull(createdQualitativeSequence);
            Assert.AreEqual(createdQualitativeSequence.Alphabet, alphabet);
            Assert.AreEqual(createdQualitativeSequence.ConvertToString(), expectedSequence);
            Assert.AreEqual(createdQualitativeSequence.Count.ToString((IFormatProvider)null), expectedSequenceCount);
            ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative Sequence {0} is as expected.", createdQualitativeSequence));
            ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative Sequence Score {0} is as expected.", createdQualitativeSequence.GetEncodedQualityScores()));
            Assert.AreEqual(createdQualitativeSequence.FormatType, expectedFormatType);
            ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative format type {0} is as expected.", createdQualitativeSequence.FormatType));
        }
        /// <summary>
        /// General method to validate Index of Qualitative Sequence Items.
        /// <param name="nodeName">xml node name.</param>
        /// <param name="indexParam">Different Qualitative Sequence parameters.</param>
        /// </summary>
        void ValidateGeneralQualitativeSeqItemIndices(string nodeName, QualitativeSequenceParameters indexParam)
        {
            // Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
               nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            QualitativeSequence createdQualitativeSequence = null;
            string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedFirstItemIdex = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.FirstItemIndex);
            string expectedLastItemIdex = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.LastItemIndex);
            string expectedGapIndex = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.IndexOfGap);
            long lastItemIndex;
            long index;

            // Create a qualitative Sequence.
            createdQualitativeSequence = new QualitativeSequence(
                alphabet, expectedFormatType, inputSequence,
                 Utility.GetDefaultEncodedQualityScores(expectedFormatType, inputSequence.Length));

            // Get a Index of qualitative sequence items
            switch (indexParam)
            {
                case QualitativeSequenceParameters.IndexOfNonGap:
                    index = createdQualitativeSequence.IndexOfNonGap();

                    // Validate Qualitative sequence item indices.
                    Assert.AreEqual(index, Convert.ToInt32(expectedFirstItemIdex, (IFormatProvider)null));
                    break;
                case QualitativeSequenceParameters.IndexOfNonGapWithParam:
                    index = createdQualitativeSequence.IndexOfNonGap(5);

                    // Validate Qualitative sequence item indices.
                    Assert.AreEqual(index, Convert.ToInt32(expectedGapIndex, (IFormatProvider)null));
                    break;
                case QualitativeSequenceParameters.LastIndexOf:
                    lastItemIndex = createdQualitativeSequence.LastIndexOfNonGap();

                    // Validate Qualitative sequence item indices.
                    Assert.AreEqual(lastItemIndex, Convert.ToInt32(expectedLastItemIdex, (IFormatProvider)null));
                    break;
                case QualitativeSequenceParameters.LastIndexOfWithPam:
                    lastItemIndex = createdQualitativeSequence.LastIndexOfNonGap(5);

                    // Validate Qualitative sequence item indices.
                    Assert.AreEqual(lastItemIndex, Convert.ToInt32(expectedGapIndex, (IFormatProvider)null));
                    break;
                default:
                    break;
            }

            // Logs to the VSTest GUI window
            ApplicationLog.WriteLine("Qualitative Sequence P1 : Qualitative SequenceItems indices validation completed successfully.");
        }
Example #5
0
        /// <summary>
        /// General method to validate Index of Qualitative Sequence Items.
        /// <param name="nodeName">xml node name.</param>
        /// <param name="indexParam">Different Qualitative Sequence parameters.</param>
        /// </summary>
        void ValidateGeneralQualitativeSeqItemIndices(
            string nodeName, QualitativeSequenceParameters indexParam)
        {
            // Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(
                                                         nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            QualitativeSequence createdQualitativeSequence = null;
            string inputSequence = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedFirstItemIdex = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.FirstItemIndex);
            string expectedLastItemIdex = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.LastItemIndex);
            string expectedGapIndex = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.IndexOfGap);
            long lastItemIndex;
            long index;

            // Create a qualitative Sequence.
            createdQualitativeSequence = new QualitativeSequence(
                alphabet, expectedFormatType, inputSequence,
                ((char)QualitativeSequence.GetDefaultQualScore(expectedFormatType)).ToString());

            // Get a Index of qualitative sequence items
            switch (indexParam)
            {
            case QualitativeSequenceParameters.IndexOfNonGap:
                index = createdQualitativeSequence.IndexOfNonGap();

                // Validate Qualitative sequence item indices.
                Assert.AreEqual(index, Convert.ToInt32(expectedFirstItemIdex, (IFormatProvider)null));
                break;

            case QualitativeSequenceParameters.IndexOfNonGapWithParam:
                index = createdQualitativeSequence.IndexOfNonGap(5);

                // Validate Qualitative sequence item indices.
                Assert.AreEqual(index, Convert.ToInt32(expectedGapIndex, (IFormatProvider)null));
                break;

            case QualitativeSequenceParameters.LastIndexOf:
                lastItemIndex = createdQualitativeSequence.LastIndexOfNonGap();

                // Validate Qualitative sequence item indices.
                Assert.AreEqual(lastItemIndex, Convert.ToInt32(expectedLastItemIdex, (IFormatProvider)null));
                break;

            case QualitativeSequenceParameters.LastIndexOfWithPam:
                lastItemIndex = createdQualitativeSequence.LastIndexOfNonGap(5);

                // Validate Qualitative sequence item indices.
                Assert.AreEqual(lastItemIndex, Convert.ToInt32(expectedGapIndex, (IFormatProvider)null));
                break;

            default:
                break;
            }

            // Logs to the NUnit GUI (Console.Out) window
            Console.WriteLine("Qualitative Sequence P1 : Qualitative SequenceItems indices validation completed successfully.");
        }
Example #6
0
        /// <summary>
        /// General method to validate default score for different FastQ
        /// format with different sequence.
        /// <param name="nodeName">xml node name.</param>
        /// <param name="parameters">Different Qualitative Score method parameter.</param>
        /// </summary>
        void ValidateFastQDefaultScores(
            string nodeName, QualitativeSequenceParameters parameters)
        {
            // Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(
                                                         nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            string inputSequence = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedMaxScore = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.DefualtMaxScore);
            string expectedMinScore = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.DefaultMinScore);

            QualitativeSequence createdQualitativeSequence = null;

            switch (parameters)
            {
            case QualitativeSequenceParameters.DefaultScoreWithAlphabets:
                createdQualitativeSequence = new QualitativeSequence(
                    alphabet, expectedFormatType, inputSequence,
                    ((char)QualitativeSequence.GetDefaultQualScore(expectedFormatType)).ToString());

                // Validate default score.
                foreach (byte qualitativeScore in createdQualitativeSequence.QualityScores)
                {
                    Assert.AreEqual(qualitativeScore,
                                    QualitativeSequence.GetDefaultQualScore(expectedFormatType));
                }

                // Log Nunit GUI.
                Console.WriteLine(string.Format((IFormatProvider)null,
                                                "Qualitative Sequence P1:Qualitative Sequence Default score {0} is as expected.",
                                                QualitativeSequence.GetDefaultQualScore(expectedFormatType)));
                break;

            case QualitativeSequenceParameters.DefaultScoreWithSequence:
                createdQualitativeSequence = new QualitativeSequence(alphabet,
                                                                     expectedFormatType, inputSequence,
                                                                     ((char)QualitativeSequence.GetDefaultQualScore(expectedFormatType)).ToString());

                // Validate default score.
                foreach (byte qualitativeScore in createdQualitativeSequence.QualityScores)
                {
                    Assert.AreEqual(qualitativeScore,
                                    QualitativeSequence.GetDefaultQualScore(expectedFormatType));
                }

                // Log Nunit GUI.
                Console.WriteLine(string.Format((IFormatProvider)null,
                                                "Qualitative Sequence P1:Qualitative Sequence Default score {0} is as expected.",
                                                QualitativeSequence.GetDefaultQualScore(expectedFormatType)));
                break;

            case QualitativeSequenceParameters.MaxDefaultScore:
                createdQualitativeSequence = new QualitativeSequence(
                    alphabet, expectedFormatType, encodingObj.GetBytes(inputSequence),
                    new byte[] { byte.Parse(expectedMaxScore, (IFormatProvider)null) });

                // Validate default maximum score.
                foreach (byte qualitativeScore in createdQualitativeSequence.QualityScores)
                {
                    Assert.AreEqual(qualitativeScore,
                                    QualitativeSequence.GetMaxQualScore(expectedFormatType));
                }

                // Log Nunit GUI.
                Console.WriteLine(string.Format((IFormatProvider)null,
                                                "Qualitative Sequence P1:Qualitative Sequence Maximum score {0} is as expected.",
                                                QualitativeSequence.GetMaxQualScore(expectedFormatType)));
                break;

            case QualitativeSequenceParameters.MinDefaultScore:
                createdQualitativeSequence = new QualitativeSequence(
                    alphabet, expectedFormatType, encodingObj.GetBytes(inputSequence),
                    new byte[] { byte.Parse(expectedMinScore, (IFormatProvider)null) });

                // Validate default minimum score.
                foreach (byte qualitativeScore in createdQualitativeSequence.QualityScores)
                {
                    Assert.AreEqual(qualitativeScore,
                                    QualitativeSequence.GetMinQualScore(expectedFormatType));
                }

                // Log Nunit GUI.
                Console.WriteLine(string.Format((IFormatProvider)null,
                                                "Qualitative Sequence P1:Qualitative Sequence Minimum score {0} is as expected.",
                                                QualitativeSequence.GetMinQualScore(expectedFormatType)));
                break;

            default:
                break;
            }
        }
Example #7
0
        /// <summary>
        /// General method to validate default score for different FastQ
        /// format with different sequence.
        /// <param name="nodeName">xml node name.</param>
        /// <param name="parameters">Different Qualitative Score method parameter.</param>
        /// </summary>
        void ValidateFastQDefaultScores(string nodeName, QualitativeSequenceParameters parameters)
        {
            // Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(
                                                         nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            string inputSequence = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedMaxScore = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.DefualtMaxScore);
            string expectedMinScore = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.DefaultMinScore);

            QualitativeSequence createdQualitativeSequence = null;
            string qualityScoresString = Utility.GetDefaultEncodedQualityScores(expectedFormatType, inputSequence.Length);

            byte[] expectedMaxScores = Utility.GetEncodedQualityScores((byte)int.Parse(expectedMaxScore, null as IFormatProvider), inputSequence.Length);
            byte[] expectedMinScores = Utility.GetEncodedQualityScores((byte)int.Parse(expectedMinScore, null as IFormatProvider), inputSequence.Length);
            int    i = 0;

            switch (parameters)
            {
            case QualitativeSequenceParameters.DefaultScoreWithAlphabets:
                createdQualitativeSequence = new QualitativeSequence(
                    alphabet, expectedFormatType, inputSequence,
                    qualityScoresString);

                // Validate default score.
                i = 0;
                foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
                {
                    Assert.AreEqual(qualitativeScore,
                                    (byte)(qualityScoresString[i]));
                    i++;
                }

                // Log VSTest GUI.
                ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
                                                       "Qualitative Sequence P1:Qualitative Sequence Default score {0} is as expected.",
                                                       qualityScoresString[0]));
                break;

            case QualitativeSequenceParameters.DefaultScoreWithSequence:
                createdQualitativeSequence = new QualitativeSequence(alphabet,
                                                                     expectedFormatType, inputSequence,
                                                                     qualityScoresString);

                i = 0;
                // Validate default score.
                foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
                {
                    Assert.AreEqual(qualitativeScore,
                                    (byte)(qualityScoresString[i]));
                    i++;
                }

                // Log VSTest GUI.
                ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
                                                       "Qualitative Sequence P1:Qualitative Sequence Default score {0} is as expected.",
                                                       qualityScoresString[0]));
                break;

            case QualitativeSequenceParameters.MaxDefaultScore:
                createdQualitativeSequence = new QualitativeSequence(
                    alphabet, expectedFormatType, Encoding.UTF8.GetBytes(inputSequence),
                    expectedMaxScores);
                i = 0;
                // Validate default maximum score.
                foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
                {
                    Assert.AreEqual(qualitativeScore,
                                    expectedMaxScores[i]);
                    i++;
                }

                // Log VSTest GUI.
                ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
                                                       "Qualitative Sequence P1:Qualitative Sequence Maximum score {0} is as expected.",
                                                       QualitativeSequence.GetMaxEncodedQualScore(expectedFormatType)));
                break;

            case QualitativeSequenceParameters.MinDefaultScore:
                createdQualitativeSequence = new QualitativeSequence(
                    alphabet, expectedFormatType, Encoding.UTF8.GetBytes(inputSequence),
                    expectedMinScores);

                i = 0;
                // Validate default minimum score.
                foreach (byte qualitativeScore in createdQualitativeSequence.GetEncodedQualityScores())
                {
                    Assert.AreEqual(qualitativeScore,
                                    expectedMinScores[i]);
                    i++;
                }

                // Log VSTest GUI.
                ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative Sequence Minimum score {0} is as expected.",
                                                       QualitativeSequence.GetMinEncodedQualScore(expectedFormatType)));
                break;

            default:
                break;
            }
        }
Example #8
0
        /// <summary>
        /// General method to validate creation of Qualitative sequence.
        /// <param name="nodeName">xml node name.</param>
        /// <param name="parameters">Different Qualitative Sequence parameters.</param>
        /// </summary>
        void GeneralQualitativeSequence(
            string nodeName, QualitativeSequenceParameters parameters)
        {
            // Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(
                                                         nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            QualitativeSequence createdQualitativeSequence = null;
            string inputSequence = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedSequence = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.ExpectedSequenceNode);
            string expectedSequenceCount = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.QSequenceCount);
            string inputScoreforIUPAC = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.MaxScoreNode);
            string inputQuality = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.InputByteArrayNode);

            byte[] byteArray = Encoding.UTF8.GetBytes(inputQuality);
            int    index     = 0;

            // Create and validate Qualitative Sequence.
            switch (parameters)
            {
            case QualitativeSequenceParameters.Score:
                createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                                                                     inputSequence, Utility.GetDefaultEncodedQualityScores(expectedFormatType, inputSequence.Length));
                // Validate score
                foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
                {
                    Assert.AreEqual(qualScore, Convert.ToInt32(inputScoreforIUPAC, (IFormatProvider)null));
                }
                break;

            case QualitativeSequenceParameters.ByteArray:
                createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                                                                     Encoding.UTF8.GetBytes(inputSequence), byteArray);

                // Validate score
                foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
                {
                    Assert.AreEqual(qualScore, Convert.ToInt32(byteArray[index], (IFormatProvider)null));
                    index++;
                }
                break;

            default:
                break;
            }

            // Validate createdSequence qualitative sequence.
            Assert.IsNotNull(createdQualitativeSequence);
            Assert.AreEqual(createdQualitativeSequence.Alphabet, alphabet);
            Assert.AreEqual(createdQualitativeSequence.ConvertToString(), expectedSequence);
            Assert.AreEqual(createdQualitativeSequence.Count.ToString((IFormatProvider)null), expectedSequenceCount);
            ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative Sequence {0} is as expected.", createdQualitativeSequence));
            ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative Sequence Score {0} is as expected.", createdQualitativeSequence.GetEncodedQualityScores()));
            Assert.AreEqual(createdQualitativeSequence.FormatType, expectedFormatType);
            ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence P1:Qualitative format type {0} is as expected.", createdQualitativeSequence.FormatType));
        }
        void GeneralQualitativeSequence(
            string nodeName, QualitativeSequenceParameters parameters)
        {
            //// Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            string expectedScore = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.ExpectedScore);
            QualitativeSequence createdQualitativeSequence = null;
            string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedSequence = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.ExpectedSequenceNode);
            string expectedSequenceCount = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.QSequenceCount);           
            string inputQuality = this.utilityObj.xmlUtil.GetTextValue(
            nodeName, Constants.InputByteArrayNode);            
            Byte[] inputScoreArray = Encoding.UTF8.GetBytes(inputQuality);

            // Create and validate Qualitative Sequence.
            switch (parameters)
            {

                case QualitativeSequenceParameters.Score:
                    createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                    inputSequence, inputQuality);
                    int count = 0;
                    // Validate score
                    foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
                    {
                        Assert.AreEqual(qualScore, inputScoreArray[count]);
                        count++;
                    }
                    break;
                case QualitativeSequenceParameters.ByteArray:
                    byte[] scoreValue = Encoding.UTF8.GetBytes(inputSequence);          
                    int index = 0;
                    createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                    scoreValue, inputScoreArray);

                    // Validate score
                    foreach (byte qualScore in createdQualitativeSequence.GetEncodedQualityScores())
                    {
                        Assert.AreEqual(qualScore, inputScoreArray[index]);
                        index++;
                    }
                    break;
                default:
                    break;
            }

            string qualitativeSequence = new string(createdQualitativeSequence.Select(a => (char)a).ToArray());

            // Validate createdSequence qualitative sequence.
            Assert.IsNotNull(createdQualitativeSequence);
            Assert.AreEqual(alphabet, createdQualitativeSequence.Alphabet);

            Assert.AreEqual(expectedSequence, qualitativeSequence);
            Assert.AreEqual(expectedSequenceCount, createdQualitativeSequence.Count.ToString((IFormatProvider)null));
            ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence BVT:Qualitative Sequence {0} is as expected.", qualitativeSequence));

            Assert.AreEqual(expectedScore, createdQualitativeSequence.GetEncodedQualityScores().Count().ToString((IFormatProvider)null));
            ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence BVT:Qualitative Sequence Score {0} is as expected.", createdQualitativeSequence.Count().ToString((IFormatProvider)null)));

            Assert.AreEqual(expectedFormatType, createdQualitativeSequence.FormatType);
            ApplicationLog.WriteLine(string.Format(null, "Qualitative Sequence BVT:Qualitative format type {0} is as expected.", createdQualitativeSequence.FormatType));
        }
Example #10
0
        /// <summary>
        /// General method to validate creation of Qualitative sequence.
        /// <param name="nodeName">xml node name.</param>
        /// <param name="parameters">Different Qualitative Sequence parameters.</param>
        /// </summary>
        void GeneralQualitativeSequence(
            string nodeName, QualitativeSequenceParameters parameters)
        {
            // Gets the actual sequence and the alphabet from the Xml
            IAlphabet alphabet = Utility.GetAlphabet(utilityObj.xmlUtil.GetTextValue(
                                                         nodeName, Constants.AlphabetNameNode));
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            QualitativeSequence createdQualitativeSequence = null;
            string inputSequence = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string expectedSequence = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.ExpectedSequenceNode);
            string expectedSequenceCount = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.QSequenceCount);
            string inputScoreforIUPAC = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.MaxScoreNode);
            string expectedOuptutScore = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.InputScoreNode);
            string inputQuality = utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.InputByteArrayNode);

            byte[] byteArray = UTF8Encoding.UTF8.GetBytes(inputQuality);
            int    index     = 0;

            // Create and validate Qualitative Sequence.
            switch (parameters)
            {
            case QualitativeSequenceParameters.Score:
                createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                                                                     inputSequence, ((char)QualitativeSequence.GetDefaultQualScore(expectedFormatType)).ToString());
                // Validate score
                foreach (byte qualScore in createdQualitativeSequence.QualityScores)
                {
                    Assert.AreEqual(qualScore, Convert.ToInt32(inputScoreforIUPAC, (IFormatProvider)null));
                }
                break;

            case QualitativeSequenceParameters.ByteArray:
                createdQualitativeSequence = new QualitativeSequence(alphabet, expectedFormatType,
                                                                     UTF8Encoding.UTF8.GetBytes(inputSequence), new byte[] { byte.Parse(expectedOuptutScore, (IFormatProvider)null) });

                // Validate score
                foreach (byte qualScore in createdQualitativeSequence.QualityScores)
                {
                    Assert.AreEqual(qualScore, Convert.ToInt32(byteArray[index], (IFormatProvider)null));
                    index++;
                }
                break;

            default:
                break;
            }

            // Validate createdSequence qualitative sequence.
            Assert.IsNotNull(createdQualitativeSequence);
            Assert.AreEqual(createdQualitativeSequence.Alphabet, alphabet);
            Assert.AreEqual(new string(createdQualitativeSequence.Select(a => (char)a).ToArray()), expectedSequence);
            Assert.AreEqual(createdQualitativeSequence.Count.ToString((IFormatProvider)null), expectedSequenceCount);
            Assert.AreEqual(createdQualitativeSequence.FormatType, expectedFormatType);

            // Logs to the VSTest GUI (Console.Out) window
            Console.WriteLine(string.Format((IFormatProvider)null,
                                            "Qualitative Sequence P1:Qualitative Sequence {0} is as expected.",
                                            createdQualitativeSequence.ToString()));

            Console.WriteLine(string.Format((IFormatProvider)null,
                                            "Qualitative Sequence P1:Qualitative Sequence Score {0} is as expected.",
                                            createdQualitativeSequence.QualityScores.ToString()));

            Console.WriteLine(string.Format((IFormatProvider)null,
                                            "Qualitative Sequence P1:Qualitative format type {0} is as expected.",
                                            createdQualitativeSequence.FormatType));
        }
        /// <summary>
        /// General method to invalidate creation of Qualitative sequence
        /// with invalid qual score..
        /// <param name="nodeName">Name of the Format type xml node.</param>
        /// <param name="errorMessage">Error message xml node name.</param>
        /// <param name="qualPam">Qualitative sequence constructor paramter.</param>
        /// </summary>
        void InValidateQualSequence(string nodeName, string errorMessage,
            QualitativeSequenceParameters qualPam)
        {
            // Get values from xml.
            FastQFormatType expectedFormatType = Utility.GetFastQFormatType(
                this.utilityObj.xmlUtil.GetTextValue(nodeName, Constants.FastQFormatType));
            string expectedErrorMessage = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, errorMessage).Replace("FORMATTYPE", expectedFormatType.ToString());
            string inputSequence = this.utilityObj.xmlUtil.GetTextValue(
                nodeName, Constants.inputSequenceNode);
            string actualError = string.Empty;
            string updatedActualError = string.Empty;
            QualitativeSequence qualSeq = null;
            byte[] scoreArray = { 65, 64, 66, 68, 69, 67, 65, 65, 65, 65, 65,
                                   200, 3, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 4 };
            switch (qualPam)
            {
                case QualitativeSequenceParameters.FormatType:
                    //Try to create Qualitative sequence by invalid Quality score
                    try
                    {
                        qualSeq = new QualitativeSequence(Alphabets.DNA, expectedFormatType,
                          Encoding.UTF8.GetBytes(inputSequence), (byte[])null);
                        Assert.Fail();
                    }
                    catch (ArgumentException ex)
                    {
                        actualError = ex.Message;
                        // Validate an expected exception.
                        updatedActualError = actualError.Replace("\r", "").Replace("\n", "");
                        Assert.AreEqual(expectedErrorMessage.ToLower(CultureInfo.CurrentCulture),
                            updatedActualError.ToLower(CultureInfo.CurrentCulture));
                    }
                    break;
                case QualitativeSequenceParameters.ByteArray:
                    //Try to create Qualitative sequence by invalid Quality score
                    try
                    {
                        qualSeq = new QualitativeSequence(Alphabets.DNA, expectedFormatType,
                            Encoding.UTF8.GetBytes(inputSequence), scoreArray);
                        Assert.Fail();
                    }
                    catch (ArgumentException ex)
                    {
                        actualError = ex.Message;
                        // Validate an expected exception.
                        updatedActualError = actualError.Replace("\r", "").Replace("\n", "");
                        Assert.AreEqual(expectedErrorMessage.ToLower(CultureInfo.CurrentCulture),
                            updatedActualError.ToLower(CultureInfo.CurrentCulture));
                    }
                    break;
                default:
                    break;
            }

            // Log to VSTest GUI.
            Assert.IsNull(qualSeq);
            ApplicationLog.WriteLine(string.Format((IFormatProvider)null,
                "Qualitative Sequence P2: Qualitative Sequence Invalid score exception was validated successfully {0}",
                updatedActualError));
        }