Added CircularBuffer DataStructure. It's also known as circular queue or ring buffer. I also added appropriate unit tests for each behaviour

Author: NdubuisiJr

DataStructures/Lists/CircularBuffer.cs

@@ -0,0 +1,87 @@
+using System;
+
+namespace DataStructures.Lists {
+    public class CircularBuffer<T> {
+        /// <summary>
+        /// Initializes a circular buffer with initial length of 10
+        /// </summary>
+        public CircularBuffer(bool canOverride=true) : this(10,canOverride) {
+        }
+
+        /// <summary>
+        /// Initializes a circular buffer with given length
+        /// </summary>
+        /// <param name="length">The length of the buffer</param>
+        public CircularBuffer(int length, bool canOverride=true) {
+            if (length < 1) {
+                throw new ArgumentOutOfRangeException("length can not be zero or negative");
+            }
+            _circularBuffer = new T[length + 1];
+            _end = 0;
+            _start = 0;
+            CanOverride = canOverride;
+        }
+
+        /// <summary>
+        /// Writes value to the back of the buffer
+        /// </summary>
+        /// <param name="value">value to be added to the buffer</param>
+        public void Write(T value) {
+            if (CanOverride) {
+                InsertData(value);
+            }
+            else {
+                DontOverrides(value);
+            }
+        }
+
+        /// <summary>
+        /// Inserts data into the buffer when it is not filled up
+        /// </summary>
+        /// <param name="value"></param>
+        private void DontOverrides(T value) {
+            if (IsFilledUp) {
+                return;
+            }
+            InsertData(value);
+        }
+
+        /// <summary>
+        /// Inserts data into the buffer without checking if it is full
+        /// </summary>
+        /// <param name="value"></param>
+        private void InsertData(T value) {
+            _circularBuffer[_end] = value;
+            _end = (_end + 1) % _circularBuffer.Length;
+            if (_end == _start) {
+                _start = (_start + 1) % _circularBuffer.Length;
+            }
+        }
+
+        /// <summary>
+        ///     Reads value from the front of the buffer
+        ///     <summay>
+        ///         Use the IsEmpty property to know when to read appropriately.
+        ///     </summay>
+        /// </summary>
+        /// <returns></returns>
+        public T Read() {
+            var result = _circularBuffer[_start];
+            _circularBuffer[_start] = _circularBuffer[_end];
+            _start = (_start + 1) % _circularBuffer.Length;
+            return result;
+        }
+
+        public bool IsEmpty { get => _end == _start; }
+        public int Length { get => _circularBuffer.Length - 1; }
+        public bool IsFilledUp { get => ((_end + 1) % _circularBuffer.Length == _start) && !_circularBuffer[_start].Equals(_circularBuffer[_end]); }
+        /// <summary>
+        /// Controls whether data should be overridden when it is continously inserted without reading
+        /// </summary>
+        public bool CanOverride { get; }
+
+        private T[] _circularBuffer;
+        private int _end;
+        private int _start;
+    }
+}

UnitTest/DataStructuresTests/CircularBufferTest.cs

@@ -0,0 +1,91 @@
+using DataStructures.Lists;
+using Xunit;
+
+namespace UnitTest.DataStructuresTests {
+    public class CircularBufferTest {
+        
+        [Fact]
+        public static void SetsFixedLength() {
+            var circularBuffer = new CircularBuffer<byte>(3);
+            var length = circularBuffer.Length;
+
+            Assert.Equal(3, length);
+        }
+
+        [Fact]
+        public static void InitializesWithDefaultLengthOf10() {
+            var circularBuffer = new CircularBuffer<byte>();
+            var length = circularBuffer.Length;
+
+            Assert.Equal(10, length);
+        }
+
+        [Fact]
+        public static void WritesAndReadsValue() {
+            var circularBuffer = new CircularBuffer<byte>(4);
+            circularBuffer.Write(13);
+            circularBuffer.Write(43);
+            circularBuffer.Write(23);
+            circularBuffer.Write(2);
+
+            var result1 = circularBuffer.Read();
+            var result2 = circularBuffer.Read();
+            var result3 = circularBuffer.Read();
+            var result4 = circularBuffer.Read();
+            var result5 = circularBuffer.Read();
+            var result6 = circularBuffer.Read();
+            var result7 = circularBuffer.Read();
+            var result8 = circularBuffer.Read();
+
+            Assert.Equal(13, result1);
+            Assert.Equal(43, result2);
+            Assert.Equal(23, result3);
+            Assert.Equal(2, result4);
+            Assert.Equal(0, result5);
+            Assert.Equal(0, result6);
+            Assert.Equal(0, result7);
+            Assert.Equal(0, result8);
+        }
+
+        [Fact]
+        public static void TestingCantOverrideFunctionality() {
+            var circularBuffer = new CircularBuffer<byte>(3, false);
+            circularBuffer.Write(3);
+            circularBuffer.Write(34);
+            circularBuffer.Write(24);
+            // if it doesn't override, then the values above will be read else, 
+            // the value below will be read
+            circularBuffer.Write(2);
+            circularBuffer.Write(1);
+            circularBuffer.Write(3);
+
+            var result1 = circularBuffer.Read();
+            var result2 = circularBuffer.Read();
+            var result3 = circularBuffer.Read();
+
+            Assert.Equal(3, result1);
+            Assert.Equal(34, result2);
+            Assert.Equal(24, result3);
+        }
+
+        [Fact]
+        public static void TestingWritingAndReadingSimultenouslyWithoutOverriding() {
+            var circularBuffer = new CircularBuffer<byte>(3, false);
+            circularBuffer.Write(3);
+            circularBuffer.Write(34);
+            circularBuffer.Write(24);
+            var result1 = circularBuffer.Read();
+            var result2 = circularBuffer.Read();
+
+            circularBuffer.Write(4);
+            circularBuffer.Write(14);
+            var result3 = circularBuffer.Read();
+            var result4 = circularBuffer.Read();
+            var result5 = circularBuffer.Read();
+
+            Assert.Equal(24, result3);
+            Assert.Equal(4, result4);
+            Assert.Equal(14, result5);
+        }
+    }
+}