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());
}
