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(); }