Added More Unit tests

Author: Matthiee

UpdateLib/UpdateLib.Tests/Tasks/AsyncTaskTest.cs

@@ -42,7 +42,7 @@ public void FaultyTaskReturnsException()
             {
                 Assert.False(e.Cancelled, "The task got cancelled");
                 Assert.NotNull(e.Error, "The error object is null");
-                Assert.IsInstanceOf<ErrorTask>(e.Error, $"{e.Error} is not an instance of {nameof(AsyncTaskTestException)}");
+                Assert.IsInstanceOf<AsyncTaskTestException>(e.Error, $"{e.Error} is not an instance of {nameof(AsyncTaskTestException)}");
                 //  wait.Set();
             };
             task.Start();

UpdateLib/UpdateLib.Tests/Threading/AtomicIntegerTest.cs

@@ -0,0 +1,79 @@
+using MatthiWare.UpdateLib.Threading;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace UpdateLib.Tests.Threading
+{
+    [TestFixture]
+    public class AtomicIntegerTest
+    {
+
+
+        [Test, Parallelizable]
+        public void AtomicIntegerShouldGetCorrectValueFromConstructor()
+        {
+            AtomicInteger myInt = new AtomicInteger(50);
+            Assert.AreEqual(50, myInt.Value);
+        }
+
+        [Test, Parallelizable]
+        public void AtomicIntegerShouldIncrementCorrectly()
+        {
+            AtomicInteger myInt = new AtomicInteger();
+            Assert.AreEqual(1, myInt.Increment());
+        }
+
+        [Test, Parallelizable]
+        public void AtomicIntegerShouldDecrementCorrectly()
+        {
+            AtomicInteger myInt = new AtomicInteger();
+            Assert.AreEqual(-1, myInt.Decrement());
+        }
+
+        [Test, Parallelizable]
+        public void AtomicIntegerShouldHaveCorrectValueAfterSetting()
+        {
+            AtomicInteger myInt = new AtomicInteger(50);
+            Assert.AreEqual(50, myInt.Value);
+            myInt.Value = 30;
+            Assert.AreEqual(30, myInt.Value);
+        }
+
+        [Test, Parallelizable]
+        public void MultithreadedTest()
+        {
+            AtomicInteger myInt = new AtomicInteger(50);
+
+            ThreadStart IncrementAction = new ThreadStart(() => myInt.Increment());
+
+            ThreadStart DecrementAction = new ThreadStart(() => myInt.Decrement());
+
+            Thread[] threads = new Thread[10];
+
+            for (int i = 0; i < 10; i++)
+            {
+                threads[i] = new Thread((i % 2 == 0) ? IncrementAction : DecrementAction);
+                threads[i].Start();
+            }
+
+            for (int i = 0; i < 10; i++)
+            {
+                threads[i].Join();
+            }
+
+            Assert.AreEqual(50, myInt.Value);
+        }
+
+        [Test, Parallelizable]
+        public void ToStringShouldDisplayValue()
+        {
+            AtomicInteger myInt = new AtomicInteger(30);
+            Assert.AreEqual(myInt.Value.ToString(), myInt.ToString());
+        }
+    }
+}

UpdateLib/UpdateLib.Tests/Threading/ConcurrentQueueTests.cs

@@ -0,0 +1,81 @@
+using MatthiWare.UpdateLib.Threading;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace UpdateLib.Tests.Threading
+{
+    [TestFixture]
+    public class ConcurrentQueueTests
+    {
+        private ConcurrentQueue<object> m_queue;
+
+        [SetUp]
+        public void Setup()
+        {
+            m_queue = new ConcurrentQueue<object>();
+        }
+
+        [Test, Parallelizable]
+        public void CountShouldBeZero()
+        {
+            Assert.AreEqual(0, m_queue.Count);
+        }
+
+        [Test, Parallelizable]
+        public void AddingItemsShouldIncrementCount()
+        {
+            m_queue.Enqueue(new object());
+            Assert.AreEqual(1, m_queue.Count);
+            m_queue.Enqueue(new object());
+            Assert.AreEqual(2, m_queue.Count);
+            m_queue.Enqueue(new object());
+            Assert.AreEqual(3, m_queue.Count);
+        }
+
+        [Test, Parallelizable]
+        public void DequeueShouldDecrementCount()
+        {
+            object data = null;
+
+            m_queue.Enqueue(new object());
+            Assert.AreEqual(1, m_queue.Count);
+            m_queue.Enqueue(new object());
+            Assert.AreEqual(2, m_queue.Count);
+            m_queue.Enqueue(new object());
+            Assert.AreEqual(3, m_queue.Count);
+
+            Assert.IsTrue(m_queue.TryDequeue(out data));
+            Assert.AreEqual(2, m_queue.Count);
+            Assert.IsTrue(m_queue.TryDequeue(out data));
+            Assert.AreEqual(1, m_queue.Count);
+            Assert.IsTrue(m_queue.TryDequeue(out data));
+            Assert.AreEqual(0, m_queue.Count);
+        }
+
+        [Test, Parallelizable]
+        public void ClearShouldEmptyTheQueue()
+        {
+            m_queue.Enqueue(new object());
+            Assert.AreEqual(1, m_queue.Count);
+            m_queue.Enqueue(new object());
+            Assert.AreEqual(2, m_queue.Count);
+            m_queue.Enqueue(new object());
+            Assert.AreEqual(3, m_queue.Count);
+
+            m_queue.Clear();
+
+            Assert.AreEqual(0, m_queue.Count);
+        }
+
+        [TearDown]
+        public void CleanUp()
+        {
+            m_queue.Clear();
+            m_queue = null;
+        }
+
+    }
+}

UpdateLib/UpdateLib.Tests/UpdateLib.Tests.csproj

@@ -63,6 +63,8 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Security\HashUtilTest.cs" />
     <Compile Include="Tasks\AsyncTaskTest.cs" />
+    <Compile Include="Threading\AtomicIntegerTest.cs" />
+    <Compile Include="Threading\ConcurrentQueueTests.cs" />
     <Compile Include="UI\WizardPageCollectionTest.cs" />
   </ItemGroup>
   <ItemGroup>

UpdateLib/UpdateLib/Threading/ConcurrentQueue.cs

@@ -21,6 +21,15 @@ public void Enqueue(T item)
                 m_queue.Enqueue(item);
         }
 
+        public int Count
+        {
+            get
+            {
+                lock (sync)
+                    return m_queue.Count;
+            }
+        }
+
         public bool TryDequeue(out T data)
         {
             data = default(T);