Teaching a String Calculator How to Behave

I prefer to design my code by specifying expected behavior before any code is written. Machine.Specifications (mspec) provides a great way to accomplish this with less overall code and the bonus of normal-person-readable specifications. BDD keeps me focused on what the code is actually supposed to do, not on the classes and methods themselves. To exercise my BDD muscles, I decided to work through the popular “String Calculator Kata” by Roy Osherove. His instructions were from the traditional TDD approach, though, so I took a stab at converting them to a simple user story with acceptance criteria. Here’s what I came up with:

“As a user, I want to add numbers together so that I can know the sum.”

WHEN provided an empty string,
THEN it should return 0

WHEN provided one number,
THEN it should return the same number

WHEN provided two numbers separated by a comma,
THEN it should return the sum of those two numbers

WHEN provided an unknown amount of numbers separated by commas,
THEN it should return the sum of all numbers provided

WHEN provided numbers with a new line character,
THEN it should return the sum of all numbers provided

WHEN provided numbers separated by a specified delimiter,
THEN it should return the sum of all numbers provided

WHEN provided one negative number,
THEN it should throw an exception (“Negative numbers are not allowed – [Display the negative number.”)

WHEN provided more than one negative number,
THEN it should throw an exception (“Negative numbers are not allowed – [Display the negative numbers.”)

So, let's dive in and see where the story leads us! My job from here on out is to create a spec based on a single acceptance criterion, run the spec so that it fails, write JUST ENOUGH code in my new string calculator class to make the spec pass, and then move on to the next acceptance criterion.

Acceptance Criterion:

WHEN provided an empty string,
THEN it should return 0

Specification with mspec:

public class when_provided_an_empty_string { Establish a_string_calculator_context = () => _stringCalculator = new StringCalculator(); Because of = () => _result = _stringCalculator.Add(string.Empty); It should_return_zero = () => _result.ShouldEqual(0); static StringCalculator _stringCalculator; static int _result; }

Resulting code:

Acceptance Criterion:

WHEN provided one number,
THEN it should return the same number

Specification with mspec:

public class when_provided_one_number { Establish a_string_calculator_context = () => _stringCalculator = new StringCalculator(); Because of = () => _result = _stringCalculator.Add("5"); It should_return_the_same_number = () => _result.ShouldEqual(5); static StringCalculator _stringCalculator; static int _result; }

Now, I’m starting to see some repetition in my context. Before moving forward, I’m going to refactor my specs a bit to use a common context. For this, I will use an abstract class that starts with the word “given”.

public abstract class given_a_string_calculator { Establish a_string_calculator_context = () => _stringCalculator = new StringCalculator(); protected static StringCalculator _stringCalculator; }

So, first spec looks like this:

public class when_provided_an_empty_string : given_a_string_calculator { Because of = () => _result = _stringCalculator.Add(string.Empty); It should_return_zero = () => _result.ShouldEqual(0); static int _result; }

…and my second spec looks like this:

public class when_provided_one_number : given_a_string_calculator { Because of = () => _result = _stringCalculator.Add("5"); It should_return_the_same_number = () => _result.ShouldEqual(5); static int _result; }

Resulting code:

public class StringCalculator { public int Add(string stringToCalculate) { return string.IsNullOrWhiteSpace(stringToCalculate) ? 0 : int.Parse(stringToCalculate); } }

Acceptance Criterion:

WHEN provided two numbers separated by a comma,
THEN it should return the sum of those two numbers

Specification with mspec:

public class when_provided_two_number_separated_by_a_comma : given_a_string_calculator { Because of = () => _result = _stringCalculator.Add("2,5"); It should_return_the_sum_of_those_two_numbers = () => _result.ShouldEqual(7); static int _result; }

Resulting code:

public class StringCalculator { public int Add(string stringToCalculate) { return string.IsNullOrWhiteSpace(stringToCalculate) ? 0 : stringToCalculate.Split(new char[] { ',' }) .Sum(x=> int.Parse(x)); } }

Acceptance Criterion:

WHEN provided an unknown amount of numbers separated by commas,
THEN it should return the sum of all numbers provided

Specification with mspec:

public class when_provided_multiple_numbers_separated_by_commas : given_a_string_calculator { Because of = () => _result = _stringCalculator.Add("3,4,5"); It should_return_the_sum_of_all_numbers_provided = () => _result.ShouldEqual(12); static int _result; }

UH OH! This spec passed without any modification to the calculator. I don’t like when this happens, but I don’t think I could have made the Add method much simpler when adding two numbers separated by a comma. Now, because of my use of Linq’s Sum extension method, it passes with any amount of numbers. Moving on…

Acceptance Criterion:

WHEN provided numbers with a new line character,
THEN it should return the sum of all numbers provided

Specification with mspec:

public class when_provided_numbers_with_a_new_line_character : given_a_string_calculator { Because of = () => _result = _stringCalculator.Add("3,4n6"); It should_return_the_sum_of_all_numbers_provided = () => _result.ShouldEqual(13); static int _result; }

Resulting code:

Acceptance Criterion:

WHEN provided numbers separated by a specified delimiter,
THEN it should return the sum of all numbers provided

Specification with mspec:

public class when_provided_numbers_separated_by_a_specified_delimeter : given_a_string_calculator { Because of = () => _result = _stringCalculator.Add("//;n3;4;7"); It should_return_the_sum_of_all_numbers_provided = () => _result.ShouldEqual(14); static int _result; }

Resulting code:

public class StringCalculator { public int Add(string stringToCalculate) { var delimiters = ",n"; if (stringToCalculate.StartsWith("//")) { delimiters += stringToCalculate[2]; stringToCalculate = stringToCalculate .Substring(4, stringToCalculate.Length - 4); } return string.IsNullOrWhiteSpace(stringToCalculate) ? 0 : stringToCalculate .Split(delimiters.ToCharArray()) .Sum(x=> int.Parse(x)); } }

Acceptance Criterion:

WHEN provided one negative number,
THEN it should throw an exception (“Negative numbers are not allowed – [Display the negative number.”)

Specification with mspec:

public class when_provided_one_negative_number : given_a_string_calculator { Because of = () => _exception = Catch.Exception(()=> _stringCalculator.Add("-1,2")); It should_throw_an_exception = () => _exception.Message .ShouldEqual("Negative numbers are not allowed: -1"); static Exception _exception; }

Resulting code:

public class StringCalculator { public int Add(string stringToCalculate) { var delimiters = ",n"; if (stringToCalculate.StartsWith("//")) { delimiters += stringToCalculate[2]; stringToCalculate = stringToCalculate .Substring(4, stringToCalculate.Length - 4); } if(stringToCalculate.Contains("-")) { throw new Exception("Negative numbers are not allowed: -1"); } return string.IsNullOrWhiteSpace(stringToCalculate) ? 0 : stringToCalculate .Split(delimiters.ToCharArray()) .Sum(x=> int.Parse(x)); } }

Acceptance Criterion:

WHEN provided more than one negative number,
THEN it should throw an exception (“Negative numbers are not allowed – [Display the negative numbers.”)

Specification with mspec:

public class when_provided_more_than_one_negative_number : given_a_string_calculator { Because of = () => _exception = Catch.Exception(() => _stringCalculator.Add("-1,-2")); It should_throw_an_exception = () => _exception.Message.ShouldEqual( "Negative numbers are not allowed: -1,-2"); static Exception _exception; }

Resulting code:

public class StringCalculator { public int Add(string stringToCalculate) { var delimiters = ",n"; if (stringToCalculate.StartsWith("//")) { delimiters += stringToCalculate[2]; stringToCalculate = stringToCalculate .Substring(4, stringToCalculate.Length - 4); } if(stringToCalculate.Contains("-")) { throw new Exception( string.Format("Negative numbers are not allowed: {0}", string.Join(",", stringToCalculate.Split( delimiters.ToCharArray()).Where(x=> int.Parse(x) < 1 )))); } return string.IsNullOrWhiteSpace(stringToCalculate) ? 0 : stringToCalculate .Split(delimiters.ToCharArray()) .Sum(x=> int.Parse(x)); } }

Here are the results from all eight specs:

[code]
when provided more than one negative number
» should throw an exception
when provided one negative number
» should throw an exception
when provided numbers separated by a specified delimiter
» should return the sum of all numbers provided
when provided numbers with a new line character
» should return the sum of all numbers provided
when provided multiple numbers separated by commas
» should return the sum of all numbers provided
when provided two number separated by a comma
» should return the sum of those two numbers
when provided one number
» should return the same number
when provided an empty string
» should return zero

8 passed, 0 failed, 0 skipped, took 1.05 seconds (Machine.Specifications 0.3.0).
[/code]

In a simple kata like this, the end-result is pretty similar to what might come out of a traditional TDD process. Imagine doing a much more complicated code project, and you’ll probably begin to see how powerful and valuable Behavior-Driven Development can be.

Download Source Code

http://aspiringcraftsman.com Derek Greer

Great post Byron! For what it’s worth, the issue with your passing sum of multiple numbers spec is really with the acceptance criteria. Returning the sum of two numbers separated by commas is just an instance of the ability to return the sum of an unlimited string of numbers separated by commas, so that’s all that needed to be specified.
- Byron Sommardahl
  
  Thanks Derek! I believe you’re right. It looks like the 3rd and 4th AC’s can be condensed into something like, “WHEN provided two or more numbers separated by commas, THEN it should return the sum of those numbers.” Good catch!
DavidS

This is an excellent up to date post on how to actually get started with writing MSpec code! Thanks a lot for taking the time to share the article and the code.
- Anonymous
  
  Thanks David! Are you planning on or already using MSpec?

Awkward Coder

Learning to behave in public.

Teaching a String Calculator How to Behave

“As a user, I want to add numbers together so that I can know the sum.”

Acceptance Criterion:

Specification with mspec:

Resulting code:

Acceptance Criterion:

Specification with mspec:

Resulting code:

Acceptance Criterion:

Specification with mspec:

Resulting code:

Acceptance Criterion:

Specification with mspec:

Acceptance Criterion:

Specification with mspec:

Resulting code:

Acceptance Criterion:

Specification with mspec:

Resulting code:

Acceptance Criterion:

Specification with mspec:

Resulting code:

Acceptance Criterion:

Specification with mspec:

Resulting code: