public void CalculateTest(double firstValue, double secondValue, double expected)
{
var calculator = new AdditionCalculator();
var actualResult = calculator.Calculate(firstValue, secondValue);
Assert.AreEqual(expected, actualResult);
}
public void CalculateTest(double firstArgument, double secondArgument, double expectedResult)
{
var calculator = new AdditionCalculator();
var actualResult = calculator.Calculate(firstArgument, secondArgument);
Assert.AreEqual(actualResult, expectedResult);
}
public void Calculate()
{
ITwoArgumentsCalculator calculator = new AdditionCalculator();
double result = calculator.Calculate(1, 2);
Assert.AreEqual(3, result);
}
public void CalculateTests()
{
AdditionCalculator additionCalculator = new AdditionCalculator();
double result = additionCalculator.Calculate(1, 2);
Assert.AreEqual(3, result);
}
public void AdditionCalculatorTest()
{
var calculator = new AdditionCalculator();
double actual = calculator.Calculate(1, 2);
Assert.AreEqual(3, actual);
}
void CalcMetTests()
{
AdditionCalculator addc = new AdditionCalculator();
double ExpResult = 33 + 66, actResult = addc.CalcMet(33, 66);;
Assert.AreEqual(ExpResult, actResult);
}
public void CalculateTest()
{
double expected = -32;
double actual = new AdditionCalculator().Calculate(-33, 1);
Assert.AreEqual(expected, actual);
}
public void AdditionCalculator()
{
AdditionCalculator calculator = new AdditionCalculator();
double actual = calculator.Calculate(1, 1);
Assert.AreEqual(2, actual);
}
public void AdditionCalculatorTests(double firstArgument, double secondArgument, double result)
{
var calculator = new AdditionCalculator();
var actualResult = calculator.Calculate(firstArgument, secondArgument);
Assert.AreEqual(result, actualResult);
}
public void CalculateTest(double valueOne, double valueTwo, double result)
{
var calculator = new AdditionCalculator();
var testResult = calculator.Calculate(valueOne, valueTwo);
Assert.AreEqual(result, testResult);
}
public void CalculateTest()
{
AdditionCalculator calculator = new AdditionCalculator();
Assert.AreEqual(12, calculator.Calculate(7, 5));
Assert.AreEqual(30, calculator.Calculate(15, 15));
Assert.AreEqual(21, calculator.Calculate(10.6, 10.4));
}
public void CalculateTest()
{
AdditionCalculator calculator = new AdditionCalculator();
Assert.AreEqual(10, calculator.Calculate(5, 5));
Assert.AreEqual(26, calculator.Calculate(12, 14));
Assert.AreEqual(5.3, calculator.Calculate(5.2, 0.1));
}
public void AdditionCalculator(
double firstValue,
double secondValue,
double expected)
{
AdditionCalculator calculator = new AdditionCalculator();
double actual = calculator.Calculate(firstValue, secondValue);
Assert.AreEqual(expected, actual);
}
public void Test_For_2_Numbers_Returns_The_Sum_Of_Those_Numbers()
{
//Arrange
var additionCalculator = new AdditionCalculator();
//Act
int result = additionCalculator.AddNumbers("1", "2");
//Assert
Assert.AreEqual(3, result);
}
public void Test_For_1_Number_Returns_That_Number_Plus_Zero()
{
//Arrange
var additionCalculator = new AdditionCalculator();
//Act
int result = additionCalculator.AddNumbers("1");
//Assert
Assert.AreEqual(1, result);
}
public void Test_Empty_String()
{
//Arrange
string numbers = string.Empty;
var additionCalculator = new AdditionCalculator();
//Act
int result = additionCalculator.AddNumbers("");
//Assert
Assert.AreEqual(0, result);
}
public void ShouldReturnCorrectSumOfNumbers()
{
var calculator = new AdditionCalculator(new List <int> {
1, 2, 3
});
var actualResult = calculator.Calculate();
Assert.AreEqual(actualResult, 6);
calculator = new AdditionCalculator(new List <int> {
7, 11, 24, 7
});
actualResult = calculator.Calculate();
Assert.AreEqual(actualResult, 49);
}
private ICalculator <float> CreateCalculator(CalculateType calculateType, params float[] values)
{
ICalculator <float> ret = null;
switch (calculateType)
{
case CalculateType.Addition:
ret = new AdditionCalculator <float>(values[0], values[1]);
break;
case CalculateType.Subtraction:
ret = new SubtractionCalculator <float>(values[0], values[1]);
break;
case CalculateType.Multiplication:
ret = new MultiplicationCalculator <float>(values[0], values[1]);
break;
case CalculateType.Division:
ret = new DivisionCalculator <float>(values[0], values[1]);
break;
case CalculateType.Power:
ret = new PowerCalculator <float>(values[0], values[1]);
break;
case CalculateType.Sine:
ret = new SineCalculator <float>(values[0]);
break;
case CalculateType.Cosine:
ret = new CosineCalculator <float>(values[0]);
break;
}
return(ret);
}
public void AdditionCalculatorTest()
{
AdditionCalculator calculator = new AdditionCalculator();
Assert.AreEqual(3, calculator.Calculate(2, 1));
}
