private int Calculate(string operation) { if (!ModelState.IsValid) { return(0); } switch (operation) { case "add": return(calc.Calculate( new AddOperation(Left, Right) )); case "subtract": return(calc.Calculate( new SubtractOperation(Left, Right) )); case "multiply": return(calc.Calculate( new MultiplyOperation(Left, Right) )); default: return(int.MinValue); } }
public ActionResult CombinedWith(decimal pa, decimal pb) { var calculation = new CombinedWithCalculation(pa, pb); var result = _calculatorService.Calculate(calculation); return(Ok(result)); }
public void GivenSpecialCondition_WhenEnterEarly_ThenReturnEarlyBirdRate() { List <CalculatorCase> cases = new List <CalculatorCase>() { // Edge case new CalculatorCase() { TimerData = new TimerDto() { Entry = new DateTime(2017, 1, 2, 6, 0, 0), Exit = new DateTime(2017, 1, 2, 15, 30, 0) }, Expected = new ParkingRateDto() { Name = "Early Bird", Price = 13 } }, // Edge case new CalculatorCase() { TimerData = new TimerDto() { Entry = new DateTime(2017, 1, 2, 9, 0, 0), Exit = new DateTime(2017, 1, 2, 23, 30, 0) }, Expected = new ParkingRateDto() { Name = "Early Bird", Price = 13 } }, new CalculatorCase() { TimerData = new TimerDto() { Entry = new DateTime(2017, 1, 2, 7, 0, 0), Exit = new DateTime(2017, 1, 2, 10, 00, 0) }, Expected = new ParkingRateDto() { Name = "Early Bird", Price = 13 } } }; foreach (var c in cases) { var result = _calculatorService.Calculate(c.TimerData).Result; Assert.AreEqual(c.Expected.Name, result.Name); Assert.AreEqual(c.Expected.Price, result.Price); } }
public void CalculationIsCorrect_BaseAmount(double baseAmount, double interestRatePercent, CompoundInterval compoundInterval, double monthlyDeposit, short calcPeriodYrs, double lastExpectedTotalDeposits, double lastExpectedYearInterest, double lastExpectedTotalInterest, double lastExpectedBalance) { CalculationResult[] result = _sut.Calculate(baseAmount, interestRatePercent, compoundInterval, monthlyDeposit, calcPeriodYrs); CalculationResult lastYear = result.Last(); Assert.Equal(lastExpectedTotalDeposits, lastYear.TotalDeposits); Assert.Equal(lastExpectedYearInterest, lastYear.YearInterest); Assert.Equal(lastExpectedTotalInterest, lastYear.TotalInterest); Assert.Equal(lastExpectedBalance, lastYear.Balance); }
public void Calculate_Given_Calculation_Type_And_Numbers_When_Add_Then_Return_Correct_Result() { // Arrange operationServiceMock .Setup(x => x.Add(It.IsAny <decimal>(), It.IsAny <decimal>())) .Returns(4); // Act var result = sut.Calculate(OperationType.Add, 2m, 2m); // Assert result.Should().Be(4); }
public void Calculate_WhenCall_ReturnedResult() { const decimal expectedValue = 5; var data = new CalculationData { MathOperation = MathOperations.Multiply, Operand1 = 1, Operand2 = 1 }; _providerMock.Setup(x => x.Get(It.IsAny <MathOperations>())).Returns((x, y) => expectedValue); var result = _service.Calculate(data); Assert.IsTrue(result.IsOk); Assert.AreEqual(expectedValue, result.Value); }
public void OnNavigatedTo(NavigationParameters parameters) { if (parameters.ContainsKey("calculationInput")) { CalculationInput = (CalculationInput)parameters["calculationInput"]; CalculationOutput = (CalculationOutput)_calculatorService.Calculate(_calculationInput); if (parameters.ContainsKey("Summary")) { if ((bool)parameters["Summary"]) { OriginalWorkingDistance = CalculationInput.WorkingDistance; OriginalIncidentEnergy = CalculationOutput.IncidentEnergy; } } //InitResultP1(); //InitResultP2(); //InitResultP3(); //InitResults(); //_eventAggregator.GetEvent<CalculationInputUpdated>().Subscribe(HandleCalculationInputUpdated); InitResultP1(); InitResultP2(); InitResultP3(); InitResults(); } }
public async Task <ActionResult <MessageModel> > Test(CalculatorRequestModel request) { var cur1 = request.Curr1; var cur2 = request.Curr2; return(await _calculatorService.Calculate(cur1, cur2)); }
private static void Calculate(ICalculatorService calculator) { Console.WriteLine("Enter expression:"); var name = Console.ReadLine(); var result = calculator.Calculate(name); Console.WriteLine("Result: {0}", result); }
public void EarlyEntry_EarlyExit_RateTest() { List <CalculatorCase> testCases = new List <CalculatorCase>() { new CalculatorCase() { TimerData = new TimerDto() { Entry = new DateTime(2020, 7, 6, 6, 0, 0), Exit = new DateTime(2020, 7, 6, 15, 30, 0) }, ExpectedData = new ParkingRateDto() { Name = "Early Bird", Price = 13 } }, new CalculatorCase() { TimerData = new TimerDto() { Entry = new DateTime(2020, 7, 6, 9, 0, 0), Exit = new DateTime(2020, 7, 6, 23, 30, 0) }, ExpectedData = new ParkingRateDto() { Name = "Early Bird", Price = 13 } }, new CalculatorCase() { TimerData = new TimerDto() { Entry = new DateTime(2020, 7, 6, 7, 0, 0), Exit = new DateTime(2020, 7, 6, 10, 30, 0) }, ExpectedData = new ParkingRateDto() { Name = "Early Bird", Price = 13 } } }; foreach (var c in testCases) { var result = _calculatorService.Calculate(c.TimerData).Result; Assert.AreEqual(c.ExpectedData.Name, result.Name); Assert.AreEqual(c.ExpectedData.Price, result.Price); } }
public async Task <IHttpActionResult> Post(Calculation calculation) { _calculatorService.Calculate(calculation.CalculationString); // _calculationService.Add(calculation); // await _calculationService.SaveChangesAsync(); return(Ok(calculation.CalculationString + " added to database")); }
private void equal_Click(object sender, System.EventArgs e) { if (!calculatorService.Calculate()) { return; } SetInputValue(calculatorService.Input); }
public async Task <string> ProcessAsync(TimerDto input) { var response = await _calculatorService.Calculate(input); var result = "\nPackage : " + response.Name + "\nTOTAL COST : " + response.Price.ToString("C"); return(result); }
public IActionResult Post(CalculatorRequestDto calculatorRequestDto) { if (ModelState.IsValid) { var result = _calculatorService.Calculate(calculatorRequestDto); return(Ok(result)); } return(BadRequest(ModelState)); }
public IHttpActionResult Calculate(decimal[] values) { try { return(Ok(new { status = "success", result = _calculatorService.Calculate(values) })); } catch (Exception ex) { return(Ok(new { status = "error", result = ex.Message })); } }
public void OnNavigatedTo(NavigationParameters parameters) { if (parameters.ContainsKey("calculationInput")) { CalculationInput = (CalculationInput)parameters["calculationInput"]; CalculationOutput = (CalculationOutput)_calculatorService.Calculate(_calculationInput); InitList(); initCarousel(); ItemSource = new List <int>(); } }
//public CalculatorController(ICalculatorService calculatorService) //{ // _calculatorService = calculatorService; //} // [System.Web.Http.HttpGet("Calculate")] public IHttpActionResult Calculate(CalculateParams param) { var result = _calculatorService.Calculate(param.Sign, param.FirstValue, param.SecondValue); var resultData = new ResultData { Result = result, ErrorMessage = string.Empty }; return(Ok(resultData)); }
public int StringCalculator(string input) { if (input.Contains("-")) { throw new System.ArgumentException("Must be positive number"); } if (String.IsNullOrWhiteSpace(input)) { return(0); } if (input.Contains(",") || input.Contains("\n")) { return(_calculatorService.Calculate(input)); // char[] separator = {',', '\n'}; // var numbers = input.Split(separator); // var sum = 0; // foreach (var number in numbers) // { // var convertedInt = Convert.ToInt32(number); // if (convertedInt <= 1000) // sum += convertedInt; // } // return sum; } // if (input.Contains(",")) // { // var numbers = input.Split(','); // var sum = 0; // foreach (var number in numbers) // { // sum += Convert.ToInt32(number); // } // return sum; // } // if (input.Contains("\n")) // { // var numbers = input.Split('\n'); // var sum = 0; // foreach (var number in numbers) // { // sum += Convert.ToInt32(number); // } // return sum; // } return(Convert.ToInt32(input)); }
public OperationResult Calculate(CalculationRequest request) { var validationResult = _calculationRequestValidator.Validate(request); if (!validationResult.IsOk) { return(new OperationResult(validationResult.ErrorMessage)); } var calculationData = ParseRequest(request); return(_calculator.Calculate(calculationData)); }
public async Task <IActionResult> Post([FromBody] CalculateRequestDto requestDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (requestDto.ShippingToCountryIso == "CA" && String.IsNullOrEmpty(requestDto.CanadianProvinceCode)) { return(BadRequest("You must specify the property CanadianProvinceCode with a valu for Canadian calculations")); } return(Ok(_calculatorService.Calculate(requestDto))); }
public void RefinancingLoanWithNoFees() { var requestModel = new RefinancingLoanRequestModel { LoanAmount = 1000, Interest = 10, Period = 12, CountOfPaidInstallments = 2, EarlyInstallmentsFee = 0, NewInterest = 2, StartingFeesCurrency = 0, StartingFeesPercent = 0 }; var actual = _service.Calculate(requestModel, null); var expected = new RefinancingLoanResponseModel { Status = System.Net.HttpStatusCode.OK, CurrentLoan = new RefinancingLoanHelperModel { Interest = 10, Period = 12, EarlyInstallmentsFee = 0, MonthlyInstallment = 87.92M, //Total = 879.16M Total = 879.20M }, NewLoan = new RefinancingLoanHelperModel { Interest = 2, Period = 10, EarlyInstallmentsFee = 0, //MonthlyInstallment = 84.79M, MonthlyInstallment = 84.77M, //Total = 847.89M Total = 847.70M } }; Assert.AreEqual(actual, expected); }
private void CalculateClick(bool clicked) { if (clicked) { HasStandardWorkingDistance = !CalculationInput.HasCustomWorkingDistance; CalculationOutput = _calculatorService.Calculate(CalculationInput) as CalculationOutput; CalculationOutput.IncidentEnergy = Math.Round(CalculationOutput.IncidentEnergy, 2, MidpointRounding.ToEven); WorkingDistanceRounded = Math.Round(CalculationInput.WorkingDistance.Value, 2, MidpointRounding.ToEven); OverFortyCal = CalculationOutput.IncidentEnergy > 40.00m; IsLevelZero = CalculationOutput.IncidentEnergy <= 1.2m; IsLevelTwo = CalculationOutput.IncidentEnergy > 1.2m && CalculationOutput.IncidentEnergy <= 8; IsLevelFour = CalculationOutput.IncidentEnergy > 8 && CalculationOutput.IncidentEnergy <= 40; ShowFindSafeWorkingDistance = OverFortyCal || CalculationInput.HasCustomWorkingDistance; _eventAggregator.GetEvent <CalculationOutputUpdated>().Publish(CalculationOutput); } }
public async Task <IActionResult> GetAsync(string left, string right, string operation) { var responce = new Dictionary <string, string>(); try { var result = _calculator.Calculate(left, right, operation); var id = await _resultsRepository.Save(result); _logger.LogInformation($"Result: {result}, Id: {id}"); responce.Add("result", result); responce.Add("id", id); return(new JsonResult(responce)); } catch (Exception e) { _logger.LogError(e, $"Error: {e.Message}"); responce.Add("error", e.Message); return(new JsonResult(responce)); } }
public IActionResult Post([FromBody] RequestDto request) { return(new OkObjectResult(calculatorService.Calculate(request))); }
public ActionResult <CloudCombinationResultDTO> Calculate([FromBody] CloudCombinationDTO cloudCombination) { return(_calculatorService.Calculate(cloudCombination)); }
public LeasingLoanResponseModel CalculateLeasingLoan([FromBody] LeasingLoanRequestModel requestModel) { string cookieValue = Request.Cookies["Auth-Tst"]; return(_leasingLoanService.Calculate(requestModel, cookieValue)); }
public RefinancingLoanResponseModel CalculateRefinancingLoan([FromBody] RefinancingLoanRequestModel requestModel) { string cookieValue = Request.Cookies["Auth-Tst"]; return(_refinancingLoanService.Calculate(requestModel, cookieValue)); }
public void ExpressionCalculate_Success(string expression, double expectedResult) { var actualResult = calculatorService.Calculate(expression); Assert.AreEqual(expectedResult, actualResult); }
public void TestCalculate2Numbers() { var result = _calculatorService.Calculate("1,2"); Assert.IsTrue(result == 3); result = _calculatorService.Calculate("20"); Assert.IsTrue(result == 20); result = _calculatorService.Calculate("5,dfaadf"); Assert.IsTrue(result == 5); }
public void PushOperator(string op) { CalculatorService.Calculate(op); }