public void ReturnsBuzz_WhenDivisible_By_FiveOnly()
{
// given the way the solution is, let us only execute up until the point of where we expect the end result to be
// grab the last result and compare with the actual execution for each of the points for FizzBuzz.
FizzBuzzRequest fiveUpperBound = new FizzBuzzRequest {
UpperBound = 5, UseDefaultRules = true
};
FizzBuzzRequest tenUpperBound = new FizzBuzzRequest {
UpperBound = 10, UseDefaultRules = true
};
FizzBuzzRequest twentyFiveUpperBound = new FizzBuzzRequest {
UpperBound = 20, UseDefaultRules = true
};
var runner = new FizzBuzzRunner();
var expectedFizz = "Buzz";
var actualRunnerFiveResult = runner.FizzBuzzRun(fiveUpperBound).ToList();
var actualFizzBuzzResult = actualRunnerFiveResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizz, actualFizzBuzzResult.Result);
var actualRunnerTenResult = runner.FizzBuzzRun(tenUpperBound).ToList();
var actualFizzBuzzTenResult = actualRunnerTenResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizz, actualFizzBuzzTenResult.Result);
var actualRunnerTwentyResult = runner.FizzBuzzRun(twentyFiveUpperBound).ToList();
var actualFizzNineTwentyResult = actualRunnerTwentyResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizz, actualFizzNineTwentyResult.Result);
}
public void DoesNotReturnFizzBuzz_WhenDivisible_By_ThreeOnly()
{
// given the way the solution is, let us only execute up until the point of where we expect the end result to be
// grab the last result and compare with the actual execution for each of the points for FizzBuzz.
FizzBuzzRequest fifteenUpperBound = new FizzBuzzRequest {
UpperBound = 6, UseDefaultRules = true
};
FizzBuzzRequest thirtyUpperBound = new FizzBuzzRequest {
UpperBound = 2, UseDefaultRules = true
};
FizzBuzzRequest fortyFiveUpperBound = new FizzBuzzRequest {
UpperBound = 7, UseDefaultRules = true
};
var runner = new FizzBuzzRunner();
var expectedFizzBuzz = "FizzBuzz";
var actualRunnerFifteenResult = runner.FizzBuzzRun(fifteenUpperBound).ToList();
var actualFizzBuzzResult = actualRunnerFifteenResult.Last();
StringAssert.AreNotEqualIgnoringCase(expectedFizzBuzz, actualFizzBuzzResult.Result);
var actualRunnerThirtyResult = runner.FizzBuzzRun(thirtyUpperBound).ToList();
var actualFizzBuzzThirtyResult = actualRunnerThirtyResult.Last();
StringAssert.AreNotEqualIgnoringCase(expectedFizzBuzz, actualFizzBuzzThirtyResult.Result);
var actualRunnerFortyFiveResult = runner.FizzBuzzRun(fortyFiveUpperBound).ToList();
var actualFizzBuzzFortyFiveResult = actualRunnerFortyFiveResult.Last();
StringAssert.AreNotEqualIgnoringCase(expectedFizzBuzz, actualFizzBuzzFortyFiveResult.Result);
}
public void Returns_Fizz_Buzz_FizzBuzz_And_NoHit()
{
// given the way the solution is, let us only execute up until the point of where we expect the end result to be
// grab the last result and compare with the actual execution for each of the points for FizzBuzz.
FizzBuzzRequest twentyUpperBound = new FizzBuzzRequest {
UpperBound = 20, BuzzRule = new Rule {
DivisibleByWord = "Buzz", DivisibleBy = 5
}, NoMatch = new Rule {
DivisibleByWord = "Nothing"
}, FizzRule = new Rule {
DivisibleBy = 3, DivisibleByWord = "Fizz"
}
};
var runner = new FizzBuzzRunner();
var expectedNoMatchReplacement = "Nothing";
var fizz = "Fizz";
var buzz = "Buzz";
var actualRunnerResult = runner.FizzBuzzRun(twentyUpperBound).ToList();
var buzzResult = actualRunnerResult.Last();
var noMatchResult = actualRunnerResult.Skip(18).Take(1).First();
var fizzResult = actualRunnerResult.Skip(17).Take(1).First();
var fizzBuzzResult = actualRunnerResult.Skip(14).Take(1).First();
StringAssert.AreEqualIgnoringCase(expectedNoMatchReplacement, noMatchResult.Result);
StringAssert.AreEqualIgnoringCase(fizz, fizzResult.Result);
StringAssert.AreEqualIgnoringCase(buzz, buzzResult.Result);
StringAssert.AreEqualIgnoringCase($"{fizz}{buzz}", fizzBuzzResult.Result);
}
public void WillRunSuccessfully_DoesNotThrowException_ForLargeIterations()
{
// given the way the solution is, let us only execute up until the point of where we expect the end result to be
// grab the last result and compare with the actual execution for each of the points for FizzBuzz.
FizzBuzzRequest largeUpperBoundRequest = new FizzBuzzRequest {
UpperBound = Int32.MaxValue, BuzzRule = new Rule {
DivisibleByWord = "World", DivisibleBy = 5
}, NoMatch = new Rule {
DivisibleByWord = "Nothing"
}, FizzRule = new Rule {
DivisibleBy = 3, DivisibleByWord = "My"
}
};
var runner = new FizzBuzzRunner();
Assert.DoesNotThrow(() =>
{
foreach (var currentItem in runner.FizzBuzzRun(largeUpperBoundRequest))
{
// do nothing
}
});
}
public void NullRequestObject_ThrowsArgumentNullExceptionWhenExecuting()
{
FizzBuzzRequest req = null;
var runner = new FizzBuzzRunner();
Assert.Throws <ArgumentNullException>(() => runner.FizzBuzzRun(req).ToList());
}
public void ReturnsFizz_WhenDivisible_By_ThreeOnly()
{
// given the way the solution is, let us only execute up until the point of where we expect the end result to be
// grab the last result and compare with the actual execution for each of the points for FizzBuzz.
FizzBuzzRequest threeUpperBound = new FizzBuzzRequest {
UpperBound = 3, UseDefaultRules = true
};
FizzBuzzRequest sixUpperBound = new FizzBuzzRequest {
UpperBound = 6, UseDefaultRules = true
};
FizzBuzzRequest nineFiveUpperBound = new FizzBuzzRequest {
UpperBound = 9, UseDefaultRules = true
};
var runner = new FizzBuzzRunner();
var expectedFizz = "Fizz";
var actualRunnerThreeResult = runner.FizzBuzzRun(threeUpperBound).ToList();
var actualFizzBuzzResult = actualRunnerThreeResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizz, actualFizzBuzzResult.Result);
var actualRunnerSixResult = runner.FizzBuzzRun(sixUpperBound).ToList();
var actualFizzBuzzSixResult = actualRunnerSixResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizz, actualFizzBuzzSixResult.Result);
var actualRunnerNineResult = runner.FizzBuzzRun(nineFiveUpperBound).ToList();
var actualFizzNineFiveResult = actualRunnerNineResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizz, actualFizzNineFiveResult.Result);
}
public void AnyNullRules_ThrowsArgumentNullExceptionWhenExecuting()
{
FizzBuzzRequest req = new FizzBuzzRequest {
UpperBound = 100, BuzzRule = new BuzzRuleDefault(), FizzRule = null, NoMatch = null
};
var runner = new FizzBuzzRunner();
Assert.Throws <ArgumentNullException>(() => runner.FizzBuzzRun(req).ToList());
}
public void LessThanOneUpperBound_ThrowsArgumentOutOfRangeExceptionWhenExecuting()
{
FizzBuzzRequest req = new FizzBuzzRequest {
UpperBound = -2, BuzzRule = new BuzzRuleDefault(), FizzRule = new FizzRuleDefault(), NoMatch = new NoMatchRuleDefault()
};
var runner = new FizzBuzzRunner();
Assert.Throws <ArgumentOutOfRangeException>(() => runner.FizzBuzzRun(req).ToList());
}
public void ReturnsCustomWordForFizzBuzz_WhenDivisible_By_ThreeAndFive()
{
// given the way the solution is, let us only execute up until the point of where we expect the end result to be
// grab the last result and compare with the actual execution for each of the points for FizzBuzz.
FizzBuzzRequest fifteenUpperBound = new FizzBuzzRequest {
UpperBound = 15, BuzzRule = new Rule {
DivisibleByWord = "World", DivisibleBy = 5
}, NoMatch = new Rule {
DivisibleByWord = "Nothing"
}, FizzRule = new Rule {
DivisibleBy = 3, DivisibleByWord = "My"
}
};
FizzBuzzRequest thirtyUpperBound = new FizzBuzzRequest {
UpperBound = 30, BuzzRule = new Rule {
DivisibleByWord = "World", DivisibleBy = 5
}, NoMatch = new Rule {
DivisibleByWord = "Nothing"
}, FizzRule = new Rule {
DivisibleBy = 3, DivisibleByWord = "My"
}
};
FizzBuzzRequest fortyFiveUpperBound = new FizzBuzzRequest {
UpperBound = 45, BuzzRule = new Rule {
DivisibleByWord = "World", DivisibleBy = 5
}, NoMatch = new Rule {
DivisibleByWord = "Nothing"
}, FizzRule = new Rule {
DivisibleBy = 3, DivisibleByWord = "My"
}
};
var runner = new FizzBuzzRunner();
var expectedFizzBuzzReplacement = "MyWorld";
var actualRunnerFifteenResult = runner.FizzBuzzRun(fifteenUpperBound).ToList();
var actualFizzBuzzFifteenResult = actualRunnerFifteenResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizzBuzzReplacement, actualFizzBuzzFifteenResult.Result);
var actualRunnerThirtyResult = runner.FizzBuzzRun(thirtyUpperBound).ToList();
var actualFizzBuzzThirtyResult = actualRunnerThirtyResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizzBuzzReplacement, actualFizzBuzzThirtyResult.Result);
var actualRunnerFortyFiveResult = runner.FizzBuzzRun(fortyFiveUpperBound).ToList();
var actualFizzFortyFiveResult = actualRunnerFortyFiveResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizzBuzzReplacement, actualFizzFortyFiveResult.Result);
}
public FizzBuzzResponse GetFizzBuzzList(FizzBuzzRequest input)
{
var fizzBuzzList = new List <FizzBuzz>();
for (var number = 1; number <= input.UserInput; number++)
{
fizzBuzzList.Add(GetFizzBuzz(number));
}
return(new FizzBuzzResponse()
{
FizzBuzzList = fizzBuzzList
});
}
public void WhenUserInputIsPositiveIntegerFromOneToThousandAndWhenCurrentDayIsNotWednesDayFizzBuzzListShouldBeReturned()
{
//Arrange
var descriptionList = new List <string> {
"Fizz", "Buzz", "Fizz Buzz"
};
fizzBuzzDescriptionProvider.Stub(x => x.GetDescriptions(DayOfWeek.Monday, DayOfWeek.Wednesday)).IgnoreArguments().Return(descriptionList);
var input = new FizzBuzzRequest()
{
UserInput = 5
};
SetUpDependencies();
fizzBuzzProvider = new FizzBuzzProvider(divisibileCheckers, fizzBuzzDescriptionProvider);
FizzBuzzResponse expectedResponse = new FizzBuzzResponse
{
FizzBuzzList = new List <FizzBuzz>
{
new FizzBuzz {
Description = "1"
},
new FizzBuzz {
Description = "2"
},
new FizzBuzz {
Description = "Fizz"
},
new FizzBuzz {
Description = "4"
},
new FizzBuzz {
Description = "Buzz"
}
}
};
//Act
var result = fizzBuzzProvider.GetFizzBuzzList(input);
//Assert
Assert.AreEqual(expectedResponse.FizzBuzzList[0].Description, result.FizzBuzzList[0].Description);
}
public void ReturnsCustomWordForFizz_WhenDivisible_By_ThreeOnly()
{
// given the way the solution is, let us only execute up until the point of where we expect the end result to be
// grab the last result and compare with the actual execution for each of the points for FizzBuzz.
FizzBuzzRequest threeUpperBound = new FizzBuzzRequest {
UpperBound = 3, FizzRule = new Rule {
DivisibleBy = 3, DivisibleByWord = "Hello"
}, BuzzRule = new BuzzRuleDefault(), NoMatch = new NoMatchRuleDefault()
};
FizzBuzzRequest sixUpperBound = new FizzBuzzRequest {
UpperBound = 6, FizzRule = new Rule {
DivisibleBy = 3, DivisibleByWord = "Hello"
}, BuzzRule = new BuzzRuleDefault(), NoMatch = new NoMatchRuleDefault()
};
FizzBuzzRequest nineFiveUpperBound = new FizzBuzzRequest {
UpperBound = 9, FizzRule = new Rule {
DivisibleBy = 3, DivisibleByWord = "Hello"
}, BuzzRule = new BuzzRuleDefault(), NoMatch = new NoMatchRuleDefault()
};
var runner = new FizzBuzzRunner();
var expectedFizzReplacementWord = "Hello";
var actualRunnerThreeResult = runner.FizzBuzzRun(threeUpperBound).ToList();
var actualFizzBuzzResult = actualRunnerThreeResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizzReplacementWord, actualFizzBuzzResult.Result);
var actualRunnerSixResult = runner.FizzBuzzRun(sixUpperBound).ToList();
var actualFizzBuzzSixResult = actualRunnerSixResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizzReplacementWord, actualFizzBuzzSixResult.Result);
var actualRunnerNineResult = runner.FizzBuzzRun(nineFiveUpperBound).ToList();
var actualFizzNineFiveResult = actualRunnerNineResult.Last();
StringAssert.AreEqualIgnoringCase(expectedFizzReplacementWord, actualFizzNineFiveResult.Result);
}
public void ReturnsCustomWordForNoMatch_WhenNotDivisible_By_Three_Or_Five_Or_ThreeAndFive()
{
// given the way the solution is, let us only execute up until the point of where we expect the end result to be
// grab the last result and compare with the actual execution for each of the points for FizzBuzz.
FizzBuzzRequest eightUpperBound = new FizzBuzzRequest {
UpperBound = 8, BuzzRule = new Rule {
DivisibleByWord = "Buzz", DivisibleBy = 5
}, NoMatch = new Rule {
DivisibleByWord = "Nothing"
}, FizzRule = new Rule {
DivisibleBy = 3, DivisibleByWord = "Fizz"
}
};
var runner = new FizzBuzzRunner();
var expectedNoMatchReplacement = "Nothing";
var actualRunnerResult = runner.FizzBuzzRun(eightUpperBound).ToList();
var actualResult = actualRunnerResult.Last();
StringAssert.AreEqualIgnoringCase(expectedNoMatchReplacement, actualResult.Result);
}
/// <summary>
/// Main entry point for FizzBuzz!
/// </summary>
/// <param name="request">The request object containing parameters for execution</param>
/// <returns>Enumerable of a response object indicating the result of the operation</returns>
public IEnumerable <FizzBuzzResponse> FizzBuzzRun(FizzBuzzRequest request)
{
// Let's use default rules, in case if the consumer does not provide any rules
Rule fizzRule = new FizzRuleDefault {
};
Rule buzzRule = new BuzzRuleDefault {
};
Rule noMatch = new NoMatchRuleDefault {
};
// Validate our inputs
if (request == null)
{
throw new ArgumentNullException(nameof(request), "A valid request object must be supplied");
}
// Do they want to use default rules?
if (!request.UseDefaultRules)
{
if (request.FizzRule == null)
{
throw new ArgumentNullException(nameof(request.FizzRule), "A valid fizz rule must be supplied");
}
if (request.BuzzRule == null)
{
throw new ArgumentNullException(nameof(request.FizzRule), "A valid buzz rule must be supplied");
}
if (request.NoMatch == null)
{
throw new ArgumentNullException(nameof(request.NoMatch), "A valid no match rule must be supplied");
}
fizzRule = request.FizzRule;
buzzRule = request.BuzzRule;
noMatch = request.NoMatch;
}
if (request.UpperBound < 1)
{
throw new ArgumentOutOfRangeException(nameof(request.UpperBound), "UpperBound must be greater than 1");
}
// Let's get an enumerable range of numbers based on low point and our upper point as specified by consumer
var range = Enumerable.Range(1, request.UpperBound);
foreach (var currentNumber in range)
{
// FizzBuzz!
if (currentNumber % fizzRule.DivisibleBy == 0 && currentNumber % buzzRule.DivisibleBy == 0)
{
yield return(new FizzBuzzResponse
{
Success = true,
Result = $"{fizzRule.DivisibleByWord}{buzzRule.DivisibleByWord}"
});
}
else if (currentNumber % fizzRule.DivisibleBy == 0) // Fizz
{
yield return(new FizzBuzzResponse
{
Success = true,
Result = fizzRule.DivisibleByWord
});
}
else if (currentNumber % buzzRule.DivisibleBy == 0) // Buzz
{
yield return(new FizzBuzzResponse
{
Success = true,
Result = buzzRule.DivisibleByWord
});
}
else
{
if (string.IsNullOrWhiteSpace(noMatch.DivisibleByWord)) // No match so let's see if the input has a word to return or not
{
yield return(new FizzBuzzResponse
{
Success = true,
Result = currentNumber.ToString() // just use counter
});
}
else
{
yield return(new FizzBuzzResponse
{
Success = true,
Result = noMatch.DivisibleByWord // just use what was supplied instead
});
}
}
}
}
