Test Driven Development- practicising with The word wrap Kata
In these days Test driven development is growing and TDD Katas is a best way to learn this approach. In this code-snippet, we will see a famous kata called word wrap kata.
Firstly, we will check the problem
Secondly, we will divide the problem in step(s)
Finally, we will write code
We need a function or a tiny program, which breaks words on specified space with new line. Its nothing but merely similar to word-processor. Following is the complete code snippet, which solve the above problem: Note that in above snippet I have used NUnit Framework for testing.Introduction
In this code snippet we are going to write a famous kata i.e. word wrap kataProblem
Solution
We divided the problem in following step(s):
1. Create a public class named WordWrap
2. Create a method 'wrap' it can be a static method
3. Create a function which count the number of spliter words of non-space
4. check for if words already having newline ['\n'] characters - ignore in counts
5. Check for multiple lines
6. Remove blank spaces if any in new line eg. Actual - "this is a test" WrappedText = "this\n is a t\nest"WordWrap.cs
using System;
using System.Globalization;
namespace TDD_Katas_project.The_WordWrap_Kata
{
public class WordWrap
{
#region Public Methods
public static string Wrap(string word, int wordLength)
{
var actualCount = 0;
var wrappedword = string.Empty;
if (IsContainNewLine(word)) return word;
if (IsContainNullEmptyOrWhiteSpaces(word)) return string.Empty;
foreach (var wrd in word)
{
wrappedword = wrappedword + Convert.ToString(wrd);
if (IsWhiteSpaceOrNewLine(wrd)) continue;
if (IsContainNewLine(wrd.ToString(CultureInfo.InvariantCulture))) continue;
actualCount++;
if (actualCount == wordLength)
wrappedword += "\n";
}
wrappedword = GetWrappedwordWithoutBlankSpacesAtStartOfNewLine(wrappedword);
return wrappedword;
}
#endregion
#region MyRegion
private static string GetWrappedwordWithoutBlankSpacesAtStartOfNewLine(string wrappedword)
{
var newWrappedWord = wrappedword;
var spaceCounter = 0;
for (var outCounter = 0; outCounter < wrappedword.Length; outCounter++)
{
if (IsContainNewLine(wrappedword[outCounter].ToString(CultureInfo.InvariantCulture)))
for (var inCounter = outCounter + 1; inCounter < wrappedword.Length; inCounter++)
{
if (char.IsWhiteSpace(wrappedword[inCounter]))
spaceCounter++;
else
break;
}
if (spaceCounter <= 0) continue;
newWrappedWord = RemoveWhiteSpacesFromWrappedWord(wrappedword, outCounter, spaceCounter); //RemoveWhiteSpacesFromWrappedWord(wrappedword, outCounter + 1, spaceCounter);
spaceCounter = 0;
}
return newWrappedWord;
}
private static string RemoveWhiteSpacesFromWrappedWord(string wrappedword, int outCounter, int spaceCounter)
{
return wrappedword.Remove(outCounter + 1, spaceCounter);
}
private static bool IsContainNewLine(string word)
{
return word == "\n";
}
private static bool IsContainNullEmptyOrWhiteSpaces(string word)
{
return (string.IsNullOrEmpty(word)) || (string.IsNullOrWhiteSpace(word));
}
private static bool IsWhiteSpaceOrNewLine(char wrd)
{
return char.IsWhiteSpace(wrd) && (wrd == '\n');
}
#endregion
}
}WordWrapTest.cs
using NUnit.Framework;
namespace TDD_Katas_project.The_WordWrap_Kata
{
[TestFixture]
[Category("The Word Wrap Kata")]
public class WordWrapTest
{
[Test]
public void CanWrapSingleLine()
{
Assert.That("Let's\nGo", Is.EqualTo(WordWrap.Wrap("Let's Go", 5)));
}
[Test]
public void CanTestForNullWord()
{
Assert.That("", Is.EqualTo(WordWrap.Wrap(null, 5)));
}
[Test]
public void CanTestForNullOrWhiteSpacesWord()
{
Assert.That("", Is.EqualTo(WordWrap.Wrap(null, 5)));
Assert.That("", Is.EqualTo(WordWrap.Wrap(" ", 5)));
}
[Test]
public void CanTestNewLineCharacter()
{
Assert.That("\n", Is.EqualTo(WordWrap.Wrap("\n", 1)));
Assert.That("\nLet's\nGo\noutside.", Is.EqualTo(WordWrap.Wrap("\nLet's Go\noutside.", 5)));
}
[Test]
public void CanWrapMultipleLine()
{
const string inputword = "Today is friday. \nLets go outside.\n Happy weekedn!";
const string expectedword = "Today\n is friday. \nLets go outside.\nHappy weekedn!";
var actualresult = (WordWrap.Wrap(inputword, 5));
Assert.That(expectedword, Is.EqualTo(actualresult),
string.Format("result of entered word [{0}] is [{1}] but it should be [{2}]", inputword,
actualresult, expectedword));
}
}
}