Remove of .First() and .Last() method extensions for collections: LINQ FirstOrDefault and LastOrDefault should be used instead

Utilities for TimeSpan struct added
Extensions for TimeSpan stuct added
Utilities for DateTime struct added
Dictionary for http header values added: Sharpility.Net.HttpHeaders
Dictionary for content types values added: Sharpility.Net.MediaTypes
Enum for http methods values added: Sharpility.Net.HttpMethod
Extension method ToComparable added to IDictionary, IList, ISet, ICollection and IEnumerable that wraps object with equals/hashCode/toString implementations
InstanceCreator utility added for creating instance of type without default constructor requirement
System.Collections.Immutable version update: 1.1.36 -> 1.1.37

Author: jakubmalek

src/Sharpility.Tests/Collections/Concurrent/DefaultBlockingQueueTests.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using NFluent;
+using NUnit.Framework;
+using Sharpility.Collections.Concurrent;
+
+namespace Sharpility.Tests.Collections.Concurrent
+{
+    [TestFixture]
+    public class DefaultBlockingQueueTests
+    {
+        [Test]
+        public void PeekShouldReturnNull()
+        {
+            // given
+            var queue = new DefaultBlockingQueue<string>();
+
+            // when
+            var item = queue.Peek();
+
+            // then
+            Check.That(item).IsNull();
+        }
+
+        [Test]
+        public void PeekShouldReturnValueWithoutDequeue()
+        {
+            // given
+            var queue = new DefaultBlockingQueue<string>();
+            queue.Offer("test");
+
+            // when
+            var item = queue.Peek();
+
+            // then
+            Check.That(item).IsEqualTo("test");
+            Check.That(queue).HasSize(1);
+        }
+
+        [Test]
+        public void ShouldPollValue()
+        {
+            // given
+            var queue = new DefaultBlockingQueue<string>();
+            queue.Offer("test");
+
+            // when
+            var item = queue.Poll();
+
+            // then
+            Check.That(item).IsEqualTo("test");
+            Check.That(queue).IsEmpty();
+        }
+
+        [Test]
+        public void PollShouldReturnNull()
+        {
+            // given
+            var queue = new DefaultBlockingQueue<string>();
+
+            // when
+            var item = queue.Poll();
+
+            // then
+            Check.That(item).IsNull();
+        }
+
+        [Test, Timeout(2000)]
+        public void TakeShouldWaitForElementAvailability()
+        {
+            // given
+            var queue = new DefaultBlockingQueue<string>();
+            const string element = "test";
+            Task.Factory.StartNew(() =>
+            {
+                Thread.Sleep(TimeSpan.FromSeconds(1));
+                queue.Offer(element);
+            });
+
+            // when
+            var item = queue.Take();
+
+            // then
+            Check.That(item).IsEqualTo(element);
+        }
+
+
+        [Test]
+        public void ShouldWaitForValueTake()
+        {
+            // given
+            var queue = new DefaultBlockingQueue<string>();
+            var timeout = TimeSpan.FromSeconds(10);
+            const string itemToOffer = "item";
+
+            // when
+            Task.Run(() =>
+            {
+                Thread.Sleep(100);
+                queue.Offer(itemToOffer);
+            });
+            var item = queue.Poll(timeout);
+
+            // then
+            Check.That(item).IsEqualTo(itemToOffer);
+        }
+    }
+}

src/Sharpility.Tests/Collections/OrderedImmutableDictionaryTests.cs

@@ -12,7 +12,7 @@ public class OrderedImmutableDictionaryTests
         public void ShouldReturnKeysInPutOrder()
         {
             // given
-            var dictionary = OrderedHashImmutableDictionary<string, int>.CreateBuilder()
+            var dictionary = OrderedHashImmutableDictionary<string, int>.Builder()
                 .Put("Z", 1)
                 .Put("Y", 2)
                 .Put("X", 3)
@@ -29,7 +29,7 @@ public void ShouldReturnKeysInPutOrder()
         public void ShouldReturnEntriesInPutOrder()
         {
             // given
-            var dictionary = OrderedHashImmutableDictionary<string, int>.CreateBuilder()
+            var dictionary = OrderedHashImmutableDictionary<string, int>.Builder()
                 .Put("Z", 1)
                 .Put("Y", 2)
                 .Put("X", 3)

src/Sharpility.Tests/Extensions/CollectionExtensionsTests.cs

@@ -3,6 +3,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 using NFluent;
 using NiceTry;
 using NUnit.Framework;
@@ -471,19 +472,6 @@ public void ShouldExtenedListByFirstMethod()
             Check.That(first).IsEqualTo("A");
         }
 
-        [Test]
-        public void ShouldReturnNullFirstElementOfEmptyCollection()
-        {
-            // given
-            ICollection<int?> collection = Lists.EmptyList<int?>();
-
-            // when
-            var first = collection.First();
-
-            // then
-            Check.That(first).IsNull();
-        }
-
         [Test]
         public void ShouldExtenedLinkedListByLastMethod()
         {
@@ -512,19 +500,6 @@ public void ShouldExtenedListByLastMethod()
             Check.That(first).IsEqualTo("C");
         }
 
-        [Test]
-        public void ShouldReturnNullLastElementOfEmptyCollection()
-        {
-            // given
-            ICollection<int?> collection = Lists.EmptyList<int?>();
-
-            // when
-            var first = collection.Last();
-
-            // then
-            Check.That(first).IsNull();
-        }
-
         [Test]
         public void ShouldExtendLinkedListByRemoveFirstMethod()
         {
@@ -727,5 +702,221 @@ public void ShouldExtenedEnumerableByDistinctElementCountMethod()
             Check.That(setDistinctElementsCount).IsEqualTo(Dictionaries.Create("A", 1, "B", 1, "C", 1));
             Check.That(listDistinctElementsCount).IsEqualTo(Dictionaries.Create("A", 1, "B", 3, "C", 2, "D", 4));
         }
+
+        [Test]
+        [TestCaseSource("TopSliceCases")]
+        public IList<string> ShouldReturnTopSliceOfList(IList<string> list, int size)
+        {
+            // when
+            var result = list.TopSlice(size);
+
+            // then
+            return result;
+        }
+
+        private static IEnumerable<ITestCaseData> TopSliceCases()
+        {
+            var givenList = Lists.AsList("A", "B", "C");
+            var givenSize = 3;
+            var expectedSlice = Lists.AsList("A", "B", "C");
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Top {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+
+            givenList = Lists.AsList("A", "B", "C");
+            givenSize = 2;
+            expectedSlice = Lists.AsList("B", "C");
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Top {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+
+            givenList = Lists.AsList("A", "B", "C");
+            givenSize = 1;
+            expectedSlice = Lists.AsList("C");
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Top {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+
+            givenList = Lists.AsList("A", "B", "C");
+            givenSize = 5;
+            expectedSlice = Lists.AsList("A", "B", "C");
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Top {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+
+            givenList = Lists.AsList("A", "B", "C");
+            givenSize = 0;
+            expectedSlice = Lists.EmptyList<string>();
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Top {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+        }
+
+        [Test]
+        [TestCaseSource("BottomSliceCases")]
+        public IList<string> ShouldTrimCollectionRight(IList<string> list, int size)
+        {
+            // when
+            var result = list.BottomSlice(size);
+
+            // then
+            return result;
+        }
+
+        private static IEnumerable<ITestCaseData> BottomSliceCases()
+        {
+            var givenList = Lists.AsList("A", "B", "C");
+            var givenSize = 3;
+            var expectedSlice = Lists.AsList("A", "B", "C");
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Bottom {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+
+            givenList = Lists.AsList("A", "B", "C");
+            givenSize = 2;
+            expectedSlice = Lists.AsList("A", "B");
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Bottom {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+
+            givenList = Lists.AsList("A", "B", "C");
+            givenSize = 1;
+            expectedSlice = Lists.AsList("A");
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Bottom {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+
+            givenList = Lists.AsList("A", "B", "C");
+            givenSize = 5;
+            expectedSlice = Lists.AsList("A", "B", "C");
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Bottom {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+
+            givenList = Lists.AsList("A", "B", "C");
+            givenSize = 0;
+            expectedSlice = Lists.EmptyList<string>();
+            yield return new TestCaseData(givenList, givenSize)
+                .SetName(Strings.Format("Bottom {0} slice of {1} should return {2}", givenSize, givenList, expectedSlice))
+                .Returns(expectedSlice);
+        }
+
+        [Test]
+        [TestCaseSource("SetLastListElementCases")]
+        public IList<string> ShouldReplaceLastElementList(IList<string> elements, string element)
+        {
+            // given
+            var list = new List<string>(elements);
+
+            // when
+            list.SetLast(element);
+
+            // then
+            return list;
+        }
+
+        private static IEnumerable<ITestCaseData> SetLastListElementCases()
+        {
+            const string element = "X";
+            var givenList = Lists.AsList("A", "B", "C");
+            var expected = Lists.AsList("A", "B", element);
+            yield return new TestCaseData(givenList, element)
+                .SetName(Strings.Format("Replace last item of {1} by {0} results {2}", element, givenList, expected))
+                .Returns(expected);
+
+            givenList = Lists.EmptyList<string>();
+            expected = Lists.AsList(element);
+            yield return new TestCaseData(givenList, element)
+                .SetName(Strings.Format("Replace last item of {1} by {0} results {2}", element, givenList, expected))
+                .Returns(expected);
+        }
+
+        [Test]
+        [TestCaseSource("SetFirstListElementCases")]
+        public IList<string> ShouldReplaceFirstElementList(IList<string> elements, string element)
+        {
+            // given
+            var list = new List<string>(elements);
+
+            // when
+            list.SetFirst(element);
+
+            // then
+            return list;
+        }
+
+        private static IEnumerable<ITestCaseData> SetFirstListElementCases()
+        {
+            const string element = "X";
+            var givenList = Lists.AsList("A", "B", "C");
+            var expected = Lists.AsList(element, "B", "C");
+            yield return new TestCaseData(givenList, element)
+                .SetName(Strings.Format("Replace first item of {1} by {0} results {2}", element, givenList, expected))
+                .Returns(expected);
+
+            givenList = Lists.EmptyList<string>();
+            expected = Lists.AsList(element);
+            yield return new TestCaseData(givenList, element)
+                .SetName(Strings.Format("Replace first item of {1} by {0} results {2}", element, givenList, expected))
+                .Returns(expected);
+        }
+
+        [Test]
+        public void ShouldConvertEnumerableToComparable()
+        {
+            // given
+            IEnumerable<string> enumerable = new[] {"A", "B", "C"};
+
+            // when
+            var comparable = enumerable.ToComparable();
+
+            // then
+            Check.That(comparable).IsEqualTo(Lists.AsList("A", "B", "C"));
+            Check.That(comparable.GetHashCode()).IsEqualTo(enumerable.ToComparable().GetHashCode());
+            Check.That(comparable.ToString()).IsEqualTo("[A, B, C]");
+        }
+
+        [Test]
+        public void ShouldConvertListToComparable()
+        {
+            // given
+            IList<string> enumerable = new[] { "A", "B", "C" };
+
+            // when
+            var comparable = enumerable.ToComparable();
+
+            // then
+            Check.That(comparable).IsEqualTo(Lists.AsList("A", "B", "C"));
+            Check.That(comparable.GetHashCode()).IsEqualTo(enumerable.ToComparable().GetHashCode());
+            Check.That(comparable.ToString()).IsEqualTo("[A, B, C]");
+        }
+
+        [Test]
+        public void ShouldConvertCollectionToComparable()
+        {
+            // given
+            ICollection<string> enumerable = new[] { "A", "B", "C" };
+
+            // when
+            var comparable = enumerable.ToComparable();
+
+            // then
+            Check.That(comparable).IsEqualTo(Lists.AsList("A", "B", "C"));
+            Check.That(comparable.GetHashCode()).IsEqualTo(enumerable.ToComparable().GetHashCode());
+            Check.That(comparable.ToString()).IsEqualTo("[A, B, C]");
+        }
+
+        [Test]
+        public void ShouldConvertSetToComparable()
+        {
+            // given
+            ISet<string> enumerable = new HashSet<string>(new [] {"A", "B", "C"});
+
+            // when
+            var comparable = enumerable.ToComparable();
+
+            // then
+            Check.That(comparable).IsEqualTo(Lists.AsList("C", "B", "A"));
+        }
     }
 }