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, '&'));
}
