//===========================================================================//
// File:	event.tst                                                           //
// Project: MUNGA           Brick: Dynamic Dispatch                          //
// Contents: Test stuff for Event class                                      //
//---------------------------------------------------------------------------//
//   Date    Who  Modification                                               //
// --------  ---  ---------------------------------------------------------- //
// 11/02/94  JMA  Initial coding.                                            //
//---------------------------------------------------------------------------//
// Copyright (C) 1994, Virtual World Entertainment, Inc. All Rights reserved //
//                      PROPRIETARY AND CONFIDENTIAL                         //
//===========================================================================//

#include "testclas.hpp"

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

	//
	// Construct Queues
	//
	EventQueue
		*p = EventQueue::Make(5),
		*q = new EventQueue;
	Register_Object(q);

	Test(p->priorityLevels == 5);
	Test(q->priorityLevels == 1);

	//
	// Test how a single priority queue works
	//
	Receiver::Message
		m(Alpha::message0ID, sizeof(Receiver::Message)),
		n(Alpha::message1ID, sizeof(Receiver::Message));
	Alpha
		a,b;
	Event
		*event;

	q->Post(0, &a, &m);
	Test(a.x == -1);

	event = q->PeekAtNextEvent();
	Test(event);
	Test(event->targetReceiver.GetCurrent() == &a);
	Test(event->messageToSend);
	Test(a.x == -1);
	PlugIteratorOf<Event*>
		i(&a);
	Test(i.GetCurrent() == event);

	event->Process();
	Test(a.x == 0);
	Test(!q->PeekAtNextEvent());

	//
	// Test multiple events
	//
	a.x = -1;
	q->Post(0, &a, &m);
	event = q->PeekAtNextEvent();
	q->Post(0, &a, &n);
	Test(q->PeekAtNextEvent() == event);
	Test(q->ProcessOneEvent());
	Test(a.x == 0);
	Test(q->ProcessOneEvent());
	Test(a.x == 1);
	Test(!q->ProcessOneEvent());

	//
	// Test timed messages
	//
	a.x = -1;
	Time t = Now();
	t += 0.5f;
	q->Post(0, &a, &m, t);
	Time t2 = t;
	t2 += 0.1f;
	while (!q->ProcessOneEvent())
	{
		Test(Now() < t2);
	}
	Scalar f = Now() - t;
	Test(Abs(f) < 0.06f);
	Test(a.x == 0);
	Test(!q->PeekAtNextEvent());

	//
	// Test multi-priority Queues
	//
	a.x = -1;
	p->Post(2, &a, &m);
	event = p->PeekAtNextEvent();
	Test(event);
	p->Post(3, &a, &n);
	Test(event != p->PeekAtNextEvent());

	p->ProcessOneEvent(3);
	Test(a.x == 1);
	event = p->PeekAtNextEvent(3);
	Test(!event);
	event = p->PeekAtNextEvent();
	Test(event);
	Test(event->targetReceiver.GetCurrent() == &a);
	p->ProcessOneEvent();
	Test(a.x == 0);
	Test(!p->PeekAtNextEvent());

	//
	// Test Reposting
	//
	a.x = -1;
	q->Post(0, &a, &m);
	event = q->PeekAtNextEvent();
	event->Repost(p,2);
	Test(!q->PeekAtNextEvent());
	Test(!p->PeekAtNextEvent(3));
	Test(p->PeekAtNextEvent(2));
	p->ProcessOneEvent();
	Test(!p->PeekAtNextEvent());
	Test(a.x == 0);

	//
	// Test event deference
	//
	a.x = -1;
	q->Post(0, &a, &m);
	event = q->PeekAtNextEvent();
	event->Defer();
	Test(!q->PeekAtNextEvent());
	a.ProcessDeferredQueue();
	Test(a.x == 0);

	//
	// Test destroying a receiver
	//
	Alpha *a2 = new Alpha;
	Register_Object(a2);
	p->Post(1, a2, &n);
	Test(p->PeekAtNextEvent());
	Unregister_Object(a2);
	delete a2;
	Test(!p->PeekAtNextEvent());

	//
	// Now test the flushing functions
	//
	q->Post(0, &a, &n);
	q->Post(0, &a, &m);
	a.FlushMatchingEvents(Alpha::message1ID);
	Test(q->PeekAtNextEvent()->messageToSend->messageID == Alpha::message0ID);
	a.FlushEvents();
	Test(!q->PeekAtNextEvent());

	q->Post(0, &a, &n);
	q->Post(0, &b, &m);
	q->FlushMatchingEvents(Alpha::message1ID);
	Test(q->PeekAtNextEvent()->messageToSend->messageID == Alpha::message0ID);
	q->FlushAllEvents();
	Test(!q->PeekAtNextEvent());

	//
	// Get rid of the queues
	//
	Unregister_Object(p);
	delete[] p;

	Unregister_Object(q);
	delete q;
	return True;
}