public void DefineOperation_BinaryAlreadyExists_ShouldThrow() { var calculator = new CalculatorEngine(); calculator.DefineOperation("+", (x, y) => x + y); Assert.Throws <AlreadyExistsOperationException>(() => { calculator.DefineOperation("+", (x, y) => x + y); }); }
public override double calculate(List <double> arguments, CalculatorEngine engine) { switch (arguments.Count) { case 1: return(random.NextDouble() * arguments[0]); case 2: return(arguments[0] + (arguments[1] - arguments[0]) * random.NextDouble()); default: throw new ExpressionInvalidException("invalidRandomNumArgs"); } }
public override double calculate(List <double> arguments, CalculatorEngine engine) { foreach (double num in arguments) { if (num > 0) { return(1); } } return(0); }
public void DefineOperation_TernaryAlreadyExists_ShouldThrow() { var calculator = new CalculatorEngine(); calculator.DefineOperation("whatever", (x, y, z) => x + y + z); Assert.Throws <AlreadyExistsOperationException>(() => { calculator.DefineOperation("whatever", (x, y, z) => x + y + z); }); }
public void PerformOperation_Ternary_ShouldCalculate() { var calculator = new CalculatorEngine(); calculator.DefineOperation("T5", (x, y, z) => Math.Min(x, Math.Min(y, z))); var operation = new Operation("T5", new[] { 2.0, 3.0, 6.0 }); var actual = calculator.PerformOperation(operation); Assert.That(actual, Is.EqualTo(2.0).Within(0.001), "Incorrect calculation result"); }
public void PerformOperation_Binary_ShouldCalculate() { var calculator = new CalculatorEngine(); calculator.DefineOperation("*", (x, y) => x * y); var operation = new Operation("*", new[] { 5.0, 3.0 }); var actual = calculator.PerformOperation(operation); Assert.That(actual, Is.EqualTo(15.0).Within(0.001), "Incorrect calculation result"); }
public void PerformOperation_Unary_ShouldCalculate() { var calculator = new CalculatorEngine(); calculator.DefineOperation("++", x => x + 1); var operation = new Operation("++", new[] { 3.0 }); var actual = calculator.PerformOperation(operation); Assert.That(actual, Is.EqualTo(4.0).Within(0.001), "Incorrect calculation result"); }
public void ShouldReturn7WhenDivide35To5() { //arrange var calculator = new CalculatorEngine(); //act Int32 realExeption = calculator.Divide(35, 5); Int32 simulateExeption = 35 / 5; //assert Assert.AreEqual(realExeption, simulateExeption); }
public void ShouldReturn15WhenMultiply5To3() { //arrange var calculator = new CalculatorEngine(); //act Int32 realExeption = calculator.Multiply(5, 3); Int32 simulateExeption = 5 * 3; //assert Assert.AreEqual(realExeption, simulateExeption); }
public void ShouldReturn2WhenSubstract7To5() { //arrange var calculator = new CalculatorEngine(); //act Int32 realExeption = calculator.Substract(7, 5); Int32 simulateExeption = 7 - 5; //assert Assert.AreEqual(realExeption, simulateExeption); }
public void ShouldReturn5WhenAdd2To3() { //arrange var calculator = new CalculatorEngine(); //act Int32 realExeption = calculator.Add(2, 3); Int32 simulateExeption = 2 + 3; //assert Assert.AreEqual(realExeption,simulateExeption); }
public override double calculate(List <double> arguments, CalculatorEngine engine) { if (arguments.Count > 4) { throw new ExpressionInvalidException("invalidTimeNumArgs"); } while (arguments.Count < 4) { arguments.Add(0); } return(arguments[0] + arguments[1] / 24 + arguments[2] / 1440 + arguments[3] / 86400); }
public override double calculate(List <double> arguments, CalculatorEngine engine) { if (arguments.Count > 3) { throw new ExpressionInvalidException("invalidIfNumArgs"); } while (arguments.Count < 3) { arguments.Add(0); } return(arguments[0] > 0 ? arguments[1]: arguments[2]); }
public void Calculate_BasicNegativeDivide_Test() { string firstOperand = "-4"; string secondOperand = "2"; string expected = "-2"; string actual; CalculatorEngine engine = new CalculatorEngine(); actual = engine.calculate("÷", firstOperand, secondOperand); Assert.AreEqual(expected, actual); }
public void Calculate_DivideByZero_Test() { string firstOperand = "4"; string secondOperand = "0"; string expected = "E"; string actual; CalculatorEngine engine = new CalculatorEngine(); actual = engine.calculate("÷", firstOperand, secondOperand); Assert.AreEqual(expected, actual); }
public void Calculate_BasicPlus_Test() { string firstOperand = "1"; string secondOperand = "2"; string expected = "3"; string actual; CalculatorEngine engine = new CalculatorEngine(); actual = engine.calculate("+", firstOperand, secondOperand); Assert.AreEqual(expected, actual); }
protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); // Set our view from the "main" layout resource SetContentView(Resource.Layout.Main); calculatorEngine = new CalculatorEngine(); calculatorEngine.PropertyChanged += CalculatorPropertyChanged; var gridView = FindViewById <GridView> (Resource.Id.buttonGridView); gridView.Adapter = new ButtonAdapter(this, OnCalculatorKeyPress); }
public override double calculate(List <double> arguments, CalculatorEngine engine) { if (arguments.Count < 2) { throw new ExpressionInvalidException("invalidComparisonNumArgs"); } for (int i = 1; i < arguments.Count; i++) { if (arguments[i] != arguments[0]) { return(0); } } return(1); }
public void Calculate_TernaryParametersMismatch_ShouldThrow() { var calculator = new CalculatorEngine(); calculator.DefineOperation("+", (x, y, z) => x + y + z); Assert.Throws <ParametersCountMismatchException>(() => { calculator.PerformOperation(new Operation("+", new double[] { 1 })); }); Assert.Throws <ParametersCountMismatchException>(() => { calculator.PerformOperation(new Operation("+", new double[] { 1, 2 })); }); }
public override double calculate(List <double> arguments, CalculatorEngine engine) { double min = 0; bool isFirst = true; foreach (double num in arguments) { if (isFirst) { isFirst = false; min = num; } else if (num < min) { min = num; } } return(min); }
public override double calculate(List <double> arguments, CalculatorEngine engine) { double total = 0; foreach (double argument in arguments) { total += argument; } double n = Math.Floor(total); if (n < 0) { throw new ExpressionInvalidException("invalidFactorialArg"); } total = 1; for (double i = 1; i <= n; i += 1) { total *= i; } return(total); }
public override double calculate(List <double> arguments, CalculatorEngine engine) { if (arguments.Count == 1) { double r = Math.Floor(Math.Abs(arguments[0])); return(r == 0 ? 1 : r); } double res = Math.Floor(Math.Abs(arguments[0])); for (int i = 1; i < arguments.Count; i++) { double n = Math.Floor(Math.Abs(arguments[i])); while (n != 0) { double temp = n; n = mod(res, n); res = temp; } } return(res); }
public void Calculate_ArgumentOutOfRange_ShouldThrow() { var calculator = new CalculatorEngine(); var sqrt = new Func <double, double>( x => { if (x < 0) { throw new ArgumentOutOfRangeException(); } return(Math.Sqrt(x)); }); calculator.DefineOperation("sqrt", sqrt); Assert.Throws <ArgumentOutOfRangeException>(() => { calculator.PerformOperation(new Operation("sqrt", new double[] { -4 })); }); }
public override double calculate(List <double> arguments, CalculatorEngine engine) { if (arguments.Count == 1) { return(Math.Floor(Math.Abs(arguments[0]))); } double res = Math.Floor(Math.Abs(arguments[0])); for (int i = 1; i < arguments.Count; i++) { double n = Math.Floor(Math.Abs(arguments[i])); double t = n; double t2 = res; while (t2 != 0) { double temp = t2; t2 = mod(n, t2); n = temp; } res = div(res * t, n); } return(res); }
public abstract double calculate(double val1, double val2, CalculatorEngine engine);
public override double calculate(double val1, double val2, CalculatorEngine engine) { throw new ExpressionInvalidException("braceInvolved"); }
public void Init() { calculatorEngine = new CalculatorEngine(); }
public void Setup() { //Arrange calcEngine = new CalculatorEngine(); }
public void TestSubtractMethod() { double result = CalculatorEngine.Subtract(10.0, 20.0); Assert.AreEqual(-10.0, result); }
public void TestAddMethod() { double result = CalculatorEngine.Add(10.0, 20.0); Assert.AreEqual(30.0, result); }
public void CreateCalculatorEngine() { engine = new CalculatorEngine(); }
public override double calculate(double val1, double val2, CalculatorEngine engine) { return(val1 * val2); }
public override double calculate(double val1, double val2, CalculatorEngine engine) { return(CoreUtils.power(val1, val2, engine)); }
public void Setup() { display = new CalculatorDisplay(); calculator = new CalculatorEngine(display); rnd = new Random(123); }