Biblioteka OWL cześć 1

3 minutesPierwszym krokiem po utworzeniu solucji jest utworzenie biblioteki. TDD () wymusza na nas napisanie pustej klasy i zaimplementowanie w niej metod niezbędnych do wykonania testów jednostkowych. Na początku utwórzmy klasę StringUtility, ponieważ jest to klasa statyczna nie tworzymy interfejsu do niej. Nasza klasa:
 
static class StringUtility {}
Mając już utworzoną klasę możemy utworzyć nasz pierwszy test. W projekcie TooExe.Owl.Library.UnitTests tworzymy klasę TestStringUtility, a w niej metodę ToWordList_DirtyString_ExpectedWord. Nasza metoda ToWordList() jest bardzo złożona więc nie możemy jej od razu zaimplementować. Przyjrzyjmy się jakie wymagania musi ona spełniać:
  1. Eliminacja słów zawierających:
    1. Niepożądane znaki;
       bool IsContainUnneceseryCharacter(this string text, string charsCharacter = @"~`1234567890@#$%^&amp;*()_=+{[}]\|<>/")
    2. Dwie lub więcej duże litery;
      bool HaveTwoOrMoreUpperCaseLetter()
  2. Usuwanie ostatnich znaków takich jak: „.,;:’?!
    string RemoveLastCharByLists(this string text, string unnecessaryCharacters = "\".,;:'?!")
  3. Wszystkie słowa muszą być przechowywane w formie bezokolicznika. Ten warunek wymaga od nas dodatkowych zabezpieczeń:
    1. Liczba mnoga (regularna);
      string ReplaceRegularPluralWords(this string text)
    2. Liczba mnoga (nie regularna);
       string ReplaceIrregularPluralWords(this string text)
    3. Czasowniki w formie regularnej;
       static string ReplcaceRegularVerbForm(this string text)
    4. Czasowniki w formie nieregularnej;
       static string ReplcaceIrregularVerbForm(this string text)
    5. Trzecia osoba liczby pojedynczej jest częściowo zaimplementowana w liczbie mnogiej regularnej rzeczowników.
  4. Wszystkie duże litery będą ignorowane.
Nasza klasa:
static class StringUtility
    {

        static StringUtility()
        {

        }

        public static IEnumerable<string> ToWordList(this string text)
        {
            return null;
        }
        public static string ReplaceWordToInfinitive(this string text)
        {
            throw new NotImplementedException();
        }
        public static bool IsBadWord(this string text)
        {
            throw new NotImplementedException();
        }
        public static string RemoveLastCharByLists(this string text, string unnecessaryCharacters = "\".,;:'?!")
        {
            throw new NotImplementedException();
        }
        public static string ReplcaceRegularVerbForm(this string text)
        {
            throw new NotImplementedException();
        }
        public static string ReplacePluralWords(this string text)
        {
            throw new NotImplementedException();
        }
        public static string ReplcaceIrregularVerbForm(this string text)
        {
            throw new NotImplementedException();
        }
        public static bool IsContainUnneceseryCharacter(this string text, string charsCharacter = @"~`1234567890@#$%^&amp;*()_=+{[}]\|<>")
        {
            throw new NotImplementedException();
        }
        public static bool HaveTwoOrMoreUpperCaseLetter(this string text)
        {
            throw new NotImplementedException();
        }
    }
Jest to bardzo prosty algorytm, ale w zupełności wystarczy do naszego zastosowania. Nieregularne formy dla czasowników, liczby mnogiej rzeczowników jak i trzeciej formy osobowej będą pobierane z piku. (jest to tymczasowe rozwiązanie, w późniejszym okresie będzie to baza danych lub web API połączone do słownika). Pierwszy test:
 [Theory]
 [InlineData(@"12312312312")]
 [InlineData(@"mark@gmail.com")]
 [InlineData(@"Ma#$t")]
 public void IsContainUnneceseryCharacter_InsertUnneceseryCharacter_True(string input)
 {
 // Arrange all necessary preconditions and inputs.
 var expected = true;

 // Act on the object or method under test.
 var actual = input.IsContainUnneceseryCharacter();

 // Assert that the expected results have occurred.
 // ReSharper disable once ConditionIsAlwaysTrueOrFalse
 Assert.Equal(expected, actual);
 }
Uruchamiamy go i widzimy, że się nie powiódł. (Tego się spodziewaliśmy.) Napiszmy kod w metodzie:
 public static bool IsContainUnneceseryCharacter(this string text, string charsCharacter = @"~`1234567890@#$%^&amp;*()_=+{[}]\|<>/")
 {
 var result = text.IndexOfAny(charsCharacter.ToCharArray()) != -1;
 return result;
 }
Uruchamiamy test. Test się powiódł. Pokrycie kodu jest na poziomie 100%. Jesteśmy pewni, że nasza metoda jest przetestowana poprawnie. Następna metodą do utworzenia testu jest HaveTwoOrMoreUpperCaseLetter(). Nasz test:
 [Theory]
 [InlineData(@"Abcdef123")]
 [InlineData(@"Abcdef123jk")]
 [InlineData(@"Abcdef123j")]
 [InlineData(@"Abcdef123dfgdfg")]
 [InlineData(@"abcd123!@#234sdfgdgerge2342!$@%#^^#")]
 [InlineData(@"abcd")]
 [InlineData(@"ab")]
 [InlineData(@"a")]
 public void HaveTwoOrMoreCapitalLetter_StringDontContainTwoOrMoreUpperCaseLetter_True(string input)
 {
 // Arrange all necessary preconditions and inputs.
 var expected = false;

 // Act on the object or method under test.
 var actual = input.HaveTwoOrMoreCapitalLetter();

 // Assert that the expected results have occurred.
 // ReSharper disable once ConditionIsAlwaysTrueOrFalse
 Assert.Equal(expected, actual);
 }

 [Theory]
 [InlineData(@"AB")]
 [InlineData(@"ABC")]
 [InlineData(@"AbcDef123")]
 [InlineData(@"Abcdef123G")]
 [InlineData(@"AAbcdef123G")]
 [InlineData(@"AAbcdef123GF")]
 [InlineData(@"abcd123!@#KLsdfgdgerge2342!$@%#^^#")]
 public void HaveTwoOrMoreCapitalLetter_StringContainTwoOrMoreUpperCaseLetter_True(string input)
 {
 // Arrange all necessary preconditions and inputs.
 var expected = true;

 // Act on the object or method under test.
 var actual = input.HaveTwoOrMoreCapitalLetter();

 // Assert that the expected results have occurred.
 // ReSharper disable once ConditionIsAlwaysTrueOrFalse
 Assert.Equal(expected, actual);
 }
Utworzyliśmy dwa typy testów. Pierwszy musi zwrócić true (pobrane dane zawierają oczekiwane znaki w naszym przypadku są to dwie lub więcej duże litery), drugi test zwróci false (pobrane dane nie będą zawierać oczekiwanych znaków w naszym przypadku dwóch lub więcej dużych liter). Uruchamiamy go i widzimy, że się nie powiódł. (Tego się spodziewaliśmy.) Napiszmy kod w metodzie:
 public static bool HaveTwoOrMoreCapitalLetter(this string text)
 {
 int numberCapitalLetter = 0;

 foreach (var item in text.ToCharArray())
 {
 if ((item >= 65) &amp;&amp; (item <= 90)) { numberCapitalLetter++; } if (numberCapitalLetter > 1)
 {
 return true;
 }
 }

 return false;
 }
Uruchamiamy test. Test się powiódł. Pokrycie kodu jest na poziomie 100%.