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 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 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 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 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 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 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 static void Main(string[] args) { var fizzBuzz = new FizzBuzzRunner(); const int UpperBound = 100; // Int32.MaxValue; var response = fizzBuzz.FizzBuzzRun(new FizzBuzzRequest { UpperBound = UpperBound, UseDefaultRules = true, }); if (response != null) { foreach (var currentResult in response) { Console.WriteLine(currentResult.Result); } } Console.ReadLine(); }
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); }