static void Main(string[] args)
{
var parsedArgs = ArgumentParser.Parse(args);
var runner = new FizzBuzzRunner();
runner.Run(parsedArgs);
Console.WriteLine("Finished! Press any key...");
Console.Read();
}
public void GivenInput_WhenRunningFizzBuzzRunner_ThenOutputTheNumberAndCorrectText(int number, string expectedOutput)
{
var fakeOutput = new FakeOutput();
FizzBuzzRunner.Run(number, fakeOutput);
var actualItems = fakeOutput.OutputResult.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
var actualOutput = actualItems.SingleOrDefault(s => s.StartsWith($"{number}: "));
Assert.AreEqual(expectedOutput, actualOutput);
}
public void GivenEndIsSetToOneThousand_WhenRunningFizzBuzzRunner_ThenOneThousandAndOneItemsAreOutput()
{
var end = 1000;
var expectedNumberOfItems = 1001;
var fakeOutput = new FakeOutput();
FizzBuzzRunner.Run(end, fakeOutput);
var actualNumberOfItems = fakeOutput.OutputResult.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual(expectedNumberOfItems, actualNumberOfItems.Length);
}
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 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 ReturnsCustomWordForBuzz_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, BuzzRule = new Rule {
DivisibleByWord = "World", DivisibleBy = 5
}, NoMatch = new NoMatchRuleDefault(), FizzRule = new FizzRuleDefault()
};
FizzBuzzRequest tenUpperBound = new FizzBuzzRequest {
UpperBound = 10, BuzzRule = new Rule {
DivisibleByWord = "World", DivisibleBy = 5
}, NoMatch = new NoMatchRuleDefault(), FizzRule = new FizzRuleDefault()
};
FizzBuzzRequest twentyFiveUpperBound = new FizzBuzzRequest {
UpperBound = 20, BuzzRule = new Rule {
DivisibleByWord = "World", DivisibleBy = 5
}, NoMatch = new NoMatchRuleDefault(), FizzRule = new FizzRuleDefault()
};
var runner = new FizzBuzzRunner();
var expectedFizz = "World";
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 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);
}
public static void Main()
{
var outputConsole = new OutputConsole();
FizzBuzzRunner.Run(1000, outputConsole);
}
public MainWindow()
{
InitializeComponent();
_FizzBuzzRunner = new FizzBuzzRunner(new FizzBuzzEvaluator());
}
public static void Main()
{
var outputLogFile = new OutputLogFile(Environment.ExpandEnvironmentVariables("%AppData%\\FizzBuzz.log"));
FizzBuzzRunner.Run(1000, outputLogFile);
}
