public void TestFizzBuzz()
{
FizzBuzz fb = new FizzBuzz();
int num = 15;
string value = fb.DetermineOutput(num);
Assert.AreEqual("FizzBuzz", value);
}
//
// GET: /Home/
public string Index(int count = 10)
{
var fizzBuzz = new FizzBuzz();
var values = fizzBuzz.Generate(count).ToArray();
return string.Join(" ", values);
}
//
// GET: /Home/
public ActionResult Index(int count = 10)
{
var fizzBuzz = new FizzBuzz();
var model = fizzBuzz.Generate(count);
return View(model);
}
public void FizzBuzzShouldAppearFor15Test()
{
FizzBuzz fb = new FizzBuzz(config);
var result = fb.BuildResults(16);
Assert.IsTrue(result);
Assert.AreEqual("Fizz Buzz", fb.GetResult(15).Result);
}
public void ClassicRules(int upperBound, string expected)
{
FizzBuzz buzz = new FizzBuzz();
string actual = string.Join(string.Empty, buzz.Range(upperBound));
Assert.AreEqual(expected, actual);
}
public void TestNormal()
{
FizzBuzz fb = new FizzBuzz();
int num = 7;
string value = fb.DetermineOutput(num);
Assert.AreEqual(num.ToString(), value);
}
public void TestingToFifteenAsInputFizzBuzz()
{
//Fifteen tests all current possible output scenarios
FizzBuzz fifteenFizzBuzzExpected = new FizzBuzz();
FizzBuzz fifteenFizzBuzzActual = new FizzBuzz();
fifteenFizzBuzzExpected.fizzBuzzList.Add("1");
fifteenFizzBuzzExpected.fizzBuzzList.Add("2");
fifteenFizzBuzzExpected.fizzBuzzList.Add("Fizz");
fifteenFizzBuzzExpected.fizzBuzzList.Add("4");
fifteenFizzBuzzExpected.fizzBuzzList.Add("Buzz");
fifteenFizzBuzzExpected.fizzBuzzList.Add("Fizz");
fifteenFizzBuzzExpected.fizzBuzzList.Add("7");
fifteenFizzBuzzExpected.fizzBuzzList.Add("8");
fifteenFizzBuzzExpected.fizzBuzzList.Add("Fizz");
fifteenFizzBuzzExpected.fizzBuzzList.Add("Buzz");
fifteenFizzBuzzExpected.fizzBuzzList.Add("11");
fifteenFizzBuzzExpected.fizzBuzzList.Add("Fizz");
fifteenFizzBuzzExpected.fizzBuzzList.Add("13");
fifteenFizzBuzzExpected.fizzBuzzList.Add("14");
fifteenFizzBuzzExpected.fizzBuzzList.Add("FizzBuzz");
var resultExpected = fifteenFizzBuzzExpected.fizzBuzzList;
var resultActual = fifteenFizzBuzzActual.DoFizzBuzz(15);
CollectionAssert.AreEqual(resultExpected, resultActual);
}
static void Main(string[] args)
{
var fb = new FizzBuzz(1, 100);
foreach (var result in fb.GetResults())
Console.WriteLine(result);
}
public void IntMaxValue_As_Max_Returns_IntMaxValue_Items()
{
var fizz = new FizzBuzz();
var result = fizz.GetFizzBuzz(1, int.MaxValue);
var count = result.Count();
Assert.AreEqual(count, int.MaxValue);
}
public void SetNumbersDividedOnThreeReturnsCorrectResult(FizzBuzz sut, int count, Generator<int> generator)
{
var numbers = generator.Take(count).Where(x => x % 3 == 0 && x % 5 != 0).ToArray();
var actual = numbers.Select(n => sut.Get(n)).ToList();
actual.ForEach(result => Assert.Equal("Fizz", result));
}
public void CanReverseTraverseTest()
{
FizzBuzz fb = new FizzBuzz(config);
var result = fb.BuildResults(16);
Assert.IsTrue(result);
Assert.AreEqual("Fizz Buzz", fb.GetResult(15).Result);
Assert.AreEqual("Fizz", fb.GetResult(3).Result);
}
public void CustomRules_EmptySet(int upperBound, string expected)
{
FizzBuzz buzz = new FizzBuzz(new Dictionary<int, string>());
string actual = string.Join(string.Empty, buzz.Range(upperBound));
Assert.AreEqual(expected, actual);
}
public void Should_Return_Buzz()
{
var fizz = new FizzBuzz();
var actual = fizz.Calculate(5);
var expected = "Buzz";
Assert.Equal(expected, actual);
}
public void BeforeAll()
{
_sut = _ioc.Resolve<FizzBuzz>();
for (int i = 1; i <= 15; i++)
{
_result[i - 1] = _sut.Print();
}
}
public void PrintNumber_IsNeitherMultipleOfThreeOrFive_ReturnsNumber(int value)
{
string expected = value.ToString();
var fizzBuzz = new FizzBuzz();
var result = fizzBuzz.PrintNumber(value);
Assert.AreEqual(expected, result);
}
public void EscreverOProprioNumeroQuandoNaoForDivisivelPor3ou5()
{
//Arrange
FizzBuzz fizzBuzz = new FizzBuzz();
//Act
var retorno = fizzBuzz.Escrever(1);
//Asser
Assert.IsTrue(retorno == "1");
}
public void PrintNumber_IsMultipleOfThree_ReturnsFizz(int value)
{
const string expected = "Fizz";
var fizzBuzz = new FizzBuzz();
var result = fizzBuzz.PrintNumber(value);
Assert.AreEqual(expected, result);
}
public void DadoUmNumeroDivisivelPor3EscreverFizz()
{
//Arrange
FizzBuzz fizzBuzz = new FizzBuzz();
//Act
var retorno = fizzBuzz.Escrever(3);
//Assert
Assert.IsTrue(retorno == "Fizz");
}
public void BeforeAll()
{
_sut = new FizzBuzz(_numericPrinter, _fizzBuzzPrinter, _fizzBuzzPredicate, _counterFake);
_fizzBuzzPredicate.MatchesShouldReturn(false, _counterFake);
_fizzBuzzPrinter.PrintShouldReturn(_expected, _counterFake);
_numericPrinter.PrintShouldReturn(_expected, _counterFake);
_returned = _sut.Print();
}
static void Main(string[] args)
{
FizzBuzz fizzbuzz = new FizzBuzz(300);
IEnumerable<String> results = from fb in fizzbuzz select fb;
foreach (String line in results)
{
System.Console.WriteLine(line);
}
System.Console.ReadKey();
}
public void FizzBuzzTest()
{
//var input = new[] {"1 2 F 4 B F 7 8 F B"};
var input = new string[] {"3 5 10"};
var expected = "1 2 F 4 B F 7 8 F B";
var prog = new FizzBuzz(input);
var result = prog.Run().First();
//var expected = "1 F 3 F 5 F B F 9 F 11 F 13 FB 15";
Assert.AreEqual(expected, result);
}
public void SetNumbersNotDividedOnFiveAndThreeReturnsCorrectResult(FizzBuzz sut, int count, Generator<int> generator)
{
var numbers = generator.Take(count).Where(x => x % 5 != 0 && x % 3 != 0).ToArray();
var actual = numbers.Select(n => sut.Get(n)).ToList();
var expected = numbers.Select(n => Convert.ToString(n));
Assert.Equal(expected, actual);
}
public static void Main(string[] args)
{
for (int x = 1; x <= 100; x++)
{
FizzBuzz fb = new FizzBuzz();
string result = fb.DetermineOutput(x);
Console.Write(result);
Console.WriteLine();
}
}
public void DuplicateValuesTest()
{
config.Add(new FizzBuzzConfiguration()
{
Text = "Fizz",
Value = 7
});
FizzBuzz fb = new FizzBuzz(config);
Assert.Throws<ArgumentException>(() => fb.BuildResults(10));
}
public static string SutPrinter(int numberOfTimes)
{
var sut = new FizzBuzz();
var result = "";
for (int i = 0; i < numberOfTimes; i++)
{
result = sut.Print();
}
return result;
}
static void Main(string[] args)
{
var fizzBuzz = new FizzBuzz();
for (int i = 1; i <= 100; i++)
{
var result = fizzBuzz.GetResult(i);
Console.WriteLine(result);
}
Console.ReadLine();
}
public void BeforeAll()
{
_numericPrinter = MockRepository.GenerateStrictMock<NumericPrinter>();
_fizzBuzzPredicate = MockRepository.GenerateStrictMock<FizzBuzzPredicate>();
_fizzBuzzPrinter = MockRepository.GenerateStrictMock<FizzBuzzPrinter>();
_counter = MockRepository.GenerateMock<Counter>();
_sut = new FizzBuzz(_numericPrinter, _fizzBuzzPrinter, _fizzBuzzPredicate, _counter);
_fizzBuzzPredicate.Stub(x => x.Matches(_counter)).Return(true);
_fizzBuzzPrinter.Stub(x => x.Print(_counter)).Return(_expected);
_returned = _sut.Print();
}
/// <summary>
/// The main method.
/// </summary>
/// <param name="args">The args.</param>
public static void Main(string[] args)
{
var fizzbuzz = new FizzBuzz();
for (int i = 1; i <= 100; i++)
{
Console.WriteLine(fizzbuzz.GetFizzBuzzFormattedString(i));
}
Console.ReadLine();
}
public void RetornarFizzParaNumeroSeis()
{
// Arrange
var fizzBuzz = new FizzBuzz();
// Act
var resultado = fizzBuzz.ObterNumeroFizzBuzz(6);
// Assert
Assert.AreEqual("Fizz", resultado);
}
public void CustomRules_LowerCase(int upperBound, string expected)
{
FizzBuzz buzz = new FizzBuzz(new Dictionary<int, string>
{
{5, "buzz"},
{3, "fizz"},
});
string actual = string.Join(string.Empty, buzz.Range(upperBound));
Assert.AreEqual(expected, actual);
}
public void Generating_The_First_Two_Numbers_And_Fizz_If_MaxNumber_Is_Three()
{
Assert.Equal(new String[] { "1", "2", "Fizz" }, FizzBuzz.GenerateOutput(3));
}
public void SetUp()
{
_fizzBuzz = new FizzBuzz();
}
public void GetOutput_WhenCalled_GetsExpectedResult(int num, string expectedResult)
{
var result = FizzBuzz.GetOutput(num);
Assert.That(result, Is.EqualTo(expectedResult));
}
public void Generating_The_First_Two_Numbers_If_MaxNumber_Is_Two()
{
Assert.Equal(new String[] { "1", "2" }, FizzBuzz.GenerateOutput(2));
}
public void GetOutput_NotDivisableBy3And5_ReturnsNumber()
{
var result = FizzBuzz.GetOutput(7);
Assert.Equal("7", result);
}
public void WhenGivenSevenReturnsSeven()
{
Assert.Equal("7", FizzBuzz.doFizzBuzz(7));
}
public void Generating_The_First_Nine_Numbers_With_Bizz_And_Buzz_If_MaxNumber_Is_Nine()
{
Assert.Equal(new String[] { "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz" }, FizzBuzz.GenerateOutput(9));
}
public void GetOutput_NumberIsNotDivisableBy3or5_ReturnNumber()
{
var result = FizzBuzz.GetOutput(7);
Assert.That(result, Is.EqualTo("7"));
}
public void WhenGivenThreeReturnsFizz()
{
Assert.Equal("Fizz", FizzBuzz.doFizzBuzz(3));
}
public void GetOutput_InputIsNotDivisibleBy3Or5_ReturnFizzBuzz()
{
var result = FizzBuzz.GetOutput(1);
Assert.That(result, Is.EqualTo("1"));
}
public void GetOutput_InputIsDivisibleByOnly5_ReturnFizzBuzz()
{
var result = FizzBuzz.GetOutput(5);
Assert.That(result, Is.EqualTo("Buzz"));
}
public void GetOutput_NotDivisibleBy5or3_ReturnStringResult()
{
var results = FizzBuzz.GetOutput(2);
Assert.That(results, Is.EqualTo("2"));
}
public void GetOutput_CheckIfDivisibleBy5or3orBoth_ReturnStringResult(int a)
{
var results = FizzBuzz.GetOutput(a);
Assert.That(results, Does.Contain("zz"));
}
private static void AssertFizzBuzz(string expected, int number)
{
Assert.AreEqual(expected, FizzBuzz.Of(number));
}
public void GetOutput_DivisableOnlyBy5_ReturnsBuzz()
{
var result = FizzBuzz.GetOutput(10);
Assert.Equal("Buzz", result);
}
public void Generating_The_First_Four_Numbers_If_MaxNumber_Is_Four()
{
Assert.Equal(new String[] { "1", "2", "Fizz", "4" }, FizzBuzz.GenerateOutput(4));
}
public void GetOutput_DivisableBy3And5_ReturnsFizzBuzz()
{
var result = FizzBuzz.GetOutput(15);
Assert.Equal("FizzBuzz", result);
}
public void Generate_First_Number_If_MaxNumber_Is_One()
{
Assert.Equal(new String[] { "1" }, FizzBuzz.GenerateOutput(1));
}
public void Setup()
{
sut = new FizzBuzz();
}
public void Generating_The_First_Fiveteen_Numbers_With_Bizz_And_Buzz_If_MaxNumber_Is_Fiveteen()
{
Assert.Equal(new String[] { "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz" }, FizzBuzz.GenerateOutput(15));
}
public void DoitDonnerErreurSiNombreNegatif()
{
int nb = -9;
String FizzStr = FizzBuzz.BobRepond(nb);
}
public async Task ShouldReturnKeyException()
{
//Arrange
var start = 0;
var limit = 10;
var fizzBuzzParams = GetDummyDictionary();
fizzBuzzParams.Add(0, "wrongKey");
//Act
//Assert
await Assert.ThrowsExceptionAsync <InvalidKeyException>(async() => { var Result = await FizzBuzz.DoFizzBuzzAsync(start, fizzBuzzParams, limit); });
}
public void DoitDonnerErreurSiNombre0()
{
int nb = 0;
String FizzStr = FizzBuzz.BobRepond(nb);
}
public void WhenGivenOneReturnsOne()
{
Assert.Equal("1", FizzBuzz.doFizzBuzz(1));
}
public void WhenGivenTwoReturnsTwo()
{
Assert.Equal("2", FizzBuzz.doFizzBuzz(2));
}
public FizzBuzzSuppliedNumbersTests(ITestOutputHelper testOutputHelper)
{
_testOutputHelper = testOutputHelper;
_superFizzBuzz = new FizzBuzz();
}
public void GetOutput_WithDivizibleBy3_ShouldReturnFizz()
{
var result = FizzBuzz.GetOutput(3);
Assert.That(result, Is.EqualTo("Fizz"));
}
public void WhenGivenFourReturnsFour()
{
Assert.Equal("4", FizzBuzz.doFizzBuzz(4));
}
public void GetOutput_NumberIsDivisableBy3And5_ReturnFizzBuzz()
{
var result = FizzBuzz.GetOutput(15);
Assert.That(result, Is.EqualTo("FizzBuzz"));
}
public void WhenGivenFiveReturnsBuzz()
{
Assert.Equal("Buzz", FizzBuzz.doFizzBuzz(5));
}
