//=======================================================================
// File: SCHNTST.CPP
//         
// Created: Thursday, September 29, 1994, 2:37 PM
// Author: Eric Huffman
// Project: Node.Û
// Compiler: 7.0, Û Symantec Corporation 1994
//-----------------------------------------------------------------------
// 11/03/94  ECH  Made compatible with BC4.0
//-----------------------------------------------------------------------
// Copyright (C) 1994, Virtual World Entertainments, All Rights reserved 
// PROPRIETARY AND CONFIDENTIAL                                          
//=======================================================================

#include "time.hpp"

class SChainTestPlug:
	public Plug
{
public:
	long value;
		
	SChainTestPlug(long value);
	~SChainTestPlug();
};

class SChainTestNode:
	public Node
{
public:
	SChainOf<SChainTestPlug*>
		chain1,
		chain2;

	SChainTestNode();
	~SChainTestNode();

	void RunProfile();
	void RunTest();
};

SChainTestPlug::SChainTestPlug(long value):
	Plug()
{
	this->value = value;
}

SChainTestPlug::~SChainTestPlug()
{
}

SChainTestNode::SChainTestNode():
	Node(), chain1(this), chain2(this)
{
}

SChainTestNode::~SChainTestNode()
{
}

#define RandInt(x) (rand() % x + 1)

//
//###########################################################################
// ProfileClass
//###########################################################################
//

void
	SChain::ProfileClass()
{
	SChainTestNode testNode;
	Time startTicks = Now();

	Test_Message("SChain::ProfileClass\n");

	testNode.RunProfile();

	Test_Message("SChain::ProfileClass elapsed = " << (Now() - startTicks) << endl);
}

//
//###########################################################################
// TestClass
//###########################################################################
//

void
	SChain::TestClass()
{
	DEBUG_STREAM << "Starting SChain test...\n";

	SChainTestNode testNode;

	testNode.RunTest();
}

void
	SChainTestNode::RunProfile()
{
	SChainTestPlug	*testPlug1;
	int 				i;
	Time 				startTicks;

	//
	//--------------------------------------------------------------------
	// Run timing tests
	//--------------------------------------------------------------------
	//

	/*
	 * Create plugs and add to both sockets
	 */
	startTicks = Now();
	for (i = 0; i < TEST_CLASS; i++) 
	{
		testPlug1 = new SChainTestPlug(i);
		Register_Object( testPlug1 );
		chain1.Add(testPlug1);
		chain2.Add(testPlug1);
	}
	Test_Message("SChainTestNode::RunTest Create = " << (Now() - startTicks) << endl);

	/*
	 * Iterate over both sockets
	 */
	startTicks = Now();
	{
		SChainIteratorOf<SChainTestPlug*> iterator1(&chain1);
		SChainIteratorOf<SChainTestPlug*> iterator2(&chain2);
	
		Verify( iterator1.GetSize() == TEST_CLASS );
		Verify( iterator2.GetSize() == TEST_CLASS );
		
		i = 0;
		while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
		{
			Check( testPlug1 );
			Verify( testPlug1->value == i );
			i++;
		}
		Verify( i == TEST_CLASS );
		
		i = 0;
		while ((testPlug1 = iterator2.ReadAndNext()) != NULL)
		{
			Check( testPlug1 );
			Verify( testPlug1->value == i );
			i++;
		}
		Verify( i == TEST_CLASS );
	}
	Test_Message("SChainTestNode::RunTest Iterate = " << (Now() - startTicks) << endl);

	/*
	 * Destroy from chain1, verify with chain2
	 */
	startTicks = Now();
	{
		SChainIteratorOf<SChainTestPlug*> iterator1(&chain1);
		SChainIteratorOf<SChainTestPlug*> iterator2(&chain2);

		Verify( iterator1.GetSize() == TEST_CLASS );
		Verify( iterator2.GetSize() == TEST_CLASS );

		i = 0;
		while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
		{
			Check( testPlug1 );
			Verify( testPlug1->value == i );
			i++;
			
			Unregister_Object( testPlug1 );
			delete(testPlug1);
		}
		Verify( i == TEST_CLASS );
		
		Verify( iterator1.GetSize() == 0 );
		Verify( iterator2.GetSize() == 0 );
	}
	Test_Message("SChainTestNode::RunTest Destroy = " << (Now() - startTicks) << endl);
}

void
	SChainTestNode::RunTest()
{
	SChainTestPlug	*testPlug1, *testPlug2;
	int 			i, j;
//	Time 		startTicks;

	//
	//--------------------------------------------------------------------
	// Stress tests
	//--------------------------------------------------------------------
	//

	/*
	 * Create plugs and add to both sockets
	 */
	for (i = 0; i < TEST_CLASS; i++) 
	{
		testPlug1 = new SChainTestPlug(i);
		Register_Object( testPlug1 );
		chain1.Add(testPlug1);
		chain2.Add(testPlug1);
	}

	/*
	 * Test first and last
	 */
	{
		SChainIteratorOf<SChainTestPlug*> iterator1(&chain1);
		SChainIteratorOf<SChainTestPlug*> iterator2(&chain2);

		Verify( iterator1.GetSize() == TEST_CLASS );
		Verify( iterator2.GetSize() == TEST_CLASS );

		iterator1.First();
		iterator2.First();
		
		testPlug1 = iterator1.GetCurrent();
		testPlug2 = iterator2.GetCurrent();
		Check( testPlug1 );
		Check( testPlug2 );

		Verify( testPlug1 == testPlug2 );
		Verify( testPlug1 == iterator1.GetNth(0) );
		Verify( testPlug1 == iterator2.GetNth(0) );

		iterator1.Last();
		iterator2.Last();
		
		testPlug1 = iterator1.GetCurrent();
		testPlug2 = iterator2.GetCurrent();
		Check( testPlug1 );
		Check( testPlug2 );

		Verify( testPlug1 == testPlug2 );
		Verify( testPlug1 == iterator1.GetNth(TEST_CLASS - 1) );
		Verify( testPlug1 == iterator2.GetNth(TEST_CLASS - 1) );
	}

	/*
	 * Test next and prev
	 */
	{
		SChainIteratorOf<SChainTestPlug*> iterator1(&chain1);
		SChainIteratorOf<SChainTestPlug*> iterator2(&chain2);
	
		Verify( iterator1.GetSize() == TEST_CLASS );
		Verify( iterator2.GetSize() == TEST_CLASS );
		
		i = 0;
		while ((testPlug1 = iterator1.GetCurrent()) != NULL)
		{
			testPlug2 = iterator2.GetCurrent();
			
			Check( testPlug1 );
			Check( testPlug2 );
			Verify( testPlug1 == testPlug2 );

			Verify( testPlug1->value == i );
			Verify( testPlug2->value == i );
			
			iterator1.Next();
			iterator2.Next();

			i++;
		}
		Verify( i == TEST_CLASS );

		iterator1.Last();
		iterator2.Last();

		i = TEST_CLASS - 1;
		while ((testPlug1 = iterator1.GetCurrent()) != NULL)
		{
			testPlug2 = iterator2.GetCurrent();
			
			Check( testPlug1 );
			Check( testPlug2 );
			Verify( testPlug1 == testPlug2 );

			Verify( testPlug1->value == i );
			Verify( testPlug2->value == i );
			
			iterator1.Previous();
			iterator2.Previous();
			
			i--;
		}
		Verify( i == -1 );
	}

	/*
	 * Test read next and read prev
	 */
	{
		SChainIteratorOf<SChainTestPlug*> iterator1(&chain1);
		SChainIteratorOf<SChainTestPlug*> iterator2(&chain2);
	
		Verify( iterator1.GetSize() == TEST_CLASS );
		Verify( iterator2.GetSize() == TEST_CLASS );
		
		i = 0;
		while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
		{
			testPlug2 = iterator2.ReadAndNext();
			
			Check( testPlug1 );
			Check( testPlug2 );
			Verify( testPlug1 == testPlug2 );

			Verify( testPlug1->value == i );
			Verify( testPlug2->value == i );
			
			i++;
		}
		Verify( i == TEST_CLASS );

		iterator1.Last();
		iterator2.Last();

		i = TEST_CLASS - 1;
		while ((testPlug1 = iterator1.ReadAndPrevious()) != NULL)
		{
			testPlug2 = iterator2.ReadAndPrevious();
			
			Check( testPlug1 );
			Check( testPlug2 );
			Verify( testPlug1 == testPlug2 );

			Verify( testPlug1->value == i );
			Verify( testPlug2->value == i );

			i--;
		}
		Verify( i == -1 );
	}
	
	/*
	 * Test nth
	 */
	{
		SChainIteratorOf<SChainTestPlug*> iterator1(&chain1);
		SChainIteratorOf<SChainTestPlug*> iterator2(&chain2);
	
		Verify( iterator1.GetSize() == TEST_CLASS );
		Verify( iterator2.GetSize() == TEST_CLASS );
		
		for (i = 0; i < TEST_CLASS; i++) 
		{
			testPlug1 = iterator1.GetNth(i);
			testPlug2 = iterator2.GetNth(i);
			
			Check( testPlug1 );
			Check( testPlug2 );
			Verify( testPlug1 == testPlug2 );

			Verify( testPlug1->value == i );
			Verify( testPlug2->value == i );
		}
	}

	/*
	 * Test Remove
	 */
	{
		SChainIteratorOf<SChainTestPlug*> iterator1(&chain1);
		SChainIteratorOf<SChainTestPlug*> iterator2(&chain2);
	
		Verify( iterator1.GetSize() == TEST_CLASS );
		Verify( iterator2.GetSize() == TEST_CLASS );

		i = 0;
		while ((testPlug1 = iterator1.GetCurrent()) != NULL)
		{
			Check( testPlug1 );
			Verify( testPlug1->value == i );

			iterator1.Remove();
			
			testPlug2 = iterator2.GetNth(0);
			
			Check( testPlug2 );
			Verify( testPlug2->value == i );
			Verify( testPlug1 == testPlug2 );
			
			Unregister_Object( testPlug2 );
			delete(testPlug2);
			
			i++;
		}
		Verify( i == TEST_CLASS );
		Verify( iterator1.GetSize() == 0 );
		Verify( iterator2.GetSize() == 0 );
	}

	/*
	 * Test random deletion
	 */
	{
		/*
		 * Add plugs to both sockets
		 */
		SChainIteratorOf<SChainTestPlug*> iterator1(chain1);
		SChainIteratorOf<SChainTestPlug*> iterator2(chain2);

		Verify( iterator1.GetSize() == 0 );
		Verify( iterator2.GetSize() == 0 );

		for (i = 0; i < TEST_CLASS; i++)
		{
			testPlug1 = new SChainTestPlug(i);
			Register_Object( testPlug1 );
			chain1.Add(testPlug1);
			chain2.Add(testPlug1);
		}
	}

	{
		/*
		 * Perform random deletion
		 */
		int size, index;
		SChainIteratorOf<SChainTestPlug*> iterator1(chain1);
		SChainIteratorOf<SChainTestPlug*> iterator2(chain2);

		Verify( iterator1.GetSize() == TEST_CLASS );
		Verify( iterator2.GetSize() == TEST_CLASS );

		i = 0;
		while((size = iterator1.GetSize()) != 0)
		{
			index = RandInt(size) - 1;
			testPlug1 = iterator1.GetNth(index);
			Check( testPlug1 );
			iterator1.Remove();

			testPlug2 = iterator2.GetNth(index);
			Check( testPlug2 );
			Verify( testPlug1 == testPlug2 );

			Unregister_Object( testPlug2 );
			delete(testPlug2);

			i++;
		}
		Verify( i == TEST_CLASS );
		Verify( iterator1.GetSize() == 0 );
		Verify( iterator2.GetSize() == 0 );
	}

	/*
	 * Test insertion
	 */
	{
		SChainIteratorOf<SChainTestPlug*> iterator1(chain1);

		Verify(iterator1.GetSize() == 0);

		for (i = 0; i < TEST_CLASS; i++)
		{
			testPlug1 = new SChainTestPlug(i);
			Register_Object(testPlug1);

			if (i == 0)
			{
				chain1.Add(testPlug1);
			}
			else
			{
				iterator1.First();
				iterator1.Insert(testPlug1);
			}
		}

		for (i = 0, j = TEST_CLASS-1; i < TEST_CLASS; i++, j--)
		{
			testPlug1 = iterator1.GetNth(i);
			Check(testPlug1);
			Verify(testPlug1->value == j);
		}

      iterator1.DeletePlugs();
	}
	{
		SChainIteratorOf<SChainTestPlug*> iterator1(chain1);

		Verify(iterator1.GetSize() == 0);

		for (i = 0; i < TEST_CLASS; i++)
		{
			testPlug1 = new SChainTestPlug(i);
			Register_Object(testPlug1);

			if (i == 0)
			{
				chain1.Add(testPlug1);
			}
			else
			{
				iterator1.Last();
				iterator1.Insert(testPlug1);
			}
		}

		for (i = 0; i < TEST_CLASS; i++)
		{
			testPlug1 = iterator1.GetNth(i);
			Check(testPlug1);
			if (i == TEST_CLASS-1)
			{
				Verify(testPlug1->value == 0);
			}
			else
			{
				Verify(testPlug1->value == i+1);
			}
		}

      iterator1.DeletePlugs();
	}

}