Index: test/Common/DelftTools.Utils.Tests/Collections/EnumerableExtensionsTest.cs
===================================================================
diff -u -r3231c54b8de174cf77967f25312ea59a170da0c6 -r5fc71a385897af92ccb092f2f969b5709afab85a
--- test/Common/DelftTools.Utils.Tests/Collections/EnumerableExtensionsTest.cs	(.../EnumerableExtensionsTest.cs)	(revision 3231c54b8de174cf77967f25312ea59a170da0c6)
+++ test/Common/DelftTools.Utils.Tests/Collections/EnumerableExtensionsTest.cs	(.../EnumerableExtensionsTest.cs)	(revision 5fc71a385897af92ccb092f2f969b5709afab85a)
@@ -18,34 +18,57 @@
             Assert.IsTrue(one.HasExactlyOneValue());
 
             //has two
-            IEnumerable two= Enumerable.Range(1, 2);
-            
+            IEnumerable two = Enumerable.Range(1, 2);
+
             two.HasExactlyOneValue()
-                .Should().Be.False();
-            
+               .Should().Be.False();
+
             //has none
             Enumerable.Empty<double>().HasExactlyOneValue()
-                .Should().Be.False();
+                      .Should().Be.False();
         }
 
         [Test]
         public void PlusShouldAddElements()
         {
-            var items = new[] {1, 2, 3};
+            var items = new[]
+            {
+                1,
+                2,
+                3
+            };
             var results = items.Plus(4);
 
-            results.Should().Have.SameSequenceAs(new[] {1, 2, 3, 4});
+            results.Should().Have.SameSequenceAs(new[]
+            {
+                1,
+                2,
+                3,
+                4
+            });
 
             results = items.Plus(4, 5);
 
-            results.Should().Have.SameSequenceAs(new[] { 1, 2, 3, 4, 5 });
+            results.Should().Have.SameSequenceAs(new[]
+            {
+                1,
+                2,
+                3,
+                4,
+                5
+            });
         }
-        
+
         [Test]
         public void ForEach()
         {
-            var items = new [] {1, 2, 3};
-            
+            var items = new[]
+            {
+                1,
+                2,
+                3
+            };
+
             var results = new List<int>();
 
             items.ForEach(results.Add);
@@ -57,32 +80,66 @@
         [Test]
         public void ForEachWithIndex()
         {
-            var items = new[] {1, 2, 3};
+            var items = new[]
+            {
+                1,
+                2,
+                3
+            };
 
             var resultIndices = new List<int>();
             var resultElements = new List<int>();
 
-            items.ForEach((o, i) => { resultElements.Add(o); resultIndices.Add(i); });
+            items.ForEach((o, i) =>
+            {
+                resultElements.Add(o);
+                resultIndices.Add(i);
+            });
 
             resultElements.Should().Have.SameSequenceAs(items);
-            resultIndices.Should().Have.SameSequenceAs(new []{0, 1, 2});
+            resultIndices.Should().Have.SameSequenceAs(new[]
+            {
+                0,
+                1,
+                2
+            });
         }
 
         [Test]
         public void IsMonotonousAscending()
         {
-            var items = new[] { 1, 2, 3,3,3,5 };
+            var items = new[]
+            {
+                1,
+                2,
+                3,
+                3,
+                3,
+                5
+            };
             Assert.IsTrue(items.IsMonotonousAscending());
 
-            
-            Assert.IsFalse(new[] { 1, 2, 1}.IsMonotonousAscending());
+            Assert.IsFalse(new[]
+            {
+                1,
+                2,
+                1
+            }.IsMonotonousAscending());
         }
 
         [Test]
         public void SplitInGroupsAndVerify()
         {
             var items0 = new int[0];
-            var items1 = new[] { 1, 2, 3, 3, 3, 5 };
+            var items1 = new[]
+            {
+                1,
+                2,
+                3,
+                3,
+                3,
+                5
+            };
 
             Assert.AreEqual(0, items0.SplitInGroups(5).Count());
             Assert.AreEqual(2, items1.SplitInGroups(5).Count());
@@ -91,7 +148,6 @@
 
             Assert.AreEqual(1, items1.SplitInGroups(5).ToList()[0][0]);
             Assert.AreEqual(5, items1.SplitInGroups(5).ToList()[1][0]);
-            
         }
 
         [Test]