public ActionResult Index(CalculatorViewModel model) { var calculator = new CalculatorViewModel(); calculator.Types = this.types; calculator.Kilos = this.Kilos; if (model.SelectedType == null) { calculator.Quantity = 1; } if (model.SelectedKilo != null && model.SelectedType != null) { calculator.SelectedKilo = model.SelectedKilo; calculator.SelectedType = model.SelectedType; calculator.Quantity = model.Quantity; calculator.Result = new Dictionary<string, string>(); for (int i = 0; i < this.types.Count; i++) { var resultType = this.types[i].Text.Substring(0, this.types[i].Text.IndexOf(" - ")); calculator.Result.Add(resultType, this.CalculateValue(i, calculator.Quantity, calculator.SelectedType, calculator.SelectedKilo)); } } return View(calculator); }
public void decimalSeparatorTestMethod() { calculatorViewModel = new CalculatorViewModel(); string referenceNumberStr = ""; calculatorViewModel.enterDigitCommand.Execute("1"); referenceNumberStr += "1"; calculatorViewModel.enterDigitCommand.Execute("2"); referenceNumberStr += "2"; calculatorViewModel.enterDigitCommand.Execute("3"); referenceNumberStr += "3"; calculatorViewModel.enterDigitCommand.Execute("4"); referenceNumberStr += "4"; calculatorViewModel.enterSeparatorCommand.Execute(separator); referenceNumberStr += separator; calculatorViewModel.enterDigitCommand.Execute("5"); referenceNumberStr += "5"; calculatorViewModel.enterEqualsCommand.Execute("="); Assert.AreEqual(calculatorViewModel.Display, referenceNumberStr); return; }
public void AddRandomSimple() { var stubRandom = new StubIRandom(); stubRandom.GetRandomNumber = () => { return -10; }; calculator = new CalculatorViewModel(stubRandom); calculator.KeyCommand.Execute("100"); calculator.AddCommand.Execute(null); calculator.AddRandomCommand.Execute(null); calculator.EquateCommand.Execute(null); Assert.AreEqual(90, calculator.CurrentValue); }
public JsonResult GetResult(CalculatorViewModel model) { if (ModelState.IsValid) { var expression = model.Expression; var result = ExpressionEvaluator.Evaluate(expression); var msg = result.HasError ? FormatEvaluationErrorMessage(result) : result.Result.ToString(); return Json(new {Result = msg, HasError = result.HasError}, JsonRequestBehavior.AllowGet); } string messages = string.Join("; ", ModelState.Values .SelectMany(x => x.Errors) .Select(x => x.ErrorMessage)); return Json(new {Result = messages, HasError = true}, JsonRequestBehavior.AllowGet); }
public void additionTestMethod1() { calculatorViewModel = new CalculatorViewModel(); for (int i = 0; i < 10; i++) { int number1 = i * 5000 + 5; int number2 = i * 3000 + 3; int number3 = i * 1000 + 1; int refernceResultNumber = number1 + number2 + number3; string operand1 = Convert.ToString(number1); for (int s = 0; s < operand1.Length; s++) { string temp = operand1.Substring(s, 1); calculatorViewModel.enterDigitCommand.Execute(temp); } calculatorViewModel.enterBinaryOperationCommand.Execute("+"); string operand2 = Convert.ToString(number2); for (int s = 0; s < operand2.Length; s++) { string temp = operand2.Substring(s, 1); calculatorViewModel.enterDigitCommand.Execute(temp); } calculatorViewModel.enterBinaryOperationCommand.Execute("+"); string operand3 = Convert.ToString(number3); for (int s = 0; s < operand3.Length; s++) { string temp = operand3.Substring(s, 1); calculatorViewModel.enterDigitCommand.Execute(temp); } calculatorViewModel.enterEqualsCommand.Execute("="); Assert.AreEqual(calculatorViewModel.Display, Convert.ToString(refernceResultNumber)); System.Diagnostics.Debug.WriteLine("Reference result:" + Convert.ToString(refernceResultNumber)); System.Diagnostics.Debug.WriteLine("Calculator result:" + calculatorViewModel.Display); } return; }
public void FacadeReturnsCorrectResultWithOnePlusTwo() { // Arrange var model = new CalculatorViewModel() { Operand = "+", X = 1, Y = 2 }; var expectedResult = 3; _calculatorService.Setup(service => service.Calculate("+", 1, 2)).Returns(3); // Act var actualResult = _calcalatorFacade.GetCalculation(model); // Assert Assert.Equal(expectedResult, actualResult.Result); _calculatorService.Verify(service => service.Calculate("+", 1, 2), Times.Once); }
public void CalculatorViewModel_OperationButtonPress_WhenLeftOperandIsEnteredAndOperationIsEntered_ThenOperationButtonUpdatesOperationAndDisplay(string button) { var leftOperand = "20"; var operationBeforePress = "+"; var expectedDisplay = "20" + button; // Arrange var mockCalcModel = new Mock <ICalculatorModel>(); mockCalcModel.SetupAllProperties(); mockCalcModel.Object.LeftOperand = leftOperand; mockCalcModel.Object.RightOperand = string.Empty; mockCalcModel.Object.Operation = operationBeforePress; var calculatorViewModel = new CalculatorViewModel(mockCalcModel.Object); // Act calculatorViewModel.OperationButtonPress(button); //Assert Assert.AreEqual(leftOperand, calculatorViewModel.LeftOperand); Assert.AreEqual(expectedDisplay, calculatorViewModel.Display); Assert.AreEqual(string.Empty, calculatorViewModel.RightOperand); Assert.AreEqual(button, calculatorViewModel.Operation); }
public void Post_WithValidN_Test() { // Setup var viewModel = new CalculatorViewModel { N = 1 }; mockFibonacciCalculator.Setup(o => o.GetNthValue(1)).Returns("1").Verifiable(); // Act var result = target.Index(viewModel) as ViewResult; viewModel = result.Model as CalculatorViewModel; // Assert mockFibonacciCalculator.Verify(); Assert.IsNotNull(result); Assert.IsNotNull(viewModel); Assert.AreEqual(1, viewModel.N); Assert.AreEqual("1", viewModel.Result); }
public void CalculatorViewModel_DigitButtonPress_WhenLeftOperandIsEnteredAndOperationIsNotEntered_ThenDigitButtonUpdatesLeftOperandAndDisplay() { var leftOperand = "12"; var button = "3"; var updatedLeftOperand = "123"; // Arrange var mockCalcModel = new Mock <ICalculatorModel>(); mockCalcModel.SetupAllProperties(); mockCalcModel.Object.LeftOperand = leftOperand; mockCalcModel.Object.RightOperand = string.Empty; mockCalcModel.Object.Operation = string.Empty; var calculatorViewModel = new CalculatorViewModel(mockCalcModel.Object); // Act calculatorViewModel.DigitButtonPress(button); //Assert Assert.AreEqual(updatedLeftOperand, calculatorViewModel.LeftOperand); Assert.AreEqual(updatedLeftOperand, calculatorViewModel.Display); Assert.AreEqual(string.Empty, calculatorViewModel.RightOperand); Assert.AreEqual(string.Empty, calculatorViewModel.Operation); }
public IHttpActionResult PostCalculate(CalculatorViewModel model) { var result = "Invalid data!"; if (ModelState.IsValid) { var calc = new Calculator(model.Num1, model.Num2); result = calc.ExecuteOperation(model.Operation); var calculation = new Calculation { Num1 = model.Num1, Num2 = model.Num2, Operation = model.Operation, Result = result }; db.Calculations.Add(calculation); db.SaveChanges(); } return(Ok(result)); }
public ActionResult Index(CalculatorViewModel model, string command) { switch (model.Operator) { case "add": model.Result = model.A + model.B; break; case "sub": model.Result = model.A - model.B; break; case "div": model.Result = model.A / model.B; break; case "mul": model.Result = model.A * model.B; break; } return(View(model)); }
private void PopulateOperators(CalculatorViewModel model, string operation) { model.Operator = operation; var operators = GetOperators(); foreach (var item in operators) { item.Selected = false; } var selectThisOperator = (from temp in operators where temp.Text == operation select temp).FirstOrDefault(); if (selectThisOperator != null) { selectThisOperator.Selected = true; } model.Operators = operators; }
public IActionResult Calculator(CalculatorViewModel model) { if (model != null) { var calService = new CalculatorService(); var record = (IList <EntryDepart>)model.EntryDepartRecord; var resultMonths = calService.CalculateResult(ref record, model.VisaStartDate.Value, model.VisaEndDate.Value); var formattedEntryDepartRecord = new List <dynamic>(); if (record != null) { record.ToList().ForEach(edr => { formattedEntryDepartRecord.Add(new { EntryDate = edr.EntryDate.ToString("dd/MM/yyyy"), DepartDate = edr.DepartDate.Value.ToString("dd/MM/yyyy") }); }); } return(Json(new { Result = true, Data = new { ResultMonths = resultMonths, EntryDepartRecord = formattedEntryDepartRecord } })); } else { return(Json(new { Result = false })); } }
public CalculatorViewModel Calculate(CalculatorViewModel model) { switch (model.Action) { case CalculatorType.Add: model.Result = (model.InputOne + model.InputTwo).ToString(); break; case CalculatorType.Subtract: model.Result = (model.InputOne - model.InputTwo).ToString(); break; case CalculatorType.Multiply: model.Result = (model.InputOne * model.InputTwo).ToString(); break; case CalculatorType.Divide: model.Result = (model.InputOne / model.InputTwo).ToString(); break; } return(model); }
public async Task <IActionResult> GoodCalculator(CalculatorViewModel vm) { var validator = _grossPayValidator.IsValid(vm.GrossPayInput); if (!validator.IsValid) { foreach (var error in validator.Errors) { ModelState.AddModelError("Error", error); } return(View("~/Views/Home/Index.cshtml", vm)); } var taxBands = _config.GetTaxBands(); var natInsuranceBands = _config.GetNatInsuranceBands(); vm.GrossPay = validator.GrossPay; vm.CalculatorOutput = _goodCalculator.Calculate(vm.GrossPay, taxBands, natInsuranceBands); return(View("~/Views/Home/Index.cshtml", vm)); }
public void TenMinusEightReturnsTwo() { // Arrange var model = new CalculatorViewModel() { Operand = "-", X = 10, Y = 8 }; var expectedResult = 2; _calculatorService.Setup(service => service.Calculate("-", 10, 8)).Returns(2); // Act var actualResult = _calcalatorFacade.GetCalculation(model); // Assert Assert.Equal(expectedResult, actualResult.Result); _calculatorService.Verify(service => service.Calculate( It.IsAny <string>(), It.IsAny <double>(), It.IsAny <double>())); }
public void Post_WithException_DisplaysError_Test() { // Setup var viewModel = new CalculatorViewModel { N = 1, Result = "1" }; mockFibonacciCalculator.Setup(o => o.GetNthValue(It.IsAny <int>())).Throws(new Exception()); // Act var result = target.Index(viewModel) as ViewResult; viewModel = result.Model as CalculatorViewModel; // Assert Assert.IsFalse(target.ModelState.IsValid); Assert.IsNotNull(result); Assert.IsNotNull(viewModel); Assert.AreEqual(1, viewModel.N); Assert.AreEqual("1", viewModel.Result); }
public void Post_WithModelError_ClearsResult_Test() { // Setup var viewModel = new CalculatorViewModel { N = 100001, Result = "test" }; target.ModelState.AddModelError("Test", "Some error message"); // Act var result = target.Index(viewModel) as ViewResult; viewModel = result.Model as CalculatorViewModel; // Assert Assert.IsNotNull(result); Assert.IsNotNull(viewModel); Assert.AreEqual(100001, viewModel.N); Assert.AreEqual(string.Empty, viewModel.Result); mockFibonacciCalculator.Verify(o => o.GetNthValue(It.IsAny <int>()), Times.Never); }
public void CalculatorViewModel_PositiveNegativeButtonPress_WhenLeftOperandIsEntered_ThenChangeLeftOperandSignIsCalled() { var button = "+/-"; var expectedDisplay = "-12"; var leftOperandAfterPress = "-12"; // Arrange var mockCalcModel = new Mock <ICalculatorModel>(); mockCalcModel.SetupAllProperties(); mockCalcModel.Object.RightOperand = string.Empty; mockCalcModel.Object.Operation = string.Empty; mockCalcModel.Setup(c => c.LeftOperand).Returns("-12"); var calculatorViewModel = new CalculatorViewModel(mockCalcModel.Object); // Act calculatorViewModel.PositiveNegativeButtonPress(button); //Assert mockCalcModel.Verify(x => x.ChangeLeftOperandSign(), Times.Once); Assert.AreEqual(leftOperandAfterPress, calculatorViewModel.LeftOperand); Assert.AreEqual(expectedDisplay, calculatorViewModel.Display); Assert.AreEqual(string.Empty, calculatorViewModel.RightOperand); Assert.AreEqual(string.Empty, calculatorViewModel.Operation); }
public static Dictionary <string, decimal> CalculateUnits(CalculatorViewModel model) { var results = new Dictionary <string, decimal>(); var units = GetUnits(); if (units.ContainsKey(model.Type)) { var unitTypeIndex = units[model.Type]; foreach (var unit in units) { if (model.Type.EndsWith("it")) { if (unit.Key.EndsWith("it")) { results.Add(unit.Key, model.Quantity * (decimal)Math.Pow(model.Kilo, (double)(unit.Value - unitTypeIndex))); } else if (unit.Key.EndsWith("yte")) { results.Add(unit.Key, model.Quantity / 8 * (decimal)Math.Pow(model.Kilo, (double)(unit.Value - unitTypeIndex))); } } else if (model.Type.EndsWith("yte")) { if (unit.Key.EndsWith("yte")) { results.Add(unit.Key, model.Quantity * (decimal)Math.Pow(model.Kilo, (double)(unit.Value - unitTypeIndex))); } else if (unit.Key.EndsWith("it")) { results.Add(unit.Key, model.Quantity * 8 * (decimal)Math.Pow(model.Kilo, (double)(unit.Value - unitTypeIndex))); } } } } return(results); }
public IActionResult Index(CalculatorViewModel model, string command) { if (command == "add") { _modelService.Addition(model); } if (command == "sub") { _modelService.Sububstract(model); } if (command == "mul") { _modelService.Multiply(model); } if (command == "div") { _modelService.Divide(model); } if (command == "mod") { _modelService.Modulo(model); } return(View(model)); }
private CalculatorViewModel GenerateTestViewModel() { var testitem = new CalculatorViewModel { weight = 0, lengthmm = 100, SelectedFilament = 1 }; var filaments = new List <Filament> { new Filament() { FilamentId = 1, Diameter = 1.75f, Price = 20, SpoolWeight = 800 } }; testitem.Filaments = filaments; var settings = new Settings { PrinterEnergyUsageW = 300, Energiekosts = (decimal)0.21 }; testitem.Settings = settings; return(testitem); }
public void CalculatorViewModel_DigitButtonPress_WhenClearIsPressed_ThenOperandsAndOperationAreResetAndZeroIsDisplay() { var leftOperand = "13"; var operation = "+"; var rightOperand = "7"; var expectedDisplay = "0"; var button = "CLEAR"; // Arrange var mockCalcModel = new Mock <ICalculatorModel>(); mockCalcModel.SetupAllProperties(); mockCalcModel.Object.LeftOperand = leftOperand; mockCalcModel.Object.RightOperand = rightOperand; mockCalcModel.Object.Operation = operation; var calculatorViewModel = new CalculatorViewModel(mockCalcModel.Object); // Act calculatorViewModel.DigitButtonPress(button); //Assert Assert.AreEqual(string.Empty, calculatorViewModel.LeftOperand); Assert.AreEqual(expectedDisplay, calculatorViewModel.Display); Assert.AreEqual(string.Empty, calculatorViewModel.RightOperand); Assert.AreEqual(string.Empty, calculatorViewModel.Operation); }
public void Index() { // Arrange HomeController controller = new HomeController(); BandInfoRepository bandRepo = new BandInfoRepository(); List <BandSpec> bandColors = bandRepo.GetBandInfo(); CalculatorViewModel vmCalculator = new CalculatorViewModel() { bandAColor = "Red", bandBColor = "Red", bandCColor = "Red", bandDColor = "Red", BandInfo = null, OhmValue = 0 }; // Act ViewResult result = controller.Index(vmCalculator) as ViewResult; // Assert Assert.IsNotNull(result); }
/// <summary> /// Main.ascx in WebForms /// </summary> /// <param name="model"></param> /// <returns></returns> public ActionResult Index(CalculatorViewModel model) { model.State = this.State; model.Stack = this.Stack; return(View(model)); }
public IActionResult Calculator(CalculatorViewModel model) { var modelWithData = _calculatorFacade.Calculate(model); return(View(modelWithData)); }
public IViewComponentResult Invoke(CalculatorViewModel model) { return(View(model)); }
public Plugin(CalculatorViewModel viewModel) { _view = new MainWindow(viewModel); }
public DivionCommand(CalculatorViewModel vm) { calVm = vm; }
public IActionResult Calculate(CalculatorViewModel model) { if (model == null) { throw new ArgumentNullException("model", "Argument cannot be null."); } var operation = model.Operator; if (operation == CalculatorConstants.OperatorAdd) { // perform add model.ResultValue = _CalculatorService.Add( model.Value1, model.Value2 ); model.IsResultValid = true; model.Message = CalculatorConstants.Message_Success; PopulateOperators(model, operation); return(View("Index", model)); } else if (operation == CalculatorConstants.OperatorSubtract) { model.ResultValue = _CalculatorService.Subtract( model.Value1, model.Value2); model.Message = CalculatorConstants.Message_Success; model.IsResultValid = true; PopulateOperators(model, operation); return(View("Index", model)); } else if (operation == CalculatorConstants.OperatorMultiply) { model.ResultValue = _CalculatorService.Multiply( model.Value1, model.Value2); model.Message = CalculatorConstants.Message_Success; model.IsResultValid = true; PopulateOperators(model, operation); return(View("Index", model)); } else if (operation == CalculatorConstants.OperatorDivide) { if (model.Value2 == 0) { model.ResultValue = 0; model.IsResultValid = false; model.Message = CalculatorConstants.Message_CantDivideByZero; PopulateOperators(model, operation); } else { model.ResultValue = _CalculatorService.Divide( model.Value1, model.Value2); model.Message = CalculatorConstants.Message_Success; model.IsResultValid = true; PopulateOperators(model, operation); } return(View("Index", model)); } else { return(BadRequest()); } }
public void negativeSqRootTestMethod() { calculatorViewModel = new CalculatorViewModel(); for (int i = 4; i <= 16384; i = i * 4) { try { string operand1 = Convert.ToString(i * -1); for (int s = 0; s < operand1.Length; s++) { string temp = operand1.Substring(s, 1); calculatorViewModel.enterDigitCommand.Execute(temp); } calculatorViewModel.enterUnaryOperation.Execute("sqrt"); Assert.AreEqual(calculatorViewModel.Display, "ERR"); calculatorViewModel.enterClearCommand.Execute("C"); } catch(Exception) { } } return; }
public void percentTestMethod() { calculatorViewModel = new CalculatorViewModel(); int number = 100; for(int i=5; i<=100; i=i+5) { string numberStr = Convert.ToString(number); for (int s = 0; s < numberStr.Length; s++) { string temp = numberStr.Substring(s, 1); calculatorViewModel.enterDigitCommand.Execute(temp); } calculatorViewModel.enterBinaryOperationCommand.Execute("+"); string percent = Convert.ToString(i); for (int p = 0; p < percent.Length; p++) { string tmp = percent.Substring(p, 1); calculatorViewModel.enterDigitCommand.Execute(tmp); } calculatorViewModel.enterUnaryOperation.Execute("%"); Assert.AreEqual(calculatorViewModel.Display, Convert.ToString(number + i)); calculatorViewModel.enterClearCommand.Execute("C"); } return; }
public void sqRootTestMethod() { calculatorViewModel = new CalculatorViewModel(); for(int i=4; i<=16384; i=i*4 ) { string operand1 = Convert.ToString(i); for (int s = 0; s < operand1.Length; s++) { string temp = operand1.Substring(s, 1); calculatorViewModel.enterDigitCommand.Execute(temp); } calculatorViewModel.enterUnaryOperation.Execute("sqrt"); double result = Math.Sqrt(i); string referenceResult = Convert.ToString(result); Assert.AreEqual(calculatorViewModel.Display, referenceResult); calculatorViewModel.enterClearCommand.Execute("C"); } return; }
public void divisionByZeroTestMethod() { calculatorViewModel = new CalculatorViewModel(); for(int i=1; i<=10; i++) { try { calculatorViewModel.enterDigitCommand.Execute(Convert.ToString(i)); calculatorViewModel.enterBinaryOperationCommand.Execute("/"); calculatorViewModel.enterDigitCommand.Execute("0"); calculatorViewModel.enterEqualsCommand.Execute("="); Assert.AreEqual(calculatorViewModel.Display, "ERR"); calculatorViewModel.enterClearCommand.Execute("C"); } catch (Exception) { } } return; }
public App () { var viewModel = new CalculatorViewModel (); MainPage = new MainPage (); MainPage.BindingContext = viewModel; }
public NonfoodDFCalculator() { this.InitializeComponent(); ViewModel = new CalculatorViewModel(); this.DataContext = ViewModel; }
public void enterDigitsTestMethod() { calculatorViewModel = new CalculatorViewModel(); string inputSequence = ""; for (int i = 0; i < 10; i++) { string digit = Convert.ToString(i); inputSequence += digit; calculatorViewModel.enterDigitCommand.Execute(digit); } System.Diagnostics.Debug.WriteLine("inputSequence:" + inputSequence); Assert.AreEqual(inputSequence, calculatorViewModel.Display); }
/// <summary> /// Constructor /// </summary> /// <param name="viewModel">the view model</param> /// <exception cref="ArgumentNullException"/> public ResetCommand(CalculatorViewModel viewModel) { _viewModel = viewModel ?? throw new ArgumentNullException(nameof(viewModel));; }
public MainWindow() { InitializeComponent(); _calculatorViewModel = new CalculatorViewModel(); DataContext = _calculatorViewModel; }
public void initializationTestMethod() { calculatorViewModel = new CalculatorViewModel(); Assert.AreEqual("0", calculatorViewModel.Display); }
public ActionResult Index(CalculatorViewModel data) { data.UpdateData(); return View(data); }
public CalculatorWindow() { InitializeComponent(); DataContext = new CalculatorViewModel(); }
public void SetUp() { this.parsing = new Parsing(); this.calculation = new Calculation(); this.testee = new CalculatorViewModel(this.parsing, this.calculation); }
public void TestInitialize() { this.calculator = new CalculatorViewModel( new BuiltInRandom()); }