Tweaks to tests

Source/Tools/FlaxEngine.Tests/TestCircularBuffer.cs

@@ -0,0 +1,527 @@
+// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved.
+
+using System;
+using System.Collections;
+using FlaxEngine.Collections;
+using NUnit.Framework;
+using Assert = FlaxEngine.Assertions.Assert;
+
+namespace FlaxEngine.Tests
+{
+    [TestFixture]
+    public class TestsCircularBuffer
+    {
+        [Test]
+        public void CircularBufferTestFrontOverwrite()
+        {
+            var buffer = new CircularBuffer<long>(3);
+            for (int i = 0; i < 5; i++)
+            {
+                buffer.PushFront(i);
+            }
+            Assert.AreEqual(2, buffer[0]);
+            Assert.AreEqual(3, buffer[1]);
+            Assert.AreEqual(4, buffer[2]);
+            Assert.AreEqual(4, buffer.Front());
+            Assert.AreEqual(2, buffer.Back());
+
+            Assert.AreEqual(buffer.Count, 3);
+            Assert.AreEqual(buffer.Capacity, 3);
+        }
+
+        [Test]
+        public void CircularBufferTestBackOverwrite()
+        {
+            var buffer = new CircularBuffer<long>(3);
+            for (int i = 0; i < 5; i++)
+            {
+                buffer.PushBack(i);
+            }
+            Assert.AreEqual(4, buffer[0]);
+            Assert.AreEqual(3, buffer[1]);
+            Assert.AreEqual(2, buffer[2]);
+            Assert.AreEqual(2, buffer.Front());
+            Assert.AreEqual(4, buffer.Back());
+
+            Assert.AreEqual(buffer.Count, 3);
+            Assert.AreEqual(buffer.Capacity, 3);
+        }
+
+        [Test]
+        public void CircularBufferTestMixedOverwrite()
+        {
+            var buffer = new CircularBuffer<long>(3);
+            buffer.PushFront(0);
+
+            buffer.PushFront(1);
+            buffer.PushBack(-1);
+            Assert.AreEqual(1, buffer.Front());
+            Assert.AreEqual(-1, buffer.Back());
+            buffer.PushFront(2);
+            Assert.AreEqual(2, buffer.Front());
+            Assert.AreEqual(0, buffer.Back());
+            buffer.PushBack(-2);
+            Assert.AreEqual(1, buffer.Front());
+            buffer.PushFront(3);
+            Assert.AreEqual(0, buffer.Back());
+            buffer.PushBack(-3);
+
+            Assert.AreEqual(-3, buffer[0]);
+            Assert.AreEqual(0, buffer[1]);
+            Assert.AreEqual(1, buffer[2]);
+            Assert.AreEqual(1, buffer.Front());
+            Assert.AreEqual(-3, buffer.Back());
+
+            Assert.AreEqual(buffer.Count, 3);
+            Assert.AreEqual(buffer.Capacity, 3);
+        }
+
+        [Test]
+        public void CircularBufferTestFrontUnderwrite()
+        {
+            var buffer = new CircularBuffer<long>(5);
+            for (int i = 0; i < 4; i++)
+            {
+                buffer.PushFront(i);
+            }
+            buffer.PopFront();
+            buffer.PushFront(4);
+            Assert.AreEqual(4, buffer.Front());
+            Assert.AreEqual(0, buffer.Back());
+            buffer.PopFront();
+            buffer.PushFront(5);
+            Assert.AreEqual(0, buffer[0]);
+            Assert.AreEqual(1, buffer[1]);
+            Assert.AreEqual(2, buffer[2]);
+            Assert.AreEqual(5, buffer[3]);
+
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () =>
+            {
+                var test = buffer[4];
+            });
+
+            Assert.AreEqual(5, buffer.Front());
+            Assert.AreEqual(0, buffer.Back());
+
+            Assert.AreEqual(buffer.Count, 4);
+            Assert.AreEqual(buffer.Capacity, 5);
+        }
+
+        [Test]
+        public void CircularBufferTestBackUnderwrite()
+        {
+            var buffer = new CircularBuffer<long>(5);
+            for (int i = 0; i < 4; i++)
+            {
+                buffer.PushBack(i);
+            }
+            buffer.PopBack();
+            buffer.PushBack(4);
+            Assert.AreEqual(4, buffer.Back());
+            Assert.AreEqual(0, buffer.Front());
+            buffer.PopBack();
+            buffer.PushBack(5);
+            Assert.AreEqual(5, buffer[0]);
+            Assert.AreEqual(2, buffer[1]);
+            Assert.AreEqual(1, buffer[2]);
+            Assert.AreEqual(0, buffer[3]);
+
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () =>
+            {
+                var test = buffer[4];
+            });
+
+            Assert.AreEqual(0, buffer.Front());
+            Assert.AreEqual(5, buffer.Back());
+
+            Assert.AreEqual(buffer.Count, 4);
+            Assert.AreEqual(buffer.Capacity, 5);
+        }
+
+        [Test]
+        public void CircularBufferTestMixedUnderwrite()
+        {
+            var buffer = new CircularBuffer<long>(5);
+            buffer.PushFront(0);
+
+            buffer.PushFront(1);
+            buffer.PushBack(-1);
+            Assert.AreEqual(1, buffer.Front());
+            Assert.AreEqual(-1, buffer.Back());
+
+            buffer.PushFront(2);
+            Assert.AreEqual(2, buffer.Front());
+            Assert.AreEqual(-1, buffer.Back());
+
+            buffer.PopBack();
+            Assert.AreEqual(0, buffer.Back());
+            Assert.AreEqual(2, buffer.Front());
+
+            buffer.PushBack(-2);
+            Assert.AreEqual(2, buffer.Front());
+            Assert.AreEqual(-2, buffer.Back());
+
+            Assert.AreEqual(-2, buffer[0]);
+            Assert.AreEqual(0, buffer[1]);
+            Assert.AreEqual(1, buffer[2]);
+            Assert.AreEqual(2, buffer[3]);
+
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () =>
+            {
+                var test = buffer[4];
+            });
+
+            Assert.AreEqual(buffer.Count, 4);
+            Assert.AreEqual(buffer.Capacity, 5);
+        }
+
+        [Test]
+        public void CircularBufferTestEnumerationFrontWhenOverflown()
+        {
+            var buffer = new CircularBuffer<long>(5);
+            int i;
+            for (i = 0; i < 11; i++)
+            {
+                buffer.PushFront(i);
+            }
+            for (i = 0; i < buffer.Capacity; i++)
+            {
+                Assert.AreEqual(buffer.Count + i + 1, buffer[i]);
+            }
+            i = 6;
+            foreach (var item in buffer)
+            {
+                Assert.AreEqual(i++, item);
+            }
+            i = 6;
+            var e = ((IEnumerable)buffer).GetEnumerator();
+            while (e.MoveNext())
+            {
+                Assert.AreEqual(i++, (long)e.Current);
+            }
+        }
+
+        [Test]
+        public void CircularBufferTestEnumerationBackWhenOverflown()
+        {
+            var buffer = new CircularBuffer<long>(5);
+            int i;
+            for (i = 0; i < 11; i++)
+            {
+                buffer.PushBack(i);
+            }
+            for (i = 0; i < buffer.Capacity; i++)
+            {
+                Assert.AreEqual(10 - i, buffer[i]);
+            }
+            i = 10;
+            foreach (var item in buffer)
+            {
+                Assert.AreEqual(i--, item);
+            }
+            i = 10;
+            var e = ((IEnumerable)buffer).GetEnumerator();
+            while (e.MoveNext())
+            {
+                Assert.AreEqual(i--, (long)e.Current);
+            }
+        }
+
+        [Test]
+        public void CircularBufferTestEnumerationWhenPartiallyFull()
+        {
+            var buffer = new CircularBuffer<long>(3);
+            buffer.PushFront(1);
+            buffer.PushBack(0);
+            var i = 0;
+            foreach (var item in buffer)
+            {
+                Assert.AreEqual(i++, item);
+            }
+            Assert.AreEqual(i, 2);
+            Assert.AreEqual(buffer.Count, 2);
+            Assert.AreEqual(buffer.Capacity, 3);
+        }
+
+        [Test]
+        public void CircularBufferTestEnumerationWhenPartiallyFullLarge()
+        {
+            var buffer = new CircularBuffer<long>(20000);
+            int i = 0;
+            for (i = 0; i < 10000; i++)
+            {
+                buffer.PushFront(i);
+            }
+            i = 0;
+            foreach (var value in buffer)
+            {
+                Assert.AreEqual(i++, value);
+            }
+            Assert.AreEqual(i, 10000);
+
+            Assert.AreEqual(buffer.Count, 10000);
+            Assert.AreEqual(buffer.Capacity, 20000);
+        }
+
+        [Test]
+        public void CircularBufferTestEnumerationWhenEmpty()
+        {
+            var buffer = new CircularBuffer<long>(3);
+            foreach (var value in buffer)
+            {
+                Assert.Fail("Unexpected Value: " + value);
+            }
+        }
+
+        [Test]
+        public void CircularBufferTestCopyToArray()
+        {
+            var buffer = new CircularBuffer<long>(3);
+            for (int i = 0; i < 5; i++)
+            {
+                buffer.PushFront(i);
+            }
+            var testArray = buffer.ToArray();
+            Assert.AreEqual(2, testArray[0]);
+            Assert.AreEqual(3, testArray[1]);
+            Assert.AreEqual(4, testArray[2]);
+
+            testArray = new long[3];
+            buffer.CopyTo(testArray, 0);
+            Assert.AreEqual(2, testArray[0]);
+            Assert.AreEqual(3, testArray[1]);
+            Assert.AreEqual(4, testArray[2]);
+
+            testArray = new long[5];
+            buffer.CopyTo(testArray, 2);
+            Assert.AreEqual(2, testArray[2]);
+        }
+
+        [Test]
+        public void CircularBufferTestExceptions()
+        {
+            Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { new CircularBuffer<long>(0); });
+            Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { new CircularBuffer<long>(-5); });
+            var buffer = new CircularBuffer<long>(1);
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.Front(); });
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.Back(); });
+            Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () =>
+            {
+                var test = buffer[-1];
+            });
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () =>
+            {
+                var test = buffer[1];
+            });
+            Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { buffer[-1] = 0; });
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer[1] = 0; });
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.PopBack(); });
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.PopFront(); });
+        }
+
+        [Test]
+        public void CircularBufferTestForceSet()
+        {
+            var buffer = new CircularBuffer<long>(15);
+            for (int i = 0; i < 5; i++)
+            {
+                buffer.PushFront(i);
+            }
+            for (int i = 0; i < buffer.Count; i++)
+            {
+                buffer[i] = 1;
+            }
+            foreach (var item in buffer)
+            {
+                Assert.AreEqual(1, item);
+            }
+            for (int i = 0; i < buffer.Count; i++)
+            {
+                buffer[i] = i;
+            }
+            int j = 0;
+            foreach (var item in buffer)
+            {
+                Assert.AreEqual(j++, item);
+            }
+        }
+
+        [Test]
+        public void CircularBufferTestFrontAndBack()
+        {
+            var rand = new Random();
+            var buffer = new CircularBuffer<long>(3);
+            for (int i = 0; i < 25; i++)
+            {
+                var cur = rand.Next();
+                buffer.PushFront(cur);
+                Assert.AreEqual(cur, buffer.Front());
+                buffer.PopFront();
+            }
+            for (int i = 0; i < 25; i++)
+            {
+                var cur = rand.Next();
+                buffer.PushBack(cur);
+                Assert.AreEqual(cur, buffer.Back());
+                buffer.PopBack();
+            }
+        }
+
+        [Test]
+        public void CircularBufferTestConstructors()
+        {
+            var array = new long[5];
+            for (int i = 0; i < 5; i++)
+            {
+                array[i] = i + 10;
+            }
+            var buffer = new CircularBuffer<long>(15, array, 5);
+            Assert.AreEqual(10, buffer.Back());
+            Assert.AreEqual(14, buffer.Front());
+            Assert.AreEqual(5, buffer.Count);
+            Assert.AreEqual(15, buffer.Capacity);
+            Assert.AreEqual(false, buffer.IsEmpty);
+        }
+
+        [Test]
+        public void CircularBufferTestClear()
+        {
+            var buffer = new CircularBuffer<long>(15);
+            for (int i = 0; i < 5; i++)
+            {
+                buffer.PushFront(i);
+            }
+            buffer.Clear();
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.PopBack(); });
+            Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.PopFront(); });
+            Assert.AreEqual(0, buffer.Count);
+            Assert.AreEqual(15, buffer.Capacity);
+        }
+
+        [Test]
+        public void CircularBufferTestMultipleIterations()
+        {
+            var buffer = new CircularBuffer<long>(50);
+            for (int i = 0; i < 80; i++)
+            {
+                buffer.PushFront(i);
+            }
+            for (int i = 0; i < 50; i++)
+            {
+                Assert.AreEqual(79 - i, buffer.PopFront());
+            }
+            for (int i = 0; i < 20; i++)
+            {
+                buffer.PushFront(i);
+            }
+            for (int i = 0; i < 20; i++)
+            {
+                Assert.AreEqual(i, buffer[i]);
+            }
+        }
+
+        [Test]
+        public void CircularBufferTestEvents()
+        {
+            //Front
+            var buffer = new CircularBuffer<long>(5);
+            var overflown = 0;
+            var added = 0;
+            var removed = 7;
+
+            var overflownHandler = new CircularBuffer<long>.ItemOverflownEventHandler((sender, args) =>
+            {
+                Assert.AreEqual(overflown++, args.Item);
+                Assert.AreEqual(false, args.WasFrontItem);
+            });
+            buffer.OnItemOverflown += overflownHandler;
+            var addHandler = new CircularBuffer<long>.ItemAddedEventHandler((sender, args) =>
+            {
+                Assert.AreEqual(added++, args.Item);
+                Assert.AreEqual(buffer.Count - 1, args.Index);
+            });
+            buffer.OnItemAdded += addHandler;
+            var removeHandler = new CircularBuffer<long>.ItemRemovedEventHandler((sender, args) =>
+            {
+                Assert.AreEqual(removed--, args.Item);
+                Assert.AreEqual(true, args.WasFrontItem);
+            });
+            buffer.OnItemRemoved += removeHandler;
+
+            for (int i = 0; i < 8; i++)
+            {
+                buffer.PushFront(i);
+            }
+            for (int i = 0; i < 5; i++)
+            {
+                buffer.PopFront();
+            }
+            buffer.OnItemOverflown -= overflownHandler;
+            buffer.OnItemAdded -= addHandler;
+            buffer.OnItemRemoved -= removeHandler;
+
+            //Back
+            buffer.Clear();
+            overflown = 0;
+            added = 0;
+            removed = 7;
+
+            overflownHandler = (sender, args) =>
+            {
+                Assert.AreEqual(overflown++, args.Item);
+                Assert.AreEqual(true, args.WasFrontItem);
+            };
+            buffer.OnItemOverflown += overflownHandler;
+            addHandler = (sender, args) =>
+            {
+                Assert.AreEqual(added++, args.Item);
+                Assert.AreEqual(0, args.Index);
+            };
+            buffer.OnItemAdded += addHandler;
+            removeHandler = (sender, args) =>
+            {
+                Assert.AreEqual(removed--, args.Item);
+                Assert.AreEqual(false, args.WasFrontItem);
+            };
+            buffer.OnItemRemoved += removeHandler;
+
+            for (int i = 0; i < 8; i++)
+            {
+                buffer.PushBack(i);
+            }
+            for (int i = 0; i < 5; i++)
+            {
+                buffer.PopBack();
+            }
+            buffer.OnItemOverflown -= overflownHandler;
+            buffer.OnItemAdded -= addHandler;
+            buffer.OnItemRemoved -= removeHandler;
+        }
+
+        [Test]
+        public void CircularBufferTestJsonConversion()
+        {
+            var buffer = new CircularBuffer<long>(3);
+            buffer.PushFront(0);
+
+            buffer.PushFront(1);
+            buffer.PushBack(-1);
+            buffer.PushFront(2);
+            buffer.PushBack(-2);
+            buffer.PushFront(3);
+            buffer.PushBack(-3);
+
+            var json = Json.JsonSerializer.Serialize(buffer);
+            var deserializedBuffer = Json.JsonSerializer.Deserialize<CircularBuffer<long>>(json);
+
+            Assert.AreEqual(-3, deserializedBuffer[0]);
+            Assert.AreEqual(0, deserializedBuffer[1]);
+            Assert.AreEqual(1, deserializedBuffer[2]);
+            Assert.AreEqual(1, deserializedBuffer.Front());
+            Assert.AreEqual(-3, deserializedBuffer.Back());
+
+            Assert.AreEqual(deserializedBuffer.Count, 3);
+            Assert.AreEqual(deserializedBuffer.Capacity, 3);
+        }
+    }
+}