public void BinaryGCDCalculationMethod_OrdinaryValues_CalculationTimeNotNull()
{
long time = 0;
int resultGCD = GCDAlgorithms.CalculateBySteinAndTime(5, 0, out time);
Assert.NotNull(time);
}
public long Euclidean_TwoParameters_PositiveTest(long a, long b)
{
long time;
long result = GCDAlgorithms.Euclidean(a, b, out time);
Debug.WriteLine($"Total time: {time}");
return(result);
}
public long Euclidean_Array_Test(params long[] array)
{
long time;
long result = GCDAlgorithms.Euclidean(out time, array);
Debug.WriteLine($"Total time: {time}");
return(result);
}
public void FindGCDEuclidTest_3()
{
int a = 7396;
int b = 1978;
int c = 1204;
int expected = 86;
int actual = GCDAlgorithms.FindGCDEuclid(a, b, c);
Assert.AreEqual(actual, expected);
}
public void SpeedTestV1_EuclideanIsFaster()
{
int[] arr = Enumerable.Range(1, 100_000).ToArray();
long euclideanMilliseconds;
long steinMilliseconds;
GCDAlgorithms.FindGcdByEuclidean(out euclideanMilliseconds, arr);
GCDAlgorithms.FindGcdByStein(out steinMilliseconds, arr);
Assert.IsTrue(steinMilliseconds > euclideanMilliseconds);
}
private int GetGcd(int[] numbers, string algorithmType)
{
if (algorithmType == "euclidiean")
{
return(GCDAlgorithms.GetEuclidieanGcd(numbers));
}
else
{
return(GCDAlgorithms.GetSteinGcd(numbers));
}
}
public ActionResult GCD(int numberFirst, int numberSecond, string algorithm)
{
if (algorithm == "Eukledian")
{
ViewBag.Result = GCDAlgorithms.CalculateByEuclidean(numberFirst, numberSecond);
}
else
{
ViewBag.Result = GCDAlgorithms.CalculateByStein(numberFirst, numberSecond);
}
return(View());
}
public void SteinGCD_TwoNumbersAreIntMinValue_ThrowArgumentException() => Assert.Throws <ArgumentException>(() => GCDAlgorithms.GetSteinGcd(int.MinValue, int.MinValue));
public int SteinGCD_TwoNumbersPassed_ReturnResult(int a, int b)
{
int result = GCDAlgorithms.GetSteinGcd(out _, a, b);
return(result);
}
public void GetGcdBySteinV1_WithMinValueParameter_ThrowsOutOfRangeException(params int[] vs) => Assert.Throws <ArgumentOutOfRangeException>(() => GCDAlgorithms.FindGcdByStein(vs));
public int EuclidianGCD_ConreteArrayOfNumbers_ReturnResult(int[] numbers)
{
return(GCDAlgorithms.GetEuclidieanGcd(numbers));
}
public void SteinGCD_ArrayHasOneElement_ThrowArgumentException() =>
Assert.Throws <ArgumentException>(() => GCDAlgorithms.GetSteinGcd(new int[] { 12 }));
public static int GetGcdBySteinV1_With3ValidParameters(int firstNumber, int secondNumber, int thirdNumber) => GCDAlgorithms.FindGcdByStein(firstNumber, secondNumber, thirdNumber);
public static void FindGcdByEuclidian_IntMinValue_ArgumentExeption(params long[] numbers)
{
Assert.Throws <ArgumentException>(() => GCDAlgorithms.FindGcdByEuclidean(int.MaxValue, int.MinValue));
}
public void SteinGCD_ArrayIsNull_ThrowArgumentNullException() => Assert.Throws <ArgumentNullException>(() => GCDAlgorithms.GetSteinGcd(null));
public static int FindGcdByStein_Params_GCD(params int[] numbers) => GCDAlgorithms.SteinsAlgorithm(numbers);
public static void FindGcdByStein_ZeroParams_ArgumentExeption(params long[] numbers)
{
Assert.Throws <ArgumentException>(() => GCDAlgorithms.SteinsAlgorithm(0, 0, 0, 0, 0, 0, 0));
}
public static int FindGcdByStein_TwoNumbers_GCD(int val1, int val2) => GCDAlgorithms.SteinsAlgorithm(val1, val2);
public static int FindGcdByEuclidean_Params_GCD(params int[] numbers) => GCDAlgorithms.FindGcdByEuclidean(numbers);
public static int FindGcdByEuclidean_TwoNumbers_GCD(int val1, int val2) => GCDAlgorithms.FindGcdByEuclidean(val1, val2);
public void SteinGCD_ThreeNumbersAreZeros_ThrowArgumentException() => Assert.Throws <ArgumentException>(() => GCDAlgorithms.GetSteinGcd(0, 0, 0));
public void GetGcdBySteinV1_WithManyValidParameters(int expectedResult, params int[] vs)
{
int result = GCDAlgorithms.FindGcdByStein(vs);
Assert.AreEqual(expectedResult, result);
}
public int SteinGCD_ThreeNumbers_ReturnResult(int a, int b, int c)
{
return(GCDAlgorithms.GetSteinGcd(out _, a, b, c));
}
public void EuclidianGCD_TwoNumbersAreIntMinValue_ThrowArgumentOutOfRangeException() => Assert.Throws <ArgumentOutOfRangeException>(() => GCDAlgorithms.GetEuclidieanGcd(int.MinValue, int.MinValue));
public void SteinGCD_ArrayIsEmpty_ThrowArgumentException() =>
Assert.Throws <ArgumentException>(() => GCDAlgorithms.GetSteinGcd(new int[] { }));
public void EuclidianGCD_TwoNumbersAreZeros_ThrowArgumentException() => Assert.Throws <ArgumentException>(() => GCDAlgorithms.GetEuclidieanGcd(0, 0));
public int SteinGCD_ConreteArrayOfNumbers_ReturnResult(int[] numbers)
{
return(GCDAlgorithms.GetSteinGcd(out _, numbers));
}
public int EuclidianGCD_ThreeNumbers_ReturnResult(int a, int b, int c)
{
return(GCDAlgorithms.GetEuclidieanGcd(a, b, c));
}
public int EuclidianGCD_TwoNumbersPassed_ReturnResult(int a, int b)
{
return(GCDAlgorithms.GetEuclidieanGcd(a, b));
}
public void GetGcdBySteinV1_WithAllZeroParameters_ThrowsArgumentException(params int[] vs) => Assert.Throws <ArgumentException>(() => GCDAlgorithms.FindGcdByStein(vs));
