public void TestMultiply()
{
CalculatorOperation cal = new CalculatorOperation();
int result = cal.Multiply(5, 4);
Assert.AreEqual(20, result);
}
public void PressButton(CalculatorOperation operation)
{
if (currentOperation == CalculatorOperation.None)
{
currentOperation = operation;
return;
}
if (operation == CalculatorOperation.Equals)
{
if (currentOperation == CalculatorOperation.None || currentOperation == CalculatorOperation.Equals)
{
throw new InvalidOperationException("Operation sequence is not correct");
}
double value2 = values.Pop();
double value1 = values.Pop();
if (currentOperation == CalculatorOperation.Plus)
{
double result = value1 + value2;
values.Push(result);
}
if (currentOperation == CalculatorOperation.Minus)
{
double result = value1 - value2;
values.Push(result);
}
}
}
public void AddOperation(CalculatorOperation op)
{
if (Operation == null)
{
LeftValue = RightValue;
OnDidChangeRight(this,
new CalculatorEventArgs("Левое значение приняло правое", null, RightValue, null));
RightValue = null;
OnDidChangeLeft(this,
new CalculatorEventArgs("Правое значение обнулено", null, null, null));
Operation = op;
OnDidChangeOperation(this,
new CalculatorEventArgs("Изменился оператор", null, null, Operation));
}
else if (Operation != null)
{
Compute();
OnDidCompute(this,
new ComputeEventArgs(LeftValue.Value, RightValue.Value, Operation.Value, Result.Value));
LeftValue = Result;
OnDidChangeRight(this,
new CalculatorEventArgs("Левое значение приняло результат", Result, null, null));
RightValue = null;
OnDidChangeLeft(this,
new CalculatorEventArgs("Правое значение обнулено", null, null, null));
Operation = op;
OnDidChangeOperation(this,
new CalculatorEventArgs("Изменился оператор", null, null, Operation));
}
}
protected override void Execute(CodeActivityContext context)
{
FirstNumber.Set(context, 0);
SecondNumber.Set(context, 0);
Operation.Set(context, CalculatorOperation.Unknown);
String line = Expression.Get(context);
if (!String.IsNullOrEmpty(line))
{
String[] arguments = line.Split(' ');
if (arguments.Length == 3)
{
Double number = 0;
if (Double.TryParse(arguments[0], out number))
{
FirstNumber.Set(context, number);
}
CalculatorOperation op = CalculatorOperation.Unknown;
Enum.TryParse <CalculatorOperation>(arguments[1], out op);
Operation.Set(context, op);
if (Double.TryParse(arguments[2], out number))
{
SecondNumber.Set(context, number);
}
}
}
}
public void TestAdd()
{
CalculatorOperation cal = new CalculatorOperation();
int result = cal.Add(5, 4);
Assert.AreEqual(9, result);
}
//public override void ContinueExpression(CalculatorOperation operation)
//{
// return;
//}
public override void FinishExpression(CalculatorOperation operation)
{
CalculationOperation = operation;
CalculationOperation.Result = CalculationOperation.SecondArgument;
Expression = $"{calculator.CalculatorState.CalculationOperation.Result} = {calculator.CalculatorState.CalculationOperation.Result}";
Reset = true;
}
public string ExecuteOperation(CalculatorOperation operation)
{
var result = "";
switch (operation)
{
case CalculatorOperation.Add:
result = (num1 + num2).ToString("0.00");
break;
case CalculatorOperation.Subtract:
result = (num1 - num2).ToString("0.00");
break;
case CalculatorOperation.Multiply:
result = (num1 * num2).ToString("0.00");
break;
case CalculatorOperation.Divide:
if (num2 == 0)
{
result = "Invalid operation";
}
else
{
result = (num1 / num2).ToString("0.00");
}
break;
}
return(result);
}
public override void PerformOperation(CalculatorOperation operation)
{
CalculationOperation.ExecuteOperation = operation.ExecuteOperation;
CalculationOperation.OperationSymbol = operation.OperationSymbol;
Expression = Expression.Remove(Expression.Count() - 2, 2);
Expression += $"{CalculationOperation.OperationSymbol} ";
}
public void AddOperation(CalculatorOperation op)
{
countAfterPoint = 1;
isPoint = false;
if (LeftValue == null)
{
LeftValue = 0;
}
if (Operation != null)
{
if (RightValue != 0)
{
Compute();
}
}
else
{
LeftValue = RightValue;
OnDidChangeLeft?.Invoke(this, new CalculatorEventArgs("Left change", LeftValue, RightValue, Operation));
}
Operation = op;
RightValue = null;
OnDidChangeOperation?.Invoke(this, new CalculatorEventArgs("Change operation", LeftValue, RightValue, Operation));
}
public int Operation(int num1, int num2, CalculatorOperation calculatorOperation)
{
//Add if for num1/2
switch (calculatorOperation)
{
case CalculatorOperation.Add:
return(Add(num1, num2));
case CalculatorOperation.Subtract:
return(Add(num1, num2));
case CalculatorOperation.Divide:
return(Add(num1, num2)); // I know these are wrong.
case CalculatorOperation.Multiply:
return(Add(num1, num2));
case CalculatorOperation.Modulus:
return(Add(num1, num2));
default:
return(0);
}
}
public static int GetNextValue(int currentValue, CalculatorOperation operation, int number)
{
// Adjust the calculation for the current operation.
switch (operation)
{
case CalculatorOperation.Addition:
currentValue += number;
break;
case CalculatorOperation.Subtraction:
currentValue -= number;
break;
case CalculatorOperation.Multiplication:
currentValue *= number;
break;
case CalculatorOperation.Division:
// We'll ignore that integer division is error-prone for the purposes of this exercise.
currentValue /= number;
break;
default:
throw new ArgumentException($@"Unrecognized operation ""{operation}"".", nameof(operation));
}
return(currentValue);
}
private static void OnAdded(IAsyncResult itfAsyncResult)
{
AsyncResult asyncResult = (AsyncResult)itfAsyncResult;
CalculatorOperation operation = (CalculatorOperation)asyncResult.AsyncDelegate;
int result = operation.EndInvoke(itfAsyncResult);
Console.WriteLine("The result of the asynchronous invocation is also {0}.", result);
}
public void resultShouldBeThirteen()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
float result = calculatorOperation.add(7, 6);
Assert.That(result, Is.EqualTo(13));
}
public void resultShouldBeThirteenWhenPassSevenSix()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
float result = calculatorOperation.add(7, 6);
Assert.AreEqual(13, result);
}
public CalculationResponse Calculate(CalculatorOperation operation, double first, double second)
{
var result = _calculator.Calculate(operation, first, second);
return(new CalculationResponse {
Result = result
});
}
public void resultShouldBeThirteen()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
float result = calculatorOperation.add(7, 6);
Assert.That(result, Is.EqualTo(13));
}
public void resultShouldBeFortyTwoWhenPassSevenSix()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
float result = calculatorOperation.mul(7, 6);
Assert.AreEqual(42, result);
}
public void resultShouldBeThirteenWhenPassSevenSix()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
float result = calculatorOperation.add(7, 6);
Assert.AreEqual(13, result);
}
public void resultShouldBeFortyTwo()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
float result = calculatorOperation.mul(7, 6);
Assert.That(result, Is.EqualTo(42));
}
public void resultShouldBeFortyTwo()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
float result = calculatorOperation.mul(7, 6);
Assert.That(result, Is.EqualTo(42));
}
private CalculationTask CreateCalculationTask(CalculatorOperation item1, CalculatorOperation item2, string version)
{
var operationtask = calculatorServiceFinder.FindByCalculatorOperation(item2.Operation, version);
var continueWith = operationtask.ContinueWith(operation =>
httpClient.GetStringAsync(operation.Result, item2.Operation, item1.Value, item2.Value));
return(new CalculationTask(continueWith, item2.Operation));
}
public void CalculatorOperationTest6()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
List <string> input = new List <string> {
"5", "+", "6", "+"
};
Assert.ThrowsException <System.FormatException>(() => calculatorOperation.PerformCalculation(input));
}
public void TestDivide()
{
CalculatorOperation cal = new CalculatorOperation();
int numerator = 4;
int denominator = 0;
int actualResult;
actualResult = cal.Divide(numerator, denominator);
}
public override void FinishExpression(CalculatorOperation operation)
{
CalculationOperation.SecondArgument = operation.SecondArgument;
CalculationOperation.Result = CalculationOperation.ExecuteOperation(CalculationOperation.FirstArgument, CalculationOperation.SecondArgument);
Expression += $" {operation.SecondArgument} = {CalculationOperation.Result}";
calculator.CalculatorState = new InitialState(calculator);
calculator.CalculatorState.CalculationOperation = CalculationOperation;
calculator.CalculatorState.Expression = Expression;
}
static void Main(string[] args)
{
double radius = 1.5;
var c1 = new Circle(radius);
var output = new CalculatorOperation();
output.Write(radius, c1);
}
public void resultShouldBeFortyTwoWhenPassSevenSix()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
float result = calculatorOperation.mul(7, 6);
Assert.AreEqual(42, result);
}
public CalculatorResult(CalculatorOperation operation, long result)
{
if (operation == null)
{
throw new ArgumentNullException("operation");
}
_id = operation._id;
_result = result;
}
private static void TesAdd(string input, int expectedREsult)
{
//Arrange
CalculatorOperation cal = new CalculatorOperation();
//Act
var result = cal.Add(input);
//Assert
Assert.AreEqual(expectedREsult, result);
}
public void ShouldInitializeStoreStateWithFirstValue(int value, CalculatorOperation operation)
{
var store = NewCalculator();
store.CommitNumber(value, operation);
var storeCurrentValue = GetCurrentCalculatorValue(store);
Assert.IsTrue(storeCurrentValue.HasValue);
Assert.AreEqual(value, storeCurrentValue);
}
public void CalculatorOperationTest2()
{
CalculatorOperation calculatorOperation = new CalculatorOperation();
List <string> input = new List <string> {
"5", "2", "*", "10", "+"
};
var actualResult = calculatorOperation.PerformCalculation(input);
var expectedResult = 20;
Assert.AreEqual(expectedResult, actualResult);
}
public void ShouldReturnSumAfterTwoDigitsAdded(CalculatorOperation operation, int[] numbers, int expectedValue)
{
var store = NewCalculator();
foreach (var number in numbers)
{
store.CommitNumber(number, operation);
}
var result = store.GetResult();
Assert.AreEqual(expectedValue, result);
}
public override void PerformOperation(CalculatorOperation operation)
{
calculator.CalculatorState = new OperationChoosingState(calculator);
calculator.CalculatorState.CalculationOperation = new CalculatorOperation
{
FirstArgument = operation.SecondArgument,
ExecuteOperation = operation.ExecuteOperation,
OperationSymbol = operation.OperationSymbol,
Result = operation.SecondArgument
};
calculator.CalculatorState.Expression = $"{calculator.CalculatorState.CalculationOperation.FirstArgument} {calculator.CalculatorState.CalculationOperation.OperationSymbol} ";
}
public override void PerformOperation(CalculatorOperation operation)
{
CalculationOperation.SecondArgument = operation.SecondArgument;
CalculationOperation.Result = CalculationOperation.ExecuteOperation(CalculationOperation.FirstArgument, CalculationOperation.SecondArgument);
calculator.CalculatorHistory?.AddToHistory(CalculationOperation);
Expression += $"{CalculationOperation.SecondArgument} {operation.OperationSymbol} ";
CalculationOperation.FirstArgument = CalculationOperation.Result;
calculator.CalculatorState = new OperationChoosingState(calculator);
calculator.CalculatorState.CalculationOperation = CalculationOperation;
CalculationOperation.OperationSymbol = operation.OperationSymbol;
CalculationOperation.ExecuteOperation = operation.ExecuteOperation;
calculator.CalculatorState.Expression = Expression;
}
//public override void ContinueExpression(CalculatorOperation operation)
//{
// calculator.CalculatorState = new OperationChoosingState(calculator) { Reset = true };
// CalculationOperation.FirstArgument = CalculationOperation.Result;
// CalculationOperation.ExecuteOperation = operation.ExecuteOperation;
// calculator.CalculatorState.CalculationOperation = CalculationOperation;
//}
public override void FinishExpression(CalculatorOperation operation)
{
CalculationOperation.SecondArgument = operation.SecondArgument;
CalculationOperation.Result = CalculationOperation.ExecuteOperation(CalculationOperation.FirstArgument, CalculationOperation.SecondArgument);
calculator.CalculatorHistory?.AddToHistory(CalculationOperation);
Expression += $"{CalculationOperation.SecondArgument} = {CalculationOperation.Result}";
calculator.CalculatorState = new InitialState(calculator)
{
Reset = true,
CalculationOperation = CalculationOperation,
Expression = Expression
};
}
private void OnEqualsButtonPressed()
{
if (!(currentOperation == CalculatorOperation.None || isOperationButtonPressed == true))
{
switch (currentOperation)
{
case CalculatorOperation.Add:
currentNumber += firstNumber;
break;
case CalculatorOperation.Subtract:
currentNumber = firstNumber - currentNumber;
break;
case CalculatorOperation.Multiply:
currentNumber *= firstNumber;
break;
case CalculatorOperation.Divide:
if (currentNumber != 0)
{
currentNumber = firstNumber / currentNumber;
}
else
{
ScreenTextBlock.Text = "Can't divide by zero.";
}
break;
default:
throw new NotSupportedException(String.Format("Unsupported operation: {0}",
Enum.GetName(typeof(CalculatorOperation), currentOperation)));
}
if (!(currentOperation == CalculatorOperation.Divide && currentNumber == 0))
{
OnValueChanged();
}
currentOperation = CalculatorOperation.None;
isCalculationDone = true;
}
}
public CalculatorResult(CalculatorOperation operation, long result)
{
if (operation == null)
throw new ArgumentNullException("operation");
_id = operation._id;
_result = result;
}
private void OnClearButtonPressed()
{
firstNumber = new Number(0);
currentNumber = new Number(0);
isOperationButtonPressed = false;
isFloatButtonPressed = false;
isEnteringSecondNumber = false;
isCalculationDone = false;
currentOperation = CalculatorOperation.None;
OnValueChanged();
}
private void OnOperationButtonPressed(CalculatorOperation operation)
{
if (isEnteringSecondNumber)
{
OnEqualsButtonPressed();
}
currentOperation = operation;
isOperationButtonPressed = true;
isFloatButtonPressed = false;
}
