//------------------------------------------------------------------------------
//	IsMessageWaitingTest.cpp
//
//------------------------------------------------------------------------------

// Standard Includes -----------------------------------------------------------
#include <iostream>
#include <posix/string.h>

// System Includes -------------------------------------------------------------
#include <Looper.h>
#include <Message.h>
#include <MessageQueue.h>

// Project Includes ------------------------------------------------------------

// Local Includes --------------------------------------------------------------
#include "IsMessageWaitingTest.h"

// Local Defines ---------------------------------------------------------------

// Globals ---------------------------------------------------------------------
port_id _get_looper_port_(const BLooper* looper);

//------------------------------------------------------------------------------
/**
	IsMessageWaiting()
	@case		looper is unlocked and queue is empty
	@results	IsMessageWaiting() returns false
 */
void TIsMessageWaitingTest::IsMessageWaiting1()
{
	DEBUGGER_ESCAPE;

	BLooper Looper;
	Looper.Unlock();
	CPPUNIT_ASSERT(!Looper.IsMessageWaiting());
}
//------------------------------------------------------------------------------
/**
	IsMessageWaiting()
	@case		looper is unlocked and queue is filled
	@results	IsMessageWaiting() returns false
 */
void TIsMessageWaitingTest::IsMessageWaiting2()
{
	DEBUGGER_ESCAPE;

	BLooper Looper;
	Looper.Unlock();
	Looper.PostMessage('1234');
	CPPUNIT_ASSERT(!Looper.IsMessageWaiting());
}
//------------------------------------------------------------------------------
/**
	IsMessageWaiting()
	@case		looper is locked and queue is empty
	@results	IsMessageWaiting() returns false
	@note		R5 will return true in this test.  The extra testing below
				indicates that the R5 version probably returns != 0 from
				port_buffer_size_etc(), resulting in an incorrect true in cases
				where the operation would block.
 */
void TIsMessageWaitingTest::IsMessageWaiting3()
{
	BLooper Looper;
	Looper.Lock();
#ifndef TEST_R5
	CPPUNIT_ASSERT(!Looper.IsMessageWaiting());
#else
#if 0
	// Testing to figure out why we get false positives from the R5
	// implementation of BLooper::IsMessageWaiting().  Basically, it tests for
	// port_buffer_size_etc() != 0 -- which means that return values like
	// B_WOULD_BLOCK make the function return true, which is just not correct.
	CPPUNIT_ASSERT(Looper.IsLocked());
	CPPUNIT_ASSERT(Looper.MessageQueue()->IsEmpty());

	int32 count;
	do
	{
		count = port_buffer_size_etc(_get_looper_port_(&Looper), B_TIMEOUT, 0);
	} while (count == B_INTERRUPTED);

	CPPUNIT_ASSERT(count < 0);
	cout << endl << "port_buffer_size_etc: " << strerror(count) << endl;
#endif
	CPPUNIT_ASSERT(Looper.IsMessageWaiting());
#endif
}
//------------------------------------------------------------------------------
/**
	IsMessageWaiting()
	@case		looper is locked and queue is filled
	@results	IsMessageWaiting() returns true.
 */
void TIsMessageWaitingTest::IsMessageWaiting4()
{
	BLooper Looper;
	Looper.Lock();
	Looper.PostMessage('1234');
	CPPUNIT_ASSERT(Looper.IsMessageWaiting());
}
//------------------------------------------------------------------------------
/**
	IsMessageWaiting()
	@case		looper is locked, message is posted, queue is empty
	@results	IsMessageWaiting() returns true.
	@note		The first assert always worked under R5 but only sometimes for
				Haiku.  Answer: the Haiku implementation of BLooper was attempting
				to lock itself prior to fetching the message from the queue.  I
				moved the lock attempt after the fetch and it worked the same.
				I realized that if the system was loaded heavily enough, the
				assert might still fail simply because the looper would not have
				had enough time to get to the fetch (thereby emptying the queue),
				so the assert is no longer used.  If we do manage to call
				IsMessageWaiting() before the fetch happens (which does happen
				every once in a while), we still get a true result because the
				port buffer is checked.  Later: it's finally dawned on me that
				if the system is loaded *lightly* enough, the message will not
				only get fetched, but popped off the queue as well.  Since R5
				returns the bogus true, the second assert works even when the
				message has been de-queued.  Haiku, of course, will (correctly)
				fail the assert in that situation.  Unfortunately, that renders
				this test completely unreliable.  It is pulled until a fully
				reliable test can be devised.
 */
void TIsMessageWaitingTest::IsMessageWaiting5()
{
	BLooper* Looper = new BLooper(__PRETTY_FUNCTION__);
	Looper->Run();

	// Prevent a port read
	Looper->Lock();
	Looper->PostMessage('1234');
//	CPPUNIT_ASSERT(Looper->MessageQueue()->IsEmpty());
	CPPUNIT_ASSERT(Looper->IsMessageWaiting());

#if 0
	ssize_t count;
	do
	{
		count = port_buffer_size_etc(_get_looper_port_(Looper), B_TIMEOUT, 0);
	} while (count == B_INTERRUPTED);

	cout << endl << "port_buffer_size_etc: ";
	if (count < 0)
	{
		cout << strerror(count);
	}
	else
	{
		cout << count << endl;
		char* buffer = new char[count];
		int32 code;
		read_port(_get_looper_port_(Looper), &code, (void*)buffer, count);
		cout << "code: " << code << endl;
		cout << "buffer: ";
		for (int32 i = 0; i < count; ++i)
		{
			cout << buffer[i];
		}
		cout << endl;
	}
	cout << endl;
#endif
}
//------------------------------------------------------------------------------
Test* TIsMessageWaitingTest::Suite()
{
	TestSuite* suite = new TestSuite("BLooper::IsMessageWaiting()");

	ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting1);
	ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting2);
	ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting3);
	ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting4);

	// See note for test
//	ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting5);

	return suite;
}
//------------------------------------------------------------------------------

/*
 * $Log $
 *
 * $Id  $
 *
 */