---

test-thread.cc

/*
*  Name:      test-thread.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Test for threads
*  Date:      $Date: 2003/04/14 00:18:36 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#include <iostream>
#include <mpcl/system/all.hh>
#include <mpcl/test.h>
#include <queue>


using mpcl::system::TCondition;
using mpcl::system::TMutex;
using mpcl::system::TThread;
using mpcl::system::tSystem;
using std::queue;


//
//  L O C A L   V A R I A B L E S
//

static int            _iSharedCounter;
static TMutex         _tMutex;
static queue<int>     _tQueue;
static TCondition     _tNotEmptyCondition (_tMutex);
static TCondition     _tNotFullCondition  (_tMutex);
static bool           _gError         = false;
static const size_t   _kzMaxQueueSize = 16;


class TExampleThread : public TThread
{

  protected:
  
    void body (void);

};  // class TExampleThread


class TProducerThread : public TThread
{

  protected:
  
    void body (void);
    void put (const int kiSOURCE_DATA) const;

};  // class TProducerThread


class TConsumerThread : public TThread
{

  protected:
  
    void body (void);
    const int get (void) const;

};  // class TExampleThread


class TThrowingThread : public TThread
{

  public:

    int   iExitCode;


  protected:
  
    void body (void)
    {
      try
      {
        iExitCode = 1;
        throw 0;
      }
      catch (int)
      {
        iExitCode = 0;
      }
    }

};  // class TExampleThread


void TExampleThread::body (void)
{

  for (register size_t J = 0; ( J < 50000 ) ;++J)
  {
    _tMutex.lock();
    ++_iSharedCounter;
    _tMutex.unlock();
  }

}  // TExampleThread::body()


void TProducerThread::body (void)
{

  for (register int J = 0; ( J < 50000 ) ;++J)
  {
    put (J);
  }

}  // TProducerThread::body()


void TProducerThread::put (const int kiSOURCE_DATA) const
{
  
  _tMutex.lock();
  if ( _tQueue.size() == _kzMaxQueueSize )
  {
    _tNotFullCondition.wait();
  }
  _tQueue.push (kiSOURCE_DATA);
  _tNotEmptyCondition.signal();
  _tMutex.unlock();

}  // TProducerThread::put()


void TConsumerThread::body (void)
{

  TEST_INIT ("tests for consumer");
  for (register int J = 0; ( J < 50000 ) ;++J)
  {
    if ( J != get() )
    {
      _tMutex.lock();
      _gError = true;
      _tMutex.unlock();
    }
  }
  TEST_END;

}  // TConsumerThread::body()


const int TConsumerThread::get (void) const
{

  int   iData;
  
  _tMutex.lock();
  if ( _tQueue.empty() )
  {
    _tNotEmptyCondition.wait();
  }
  iData = _tQueue.front();
  _tQueue.pop();
  _tNotFullCondition.signal();
  _tMutex.unlock();
  return iData;

}  // TConsumerThread::get()


int main (void)
{

  TExampleThread    tExample1;
  TExampleThread    tExample2;
  TProducerThread   tProducerThread;
  TConsumerThread   tConsumerThread;

  TEST_INIT ("tests for class 'TThread'");

  tExample1.start();
  tExample2.start();
  tSystem.sleep (5);
  tSystem.yield();
  tExample1.join();
  tExample2.join();
  TEST_NUMBERS (100000, _iSharedCounter);

  tProducerThread.start();
  tConsumerThread.start();
  tProducerThread.join();
  tConsumerThread.join();
  TEST_NUMBERS (false, _gError);

  //
  //  Tests that threads are catched in the right place.
  //
  {
    TProducerThread   tProducerThreadA;
    TConsumerThread   tConsumerThreadA;

    try
    {
      
      tProducerThreadA.start();
      tConsumerThreadA.start();
      throw 1;
      TEST_FAIL;
    }
    catch (int)
    {
      tProducerThreadA.join();
      tConsumerThreadA.join();
      TEST_PASS;
    }
  }

  //
  //  Tests that exceptions thrown in threads are catched in the right place.
  //
  try
  {
    TThrowingThread   tThrowingThread;

    tThrowingThread.start();
    tThrowingThread.join();
    TEST_NUMBERS (0, tThrowingThread.iExitCode);
    TEST_PASS
  }
  catch (int)
  {
    TEST_FAIL
  }
  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // main()

---