//===========================================================================//
// File:	vchain.tst                                                          //
// Project: MUNGA           Brick: Connection Library                        //
// Contents: test routines for VChain class                                  //
//---------------------------------------------------------------------------//
//   Date    Who  Modification                                               //
// --------  ---  ---------------------------------------------------------- //
// 12/02/94  ECH  Initial coding.                                            //
//---------------------------------------------------------------------------//
// Copyright (C) 1994, Virtual World Entertainment, Inc. All Rights reserved //
//                      PROPRIETARY AND CONFIDENTIAL                         //
//===========================================================================//

#include "time.hpp"

class VChainTestPlug:
	public Plug
{
public:
	int value;

	VChainTestPlug(int value);
	~VChainTestPlug();
};

class VChainTestNode:
	public Node
{
public:
	VChainOf<VChainTestPlug*, int> vchain1;
	VChainOf<VChainTestPlug*, int> vchain2;

	VChainTestNode();
	~VChainTestNode();

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

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

VChainTestPlug::VChainTestPlug(int value)
{
	this->value = value;
}

VChainTestPlug::~VChainTestPlug()
{
}

VChainTestNode::VChainTestNode():
	vchain1(this, True), vchain2(this, True)
{
}

VChainTestNode::~VChainTestNode()
{
}

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

Logical
	VChain::ProfileClass()
{
	VChainTestNode testNode;
	Time startTicks = Now();

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

	testNode.RunProfile();

	Test_Message("VChain::ProfileClass elapsed = " << (Now() - startTicks) << endl);
	return True;
}

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

Logical
	VChain::TestClass()
{
	DEBUG_STREAM << "Starting VChain test...\n";

	VChainTestNode	testNode;

	testNode.RunTest();
	return True;
}

void
	VChainTestNode::RunProfile()
{
	VChainTestPlug	*testPlug1, *testPlug2;
	int		 		values[TEST_CLASS];
	int				i, j;
	Time 				startTicks;

	/*
	 * Generate unique values, shuffle them
	 */
	for (i = 0; i < TEST_CLASS; i++) {
		values[i] = i;
	}
	for (i = 0; i < TEST_CLASS; i++) {
		int  tmp;
                
		j = i + RandInt(TEST_CLASS - i) - 1;
		tmp = values[j];
		values[j] = values[i];
		values[i] = tmp;
	}

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

	/*
	 * Create plugs and add to both sockets
	 */
	startTicks = Now();
	for (i = 0; i < TEST_CLASS; i++) 
	{
		testPlug1 = new VChainTestPlug(values[i]);
		Register_Object(testPlug1);
		vchain1.AddValue(testPlug1, values[i]);
		vchain2.AddValue(testPlug1, values[i]);
	}
	Test_Message("VChainTestNode::RunTest Create = " << (Now() - startTicks) << endl);

	/*
	 * Iterate over both sockets
	 */
	startTicks = Now();
	{
		VChainIteratorOf<VChainTestPlug*, int> iterator1(&vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(&vchain2);

		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("VChainTestNode::RunTest Iterate = " << (Now() - startTicks) << endl);

	/*
	 * Find 
	 */
	startTicks = Now();
	{
		VChainIteratorOf<VChainTestPlug*, int> iterator1(&vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(&vchain2);

		for (i = 0; i < TEST_CLASS; i++) 
		{
			testPlug1 = iterator1.Find(i);
			testPlug2 = iterator2.Find(i);

			Check( testPlug1 );
			Check( testPlug2 );

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

			Verify( testPlug1 == testPlug2 );
		}
	}
	Test_Message("VChainTestNode::RunTest Find = " << (Now() - startTicks) << endl);

	/*
	 * Destroy from vchain1, verify with vchain2
	 */
	startTicks = Now();
	{
		VChainIteratorOf<VChainTestPlug*, int> iterator1(&vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(&vchain2);

		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("VChainTestNode::RunTest Destroy = " << (Now() - startTicks) << endl);
}

void
	VChainTestNode::RunTest()
{
	VChainTestPlug	*testPlug1, *testPlug2;
	int	 			values[TEST_CLASS];
	int				i, j;
//	Time 				startTicks;

	/*
	 * Generate unique values, shuffle them
	 */
	for (i = 0; i < TEST_CLASS; i++) {
		values[i] = i;
	}
	for (i = 0; i < TEST_CLASS; i++) {
		int  tmp;
                
		j = i + RandInt(TEST_CLASS - i) - 1;
		tmp = values[j];
		values[j] = values[i];
		values[i] = tmp;
	}

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

	/*
	 * Create plugs and add to both sockets
	 */
	for (i = 0; i < TEST_CLASS; i++) 
	{
		testPlug1 = new VChainTestPlug(values[i]);
		Register_Object( testPlug1 );
		vchain1.AddValue(testPlug1, values[i]);
		vchain2.AddValue(testPlug1, values[i]);
	}

	/*
	 * Find
	 */
	{
		for (i = 0; i < TEST_CLASS; i++) 
		{
			testPlug1 = vchain1.Find(i);
			testPlug2 = vchain2.Find(i);
			
			Check( testPlug1 );
			Check( testPlug2 );

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

			Verify( testPlug1 == testPlug2 );
		}
	}

	/*
	 * Test first and last
	 */
	{
		VChainIteratorOf<VChainTestPlug*, int> iterator1(&vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(&vchain2);

		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
	 */
	{
		VChainIteratorOf<VChainTestPlug*, int> iterator1(&vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(&vchain2);
	
		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
	 */
	{
		VChainIteratorOf<VChainTestPlug*, int> iterator1(&vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(&vchain2);
	
		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
	 */
	{
		VChainIteratorOf<VChainTestPlug*, int> iterator1(&vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(&vchain2);
	
		Verify( iterator1.GetSize() == TEST_CLASS );
		Verify( iterator2.GetSize() == TEST_CLASS );
		
		for (
			i = 0;
			i < TEST_CLASS;
			i++
		)
		{
			testPlug1 = iterator1.GetNth((int)i);
			testPlug2 = iterator2.GetNth((int)i);
			
			Check( testPlug1 );
			Check( testPlug2 );
			Verify( testPlug1 == testPlug2 );

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

	/*
	 * Test Remove
	 */
	{
		VChainIteratorOf<VChainTestPlug*, int> iterator1(&vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(&vchain2);

		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
		 */
		VChainIteratorOf<VChainTestPlug*, int> iterator1(vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(vchain2);

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

		for (i = 0; i < TEST_CLASS; i++)
		{
			testPlug1 = new VChainTestPlug(values[i]);
			Register_Object( testPlug1 );
			vchain1.AddValue(testPlug1, values[i]);
			vchain2.AddValue(testPlug1, values[i]);
		}
	}

	{
		/*
		 * Perform random deletion
		 */
		int size, index;
		VChainIteratorOf<VChainTestPlug*, int> iterator1(vchain1);
		VChainIteratorOf<VChainTestPlug*, int> iterator2(vchain2);

		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 );
	}
}