public ActionResult <BigInteger> Get()
{
using (var reader = new StreamReader(Request.Body))
{
var body = reader.ReadToEnd();
switch (Request.ContentType)
{
case "text/plain; charset=utf-8":
case "text/plain":
if (long.TryParse(body, out var index))
{
try
{
Response.Headers.Add(FibonacciRequestedTag, index.ToString());
return(FibonacciCalculator.Calculate(index));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
return(BadRequest($"Invalid Index Value: ''{body}''"));
default:
return(BadRequest("Only Contenttype text/plain accepted"));
}
}
}
public void TestFibonacciOutsideLimit()
{
FibonacciCalculator fibCal = new FibonacciCalculator();
var exception = Assert.Throws <System.NotSupportedException>(() => fibCal.Calculate(11));
Assert.That(exception.Message, Is.EqualTo("n > 10 is not supported"));
}
private void ProcessFibonacci(FibonacciMessage message)
{
var fibonacciCalculator = new FibonacciCalculator();
for (int i = 0; i < message.NumbersToProcess; i++)
{
var numberIndex = message.StartIndex + i;
var result = fibonacciCalculator.Calculate(message.FibonacciNumbers[numberIndex], message.ProcessingType);
SynchronizationContext.AddNumberAndCheckIfIsDone(result);
}
}
public ActionResult <BigInteger> Get(long index)
{
try
{
Response.Headers.Add(FibonacciRequestedTag, index.ToString());
return(FibonacciCalculator.Calculate(index));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
static void ConsumeMessage(object model, BasicDeliverEventArgs ea)
{
try
{
var number = Int64.Parse(Encoding.UTF8.GetString(ea.Body.ToArray()));
Console.WriteLine("[x] Received {0}", number);
var fibonacciCalculator = new FibonacciCalculator();
var result = fibonacciCalculator.Calculate(number, ProcessingType.Sleepy);
FileUtility.AppendNumberToFile(OUTPUT_FILE, result);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
private static void CalculateFibonacci(long[] fibonacciNumbers, int numberOfTasks, int taskIndex, ProcessingType processingType)
{
var fibonacciCalculator = new FibonacciCalculator();
int numbersPerTask = fibonacciNumbers.Length / numberOfTasks; // ideal case, even tasks and even numbers count
int numbersToProcess = 0;
if (taskIndex == numberOfTasks - 1) // if is last task
{
numbersToProcess = fibonacciNumbers.Length - (numbersPerTask * (numberOfTasks - 1));
}
else
{
numbersToProcess = numbersPerTask;
}
for (int i = 0; i < numbersToProcess; i++)
{
var numberIndex = taskIndex * numbersPerTask + i;
var result = fibonacciCalculator.Calculate(fibonacciNumbers[numberIndex], processingType);
ConcurrentStore.AddNumberToStore(result);
}
}
public void Test_less_than_10(int input, int output)
{
int result = fibonacciCalculator.Calculate(input);
Assert.AreEqual(output, result);
}
public void TestHidden1()
{
Assert.AreEqual(377, FibonacciCalculator.Calculate(14));
}
public void Test2()
{
Assert.AreEqual(5, FibonacciCalculator.Calculate(5));
}
public IActionResult GetFibonacci(int n) => Ok(new CalculationResponse(_fibonacciCalculator.Calculate(n)));
public int TestFibonacciInLimit(int number)
{
FibonacciCalculator fibCal = new FibonacciCalculator();
return(fibCal.Calculate(number));
}
public void Test3()
{
Assert.AreEqual(6765, FibonacciCalculator.Calculate(20));
}
public void TestFibonacci(Tuple <long, BigInteger> testdata)
{
Assert.True(FibonacciCalculator.Calculate(testdata.Item1).Equals(testdata.Item2));
}
public async Task <ulong> GetFibonacciNumber(int n)
{
return(await _fibonacciCalculator.Calculate(n));
}
public void Test4()
{
Assert.AreEqual(75025, FibonacciCalculator.Calculate(25));
}
public void Test1()
{
Assert.AreEqual(0, FibonacciCalculator.Calculate(0));
}
public void TestHidden4()
{
Assert.AreEqual(4181, FibonacciCalculator.Calculate(19));
}
public void TestHidden3()
{
Assert.AreEqual(2584, FibonacciCalculator.Calculate(18));
}
public void TestHidden2()
{
Assert.AreEqual(610, FibonacciCalculator.Calculate(15));
}
