private void mulButton_Click(object sender, EventArgs e)
{
expressionLbl.Text += String.IsNullOrEmpty(displayTxt.Text) ? Constants.Multiply : displayTxt.Text + Constants.Multiply;
var number = new Number
{
EnteredNumber = String.IsNullOrEmpty(displayTxt.Text) ? 1 : Convert.ToDouble(displayTxt.Text),
IsCalculated = false
};
MultiplyCommand multiplyCommand;
//Deferred execution
if (_bracketCount == 0 || _bracketCount % 2 == 0)
{
_numbers.Add(number);
multiplyCommand = new MultiplyCommand(_result, _numbers);
//Calculating
_invoker.CalculatingOperations();
}
else if (_bracketCount > 0 && _bracketCount % 2 == 0)
{
_bracketNumbers.Add(number);
multiplyCommand = new MultiplyCommand(_result, _bracketNumbers);
_invoker.CalculatingOperations();
}
else
{
_bracketNumbers.Add(number);
multiplyCommand = new MultiplyCommand(_result, _bracketNumbers);
}
//Adding current operation into sequence
_invoker.IncludeOperations(multiplyCommand);
displayTxt.Clear();
}
public void TestMultiplyCommand()
{
var c = new MultiplyCommand(options);
var actualResult = c.Execute(new long[] { 2, 2, 2 });
Assert.Equal(8, actualResult);
}
public CalculatorViewModel()
{
plusCommand = new PlusCommand(this);
minusCommand = new MinusCommand(this);
multiplyCommand = new MultiplyCommand(this);
divisionCommand = new DivionCommand(this);
}
public double Multiply(double first, double second)
{
var cmd = new MultiplyCommand(first, second);
_multiplyHandler.Handle(cmd);
return(_store.Result);
}
public MultiplyDialog()
{
InitializeComponent();
_MultiplyCommand = new MultiplyCommand();
//Set command default values
InitializeUI();
}
public SYMathCalculator(ISYReciever reciever)
{
_addCommand = new AddCommand(reciever);
_subtractCommand = new SubtractCommand(reciever);
_multiplyCommand = new MultiplyCommand(reciever);
_divCommand = new DivCommand(reciever);
_powCommand = new PowCommand(reciever);
}
public ViewModel()
{
AddCommand = new AddCommand(this);
SubtractCommand = new SubtractCommand(this);
MultiplyCommand = new MultiplyCommand(this);
DivideCommand = new DivideCommand(this);
Results = new ObservableCollection <Result>();
}
private void SignalsGenerated(object sender, EventArgs args)
{
AddCommand.RaiseCanExecuteChanged();
DivideCommand.RaiseCanExecuteChanged();
MultiplyCommand.RaiseCanExecuteChanged();
SubtractCommand.RaiseCanExecuteChanged();
SwapCommand.RaiseCanExecuteChanged();
CorrelationCommand.RaiseCanExecuteChanged();
ConvolutionCommand.RaiseCanExecuteChanged();
}
public CalculatorViewModel(ICalculatorOperationsService operationsService = null)
{
Calculator = new CalculatorModel();
_operationsService = operationsService ?? new CalculatorOperationsService();
AddCommand = new AddCommand(this);
SubtractCommand = new SubtractCommand(this);
MultiplyCommand = new MultiplyCommand(this);
DivideCommand = new DivideCommand(this);
}
private void UserControl1_Load(object sender, EventArgs e)
{
Application.AddMessageFilter(this); //Function to check the events.
calculator = new Calculator(20, 10);
addCmd = new AddCommand(calculator);
subCmd = new SubtractCommand(calculator);
mulCmd = new MultiplyCommand(calculator);
divCmd = new DividerCommand(calculator);
}
public void MultiplyCommand_WithOneNumberInStack_FailExecute()
{
var command = new MultiplyCommand();
var stack = new Stack <decimal>();
stack.Push(1);
Exception ex = Assert.Throws <CalculateException>(() => command.Calculate(stack));
Assert.Equal("Невозможно умножить 2 числа", ex.Message);
}
static void Main(string[] args)
{
var receiver = new Calculator(345, 9945);
var addCommand = new AddCommand(receiver);
var subtractCommand = new SubtractCommand(receiver);
var multiplyCommand = new MultiplyCommand(receiver);
Console.WriteLine($"Add command result: {addCommand.Execute()}");
Console.WriteLine($"Subtract command result: {subtractCommand.Execute()}");
Console.WriteLine($"Multiply command result: {multiplyCommand.Execute()}");
Console.ReadKey();
}
public void MultiplyCommand_WithTwoNumberInStack_MultiplyInStack()
{
var command = new MultiplyCommand();
var stack = new Stack <decimal>();
stack.Push(3);
stack.Push(2);
command.Calculate(stack);
Assert.Single(stack);
Assert.Equal(6m, stack.Peek());
}
static void Main(string[] args)
{
Calculator calc = new Calculator();
while (true)
{
string[] input = Console.ReadLine().Split();
int value = int.Parse(input[1]);
ICommmand command = null;
switch (input[0])
{
case "+":
command = new PlusCommand(value);
break;
case "-":
command = new MinusCommand(value);
break;
case "*":
command = new MultiplyCommand(value);
break;
case "undo":
calc.Undo(value);
break;
case "redo":
calc.Redo(value);
break;
}
if (command != null)
{
calc.AddCommand(command);
}
Console.WriteLine(calc.Result);
}
}
public void PlusCommand_ShouldBe_Undone()
{
// Arrange
var initValue = 10;
// Act
var command1 = new MultiplyCommand(initValue, 2);
var command2 = new PlusCommand(Do(command1), 5);
var command3 = new PlusCommand(Do(command2), 3);
var command4 = new PlusCommand(Do(command3), 7);
var result = Do(command4);
// Undo all plus commands
var undoResultPlusCommands = Undo(3);
// Undo multiply command
var undoResult = Undo(1);
// Assert
Assert.AreEqual(initValue * 2 + 5 + 3 + 7, result);
Assert.AreEqual(initValue * 2, undoResultPlusCommands);
Assert.AreEqual(initValue, undoResult);
}
public void PlusCommand_ShouldBe_Undone()
{
// Arrange
var initValue = 10;
// Act
var command1 = new MultiplyCommand(initValue, 2);
var command2 = new PlusCommand(Do(command1), 5);
var command3 = new PlusCommand(Do(command2), 3);
var command4 = new PlusCommand(Do(command3), 7);
var result = Do(command4);
// Undo all plus commands
var undoResultPlusCommands = Undo(3);
// Undo multiply command
var undoResult = Undo(1);
// Assert
Assert.AreEqual(initValue * 2 + 5 + 3 + 7, result);
Assert.AreEqual(initValue * 2, undoResultPlusCommands);
Assert.AreEqual(initValue, undoResult);
}
public void SetUp()
{
_numberToMultiply = 3;
_command = new MultiplyCommand(_mockCalculator.Object, _numberToMultiply);
}
public void Constructor_NullCalculator_ThrowsException()
{
Model.Calculator calculator = null;
_command = new MultiplyCommand(calculator, _numberToMultiply);
}
static void Main(string[] args)
{
using (reader = File.OpenText("input.txt"))
using (writer = new StreamWriter(File.Create("output.txt")))
{
QuackVM vm = new QuackVM();
Workflow wf = new Workflow(vm);
while (!reader.EndOfStream)
{
string str = reader.ReadLine();
ICommand cmd = null;
switch (str[0])
{
case '+':
cmd = new PlusCommand();
break;
case '-':
cmd = new MinusCommand();
break;
case '*':
cmd = new MultiplyCommand();
break;
case '/':
cmd = new DivideCommand();
break;
case '%':
cmd = new ModuloCommand();
break;
case '>':
cmd = new SetRegisterCommand(str[1]);
break;
case '<':
cmd = new GetRegisterCommand(str[1]);
break;
case 'P':
if (str.Length > 1)
{
cmd = new PrintRegisterCommand(str[1]);
}
else
{
cmd = new PrintCommand();
}
break;
case 'C':
if (str.Length > 1)
{
cmd = new PrintRegisterCharCommand(str[1]);
}
else
{
cmd = new PrintCharCommand();
}
break;
case ':':
cmd = new LabelCommand(str.Substring(1));
break;
case 'J':
cmd = new GoToLabelCommand(str.Substring(1));
break;
case 'Z':
cmd = new GoToLabelZCommand(str[1], str.Substring(2));
break;
case 'E':
cmd = new GoToLabelECommand(str[1], str[2], str.Substring(3));
break;
case 'G':
cmd = new GoToLabelGCommand(str[1], str[2], str.Substring(3));
break;
case 'Q':
cmd = new QuitCommand();
break;
default:
cmd = new NumberCommand(int.Parse(str));
break;
}
wf.AddCommand(cmd);
}
while (!wf.IsCompleted())
{
wf.ExecuteCurrentCommand();
}
}
}
public void Priority_MulPriorityEqualsDivPriority_True()
{
ICommand mulCommand = new MultiplyCommand();
Assert.Equal(mulCommand.Priority, divCommand.Priority);
}
private ICommand CommandFromString(string name, string[] arguments)
{
ICommand command = null;
switch (name)
{
case "SET":
{
Register register = Registers[arguments[0]];
int value = int.Parse(arguments[1]);
command = new SetCommand(register, value);
break;
}
case "ADD":
{
Register registerOne = Registers[arguments[0]];
Register registerTwo = Registers[arguments[1]];
Register registerOut = Registers[arguments[2]];
command = new AddCommand(registerOne, registerTwo, registerOut);
break;
}
case "SUB":
{
Register registerOne = Registers[arguments[0]];
Register registerTwo = Registers[arguments[1]];
Register registerOut = Registers[arguments[2]];
command = new SubtractCommand(registerOne, registerTwo, registerOut);
break;
}
case "MUL":
{
Register registerOne = Registers[arguments[0]];
Register registerTwo = Registers[arguments[1]];
Register registerOut = Registers[arguments[2]];
command = new MultiplyCommand(registerOne, registerTwo, registerOut);
break;
}
case "DIV":
{
Register registerOne = Registers[arguments[0]];
Register registerTwo = Registers[arguments[1]];
Register registerOut = Registers[arguments[2]];
command = new DivideCommand(registerOne, registerTwo, registerOut);
break;
}
case "OUT":
{
if (Registers.ContainsKey(arguments[0]))
{
Register register = Registers[arguments[0]];
command = new OutCommand(register);
}
else
{
command = new OutCommand(arguments[0]);
}
break;
}
case "HLT":
{
command = new HaltCommand();
break;
}
case "JMP":
{
string label = arguments[0];
command = new JumpCommand(label);
break;
}
case "JIF":
{
Register registerOne = Registers[arguments[0]];
Register registerTwo = Registers[arguments[2]];
string conditionString = arguments[1];
JumpCondition jumpCondition = JumpCondition.Undefined;
switch (conditionString)
{
case "==":
jumpCondition = JumpCondition.Equal;
break;
case "<":
jumpCondition = JumpCondition.LessThan;
break;
case "<=":
jumpCondition = JumpCondition.LessThanOrEqual;
break;
case ">":
jumpCondition = JumpCondition.GreaterThan;
break;
case ">=":
jumpCondition = JumpCondition.GreaterThanOrEqual;
break;
case "!=":
jumpCondition = JumpCondition.NotEqual;
break;
}
string label = arguments[3];
command = new JumpIfCommand(registerOne, registerTwo, label, jumpCondition);
break;
}
case "CPY":
{
Register registerOne = Registers[arguments[0]];
Register registerTwo = Registers[arguments[1]];
command = new CopyCommand(registerOne, registerTwo);
break;
}
default:
if (name == "str:")
{
string stringKey = arguments[0];
string stringValue = string.Empty;
for (int i = 1; i < arguments.Length; i++)
{
stringValue += arguments[i];
if (i < arguments.Length)
{
stringValue += " ";
}
}
Program.RegisterString(stringKey, stringValue);
}
else if (name.Length > 1 && name.EndsWith(":"))
{
Program.MakeLabel(name.Substring(0, name.Length - 1));
break;
}
break;
}
return(command);
}
