public void Fibonacci_Minus1_ShouldReturnOne()
{
var fibonacciService = new FibonacciService();
var actual = fibonacciService.Calculate("-1");
Assert.AreEqual(1, actual);
}
public void Fibonacci_Seven_ShouldReturn13()
{
var fibonacciService = new FibonacciService();
var actual = fibonacciService.Calculate("7");
Assert.AreEqual(13, actual);
}
public void GetFibonacciNumberAtPosition_WhenNumberIsGreaterThan92_ServiceCalled_Never_WithException()
{
try
{
//assemble
_logic = new Mock <IFibonacciLogic>();
_logic.Setup(logic => logic.FindFibonacciNumberAtPosition(It.IsAny <long>()))
.Returns(It.IsAny <long>());
_sut = new FibonacciService(_logic.Object);
long expected = 93;
//act
var result = _sut.GetFibonacciNumberAtPosition(expected.ToString());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
finally
{
//assert
_logic.Verify(m => m.FindFibonacciNumberAtPosition(It.IsAny <long>()), Times.Never);
}
}
public void Fibonacci_PositiveLargeNumber_ShouldReturnOutOfRangeException()
{
var fibonacciService = new FibonacciService();
Action act = () => fibonacciService.Calculate("93");
act.Should().Throw <ArgumentOutOfRangeException>();
}
public void Fibonacci_Zero_ShouldReturnZero()
{
var fibonacciService = new FibonacciService();
var actual = fibonacciService.Calculate("0");
Assert.AreEqual(0, actual);
}
public void GetFibonacciMethodMustThrowWrongInputExceptionWhenInputIsSmallerThanMinus92()
{
var mockedMemoryCacheWrapper = new Mock <IMemoryCacheWrapper>();
var fibonacciService = new FibonacciService(mockedMemoryCacheWrapper.Object);
Assert.Throws <WrongInputException>(() => fibonacciService.GetFibonacci(-93));
}
public void Fibonacci_Three_ShouldReturnTwo()
{
var fibonacciService = new FibonacciService();
var actual = fibonacciService.Calculate("3");
Assert.AreEqual(2, actual);
}
public void Fibonacci_Four_ShouldReturn3()
{
var fibonacciService = new FibonacciService();
var actual = fibonacciService.Calculate("4");
Assert.AreEqual(3, actual);
}
public void Fibonacci_Eight_ShouldReturn21()
{
var fibonacciService = new FibonacciService();
var actual = fibonacciService.Calculate("8");
Assert.AreEqual(21, actual);
}
public void Fibonacci_Six_ShouldReturn5()
{
var fibonacciService = new FibonacciService();
var actual = fibonacciService.Calculate("6");
Assert.AreEqual(8, actual);
}
public void GetFibonacciSequenceUntil_Zero_Exception()
{
FibonacciService fibonacciService = new FibonacciService();
Exception exception = Assert.Throws <ArgumentException>(() =>
fibonacciService.GetFibonacciSequenceUntil(0));
Assert.Equal(ErrorMessages.MUST_BE_GREATER_THAN_ZERO, exception.Message);
}
public void GetFibonacciSequenceUntil_MaxInt_Exception()
{
FibonacciService fibonacciService = new FibonacciService();
Exception exception = Assert.Throws <ArgumentException>(() =>
fibonacciService.GetFibonacciSequenceUntil(int.MaxValue));
Assert.Equal(ErrorMessages.MUST_BE_LESS_THAN_ONE_THOUSAND, exception.Message);
}
public void FibonacciMemory(int boarder)
{
var fibonacciService = new FibonacciService(new MemoryCache <IEnumerable <int> >(MemoryPrefix));
foreach (var number in fibonacciService.Start(boarder))
{
Console.Write($"{number} ");
}
}
public void GetFibonacciSequenceWithLength_15_FibonacciSequenceUnti377()
{
FibonacciService fibonacciService = new FibonacciService();
int[] expectedData = new int[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377 };
int[] actualData = fibonacciService.GetFibonacciSequenceWithLength(15);
Assert.Equal(expectedData, actualData);
}
public void GetFibonacciMethodMustReturnProperValueForNegativeInteger()
{
var mockedMemoryCacheWrapper = new Mock <IMemoryCacheWrapper>();
var fibonacciService = new FibonacciService(mockedMemoryCacheWrapper.Object);
var result = fibonacciService.GetFibonacci(-10);
Assert.Equal(-55, result);
}
public void FibonacciRedis(int boarder)
{
var fibonacciService = new FibonacciService(new RedisCache <IEnumerable <int> >(HostName, RedisPrefix));
foreach (var number in fibonacciService.Start(boarder))
{
Console.Write($"{number} ");
}
}
public void GetFibonacciMethodMustReturnZeroForInputEqualsZero()
{
var mockedMemoryCacheWrapper = new Mock <IMemoryCacheWrapper>();
var fibonacciService = new FibonacciService(mockedMemoryCacheWrapper.Object);
var result = fibonacciService.GetFibonacci(0);
Assert.Equal(0, result);
}
public void GetFibonacciSequenceUntil_10_FibonacciSequenceUntil8()
{
FibonacciService fibonacciService = new FibonacciService();
int[] expectedData = new int[] { 0, 1, 1, 2, 3, 5, 8 };
int[] actualData = fibonacciService.GetFibonacciSequenceUntil(10);
Assert.Equal(expectedData, actualData);
}
public void GetFibonacciSequenceWithLength_10_FibonacciSequenceUnti34()
{
FibonacciService fibonacciService = new FibonacciService();
int[] expectedData = new int[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };
int[] actualData = fibonacciService.GetFibonacciSequenceWithLength(10);
Assert.Equal(expectedData, actualData);
}
public void GetFibonacciSequenceUntil_1000_FibonacciSequenceUntil987()
{
FibonacciService fibonacciService = new FibonacciService();
int[] expectedData = new int[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987 };
int[] actualData = fibonacciService.GetFibonacciSequenceUntil(1000);
Assert.Equal(expectedData, actualData);
}
public void GetFibonacciSequenceUntil_35_FibonacciSequenceUntil34()
{
FibonacciService fibonacciService = new FibonacciService();
int[] expectedData = new int[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };
int[] actualData = fibonacciService.GetFibonacciSequenceUntil(35);
Assert.Equal(expectedData, actualData);
}
static void Main(string[] args)
{
int[] numArray;
var notFibonacci = new List <int>();
Console.WriteLine("\n\nWelcome to Luke's Number App");
Console.WriteLine("Please see the output of numbers not in the Fibonacci series\n");
//test.......................
// .........................
try
{
if (args.Length == 0)
{
throw new Exception("You must supply an argument for a *.txt file");
}
var filename = args[0];
var numbersAsString = FileReader.Instance.ReadFile(filename);
try
{
numArray = numbersAsString.Split(' ')
.Select(n => Convert.ToInt32(n))
.ToArray();
}
catch (Exception)
{
throw new Exception("The file must contain whole numbers seperated by spaces");
}
foreach (var num in numArray)
{
if (!FibonacciService.GetFibonnaci(num))
{
notFibonacci.Add(num);
}
}
notFibonacci.Sort();
Console.WriteLine("output...");
notFibonacci.ForEach(x => Console.WriteLine(x.ToString()));
Console.WriteLine("\nPress any key to exit");
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void FibonacciLength_ValidData_ValidResult(long[] array, int length)
{
List <long> expected = new List <long>();
CreateList(ref expected, array);
List <long> actual = new List <long>();
FibonacciService service = new FibonacciService();
actual = service.FibonacciByLength(length);
CollectionAssert.AreEqual(expected, actual);
}
public void FibonacciValue_ValidData_ValidResult(long[] array, long number)
{
List <long> expected = new List <long>();
CreateList(ref expected, array);
List <long> actual = new List <long>();
FibonacciService service = new FibonacciService();
actual = service.FibonacciByValue(number);
CollectionAssert.AreEqual(expected, actual);
}
public void CalculateFibonacciSequenceUntil_2_SequenceUntil2()
{
FibonacciService fibonacciService = new FibonacciService();
List <int> actualResult = fibonacciService.CalculateFibonacciSequenceUntil(2);
List <int> resultExpected = new List <int>()
{
0, 1, 1, 2
};
Assert.AreEqual(resultExpected, actualResult);
}
public void GetNthFibonacciNumber_OnFibonacciService_ReturnsValidFibonacci()
{
//Arrange
IFibonacciService fibService = new FibonacciService();
//Act
var test1Result = fibService.GetNthFibonacciNumber(10);
var test2Result = fibService.GetNthFibonacciNumber(50);
//Assert
Assert.That(test1Result, Is.EqualTo(55));
Assert.That(test2Result, Is.EqualTo(12586269025));
}
public void GetFibonacciNumberAtPosition_WhenValid_ServiceCalled_Ones()
{
//assemble
_logic = new Mock <IFibonacciLogic>();
_logic.Setup(logic => logic.FindFibonacciNumberAtPosition(It.IsAny <long>()))
.Returns(It.IsAny <long>());
_sut = new FibonacciService(_logic.Object);
long expected = 9;
//act
var result = _sut.GetFibonacciNumberAtPosition(expected.ToString());
//assert
_logic.Verify(m => m.FindFibonacciNumberAtPosition(It.Is <long>(input => input == expected)), Times.Once);
}
static void Main(string[] args)
{
var fibService = new FibonacciService();
uint number = 35;
var timer = new System.Diagnostics.Stopwatch();
timer.Start();
uint fibNumber = fibService.GetFibonacciNumber(number);
timer.Stop();
Console.WriteLine($"Fibonacci number of {number} is {fibNumber}");
Console.WriteLine($"Time elapsed: {timer.Elapsed.TotalMilliseconds} ms");
Console.WriteLine("\nPress Enter to exit");
Console.ReadLine();
}
public void GetNthValue_OnFibonacciController_ReturnsValidValues()
{
//Arrange
IFibonacciService fibService = new FibonacciService();
FibonacciController fibController = new FibonacciController(fibService);
//Act
var outOfRangeResult = fibController.Get(100) as BadRequestResult;
var basicResult = fibController.Get(1) as OkObjectResult;
var smallResult = fibController.Get(8) as OkObjectResult;
var largeResult = fibController.Get(70) as OkObjectResult;
//Assert
Assert.That(outOfRangeResult, Is.TypeOf(typeof(BadRequestResult)));
Assert.That(basicResult?.Value, Is.Not.Null.And.EqualTo(1));
Assert.That(smallResult?.Value, Is.Not.Null.And.EqualTo(21));
Assert.That(largeResult?.Value, Is.Not.Null.And.EqualTo(190392490709135));
}
static void Main(string[] args)
{
var logger = new NLogProvider();
var rabbitMq = ConfigurationManager.AppSettings["RabbitMqConnectionString"];
using (var bus = new RabbitMqProvider(rabbitMq, logger))
{
var webApiAddress = ConfigurationManager.AppSettings["WebApiEndpointAddress"];
using (var sender = new HttpClientProvider(webApiAddress, logger))
{
var fibonacciService = new FibonacciService(sender, logger);
bus.Subscribe <CalculationDTO>("fibonacciQueue", fibonacciService.Handle);
Console.WriteLine("Press any key to stop");
Console.ReadLine();
}
}
}
