ThreadSchedulerTest.h

#ifndef MANTID_KERNEL_THREADSCHEDULERTEST_H_
#define MANTID_KERNEL_THREADSCHEDULERTEST_H_

#include <cxxtest/TestSuite.h>
#include <MantidKernel/Timer.h>
#include <MantidKernel/System.h>
#include <iostream>
#include <iomanip>

#include <MantidKernel/ThreadScheduler.h>
#include <MantidKernel/Task.h>

using namespace Mantid::Kernel;

int ThreadSchedulerTest_numDestructed;

class ThreadSchedulerTest : public CxxTest::TestSuite
{
public:

  class TaskDoNothing : public Task
  {
  public:
    TaskDoNothing() : Task() {}
    TaskDoNothing(double cost) : Task() {m_cost = cost;}

    ~TaskDoNothing()
    {
      // To keep track of proper deleting of Task pointers
      ThreadSchedulerTest_numDestructed++;
    }

    void run() {}
  };

  void do_basic_test(ThreadScheduler * sc)
  {
    ThreadSchedulerTest_numDestructed = 0;
    TS_ASSERT( !sc->getAborted());
    TS_ASSERT_EQUALS( std::string(sc->getAbortException().what()), "");
    TS_ASSERT_EQUALS( sc->size(), 0 );

    sc->push( new TaskDoNothing() );
    TS_ASSERT_EQUALS( sc->size(), 1 );
    sc->push( new TaskDoNothing() );
    TS_ASSERT_EQUALS( sc->size(), 2 );

    // Clear empties the queue
    ThreadSchedulerTest_numDestructed = 0;
    sc->clear();
    TS_ASSERT_EQUALS( sc->size(), 0 );
    // And deletes the tasks properly
    TS_ASSERT_EQUALS(ThreadSchedulerTest_numDestructed, 2);

    delete sc;
  }


  void test_basic_ThreadSchedulerFIFO()
  {
    do_basic_test(new ThreadSchedulerFIFO());
  }

  void test_basic_ThreadSchedulerLIFO()
  {
    do_basic_test(new ThreadSchedulerLIFO());
  }

  void test_basic_ThreadSchedulerLargestCost()
  {
    do_basic_test(new ThreadSchedulerLargestCost());
  }


  //==================================================================================================

  void do_test(ThreadScheduler * sc, double * costs, size_t * poppedIndices)
  {
    ThreadSchedulerTest_numDestructed = 0;

    // Create and push them in order
    TaskDoNothing * tasks[4];
    for (size_t i=0; i<4; i++)
    {
      tasks[i] = new TaskDoNothing(costs[i]);
      sc->push(tasks[i]);
    }

    // Pop them, and check that we get them in the order we expected
    for (size_t i=0; i<4; i++)
    {
      TaskDoNothing * task = dynamic_cast<TaskDoNothing *>(sc->pop(0));
      size_t index=0;
      for (index=0; index<4; index++)
        if (task == tasks[index]) break;
      TS_ASSERT_EQUALS( index, poppedIndices[i]);
    }

    // Nothing is left
    TS_ASSERT_EQUALS(sc->size(), 0);

    // And ThreadScheduler does not delete popped tasks in this way
    TS_ASSERT_EQUALS(ThreadSchedulerTest_numDestructed, 0);
    for (size_t i=0; i<4; i++)
    {
      delete tasks[i];
    }
  }

  void test_ThreadSchedulerFIFO()
  {
    ThreadScheduler * sc = new ThreadSchedulerFIFO();
    double costs[4] = {0,1,2,3};
    size_t poppedIndices[4] = {0,1,2,3};
    do_test(sc, costs, poppedIndices);
    delete sc;
  }

  void test_ThreadSchedulerLIFO()
  {
    ThreadScheduler * sc = new ThreadSchedulerLIFO();
    double costs[4] = {0,1,2,3};
    size_t poppedIndices[4] = {3,2,1,0};
    do_test(sc, costs, poppedIndices);
    delete sc;
  }

  void test_ThreadSchedulerLargestCost()
  {
    ThreadScheduler * sc = new ThreadSchedulerLargestCost();
    double costs[4] = {1,5,2,-3};
    size_t poppedIndices[4] = {1,2,0,3};
    do_test(sc, costs, poppedIndices);
    delete sc;
  }


};


#endif /* MANTID_KERNEL_THREADSCHEDULERTEST_H_ */