essentially completed

1 files changed, 180 insertions, 77 deletions

diff --git a/CST 126/UnitTester/UnitTester.cpp b/CST 126/UnitTester/UnitTester.cpp
index aa04fe1..83b51d9 100644
--- a/CST 126/UnitTester/UnitTester.cpp
+++ b/CST 126/UnitTester/UnitTester.cpp
@@ -54,7 +54,6 @@ namespace LinkedListUnitTests
 				TraverseNode = TraverseNode->_next;
 			}
 
-			
 		}
 
 		TEST_METHOD(One_Append_Clear_LinkedList_Success)
@@ -62,7 +61,6 @@ namespace LinkedListUnitTests
 			struct SinglyLinkedList<int> LinkedList = {};
 			ListNode<int>Node1 = { 1,nullptr };
 
-
 			bool success = Append(&LinkedList, &Node1);
 			
 			Clear(&LinkedList);
@@ -70,7 +68,6 @@ namespace LinkedListUnitTests
 			Assert::AreEqual(0ull, LinkedList._size);
 			Assert::IsNull(LinkedList._head);
 
-
 		}
 
 
@@ -116,7 +113,7 @@ namespace LinkedListUnitTests
 			Success = Append(&NewList, &Node3);
 			Success = Append(&NewList, &Node5);
 
-			
+			InsertAfter(&NewList, 3, &Node4);
 
 			ListNode<int>* TraverseNode = NewList._head;
 
@@ -125,106 +122,211 @@ namespace LinkedListUnitTests
 				Assert::AreEqual(i, TraverseNode->_data);
 				TraverseNode = TraverseNode->_next;
 			}
-			
-			//Assert
-			//Assert that list is corret
 		}
 
-		//TEST_METHOD(DeleteFirstLinkWith0)
-		//{
-		//	SinglyLinkedList<int> LinkedList{};
-		//	ListNode<int>* node = new ListNode<int>{};
-		//	bool Success = RemoveFirst(&LinkedList);
-		//	Assert::AreEqual(1, static_cast<int>(Success));
-		//	delete node;
-		//}
-		//
-		//TEST_METHOD(PREPENDLINKEDLIST)
-		//{
+		TEST_METHOD(Insert_Before_UNO_List)
+		{
+			struct SinglyLinkedList<int> NewList{};
+			ListNode<int> Node1 = { 1, nullptr };
+			ListNode<int> Node2 = { 2, nullptr };
+			bool Success = InsertBefore(&NewList, 1, &Node2);
 
-		//}
+			Assert::AreEqual(2, NewList._head->_data);
+		}
 
-		//TEST_METHOD(ExtractFirst_LinkedList_Success)
-		//{
-		//	struct SinglyLinkedList<int> NewList {};
-		//	ListNode<int> Node1 = { 1,nullptr };
-		//	ListNode<int>Node2 = { 2,nullptr };
-		//	ListNode<int>Node3 = { 3,nullptr };
-		//	ListNode<int>Node4 = { 4,nullptr };
-		//	ListNode<int>Node5 = { 5,nullptr };
+		TEST_METHOD(Insert_Before_5_List)
+		{
+			struct SinglyLinkedList<int> NewList {};
+			ListNode<int> Node1 = { 1,nullptr };
+			ListNode<int>Node2 = { 2,nullptr };
+			ListNode<int>Node3 = { 3,nullptr };
+			ListNode<int>Node4 = { 4,nullptr };
+			ListNode<int>Node5 = { 5,nullptr };
+	
+			bool Success = Append(&NewList, &Node1);
+			Success = Append(&NewList, &Node2);
+			Success = Append(&NewList, &Node3);
+			Success = Append(&NewList, &Node5);
+			InsertBefore(&NewList, 5, &Node4);
 
-		//	ListNode<int> NodeArray[] = { Node1, Node2, Node3, Node4, Node5 };
+			ListNode<int>* Traverse = NewList._head;
+			for (auto i = 1; i < 5; i++)
+			{
+				Traverse = Traverse->_next;
+			}
 
-		//	for (auto node : NodeArray)
-		//	{
-		//		Assert::IsTrue(Append(&NewList, &node));
-		//	}
+			Assert::AreEqual(4, Traverse->_data);
+		}
+		
+		TEST_METHOD(DeleteFirstLinkWith0)
+		{
+			SinglyLinkedList<int> LinkedList{};
+			ListNode<int>* node = new ListNode<int>{};
+			bool Success = RemoveFirst(&LinkedList);
+			Assert::AreEqual(1, static_cast<int>(Success));
+			delete node;
+		}
+		
+		TEST_METHOD(Prepend_LinkedList_With_1)
+		{
+			struct SinglyLinkedList<int> NewList {};
+			ListNode<int> Node1 = { 1,nullptr };
 
-		//	ListNode<int>* Temp = Extract(&NewList, Node1._data);
-		//
-		///*	size_t NodeAddress = reinterpret_cast<size_t>(&Node1);
-		//	size_t TempAddress = reinterpret_cast<size_t>(&Temp);*/
-		//	//Assert::AreSame(&Node1, Temp);
+			Prepend(&NewList, &Node1);
 
-		//
-		//	
-		//	//Assert::AreEqual(&Node1, Extract(&NewList, Node1._data));
-		//
-		//	//Assert::AreEqual(NodeAddress, TempAddress);
-		//	//Assert::AreEqual(4ull, NewList._size);
+			Assert::AreEqual(1, NewList._head->_data);
+			Assert::AreEqual(1ull, NewList._size);
+		}
 
+		TEST_METHOD(Prepend_LinkedList_With_5)
+		{
+			struct SinglyLinkedList<int> NewList {};
+			ListNode<int> Node1 = { 1,nullptr };
+			ListNode<int>Node2 = { 2,nullptr };
+			ListNode<int>Node3 = { 3,nullptr };
+			ListNode<int>Node4 = { 4,nullptr };
+			ListNode<int>Node5 = { 5,nullptr };
 
+			bool Success = Append(&NewList, &Node2);
+			Success = Append(&NewList, &Node3);
+			Success = Append(&NewList, &Node4);
+			Success = Append(&NewList, &Node5);
 
+			Prepend(&NewList, &Node1);
 
-		//	delete Temp;
-		//}
+			Assert::AreEqual(1, NewList._head->_data);
+			Assert::AreEqual(5ull, NewList._size);
+		}
 
+		TEST_METHOD(ExtractFirst_LinkedList_Success)
+		{
+			struct SinglyLinkedList<int> NewList {};
+			ListNode<int> Node1 = { 1,nullptr };
+			ListNode<int>Node2 = { 2,nullptr };
+			ListNode<int>Node3 = { 3,nullptr };
+			ListNode<int>Node4 = { 4,nullptr };
+			ListNode<int>Node5 = { 5,nullptr };
 
-		//TEST_METHOD(Extract_Last_LinkedList_Success)
-		//{
-		//	struct SinglyLinkedList<int> NewList {};
-		//	ListNode<int> Node1 = { 1,nullptr };
-		//	ListNode<int>Node2 = { 2,nullptr };
-		//	ListNode<int>Node3 = { 3,nullptr };
-		//	ListNode<int>Node4 = { 4,nullptr };
-		//	ListNode<int>Node5 = { 5,nullptr };
+			
+			bool Success = Append(&NewList, &Node1);
+			Success = Append(&NewList, &Node2);
+			Success = Append(&NewList, &Node3);
+			Success = Append(&NewList, &Node4);
+			Success = Append(&NewList, &Node5);
 
-		//	ListNode<int> NodeArray[] = { Node1, Node2, Node3, Node4, Node5 };
 
-		//	for (auto node : NodeArray)
-		//	{
-		//		Assert::IsTrue(Append(&NewList, &node));
-		//	}
+			ListNode<int>* Temp = Extract(&NewList, Node1._data);
+			ListNode<int>* NullCheck = &Node1;
+		
+			Assert::AreEqual(1, Temp->_data);
+			Assert::IsNull(NullCheck->_next);
 
-		//}
+			delete Temp;
+			
+		}
 
-		//TEST_METHOD(Extract_Middle_LinkedList_Success)
-		//{
-		//	struct SinglyLinkedList<int> NewList {};
-		//	ListNode<int> Node1 = { 1,nullptr };
-		//	ListNode<int>Node2 = { 2,nullptr };
-		//	ListNode<int>Node3 = { 3,nullptr };
-		//	ListNode<int>Node4 = { 4,nullptr };
-		//	ListNode<int>Node5 = { 5,nullptr };
+		TEST_METHOD(Extract_Last_LinkedList_Success)
+		{
+			struct SinglyLinkedList<int> NewList {};
+			ListNode<int> Node1 = { 1,nullptr };
+			ListNode<int>Node2 = { 2,nullptr };
+			ListNode<int>Node3 = { 3,nullptr };
+			ListNode<int>Node4 = { 4,nullptr };
+			ListNode<int>Node5 = { 5,nullptr };
 
-		//	ListNode<int> NodeArray[] = { Node1, Node2, Node3, Node4, Node5 };
+			bool Success = Append(&NewList, &Node1);
+			Success = Append(&NewList, &Node2);
+			Success = Append(&NewList, &Node3);
+			Success = Append(&NewList, &Node4);
+			Success = Append(&NewList, &Node5);
 
-		//	for (auto node : NodeArray)
-		//	{
-		//		Assert::IsTrue(Append(&NewList, &node));
-		//	}
+			ListNode<int>* Temp = Extract(&NewList, Node5._data);
+			ListNode<int>* NullCheck = &Node4;
 
+			Assert::AreEqual(5, Temp->_data);
+			Assert::IsNull(NullCheck->_next);
+
+			delete Temp;
+		}
 
+		TEST_METHOD(Extract_Middle_LinkedList_Success)
+		{
+			struct SinglyLinkedList<int> NewList {};
+			ListNode<int> Node1 = { 1,nullptr };
+			ListNode<int>Node2 = { 2,nullptr };
+			ListNode<int>Node3 = { 3,nullptr };
+			ListNode<int>Node4 = { 4,nullptr };
+			ListNode<int>Node5 = { 5,nullptr };
 
+			
 
-		//}
+			bool Success = Append(&NewList, &Node1);
+			Success = Append(&NewList, &Node2);
+			Success = Append(&NewList, &Node3);
+			Success = Append(&NewList, &Node4);
+			Success = Append(&NewList, &Node5);
 
+
+			ListNode<int>* Temp = Extract(&NewList, Node3._data);
+			ListNode<int>* NullCheck = &Node3;
+
+			Assert::AreEqual(3, Temp->_data);
+			Assert::IsNull(Node3._next);
+			delete Temp;
+
+		}
+
+
+		TEST_METHOD(Clear_LinkedList_Full)
+		{
+			struct SinglyLinkedList<int> NewList {};
+			ListNode<int> Node1 = { 1,nullptr };
+			ListNode<int>Node2 = { 2,nullptr };
+			ListNode<int>Node3 = { 3,nullptr };
+			ListNode<int>Node4 = { 4,nullptr };
+			ListNode<int>Node5 = { 5,nullptr };
+
+
+
+			bool Success = Append(&NewList, &Node1);
+			Success = Append(&NewList, &Node2);
+			Success = Append(&NewList, &Node3);
+			Success = Append(&NewList, &Node4);
+			Success = Append(&NewList, &Node5);
+			Clear(&NewList);
+
+			Assert::AreEqual(0ull, NewList._size);
+
+		}
+
+		TEST_METHOD(Clear_LinkedList_Empty)
+		{
+			struct SinglyLinkedList<int> NewList {};
 		
-		
+			Clear(&NewList);
 
+			Assert::AreEqual(0ull, NewList._size);
+
+		}
+
+		TEST_METHOD(Clear_LinkedList_1)
+		{
+			struct SinglyLinkedList<int> NewList {};
+			ListNode<int> Node1 = { 1,nullptr };
 
+			bool Success = Append(&NewList, &Node1);
+			
+			Clear(&NewList);
 
+			Assert::AreEqual(0ull, NewList._size);
+		
+		}
 	};
+
+
+
+
+
 	TEST_CLASS(NodeUnitTests)
 	{
 	public:
@@ -250,12 +352,13 @@ namespace LinkedListUnitTests
 			Node<int>* NewNode = new Node<int>(5);
 
 			Assert::IsNotNull(NewNode);
+			
 			Assert::AreEqual(5, NewNode->Data());
+
+			delete NewNode;
 		}
 		
 
-	}
-
-
+	};
 
 };