Beispiel #1
0
void TestFirstAndLast(const DoubleLinkedList<int> & alist)
{
	DoubleLinkedList<int> blist;

	std::cout << "\n********** First and Last **********" << std::endl;

	// Full List
	std::cout << alist.First() << std::endl;
	std::cout << alist.Last() << std::endl;

	// Empty List
	try
	{
		std::cout << blist.First() << std::endl;
	}
	catch (char * msg)
	{
		std::cout << msg << std::endl;
	}
	try
	{
		std::cout << blist.Last() << std::endl;
	}
	catch (char * msg)
	{
		std::cout << msg << std::endl;
	}
}
Beispiel #2
0
void TestPrepend(DoubleLinkedList<int> & alist)
{
	DoubleLinkedList<int> blist;

	std::cout << "\n********** Prepend **********" << std::endl;

	// Full List
	alist.Prepend(4);
	alist.Prepend(3);
	alist.Prepend(2);
	alist.Prepend(1);
	alist.Prepend(0);

	std::cout << alist.First() << std::endl;
	std::cout << alist.Last() << std::endl;

	// Empty List
	blist.Prepend(100);
	blist.Prepend(200);
	blist.Prepend(300);
	blist.Prepend(400);
	blist.Prepend(500);

	std::cout << blist.First() << std::endl;
	std::cout << blist.Last() << std::endl;
}
Beispiel #3
0
void TestFirstAndLast(const DoubleLinkedList<int> & alist)
{
    DoubleLinkedList<int> blist;
    
    std::cout << "\n********** Testing: DoubleLinkedList First and Last **********" << std::endl;
    
    std::cout << "\n********** Testing: First and Last with Full List **********" << std::endl;
    std::cout << alist.First() << std::endl;
    std::cout << alist.Last() << std::endl;
    
    std::cout << "\n********** Testing: First with Empty List **********" << std::endl;
    try
    {
        std::cout << blist.First() << std::endl;
    }
    catch (const char * msg)
    {
        std::cout << msg << std::endl;
    }
    std::cout << "\n********** Testing: First with Empty List **********" << std::endl;
    try
    {
        std::cout << blist.Last() << std::endl;
    }
    catch (const char * msg)
    {
        std::cout << msg << std::endl;
    }
}
Beispiel #4
0
void TestExtract()
{
	DoubleLinkedList<int> alist;

	std::cout << "\n********** Extract **********" << std::endl;

	// Empty List
	try
	{
		alist.Extract(0);
	}
	catch (char * msg)
	{
		std::cout << msg << std::endl;
	}
	// Head and Tail are the same
	alist.Append(0);
	alist.Extract(0);

	try
	{
		std::cout << alist.First() << std::endl;
	}
	catch (char * msg)
	{
		std::cout << msg << std::endl;
	}

	try
	{
		std::cout << alist.Last() << std::endl;
	}
	catch (char * msg)
	{
		std::cout << msg << std::endl;
	}

	// Remove Head
	alist.Append(0);
	alist.Append(1);
	alist.Extract(0);

	std::cout << alist.First() << std::endl;
	std::cout << alist.Last() << std::endl;

	// Remove Tail
	alist.Prepend(0);
	alist.Extract(1);

	std::cout << alist.First() << std::endl;
	std::cout << alist.Last() << std::endl;
}
Beispiel #5
0
void TestInsertAfter()
{
    DoubleLinkedList<int> clist;
    
    std::cout << "\n********** Testing: DoubleLinkedList InsertAfter **********" << std::endl;
    
    std::cout << "\n********** Testing: InsertAfter with Empty List **********" << std::endl;
    try
    {
        //Note: Here is the function signature so you can determine the order of parameters
        //void DoubleLinkedList<T>::InsertAfter(const T & new_data, const T & existing_data)
        clist.InsertAfter(-1, 0);
    }
    catch(const char * msg)
    {
        std::cout << msg << std::endl;
    }
    std::cout << "\n********** Testing: InsertAfter tail with only one node **********" << std::endl;
    clist.Append(0);
    clist.InsertAfter(1, 0);
    
    std::cout << clist.First() << std::endl;
    std::cout << clist.Last() << std::endl;
    
    std::cout << "\n********** Testing: InsertAfter tail with multiple nodes **********" << std::endl;
    clist.InsertAfter(3, 1);
    
    std::cout << clist.First() << std::endl;
    std::cout << clist.Last() << std::endl;
    
    std::cout << "\n********** Testing: InsertAfter a node in the middle of the list **********" << std::endl;
    clist.InsertAfter(2, 1);
    
    std::cout << clist.First() << std::endl;
    std::cout << clist.Last() << std::endl;
    
    std::cout << "\n********** Testing: InsertAfter but existing_data doesn't exist **********" << std::endl;
    try
    {
        clist.InsertAfter(-2, 99);
    }
    catch (const char * msg)
    {
        std::cout << msg << std::endl;
    }
}
Beispiel #6
0
void TestInsertBefore()
{
	DoubleLinkedList<int> clist;

	std::cout << "\n********** InsertBefore **********" << std::endl;

	// Empty List
	try
	{
		clist.InsertBefore(-1, 0);
	}
	catch (char * msg)
	{
		std::cout << msg << std::endl;
	}
	// Head and Tail are the same
	clist.Append(0);
	clist.InsertBefore(-1, 0);

	std::cout << clist.First() << std::endl;
	std::cout << clist.Last() << std::endl;

	// Before Head
	clist.InsertBefore(-3, -1);

	std::cout << clist.First() << std::endl;
	std::cout << clist.Last() << std::endl;

	// Middle
	clist.InsertBefore(-2, -1);

	std::cout << clist.First() << std::endl;
	std::cout << clist.Last() << std::endl;

	// Node doesn't exist
	try
	{
		clist.InsertBefore(-2, 99);
	}
	catch (char * msg)
	{
		std::cout << msg << std::endl;
	}
}
Beispiel #7
0
void TestInsertAfter()
{
	DoubleLinkedList<int> clist;

	std::cout << "\n********** InsertAfter **********" << std::endl;

	try
	{
		clist.InsertAfter(-1, 0);
	}
	catch (char * msg)
	{
		std::cout << msg << std::endl;
	}
	// Head and Tail are the same
	clist.Append(0);
	clist.InsertAfter(1, 0);

	std::cout << clist.First() << std::endl;
	std::cout << clist.Last() << std::endl;

	// After Tail
	clist.InsertAfter(3, 1);

	std::cout << clist.First() << std::endl;
	std::cout << clist.Last() << std::endl;

	// Middle
	clist.InsertAfter(2, 1);

	std::cout << clist.First() << std::endl;
	std::cout << clist.Last() << std::endl;

	// Node doesn't exist
	try
	{
		clist.InsertAfter(-2, 99);
	}
	catch (char * msg)
	{
		std::cout << msg << std::endl;
	}
}
Beispiel #8
0
void TestAppend(DoubleLinkedList<int> & alist)
{
    std::cout << "\n********** Testing: DoubleLinkedList Append **********" << std::endl;
    
    alist.Append(5);
    alist.Append(15);
    alist.Append(25);
    alist.Append(35);
    
    std::cout << alist.First() << std::endl;
    std::cout << alist.Last() << std::endl;
}
Beispiel #9
0
void TestExtract()
{
    DoubleLinkedList<int> alist;
    
    std::cout << "\n********** Testing: DoubleLinkedList Extract **********" << std::endl;
    
    std::cout << "\n********** Testing: Extract with empty list**********" << std::endl;
    try
    {
        //Note: The parameter is the DATA to be removed
        alist.Extract(0);
    }
    catch (const char * msg)
    {
        std::cout << msg << std::endl;
    }
    std::cout << "\n********** Testing: Extract removing only node **********" << std::endl;
    alist.Append(0);
    alist.Extract(0);
    
    try
    {
        std::cout << alist.First() << std::endl;
    }
    catch (const char * msg)
    {
        std::cout << msg << std::endl;
    }
    try
    {
        std::cout << alist.Last() << std::endl;
    }
    catch (const char * msg)
    {
        std::cout << msg << std::endl;
    }
    
    std::cout << "\n********** Testing: Extract removing head **********" << std::endl;
    alist.Append(0);
    alist.Append(1);
    alist.Extract(0);
    
    std::cout << alist.First() << std::endl;
    std::cout << alist.Last() << std::endl;
    
    std::cout << "\n********** Testing: Extract removing tail **********" << std::endl;
    alist.Prepend(0);
    alist.Extract(1);
    
    std::cout << alist.First() << std::endl;
    std::cout << alist.Last() << std::endl;
    
    std::cout << "\n********** Testing: Extract removing non-existing node **********" << std::endl;
    alist.Append(0);
    alist.Append(1);
    
    try
    {
        alist.Extract(99);
    }
    catch (const char * msg)
    {
        std::cout << msg << std::endl;
    }
}