wxWidgets/tests/thread/queue.cpp
2007-11-01 01:35:20 +00:00

216 lines
6.5 KiB
C++

///////////////////////////////////////////////////////////////////////////////
// Name: tests/thread/queue.cpp
// Purpose: Unit test for wxMessageQueue
// Author: Evgeniy Tarassov
// Created: 31/10/2007
// RCS-ID: $Id:$
// Copyright: (c) 2007 Evgeniy Tarassov
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "testprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/dynarray.h"
#include "wx/thread.h"
#endif // WX_PRECOMP
#include "wx/msgqueue.h"
// ----------------------------------------------------------------------------
// test class
// ----------------------------------------------------------------------------
class QueueTestCase : public CppUnit::TestCase
{
public:
QueueTestCase() { }
private:
typedef wxMessageQueue<int> Queue;
enum WaitTestType
{
WaitWithTimeout = 0,
WaitInfinitlyLong
};
// This class represents a thread that waits (following WaitTestType type)
// for exactly maxMsgCount messages from its message queue and if another
// MyThread is specified, then every message received is posted
// to that next thread.
class MyThread : public wxThread
{
public:
MyThread(WaitTestType type, MyThread *next, int maxMsgCount)
: wxThread(wxTHREAD_JOINABLE),
m_type(type), m_nextThread(next), m_maxMsgCount(maxMsgCount)
{}
// thread execution starts here
virtual void *Entry();
// Thread message queue
Queue& GetQueue()
{
return m_queue;
}
private:
WaitTestType m_type;
MyThread* m_nextThread;
int m_maxMsgCount;
Queue m_queue;
};
WX_DEFINE_ARRAY_PTR(MyThread *, ArrayThread);
CPPUNIT_TEST_SUITE( QueueTestCase );
CPPUNIT_TEST( TestReceive );
CPPUNIT_TEST( TestReceiveTimeout );
CPPUNIT_TEST_SUITE_END();
void TestReceive();
void TestReceiveTimeout();
DECLARE_NO_COPY_CLASS(QueueTestCase)
};
// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( QueueTestCase );
// also include in it's own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( QueueTestCase, "QueueTestCase" );
// this function creates the given number of threads and posts msgCount
// messages to the last created thread which, in turn, posts all the messages
// it receives to the previously created thread which does the same and so on
// in cascade -- at the end, each thread will have received all msgCount
// messages directly or indirectly
void QueueTestCase::TestReceive()
{
const int msgCount = 100;
const int threadCount = 10;
ArrayThread threads;
int i;
for ( i = 0; i < threadCount; ++i )
{
MyThread *previousThread = i == 0 ? NULL : threads[i-1];
MyThread *thread =
new MyThread(WaitInfinitlyLong, previousThread, msgCount);
CPPUNIT_ASSERT_EQUAL ( thread->Create(), wxTHREAD_NO_ERROR );
threads.Add(thread);
}
for ( i = 0; i < threadCount; ++i )
{
threads[i]->Run();
}
MyThread* lastThread = threads[threadCount - 1];
for ( i = 0; i < msgCount; ++i )
{
lastThread->GetQueue().Post(i);
}
for ( i = 0; i < threadCount; ++i )
{
// each thread should return the number of messages received.
// if it returns a negative, then it detected some problem.
wxThread::ExitCode code = threads[i]->Wait();
CPPUNIT_ASSERT_EQUAL( code, (wxThread::ExitCode)wxMSGQUEUE_NO_ERROR );
}
}
// this function creates two threads, each one waiting (with a timeout) for
// exactly two messages.
// Exactly to messages are posted into first thread queue, but
// only one message is posted to the second thread queue.
// Therefore first thread should return with wxMSGQUEUE_NO_ERROR, but the second
// should return wxMSGQUEUUE_TIMEOUT.
void QueueTestCase::TestReceiveTimeout()
{
MyThread* thread1 = new MyThread(WaitWithTimeout, NULL, 2);
MyThread* thread2 = new MyThread(WaitWithTimeout, NULL, 2);
CPPUNIT_ASSERT_EQUAL ( thread1->Create(), wxTHREAD_NO_ERROR );
CPPUNIT_ASSERT_EQUAL ( thread2->Create(), wxTHREAD_NO_ERROR );
thread1->Run();
thread2->Run();
// Post two messages to the first thread
CPPUNIT_ASSERT_EQUAL( thread1->GetQueue().Post(0), wxMSGQUEUE_NO_ERROR );
CPPUNIT_ASSERT_EQUAL( thread1->GetQueue().Post(1), wxMSGQUEUE_NO_ERROR );
// ...but only one message to the second
CPPUNIT_ASSERT_EQUAL( thread2->GetQueue().Post(0), wxMSGQUEUE_NO_ERROR );
wxThread::ExitCode code1 = thread1->Wait();
wxThread::ExitCode code2 = thread2->Wait();
CPPUNIT_ASSERT_EQUAL( code1, (wxThread::ExitCode)wxMSGQUEUE_NO_ERROR );
CPPUNIT_ASSERT_EQUAL( code2, (wxThread::ExitCode)wxMSGQUEUE_TIMEOUT );
}
// every thread tries to read exactly m_maxMsgCount messages from its queue
// following the waiting strategy specified in m_type. If it succeeds then it
// returns 0. Otherwise it returns the error code - one of wxMessageQueueError.
void *QueueTestCase::MyThread::Entry()
{
int messagesReceived = 0;
while ( messagesReceived < m_maxMsgCount )
{
wxMessageQueueError result;
int msg;
if ( m_type == WaitWithTimeout )
result = m_queue.ReceiveTimeout(1000, msg);
else
result = m_queue.Receive(msg);
if ( result == wxMSGQUEUE_MISC_ERROR )
return (wxThread::ExitCode)wxMSGQUEUE_MISC_ERROR;
if ( result == wxMSGQUEUE_NO_ERROR )
{
if ( m_nextThread != NULL )
{
wxMessageQueueError res = m_nextThread->GetQueue().Post(msg);
if ( res == wxMSGQUEUE_MISC_ERROR )
return (wxThread::ExitCode)wxMSGQUEUE_MISC_ERROR;
CPPUNIT_ASSERT_EQUAL( wxMSGQUEUE_NO_ERROR, res );
}
++messagesReceived;
continue;
}
CPPUNIT_ASSERT_EQUAL ( result, wxMSGQUEUE_TIMEOUT );
break;
}
if ( messagesReceived != m_maxMsgCount )
{
CPPUNIT_ASSERT_EQUAL( m_type, WaitWithTimeout );
return (wxThread::ExitCode)wxMSGQUEUE_TIMEOUT;
}
return (wxThread::ExitCode)wxMSGQUEUE_NO_ERROR;
}