public void FiboncciGeneratorInvalidArgumentsTest()
{
foreach (var i in FibonacciSequenceGenerator.GenerateSequence(-1))
{
Debug.WriteLine(i);
}
}
public void getRangeOfN_FibonacciNumbers_StartingFromZero()
{
var expectedNumbers = new int[] { 1, 1, 2, 3, 5 };
var actualNumbers = new FibonacciSequenceGenerator().GetRangeOfN(1, 5);
CollectionAssert.AreEqual(expectedNumbers, actualNumbers);
}
public void getRangeOfN_FibonacciNumbers()
{
var expectedNumbers = new int[] { 5, 8, 13, 21, 34 };
var actualNumbers = new FibonacciSequenceGenerator().GetRangeOfN(5, 5);
CollectionAssert.AreEqual(expectedNumbers, actualNumbers);
}
public void FiboncciGeneratorTest()
{
var sequence = FibonacciSequenceGenerator.GenerateSequence(12).ToList();
var cachedSequence = new List <int> {
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89
};
CollectionAssert.AreEqual(sequence, cachedSequence);
}
public void InitializeTest_IncorrectInputForOneArguments_ExpectedException
(int boundaryValue)
{
//Arrange
FibonacciSequenceGenerator fb = new FibonacciSequenceGenerator();
//Act
fb.Initialize(boundaryValue);
}
public void getFirstTenFibonacciNumbersWithGetRangeN()
{
var expectedNumbers = new int[] { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
var generator = new FibonacciSequenceGenerator();
var actualNumbers = generator.GetRange(55);
CollectionAssert.AreEqual(expectedNumbers, actualNumbers);
}
public void RedisCacheTest()
{
var cache = new FibonacciSequenceRedisCache();
var sequence = FibonacciSequenceGenerator.GenerateSequence(15).ToList();
cache.Set("key1", sequence);
var cachedSequence = cache.Get("key1").ToList();
CollectionAssert.AreEqual(sequence, cachedSequence);
}
public void GeneratesFibonacciSequence()
{
// Act
var response = FibonacciSequenceGenerator.GenerateFibonacciSequence(10);
// Assert
Assert.AreEqual(response, new List <BigInteger> {
0, 1, 1, 2, 3, 5, 8, 13, 21, 34
});
}
public ActionResult <List <BigInteger> > Get(int length)
{
if (length > 0 && length <= 100000)
{
return(FibonacciSequenceGenerator.GenerateFibonacciSequence(length));
}
else
{
return(BadRequest("Parameter should be positive integer between 1 and 100000"));
}
}
public void InitializeTest_DoNotInitializeGenerator_ExpectedException()
{
//Arrange
FibonacciSequenceGenerator fb = new FibonacciSequenceGenerator();
//Act
foreach (int element in fb)
{
Console.WriteLine(element);
}
}
public void getFirstTenFibonacciNumbersWithGetNext()
{
var expectedNumbers = new int[] { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
var actualNumbers1 = new int[10];
var generator = new FibonacciSequenceGenerator();
for (var i = 0; i < 10; i++)
{
actualNumbers1[i] = generator.GetNext();
}
CollectionAssert.AreEqual(expectedNumbers, actualNumbers1);
}
public void getNext_N_Numbers()
{
var expectedNumbers = new int[] { 5, 8 };
var generator = new FibonacciSequenceGenerator();
for (var i = 0; i < 4; i++)
{
generator.GetNext();
}
var actualNumbers = generator.GetNext(2);
CollectionAssert.AreEqual(expectedNumbers, actualNumbers);
}
public void GetEnumeratorTest_CorrectInputForOneArguments(int boundaryValue, int[] expected)
{
//Arrange
FibonacciSequenceGenerator fb = new FibonacciSequenceGenerator();
fb.Initialize(boundaryValue);
int[] actual = new int[0];
//Act
int i = 0;
foreach (int element in fb)
{
Console.WriteLine(element);
Array.Resize <int>(ref actual, i + 1);
actual[i] = element;
i++;
}
//Assert
CollectionAssert.AreEqual(expected, actual);
}
public static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: false)
.Build();
var host = BuildWebHost(args);
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <FibonacciDbContext>();
FibonacciSequenceGenerator.Initialize(context, System.Convert.ToInt32(config.GetSection("MaxStepNumber").Value));
}
catch (Exception ex)
{
throw ex;
}
}
host.Run();
}
public static void Parse(
string[] args,
out ISequenceGenerator sequenceGenerator,
out int boundaryValue,
out int?startValue)
{
if (args.Length < (int)ArgumentsCount.Minimum)
{
throw new ArgumentException("You do not have enough arguments! "
+ "Please, enter the correct number of arguments!");
}
if (args.Length > (int)ArgumentsCount.Maximum)
{
throw new ArgumentException("You have too many arguments! "
+ "Please, enter the correct number of arguments!");
}
string sequenceGeneratorType = args[0].ToLower();
switch (sequenceGeneratorType)
{
case "fibonacci":
sequenceGenerator = new FibonacciSequenceGenerator();
break;
case "squarelessn":
sequenceGenerator = new SquareLessNSequenceGenerator();
break;
default:
throw new ArgumentException("Please, enter correct algorithm "
+ "for searching the sequence");
}
if (!int.TryParse(args[1], out boundaryValue))
{
throw new ArgumentException("The second argument is not a number or is a too big number!");
}
startValue = null;
if (args.Length == (int)ArgumentsCount.Maximum)
{
int thirdArgument;
if (!int.TryParse(args[2], out thirdArgument))
{
throw new ArgumentException("The third argument is not a number!");
}
else
{
startValue = thirdArgument;
if (startValue - boundaryValue > 0)
{
throw new ArgumentException("The third argument (boundary value) can not be "
+ "bigger than second (start value)! Please, check your arguments!");
}
if (startValue < 0 || boundaryValue < 0)
{
throw new ArgumentException("Arguments can not be negative!");
}
}
}
}
