public void SuperFizzBuzz_from_RangeValue_should_return_a_valid_fizzBuzz_result_for_random_values()
{
var values = new int[] { 1, 5, 10000, -1, -22, 44, 200, 24, 24, 24 };
var range = new RangeValue(values);
var replacements = new Dictionary <int, string>()
{
{ 1, "Head" },
{ 2, "Spring" },
{ 24, "Code" }
};
var sfb = new SuperFizzBuzz(range, replacements);
var result = sfb.Get().ToList();
Assert.AreEqual("Head", result[0]);
Assert.AreEqual("Head", result[1]);
Assert.AreEqual("HeadSpring", result[2]);
Assert.AreEqual("Head", result[3]);
Assert.AreEqual("HeadSpring", result[4]);
Assert.AreEqual("HeadSpring", result[5]);
Assert.AreEqual("HeadSpring", result[6]);
Assert.AreEqual("HeadSpringCode", result[7]);
Assert.AreEqual("HeadSpringCode", result[8]);
Assert.AreEqual("HeadSpringCode", result[9]);
}
public void Should_Evaluate_Negative_Numbers(int a, int b, string r)
{
var FizzBuzz = new SuperFizzBuzz(a, b);
var result = FizzBuzz.Evaluate();
Assert.That(r, Is.EqualTo(result.ToString()));
}
public void Should_Evaluate_Input_Not_In_Incremental_Sequence(int a, int b, string r)
{
var FizzBuzz = new SuperFizzBuzz(a, b);
var result = FizzBuzz.Evaluate();
Assert.That(r, Is.EqualTo(result.ToString()));
}
public void Should_Evaluate_Classic_FizzBuzz_With_Default_Constructor(int a, int b, string r)
{
var FizzBuzz = new SuperFizzBuzz(a, b);
var result = FizzBuzz.Evaluate();
Assert.That(r, Is.EqualTo(result.ToString()));
}
static void Main(string[] args)
{
var Divisors = new List <Divisor>
{
new Divisor {
Value = 3, Token = "Fizz"
},
new Divisor {
Value = 7, Token = "Buzz"
},
new Divisor {
Value = 38, Token = "Bazz"
},
};
Console.WriteLine("Press any key to run FizzBuzz with the given parameters:");
Console.WriteLine("Range: -12 to 145");
Console.WriteLine("Multiples of 3: Fizz");
Console.WriteLine("Multiples of 7: Buzz");
Console.WriteLine("Multiples of 38: Bazz");
var fizzBuzz = new SuperFizzBuzz(-12, 145, Divisors);
fizzBuzz.display(fizzBuzz.generate());
}
public void UserIntegersUserTokenized()
{
//Arrange
var userInts = new List <int>()
{
3, 8, 10, 2, 5, 18, 38, 20, 15, 21
};
var listTokens = new List <DivisorToken>();
var divisorToken1 = new DivisorToken(3, "Fizz");
var divisorToken2 = new DivisorToken(7, "Buzz");
var divisorToken3 = new DivisorToken(38, "Bazz");
var superFizzBuzz = new SuperFizzBuzz(null, userInts, listTokens);
listTokens.Add(divisorToken1);
listTokens.Add(divisorToken2);
listTokens.Add(divisorToken3);
//Act
var result = superFizzBuzz.FizzBuzz();
//Assert
Assert.AreEqual("Fizz", result[0]);
Assert.AreEqual("Bazz", result[6]);
Assert.AreEqual("FizzBuzz", result[9]);
}
public void Test_B()
{
//Test B: Testing a No sequential input
Dictionary <int, string> dictPref = new Dictionary <int, string>();
dictPref.Add(4, "Frog");
dictPref.Add(13, "Duck");
dictPref.Add(9, "Chicken");
List <int> lsNumber = new List <int> {
50, 51, 52, 30, 36, 468, 469
};
var oSuperBuzz = new SuperFizzBuzz(dictPref);
oSuperBuzz.startSuperFizzBuzz(lsNumber);
//dictOutPut is the structure which I can test on
List <int> lsTest1 = new List <int>()
{
50, 51, 30, 469
};
foreach (var item in lsTest1)
{
Assert.AreEqual("", oSuperBuzz._dictOutput[item].ToString());
}
List <int> lsTest2 = new List <int>()
{
52
};
foreach (var item in lsTest2)
{
Assert.AreEqual("FrogDuck", oSuperBuzz._dictOutput[item].ToString());
}
List <int> lsTest3 = new List <int>()
{
36
};
foreach (var item in lsTest3)
{
Assert.AreEqual("FrogChicken", oSuperBuzz._dictOutput[item].ToString());
}
List <int> lsTest4 = new List <int>()
{
468
};
foreach (var item in lsTest4)
{
Assert.AreEqual("FrogDuckChicken", oSuperBuzz._dictOutput[item].ToString());
}
}
private static void Play()
{
var min = string.Empty;
while (min == string.Empty)
{
Console.Write("\nPlease enter the first number in the range: ");
min = Console.ReadLine();
}
var max = string.Empty;
while (max == string.Empty)
{
Console.Write("Please enter the last number in the range: ");
max = Console.ReadLine();
}
var divisors = new List <Divisor>();
var addAnotherDivisor = true;
while (addAnotherDivisor)
{
var divisor = string.Empty;
while (divisor == string.Empty)
{
Console.Write("Please enter the divisor value: ");
divisor = Console.ReadLine();
}
var token = string.Empty;
while (token == string.Empty)
{
Console.Write("Please enter the word for this divisor: ");
token = Console.ReadLine().Trim();
}
divisors.Add(new Divisor {
Value = Convert.ToInt32(divisor), Token = token
});
addAnotherDivisor = GetMenuInput("Press 1 to enter another, Press 2 to continue: ") == 1;
Console.WriteLine("");
}
Console.Clear();
var fizzBuzz = new SuperFizzBuzz(Convert.ToInt32(min), Convert.ToInt32(max), divisors);
fizzBuzz.display(fizzBuzz.generate());
MainMenu();
}
public void ShouldReturnToken_GivenSingleFactorWithSingleDivisor()
{
var divisors = new List <Divisor> {
new Divisor {
Value = 3, Token = "Fizz"
}
};
var result = SuperFizzBuzz.GetStringForIndex(3, divisors);
var expected = "Fizz";
Assert.Equal(expected, result);
}
public void ShouldThrowExceptionWithStartIndexGreaterThanFinishIndex()
{
// Note: Requirements 2 and 3 should not require command line parsing to complete.
var tokens = new List <Tuple <int, string> >
{
new Tuple <int, string>(3, "Fizz"),
new Tuple <int, string>(5, "Buzz")
};
var superFizzBuzz = new SuperFizzBuzz();
Assert.Throws <ArgumentOutOfRangeException>(() => superFizzBuzz.GetSuperFizzBuzz(-5, -10, tokens));
}
public void Should_Evaluate_Using_Tokens(int a, int b, string r)
{
var tokens = new List <KeyValuePair <int, string> >();
tokens.Add(new KeyValuePair <int, string>(3, "Fizz"));
tokens.Add(new KeyValuePair <int, string>(7, "Buzz"));
tokens.Add(new KeyValuePair <int, string>(38, "Bazz"));
var FizzBuzz = new SuperFizzBuzz(a, b, tokens);
var result = FizzBuzz.Evaluate();
Assert.That(r, Is.EqualTo(result.ToString()));
}
static void Main(string[] args)
{
var listTokens = new List <DivisorToken>();
var divisorToken1 = new DivisorToken(3, "Fizz");
var divisorToken2 = new DivisorToken(5, "Buzz");
listTokens.Add(divisorToken1);
listTokens.Add(divisorToken2);
var classicFizzBuzz = new SuperFizzBuzz(new IntRange(1, 100), null, listTokens);
classicFizzBuzz.FizzBuzz();
}
public void ShouldReturn1MillionIterationsWithLastValueOf_Buzz()
{
// Note: Requirements 2 and 3 should not require command line parsing to complete.
var tokens = new List <Tuple <int, string> >
{
new Tuple <int, string>(3, "Fizz"),
new Tuple <int, string>(5, "Buzz")
};
var superFizzBuzz = new SuperFizzBuzz();
var actual = superFizzBuzz.GetSuperFizzBuzz(1, 1000000, tokens);
Assert.That(actual.Last(), Is.EqualTo("Buzz"));
}
public void ShouldReturnIndex_GivenNoFactors_WithMultipleDivisors()
{
var divisors = new List <Divisor> {
new Divisor {
Value = 3, Token = "Fizz"
}, new Divisor {
Value = 5, Token = "Buzz"
}
};
var result = SuperFizzBuzz.GetStringForIndex(4, divisors);
var expected = "4";
Assert.Equal(expected, result);
}
public void ShouldReturnCorrectList_GivenBasic35FizzBuzz()
{
var fizzBuzz = new SuperFizzBuzz(1, 15, new List <Divisor> {
new Divisor {
Value = 3, Token = "Fizz"
}, new Divisor {
Value = 5, Token = "Buzz"
}
});
var result = fizzBuzz.generate();
var expected = new List <string> {
"1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"
};
Assert.Equal(expected, result);
}
static void Main(string[] args)
{
var range = new Range(1, 20);
var replacements = new Dictionary <int, string>()
{
{ 3, "Fizz" },
{ 5, "Buzz" }
};
var sfb = new SuperFizzBuzz(range, replacements);
foreach (var fb in sfb.Get())
{
Console.WriteLine($"{fb}");
}
}
static void Main(string[] args)
{
var listTokens = new List <DivisorToken>();
var divisorToken1 = new DivisorToken(3, "Fizz");
var divisorToken2 = new DivisorToken(7, "Buzz");
var divisorToken3 = new DivisorToken(38, "Bazz");
listTokens.Add(divisorToken1);
listTokens.Add(divisorToken2);
listTokens.Add(divisorToken3);
var superFizzBuzz = new SuperFizzBuzz(new IntRange(-12, 145), null, listTokens);
superFizzBuzz.FizzBuzz();
}
private static void SolveClassicFizzBuzz()
{
// Declare a dictionary and set token values for 3 and 5
Dictionary <Int64, String> tokensDictionary = new Dictionary <Int64, String> {
{ 3, "Fizz" },
{ 5, "Buzz" }
};
// Create an instance of our super class passing the data dictionary as parameter
SuperFizzBuzz superFizzBuzz = new SuperFizzBuzz(tokensDictionary);
// Call the method that generates the list of numbers and tokens
List <String> output = superFizzBuzz.GetOutput(1, 100);
foreach (var fuzzbizz in output)
{
Console.WriteLine(fuzzbizz);
}
}
public void SuperFizzBuzz_from_RangeValue_should_return_a_zero_fizzBuzz_results()
{
var values = new int[0];
var range = new RangeValue(values);
var replacements = new Dictionary <int, string>()
{
{ 3, "Fizz" },
{ 5, "Buzz" }
};
var sfb = new SuperFizzBuzz(range, replacements);
var result = sfb.Get().ToList();
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Count);
}
public void ShouldReturnNegativeNumbersOf_FizzBuzz_14_13_Fizz_11_Buzz_Fizz_8_7_Fizz_Buzz_4_Fizz_2_1()
{
// Note: Requirements 2 and 3 should not require command line parsing to complete.
var tokens = new List <Tuple <int, string> >
{
new Tuple <int, string>(3, "Fizz"),
new Tuple <int, string>(5, "Buzz")
};
var superFizzBuzz = new SuperFizzBuzz();
var expected = new List <string> {
"FizzBuzz", "-14", "-13", "Fizz", "-11", "Buzz", "Fizz", "-8", "-7", "Fizz", "Buzz", "-4", "Fizz", "-2", "-1"
};
var actual = superFizzBuzz.GetSuperFizzBuzz(-15, -1, tokens);
Assert.That(actual, Is.EqualTo(expected));
}
public void ShouldReturn1_2_Fizz_4_Buzz_Fizz_7_8_Fizz_Buzz_11_Fizz_13_14_FizzBuzz()
{
// Note: Requirements 2 and 3 should not require command line parsing to complete.
var tokens = new List <Tuple <int, string> >
{
new Tuple <int, string>(3, "Fizz"),
new Tuple <int, string>(5, "Buzz")
};
var superFizzBuzz = new SuperFizzBuzz();
var expected = new List <string> {
"1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"
};
var actual = superFizzBuzz.GetSuperFizzBuzz(1, 15, tokens);
Assert.That(actual, Is.EqualTo(expected));
}
/// <summary>
/// Maybe a user wants to test division by 4, 13 and 9 using "Frog", "Duck" and "Chicken" respectively,
/// in this case 52 would output "FrogDuck", 36 would output "FrogChicken" and 468 would output "FrogDuckChicken".
///
/// Solution: Since we want to avoid displaying a huge list of numbers like from 36 to 468 just to test these 3 values,
/// let's define a set of integers not necessarily in order and pass it in as a parameter, SuperFizzBuzz should be intelligent enough
/// to handle it... in theory =o)
/// </summary>
private static void DisplayUserDefinedTokenValues()
{
// Declare a dictionary and set token values for 3 and 5
Dictionary <Int64, String> tokensDictionary = new Dictionary <Int64, String> {
{ 4, "Frog" },
{ 13, "Duck" },
{ 9, "Chicken" }
};
// Create an instance of our super class passing the data dictionary as parameter
SuperFizzBuzz superFizzBuzz = new SuperFizzBuzz(tokensDictionary);
// Call the method that generates the list of numbers and tokens
List <String> output = superFizzBuzz.GetOutput(new long[] { 9, 4, 12, 13, 14, 35, 36, 400, 500, 468 });
foreach (var fuzzbizz in output)
{
Console.WriteLine(fuzzbizz);
}
}
public void ShouldReturn2_Fizz_4_Buzz_FizzBuzz_FizzBuzz_2_Fizz()
{
var superFizzBuzz = new SuperFizzBuzz();
var userSuppliedListOfIntegers = new List <int> {
2, 3, 4, 15, 30, 2, 9
};
var tokens = new List <Tuple <int, string> >
{
new Tuple <int, string>(3, "Fizz"),
new Tuple <int, string>(5, "Buzz")
};
var expected = new List <string> {
"2", "Fizz", "4", "FizzBuzz", "FizzBuzz", "2", "Fizz"
};
var actual = superFizzBuzz.GetSuperFizzBuzz(userSuppliedListOfIntegers, tokens);
Assert.That(actual, Is.EqualTo(expected));
}
public void ShouldReturnThePropperSequenceEvenWithMixedPossitiveAndNegativeNumbersAndDups()
{
var superFizzBuzz = new SuperFizzBuzz();
var userSuppliedListOfIntegers = new List <int> {
-2, 3, 4, -15, 30, 2, -9, -9, 4
};
var tokens = new List <Tuple <int, string> >
{
new Tuple <int, string>(3, "Fizz"),
new Tuple <int, string>(5, "Buzz")
};
var expected = new List <string> {
"-2", "Fizz", "4", "FizzBuzz", "FizzBuzz", "2", "Fizz", "Fizz", "4"
};
var actual = superFizzBuzz.GetSuperFizzBuzz(userSuppliedListOfIntegers, tokens);
Assert.That(actual, Is.EqualTo(expected));
}
public void Test_A()
{
/* Test_A tests the advanced problem from -12 to 145 (Sequence)
*
*/
Dictionary <int, string> dictPref = new Dictionary <int, string>();
dictPref.Add(3, "Fizz");
dictPref.Add(7, "Buzz");
dictPref.Add(38, "Bazz");
var objsuperFizzBuzz = new SuperFizzBuzz(dictPref);
List <int> lsNumber = new List <int> {
-12, 145
};
var oSuperBuzz = new SuperFizzBuzz(dictPref);
objsuperFizzBuzz.startSuperFizzBuzz(lsNumber);
//dictOutPut is the structure which I can test on
List <int> lsTest1 = new List <int>()
{
-11, -10, -8
};
foreach (var item in lsTest1)
{
Assert.AreEqual("", objsuperFizzBuzz._dictOutput[item].ToString());
}
List <int> lsTest2 = new List <int>()
{
-12, -9, -6
};
foreach (var item in lsTest2)
{
Assert.AreEqual("Fizz", objsuperFizzBuzz._dictOutput[item].ToString());
}
}
public void ShouldReturn11_FrogDuck_10001_FrogChicken_1234567_FrogDuckChicken__DuckChicken()
{
var superFizzBuzz = new SuperFizzBuzz();
var userSuppliedListOfIntegers = new List <int> {
-11, 52, -10001, 36, 1234567, 468, 117
};
var tokens = new List <Tuple <int, string> >
{
new Tuple <int, string>(4, "Frog"),
new Tuple <int, string>(13, "Duck"),
new Tuple <int, string>(9, "Chicken")
};
var expected = new List <string> {
"-11", "FrogDuck", "-10001", "FrogChicken", "1234567", "FrogDuckChicken", "DuckChicken"
};
var actual = superFizzBuzz.GetSuperFizzBuzz(userSuppliedListOfIntegers, tokens);
Assert.That(actual, Is.EqualTo(expected));
}
public void SuperFizzBuzz_from_Range_should_return_a_valid_fizzBuzz_result()
{
var range = new Range(1, 15);
var replacements = new Dictionary <int, string>()
{
{ 3, "Fizz" },
{ 5, "Buzz" }
};
var sfb = new SuperFizzBuzz(range, replacements);
var result = sfb.Get().ToList();
Assert.AreEqual("1", result[0]);
Assert.AreEqual("Fizz", result[2]);
Assert.AreEqual("4", result[3]);
Assert.AreEqual("Buzz", result[4]);
Assert.AreEqual("14", result[13]);
Assert.AreEqual("FizzBuzz", result[14]);
}
static void Main(string[] args)
{
Dictionary <int, string> dictPref = new Dictionary <int, string>();
dictPref.Add(3, "Fizz");
dictPref.Add(7, "Buzz");
dictPref.Add(38, "Bazz");
var objsuperFizzBuzz = new SuperFizzBuzz(dictPref);
List <int> lsNumber = new List <int> {
-12, 145
};
try
{
objsuperFizzBuzz.startSuperFizzBuzz(lsNumber);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.ToString());
}
}
public void ClassicFizzBuzz()
{
//Arrange
var listTokens = new List <DivisorToken>();
var divisorToken1 = new DivisorToken(3, "Fizz");
var divisorToken2 = new DivisorToken(5, "Buzz");
listTokens.Add(divisorToken1);
listTokens.Add(divisorToken2);
var classicFizzBuzz = new SuperFizzBuzz(new IntRange(1, 100), null, listTokens);
//Act
var result = classicFizzBuzz.FizzBuzz();
//Assert
Assert.AreEqual("Fizz", result[2]);
Assert.AreEqual("Buzz", result[4]);
Assert.AreEqual("FizzBuzz", result[14]);
}
static void Main(string[] args)
{
Dictionary <int, string> dictPref = new Dictionary <int, string>();
dictPref.Add(4, "Frog");
dictPref.Add(13, "Duck");
dictPref.Add(9, "Chicken");
var objsuperFizzBuzz = new SuperFizzBuzz(dictPref);
List <int> lsNumber = new List <int> {
50, 51, 52, 30, 36, 468, 469
};
try
{
objsuperFizzBuzz.startSuperFizzBuzz(lsNumber);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.ToString());
}
}
