private void AssertList(List <string> values, int nrOfUniqueItems)
{
InnerOutputWriter.WriteLine("Result = {{{0}}}", string.Join(";", values));
values.Should()
.HaveCount(nrOfUniqueItems, "We expect the list to contain the specified number of items");
values.Distinct()
.Count()
.Should()
.Be(values.Count, "We expect the list to contain unique items");
}
public void FibonacciTest()
{
//Arrange
var input = 8;
var expected = 21;
//Act
var result = Impl.Fibonaci(input);
InnerOutputWriter.WriteLine("Result: {0}", result);
result.Should().Be(expected, " Calling Fibbonaci Should Result In Expected Number ");
InnerOutputWriter.WriteLine("Succes");
}
public void CallingCounterShouldResultInExpectedNumber()
{
//arrange
int times = 10;
int expected = 9;
//act
var result = Impl.CallCounterNrOfTimes(times);
InnerOutputWriter.WriteLine("Result: {0}", result);
result.Should().Be(expected, " Calling Counter Should Result In Expected Number ");
InnerOutputWriter.WriteLine("Succes");
}
public void TestHelperShouldBeFilledWithThreeListsWithUniqueItems()
{
//arrange
var nrOfUniqueItems = 5;
//act
var result = Impl.FunctionsAsVariablesTwo(nrOfUniqueItems);
//assert
AssertList(result.List1, nrOfUniqueItems);
AssertList(result.List2, nrOfUniqueItems);
AssertList(result.List3, nrOfUniqueItems);
InnerOutputWriter.WriteLine("Succes !");
}
public void TrampolineRecursion1()
{
//arrange
var input = 5;
var expected = 120;
//act
var result = Impl.FactorialTrampoline(input);
InnerOutputWriter.WriteLine("result = {0}", result);
//Assert
result.Should().Be(expected, "We expect the factorial to be calculated correctly");
InnerOutputWriter.WriteLine("succes");
}
public void TrampolineRecursion2()
{
//arrange
var input = 10000;
//act
Action a = () =>
{
var result = Impl.FactorialTrampoline(input);
InnerOutputWriter.WriteLine("result = {0}", result);
};
//Assert
a.ShouldNotThrow <StackOverflowException>("An input that is large should not cause a stackoverflow");
InnerOutputWriter.WriteLine("succes");
}
public void ToLargeAFactorialShouldCauseAsStackOverflow()
{
//arrange
var input = 100000;
//act
Action a = () =>
{
var result = Impl.Factorial(input);
InnerOutputWriter.WriteLine("result = {0}", result);
};
//Assert
a.ShouldThrow <StackOverflowException>("An input that is to large should cause a stackoverflow");
InnerOutputWriter.WriteLine("succes");
}
public void SimpleReduceTest()
{
//arrange
var input = new List <int> {
1, 2, 3, 4, 5
};
var expected = 15;
//act
var result = Impl.SimpleReduceFunction(input);
InnerOutputWriter.WriteLine("Result = {0}", result);
//Assert
result.Should().Be(expected, "We expect the result to be the sum of all numbers");
InnerOutputWriter.WriteLine("Succes !");
}
public void MaybeMonadTest1()
{
//Arrange
Person person = new Person();
string expected = "PostalCodeIsEmpty";
//Act
var result = person.ToMaybe()
.With(x => x.Adress)
.Return(x => x.PostalCode, "PostalCodeIsEmpty");
InnerOutputWriter.WriteLine("result = {0}", result);
//Assert
result.Should().Be(expected, "For an empty postalcode we expect the result to be the default value");
InnerOutputWriter.WriteLine("succes");
}
public void ShouldBeAbleToGetTheFirstFiveIndexesOfFar()
{
//arrange
var text = SampleText.FarFarAwayWords;
var expected = new List <int> {
0, 1, 7, 103, 316
};
// act
var result = Impl.FirstFiveIndexesOfFarInFarFarAway(text);
InnerOutputWriter.WriteLine("Result = {{{0}}}", string.Join(";", result));
//Assert
result.ShouldBeEquivalentTo(expected, "First Five indexes should be as expected");
InnerOutputWriter.WriteLine("Succes !");
}
public void TimedFibonacciTest()
{
//Arrange
var input = 45;
var expected = 1134903170;
var timer = new Stopwatch();
//Act
timer.Start();
var result = Impl.Fibonaci(input, 1);
timer.Stop();
InnerOutputWriter.WriteLine("Result: {0} in {1}", result, timer.ElapsedMilliseconds);
result.Should().Be(expected, " Calling Fibbonaci Should Result In Expected Number ");
InnerOutputWriter.WriteLine("Succes");
}
public void SlightlyLessSimpleReduceFunctionTest()
{
//arrange
var input = new List <int> {
1, 2, 3, 4, 5
};
var seed = 1;
var expected = 120;
//act
var result = Impl.SlightlyLessSimpleReduceFunction(input, seed, (r, i) => r * i);
InnerOutputWriter.WriteLine("Result = {0}", result);
//Assert
result.Should().Be(expected, "We expect the result to be the mutiplication result of all numbers");
InnerOutputWriter.WriteLine("Succes !");
}
public void SimpleFunctionalComposition()
{
//arrange
int expected = 2 * 5 + 2;
Func <int, int> add2 = x => x + 2;
Func <int, int> mult2 = x => x * 2;
Func <int, int> add2Mult2 = x => add2(mult2(x));
//act
var result = add2Mult2(5);
InnerOutputWriter.WriteLine("expected = {0} , result = {1}", expected, result);
//assert
result.Should().Be(expected);
InnerOutputWriter.WriteLine("succes");
}
public void MonadComposition2()
{
//arrange
var expected = "Hello World!, 7, 11-01-2010";
//act
var result =
from hello in "Hello World!".ToIdentity()
from number in 7.ToIdentity()
from date in (new DateTime(2010, 1, 11)).ToIdentity()
select string.Format("{0}, {1}, {2:dd-MM-yyyy}", hello, number, date);
InnerOutputWriter.WriteLine("result = {0}", result.Value);
//assert
result.Value.Should().Be(expected);
InnerOutputWriter.WriteLine("succes");
}
public void MonadComposition()
{
//arrange
var expected = "Hello World!, 7, 11-01-2010";
//act
var result =
"Hello World!".ToIdentity()
.Bind(hello => 7.ToIdentity()
.Bind(number => (new DateTime(2010, 1, 11)).ToIdentity()
.Bind(date => string.Format("{0}, {1}, {2:dd-MM-yyyy}", hello, number, date).ToIdentity())));
InnerOutputWriter.WriteLine("result = {0}", result.Value);
//assert
result.Value.Should().Be(expected);
InnerOutputWriter.WriteLine("succes");
}
public void SimpleMapTest()
{
//arrange
var input = new List <int> {
1, 2, 3, 4, 5
};
var expected = new List <int> {
2, 4, 6, 8, 10
};
//act
var result = Impl.SimpleMapFunction(input);
InnerOutputWriter.WriteLine("Result = {{{0}}}", string.Join(";", result));
//Assert
result.Should().BeEquivalentTo(expected, "We expect all numbers to be multiplied by 2");
InnerOutputWriter.WriteLine("Succes !");
}
public void PartialApplicationComposition()
{
//arrange
int expected = 2 * 5 + 2;
Func <int, int, int> add = (x, y) => x + y;
Func <int, int, int> mult = (x, y) => x * y;
Func <int, int> add2 = x => add(x, 2);
Func <int, int> mult2 = x => mult(x, 2);
//act
var result = add2(mult2(5));
InnerOutputWriter.WriteLine("expected = {0} , result = {1}", expected, result);
//assert
result.Should().Be(expected);
InnerOutputWriter.WriteLine("succes");
}
public void DeclarativeVsImperativeShouldFilterOutOdds()
{
//arrange
var input = new List <int> {
1, 2, 3, 4, 5
};
var expected = new List <int> {
1, 3, 5
};
//act
var result = Impl.DeclarativeVsImperative(input);
InnerOutputWriter.WriteLine("Result = {{{0}}}", string.Join(";", result));
//assert
result.Should().BeEquivalentTo(expected, "We expect the even numbers to be filtered out");
InnerOutputWriter.WriteLine("Succes !");
}
public void SlightlyLessSimpleMapFunctionTest()
{
//arrange
var input = new List <int> {
1, 2, 3, 4, 5
};
var expected = new List <int> {
3, 5, 7, 9, 11
};
//act
var result = Impl.SlightlyLessSimpleMapFunction(input, i => i * 2 + 1);
InnerOutputWriter.WriteLine("Result = {{{0}}}", string.Join(";", result));
//Assert
result.Should().BeEquivalentTo(expected, "We expect all numbers to be multiplied by 2 plus one");
InnerOutputWriter.WriteLine("Succes !");
}
public void SlightlyLessSimpleSelectFunctionTest()
{
//arrange
var input = new List <int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
};
var expected = new List <int> {
1, 2, 3, 4, 5, 6, 7, 8, 9
};
//act
var result = Impl.SlightlyLessSimpleSelectFunction(input, i => i < 10);
InnerOutputWriter.WriteLine("Result = {{{0}}}", string.Join(";", result));
//Assert
result.Should().BeEquivalentTo(expected, "We expect all numbers above 10 to be selected");
InnerOutputWriter.WriteLine("Succes !");
}
public void MaybeMonadTest2()
{
//Arrange
string expected = "Blah22";
Person person = new Person {
Adress = new Address {
PostalCode = expected
}
};
//Act
var result = person.ToMaybe()
.With(x => x.Adress)
.Return(x => x.PostalCode, "PostalCodeIsEmpty");
InnerOutputWriter.WriteLine("result = {0}", result);
//Assert
result.Should().Be(expected, "When the postalcode not is null we expect the result to be the postalcode");
InnerOutputWriter.WriteLine("succes");
}
public void CurryComposition()
{
//arrange
int expected = 2 * 5 + 2;
Func <int, int, int> add = (x, y) => x + y;
Func <int, int, int> mult = (x, y) => x * y;
Func <int, Func <int, int> > curriedAdd = add.Curry();
Func <int, Func <int, int> > curriedMultiply = mult.Curry();
Func <int, int> add2 = curriedAdd(2);
Func <int, int> mult2 = curriedMultiply(2);
//act
var result = add2(mult2(5));
InnerOutputWriter.WriteLine("expected = {0} , result = {1}", expected, result);
//assert
result.Should().Be(expected);
InnerOutputWriter.WriteLine("succes");
}
public void MaybeMonadTest3()
{
//Arrange
string expected = "PostalCodeIsEmpty";
Person person = new Person {
Adress = new Address {
PostalCode = "Blah22"
}, Name = "NameLongerThanFour"
};
//Act
var result = person.ToMaybe()
.Where(x => x.Name.Length < 4)
.With(x => x.Adress)
.Return(x => x.PostalCode, "PostalCodeIsEmpty");
InnerOutputWriter.WriteLine("result = {0}", result);
//Assert
result.Should().Be(expected, "For a person with a name longer than four characters we expect the postalcode to be the default value");
InnerOutputWriter.WriteLine("succes");
}
public void CurryComposition2()
{
//arrange
int expected = 10;
Func <int, int, int, int, int> addFourThings = (a, b, c, d) => a + b + c + d;
var curriedAddFourThings = addFourThings.Curry();
var addOne = curriedAddFourThings(1);
var addOneAndTwo = addOne(2);
var addOneAndTwoAndThree = addOneAndTwo(3);
//act
int result1 = curriedAddFourThings(1)(2)(3)(4);
int result2 = addOneAndTwoAndThree(4);
InnerOutputWriter.WriteLine("expected = {0} , result1 = {1}, result2 = {2}", expected, result1, result2);
//assert
result1.Should().Be(expected);
result2.Should().Be(expected);
InnerOutputWriter.WriteLine("succes");
}
