# Forum: RSpec Sufficiently tested?

on 2012-03-09 14:06
```Hi everybody,

I have a general question about how many different cases have to be
covered in one Example.

Considering the famous Fizzbuzz program, you should test if your output
is either "Fizz", "buzz", "Fizzbuzz" or just the number (between 1 and
100). Pretty simple. However, I often see solutions of testing multiples
of 3 only by looking at some relevant values like 6, 9 etc.

it "should return 'fizz' when number is divisible by 3" do
@fizzbuzz.calculate(3).should == 'fizz'
@fizzbuzz.calculate(6).should == 'fizz'
@fizzbuzz.calculate(9).should == 'fizz'
end

So far, so good. But what if I claim that the test will fail in case of
12? It's actually not covered and we are just assuming, that all further
multiples will work as well, because these do. My idea was to check all
multiples right away in a loop.

it "should return Fizz if number is divisible only by 3" do
(1..100).each do |number|
@fizzbuzz.calculate(number).should == "Fizz" if number % 3 == 0 &&
number % 5 != 0
end
end

Given that the calculate method works fine, both ways will pass. But my
question is: Does my solution more than it actually needs to or is the
first one in fact a little too lazy?

Ulfmann```
on 2012-03-27 10:40
```Dear Ulf,

in your fizzbuzz example a kind of simple algorithm is used (% 3 and %
5) which can be easily tested in a loop. If this loop is clearly
predictable, a test with only three levels like 3, 6, 9 is enough in my
opinion.

To extend the test from 1 to 100 in this case is a bit to much. Assuming
there are exceptions in fizzbuzz like 60 should not be "Fizzbuzz" and 89
should not be "Fizz" your loop would fail. My point is not that your
loop fails. My point is You have to create a new algorithm for your
loop, taking care of the exceptions for 60 and 89.

Keeping the thought of a loop including a special algorithm, one might
be tempted to extend the loop from 100 to lets say 1000 or even more.

I think loops an algorithms in tests can be used if they are aware of
expectations and still valid, if they can be extended. Special scenarios
like days in a month have no values > 31, so there is no reason, to
extend a loop for days of a month to more than 31. Days in a month is
commonly known thing. But other types of information can of course be
mor exceptional, like 0 kelvin = -273.15 degrees Celsius and an
algorithm testing a colder temperature would be some how out of scope.

So when an algorithm is with out exceptions valid and easily
predictable, testing of three values should be fine.

Cheers,

Andreas```