Update README

Author: seanchen1991

README.md

@@ -30,11 +30,7 @@ This Sprint Challenge is split into three parts:
 
 A ring buffer is a non-growable buffer with a fixed size. When the ring buffer is full and a new element is inserted, the oldest element in the ring buffer is overwritten with the newest element. This kind of data structure is very useful for use cases such as storing logs and history information, where you typically want to store information up until it reaches a certain age, after which you don't care about it anymore and don't mind seeing it overwritten by newer data.
 
-Implement this behavior in the RingBuffer class. RingBuffer has two methods, `append` and `get`. The `append` method adds elements to the buffer. The `get` method, which is provided, returns all of the elements in the buffer in a list in their given order. It should not return any `None` values in the list even if they are present in the ring buffer.
-
-_You may not use a Python List in your implementation of the `append` method (except for the stretch goal)_
-
-*Stretch Goal*:  Another method of implementing a ring buffer uses an array (Python List) instead of a linked list.  What are the advantages and disadvantages of using this method?  What disadvantage normally found in arrays is overcome with this arrangement?
+Implement this behavior in the RingBuffer class. RingBuffer has two methods, `append` and `get`. The `append` method adds the given element to the buffer. The `get` method returns all of the elements in the buffer in a list in their given order. It should not return any `None` values in the list even if they are present in the ring buffer.
 
 For example:
 
@@ -73,7 +69,7 @@ Six seconds is an eternity so you've been tasked with speeding up the code. Can
 (Hint: You might try importing a data structure you built during the week)
 
 
-#### Task 3. Reverse a Linked List Recursively
+#### Task 3. Reverse a Linked List
 
 Inside of the `reverse` directory, you'll find a basic implementation of a Singly Linked List. _Without_ making it a Doubly Linked List (adding a tail attribute), complete the `reverse_list()` function within `reverse/reverse.py` reverse the contents of the list using recursion, *not a loop.*
 

ring_buffer/test_ring_buffer.py

@@ -3,75 +3,50 @@
 
 class RingBufferTests(unittest.TestCase):
     def setUp(self):
-        self.buffer = RingBuffer(5)
-        self.buffer_2 = RingBuffer(5)
+        self.capacity = 5
+        self.buffer = RingBuffer(self.capacity)
+    
+    def test_new_buffer_has_appropriate_capacity(self):
+        self.assertEqual(self.buffer.capacity, self.capacity)
 
-    def test_ring_buffer(self):
-        self.assertEqual(self.buffer.storage.length, 0)
+    def test_adding_one_element_to_buffer(self):
+        self.buffer.append('a')
+        self.assertEqual(self.buffer.get(), ['a'])
 
+    def test_filling_buffer_to_capacity(self):
         self.buffer.append('a')
         self.buffer.append('b')
         self.buffer.append('c')
         self.buffer.append('d')
-        self.assertEqual(self.buffer.storage.length, 4)
-        self.assertEqual(self.buffer.get(), ['a', 'b', 'c', 'd'])
-
         self.buffer.append('e')
-        self.assertEqual(self.buffer.storage.length, 5)
         self.assertEqual(self.buffer.get(), ['a', 'b', 'c', 'd', 'e'])
 
+    def test_adding_one_element_to_full_buffer(self):
+        self.buffer.append('a')
+        self.buffer.append('b')
+        self.buffer.append('c')
+        self.buffer.append('d')
+        self.buffer.append('e')
         self.buffer.append('f')
-        self.assertEqual(self.buffer.storage.length, 5)
         self.assertEqual(self.buffer.get(), ['f', 'b', 'c', 'd', 'e'])
 
-        self.buffer.append('g')
-        self.buffer.append('h')
-        self.buffer.append('i')
-        self.assertEqual(self.buffer.storage.length, 5)
-        self.assertEqual(self.buffer.get(), ['f', 'g', 'h', 'i', 'e'])
-
-        self.buffer.append('j')
-        self.buffer.append('k')
-        self.assertEqual(self.buffer.get(), ['k', 'g', 'h', 'i', 'j'])
-
-        for i in range(50):
-            self.buffer_2.append(i)
-        self.assertEqual(self.buffer_2.get(), [45, 46, 47, 48, 49])
-
-
-class ArrayRingBufferTests(unittest.TestCase):
-    def setUp(self):
-        self.buffer = ArrayRingBuffer(5)
-        self.buffer_2 = ArrayRingBuffer(5)
-
-    def test__array_ring_buffer(self):
-        self.assertEqual(len(self.buffer.storage), 5)
-
+    def test_adding_many_elements_to_full_buffer(self):
         self.buffer.append('a')
         self.buffer.append('b')
         self.buffer.append('c')
         self.buffer.append('d')
-        self.assertEqual(len(self.buffer.storage), 5)
-        self.assertEqual(self.buffer.get(), ['a', 'b', 'c', 'd'])
-
         self.buffer.append('e')
-        self.assertEqual(len(self.buffer.storage), 5)
-        self.assertEqual(self.buffer.get(), ['a', 'b', 'c', 'd', 'e'])
-
         self.buffer.append('f')
-        self.assertEqual(len(self.buffer.storage), 5)
-        self.assertEqual(self.buffer.get(), ['f', 'b', 'c', 'd', 'e'])
-
         self.buffer.append('g')
         self.buffer.append('h')
         self.buffer.append('i')
-        self.assertEqual(len(self.buffer.storage), 5)
         self.assertEqual(self.buffer.get(), ['f', 'g', 'h', 'i', 'e'])
 
+    def test_adding_50_elements_to_buffer(self):
         for i in range(50):
-            self.buffer_2.append(i)
-        self.assertEqual(self.buffer_2.get(), [45, 46, 47, 48, 49])
+            self.buffer.append(i)
 
+        self.assertEqual(self.buffer.get(), [45, 46, 47, 48, 49])
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()