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