//******************************************************************************************************
//  StringExtensionsTest.cs - Gbtc
//
//  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  03/20/2011 - Aniket Salver
//       Generated original version of source code.
//  12/13/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace GSF.Core.Tests
{
    [TestClass]
    public class StringExtensionsTest
    {
        private readonly string strTestMethod = string.Empty;
        private string testvalue = "test";
        private string testResult = " ";
        char c = 'a';
        int intValue = 0;
        int intData = -1;
        bool boolvalue = true;
        //Func<char, bool> characterTestFunction;

        // This test method validated given String represent a boolean value.
        [TestMethod]
        public void ParseBoolean_Valid()
        {
            ////Act
            bool result = strTestMethod.ParseBoolean();
            ////Assert
            Assert.AreEqual(false, result);
        }

        // This method will validate given string parameter is not an empty or null string
        [TestMethod]
        public void NotEmptyWithParameter_Valid()
        {
            ////Act
            string result = strTestMethod.NotEmpty(testvalue);
            ////Assert
            Assert.AreEqual(testvalue, result);
        }

        // This test method Ensures parameter is not an empty or null string
        [TestMethod]
        public void NotEmpty_Valid()
        {
            ////Act
            string result = strTestMethod.NotEmpty();
            ////Assert
            Assert.AreEqual(testResult, result);
        }

        // This test method Removes all white space from a string
        [TestMethod]
        public void RemoveWhiteSpace_Valid()
        {
            ////Act
            string result = strTestMethod.RemoveWhiteSpace();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method Removes all white space from a string with input character
        [TestMethod]
        public void ReplaceWhiteSpacewithparameter_Valid()
        {
            ////Act
            string result = strTestMethod.ReplaceWhiteSpace(c);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Removes all control characters from a string.
        [TestMethod]
        public void RemoveControlCharacters_Valid()
        {
            ////Act
            string result = strTestMethod.RemoveControlCharacters();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Replace all control characters from a string.
        [TestMethod]
        public void ReplaceControlCharacters_Valid()
        {
            ////Act
            string result = strTestMethod.ReplaceControlCharacters();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Replace all control characters from a string with input parameter as char.
        [TestMethod]
        public void ReplaceControlCharacterswithparameter_Valid()
        {
            ////Act
            string result = strTestMethod.ReplaceControlCharacters(c);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Removes all carriage returns and line feeds from a string
        [TestMethod]
        public void RemoveCrLfs_Valid()
        {
            ////Act
            string result = strTestMethod.RemoveCrLfs();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Removes all carriage returns and line feeds from a string.
        [TestMethod]
        public void RemoveCrLfswithparameter_Valid()
        {
            ////Act
            string result = strTestMethod.ReplaceCrLfs(c);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Removes duplicate character strings (adjoining replication) in a string.
        [TestMethod]
        public void RemoveDuplicates_Valid()
        {
            ////Act
            string result = strTestMethod.RemoveDuplicates(testvalue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Removes the terminator ('\0') from a null terminated string.
        [TestMethod]
        public void RemoveNull_Valid()
        {
            ////Act
            string result = strTestMethod.RemoveNull();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Replaces all repeating white space with specified spacing character.
        [TestMethod]
        public void RemoveDuplicateWhiteSpace_Valid()
        {
            ////Act
            string result = strTestMethod.RemoveDuplicateWhiteSpace();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Replaces all repeating white space with specified spacing character.
        [TestMethod]
        public void RemoveDuplicateWhiteSpacewithparameter_Valid()
        {
            ////Act
            string result = strTestMethod.RemoveDuplicateWhiteSpace(c);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Counts the total number of the occurrences of a character in the given string.
        [TestMethod]
        public void CharCount_Valid()
        {
            ////Act
            int result = strTestMethod.CharCount(c);
            ////Assert
            Assert.AreEqual(intValue, result);
        }

        // This test method will Tests to see if a string is contains only digits based on Char.IsDigit function.
        [TestMethod]
        public void IsAllDigits_Valid()
        {
            ////Act
            bool result = strTestMethod.IsAllDigits();
            ////Assert
            Assert.AreEqual(false, result);
        }

        // This test method will Tests to see if a string contains only numbers based on Char.IsNumber function.
        [TestMethod]
        public void IsAllNumbers_Valid()
        {
            ////Act
            bool result = strTestMethod.IsAllNumbers();
            ////Assert
            Assert.AreEqual(false, result);
        }

        // This test method will Tests to see if a string's letters are all upper case.
        [TestMethod]
        public void IsAllUpper_Valid()
        {
            ////Act
            bool result = strTestMethod.IsAllUpper();
            ////Assert
            Assert.AreEqual(false, result);
        }

        // This test method will Tests to see if a string's letters are all lower case.
        [TestMethod]
        public void IsAllLower_Valid()
        {
            ////Act
            bool result = strTestMethod.IsAllLower();
            ////Assert
            Assert.AreEqual(false, result);
        }

        // This test method will Tests to see if a string contains only letters.
        [TestMethod]
        public void IsAllLetters_Valid()
        {
            ////Act
            bool result = strTestMethod.IsAllLetters();
            ////Assert
            Assert.AreEqual(false, result);
        }

        // This test method will Tests to see if a string contains only letters.
        [TestMethod]
        public void IsAllLetterswithparameter_Valid()
        {
            ////Act
            bool result = strTestMethod.IsAllLetters(boolvalue);
            ////Assert
            Assert.AreEqual(false, result);
        }

        // This test method will Tests to see if a string contains only letters or digits.
        [TestMethod]
        public void IsAllLettersOrDigits_Valid()
        {
            ////Act
            bool result = strTestMethod.IsAllLettersOrDigits();
            ////Assert
            Assert.AreEqual(false, result);
        }

        // This test method will Tests to see if a string contains only letters or digits.
        [TestMethod]
        public void IsAllLettersOrDigitswithparameter_Valid()
        {
            ////Act
            bool result = strTestMethod.IsAllLettersOrDigits(boolvalue);
            ////Assert
            Assert.AreEqual(false, result);
        }

        // This test method will Encodes a string into a base-64 string.
        [TestMethod]
        public void Base64Encode_Valid()
        {
            ////Act
            string result = strTestMethod.Base64Encode();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Decodes a given base-64 encoded string encoded with
        [TestMethod]
        public void Base64Decode_Valid()
        {
            ////Act
            string result = strTestMethod.Base64Decode();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Converts the provided string into title case (upper case first letter of each word).
        [TestMethod]
        public void ToTitleCase_Valid()
        {
            ////Act
            string result = strTestMethod.ToTitleCase();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Truncates the provided string from the left if it is longer that specified length.
        [TestMethod]
        public void TruncateLeft_Valid()
        {
            ////Act
            string result = strTestMethod.TruncateLeft(intValue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Truncates the provided string from the right if it is longer that specified length.
        [TestMethod]
        public void TruncateRight_Valid()
        {
            ////Act
            string result = strTestMethod.TruncateRight(intValue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Centers text within the specified maximum length, biased to the left.
        [TestMethod]
        public void CenterText_Valid()
        {
            ////Act
            string result = strTestMethod.CenterText(intValue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Centers text within the specified maximum length, biased to the left.
        [TestMethod]
        public void CenterTextWithParameter_Valid()
        {
            ////Act
            string result = strTestMethod.CenterText(intValue, c);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Performs a case insensitive string replacement.
        [TestMethod]
        public void ReplaceCaseInsensitive_Valid()
        {
            ////Act
            string result = strTestMethod.ReplaceCaseInsensitive(testvalue, testResult);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Ensures a string starts with a specific string.
        [TestMethod]
        public void EnsureStart_Valid()
        {
            ////Act
            string result = strTestMethod.EnsureStart(c);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Ensures a string starts with a specific string.
        [TestMethod]
        public void EnsureStart1_Valid()
        {
            ////Act
            string result = strTestMethod.EnsureStart(testvalue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        /// This test method will Ensures a string starts with a specific string.
        [TestMethod]
        public void EnsureStart2_Valid()
        {
            ////Act
            string result = strTestMethod.EnsureStart(c, boolvalue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Ensures a string ends with a specific character.
        [TestMethod]
        public void EnsureEnd_Valid()
        {
            ////Act
            string result = strTestMethod.EnsureEnd(c);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Ensures a string ends with a specific character.
        [TestMethod]
        public void EnsureEnd1_Valid()
        {
            ////Act
            string result = strTestMethod.EnsureEnd(testvalue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Ensures a string ends with a specific string with Input parameter.
        [TestMethod]
        public void EnsureEnd2_Valid()
        {
            ////Act
            string result = strTestMethod.EnsureEnd(c, boolvalue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Reverses the order of the characters in a string.
        [TestMethod]
        public void Reverse_Valid()
        {
            ////Act
            string result = strTestMethod.Reverse();
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Searches a string for a repeated instance of the specified.
        [TestMethod]
        public void IndexOfRepeatedChar_Valid()
        {
            ////Act
            int result = strTestMethod.IndexOfRepeatedChar();
            ////Assert
            Assert.AreEqual(intData, result);
        }

        // This test method will Searches a string for a repeated instance of the specified.
        [TestMethod]
        public void IndexOfRepeatedChar2_Valid()
        {
            ////Act
            int result = strTestMethod.IndexOfRepeatedChar(c);
            ////Assert
            Assert.AreEqual(intData, result);
        }

        // This test method will Searches a string for a repeated instance of the specified.
        [TestMethod]
        public void IndexOfRepeatedChar3_Valid()
        {
            ////Act
            int result = strTestMethod.IndexOfRepeatedChar(intValue);
            ////Assert
            Assert.AreEqual(intData, result);
        }

        // This test method will Returns the index of the last repeated index of the first group of repeated characters that begin with the.
        [TestMethod]
        public void IndexOfRepeatedChar4_Valid()
        {
            ////Act
            int result = strTestMethod.IndexOfRepeatedChar(c, intValue);
            ////Assert
            Assert.AreEqual(intData, result);
        }

        // This test method will Places an ellipsis in the middle of a string as it is trimmed to length specified.
        [TestMethod]
        public void TrimWithEllipsisMiddle_Valid()
        {
            ////Act
            string result = strTestMethod.TrimWithEllipsisMiddle(intValue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }

        // This test method will Places an ellipsis at the end of a string as it is trimmed to length specified.
        [TestMethod]
        public void TrimWithEllipsisEnd_Valid()
        {
            ////Act
            string result = strTestMethod.TrimWithEllipsisEnd(intValue);
            ////Assert
            Assert.AreEqual(string.Empty, result);
        }
    }
}