public void ShouldAddTwoNumbers() { var sut = new SimpleCalculator(); int result = sut.Add(5, 10); Assert.That(result, Is.EqualTo(15)); }
public void ShouldMultiplyTwoNumbers() { var sut = new SimpleCalculator(); int result = sut.Multiply(10, 5); Assert.That(result, Is.EqualTo(50)); }
public void AddDoublewithPercent() { var sut = new SimpleCalculator(); double result = sut.AddDouble(50, 50); Assert.That(result, Is.EqualTo(101).Within(1).Percent); }
public void AddDoublewithTolerance() { var sut = new SimpleCalculator(); double result = sut.AddDouble(1.1, 2.2); Assert.That(result, Is.EqualTo(3.3).Within(0.1)); }
public IActionResult SimpleCalculator(SimpleCalculator simpleCalculator) { ViewData["Result"] = simpleCalculatorService.calculate(simpleCalculator.content); return(View(simpleCalculator)); }
public void Calculate_throws_exception_for_empty_string_as_operation() { Assert.Throws <ArgumentException>(() => SimpleCalculator.Calculate(1, 2, "")); }
public void Calculate_throws_exception_for_non_valid_operations() { Assert.Throws <ArgumentOutOfRangeException>(() => SimpleCalculator.Calculate(1, 2, "**")); }
public void Division_with_small_operands() { Assert.Equal("72 / 9 = 8", SimpleCalculator.Calculate(72, 9, "/")); }
public void IsEven_InputOddValues_ReturnFalse(int value) { var actual = SimpleCalculator.IsEven(value); Assert.IsFalse(actual, $"{value} should be not is even."); }
public void StaticAdd_SimpleTests() { Assert.AreEqual(7, SimpleCalculator.StaticAdd(3, 4)); Assert.AreEqual(7, SimpleCalculator.StaticAdd(3, 4)); }
public void ShouldErrorWhenNumberTooBig() { var myObject = new SimpleCalculator(); Assert.That(() => myObject.Divide(200, 2), Throws.TypeOf<ArgumentOutOfRangeException>()); }
public void Execute(SimpleCalculator context) { Console.WriteLine($"Resultado da subtração é: {context.FirstNumber} - {context.SecondNumber} = {context.FirstNumber - context.SecondNumber}"); }
public void IsOdd_InputZero_ReturnFalse() { var actual = SimpleCalculator.IsOdd(0); Assert.IsFalse(actual, $"Zero should be not is odd."); }
public void IsOdd_InputEvenValues_ReturnFalse(int value) { var actual = SimpleCalculator.IsOdd(value); Assert.IsFalse(actual, $"{value} should be not is odd."); }
public void IsOdd_InputOddValues_ReturnTrue(int value) { var actual = SimpleCalculator.IsOdd(value); Assert.IsTrue(actual, $"{value} should be is odd."); }
public void IsEven_InputZero_ReturnFalse() { var actual = SimpleCalculator.IsEven(0); Assert.IsFalse(actual, $"Zero should be not is even."); }
public void ShouldMultipleTwoNumbers() { var sut = new SimpleCalculator(); var result = sut.multiply(3.5m, 2m); Assert.That(result, Is.EqualTo(7m)); }
public void ShouldErrorWhenDivideByZero() { var myObject = new SimpleCalculator(); Assert.That(() => myObject.Divide(200, 0), Throws.Exception); }
public void setUp() { sc = new SimpleCalculator(); }
public void ShouldMultipleTwoDoubles_Negative() { var myObject = new SimpleCalculator(); var result = myObject.AddDouble(50, -50); Assert.That(result, Is.LessThanOrEqualTo(0)); }
public async Task <int> ProcessString(string input) { try { var calculator = new SimpleCalculator(); var operatorIndex = input.IndexOf(" ") + 1; var operatorChar = input.Substring(operatorIndex, 1); var firstNum = int.Parse(input.Substring(0, operatorIndex - 1)); var lastNum = int.Parse(input.Substring(operatorIndex + 2, input.Length - 2 - operatorIndex)); HttpResult result; switch (operatorChar) { case "+": result = await CalculationService.Add(firstNum, lastNum); break; case "-": result = await CalculationService.Subtract(firstNum, lastNum); break; case "/": result = await CalculationService.Divide(firstNum, lastNum); break; case "*": result = await CalculationService.Multiply(firstNum, lastNum); break; default: throw new Exception(); } // Log diagnostic result to DB await LoggerService.Log(new Diagnostic { Data = result.Data, Message = result.Message, Success = result.Success }); // Pull back all diagnostics for testing purposes var existingDiagnostics = Repository.SelectAll().ToList(); return(result.Data); } catch (Exception e) { // Log exception to DB await LoggerService.Log(new Diagnostic { Message = e.Message, Success = false }); throw e; } }
public void StaticAdd_SimpleTests(int left, int right, int result) { Assert.Equal(result, SimpleCalculator.StaticAdd(left, right)); }
public void IsEven_InputEvenValues_ReturnTrue(int value) { var actual = SimpleCalculator.IsEven(value); Assert.IsTrue(actual, $"{value} should be is even."); }
public void tearDown() { sc = null; }
public void Setup() { sc = new SimpleCalculator(); }
public void Multiplication_with_small_operands() { Assert.Equal("3 * 21 = 63", SimpleCalculator.Calculate(3, 21, "*")); }
public void Initialize() { _simpleCalculator = new SimpleCalculator(); _result = 0; }
public void Calculate_throws_exception_for_division_with_0() { Assert.Equal("Division by zero is not allowed.", SimpleCalculator.Calculate(33, 0, "/")); }
public MultiplicationCommand(SimpleCalculator simpleCalculator) { _simpleCalculator = simpleCalculator; }
public void Calculate_throws_exception_for_null_as_operation() { Assert.Throws <ArgumentNullException>(() => SimpleCalculator.Calculate(1, 2, null)); }
public void Initialise() { calculator = new SimpleCalculator(10, 5); }
public void Addition_with_small_operands() { Assert.Equal("22 + 25 = 47", SimpleCalculator.Calculate(22, 25, "+")); }
public void TestAddition() { Assert.AreEqual(23, SimpleCalculator.Add(10, 13)); }
public void ShouldMultipleTwoDoubles_WithTolerancePercent() { var myObject = new SimpleCalculator(); var result = myObject.AddDouble(50, 50); Assert.That(result, Is.EqualTo(100).Within(1).Percent); }
public void TestMultiplication() { Assert.AreEqual(42, SimpleCalculator.Multiplication(7, 6)); }
public void ShouldAddTwoNumbers() { var sut = new SimpleCalculator(); var result = sut.Add(3.5m, 2m); Assert.That(result, Is.EqualTo(5.5m)); }
public void TestMethod1(int a, int b, double expectedResult) { double result = new SimpleCalculator().Plus(a, b); Assert.AreEqual(expectedResult, result); }
public void ShouldErrorWhenDivideByZero_ExpliciteExceptionType() { var myObject = new SimpleCalculator(); Assert.That(() => myObject.Divide(99, 0), Throws.TypeOf<DivideByZeroException>()); }
public void when_no_expressions_have_been_saved() { SimpleCalculator calculator = new SimpleCalculator(); Assert.That(calculator.SavedExpressions, Is.Empty); }
public void ShouldErrorWhenNumberTooBig_MoreExplicit() { var myObject = new SimpleCalculator(); Assert.That(() => myObject.Divide(200, 2), Throws.TypeOf<ArgumentOutOfRangeException>() .With.Matches<ArgumentOutOfRangeException>(x => x.ParamName == "by")); }
public void Init() { calc = new SimpleCalculator(); }
public void ShouldMultipleTwoDoubles_WithTolerance() { var myObject = new SimpleCalculator(); var result = myObject.AddDouble(1.1, 2.2); Assert.That(result, Is.EqualTo(3.3).Within(0.1)); }
public void ErrorTest() { Assert.Throws <ArgumentException>(() => SimpleCalculator.Calculator(6, 2, '&')); }