## Monday, May 27, 2013

### A Tale of Two FizzBuzzes in Haskell - Part 2

"It is a far, far better thing that I do, than I have ever done; it is a far, far better rest that I go to than I have ever known."
-- Charles Dickens, A Tale of Two Cities

As I've stated before, I like the FizzBuzz kata.  FizzBuzz is one of those rare things that is very easy to understand and yet provides tons of depth once you really think about it.

Welcome to part two, last time we did FizzBuzz using TDD,  this time we'll do it again but will use the Transformation Priority Premise to guide our TDD.

In TPP, Uncle Bob give us the following order for our transformations to our code:

1. ({}–>nil) no code at all->code that employs nil
2. (nil->constant)
3. (constant->constant+) a simple constant to a more complex constant
4. (constant->scalar) replacing a constant with a variable or an argument
5. (statement->statements) adding more unconditional statements.
6. (unconditional->if) splitting the execution path
7. (scalar->array)
8. (array->container)
9. (statement->recursion)
10. (if->while)
11. (expression->function) replacing an expression with a function or algorithm
12. (variable->assignment) replacing the value of a variable.

The idea being that a transformation that is higher should always take place instead of one that is lower.  If this idea is followed our code will be cleaner.

Let's apply the Transformation Priority Premise to FizzBuzz using Haskell and HUnit.

## 3 => "Fizz"

### Failing Test Case

import Test.HUnit

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))

tests = TestList [TestLabel "3 is Fizz" t3]

[1 of 1] Compiling Main             ( fizzBuzz.hs, interpreted )

fizzBuzz.hs:3:48: Not in scope: `fizzBuzzer'

### Pass

#### Using the following rules:

({}–>nil) no code at all->code that employs nil
(nil->constant)

import Test.HUnit

fizzBuzzer::Int->String

fizzBuzzer n = "Fizz"

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))

tests = TestList [TestLabel "3 is Fizz" t3]

*Main> runTestTT tests

Cases: 1  Tried: 0  Errors: 0  Failures: 0
Cases: 1  Tried: 1  Errors: 0  Failures: 0
Counts {cases = 1, tried = 1, errors = 1, failures = 0}

## 5 => "Buzz"

### Failing Test Case

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer n = "Fizz"

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "5 is Buzz" t5]

*Main> runTestTT tests

Cases: 2  Tried: 0  Errors: 0  Failures: 0
Cases: 2  Tried: 1  Errors: 0  Failures: 0

### Failure in: 1:5 is Buzz
5 is Buzz
expected: "Buzz"
but got: "Fizz"
Cases: 2  Tried: 2  Errors: 0  Failures: 1
Counts {cases = 2, tried = 2, errors = 0, failures = 1}

### Pass

#### Using the following rules:

(constant->constant+) a simple constant to a more complex constant

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer 3 = "Fizz"
fizzBuzzer 5 = "Buzz"

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "5 is Buzz" t5]

*Main> runTestTT tests

Cases: 2  Tried: 0  Errors: 0  Failures: 0
Cases: 2  Tried: 1  Errors: 0  Failures: 0
Cases: 2  Tried: 2  Errors: 0  Failures: 0
Counts {cases = 2, tried = 2, errors = 0, failures = 0}

## 25 => "Buzz"

### Failing Test Case

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer 3 = "Fizz"
fizzBuzzer 5 = "Buzz"

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25]

*Main> runTestTT tests

Cases: 3  Tried: 0  Errors: 0  Failures: 0
Cases: 3  Tried: 1  Errors: 0  Failures: 0
Cases: 3  Tried: 2  Errors: 0  Failures: 0

### Error in:   2:25 is Buzz
fizzBuzz.hs:(4,1)-(5,21): Non-exhaustive patterns in function Main.fizzBuzzer

Cases: 3  Tried: 3  Errors: 1  Failures: 0
Counts {cases = 3, tried = 3, errors = 1, failures = 0}

### Pass

#### Using the following rules:

(constant->scalar) replacing a constant with a variable or an argument

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer 3 = "Fizz"
fizzBuzzer n = "Buzz"

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25]

*Main> runTestTT tests

Cases: 3  Tried: 0  Errors: 0  Failures: 0
Cases: 3  Tried: 1  Errors: 0  Failures: 0
Cases: 3  Tried: 2  Errors: 0  Failures: 0

Cases: 3  Tried: 3  Errors: 0  Failures: 0
Counts {cases = 3, tried = 3, errors = 0, failures = 0}

## 9 => "Fizz"

### Failing Test Case

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer 3 = "Fizz"
fizzBuzzer n = "Buzz"

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t9 = TestCase (assertEqual "9 is Fizz" "Fizz" (fizzBuzzer 9))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "9 is Fizz" t9
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25]

*Main> runTestTT tests

Cases: 4  Tried: 0  Errors: 0  Failures: 0
Cases: 4  Tried: 1  Errors: 0  Failures: 0

### Failure in: 1:9 is Fizz
9 is Fizz
expected: "Fizz"
but got: "Buzz"

Cases: 4  Tried: 2  Errors: 0  Failures: 1

Cases: 4  Tried: 3  Errors: 0  Failures: 1

Cases: 4  Tried: 4  Errors: 0  Failures: 1
Counts {cases = 4, tried = 4, errors = 0, failures = 1}

### Pass

#### Using the following rules:

(unconditional->if) splitting the execution path

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer n
| (==) (mod n 5) 0 = "Buzz"
| otherwise = "Fizz"

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t9 = TestCase (assertEqual "9 is Fizz" "Fizz" (fizzBuzzer 9))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "9 is Fizz" t9
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25]

*Main> runTestTT tests

Cases: 4  Tried: 0  Errors: 0  Failures: 0
Cases: 4  Tried: 1  Errors: 0  Failures: 0
Cases: 4  Tried: 2  Errors: 0  Failures: 0
Cases: 4  Tried: 3  Errors: 0  Failures: 0

Cases: 4  Tried: 4  Errors: 0  Failures: 0
Counts {cases = 4, tried = 4, errors = 0, failures = 0}

## 2 => "2"

### Failing Test Case

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer n
| (==) (mod n 5) 0 = "Buzz"
| otherwise = "Fizz"

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t9 = TestCase (assertEqual "9 is Fizz" "Fizz" (fizzBuzzer 9))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

tests = TestList [TestLabel "2 is 2" t2
,TestLabel "3 is Fizz" t3
,TestLabel "9 is Fizz" t9
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25]

*Main> runTestTT tests

Cases: 5  Tried: 0  Errors: 0  Failures: 0

### Failure in: 0:2 is 2
2 is 2
expected: "2"
but got: "Fizz"

Cases: 5  Tried: 1  Errors: 0  Failures: 1

Cases: 5  Tried: 2  Errors: 0  Failures: 1
Cases: 5  Tried: 3  Errors: 0  Failures: 1
Cases: 5  Tried: 4  Errors: 0  Failures: 1

Cases: 5  Tried: 5  Errors: 0  Failures: 1
Counts {cases = 5, tried = 5, errors = 0, failures = 1}

### Pass

#### Using the following rules:

(constant->constant+) a simple constant to a more complex constant
(unconditional->if) splitting the execution path

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer n
| (==) (mod n 5) 0 = "Buzz"
| (==) (mod n 3) 0 = "Fizz"
| otherwise = show n

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t9 = TestCase (assertEqual "9 is Fizz" "Fizz" (fizzBuzzer 9))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

tests = TestList [TestLabel "2 is 2" t2
,TestLabel "3 is Fizz" t3
,TestLabel "9 is Fizz" t9
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25]

*Main> runTestTT tests

Cases: 5  Tried: 0  Errors: 0  Failures: 0
Cases: 5  Tried: 1  Errors: 0  Failures: 0
Cases: 5  Tried: 2  Errors: 0  Failures: 0
Cases: 5  Tried: 3  Errors: 0  Failures: 0
Cases: 5  Tried: 4  Errors: 0  Failures: 0

Cases: 5  Tried: 5  Errors: 0  Failures: 0
Counts {cases = 5, tried = 5, errors = 0, failures = 0}

## Refactor

We now have a repeating pattern, let's refactor it our using the following rule:

(constant->constant+) a simple constant to a more complex constant

import Test.HUnit

xzzer n = (\x -> (==) (mod x n) 0)

fizzBuzzer::Int->String
fizzBuzzer n
| xzzer 3 = "Fizz"
| xzzer 5 = "Buzz"
| otherwise = show n

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t9 = TestCase (assertEqual "9 is Fizz" "Fizz" (fizzBuzzer 9))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

tests = TestList [TestLabel "2 is 2" t2
,TestLabel "3 is Fizz" t3
,TestLabel "9 is Fizz" t9
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25]

*Main> runTestTT tests

Cases: 5  Tried: 0  Errors: 0  Failures: 0
Cases: 5  Tried: 1  Errors: 0  Failures: 0
Cases: 5  Tried: 2  Errors: 0  Failures: 0
Cases: 5  Tried: 3  Errors: 0  Failures: 0
Cases: 5  Tried: 4  Errors: 0  Failures: 0

Cases: 5  Tried: 5  Errors: 0  Failures: 0
Counts {cases = 5, tried = 5, errors = 0, failures = 0}

## 15 => "FizzBuzz"

### Failing Test Case

import Test.HUnit

xzzer n = (\x -> (==) (mod x n) 0)

fizzBuzzer::Int->String
fizzBuzzer n
| xzzer 3 = "Fizz"
| xzzer 5 = "Buzz"
| otherwise = show n

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t9 = TestCase (assertEqual "9 is Fizz" "Fizz" (fizzBuzzer 9))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

t15 = TestCase (assertEqual "15 is FizzBuzz" "FizzBuzz" (fizzBuzzer 15))

tests = TestList [TestLabel "2 is 2" t2
,TestLabel "3 is Fizz" t3
,TestLabel "9 is Fizz" t9
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25
,TestLabel "15 is FizzBuzz" t15]

[1 of 1] Compiling Main             ( fizzBuzz.hs, interpreted )

fizzBuzz.hs:7:5:

Couldn't match expected type `Bool' with actual type `a0 -> Bool'
In the return type of a call of `xzzer'
In the expression: xzzer 3
In a stmt of a pattern guard for
an equation for `fizzBuzzer':
xzzer 3

### Pass

#### Using the following rules:

(constant->constant+) a simple constant to a more complex constant

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer n
| result == "" = show n
| otherwise    = result
where
xzzer n = (\x -> (==) (mod x n) 0)
fizzer x = if xzzer 3 x then "Fizz" else ""
buzzer x = if xzzer 5 x then "Buzz" else ""
result = foldl (\acc x -> acc ++ x n) "" [fizzer, buzzer]

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t9 = TestCase (assertEqual "9 is Fizz" "Fizz" (fizzBuzzer 9))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

t15 = TestCase (assertEqual "15 is FizzBuzz" "FizzBuzz" (fizzBuzzer 15))

tests = TestList [TestLabel "2 is 2" t2
,TestLabel "3 is Fizz" t3
,TestLabel "9 is Fizz" t9
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25
,TestLabel "15 is FizzBuzz" t15]

*Main> runTestTT tests

Cases: 6  Tried: 0  Errors: 0  Failures: 0
Cases: 6  Tried: 1  Errors: 0  Failures: 0
Cases: 6  Tried: 2  Errors: 0  Failures: 0
Cases: 6  Tried: 3  Errors: 0  Failures: 0
Cases: 6  Tried: 4  Errors: 0  Failures: 0
Cases: 6  Tried: 5  Errors: 0  Failures: 0

Cases: 6  Tried: 6  Errors: 0  Failures: 0
Counts {cases = 6, tried = 6, errors = 0, failures = 0}

## More

Let's add in a few more test cases just to show we have all the bases covered.

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer n
| result == "" = show n
| otherwise    = result
where
xzzer n = (\x -> (==) (mod x n) 0)
fizzer x = if xzzer 3 x then "Fizz" else ""
buzzer x = if xzzer 5 x then "Buzz" else ""
result = foldl (\acc x -> acc ++ x n) "" [fizzer, buzzer]

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))
t4 = TestCase (assertEqual "4 is 4" "4" (fizzBuzzer 4))

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t9 = TestCase (assertEqual "9 is Fizz" "Fizz" (fizzBuzzer 9))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

t15 = TestCase (assertEqual "15 is FizzBuzz" "FizzBuzz" (fizzBuzzer 15))
t30 = TestCase (assertEqual "30 is FizzBuzz" "FizzBuzz" (fizzBuzzer 30))

tests = TestList [TestLabel "2 is 2" t2
,TestLabel "4 is 4" t4
,TestLabel "3 is Fizz" t3
,TestLabel "9 is Fizz" t9
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25
,TestLabel "15 is FizzBuzz" t15
,TestLabel "30 is FizzBuzz" t30]

*Main> runTestTT tests

Cases: 8  Tried: 0  Errors: 0  Failures: 0
Cases: 8  Tried: 1  Errors: 0  Failures: 0
Cases: 8  Tried: 2  Errors: 0  Failures: 0
Cases: 8  Tried: 3  Errors: 0  Failures: 0
Cases: 8  Tried: 4  Errors: 0  Failures: 0
Cases: 8  Tried: 5  Errors: 0  Failures: 0
Cases: 8  Tried: 6  Errors: 0  Failures: 0
Cases: 8  Tried: 7  Errors: 0  Failures: 0

Cases: 8  Tried: 8  Errors: 0  Failures: 0
Counts {cases = 8, tried = 8, errors = 0, failures = 0}

## Conclusion

We now have a FizzBuzz that we can show to our mom, assuming that our mom knows how to program and understands Haskell (my mom does not hit into either of those categories).  I am sure someone with more experience in TPP and Haskell could do better, but I believe this is fairly good.

## Sunday, May 12, 2013

### A Tale of Two FizzBuzzes in Haskell - Part 1

"It was the best of times, it was the worst of times, it was the age of wisdom, it was the age of foolishness, it was the epoch of belief, it was the epoch of incredulity, it was the season of Light, it was the season of Darkness, it was the spring of hope, it was the winter of despair, we had everything before us, we had nothing before us, we were all going direct to Heaven, we were all going direct the other way--in short, the period was so far like the present period, that some of its noisiest authorities insisted on its being received, for good or for evil, in the superlative degree of comparison only."
-- Charles Dickens, A Tale of Two Cities

I enjoy the FizzBuzz kata.  I find that it offers endless amounts of flexibility, but yet it is very simple to understand and yet still has some complexity to it.

### TDD

Note when doing TDD, you write the test case first and have it fail before you write the code to pass it, I will not be showing that step.

#### Case 1: x == 3 -> "Fizz"

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer x
| ((==) x 3) = "Fizz"

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))

tests = TestList [TestLabel "3 is Fizz" t3]

*Main> runTestTT tests

Cases: 1  Tried: 0  Errors: 0  Failures: 0

#### Case 2: x % 3 == 0 -> "Fizz"

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer x
| (mod x 3 == 0) = "Fizz"

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t6 = TestCase (assertEqual "6 is Fizz" "Fizz" (fizzBuzzer 6))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "6 is Fizz" t6]

*Main> runTestTT tests

Cases: 2  Tried: 0  Errors: 0  Failures: 0
Cases: 2  Tried: 1  Errors: 0  Failures: 0

#### Case 3: x % 3 != 0 -> "x" when x = 2

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer x
| (mod x 3 == 0) = "Fizz"
| otherwise      = show x

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t6 = TestCase (assertEqual "6 is Fizz" "Fizz" (fizzBuzzer 6))

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "6 is Fizz" t6
,TestLabel "2 is 2" t2]

*Main> runTestTT tests

Cases: 3  Tried: 0  Errors: 0  Failures: 0
Cases: 3  Tried: 1  Errors: 0  Failures: 0
Cases: 3  Tried: 2  Errors: 0  Failures: 0

#### Case 4: x % 3 != 0 -> "x" when x = 4

This is a interesting test case since the code already passes it.

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer x
| (mod x 3 == 0) = "Fizz"
| otherwise      = show x

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t6 = TestCase (assertEqual "6 is Fizz" "Fizz" (fizzBuzzer 6))

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))
t4 = TestCase (assertEqual "4 is 4" "4" (fizzBuzzer 4))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "6 is Fizz" t6
,TestLabel "2 is 2" t2
,TestLabel "4 is 4" t4]

*Main> runTestTT tests

Cases: 4  Tried: 0  Errors: 0  Failures: 0
Cases: 4  Tried: 1  Errors: 0  Failures: 0
Cases: 4  Tried: 2  Errors: 0  Failures: 0
Cases: 4  Tried: 3  Errors: 0  Failures: 0

#### Case 5: x == 5 -> "Buzz"

We can use the mod if we want but we'll have to live with breaking strict TDD.

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer x
| (mod x 3 == 0) = "Fizz"
| (mod x 5 == 0) = "Buzz"
| otherwise      = show x

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t6 = TestCase (assertEqual "6 is Fizz" "Fizz" (fizzBuzzer 6))

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))
t4 = TestCase (assertEqual "4 is 4" "4" (fizzBuzzer 4))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "6 is Fizz" t6
,TestLabel "2 is 2" t2
,TestLabel "4 is 4" t4
,TestLabel "5 is Buzz" t5]

*Main> runTestTT tests

Cases: 5  Tried: 0  Errors: 0  Failures: 0
Cases: 5  Tried: 1  Errors: 0  Failures: 0
Cases: 5  Tried: 2  Errors: 0  Failures: 0
Cases: 5  Tried: 3  Errors: 0  Failures: 0
Cases: 5  Tried: 4  Errors: 0  Failures: 0

#### Case 6: x % 5 == 0 -> "Buzz"

Again we already have the code in place to pass this test case.

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer x
| (mod x 3 == 0) = "Fizz"
| (mod x 5 == 0) = "Buzz"
| otherwise      = show x

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t6 = TestCase (assertEqual "6 is Fizz" "Fizz" (fizzBuzzer 6))

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))
t4 = TestCase (assertEqual "4 is 4" "4" (fizzBuzzer 4))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "6 is Fizz" t6
,TestLabel "2 is 2" t2
,TestLabel "4 is 4" t4
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25]

*Main> runTestTT tests

Cases: 6  Tried: 0  Errors: 0  Failures: 0
Cases: 6  Tried: 1  Errors: 0  Failures: 0
Cases: 6  Tried: 2  Errors: 0  Failures: 0
Cases: 6  Tried: 3  Errors: 0  Failures: 0
Cases: 6  Tried: 4  Errors: 0  Failures: 0
Cases: 6  Tried: 5  Errors: 0  Failures: 0

#### Case 7: x == 15 -> "FizzBuzz"

We'll break strict TDD and use a mod 15.

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer x
| (mod x 15 == 0) = "FizzBuzz"
| (mod x 3 == 0) = "Fizz"
| (mod x 5 == 0) = "Buzz"
| otherwise      = show x

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t6 = TestCase (assertEqual "6 is Fizz" "Fizz" (fizzBuzzer 6))

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))
t4 = TestCase (assertEqual "4 is 4" "4" (fizzBuzzer 4))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

t15 = TestCase (assertEqual "15 is FizzBuzz" "FizzBuzz" (fizzBuzzer 15))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "6 is Fizz" t6
,TestLabel "2 is 2" t2
,TestLabel "4 is 4" t4
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25
,TestLabel "15 is FizzBuzz" t15]

*Main> runTestTT tests

Cases: 7  Tried: 0  Errors: 0  Failures: 0
Cases: 7  Tried: 1  Errors: 0  Failures: 0
Cases: 7  Tried: 2  Errors: 0  Failures: 0
Cases: 7  Tried: 3  Errors: 0  Failures: 0
Cases: 7  Tried: 4  Errors: 0  Failures: 0
Cases: 7  Tried: 5  Errors: 0  Failures: 0
Cases: 7  Tried: 6  Errors: 0  Failures: 0

#### Case 8: x % 15 == 0 -> "FizzBuzz"

Again, this test case already passes.

import Test.HUnit

fizzBuzzer::Int->String
fizzBuzzer x
| (mod x 15 == 0) = "FizzBuzz"
| (mod x 3 == 0) = "Fizz"
| (mod x 5 == 0) = "Buzz"
| otherwise      = show x

t3 = TestCase (assertEqual "3 is Fizz" "Fizz" (fizzBuzzer 3))
t6 = TestCase (assertEqual "6 is Fizz" "Fizz" (fizzBuzzer 6))

t2 = TestCase (assertEqual "2 is 2" "2" (fizzBuzzer 2))
t4 = TestCase (assertEqual "4 is 4" "4" (fizzBuzzer 4))

t5 = TestCase (assertEqual "5 is Buzz" "Buzz" (fizzBuzzer 5))
t25 = TestCase (assertEqual "25 is Buzz" "Buzz" (fizzBuzzer 25))

t15 = TestCase (assertEqual "15 is FizzBuzz" "FizzBuzz" (fizzBuzzer 15))
t30 = TestCase (assertEqual "30 is FizzBuzz" "FizzBuzz" (fizzBuzzer 30))

tests = TestList [TestLabel "3 is Fizz" t3
,TestLabel "6 is Fizz" t6
,TestLabel "2 is 2" t2
,TestLabel "4 is 4" t4
,TestLabel "5 is Buzz" t5
,TestLabel "25 is Buzz" t25
,TestLabel "15 is FizzBuzz" t15
,TestLabel "30 is FizzBuzz" t30]

*Main> runTestTT tests

Cases: 8  Tried: 0  Errors: 0  Failures: 0
Cases: 8  Tried: 1  Errors: 0  Failures: 0
Cases: 8  Tried: 2  Errors: 0  Failures: 0
Cases: 8  Tried: 3  Errors: 0  Failures: 0
Cases: 8  Tried: 4  Errors: 0  Failures: 0
Cases: 8  Tried: 5  Errors: 0  Failures: 0
Cases: 8  Tried: 6  Errors: 0  Failures: 0
Cases: 8  Tried: 7  Errors: 0  Failures: 0

Now we have everything in place to prove that the FizzBuzz works.

Next time we'll do the same kata but using the Transformation Priority Premise (TPP).