unit tests added

2 files changed, 338 insertions, 27 deletions

diff --git a/CST 126/Homework3/SinglyLinkedList.hpp b/CST 126/Homework3/SinglyLinkedList.hpp
index c877ed1..06e5f08 100644
--- a/CST 126/Homework3/SinglyLinkedList.hpp
+++ b/CST 126/Homework3/SinglyLinkedList.hpp
@@ -16,6 +16,9 @@ struct SinglyLinkedList
 	ListNode<T>* _head{ nullptr };
 
 };
+//prototype all your functions!
+
+
 
 template<typename T>
 inline bool Append(SinglyLinkedList<T>* list, ListNode<T>* node)
@@ -27,11 +30,13 @@ inline bool Append(SinglyLinkedList<T>* list, ListNode<T>* node)
 		return true;
 	}
 	ListNode<T>* TraverseNode = nullptr;
-	for (TraverseNode = list->_head; TraverseNode->_next!= nullptr;)
-	{
-		TraverseNode = TraverseNode->_next;
-	}
+		for (TraverseNode = list->_head; TraverseNode->_next != nullptr;)
+		{
+			TraverseNode = TraverseNode->_next;
+		}
+
 	TraverseNode->_next = node;
+	list->_size++;
 	return true;
 
 }
@@ -52,7 +57,7 @@ inline bool Prepend(SinglyLinkedList<T>* list, ListNode<T>* node)
 }
 
 template<typename T>
-inline bool RemoveFirst(SinglyLinkedList<T>* list, ListNode<T>* node)
+inline bool RemoveFirst(SinglyLinkedList<T>* list)
 {
 	if (list->_size == 0)
 	{
@@ -60,15 +65,25 @@ inline bool RemoveFirst(SinglyLinkedList<T>* list, ListNode<T>* node)
 		return true;
 
 	}
-	ListNode<T>* Temp = list->_head;
-	list->_head = node->_next;
-	list->_size--;
-	delete Temp;
+	if (list->_size == 1)
+	{
+		list->_head =nullptr;
+	}
+	else 
+	{
+
+		ListNode<T>* Temp = list->_head;
+		list->_head = list->_head->_next;
+		Temp->_next = nullptr;
+		
+		list->_size--;
+	}
+	
 	return true;
 }
 
 template<typename T>
-inline bool RemoveLast(SinglyLinkedList<T>* list, ListNode<T>* node)
+inline bool RemoveLast(SinglyLinkedList<T>* list)
 {
 	if (list->_size == 0)
 	{
@@ -77,7 +92,6 @@ inline bool RemoveLast(SinglyLinkedList<T>* list, ListNode<T>* node)
 	}
 	if (list->size == 1)
 	{
-		delete list->_head;
 		list->_head = nullptr;
 		list->_size--;
 		return true;
@@ -87,10 +101,138 @@ inline bool RemoveLast(SinglyLinkedList<T>* list, ListNode<T>* node)
 	{
 		TraverseNode = TraverseNode->_next;
 	}
-	delete TraverseNode->_next;
 	TraverseNode->_next = nullptr;
 	list->_size--;
 	return true;
 }
 
+template <typename T>
+inline bool InsertAfter(SinglyLinkedList<T>* List, const int Data, ListNode<T>* node)
+{
+	if (List->_head == nullptr)
+	{
+		Append(List, node);
+		return true;
+	}
+	ListNode<T>* Traverse = List->_head;
+	for (auto i = 1u; i < Data && Traverse != nullptr; i++)
+	{
+		Traverse = Traverse->_next;
+	}
+	node._next = Traverse->_next;
+	
+	Traverse->_next = node;
+	List->_size++;
+	
+	return true;
+}
+
+template <typename T>
+inline bool InsertBefore(SinglyLinkedList<T>* List, const int Data, ListNode<T>* node)
+{
+	return false;
+}
+
+template <typename T>
+inline bool Clear(SinglyLinkedList<T>* List)
+{
+	if (List->_size == 0)
+	{
+		return true;
+	}
+	if (List->_size == 1)
+	{
+		List->_head = nullptr;
+		List->_size--;
+		return true;
+	}
+	ListNode<T>* Traverse = List->_head;
+	ListNode<T>* TempNode = Traverse;
+
+
+	do
+	{
+		TempNode = Traverse;
+		Traverse = Traverse->_next;
+		TempNode->_data = 0;
+		TempNode->_next = nullptr;
+	} while (Traverse->_next != nullptr);
+	
+	List->_size = 0;
+	List->_head = nullptr;
+	return true;
+}
+
+template <typename T>
+inline bool Empty(SinglyLinkedList<T>* List)
+{
+	return (List->_size == 0 && List->_head == nullptr);
+}
+
+template <typename T>
+inline bool Remove(SinglyLinkedList<T>* List, ListNode<T>* node)
+{
+
+	ListNode<T>* Traverse = List->_head;
+	ListNode<T>* Previous = nullptr;
+	while (Traverse != node)
+	{
+		Previous = Traverse;
+		Traverse = Traverse->_next;
+	}
+	if (Traverse == List->_head)
+	{
+		return RemoveFirst(List);
+	}
+	if (Traverse->_next == nullptr)
+	{
+		//return RemoveLast(List);
+		return true;
+	}
+
+	Previous->_next = Traverse->_next;
+
+	//"delete" Traverse
+	Traverse->_next = nullptr;
+	Traverse->_data = 0;
+	List->_size--;
+
+	return true;
+}
+
+
+
+template <typename T>
+inline ListNode<T>* Extract(SinglyLinkedList<T>* List, const int Data)
+{
+	ListNode<T>* Temp = new ListNode<T>{ 0, nullptr };
+
+	ListNode<T>* Travel = nullptr;
+	//check if empty
+	if (Empty(List))
+	{
+		std::cout << "Empty list, nothing to extract!" << std::endl;
+		return Temp;
+
+	}
+
+	for (Travel = List->_head; Travel->_data != Data && Travel->_next != nullptr;)
+	{
+		Travel = Travel->_next;
+	}
+	Temp->_data = Travel->_data;
+
+	//read through list
+	//find data
+	//return pointer to the node
+	//remove node from list
+	if (Remove<T>(List, Travel))
+	{
+		return Temp;
+	}
+
+	return nullptr;
+}
+
+
 #endif
\ No newline at end of file
diff --git a/CST 126/UnitTester/UnitTester.cpp b/CST 126/UnitTester/UnitTester.cpp
index 47be36c..1ad15fd 100644
--- a/CST 126/UnitTester/UnitTester.cpp
+++ b/CST 126/UnitTester/UnitTester.cpp
@@ -27,25 +27,194 @@ namespace LinkedListUnitTests
 		}
 		TEST_METHOD(AppendingLinkedListWith5Items)
 		{
-			SinglyLinkedList<int> LinkedList{};
-			ListNode<int>* node = new ListNode<int>{ 5, nullptr };
-			Append(&LinkedList, node);
-			Append(&LinkedList, node);
-			Append(&LinkedList, node);
-			Append(&LinkedList, node);
-			Append(&LinkedList, node);
+			struct SinglyLinkedList<int> LinkedList = {};
+			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 };
+			
 
-			Assert::AreEqual(5, LinkedList._head->_next->_next->_next->_next->_data);
-			delete node;
+			bool success = Append(&LinkedList, &Node1);
+			success = Append(&LinkedList, &Node2);
+			success = Append(&LinkedList, &Node3);
+			success = Append(&LinkedList, &Node4);
+			success = Append(&LinkedList, &Node5);
+
+			Assert::AreEqual(Node1._data, LinkedList._head->_data);
+
+			ListNode<int>* TraverseNode = LinkedList._head;
+
+			for (auto i = 1; i <= 5; i++)
+			{
+				Assert::AreEqual(i, TraverseNode->_data);
+				TraverseNode = TraverseNode->_next;
+			}
+
+			
 		}
 
-		TEST_METHOD(DeleteFirstLinkWith0)
+		TEST_METHOD(One_Append_Clear_LinkedList_Success)
 		{
-			SinglyLinkedList<int> LinkedList{};
-			ListNode<int>* node = new ListNode<int>{};
-			bool Success = RemoveFirst(&LinkedList, node);
-			Assert::AreEqual(1, static_cast<int>(Success));
-			delete node;
+			struct SinglyLinkedList<int> LinkedList = {};
+			ListNode<int>Node1 = { 1,nullptr };
+
+
+			bool success = Append(&LinkedList, &Node1);
+			
+			Clear(&LinkedList);
+
+			Assert::AreEqual(0ull, LinkedList._size);
+			Assert::IsNull(LinkedList._head);
+
+
 		}
+
+
+		TEST_METHOD(Multiple_Append_Clear_LinkedList_Success)
+		{
+			struct SinglyLinkedList<int> LinkedList = {};
+			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(&LinkedList, &Node1);
+			success = Append(&LinkedList, &Node2);
+			success = Append(&LinkedList, &Node3);
+			success = Append(&LinkedList, &Node4);
+			success = Append(&LinkedList, &Node5);
+
+
+			Clear(&LinkedList);
+
+			Assert::AreEqual(0ull, LinkedList._size);
+			Assert::IsNull(LinkedList._head);
+			Assert::IsNull(Node1._next);
+			Assert::IsNull(Node2._next);
+			Assert::IsNull(Node3._next);
+			Assert::IsNull(Node4._next);
+			Assert::IsNull(Node5._next);
+		}
+
+		TEST_METHOD(Insert_After_Single_LinkedList_Success)
+		{
+			//Arrange
+			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 };
+			//Act
+			bool Success = Append(&NewList, &Node1);
+			Success = Append(&NewList, &Node2);
+			Success = Append(&NewList, &Node3);
+			Success = Append(&NewList, &Node5);
+
+			
+
+			ListNode<int>* TraverseNode = NewList._head;
+
+			for (auto i = 1; i < 5; i++)
+			{
+				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(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 };
+
+		//	ListNode<int> NodeArray[] = { Node1, Node2, Node3, Node4, Node5 };
+
+		//	for (auto node : NodeArray)
+		//	{
+		//		Assert::IsTrue(Append(&NewList, &node));
+		//	}
+
+		//	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);
+
+		//
+		//	
+		//	//Assert::AreEqual(&Node1, Extract(&NewList, Node1._data));
+		//
+		//	//Assert::AreEqual(NodeAddress, TempAddress);
+		//	//Assert::AreEqual(4ull, NewList._size);
+
+
+
+
+		//	delete Temp;
+		//}
+
+
+		//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 };
+
+		//	for (auto node : NodeArray)
+		//	{
+		//		Assert::IsTrue(Append(&NewList, &node));
+		//	}
+
+		//}
+
+		//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 };
+
+		//	ListNode<int> NodeArray[] = { Node1, Node2, Node3, Node4, Node5 };
+
+		//	for (auto node : NodeArray)
+		//	{
+		//		Assert::IsTrue(Append(&NewList, &node));
+		//	}
+
+
+
+
+		//}
+
 	};
 }