public void AddInt() { //Act _service.Calculate <int>(_inputSample); Assert.AreEqual("2", _inputSample.Result); }
public async void Calculator_CalculatesPrices() { var discounterFactory = new Mock <IDiscounterFactory>(); var calculator = new CalculatorService(discounterFactory.Object); var products = new List <Product>() { new Product { Name = "bread", Quantity = 1, Price = new Price { Amount = 1.00m } }, new Product { Name = "butter", Quantity = 1, Price = new Price { Amount = 0.8m } }, new Product { Name = "milk", Quantity = 1, Price = new Price { Amount = 1.15m } } }; var basket = new Basket { Products = products }; discounterFactory .Setup(f => f.GetDiscounter(It.IsAny <Product>())) .Returns <IDiscounterService>(null); var receipt = await calculator.Calculate(basket); Assert.True(receipt.Total == 2.95m); }
public void Calculate_PassesValidation_ReturnsExpectedResult() { // Arrange var calculatorService = new CalculatorService(_logger.Object); var calculation = new Mock <ICalculation <decimal> >(MockBehavior.Strict); var validationResult = new ValidationResult { IsValid = true }; calculation.Setup(x => x.Validate()).Returns(validationResult); calculation.Setup(x => x.Calculate()).Returns(0.55M); calculation.Setup(x => x.GetInputsForLogMessage()).Returns("SomeInputs"); // Act var result = calculatorService.Calculate(calculation.Object); // Assert var expected = new CalculationResult <decimal> { Value = 0.55M, Validation = validationResult }; result.Should().BeEquivalentTo(expected); calculation.Verify(x => x.Validate(), Times.Once); calculation.Verify(x => x.Calculate(), Times.Once); _logger.VerifyInformationWasCalled("[CALCULATION] Type: ICalculation`1Proxy | Inputs: SomeInputs | Result: 0.55"); }
public void Calculate_FailsValidation_ReturnsExpectedResult() { // Arrange var calculatorService = new CalculatorService(_logger.Object); var calculation = new Mock <ICalculation <decimal> >(MockBehavior.Strict); var validationResult = new ValidationResult { IsValid = false, Errors = new List <Error> { new Error { ErrorCode = ErrorCode.InvalidParameters } } }; calculation.Setup(x => x.Validate()).Returns(validationResult); // Act var result = calculatorService.Calculate(calculation.Object); // Assert var expected = new CalculationResult <decimal> { Validation = validationResult }; result.Should().BeEquivalentTo(expected); calculation.Verify(x => x.Validate(), Times.Once); _logger.VerifyNoOtherCalls(); }
public void CalculateTest() { _calculatorService.ValidateInput(@"\n2,5"); var result = _calculatorService.Calculate(); Assert.AreEqual(result, 7); }
public async Task <ActionResult <double> > Get([FromQuery] string expression, [FromServices] HistoryService historyService, [FromServices] CalculatorService calculator) { string history = string.Empty; try { double result = calculator.Calculate(expression); history = $"{expression} = {result}"; return(Ok(result)); } catch (DivideByZeroException ex) { history = ex.Message; return(BadRequest(ex.Message)); } catch (ArgumentException ex) { history = ex.Message; return(BadRequest($"Incorrect input, please, try again\n{expression}\n{ex.Message}")); } catch (Exception ex) { return(BadRequest($"Something went wrong, please, try again later\n{ex.Message}")); } finally { await historyService.Append(history); } }
public void GivenAnAdditionLine_WithZeroPlusOne_ExpectAdditonMethodCalledWithZeroAndOne() { //Arrange var firstNumber = 0; var secondNumber = 1; var expectedAddResult = 9999; A.CallTo(() => fakeAdditionService.Add(firstNumber, secondNumber)).Returns(expectedAddResult); //Act var result = _calculatorService.Calculate('+', firstNumber, secondNumber); //Assert //check there is a call to the addition service add method with correct first number and second number A.CallTo(() => fakeAdditionService.Add(firstNumber, secondNumber)).MustHaveHappenedOnceExactly(); Assert.That(result, Is.EqualTo(expectedAddResult)); }
public Sum Calculate(Sum sum) { try { sum = service.Calculate(sum.Num1, sum.Num2, sum.OperatorString); return(sum); } catch (Exception) { return(null); } }
public void Run() { var operation = new OperationService(); var alert = new Alert(); var calc = new CalculatorService(); calc.Calculate(operation.Add, 3, 5, alert.DisplayEquation, operation.AddString); calc.Calculate(operation.Subtract, 3, 5, alert.DisplayEquation, operation.SubtractString); calc.CalculateV2(operation.Add, 3, 5, alert.DisplayEquation, operation.AddString); calc.CalculateV2(operation.Subtract, 3, 5, alert.DisplayEquation, operation.SubtractString); calc.CalculateV2( (left, right) => left + right, 3, 5, (left, right, operation, answer) => Console.WriteLine($"{left} {operation} {right} = {answer}"), () => "+"); List <object> obj = new List <object>(); }
public void ProcessTransactions(int singleReadLineCount) { List <Transaction> transactions; while ((transactions = _fileService.ReadTransactions(_config.FilePath, singleReadLineCount)).Count != 0) { foreach (var transaction in transactions) { _calculatorService.Calculate(transaction); TransactionProcessed? .Invoke(this, new TransactionProcessedEventArgs(transaction.MerchantName, transaction.Date, transaction.Fee)); } } }
public void GivenATwoTransactionsInTheSameMonthWithTheSameMerchantNameOnlyFirstTransactionWillContainInvoiceFee() { // Arrange var config = FeeCalculatorConfig.Instance; var service = new CalculatorService(config); var transactionA = new Transaction() { MerchantName = "MerchantNameString", Date = DateTime.Parse("2019-01-01"), Amount = 100, }; var transactionB = new Transaction() { MerchantName = "MerchantNameString", Date = DateTime.Parse("2019-01-02"), Amount = 100, }; var ruleA = service.FindRule(transactionA.MerchantName); var ruleB = service.FindRule(transactionB.MerchantName); var feeA = ((transactionA.Amount - (transactionA.Amount / 100 * ruleA.Discount)) / 100 * ruleA.Fee) + ruleA.InvoiceFee; var feeB = (transactionB.Amount - (transactionB.Amount / 100 * ruleB.Discount)) / 100 * ruleB.Fee; // Act service.Calculate(transactionA); service.Calculate(transactionB); // Assert Assert.NotNull(transactionA); Assert.NotNull(transactionB); Assert.IsTrue(transactionA.Fee == feeA); Assert.IsTrue(transactionB.Fee == feeB); }
public void Calculate(string operation) { PlaySoundService.PlaySound(AppSoundsEnum.DigitalButton); var addNew = !_operands.Any() || (_operands.Count - _operators.Count) == 0; switch (operation) { case "0": case "1": case "2": case "3": case "4": case "5": case "6": case "7": case "8": case "9": if (addNew) { _operands.Push(operation); } else { var lastOperand = _operands.Pop(); _operands.Push(lastOperand + operation); } break; case "-": _operators.Push(CalculatorOperatorsEnum.Minus); break; case "+": _operators.Push(CalculatorOperatorsEnum.Plus); break; case "=": _operators.Push(CalculatorOperatorsEnum.Equal); break; case "C": _operators.Clear(); _operands.Clear(); break; } OutputResult = CalculatorService.Calculate(_operands.ToList(), _operators.ToList()); }
protected async Task Calculate() { if (input.IsValid()) { totalDepositsColVisible = input.MonthlyDeposit.HasValue && input.MonthlyDeposit.Value > 0; input.BaseAmount ??= 0; input.MonthlyDeposit ??= 0; result = CalculatorService.Calculate( input.BaseAmount.Value, input.InterestRatePercent.Value, input.CompoundInterval, input.MonthlyDeposit.Value, input.CalcPeriodYrs.Value); await JSRuntime.InvokeVoidAsync("jsFunctions.scrollToResults"); } }
public void GivenATransactionCalculatesFees() { // Arange var config = FeeCalculatorConfig.Instance; var service = new CalculatorService(config); var transaction = new Transaction() { MerchantName = "MerchantNameString", Date = DateTime.Now, Amount = 100, }; var rule = service.FindRule(transaction.MerchantName); var fee = ((transaction.Amount - (transaction.Amount / 100 * rule.Discount)) / 100 * rule.Fee) + rule.InvoiceFee; // Act service.Calculate(transaction); // Assert Assert.NotNull(transaction); Assert.IsTrue(transaction.Fee == fee); }
public async void Calculator_CalculatesPricesWithDiscount() { var butterDiscounter = new Mock <IDiscounterService>(); var discounterFactory = new Mock <IDiscounterFactory>(); var calculator = new CalculatorService(discounterFactory.Object); var butter = new Product { Name = "butter", Quantity = 2, Price = new Price { Amount = 0.80m } }; var bread = new Product { Name = "bread", Quantity = 1, Price = new Price { Amount = 1.00m } }; var products = new List <Product>() { butter, bread }; var basket = new Basket { Products = products }; discounterFactory .Setup(f => f.GetDiscounter(It.Is <Product>(p => p.Name == "butter"))) .Returns(butterDiscounter.Object); butterDiscounter .Setup(d => d.ApplyDiscountAsync(It.IsAny <Receipt>())) .Callback((Receipt r) => { r.Total -= bread.Price.Amount / 2; }) .Returns(Task.Delay(0)); var receipt = await calculator.Calculate(basket); Assert.Equal(2.10m, receipt.Total); }
static void Main(string[] args) { if (args.Length < 1 || args.Length > 2) { Usage(); return; } var numbers = args[0]; // Per STEP-10: Allow specifying an operation. var operation = CalculatorOperation.Addition; if (args.Length == 2 && Enum.TryParse <CalculatorOperation>(args[1], out var enumResult)) { operation = enumResult; } var calculatorService = new CalculatorService(); var calcResult = calculatorService.Calculate(numbers, operation); Console.WriteLine($"Result: {calcResult}"); }
public void ShouldReturn0ForEmptyInput() { var result = calculatorService.Calculate(string.Empty); Assert.AreEqual(0, result); }
public void GetResultTest(string input, Operations operations, string[] delimiter, bool allowNegative, int max, string expectedResult) { var result = _addCalculator.Calculate(input, operations, delimiter, allowNegative, max); Assert.Equal(expectedResult, result); }
// POST: api/Balance public BalanceOutput Post([FromBody] BalanceInput balanceInput) { CalculatorService calculatorService = new CalculatorService(); return(calculatorService.Calculate(balanceInput)); }