source: ThirdParty/JobMarket/src/unittests/FragmentQueueUnitTest.cpp@ c79d7a

/*
 * Project: JobMarket
 * Description: asynchronous Server/Controller/Client-approach to parallel computing, based on boost::asio
 * Copyright (C)  2011 Frederik Heber. All rights reserved.
 * 
 */

/*
 * FragmentQueueUnitTest.cpp
 *
 *  Created on: Oct 23, 2011
 *      Author: heber
 */

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <cppunit/CompilerOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>

#include "FragmentQueueUnitTest.hpp"

#include <limits>
#include <vector>

#include "CodePatterns/Assert.hpp"
#include "JobMarket/FragmentQueue.hpp"

#include "CodePatterns/Observer/Channels.hpp"

#ifdef HAVE_TESTRUNNER
#include "JobMarket/UnitTestMain.hpp"
#endif /*HAVE_TESTRUNNER*/

/********************************************** Test classes **************************************/

#include "stubs/FragmentJobStub.hpp"
#include "stubs/ObserverStub.hpp"

// Registers the fixture into the 'registry'
CPPUNIT_TEST_SUITE_REGISTRATION( FragmentQueueTest );


void FragmentQueueTest::setUp()
{
  // Throw assertions
  ASSERT_DO(Assert::Throw);

  queue = new FragmentQueue();
  addobserver = new NotificationObserver(queue->getChannel(FragmentQueue::JobAdded));

  // and sign on
  queue->signOn(addobserver, FragmentQueue::JobAdded);
}


void FragmentQueueTest::tearDown()
{
  queue->signOff(addobserver, FragmentQueue::JobAdded);

  delete queue;
  delete addobserver;
}

/** UnitTest for working JobQueue
 */
void FragmentQueueTest::JobTest()
{
  FragmentJob::ptr testJob(new FragmentJobStub(JobId::IllegalJob));
  /// check for illegal id
#ifndef NDEBUG
  std::cout << "The following assertion is intended and does not indicate a failure." << std::endl;
  CPPUNIT_ASSERT_THROW( queue->pushJob(testJob), Assert::AssertionFailure );
#endif
  // set to valid id
  testJob->setId(1);

  CPPUNIT_ASSERT_EQUAL(false, queue->isJobPresent() );

#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushJob(testJob) );
#else
  queue->pushJob(testJob);
#endif
  CPPUNIT_ASSERT( addobserver->wasNotified );
  addobserver->wasNotified = false;

  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->jobs.size());
  CPPUNIT_ASSERT_EQUAL(true, queue->isJobPresent() );
  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->results.size());
  {
    FragmentQueue::ResultMap::const_iterator iter = queue->results.find((JobId_t)1);
    CPPUNIT_ASSERT( iter != queue->results.end() );
    CPPUNIT_ASSERT( queue->getNoResult() == iter->second );
  }

  // push same id again
#ifndef NDEBUG
  std::cout << "The following assertion is intended and does not indicate a failure." << std::endl;
  CPPUNIT_ASSERT_THROW( queue->pushJob(testJob), Assert::AssertionFailure );
#endif

  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->jobs.size());
  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->results.size());

  FragmentJob::ptr poppedJob;
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( poppedJob = queue->popJob() );
#else
  poppedJob = queue->popJob();
#endif
  CPPUNIT_ASSERT( !addobserver->wasNotified );
  CPPUNIT_ASSERT( poppedJob == testJob );

  CPPUNIT_ASSERT_EQUAL((size_t)0, queue->jobs.size());
  CPPUNIT_ASSERT_EQUAL(false, queue->isJobPresent() );
  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->results.size());
  {
    FragmentQueue::ResultMap::const_iterator iter = queue->results.find((JobId_t)1);
    CPPUNIT_ASSERT( iter != queue->results.end() );
    CPPUNIT_ASSERT( queue->getNoResultQueued() == iter->second );
  }

#ifndef NDEBUG
  std::cout << "The following assertion is intended and does not indicate a failure." << std::endl;
  CPPUNIT_ASSERT_THROW( queue->popJob(), Assert::AssertionFailure );
#endif
}

/** UnitTest for adding multiple jobs at a time.
 */
void FragmentQueueTest::JobsTest()
{
  // prepare some jobs
  FragmentJob::ptr testJob(new FragmentJobStub(JobId::IllegalJob));
  testJob->setId((JobId_t)1);
  FragmentJob::ptr anothertestJob(new FragmentJobStub(JobId::IllegalJob));
  anothertestJob->setId((JobId_t)2);

  // prepare a vector of them
  std::vector<FragmentJob::ptr> testjobs;
  testjobs.push_back(testJob);
  testjobs.push_back(anothertestJob);

  // prepare another vector of them
  std::vector<FragmentJob::ptr> sametestjobs;
  sametestjobs.push_back(testJob);
  sametestjobs.push_back(anothertestJob);

  // push the vector
  CPPUNIT_ASSERT_EQUAL( (size_t)0, queue->jobs.size() );
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushJobs(testjobs) );
#else
  queue->pushJobs(testjobs);
#endif
  CPPUNIT_ASSERT_EQUAL( (size_t)2, queue->jobs.size() );
  CPPUNIT_ASSERT_EQUAL((size_t)2, queue->results.size());
  {
    FragmentQueue::ResultMap::const_iterator iter = queue->results.find((JobId_t)1);
    CPPUNIT_ASSERT( iter != queue->results.end() );
    CPPUNIT_ASSERT( queue->getNoResult() == iter->second );
  }
  {
    FragmentQueue::ResultMap::const_iterator iter = queue->results.find((JobId_t)2);
    CPPUNIT_ASSERT( iter != queue->results.end() );
    CPPUNIT_ASSERT( queue->getNoResult() == iter->second );
  }
  // push again
#ifndef NDEBUG
  std::cout << "The following assertion is intended and does not indicate a failure." << std::endl;
  CPPUNIT_ASSERT_THROW( queue->pushJobs(testjobs), Assert::AssertionFailure );
#endif

  CPPUNIT_ASSERT_EQUAL( (size_t)2, queue->jobs.size() );
  CPPUNIT_ASSERT_EQUAL((size_t)2, queue->results.size());
}

/** UnitTest for adding multiple jobs with different priorities.
 */
void FragmentQueueTest::PriorityTest()
{
  // prepare some jobs
  const size_t MAXJOBS = 10;
  std::vector<FragmentJob::ptr> testjobs;
  for(size_t i=1; i<= MAXJOBS; ++i) {
    FragmentJob::ptr testJob(new FragmentJobStub((JobId_t)i));
    FragmentJob::priority_t priority = rand() % 10;
    testJob->setPriority(priority);
    testjobs.push_back(testJob);
  }

  // push the vector
  CPPUNIT_ASSERT_EQUAL( (size_t)0, queue->jobs.size() );
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushJobs(testjobs) );
#else
  queue->pushJobs(testjobs);
#endif
  CPPUNIT_ASSERT_EQUAL( MAXJOBS, queue->jobs.size() );
  CPPUNIT_ASSERT_EQUAL( MAXJOBS, queue->results.size());

  // pop and check their ids
  FragmentJob::priority_t old_priority =
      std::numeric_limits<FragmentJob::priority_t>::max();
  while(queue->isJobPresent()) {
    FragmentJob::ptr testjob = queue->popJob();
    const FragmentJob::priority_t &new_priority =
        testjob->priority;
    CPPUNIT_ASSERT( old_priority >= new_priority);
    old_priority = new_priority;
  }
}


/** UnitTest for working ResultMap
 */
void FragmentQueueTest::ResultsTest()
{
  // prepare a job
  FragmentJob::ptr testJob(new FragmentJobStub(JobId::IllegalJob));
  testJob->setId(1);
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushJob(testJob) );
#else
  queue->pushJob(testJob);
#endif

  // check for present job to do
  CPPUNIT_ASSERT_EQUAL( (size_t)1, queue->getPresentJobs() );

#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->popJob() );
#else
  queue->popJob();
#endif

  // check for present job to do
  CPPUNIT_ASSERT_EQUAL( (size_t)0, queue->getPresentJobs() );

  // prepare a result
  FragmentResult::ptr testResult( new FragmentResult(1) );
  FragmentResult::ptr wrongIdResult( new FragmentResult(2) );

  // check that none are present and we can't get result yet
  CPPUNIT_ASSERT_EQUAL( (size_t)0, queue->getDoneJobs() );
  CPPUNIT_ASSERT( !queue->isResultPresent(1) );
  CPPUNIT_ASSERT( !queue->isResultPresent(2) );
#ifndef NDEBUG
  std::cout << "The following assertion is intended and does not indicate a failure." << std::endl;
  CPPUNIT_ASSERT_THROW( queue->getResult(1), Assert::AssertionFailure );
#endif

  /// check for admonishing wrong id
#ifndef NDEBUG
  std::cout << "The following assertion is intended and does not indicate a failure." << std::endl;
  CPPUNIT_ASSERT_THROW( queue->pushResult(wrongIdResult), Assert::AssertionFailure );
#endif

  // push correct result
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushResult(testResult) );
#else
  queue->pushResult(testResult);
#endif

  // check presence again
  CPPUNIT_ASSERT( queue->isResultPresent(1) );
  CPPUNIT_ASSERT_EQUAL( (size_t)1, queue->getDoneJobs() );
  CPPUNIT_ASSERT_EQUAL( (size_t)0, queue->getPresentJobs() );

  // obtain result again
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->getResult(1) );
#else
  queue->getResult(1);
#endif

  // check presence one more time
  CPPUNIT_ASSERT_EQUAL( (size_t)0, queue->getDoneJobs() );
  CPPUNIT_ASSERT_EQUAL( (size_t)0, queue->getPresentJobs() );
  CPPUNIT_ASSERT( !queue->isResultPresent(1) );
  CPPUNIT_ASSERT( !queue->isResultPresent(2) );
#ifndef NDEBUG
  std::cout << "The following assertion is intended and does not indicate a failure." << std::endl;
  CPPUNIT_ASSERT_THROW( queue->getResult(1), Assert::AssertionFailure );
#endif
}

/** UnitTest for working ResultMap
 */
void FragmentQueueTest::AllResultsTest()
{
  // prepare a job
  FragmentJob::ptr testJob( new FragmentJobStub(JobId::IllegalJob) );
  testJob->setId((JobId_t)1);
  FragmentJob::ptr anothertestJob( new FragmentJobStub(JobId::IllegalJob) );
  anothertestJob->setId((JobId_t)2);

#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushJob(testJob) );
  CPPUNIT_ASSERT_NO_THROW( queue->pushJob(anothertestJob) );
#else
  queue->pushJob(testJob);
  queue->pushJob(anothertestJob);
#endif

  // check that no results are returned.
  {
    const std::vector<FragmentResult::ptr> results = queue->getAllResults();
    CPPUNIT_ASSERT_EQUAL( (size_t)0, results.size() );
  }

  // pop both as if some work was being done
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->popJob() );
  CPPUNIT_ASSERT_NO_THROW( queue->popJob() );
#else
  queue->popJob();
  queue->popJob();
#endif

  // prepare a result
  FragmentResult::ptr testResult( new FragmentResult(1) );
  FragmentResult::ptr anothertestResult( new FragmentResult(2) );

  // push correct result
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushResult(testResult) );
  CPPUNIT_ASSERT_NO_THROW( queue->pushResult(anothertestResult) );
#else
  queue->pushResult(testResult);
  queue->pushResult(anothertestResult);
#endif

  // check that two results are returned.
  {
    const std::vector<FragmentResult::ptr> results = queue->getAllResults();
    CPPUNIT_ASSERT_EQUAL( (size_t)2, results.size() );
  }
}

/** Unit test for resubmitJob().
 *
 */
void FragmentQueueTest::removeWaitingResultsTest()
{
  // prepare a job
  FragmentJob::ptr testJob(new FragmentJobStub(JobId::IllegalJob));
  testJob->setId(1);
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushJob(testJob) );
#else
  queue->pushJob(testJob);
#endif

  CPPUNIT_ASSERT_EQUAL( (size_t)1, queue->results.size() );
  // now remove all waiting results although there are none
  queue->removeWaitingResults();
  CPPUNIT_ASSERT_EQUAL( (size_t)1, queue->results.size() );

  // pop job as if we do some work
  queue->popJob();

  // prepare a result for the job
  FragmentResult::ptr testResult( new FragmentResult(1) );
  // push correct result
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushResult(testResult) );
#else
  queue->pushResult(testResult);
#endif

  // check that one job is done
  CPPUNIT_ASSERT_EQUAL( (size_t)1, queue->getDoneJobs() );

  // now remove all waiting results
  queue->removeWaitingResults();

  // check that no results are returned.
  {
    CPPUNIT_ASSERT_EQUAL( (size_t)0, queue->getDoneJobs() );
    const std::vector<FragmentResult::ptr> results = queue->getAllResults();
    CPPUNIT_ASSERT_EQUAL( (size_t)0, results.size() );
  }
}

/** Unit test for resubmitJob().
 *
 */
void FragmentQueueTest::resubmitTest()
{
  FragmentJob::ptr testJob(new FragmentJobStub(1));

  // push a Job into queue
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->pushJob(testJob) );
#else
  queue->pushJob(testJob);
#endif
  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->jobs.size());
  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->results.size());

  // pop the job
  // pop both as if some work was being done
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->popJob() );
#else
  queue->popJob();
#endif
  CPPUNIT_ASSERT_EQUAL((size_t)0, queue->jobs.size());
  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->results.size());

  // resubmit
#ifndef NDEBUG
  CPPUNIT_ASSERT_NO_THROW( queue->resubmitJob((JobId_t)1) );
#else
  queue->resubmitJob((JobId_t)1);
#endif

  // check whethers it's present again
  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->jobs.size());
  CPPUNIT_ASSERT_EQUAL((size_t)1, queue->results.size());
}