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 }); } } } }