public void GetLastActSymIndex_WhenExpressionIsNull_ReturnMinusOne(string expression)
{
//Arrange
var calc = new CalculateExpression();
//Action
var reternedIndex = calc.GetStartIndexOfLastNumber(expression);
//Assert
Assert.AreEqual(-1, reternedIndex);
}
public void GetLastActSymIndex_WhenActionSymbolExist_ReturnRightIndex(string expression, int index)
{
//Arrange
var calc = new CalculateExpression();
//Action
var reternedIndex = calc.GetStartIndexOfLastNumber(expression);
//Assert
Assert.AreEqual(index, reternedIndex);
}
[DataRow("58+578-2*8", 8, "2")] // When left number from index is last
public void GetLeftNumber_WhenLeftNumberIsFirstMiddleLast_ReturnLeftNumber(string expression, int index, string leftNumber)
{
//Arrange
var calc = new CalculateExpression();
//Action
var returnedLeftNumber = calc.GetLeftNumber(expression, index);
//Assert
Assert.AreEqual(leftNumber, returnedLeftNumber);
}
public void GetResult_WhenExpressionIsNull_ReturnZero(string expression)
{
//Arrange
var calc = new CalculateExpression();
//Action
var calculatedResult = calc.GetResult(expression);
//Assert
Assert.AreEqual(calculatedResult, 0);
}
public void GetResult_CompareCalculatedResult_ReturnEqualResult(string expression, float result)
{
//Arrange
var calc = new CalculateExpression();
//Action
var calculatedResult = calc.GetResult(expression);
//Assert
Assert.AreEqual(calculatedResult, result);
}
public void GetRightNumber_WhenExpIsNull_ReturnNull(string expression)
{
//Arrange
var calc = new CalculateExpression();
//Action
var returnedRightNumber = calc.GetRightNumber(expression, 5);
//Assert
Assert.AreEqual(null, returnedRightNumber);
}
static void Main()
{
while (true)
{
Console.WriteLine("Введите математическое выражение для вычисления. Для выхода напишите exit");
string s = Console.ReadLine();
if (s == "exit")
{
return;
}
double result = CalculateExpression.Calculate(s);
Console.WriteLine(double.IsNaN(result) ? "Неправильный формат ввода" : $"{result:0.000}");
}
}
private void btnEquals_Click(object sender, EventArgs e)
{
if (String.IsNullOrEmpty(_expression.ToString()))
{
return;
}
try
{
textBoxDisplay.Text = CalculateExpression.Calculate(_expression.ToString());
}
catch (System.Data.SyntaxErrorException)
{
textBoxDisplay.Text = "Syntax error";
}
}
public void TestToFail_TestToFail()
{
//Arrange
CalculateExpression calculateExpression = new CalculateExpression();
BinaryExpression ExpressionTree = null;
MyExpressionVisitor myExpressionVisitor = new MyExpressionVisitor();
string TestToPassExpression = "1 + 1";
//Act
ExpressionTree = calculateExpression.CalculateValidExpression(TestToPassExpression, ExpressionTree, myExpressionVisitor);
var results = Expression.Lambda(ExpressionTree).Compile().DynamicInvoke();
//Assert
Assert.Fail();
}
public void TestBoundaries()
{
//Arrange
CalculateExpression calculateExpression = new CalculateExpression();
BinaryExpression ExpressionTree = null;
MyExpressionVisitor myExpressionVisitor = new MyExpressionVisitor();
string TestToPassExpression = "999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 1 +";
//Act
ExpressionTree = calculateExpression.CalculateValidExpression(TestToPassExpression, ExpressionTree, myExpressionVisitor);
var results = Expression.Lambda(ExpressionTree).Compile().DynamicInvoke();
//Assert
Assert.AreEqual(1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00, results);
}
public void TestToFail_DivideByZero()
{
//Arrange
CalculateExpression calculateExpression = new CalculateExpression();
MyExpressionVisitor myExpressionVisitor = new MyExpressionVisitor();
Validation validation = new Validation();
string TestToFailExpression = "1 1 + 0 /";
bool IsValidExpression = false;
//Act
bool results = validation.IsValid(TestToFailExpression, IsValidExpression);
//Assert
Assert.AreEqual(false, results);
}
public void TestAddingTwoPlusTwo() =>
Assert.AreEqual("4", CalculateExpression.Calculate("2+2"));
public void TestConvertingToRpnMoreComplexFormula() =>
Assert.AreEqual("2 2 2 * + 2 2 / - 4 * 6 + 2 -", CalculateExpression.ConvertToRPN("(2+2*2-2/2)*4+6-2"));
public void TestConvertingToRpnWithParanthesis() =>
Assert.AreEqual("2 2 + 2 *", CalculateExpression.ConvertToRPN("(2+2)*2"));
public void TestWrongEquation() =>
CalculateExpression.Calculate("(2+4-5");
public float GetResult(string expression)
{
var calc = new CalculateExpression();
return(calc.GetResult(expression));
}
public void TestOperationPriorityTwoPlusTwoTimesTwoWithParanthesis() =>
Assert.AreEqual("8", CalculateExpression.Calculate("(2+2)*2"));
public static ArithmeticExpression Calculate(CalculateExpression left, OpFlag op, CalculateExpression right)
{
var e = new ArithmeticExpression();
e.op = op;
e.Left = left;
e.Right = right;
left.Parent = e;
left.childPos = childLeft;
right.Parent = e;
right.childPos = childRight;
return e;
}
public void TestDivisionNineByThree() =>
Assert.AreEqual("3", CalculateExpression.Calculate("9/3"));
public void TestMultiplicationNineTimesFive() =>
Assert.AreEqual("45", CalculateExpression.Calculate("9*5"));
public void TestSubstractionFourMinusTwo() =>
Assert.AreEqual("2", CalculateExpression.Calculate("4-2"));
public async Task <double> Execute(CalculateExpression command)
{
return((double)await _handler.Execute(command));
}
public void TestCalculationWithDifferentOperations() =>
Assert.AreEqual("693", CalculateExpression.Calculate("33*22-33"));
public void TestComplexEquationWithAllOperations() =>
Assert.AreEqual("24", CalculateExpression.Calculate("(2+2*2-2/2)*4+6-2"));
public void TestOperationPriorityTwoPlusTwoTimesTwo() =>
Assert.AreEqual("6", CalculateExpression.Calculate("2+2*2"));
public string PurchaseSave(Purchase purchase)
{
decimal PurchaseSum = 0; //сумма покупки
int CoinsSum = 0; //сумма внесенных монет
//обновляем напитки
List <DrinkLine> drinkLines = purchase.DrinkLines;
for (int i = 0; i < drinkLines.Count; i++)
{
Drink drink = db.Drinks.FirstOrDefault(x => x.Id == drinkLines[i].drink.Id);
if (drink != null)
{
drink.Quantity = drink.Quantity - drinkLines[i].purchaseQuantity;
PurchaseSum += drink.Price;
db.Update(drink);
db.SaveChanges();
}
}
//обновляем количество монет
List <CoinLine> coinLines = purchase.CoinLines;
for (int i = 0; i < coinLines.Count; i++)
{
Coin coin = db.Coins.FirstOrDefault(x => x.Name == coinLines[i].coin.Name);
if (coin != null)
{
coin.Quantity = coin.Quantity + coinLines[i].purchaseQuantity;
CoinsSum += coinLines[i].purchaseQuantity * coin.Name;
db.Update(coin);
db.SaveChanges();
}
}
string OutCoinMessage = "";
decimal outCoinSum = CoinsSum - PurchaseSum; //сумма сдачи
if (outCoinSum > 0)
{
List <CoinLine> OutCoinList = CalculateExpression.OutCoin(outCoinSum, db.Coins.ToList());
//обновляем количество монет и формируем строку сдачи
if (!(OutCoinList == null))
{
coinLines = OutCoinList;
for (int i = 0; i < coinLines.Count; i++)
{
Coin coin = db.Coins.FirstOrDefault(x => x.Name == coinLines[i].coin.Name);
if (coin != null)
{
coin.Quantity = coin.Quantity - coinLines[i].purchaseQuantity;
OutCoinMessage = OutCoinMessage + " Монета: " + coinLines[i].coin.Name + ": количество: " + coinLines[i].purchaseQuantity;
db.Update(coin);
db.SaveChanges();
}
}
}
else
{
OutCoinMessage = "в автомате не достаточно монет для сдачи.";
}
}
return(OutCoinMessage);
}
