public void ShouldReturnFiveWhenPassTwoAndThree()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Add(2, 3);
Assert.AreEqual(5, result);
}
public void Add2WithOverwrtingUpperBound()
{
// Arrange -- setup
string twoOperands = "1,5000";
var c = new Calculator.Calculator(twoOperands, 6000);
//string twoOperansWithNegNum = "4,-3";
//string eString = String.Empty;
//string numAndInvalidOperand = "5,tytyt";
//string listOfNumbers = "1,2,3,4,5,6,7,8,9,10,11,12";
//string strWithNewLine = "1\n2,3";
//string negNumExp = "4,-3";
//string strWithValueGT1000 = "2,1001,6";
//string oneDelimiter = "//#\n2#5";
//string oneDelimiterWithLengthGTOne = "//[***]\n11***22***33";
//string multiDelimiters = "//[*][!!][r9r]\n11r9r22*hh*33!!44";
// Act
var result = c.addNumbers();
// Assert -- Make sure, as many as I want
Assert.Equal(5001, result);
}
static void Main(string[] args)
{
var calc = new Calculator();
Console.WriteLine("Input your operations: operator first, then operands, divided by whitespace");
Console.WriteLine("Avialable operations are:");
foreach (var op in calc.getAvialableOperators())
Console.WriteLine(" " + op);
Console.WriteLine("For exit - type \"quit\"");
Console.WriteLine("\nCurrent result = " + calc.getResult());
CalculatorOperation operation;
while (true)
{
operation = parseCalculatorOperation(Console.ReadLine());
if (operation.opName.Equals("quit"))
{
Console.WriteLine("\nBye-bye!");
break;
}
calc.executeOperation(operation.opName, operation.operands);
Console.WriteLine("Current result = " + calc.getResult());
}
Console.ReadKey();
}
public void ShouldReturnTwoWhenPassTenAndFive()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Div(10, 5);
Assert.AreEqual(2, result);
}
public void IntegrationTestThree()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Exp1(10, cl.Add(6, cl.Div(12, 2)));
Assert.AreEqual(34, result);
}
public void ShouldReturnTwoWhenPassNineAndFour()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Div(9, 4);
Assert.AreEqual(2, result);
}
public void ShouldReturnOneWhenPassMinusTwoAndThree()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Add(-2, 3);
Assert.AreEqual(1, result);
}
static void Main(string[] args)
{
ICalculator calc = new Calculator();
CalculateFromConsole(calc, new Utility());
Console.WriteLine("ilk sayi " + calc.FirstNumber);
Console.WriteLine("ikinci sayi " + calc.SecondNumber);
Console.WriteLine("sonuc " + calc.Result);
CalculateFromFile(calc, new Utility());
Console.WriteLine("ilk sayi " + calc.FirstNumber);
Console.WriteLine("ikinci sayi " + calc.SecondNumber);
Console.WriteLine("sonuc " + calc.Result);
ISalaryCalculator salarycalc = new SalaryCalculator();
SalaryCalculateFromConsole(salarycalc);
Console.WriteLine("calistigi gun sayisi " + salarycalc.NumberOfDays);
Console.WriteLine("gunluk yevmiye " + salarycalc.DailyWages);
Console.WriteLine("maasi " + salarycalc.Salary);
Console.ReadKey();
}
static void Main(string[] args)
{
int result;
InputHandler inputHandler = new InputHandler();
OperationFactory operationFactory = new OperationFactory();
List <ICalculate> operaters;
while (true)
{
try
{
inputHandler.execute();
operaters = operationFactory.createOperations(inputHandler.result);
Calculator.Calculator calculator = new Calculator.Calculator(inputHandler.result, operaters);
result = calculator.execute();
Console.WriteLine(string.Format("Answer: {0}", result));
inputHandler.result.Clear();
}
catch (Exception e)
{
Console.WriteLine(string.Format("Something went wrong \n{0}", e.Message));
Main(null);
}
}
}
public static void GetStatistikyForMail()
{
Calculator.Calculator calc = new Calculator.Calculator(numbers);
sum = calc.Sum();
median = calc.Median();
avg = calc.Average();
}
static void Main(string[] args)
{
Console.WriteLine("Console Calculator: Your trusted source for second-grade mathematics!\n");
Calculator doCalc = new Calculator();
baseValue = GetFirstNumber();
int? calcType = SelectCalculationType();
while (calcType != null)
{
userInput = Calculator.GetInput();
if (calcType == 1)
baseValue = doCalc.Addition(baseValue, userInput);
else if (calcType == 2)
baseValue = doCalc.Subtraction(baseValue, userInput);
else if (calcType == 3)
baseValue = doCalc.Multiplication(baseValue, userInput);
else if (calcType == 4)
baseValue = doCalc.Division(baseValue, userInput);
calcType = SelectCalculationType();
}
}
public static void Main()
{
IStack stack;
Console.WriteLine("Type:\n -2 to use Stack on references;\n -1 to use List as an Stack;\n -0 to use Stack on an Array.");
ushort command = Convert.ToUInt16(Console.ReadLine());
while (command > 2)
{
Console.WriteLine("Wrong input! Try again.");
command = Convert.ToUInt16(Console.ReadLine());
}
if (command == 2)
{
stack = new ReferenceStack();
}
else if (command == 1)
{
stack = new List();
}
else
{
stack = new ArrayStack();
}
Calculator calc = new Calculator(stack);
calc.Push(9);
calc.Push(4);
calc.Subtract();
calc.Push(2);
calc.Push(6);
calc.Add();
calc.Multiply();
calc.Push(4);
calc.Divide();
Console.WriteLine("The result of classic expression is {0}.", calc.Result());
}
public void IntegrationTestFive()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Add(2, cl.Exp2(2, cl.Div(0, cl.DivByZero(2, 2))));
Assert.AreEqual(3, result);
}
public void IntegrationTestTwo()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Add(2, cl.Exp1(2, cl.Div(10, cl.DivByZero(2, 0))));
Assert.AreEqual(34, result);
}
public void Divide_ValuesBiggerThan0_ShouldReturn2()
{
var calc = new Calculator.Calculator();
var result = calc.Divide(4, 2);
Assert.AreEqual(2, result);
}
public void ShouldReturnOneWhenPassTwoAndZero()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Exp2(2, 0);
Assert.AreEqual(1, result);
}
public void Add_ValuesBiggerThan0_ShouldReturn5()
{
var calc = new Calculator.Calculator();
var result = calc.Add(2, 3);
Assert.AreEqual(5, result);
}
public void Divide_PositiveValues_ShouldReturnEffect(double a, double b, double effect)
{
var calc = new Calculator.Calculator();
var result = calc.Divide(a, b);
Assert.AreEqual(effect, result);
}
public void Add_ValuesLessThan0_ShouldReturnMinus5()
{
var calc = new Calculator.Calculator();
var result = calc.Add(-2, -3);
Assert.AreEqual(-5, result);
}
public void CalculatorTest1()
{
Calculator.Calculator calculator = new Calculator.Calculator(new CalculatorParser(), new CalculatorConverter(), new CalculatorOperation());
var actualResult = calculator.Calculate("-(1+2)*4+(-33/3)");
var expectedResult = -23;
Assert.AreEqual(expectedResult, actualResult);
}
public void ShouldReturnSixtyFourOneWhenPassTwoAndSix()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Exp1(2, 6);
Assert.AreEqual(64, result);
}
public void Add_ValuesBiggerAndLowerThan0_ShouldReturnMinus1()
{
var calc = new Calculator.Calculator();
var result = calc.Add(2, -3);
Assert.AreEqual(-1, result);
}
public void ShouldReturnFiveOneWhenPassTwoAndMinusThree()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Sub(2, -3);
Assert.AreEqual(5, result);
}
public void ShouldReturnZeroWhenPassMinusTwoAndZero()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Mul(-2, 0);
Assert.AreEqual(0, result);
}
public void ShouldReturnIntegerFiveWhenPassIntegerNumbers()
{
Calculator.Calculator cl = new Calculator.Calculator();
var result = cl.Add(2, 3);
Assert.IsInstanceOfType(result, typeof(int));
}
public void ShouldReturnSixWhenPassMinusTwoAndMinusThree()
{
Calculator.Calculator cl = new Calculator.Calculator();
int result = cl.Mul(-2, -3);
Assert.AreEqual(6, result);
}
static void Main(string[] args)
{
Calculator calc = new Calculator();
calc.EnterValue();
calc.EnterOperator();
calc.EnterValue();
Console.WriteLine("Result is: " + calc.Calculate());
Console.ReadLine();
}
public int Calculator_Add(int a, int b)
{
//Arrange
Calculator.Calculator c = new Calculator.Calculator(a);
//Act
c.Add(b);
//Assert
return(c.Total);
}
public void SumTest(double arg1, double arg2, double expected)
{
var memoryMock = new Mock <IMemory <double> >();
Calculator.Calculator sut = new Calculator.Calculator(memoryMock.Object);
sut.Sum(arg1, arg2);
memoryMock.Verify(x => x.Store(expected));
}
public void ShouldCalculateProperly()
{
var calc = new Calculator.Calculator();
Assert.AreEqual(0, calc.getResult());
calc.executeOperation("+", new int[] {7 });
Assert.AreEqual(7, calc.getResult());
calc.executeOperation("-", new int[] { 15 });
Assert.AreEqual(-8, calc.getResult());
}
public int Calculator_Add_ArgumentNullException(int a, int b)
{
//Arrange
Calculator.Calculator c = new Calculator.Calculator(a);
//Act
c.Add(b);
throw new ArgumentNullException();
//Assert
return(c.Total);
}
public void CalculateFromReversePolishNotationTest2()
{
var expressionProcessor = new MathExpressionProcessor();
var calculator = new Calculator.Calculator(expressionProcessor);
var inputString = $"5{Dot}4 23{Dot}6 +";
var expectedOutput = 29;
var actualOutput = calculator.CalculateFromReversePolishNotation(inputString);
Assert.IsTrue(Math.Abs(expectedOutput - actualOutput) < Eps);
}
static void Main(string[] args)
{
// Create new object of the Calculator class
var calculator = new Calculator();
// Call the CalculateSum method, and assign the value returned to the variable 'result'
var result = calculator.CalculateSum(3,3,3);
// Output the result
Console.WriteLine("Result is " + result);
// Pause the program
Console.ReadLine();
}
public void DoubleNotationTest1()
{
var expressionProcessor = new MathExpressionProcessor();
var calculator = new Calculator.Calculator(expressionProcessor);
var inputString = ".1";
var expectedOutput = 0.1;
var actualOutput = calculator.CalculateFromReversePolishNotation(inputString);
Assert.IsTrue(Math.Abs(expectedOutput - actualOutput) < Eps);
}
public void AddnegNumExp()
{
// Arrange -- setup
string negNumExp = "4,-3";
var c = new Calculator.Calculator(negNumExp, false);
// Act
// var result = c.addNumbers();
// Assert -- Make sure, as many as I want
Assert.Throws <NegativeNumberException>(() => c.addNumbers());
}
public void ShouldThrowOnUnknownOperator()
{
try
{
var calc = new Calculator.Calculator();
calc.executeOperation("*", new int[] { 2 });
}
catch (Exception exc)
{
Assert.AreEqual("Operator \"*\" unknown!\r\nParameter name: operatorName", exc.Message);
}
}
public void ShouldThrowOnNullOperandsForNonNullOperator()
{
try
{
var calc = new Calculator.Calculator();
calc.executeOperation("+", null);
}
catch (Exception exc)
{
Assert.AreEqual("Operator \"+\" requires non-empty operands list!\r\nParameter name: operands", exc.Message);
}
}
public void ShouldThrowOnInsufficientOperandsNumber()
{
try
{
var calc = new Calculator.Calculator();
calc.executeOperation("+", new int[] { });
}
catch (Exception exc)
{
Assert.AreEqual("operands\r\nParameter name: Operator \"+\" requires 1operands, while only 0 presented!", exc.Message);
}
}
public void AddnumAndInvalidOperand()
{
// Arrange -- setup
string numAndInvalidOperand = "5,tytyt";
var c = new Calculator.Calculator(numAndInvalidOperand);
// Act
var result = c.addNumbers();
// Assert -- Make sure, as many as I want
Assert.Equal(5, result);
}
public void ShouldGetAnExceptionWhenPassTenAndZero()
{
Calculator.Calculator cl = new Calculator.Calculator();
try
{
int result = cl.Div(10, 0);
}
catch (DivideByZeroException ex)
{
StringAssert.Contains(ex.Message, "Division by zero is not hadled by the system.");
}
}
private void ButtonClick(object sender, EventArgs e)
{
if ((sender as Button).Tag.ToString() == "=")
{
string expression = EnterBox.Text;
var calculator = new Calculator();
EnterBox.Text = calculator.Calculate(expression).ToString();
}
else
{
EnterBox.Text += (sender as Button).Tag.ToString();
}
}
static void Main()
{
ICalculator calculator = new Calculator();
calculator.Add(2, 7);
calculator.Subtract(10, 8);
calculator.Multiply(3, 3);
calculator.Divide(20, 4);
calculator.Divide(20, 0);
Console.WriteLine();
Console.WriteLine("Press any key to continue.");
Console.ReadKey();
}
public void MultiplyTest()
{
// arrange
Calculator calc = new Calculator();
int number1 = 5;
int number2 = 7;
int expected = 35;
// act
int actual = calc.Multiply(number1, number2);
// assert
Assert.AreEqual(expected, actual);
}
public override void ViewDidLoad ()
{
base.ViewDidLoad ();
// Perform any additional setup after loading the view, typically from a nib.
Calculator.Calculator calc = new Calculator.Calculator ();
calc.AddNumber (4, 6);
System.Console.WriteLine("AAAA: {0}",calc.AddNumber (4, 6));
}
public void AddTest()
{
// arrange
Calculator calc = new Calculator();
int number1 = 5;
int number2 = 7;
int expected = 12;
// act
int actual = calc.Add(number1, number2);
// assert
Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
Calculator calc = new Calculator();
int add = calc.Add(10, 34);
Console.WriteLine("10+34 is {0}.", add);
int sub = calc.Sub(34, 10);
Console.WriteLine("34-10 is {0}.", sub);
int mul = calc.Mul(30, 40);
Console.WriteLine("30*40 is {0}.", mul);
double div = calc.Div(500, 6);
Console.WriteLine("500/6 is {0}.", div);
double modulo = calc.Modulo(56, 9);
Console.WriteLine("56*9 is {0}.", modulo);
Console.ReadLine();
}
public void start()
{
calculator = new Calculator();
// Вначале юнит тесты
runAndDisplayTime(Program.Tests);
Console.WriteLine();
// Потом ользовательский ввод
runAndDisplayTime(this.run);
Console.ReadKey();
// Создаем новые тесты на основе пользовательчкого ввода
for (int i = 0; i < question.Count; i++)
createTests(question[i], answer[i]);
}
public static void Main(string[] args)
{
var context = new Calculator();
using (var interp = new Interpreter<Calculator>(context))
{
interp.LoggingKind = LoggingKind.Console;
while (true)
{
Console.Write("calc>");
var expr = Console.ReadLine();
try
{
interp.Parse(expr);
if (context.Done)
{
break;
}
if (interp.ErrorCount == 0)
{
Console.WriteLine(context.Result);
}
}
catch (Exception error)
{
while (error.InnerException != null)
{
error = error.InnerException;
}
Console.WriteLine(error.Message);
}
}
}
}
static void Main(string[] args)
{
Calculator _calc = new Calculator();
string userInput= "";
while (userInput != "exit")
{
Console.WriteLine("Enter a calculation below, you can use [] for bodmas e.g. [3 + 5] x 2");
userInput = Console.ReadLine();
double result;
if (_calc.ContainsBrackets(userInput))
{
var opertionWithBracketsCalculated = _calc.BracketIsolationCalculation(userInput);
result = _calc.GetResultFromSingleCalculation(opertionWithBracketsCalculated);
} else {
result = _calc.GetResultFromSingleCalculation(userInput);
}
Console.WriteLine(result);
//Console.WriteLine("Press enter to clear");
//Console.Read();
//Console.Clear();
}
}
static void Main(string[] args)
{
string firstNumber, secondNumber, operationStr;
double number1 = 0.0, number2 = 0.0;
bool flag = true;
char operation;
Calculator calculator = new Calculator();
while (flag)
{
var charIsValid = true;
Console.WriteLine("Enter first number: ");
firstNumber = Console.ReadLine();
Console.WriteLine("Enter second number: ");
secondNumber = Console.ReadLine();
Console.WriteLine("Enter operation '+', '-', '*', '/' : ");
operationStr = Console.ReadLine();
if (Char.TryParse(operationStr, out operation))
{
switch (operation)
{
case '+':
break;
case '-':
break;
case '*':
break;
case '/':
break;
default:
Console.WriteLine("Wrong operation");
charIsValid = false;
break;
}
}
else
{
Console.WriteLine("Wrong operation");
charIsValid = false;
}
if (charIsValid)
{
if (Double.TryParse(firstNumber, out number1) && Double.TryParse(secondNumber, out number2))
Console.WriteLine(number1 + " " + operation + " " + number2 + " = " + calculator.Calculate(number1, number2, operation));
else
Console.WriteLine("Not a valid double ");
}
Console.WriteLine("Continue? ('y' / 'n')");
char quit = Convert.ToChar(Console.ReadLine());
if (quit == 'n')
flag = false;
}
}
public void InitializeCalculator()
{
calculator = new Calculator(new ExpressionTransformer(), new OnpAlgorithm());
}
/// <summary>
/// Text input has changed, re-evaluate and calculate
/// </summary>
/// <param name="sender">sending object</param>
/// <param name="e">event arguments</param>
private void txtInput_TextChanged(object sender, EventArgs e)
{
ClearLabels();
if (String.IsNullOrWhiteSpace(txtInput.Text))
return;
Calculator calc = new Calculator(txtInput.Text);
calc.Mode = this.Mode;
double? result = null;
try
{
result = calc.Calculate();
}
catch (Exception)
{
result = null;
}
if (result.HasValue)
{
Int64 intResult = (Int64)result;
txtResultDecimal.Text = result.ToString();
if (result == ((double)intResult))
{
// This is a whole number
txtResultHex.Text = String.Join(" ", Regex.Split(intResult.ToString("X"), "(?<=^(.{4})+)"));
txtResultBits.Text = String.Join(" ", Regex.Split(Convert.ToString(intResult, 2), "(?<=^(.{4})+)"));
if (txtResultBits.Text.Length > 100)
this.ClientSize = FullSizeThreeBinaryLines;
else if (txtResultBits.Text.Length > 50)
this.ClientSize = FullSizeTwoBinaryLines;
else
this.ClientSize = FullSize;
}
else
{
this.ClientSize = HalfSize;
}
}
else
{
txtInput.BackColor = Color.Salmon;
}
}
public void CheckSummation()
{
Calculator calc = new Calculator();
int result = calc.Add(4, 6);
Assert.AreEqual(result, 10);
}
public void Setup()
{
calc=new Calculator.Calculator();
}
public void TearDown()
{
calc=null;
}
static void Main(string[] args)
{
Calculator calculator = null;
var reg = new Regex(",*[0-9]*");
inputAgain:
Console.WriteLine("Input Operator(+, -, *, /)");
Console.Write("> ");
var inputOperator = Console.ReadLine();
switch (inputOperator)
{
case "+":
calculator = new Calculator(OperatorType.Plus);
break;
case "-":
calculator = new Calculator(OperatorType.Minus);
break;
case "*":
calculator = new Calculator(OperatorType.Multiply);
break;
case "/":
calculator = new Calculator(OperatorType.Divison);
break;
default :
goto inputAgain;
break;
}
while (true)
{
Console.WriteLine("Input Operand(If you want to exist, input exit)");
Console.Write("> ");
var inputNumber = Console.ReadLine();
if (inputNumber != null && (inputNumber != "exit" && !inputNumber.Contains(",")))
{
calculator.AddInput(Convert.ToInt32(inputNumber));
}
else if (inputNumber != null && inputNumber.Contains(","))
{
var sp = inputNumber.Split(new char[] {','});
var numArr = new int[sp.Length];
for (var i = 0; i < sp.Length; i++)
{
numArr[i] = Convert.ToInt32(sp[i]);
}
calculator.AddInputs(numArr);
}
else
{
break;
}
}
Console.WriteLine("> Result : "+"{0} = {1}",calculator,calculator.Calculate());
Console.ReadKey();
}
static void Main(string[] args)
{
Calculator calc = new Calculator();
Console.WriteLine(calc.Product(2, 3));
Console.ReadKey();
}
/// <summary>
/// Text input has changed, re-evaluate and calculate
/// </summary>
/// <param name="sender">sending object</param>
/// <param name="e">event arguments</param>
private void txtInput_TextChanged(object sender, EventArgs e)
{
ClearLabels();
if (String.IsNullOrWhiteSpace(txtInput.Text))
return;
Calculator calc = new Calculator(txtInput.Text);
calc.Mode = this.Mode;
double? result = null;
try
{
result = calc.Calculate();
}
catch (Exception)
{
result = null;
}
if (result.HasValue)
{
Int64 intResult = (Int64)result;
lblResultDecimal.Text = result.ToString();
if (result == ((double)intResult))
{
// This is a whole number
lblResultHex.Text = "0x" + intResult.ToString("X");
lblResultBits.Text = "0b" + Convert.ToString(intResult, 2);
this.ClientSize = FullSize;
}
else
{
this.ClientSize = HalfSize;
}
}
else
{
txtInput.BackColor = Color.Salmon;
}
}
public void Init()
{
_calculator = new Calculator();
}
