• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

TestThread.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// 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 "../include/TestThread.h"
#include "../../include/PCMFileSystemManager.h"

namespace ParCompMarkTest
{

  void TestThread::setUp()
  {
        std::string currentLogFile = "logs/TestThread.log";

        if(Logger::getInstance() && Logger::getInstance()->getLogFileName() != currentLogFile)
         Logger::destroyInstance();

        if(!FileSystemManager::getInstance())
        {
         FileSystemManager::createInstance();
         FileSystemManager::getInstance()->setAppDirectory("./");
         FileSystemManager::getInstance()->initialize();
        }

        if(!Logger::getInstance())
        {
         Logger::createInstance();
         Logger::getInstance()->setLogFileName(currentLogFile);
         Logger::getInstance()->initialize();
        }
  }

 /*----------------------------------------------------------------------*/

  void TestThread::tearDown()
  {
  }

 /*----------------------------------------------------------------------*/

  //
  // Constructor & destructor tests
  //

  void TestThread::test_constructor_cstd__string()
  {

        /*
         * You have to verify the following:
         * 
         * Thread constructor.
         */

        Thread *t = 0;

        CPPUNIT_ASSERT_NO_THROW(t = new Thread("test_constructor_std__string"));
        delete t;
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_destructor()
  {
        // Tested upper

        Thread *t;

        t = new Thread("test_destructor");
        t->initThread(1, 0, true, true);
        sleep(2);
        CPPUNIT_ASSERT_NO_THROW(delete t);

        t = new Thread("test_destructor");
        t->initThread(10, 0, true, true);
        CPPUNIT_ASSERT_NO_THROW(delete t);

        t = new Thread("test_destructor");
        t->initThread(10, 0, true, false);
        CPPUNIT_ASSERT_NO_THROW(delete t);

  }

 /*----------------------------------------------------------------------*/

  //
  // Class method tests
  //

  void TestThread::test_yield()
  {

        /*
         * You have to verify the following:
         * 
         * Yield current thread. 
         */

        CPPUNIT_ASSERT_NO_THROW(Thread::yield());
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_getUSTime()
  {

        /*
         * You have to verify the following:
         * 
         * Get system time in us.
         */

        // No exception and returns positive value
        ParCompMark::Real time1;
        CPPUNIT_ASSERT_NO_THROW(time1 = Thread::getUSTime());
        CPPUNIT_ASSERT(time1 > 0.0);

        usleep(10 * 1000);

        // Monotonic
        ParCompMark::Real time2;
        CPPUNIT_ASSERT_NO_THROW(time2 = Thread::getUSTime());
        CPPUNIT_ASSERT(time2 >= time1);
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_entryPoint_void_p()
  {

        /*
         * You have to verify the following:
         * 
         * Static entry point for the thread.
         */

        // This method can not be called
  }

 /*----------------------------------------------------------------------*/

  //
  // Method tests
  //

  void TestThread::test_initThread_cu32_cu32_cbool_cbool()
  {

        /*
         * You have to verify the following:
         * 
         * Start thread.
         */

        Thread *t = new Thread("test_initThread_u32_u32");

        CPPUNIT_ASSERT_NO_THROW(t->initThread());
        CPPUNIT_ASSERT_THROW(t->initThread(0, 100, true, true), ParCompMark::Exception);
        CPPUNIT_ASSERT_NO_THROW(t->initThread(10, 100, true, true));
        CPPUNIT_ASSERT_NO_THROW(t->initThread(10, 100, true, false));
        CPPUNIT_ASSERT_NO_THROW(t->initThread(10, 100, false, false));
        CPPUNIT_ASSERT_THROW(t->initThread(10, 100, false, true), ParCompMark::Exception);
        CPPUNIT_ASSERT(t->mIterationNumber == 10);
        CPPUNIT_ASSERT(t->mExpectedFPS == 100);
        delete t;
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_threadInitialize()
  {

        /*
         * You have to verify the following:
         * 
         * Some init step as thread.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_threadFinalize()
  {

        /*
         * You have to verify the following:
         * 
         * Some finitiate step as thread.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_startThread()
  {

        /*
         * You have to verify the following:
         * 
         * Start thread.
         */

        // Killing thread with destructor
        Thread *t = new Thread("test_startThread 1");

        t->initThread(100, 0);
        CPPUNIT_ASSERT_NO_THROW(t->startThread());
        CPPUNIT_ASSERT_NO_THROW(delete t);

        // Let the thread run
        t = new Thread("test_startThread 2");
        t->initThread(1, 0);
        CPPUNIT_ASSERT_NO_THROW(t->startThread());
        usleep(500 * 1000);
        CPPUNIT_ASSERT_NO_THROW(delete t);

        // wait for thread 
        t = new Thread("test_startThread 3");
        t->initThread(10, 0, true, true);
        t->startThread();
        CPPUNIT_ASSERT_NO_THROW(delete t);

        t = new Thread("test_startThread 3");
        t->initThread(10, 0, true, false);
        t->startThread();
        CPPUNIT_ASSERT_NO_THROW(delete t);

  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_joinThread()
  {

        /*
         * You have to verify the following:
         * 
         * Join thread. Wait for its ending.
         * !!! You can join if the thread will stop (mIterationNumber != 0 or 
         * mStopRequested = true).
         * 
         */
        Thread *t;

        t = new Thread("test_joinThread");
        t->initThread(10, 0, true, false);
        t->startThread();
        CPPUNIT_ASSERT_NO_THROW(delete t);

        t = new Thread("test_joinThread");
        t->initThread(10, 0, true, false);
        t->startThread();
        t->joinThread();
        CPPUNIT_ASSERT_NO_THROW(delete t);

        //join but thread not run
        t = new Thread("test_joinThread");
        t->initThread(1, 0, true, false);
        t->startThread();
        sleep(2);
        CPPUNIT_ASSERT_NO_THROW(t->joinThread());
        CPPUNIT_ASSERT_NO_THROW(delete t);

        t = new Thread("test_joinThread");
        t->initThread(0, 0, true, false);
        t->startThread();
        t->stopThread();
        CPPUNIT_ASSERT_NO_THROW(t->joinThread());
        CPPUNIT_ASSERT_NO_THROW(delete t);

        t = new Thread("test_joinThread");
        t->initThread(0, 0, true, false);
        t->startThread();
        t->stopThread();
        sleep(1);
        CPPUNIT_ASSERT_NO_THROW(t->joinThread());
        CPPUNIT_ASSERT_NO_THROW(delete t);

  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_shutDownThread()
  {

        /*
         * You have to verify the following:
         * 
         * Immediately stop the thread.
         */

        // Tested in test_startThread with destructor
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_stopThread()
  {

        /*
         * You have to verify the following:
         * 
         * Request thread shut down.
         */

        // Killing thread with destructor
        Thread *t = new Thread("test_stopThread");

        t->initThread(1000, 0);
        CPPUNIT_ASSERT_NO_THROW(t->startThread());
        usleep(10 * 1000);
        CPPUNIT_ASSERT_NO_THROW(t->stopThread());
        usleep(500 * 1000);
        CPPUNIT_ASSERT_NO_THROW(delete t);
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_go()
  {

        /*
         * You have to verify the following:
         * 
         * Go forward from wait.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_thread()
  {

        /*
         * You have to verify the following:
         * 
         * This is the thread method containing one or more (or inifinite) iterations.
         */

        // Tested above
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_iteration()
  {

        /*
         * You have to verify the following:
         * 
         * One iteration step. This method calls the overridable task method.
         */

        // Tested above
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_task()
  {

        /*
         * You have to verify the following:
         * 
         * It is the task of the thread. It have to be overiden.
         * This method should be abstact. It is not, because of unit testing of this class.
         * 
         */

        // No need to test
  }

 /*----------------------------------------------------------------------*/

  void TestThread::test_wait()
  {

        /*
         * You have to verify the following:
         * 
         * Wait for something.
         */

        CPPUNIT_FAIL("Implement this test!");
  }

 /*----------------------------------------------------------------------*/

  // To register the suite we add:
  CPPUNIT_TEST_SUITE_REGISTRATION(TestThread);
}

© Copyright - 2006 (IT)² ParCompMark Dev. Team