public IActionResult FizzBuzz(string userInput1, string userInput2)
{
var fizzBuzzModel = new FizzBuzzModel
{
FizzNum = Convert.ToInt32(userInput1),
BuzzNum = Convert.ToInt32(userInput2),
Output = ""
};
for (int i = 1; i <= 100; i++)
{
if (i % fizzBuzzModel.FizzNum == 0 && i % fizzBuzzModel.BuzzNum == 0)
{
fizzBuzzModel.Output += "FizzBuzz ";
}
else if (i % fizzBuzzModel.FizzNum == 0)
{
fizzBuzzModel.Output += "Fizz ";
}
else if (i % fizzBuzzModel.BuzzNum == 0)
{
fizzBuzzModel.Output += "Buzz ";
}
else
{
fizzBuzzModel.Output += $" {i} ";
}
}
return(RedirectToAction("FizzBuzz", fizzBuzzModel));
}
static void Main(string[] args)
{
Console.WriteLine("Please enter the \n 1.The start number \n 2.The final one");
var inputStartNumber = CheckConvertToDouble(Console.ReadLine());
var inputLastNumber = CheckConvertToDouble(Console.ReadLine());
Console.WriteLine("Please enter the prime numbers \n 1. First prime number \n 2. Second prime number ");
var firstPrime = PrimeNumberValidation(Console.ReadLine());
var secondPrime = PrimeNumberValidation(Console.ReadLine());
Console.WriteLine("Please enter the definition for special numbers \n 1. For the first value \n 2. For the second value ");
string firstDefinition = Console.ReadLine();
string secondDefinition = Console.ReadLine();
Console.WriteLine("______________________________________________________");
var fizzBuzz = new FizzBuzzModel()
{
startNumber = inputStartNumber,
lastNumber = inputLastNumber,
firstPrime = firstPrime,
secondPrime = secondPrime,
firstDefinition = firstDefinition,
secondDefinition = secondDefinition
};
FizzBuzzLib.FizzBuzzLogic(fizzBuzz);
Console.ReadKey();
}
public ActionResult Index(FizzBuzzModel fizzBuzzModel)
{
fizzBuzzModel.FizzBuzzList = _fizzBuzzResult.ExecuteCalculate(fizzBuzzModel.Num);
return(View("FizzBuzzView", fizzBuzzModel));
}
/// <summary>
/// This action method is used to handle web request with model with values
/// </summary>
/// <param name="fizzBuzzModel"></param>
/// <returns></returns>
public virtual ActionResult FizzBuzzForm(FizzBuzzModel fizzBuzzModel, int?page)
{
try
{
if (!ModelState.IsValid)
{
return(View());
}
var _numberList = this._fizzBuzzManager.GetNumbers(fizzBuzzModel);
IList <NumberModel> fizzbuzzModelList = new List <NumberModel>();
foreach (var item in _numberList)
{
fizzbuzzModelList.Add(new NumberModel()
{
Number = item.Number, InputNumber = item.InputNumber
});
}
int pageNumber = (page ?? 1);
int pageSize = 20;
fizzBuzzModel.Numbers = fizzbuzzModelList.ToPagedList(pageNumber, pageSize);
return(View("FizzBuzzForm", fizzBuzzModel));
}
catch
{
}
return(View());
}
public IActionResult FizzBuzz(int fizzInput, int buzzInput, int minInput, int maxInput, int arrayResult)
{
List <FizzBuzzModel> Result = new List <FizzBuzzModel>();
bool fizz = false;
bool buzz = false;
for (int i = minInput; i <= maxInput; i++)
{
FizzBuzzModel fbItem = new FizzBuzzModel();
fizz = (i % fizzInput == 0);
buzz = (i % buzzInput == 0);
if (fizz && buzz)
{
fbItem.Result = "fizzBuzz";
}
else if (fizz)
{
fbItem.Result = "fizz";
}
else if (buzz)
{
fbItem.Result = "buzz";
}
else
{
fbItem.Result = i.ToString();
}
Result.Add(fbItem);
}
return(View(Result));
}
private void FillFizzBuzzList(FizzBuzzModel objData)
{
if (objData.Number != null)
{
objData.FizzBuzzList = _businessrules.GetData(objData.Number.Value, _fizzbuzz);
}
}
public IActionResult Solve(int input1, int input2)
{
var model = new FizzBuzzModel()
{
FizzNum = Convert.ToInt32(input1),
BuzzNum = Convert.ToInt32(input2),
Output = $"You gave me FizzNum: {input1} and BuzzNumb: {input2} <hr/>"
};
var output = new StringBuilder();
for (var index = 1; index <= 100; index++)
{
if (index % input1 == 0 && index % input2 == 0)
{
model.Output += "<span class='fizzBuzz'> FizzBuzz </span>";
}
else if (index % input2 == 0)
{
model.Output += "<span class='buzz'> Buzz </span>";
}
else if (index % input1 == 0)
{
model.Output += "<span class='fizz'> Fizz </span>";
}
else
{
model.Output += $"<span class='miss'> {index} </span>";
}
}
ViewData["Output"] = output.ToString();
return(View("Result", model));
}
public void Teste(int nmbr, string resultadoEsperado)
{
var fb = new FizzBuzzModel();
var recebido = fb.GetResultado(nmbr);
Assert.Equal(recebido, resultadoEsperado);
}
public void TestMultipleFive_Negative()
{
// Create a list of integers that are NOT multiples of 5
List <int> notFives = new List <int>();
// Offset by one: 1,6,11...
for (int value = 1; value <= 100; value += 5)
{
notFives.Add(value);
}
// Offset by two: 2,7,12...
for (int value = 2; value <= 100; value += 5)
{
notFives.Add(value);
}
// Offset by three: 3,8,13...
for (int value = 3; value <= 100; value += 5)
{
notFives.Add(value);
}
// Offset by four: 4,9,14...
for (int value = 1; value <= 100; value += 5)
{
notFives.Add(value);
}
// Test the method
foreach (int value in notFives)
{
Assert.IsFalse(FizzBuzzModel.IsMultipleFive(value));
}
}
public void LoadContext()
{
fizzBuzzManager = new Mock <IFizzBuzzManager>();
fizzBuzzController = new FizzBuzzController(fizzBuzzManager.Object);
fizzBuzzController.ControllerContext = new ControllerContext();
this.fizzBuzzModel = new FizzBuzzModel();
}
public void sould_return__viewName()
{
fizzBuzzModel = new FizzBuzzModel {
InputValue = 2
};
var stub = new List <NumberModel>();
stub.Add(new NumberModel()
{
InputNumber = "1", Number = FizzOrBuzzValue.Buzz
});
stub.Add(new NumberModel()
{
InputNumber = "2", Number = FizzOrBuzzValue.Buzz
});
fizzBuzzManager.Setup(x => x.GetNumbers(fizzBuzzModel)).Returns(stub);
fizzBuzzController = new FizzBuzzController(fizzBuzzManager.Object);
result = fizzBuzzController.FizzBuzzForm(fizzBuzzModel, 1);
var viewResult = result as ViewResult;
Assert.IsNotNull(result);
fizzBuzzManager.Verify(x => x.GetNumbers(fizzBuzzModel), Times.Once);
Assert.AreEqual("FizzBuzzForm", viewResult.ViewName);
}
public IActionResult FizzBuzz(int fizz, int buzz)
{
// fbm -> fizz buzz model
var fbm = new FizzBuzzModel
{
Fizz = fizz,
Buzz = buzz,
Output = ""
};
for (var i = 1; i <= 100; i++)
{
if (i % fbm.Fizz == 0 && i % fbm.Buzz == 0)
{
fbm.Output += "FizzBuzz ";
}
else if (i % fbm.Fizz == 0)
{
fbm.Output += "Fizz ";
}
else if (i % fbm.Buzz == 0)
{
fbm.Output += "Buzz ";
}
else
{
fbm.Output += i.ToString() + " ";
}
}
return(RedirectToAction("Result", fbm));
}
public ActionResult Display(FizzBuzzModel model, int page = 1)
{
if (ModelState.IsValid)
{
model.FizzBuzzValue = this.PagedList(model.Number.Value, page);
}
return(this.View(Constants.ControllerActionName, model));
}
public ActionResult Post([FromBody] FizzBuzzModel model)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
return(Ok(_fizzBuzzService.BuildMessage(model)));
}
private static void WriteFizzBuzz()
{
FizzBuzzModel fizzBuzzCalculator = new FizzBuzzModel();
for (int i = 0; i < 101; i++)
{
Console.WriteLine(fizzBuzzCalculator.GetTheFizzBuzz(i));
}
}
public ActionResult LoadBasedOnPageIndex(int number, int page)
{
var model = new FizzBuzzModel
{
Number = number,
FizzBuzzValue = this.PagedList(number, page)
};
return(this.View(Constants.ControllerActionName, model));
}
public void Display_ShouldDisplayView_WithInvalidModelState()
{
var model = new FizzBuzzModel()
{
};
this.fizzBuzzController.ViewData.ModelState.AddModelError("Limit", Constants.EnterNumber1To1000);
var result = fizzBuzzController.Display(model) as ViewResult;
Assert.AreEqual(result.ViewName, Constants.ControllerActionName);
}
public string BuildMessage(FizzBuzzModel model)
{
var message = "";
for (var i = 1; i <= model.MaxNumber; i++)
{
message += GetPhrase(model, i);
}
return(message);
}
public ActionResult FizzBuzzResult(FizzBuzzModel obj)
{
FizzBuzzModel model = new FizzBuzzModel();
model.FirstDiv = obj.FirstDiv;
model.SecondDiv = obj.SecondDiv;
model.Fizz = obj.Fizz;
model.Buzz = obj.Buzz;
model.Num = obj.Num;
return(View("FizzBuzzResult", model));
}
public static void TestFromOver()
{
CustomLogger.LogDebug("Testing: TestFromOver()");
FizzBuzzModel fbm = new FizzBuzzModel(_config);
try {
fbm.getList(max + 1);
CustomLogger.LogDebug("Testing: TestFromOver() unsuccessful, no exceptions found");
} catch (CustomException e) {
CustomLogger.LogError("Testing: TestFromOver() successful: " + e.Message);
}
}
public GetPhraseTest()
{
_fizzBuzzService = new FizzBuzzService();
TestModel = new FizzBuzzModel
{
MaxNumber = 100,
Num1 = 3,
Num2 = 5,
Message1 = "Fizz",
Message2 = "Buzz"
};
}
public ActionResult GetData(FizzBuzzModel postModel)
{
var objData = new FizzBuzzModel {
Number = postModel.Number
};
if (ModelState.IsValid)
{
FillFizzBuzzList(objData);
}
return(View("FizzBuzzView", objData));
}
public void TestListCreation()
{
// Call the method
List <string> list = new FizzBuzzModel().FormatNumericList(1, 100);
// Get the list of expected values
string[] values = GetCorrectValues();
// Test all of the values
for (int index = 0; index < 99; index++)
{
Assert.AreEqual(list[index], values[index]);
}
}
public ActionResult FizzBuzzView(FizzBuzzModel model, int?page)
{
model.PageSize = 20;
if (ModelState.IsValid)
{
var number = model.Number;
for (int i = 1; i < number; i++)
{
model.NumberList = _IFizzBuzzRepository.DisplayList(number).ToPagedList(page ?? 1, model.PageSize).ToList();
}
}
return(View("FizzBuzzView", model));
}
public void LoadContext()
{
fizz = new Mock <IFizzBuzz>();
buzz = new Mock <IFizzBuzz>();
fizzbuzz = new Mock <IFizzBuzz>();
List <IFizzBuzz> list = new List <IFizzBuzz>();
list.Add(fizz.Object);
list.Add(buzz.Object);
list.Add(fizzbuzz.Object);
this.fizzBuzzManager = new FizzBuzzManager(list);
this.fizzBuzzModel = new FizzBuzzModel();
}
public void TestMultipleThree_Positive()
{
// Create a list of integers that are multiples of 3
List <int> threes = new List <int>();
for (int value = 3; value < 100; value += 3)
{
threes.Add(value);
}
// Test the method
foreach (int value in threes)
{
Assert.IsTrue(FizzBuzzModel.IsMultipleThree(value));
}
}
public void TestMultipleFive_Positive()
{
// Create a list of integers that are multiples of 5
List <int> fives = new List <int>();
for (int value = 5; value < 100; value += 5)
{
fives.Add(value);
}
// Test the method
foreach (int value in fives)
{
Assert.IsTrue(FizzBuzzModel.IsMultipleFive(value));
}
}
public ActionResult Display(int page = 1)
{
var model = new FizzBuzzModel();
if (this.HttpContext.Session["resultList"] != null)
{
var loadList = this.HttpContext.Session["resultList"] as List <string>;
model.FizzBuzzValues = loadList.ToPagedList(page, this.pageSize);
if (loadList != null)
{
model.EnterNumber = loadList.Count;
}
}
return(this.View("Display", model));
}
public ActionResult CalculateFizzBuzz(FizzBuzzModel fizzBuzzModel)
{
InRange inRange = new InRange();
if (inRange.IsInRange(fizzBuzzModel.input))
{
StringList stringList = new StringList();
fizzBuzzModel.result = stringList.NumList(fizzBuzzModel.input);
}
else
{
fizzBuzzModel.result = "The number was not in range, Please try again.";
}
return(View(fizzBuzzModel));
}
public void Display_ShouldDisplayView_WithInputNumber5()
{
var model = new FizzBuzzModel()
{
Number = 5
};
this.mockFizzBuzzService.Setup(p => p.GetFizzBuzzData(It.IsAny <int>())).Returns(this.expectedList);
var result = this.fizzBuzzController.Display(model) as ViewResult;
Assert.AreEqual(result.ViewName, Constants.ControllerActionName);
var resultModel = result.Model as FizzBuzzModel;
Assert.AreEqual(5, this.expectedList.Count);
}
