2 files changed, 456 insertions, 0 deletions
diff --git a/Plugins/MonoGame.Extended/tests/MonoGame.Extended.Tests/Collections/BagTests.cs b/Plugins/MonoGame.Extended/tests/MonoGame.Extended.Tests/Collections/BagTests.cs
new file mode 100644
index 0000000..f89b45b
--- /dev/null
+++ b/Plugins/MonoGame.Extended/tests/MonoGame.Extended.Tests/Collections/BagTests.cs
@@ -0,0 +1,48 @@
+using MonoGame.Extended.Collections;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Xunit;
+
+namespace MonoGame.Extended.Tests.Collections
+{
+    public class BagTests
+    {
+        [Fact]
+        public void Bag_Enumeration_Does_Not_Allocate()
+        {
+            var bag = new Bag<int>();
+            for (int i = 0; i < 100; i++) bag.Add(i);
+            // ensure we have plenty of memory and that the heap only increases for the duration of this test
+            Assert.True(GC.TryStartNoGCRegion(Unsafe.SizeOf<Bag<int>.BagEnumerator>() * 1000));
+            var heapSize = GC.GetAllocatedBytesForCurrentThread();
+
+            // this should NOT allocate
+            foreach (int i in bag)
+            {
+                // assert methods cause the NoGCRegion to fail, so do this manually
+                if (GC.GetAllocatedBytesForCurrentThread() != heapSize)
+                    Assert.True(false);
+            }
+
+            // sanity check: this SHOULD allocate
+            foreach (int _ in (IEnumerable<int>)bag)
+            {
+                // assert methods cause the NoGCRegion to fail, so do this manually
+                if (GC.GetAllocatedBytesForCurrentThread() == heapSize)
+                    Assert.True(false);
+            }
+
+            //  Wrap in if statement due to exception thrown when running test through
+            //  cake build script or when debugging test script manually.
+            if(GCSettings.LatencyMode == GCLatencyMode.NoGCRegion)
+            {
+                GC.EndNoGCRegion();
+            }
+        }
+
+    }
+}
diff --git a/Plugins/MonoGame.Extended/tests/MonoGame.Extended.Tests/Collections/DequeTests.cs b/Plugins/MonoGame.Extended/tests/MonoGame.Extended.Tests/Collections/DequeTests.cs
new file mode 100644
index 0000000..3196309
--- /dev/null
+++ b/Plugins/MonoGame.Extended/tests/MonoGame.Extended.Tests/Collections/DequeTests.cs
@@ -0,0 +1,408 @@
+using System;
+using System.Linq;
+using MonoGame.Extended.Collections;
+using Xunit;
+
+namespace MonoGame.Extended.Tests.Collections
+{
+    public class DequeTests
+    {
+        private class TestDequeElement
+        {
+            public int Value { get; set; }
+        }
+
+        private readonly Random _random;
+
+        public DequeTests()
+        {
+            _random = new Random();
+        }
+
+        [Fact]
+        public void Deque_Constructor_Default()
+        {
+            var deque = new Deque<object>();
+            Assert.True(deque.Count == 0);
+            Assert.True(deque.Capacity == 0);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Constructor_Collection(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+            Assert.True(deque.Count == count);
+            Assert.True(deque.Capacity == count);
+            for (var index = 0; index < deque.Count; index++)
+            {
+                Assert.True(deque[index].Value == index);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Constructor_Capacity(int capacity)
+        {
+            var deque = new Deque<TestDequeElement>(capacity);
+            Assert.True(deque.Count == 0);
+            Assert.True(deque.Capacity == capacity);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Clear(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+            deque.Clear();
+            Assert.True(deque.Count == 0);
+            Assert.True(deque.Capacity >= count);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Trim_And_Clear(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+            deque.Clear();
+            deque.TrimExcess();
+            Assert.True(deque.Count == 0);
+            Assert.True(deque.Capacity == 0);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Trim_Front(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+
+            for (var i = 0; i < count; i++)
+            {
+                deque.RemoveFromFront(out _);
+                deque.Capacity = deque.Count;
+                Assert.True(deque.Count == count - 1 - i);
+                Assert.True(deque.Capacity == count - 1 - i);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Trim_Back(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+
+            for (var i = 0; i < count; i++)
+            {
+                deque.RemoveFromBack(out _);
+                deque.Capacity = deque.Count;
+                Assert.True(deque.Count == count - 1 - i);
+                Assert.True(deque.Capacity == count - 1 - i);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Add_Front(int count)
+        {
+            var deque = new Deque<TestDequeElement>();
+            for (var i = 0; i < count; i++)
+            {
+                deque.AddToFront(new TestDequeElement
+                {
+                    Value = i
+                });
+            }
+            Assert.True(deque.Count == count);
+            Assert.True(deque.Capacity >= count);
+            for (var index = 0; index < deque.Count; index++)
+            {
+                var element = deque[index];
+                Assert.True(element.Value == deque.Count - 1 - index);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Add_Back(int count)
+        {
+            var deque = new Deque<TestDequeElement>();
+            for (var i = 0; i < count; i++)
+            {
+                deque.AddToBack(new TestDequeElement
+                {
+                    Value = i
+                });
+            }
+            Assert.True(deque.Count == count);
+            Assert.True(deque.Capacity >= count);
+            for (var index = 0; index < deque.Count; index++)
+            {
+                var element = deque[index];
+                Assert.True(element.Value == index);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Remove_Front(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+
+            var index = 0;
+            while (deque.RemoveFromFront(out var element))
+            {
+                Assert.True(element.Value == index);
+                index++;
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Remove_Back(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+
+            var index = 0;
+            while (deque.RemoveFromBack(out var element))
+            {
+                Assert.True(element.Value == elements.Length - 1 - index);
+                index++;
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Get_Front(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+            var indices = Enumerable.Range(0, count);
+            foreach (var index in indices)
+            {
+                deque.GetFront(out var element);
+                deque.RemoveFromFront();
+                Assert.True(element.Value == index);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Get_Back(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+            var indices = Enumerable.Range(0, count);
+            foreach (var index in indices)
+            {
+                deque.GetBack(out var element);
+                deque.RemoveFromBack();
+                Assert.True(element.Value == count - 1 - index);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Get_Index(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+            var indices = Enumerable.Range(0, count).ToList().Shuffle(_random);
+            foreach (var index in indices)
+            {
+                deque.Get(index, out var element);
+                Assert.True(element.Value == index);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_ForEach_Iteration(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+            var counter = 0;
+            foreach (var element in deque)
+            {
+                Assert.True(element.Value == counter);
+                counter++;
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_ForEach_Iteration_Modified(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+            var counter = 0;
+            foreach (var element in deque)
+            {
+                Assert.True(element.Value == counter);
+                counter++;
+                deque.RemoveFromFront();
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(50)]
+        public void Deque_Remove(int count)
+        {
+            var elements = new TestDequeElement[count];
+            for (var i = 0; i < count; i++)
+            {
+                elements[i] = new TestDequeElement
+                {
+                    Value = i
+                };
+            }
+            var deque = new Deque<TestDequeElement>(elements);
+            var counter = count;
+            while (deque.Count > 0)
+            {
+                var index = _random.Next(0, deque.Count - 1);
+                deque.RemoveAt(index);
+                counter--;
+                Assert.True(deque.Count == counter);
+            }
+        }
+    }
+}