public double CalculateEquation(string equation)
{
var numberCharacterBuilder = new StringBuilder();
var numbers = new List <int>();
var operators = new List <char>();
double result = 0;
int counter = 0;
var Operation = new OperatorFactory();
calcManager = new CalculationManager();
var updatedPreviousResult = 0;
var updatedCurrentValue = 0;
foreach (var character in equation)
{
if (EquationHelper.IsCharacterNumber(character))
{
numberCharacterBuilder.Append(character);
}
else
{
if (NumbersListValidator.IsListEmpty(numbers))
{
updatedPreviousResult = UpdateCalcManagerPrevious(numbers, numberCharacterBuilder.ToString());
numberCharacterBuilder.Clear();
}
else
{
updatedCurrentValue = UpdateCalcManagerCurrent(numbers, numberCharacterBuilder.ToString());
numberCharacterBuilder.Clear();
var NextOperation = Operation.GetOperator(operators[counter - 1]);
result = NextOperation.DoMaths(updatedPreviousResult, updatedCurrentValue);
updatedPreviousResult = UpdateCalcManagerPrevious(numbers, result.ToString());
}
counter++;
operators.Add(character);
}
}
updatedCurrentValue = UpdateCalcManagerCurrent(numbers, numberCharacterBuilder.ToString());
var LastOperation = Operation.GetOperator(operators[operators.Count() - 1]);
result = LastOperation.DoMaths(updatedPreviousResult, updatedCurrentValue);
return(result);
}
public void TryingToGetHigherOperator()
{
OperatorFactory factory = GetOperatorFactory();
Operator op = factory.GetOperator(OperatorKeys.HigherKey);
Assert.IsTrue(op.IsSameOperator(Operator.higher));
}
public void TryingToGetLessOperator()
{
OperatorFactory factory = GetOperatorFactory();
Operator op = factory.GetOperator(OperatorKeys.LessKey);
Assert.IsTrue(op.IsSameOperator(Operator.less));
}
public void TryingToGetEqualOperator()
{
OperatorFactory factory = GetOperatorFactory();
Operator op = factory.GetOperator(OperatorKeys.EqualKey);
Assert.IsTrue(op.IsSameOperator(Operator.equal));
}
public void Can_GetOperator(Type expectedType, OperatorType operatorType)
{
// Arrange
var service = new OperatorFactory(new List <IOperatorService> {
new AddOperatorService(),
new SubtractOperatorService(),
});
// Act
var operatorService = service.GetOperator(operatorType);
// Assert
Assert.IsType(expectedType, operatorService);
}
private void InitializeForm()
{
correctCount = 0;
incorrectCount = 0;
currentScore = 0;
topScore = GetLastTopScore();
timeTicker = timeLimit;
btnChkAnswer.Enabled = true;
label2.ForeColor = Color.DarkGreen;
label2.Text = timeTicker.ToString();
lblCorrect.Text = correctCount.ToString();
lblIncorrect.Text = incorrectCount.ToString();
lblTopScore.Text = topScore.ToString();
lblCurrentScore.Text = currentScore.ToString();
lblOutcome.Text = "";
history = new List <Tuple <string, string> >();
ops = OperatorFactory.GetOperator(cboOps.SelectedItem.ToString());
SetQuiz();
timer1.Start();
}
public static IEquationNode Calculation(string equation)
{
if (EquationHelper.IsWholeEquationWithinBrackets(equation) && EquationHelper.EquationContainsAnUnbracketedOperator(equation))
{
return(Calculation(equation.Substring(1, equation.Length - 2)));
}
if (EquationHelper.IsStringNumber(equation))
{
return(new Number(equation));
}
foreach (var op in EquationHelper.orderedOperators)
{
var bracketCounter = 0;
for (int i = 0; i < equation.Length; i++)
{
if (equation[i] == '(')
{
bracketCounter++;
}
else if (equation[i] == ')')
{
bracketCounter--;
}
if (equation[i] == op && bracketCounter == 0)
{
return(new EquationNode(
equation.Substring(0, i),
equation.Substring(i + 1),
Operation.GetOperator(equation[i])));
}
}
}
throw new InvalidEquationException("Equation is Invalid!");
}
private void CboOps_SelectedIndexChanged(object sender, EventArgs e)
{
ops = OperatorFactory.GetOperator(cboOps.SelectedItem.ToString());
}
public IOperation SetOperation(string operation)
{
_operatorTask = new OperatorTask(_operatorFactory.GetOperator(operation));
return(_operatorTask.GetOperation());
}
