public void InsertNumber_ArgumentExceptionIndexLessThan0Test()
{
int numberSource = 15, numberIn = 15;
int firstIndex = -1, lastIndex = 0;
NumberAlgorithm.InsertNumber(numberSource, numberIn, firstIndex, lastIndex);
}
public void InsertNumber_ArgumentExceptionFirstIndexGreaterThanLastTest()
{
int numberSource = 15, numberIn = 15;
int firstIndex = 2, lastIndex = 1;
NumberAlgorithm.InsertNumber(numberSource, numberIn, firstIndex, lastIndex);
}
public int[] FilterDigit_GetNumbersWithSearchNumberTests(int[] numbers, int searchNumber)
{
List <int> numbersList = numbers.ToList <int>();
List <int> resultList = NumberAlgorithm.FilterDigit(numbersList, searchNumber);
return(resultList.ToArray());
}
public void FindNthRootTest(double number, int power, double accuracy)
{
double expected = Math.Pow(number, 1.0 / power);
double actual = NumberAlgorithm.FindNthRoot(number, power, accuracy);
bool result = Math.Abs(expected - actual) < accuracy;
Assert.IsTrue(result);
}
public void InsertNumber_NumberInsert8and15From3To8Test()
{
int numberSource = 8, numberIn = 15;
int firstIndex = 3, lastIndex = 8;
int expected = 120;
int result = NumberAlgorithm.InsertNumber(numberSource, numberIn, firstIndex, lastIndex);
Assert.AreEqual(expected, result);
}
public void InsertNumber_NumberInsert15and15From0To0Test()
{
int numberSource = 15, numberIn = 15;
int firstIndex = 0, lastIndex = 0;
int expected = 15;
int result = NumberAlgorithm.InsertNumber(numberSource, numberIn, firstIndex, lastIndex);
Assert.AreEqual(expected, result);
}
public void Test1()
{
Assert.Equal(24, NumberAlgorithm.Gcd(24, 0));
Assert.Equal(8, NumberAlgorithm.Gcd(24, 8));
Assert.Equal(4, NumberAlgorithm.Gcd(24, 20));
Assert.Equal(24, NumberAlgorithm.Gcd(0, 24));
Assert.Equal(8, NumberAlgorithm.Gcd(8, 24));
Assert.Equal(4, NumberAlgorithm.Gcd(20, 24));
}
public void InsertNumber_1insertNegative2from0to0_exceptionReturned()
{
// Arrange.
int number1 = 1, number2 = -2;
int i = 0, j = 0;
// Act.
NumberAlgorithm.InsertNumber(number1, number2, i, j);
// Assert.
}
public void InsertNumber_8insert15from3toNegative8_exceptionReturned()
{
// Arrange.
int number1 = 8, number2 = 15;
int i = 3, j = -8;
// Act.
NumberAlgorithm.InsertNumber(number1, number2, i, j);
// Assert.
}
public void InsertNumber_8insert15from8to3_exceptionReturned()
{
// Arrange.
int number1 = 8, number2 = 15;
int i = 8, j = 3;
// Act.
NumberAlgorithm.InsertNumber(number1, number2, i, j);
// Assert.
}
public void FindNthRoot_RootFindingTests(double number, int rootPower, double eps)
{
if (number < 0)
{
Assert.IsTrue(Math.Abs(NumberAlgorithm.FindNthRoot(number, rootPower, eps) + Math.Pow(Math.Abs(number), 1.0 / rootPower)) < eps);
}
else
{
Assert.IsTrue(Math.Abs(NumberAlgorithm.FindNthRoot(number, rootPower, eps) - Math.Pow(number, 1.0 / rootPower)) < eps);
}
}
public BigInteger[] FibonacciNumbersTest2(int length)
{
var result = new BigInteger[length];
int i = 0;
foreach (var number in NumberAlgorithm.FibonacciNumbers(length))
{
result[i++] = number;
}
return(result);
}
public void InsertNumber_15insertIn15from0to0_15returned()
{
// Arrange.
int number1 = 15, number2 = 15;
int i = 0, j = 0;
int expected = 15;
// Act.
int actual = NumberAlgorithm.InsertNumber(number1, number2, i, j);
// Assert.
Assert.AreEqual(expected, actual);
}
public void InsertNumber_8insertIn15from3to8_120returned()
{
// Arrange.
int number1 = 8, number2 = 15;
int i = 3, j = 8;
int expected = 120;
// Act.
int actual = NumberAlgorithm.InsertNumber(number1, number2, i, j);
// Assert.
Assert.AreEqual(expected, actual);
}
public BigInteger[] FibonacciNumbersTest1(int length) => NumberAlgorithm.CalculateFibonacciNumbers(length).ToArray();
public int InsertNumberTest(int number1, int number2, int i, int j)
{
return(NumberAlgorithm.InsertNumber(number1, number2, i, j));
}
public void InsertNumber_ThrowsArgumentException(int number1, int number2, int i, int j)
{
Assert.Throws <ArgumentException>(
() => NumberAlgorithm.InsertNumber(number1, number2, i, j));
}
public int FindNextBiggerNumberTest(int source)
{
return(NumberAlgorithm.FindNextBiggerNumber(source));
}
public void FindNthRoot_ThrowsArgumentException(double number, int power, double accuracy)
{
Assert.Throws <ArgumentException>(
() => NumberAlgorithm.FindNthRoot(number, power, accuracy));
}
public void FindNextBiggerNumber_ThrowsArgumentException(int source)
{
Assert.Throws <ArgumentException>(
() => NumberAlgorithm.FindNextBiggerNumber(source));
}
public void InsertNumber_ArgumentExceptionTests(int numberSource, int numberIn, int firstIndex, int lastIndex)
{
Assert.Throws <ArgumentException>(() => NumberAlgorithm.InsertNumber(numberSource, numberIn, firstIndex, lastIndex));
}
public int InsertNumber_NumberInsertTests(int numberSource, int numberIn, int firstIndex, int lastIndex)
{
return(NumberAlgorithm.InsertNumber(numberSource, numberIn, firstIndex, lastIndex));
}
public int FindNextBiggerNumber_NextBiggerFindingTests(int number)
{
return(NumberAlgorithm.FindNextBiggerNumber(number));
}
public void FindNthRoot_ArgumentExceptionTests(double number, int rootPower, double eps)
{
Assert.Throws <ArgumentException>(() => NumberAlgorithm.FindNthRoot(number, rootPower, eps));
}
public void FindNextBiggerNumber_ArgumentExceptionTests(int number)
{
Assert.Throws <ArgumentException>(() => NumberAlgorithm.FindNextBiggerNumber(number));
}
public void FilterDigit_ArgumentNullExceptionTests(List <int> numbersList, int searchNumber)
{
Assert.Throws <ArgumentNullException>(() => NumberAlgorithm.FilterDigit(numbersList, searchNumber));
}
public void FibonacciNumbersArgumentExceptionThrown(int length) => Assert.Throws <ArgumentException>(() => NumberAlgorithm.CalculateFibonacciNumbers(length));
