Corrected '{' convention. Implemented all resolved suggestions on pull request

Author: NdubuisiJr

DataStructures/Lists/CircularBuffer.cs

@@ -1,19 +1,24 @@
 using System;
 
-namespace DataStructures.Lists {
-    public class CircularBuffer<T> {
+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) {
+        public CircularBuffer(bool canOverride=true) : this(_defaultBufferLength, 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) {
+        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];
@@ -26,62 +31,68 @@ public CircularBuffer(int length, bool canOverride=true) {
         /// 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) {
+        public void Write(T value) 
+        {
+            if (CanOverride) 
+            {
                 InsertData(value);
             }
-            else {
+            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;
+        // Inserts data into the buffer when it is not filled up
+        private void DontOverrides(T value) 
+        {
+            if (IsFilledUp) 
+            {
+                throw new CircularBufferFullException($"Circular Buffer is filled up. {value} can not be inserted");
             }
             InsertData(value);
         }
 
-        /// <summary>
-        /// Inserts data into the buffer without checking if it is full
-        /// </summary>
-        /// <param name="value"></param>
-        private void InsertData(T value) {
+        // Inserts data into the buffer without checking if it is full
+        private void InsertData(T value) 
+        {
             _circularBuffer[_end] = value;
             _end = (_end + 1) % _circularBuffer.Length;
-            if (_end == _start) {
+            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() {
+        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; }
+        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]); }
 
         private T[] _circularBuffer;
         private int _end;
         private int _start;
+        private static readonly int _defaultBufferLength = 10;
+    }
+
+    public class CircularBufferFullException: Exception 
+    {
+        public CircularBufferFullException(string message) : base(message) 
+        {
+        }
     }
 }

UnitTest/DataStructuresTests/CircularBufferTest.cs

@@ -1,27 +1,75 @@
 using DataStructures.Lists;
+using System;
 using Xunit;
 
-namespace UnitTest.DataStructuresTests {
-    public class CircularBufferTest {
+namespace UnitTest.DataStructuresTests 
+{
+    public class CircularBufferTest 
+    {
 
         [Fact]
-        public static void SetsFixedLength() {
+        public static void SetsFixedLength() 
+        {
             var circularBuffer = new CircularBuffer<byte>(3);
             var length = circularBuffer.Length;
-
             Assert.Equal(3, length);
         }
 
         [Fact]
-        public static void InitializesWithDefaultLengthOf10() {
+        public static void ChecksIsEmptyProperty() 
+        {
+            var circularBuffer = new CircularBuffer<byte>(4);
+            Assert.True(circularBuffer.IsEmpty);
+        }
+
+        [Fact]
+        public static void ChecksIsFilledProperty() 
+        {
+            var circularBuffer = new CircularBuffer<byte>(3, false);
+            circularBuffer.Write(1);
+            circularBuffer.Write(2);
+            circularBuffer.Write(3);
+
+            Assert.True(circularBuffer.IsFilledUp);
+        }
+
+        [Fact]
+        public static void InitializesWithDefaultLengthOf10() 
+        {
             var circularBuffer = new CircularBuffer<byte>();
             var length = circularBuffer.Length;
 
             Assert.Equal(10, length);
         }
+        [Fact]
+        public static void ThrowsArguementOutOfRangeExceptionForLengthLessThanOne() 
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => 
+            {
+                var circularBuffer = new CircularBuffer<byte>(0);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => 
+            {
+                var circularBuffer = new CircularBuffer<byte>(-2);
+            });
+        }
+
+        [Fact]
+        public static void ThrowsCircularBufferFullExceptionWhenInsertingInFullBuffer() 
+        {
+            Assert.Throws<CircularBufferFullException>(() => 
+            {
+                var circularBuffer = new CircularBuffer<byte>(3, false);
+                circularBuffer.Write(1);
+                circularBuffer.Write(2);
+                circularBuffer.Write(3);
+                circularBuffer.Write(4);
+            });
+        }
 
         [Fact]
-        public static void WritesAndReadsValue() {
+        public static void WritesAndReadsValue() 
+        {
             var circularBuffer = new CircularBuffer<byte>(4);
             circularBuffer.Write(13);
             circularBuffer.Write(43);
@@ -48,7 +96,8 @@ public static void WritesAndReadsValue() {
         }
 
         [Fact]
-        public static void TestingCantOverrideFunctionality() {
+        public static void TestingCantOverrideFunctionality() 
+        {
             var circularBuffer = new CircularBuffer<byte>(3, false);
             circularBuffer.Write(3);
             circularBuffer.Write(34);
@@ -69,7 +118,8 @@ public static void TestingCantOverrideFunctionality() {
         }
 
         [Fact]
-        public static void TestingWritingAndReadingSimultenouslyWithoutOverriding() {
+        public static void TestingWritingAndReadingSimultenouslyWithoutOverriding() 
+        {
             var circularBuffer = new CircularBuffer<byte>(3, false);
             circularBuffer.Write(3);
             circularBuffer.Write(34);