Added collection tests.

Author: electricessence

testing/Open.Collections.Tests/BasicCollectionTests.cs

@@ -0,0 +1,95 @@
+using FluentAssertions;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Open.Collections.Tests;
+public abstract class BasicCollectionTests<TCollection>
+    where TCollection : ICollection<int>
+{
+    public BasicCollectionTests(TCollection collection)
+    {
+        Collection = collection;
+    }
+
+    protected readonly TCollection Collection;
+
+    [Fact]
+    public void Add()
+    {
+        if(Collection.IsReadOnly)
+        {
+            Assert.Throws<Exception>(() => Collection.Add(1));
+            return;
+        }
+
+        int count = Collection.Count;
+        Collection.Add(1);
+        Collection.Count.Should().Be(count + 1);
+    }
+
+    [Fact]
+    public void Clear()
+    {
+        if (Collection.IsReadOnly)
+        {
+            Assert.Throws<Exception>(() => Collection.Clear());
+            return;
+        }
+
+        Collection.Add(1);
+        Collection.Add(2);
+        Collection.Clear();
+        Collection.Count.Should().Be(0);
+    }
+
+    [Fact]
+    public void Contains()
+    {
+        int search;
+        if (Collection.IsReadOnly)
+        {
+            search = Collection.LastOrDefault();
+            if (search == 0) return;
+        }
+        else
+        {
+            Collection.Add(1);
+            Collection.Add(2);
+            Collection.Add(3);
+            search = 2;
+        }
+        Collection.Contains(2).Should().BeTrue();
+    }
+
+    [Fact]
+    public void CopyTo()
+    {
+        if(!Collection.IsReadOnly)
+        {
+            Collection.Add(1);
+            Collection.Add(2);
+        }
+
+        int[] copy = new int[Collection.Count];
+        Collection.CopyTo(copy, 0);
+        copy.Should().BeEquivalentTo(Collection);
+    }
+
+    [Fact]
+    public void Remove()
+    {
+        if (Collection.IsReadOnly)
+        {
+            Assert.Throws<Exception>(() => Collection.Remove(1));
+            return;
+        }
+
+        Collection.Add(1);
+        Collection.Add(2);
+        Collection.Remove(1).Should().BeTrue();
+        Collection.Remove(int.MaxValue).Should().BeFalse();
+    }
+}

testing/Open.Collections.Tests/BasicListTests.cs

@@ -0,0 +1,49 @@
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Open.Collections.Tests;
+public abstract class BasicListTests<TList> : BasicCollectionTests<TList>
+    where TList : IList<int>
+{
+    protected BasicListTests(TList list) : base(list)
+    {
+    }
+
+    [Fact]
+    public void SetAndCheck()
+    {
+        if (Collection.IsReadOnly) return;
+
+        Collection.Add(10);
+        Collection.IndexOf(10).Should().Be(Collection.Count-1);
+        int value = Collection[0];
+        Collection.IndexOf(int.MaxValue).Should().Be(-1);
+        Collection[0] = int.MaxValue;
+        Collection[0].Should().Be(int.MaxValue);
+        Collection.IndexOf(int.MaxValue).Should().Be(0);
+        Collection[0] = value;
+        Collection[0].Should().Be(value);
+    }
+
+    [Fact]
+    public void InsertAndRemoveAt()
+    {
+        if (Collection.IsReadOnly)
+        {
+            Assert.Throws<Exception>(() => Collection.Insert(0, 1));
+            Assert.Throws<Exception>(() => Collection.RemoveAt(0));
+            return;
+        }
+
+        Collection.Insert(0, 1);
+        Collection.Insert(0, 2);
+        Collection.Insert(1, 3);
+        Collection[0].Should().Be(2);
+        Collection[1].Should().Be(3);
+        Collection[2].Should().Be(1);
+        Collection.RemoveAt(1);
+        Collection[1].Should().Be(1);
+    }
+}

testing/Open.Collections.Tests/Collections/LockSyncLinkedListTests.cs

@@ -0,0 +1,9 @@
+using Open.Collections.Synchronized;
+
+namespace Open.Collections.Tests.Collections;
+public class LockSyncLinkedListTests : BasicCollectionTests<LockSynchronizedLinkedList<int>>
+{
+    public LockSyncLinkedListTests() : base(new LockSynchronizedLinkedList<int>())
+    {
+    }
+}

testing/Open.Collections.Tests/Collections/LockSyncListTests.cs

@@ -0,0 +1,9 @@
+using Open.Collections.Synchronized;
+
+namespace Open.Collections.Tests.Collections;
+public class LockSyncListTests : BasicListTests<LockSynchronizedList<int>>
+{
+    public LockSyncListTests() : base(new LockSynchronizedList<int>())
+    {
+    }
+}

testing/Open.Collections.Tests/Collections/ReadWriteSyncLinkedListTests.cs

@@ -0,0 +1,9 @@
+using Open.Collections.Synchronized;
+
+namespace Open.Collections.Tests.Collections;
+public class ReadWriteSyncLinkedListTests : BasicCollectionTests<LockSynchronizedLinkedList<int>>
+{
+    public ReadWriteSyncLinkedListTests() : base(new LockSynchronizedLinkedList<int>())
+    {
+    }
+}

testing/Open.Collections.Tests/Collections/ReadWriteSyncListTests.cs

@@ -0,0 +1,9 @@
+using Open.Collections.Synchronized;
+
+namespace Open.Collections.Tests.Collections;
+public class ReadWriteSyncListTests : BasicListTests<ReadWriteSynchronizedList<int>>
+{
+    public ReadWriteSyncListTests() : base(new ReadWriteSynchronizedList<int>())
+    {
+    }
+}

testing/Open.Collections.Tests/Open.Collections.Tests.csproj

@@ -7,6 +7,11 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="coverlet.msbuild" Version="3.1.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="FluentAssertions" Version="6.5.1" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">