public void NthRoot_TakesArguments_ReturnCalculatedRoots()
{
//< param name = "result" > It's array wich contains testcases for FindNthRoot.NthRoot method.
//</ param >
double[,] result = new double[, ]
{
// Format {numb, exp, accurancy, expected value}. Where "numb" is the base of the arithmetic root,
// "exp" is the exponent of arithmetic root, accurancy is the setted accurancy
{ 1, 5, 0.0001, 1 },
{ 8, 3, 0.0001, 2 },
{ 0.001, 3, 0.00010, 0.1 },
{ 0.04100625, 4, 0.0001, 0.45 },
{ 8, 3, 0.0001, 2 },
{ 0.0279936, 7, 0.0001, 0.6 },
{ 0.0081, 4, 0.1, 0.3 },
{ -0.008, 3, 0.1, -0.2 },
{ 0.004241979, 9, 0.00000001, 0.545 },
{ 9, 2, 0.1, 3 },
{ 100, 2, 0.1, 10 },
{ -27, 3, 0.1, -3 },
{ -14, 5, 0.001, -1.695 },
{ 0.51, 4, 0.000001, 0.845 },
{ 2.811, 6, 0.0001, 1.188 }
};
for (int i = 0; i < result.GetLength(0); i++)
{
Assert.AreEqual(FindNthRoot.NthRoot(result[i, 0], result[i, 1], result[i, 2]), result[i, 3]);
}
}
public void NewtonMethod_CorrectInputValues_PositiveTest(double number, double n, double accuracy, double ExpectedResult)
{
double actual = FindNthRoot.NewtonMethod(number, n, accuracy);
double expected = ExpectedResult;
NUnit.Framework.Assert.AreEqual(actual, expected, accuracy);
}
public double DoCalculationTest(double number, int degree, double precision)
{
// arrange
var findNthRootObj = new FindNthRoot();
// act + assert
return(findNthRootObj.DoCalculation(number, degree, precision));
}
public void FindRootTest_00081and4and01_03result()
{
double testValue = 0;
testValue = FindNthRoot.FindRoot(0.0081, 4, 0.1);
Assert.AreEqual(0.3, testValue);
}
public void FindRootTest_00279936and7and0001_06result()
{
double testValue = 0;
testValue = FindNthRoot.FindRoot(0.0279936, 7, 0.0001);
Assert.AreEqual(0.6, testValue);
}
public void FindRootTest_8and3and0001_2result()
{
double testValue = 0;
testValue = FindNthRoot.FindRoot(8, 3, 0.0001);
Assert.AreEqual(2, testValue);
}
public void FindRootTest_004100625and4and0001_045result()
{
double testValue = 0;
testValue = FindNthRoot.FindRoot(0.04100625, 4, 0.0001);
Assert.AreEqual(0.45, testValue);
}
public void FindRootTest_Negative0008and3and01_Negative02result()
{
double testValue = 0;
testValue = FindNthRoot.FindRoot(-0.008, 3, 0.1);
Assert.AreEqual(-0.2, testValue);
}
public void FindRootTest_1and5and0001_1result()
{
double testValue = 0;
testValue = FindNthRoot.FindRoot(1, 5, 0.0001);
Assert.AreEqual(1, testValue);
}
public void doCalculationTest_Number_Degree_Precision_ArgumentOutOfRangeException
(double number, int degree, double precision)
{
// arrange
var findNthRootObj = new FindNthRoot();
// act + assert
Assert.Throws <ArgumentOutOfRangeException>(
() => findNthRootObj.DoCalculation(number, degree, precision));
}
public void Test_FindRoot(double number, int powerRoot, double eps, double expected)
{
double actual = FindNthRoot.FindRoot(number, powerRoot, eps);
Assert.AreEqual(expected, actual, eps);
}
public void Insertion_InputValuesLess0_ThrowsArgumentException(double number, double n, double accuracy)
{
NUnit.Framework.Assert.Throws <ArgumentException>(() => FindNthRoot.NewtonMethod(number, n, accuracy));
}
public void FindRoot_NegativeAccuracy_ArgumentException(double value, double power, double accuracy)
{
Assert.Throws <ArgumentException>(() => FindNthRoot.FindRoot(value, power, accuracy));
}
public void NthRootNUnitTests_WithNegativeRootExponent_ThrowsArgumentException()
{
Assert.That(() => FindNthRoot.NthRoot(9, -2, 0.001),
Throws.ArgumentException.With.Message
.EqualTo("Exponent should be only positive number"));
}
public double NthRootNUnitTests(double numb, double exp, double accurancy)
{
return(FindNthRoot.NthRoot(numb, exp, accurancy));
}
public void FindRootExceptionTest(double num, int n, double precision)
{
Assert.Throws <ArgumentOutOfRangeException>(()
=> FindNthRoot.FindRoot(num, n, precision));
}
public double FindRootTest(double num, int n, double precision) => FindNthRoot.FindRoot(num, n, precision);
public void NthRoot_WithNotValidAccurancy_ThrowsArgumentException() => FindNthRoot.NthRoot(9, 2, -1);
public void NthRoot_WithNegativeRootExponent_ThrowsArgumentExceptio() => FindNthRoot.NthRoot(9, -2, 0.001);
public void FindRootTest_Negative16and4and0001_06result()
{
double testValue = 0;
testValue = FindNthRoot.FindRoot(-16, 4, 0.0001);
}
public void FindNthRootTestCase(double a, int n, double eps, double expected)
{
double actual = FindNthRoot.SqrtN(a, n, eps);
Assert.AreEqual(actual, expected, eps);
}
public void NthRootNUnitTests_WithNegativeArguments_ThrowsArgumentException()
{
Assert.That(() => FindNthRoot.NthRoot(-9, 2, 0.001),
Throws.ArgumentException.With.Message
.EqualTo("Not execute even-numbered roots from negative number"));
}
public void FindNthRoot_ThrowArgumentException(double a, int n, double eps)
{
Assert.Throws <ArgumentException>(() => FindNthRoot.SqrtN(a, n, eps));
}
public void NthRootNUnitTests_WithNotValidAccurancy_ThrowsArgumentException()
{
Assert.That(() => FindNthRoot.NthRoot(9, 2, -1),
Throws.ArgumentException.With.Message
.EqualTo("The accurancy is not valid"));
}
public void FindRoot_RootedValuePowerAccuracy_NthRoot(double value, double power, double accuracy, double actual)
{
var myRoot = FindNthRoot.FindRoot(value, power, accuracy);
Assert.AreEqual(myRoot, actual, accuracy);
}
