public GetPhraseTest()
{
_fizzBuzzService = new FizzBuzzService();
TestModel = new FizzBuzzModel
{
MaxNumber = 100,
Num1 = 3,
Num2 = 5,
Message1 = "Fizz",
Message2 = "Buzz"
};
}
public void GetFizzBuzzValue_ShouldReturnStringifiedNumber()
{
// Arrange
IFizzBuzzService fizzBuzzService = new FizzBuzzService();
const int i = 1;
// Act
var result = fizzBuzzService.GetFizzBuzzValue(i);
// Assert
Assert.Equal(i.ToString(), result);
}
public void Print_WhenTheNumberDivisableByThree_ShouldPrintFizz(int num)
{
// Arrange
var service = new FizzBuzzService();
// Act
var result = service.Print(num);
// Assert
//Assert.Equal(result, "Fizz");
result.Should().Be("Fizz");
}
public void GetFizzBuzzValue_ShouldReturnFizzBuzz()
{
// Arrange
IFizzBuzzService fizzBuzzService = new FizzBuzzService();
const int i = 15;
// Act
var result = fizzBuzzService.GetFizzBuzzValue(i);
// Assert
Assert.Equal("FizzBuzz", result);
}
public void New_WithCustomSettingsInWrongOrder_CorrectsOrder()
{
var settings = new Dictionary <int, string>
{
{ 7, "Asdf" },
{ 1, "Test" }
};
var fizzBuzz = new FizzBuzzService(EmptyLogger.Instance, settings);
CollectionAssert.AreEqual(settings.OrderBy(s => s.Key), fizzBuzz.StringReplacementsSettings);
}
public void FizzBuzz_CorrectFizzItems()
{
var fizzBuzz = new FizzBuzzService();
fizzBuzz.FizzBuzz();
var result = fizzBuzz.FizzBuzzAdvanced(3, 5, 100);
Assert.AreEqual("Fizz", result[2]);
Assert.AreEqual("Buzz", result[4]);
Assert.AreEqual("FizzBuzz", result[14]);
}
public void Setup()
{
fizzRule = new Mock <IRule>();
buzzRule = new Mock <IRule>();
rules = new List <IRule>()
{
fizzRule.Object,
buzzRule.Object
};
fizzBuzzBervice = new FizzBuzzService(rules);
}
public void TestJazzFizzBuzz()
{
//Arrange
int Length = 100;
bool Jazz = true;
FizzBuzzService fizzBuzz = new FizzBuzzService(Length, false, Jazz);
//Act
var results = fizzBuzz.GetFizzBuzzResult();
//Assert
Assert.AreEqual(ExpectedJazzResults.ToString(), results.ToString());
}
public void SetCount_Number_Of_Values()
{
//Arrange
var mock = new Mock <IFizzBuzzRepository>();
mock.Setup(x => x.AddFizzBuzz(It.IsAny <List <FizzBuzz> >()));
var service = new FizzBuzzService(mock.Object);
//Act
var result = service.SetCount(100).ToList();
//Assert
Assert.AreEqual(100, result.Count);
}
public async Task TestDefaults(int min, int max)
{
var multiples = new[] { new Multiple {
Name = "Fizz", Value = 3
} };
var config = new DefaultsConfig {
DefaultMinValue = min, DefaultMaxValue = max, DefaultMultiples = multiples
};
var service = new FizzBuzzService(config);
var result = await service.FizzBuzz();
FizzBuzzValidation(min, max, result, multiples);
}
public void Play_From10For10Numbers_PlaysUpTo10()
{
var expected = new List <string>
{
"Buzz", "11", "Fizz", "13", "14",
"FizzBuzz", "16", "17", "Fizz", "19"
};
var fizzBuzz = new FizzBuzzService(EmptyLogger.Instance);
IEnumerable <string> result = fizzBuzz.Play(10, 10);
Assert.AreEqual(expected, result);
}
public void GetFizzBuzzResults_ShouldReturnExpectedSequence()
{
// Arrange
IFizzBuzzService fizzBuzzService = new FizzBuzzService();
var expectedList = new List <string>()
{
"1", "2", "Fizz", "4", "Buzz"
};
// Act
var results = fizzBuzzService.GetFizzBuzzResults(expectedList.Count);
// Assert
Assert.Equal(expectedList, results);
}
public void Play_From1WithNoEnd_PlaysIndefinitely()
{
var expected = new List <string>
{
"1", "2", "Fizz", "4", "Buzz",
"Fizz", "7", "8", "Fizz", "Buzz",
"11", "Fizz", "13", "14", "FizzBuzz"
};
var fizzBuzz = new FizzBuzzService(EmptyLogger.Instance);
IEnumerable <string> result = fizzBuzz.Play(1).Take(15);
Assert.AreEqual(expected, result);
}
public void TestBackwardsFizzBuzz()
{
//Arrange
int Length = 100;
bool Backwards = true;
string[] expected = ExpectedResults.Reverse().ToArray();
FizzBuzzService fizzBuzz = new FizzBuzzService(Length, false, false, Backwards);
//Act
var results = fizzBuzz.GetFizzBuzzResult();
//Assert
Assert.AreEqual(expected.ToString(), results.ToString());
}
public async Task GivenStartNumber_WhenGetFizzBuzz_ThenReturnExpectedResult()
{
// Arrange
var configuration = GetConfig();
var fizzBuzzService = new FizzBuzzService(new NullLogger <FizzBuzzService>());
var sut = new FizzBuzzController(configuration, new NullLogger <FizzBuzzController>(), fizzBuzzService);
var startNumber = 1;
// Act
var fizzBuzzResult = await sut.GetFizzBuzz(startNumber);
// Assert
var okObjectResult = (OkObjectResult)fizzBuzzResult.Result;
Assert.AreEqual(30, ((FizzBuzzEntity)okObjectResult.Value).FizzBuzzResults.Count);
}
public void SetCount_WhenRangeInModulo3_Wednesday()
{
//Arrange
var mock = new Mock <IFizzBuzzRepository>();
mock.Setup(x => x.AddFizzBuzz(It.IsAny <List <FizzBuzz> >()));
var service = new FizzBuzzService(mock.Object);
//Act
var result = service.SetCount(100).ToList();
//Assert
Assert.AreEqual("fizz", result[8].Text);
Assert.AreEqual("fizz", result[26].Text);
Assert.AreEqual(94, result.Count(x => x.Text != "fizz buzz"));
}
public async Task GivenStartNumberGreaterThanLimitNumber_WhenGetFizzBuzz_ThenReturnBadRequest()
{
// Arrange
var configuration = GetConfig();
var fizzBuzzService = new FizzBuzzService(new NullLogger <FizzBuzzService>());
var sut = new FizzBuzzController(configuration, new NullLogger <FizzBuzzController>(), fizzBuzzService);
var startNumber = 30;
// Act
var fizzBuzzResult = await sut.GetFizzBuzz(startNumber);
// Assert
var badRequestObjectResult = (BadRequestObjectResult)fizzBuzzResult.Result;
Assert.IsInstanceOf <BadRequestObjectResult>(badRequestObjectResult);
Assert.AreEqual("The start number should not be greater than 30", badRequestObjectResult.Value);
}
static void Main(string[] args)
{
var fizzBuzzService = new FizzBuzzService()
{
MinNumber = GetNumericInputFromUser("Enter the min number to start from", 1),
MaxNumber = GetNumericInputFromUser("Enter the max number to stop at", 100)
};
fizzBuzzService.AddMap(
GetNumericInputFromUser("Enter first number to replace, or hit enter to use the default of 3", 3),
GetStringInputFromUser("Enter fizz word, or hit enter to just use the default of Fizz", "Fizz")
);
fizzBuzzService.AddMap(
GetNumericInputFromUser("Enter next number to replace, or hit enter to use the default of 5", 5),
GetStringInputFromUser("Enter buzz word, or hit enter to just use the default of Buzz", "Buzz")
);
while (true)
{
var number = GetNumericInputFromUser("Enter another number to replace, or hit enter get the results", -1);
if (number == -1)
{
break;
}
var word = GetStringInputFromUser($"Enter the replacement word for number {number}, or hit enter to get the results", string.Empty);
if (string.IsNullOrEmpty(word))
{
break;
}
fizzBuzzService.AddMap(number, word);
}
var results = fizzBuzzService.GetAllValues();
foreach (var result in results)
{
Console.WriteLine(result);
}
// Pause for user input
Console.ReadKey();
}
public void GetFizzBuzzData_ShouldReturnBuzz_WhenInputNumberIs5(int inputValue, string expectedResult)
{
this.ruleMock = new Mock <IRule>();
this.ruleMock.Setup(x => x.IsDivisible(inputValue)).Returns(true);
this.ruleMock.Setup(y => y.GetValue()).Returns(Constants.Buzz);
var businesrule = new[]
{
this.ruleMock.Object
};
var results = new FizzBuzzService(businesrule);
var actual = results.GetFizzBuzzData(inputValue);
Assert.AreEqual(actual[4], expectedResult);
}
public void GetFizzBuzzDataTest(int inputValue, string[] expectedResult)
{
this.ruleMock = new Mock <IRule>();
this.ruleMock.Setup(x => x.IsDivisible(inputValue)).Returns(false);
this.ruleMock.Setup(y => y.GetValue()).Returns(string.Empty);
var businesrule = new[]
{
this.ruleMock.Object,
this.ruleMock.Object
};
var results = new FizzBuzzService(businesrule);
var actual = results.GetFizzBuzzData(inputValue);
Assert.AreEqual(actual, expectedResult);
}
public void FizzBuzzService_Catches_Edge_Case()
{
//Arange
var input = -3;
var service = new FizzBuzzService();
//Act
try
{
var result = service.FizzBuzz(input);
}
catch (ArgumentOutOfRangeException e)
{
return;
}
//Assert
Assert.Fail("edge case");
}
public void TestConvertToFizzBuzz()
{
// Arrange
FizzBuzzService service = new FizzBuzzService();
int from = 1;
int to = 30;
List <string> actual = null;
List <String> expected = new List <string> {
"1", "2", "Fizz", "4", "Buzz",
"Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz",
"16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26",
"Fizz", "28", "29", "FizzBuzz"
};
// Act
actual = service.ConvertToFizzBuzz(from, to);
// Assert
CollectionAssert.AreEqual(expected, actual);
}
//Get Fizz/Buzz based on multiples of 3/5.
static void Main(string[] args)
{
//Read input from app.config
string input = ConfigurationManager.AppSettings[Helpers.Helpers.INPUTNUMBER].ToString();
string output;
if (ValidateInput(input))
{
//Call Fizz Buzz Service
IFizzBuzzService fizzBuzzService = new FizzBuzzService();
output = fizzBuzzService.Process(Convert.ToInt16(input));
}
else
{
output = Helpers.Helpers.ERRORINPUT;
}
Console.WriteLine(output);
Console.WriteLine(Helpers.Helpers.PRESSKEY);
Console.ReadLine();
}
public void FizzBuzz()
{
//Arrange
var fizzBuzzProp = new FizzBuzzProperties
{
Length = 100,
Fizz = "Fizz",
Buzz = "Buzz",
DividerOne = 3,
DividerTwo = 5
};
//Act
var fizzBuzzService = new FizzBuzzService(fizzBuzzProp);
var fizzBuzzList = fizzBuzzService.GetFizzBuzz;
//Assert
Assert.AreEqual("Fizz Buzz", fizzBuzzList[15]);
Assert.AreEqual("Fizz", fizzBuzzList[3]);
Assert.AreEqual("Buzz", fizzBuzzList[5]);
Assert.AreEqual("2", fizzBuzzList[2]);
}
public void JazzBuzzWithFizzBuzzList()
{
//Arrange
var propJazz = new JazzFuzzProperties
{
Length = 100,
DividerOne = 9,
DividerTwo = 4,
Jazz = "Jazz",
Fuzz = "Fuzz",
};
var fizzBuzzProp = new FizzBuzzProperties
{
Length = 100,
Fizz = "Fizz",
Buzz = "Buzz",
DividerOne = 3,
DividerTwo = 5
};
//Act
var fizzBuzzService = new FizzBuzzService(fizzBuzzProp);
var fizzBuzzList = fizzBuzzService.GetFizzBuzz;
propJazz.ListToCorrect = fizzBuzzService.GetFizzBuzz;
var jazzFuzzService = new JazzFuzzService(propJazz);
var jazzBuzzList = jazzFuzzService.GetJazzFuzz;
//Assert
Assert.AreEqual("Fizz", jazzBuzzList[3]);
Assert.AreEqual("Fuzz", jazzBuzzList[4]);
Assert.AreEqual("Jazz", jazzBuzzList[9]);
Assert.AreEqual("2", jazzBuzzList[2]);
}
public void FizzBuzzSingleOutput_WhenCalled_ReturnStringAccordingFizzBuzzTes(int input, string expectedResult)
{
var result = FizzBuzzService.FizzBuzzSingleOutput(input);
Assert.Equal(expectedResult, result);
}
public FizzBuzzServiceTest()
{
_fizzBuzzService = new FizzBuzzService();
}
public FizzBuzzService_ConvertShould()
{
_fizzbuzzService = new FizzBuzzService();
}
public FizzBuzzTests()
{
fizzBuzz = new FizzBuzzService();
}
public void TestFizzBuzz(int input)
{
FizzBuzzService fizz = new FizzBuzzService();
Assert.AreEqual("FizzBuzz", fizz.Calculate(input));
}
public void Should_return_expected_list_if_20_is_given()
{
var sut = new FizzBuzzService();
var result = sut.GetFizzBuzzEnumBy(20);
Assert.IsTrue( expectedResult.SequenceEqual(result ));
}
