random_racer/unittests/ControlPointContainerTests.cpp

Go to the documentation of this file.

#include <cppunit/BriefTestProgressListener.h>
#include <cppunit/CompilerOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/TestResult.h>
#include <cppunit/TestResultCollector.h>
#include <cppunit/TestRunner.h>
#include <cppunit/config/SourcePrefix.h>

#include "ControlPointContainerTests.h"


namespace random_racer
{
    
CPPUNIT_TEST_SUITE_REGISTRATION(ControlPointContainerTests);

void 
ControlPointContainerTests::setUp()
{
    m_controlPointGenerator = new ControlPointTestGenerator(0);
    m_controlPoints = new ControlPointContainer(10, 10,
                        m_controlPointGenerator->getCallback(), -1, 3);
    m_controlPointsFive = new ControlPointContainer(5, 10,
                        m_controlPointGenerator->getCallback(), -5, 35);
}

void 
ControlPointContainerTests::testMapsValueToKey()
{
    // test a ControlPointContainer with blocksize 10
    // test positive values
    CPPUNIT_ASSERT_EQUAL(0, m_controlPoints->mapToKey(0));
    CPPUNIT_ASSERT_EQUAL(0, m_controlPoints->mapToKey(9));
    CPPUNIT_ASSERT_EQUAL(1, m_controlPoints->mapToKey(10));
    CPPUNIT_ASSERT_EQUAL(2, m_controlPoints->mapToKey(20));
    
    // test negative values
    CPPUNIT_ASSERT_EQUAL(-1, m_controlPoints->mapToKey(-1));
    CPPUNIT_ASSERT_EQUAL(-1, m_controlPoints->mapToKey(-10));
    CPPUNIT_ASSERT_EQUAL(-2, m_controlPoints->mapToKey(-11));
    CPPUNIT_ASSERT_EQUAL(-2, m_controlPoints->mapToKey(-20));
    
    // test floating point values
    CPPUNIT_ASSERT_EQUAL(0, m_controlPoints->mapToKey(0.1));
    CPPUNIT_ASSERT_EQUAL(0, m_controlPoints->mapToKey(9.99));
    CPPUNIT_ASSERT_EQUAL(1, m_controlPoints->mapToKey(10.1));
    
    // test negative floating point values
    CPPUNIT_ASSERT_EQUAL(-1, m_controlPoints->mapToKey(-0.1));
    
    // test a ControlPointContainer with blocksize 5
    CPPUNIT_ASSERT_EQUAL(0, m_controlPointsFive->mapToKey(0));
    CPPUNIT_ASSERT_EQUAL(0, m_controlPointsFive->mapToKey(5));
    CPPUNIT_ASSERT_EQUAL(1, m_controlPointsFive->mapToKey(10));
    
    // negative values
    CPPUNIT_ASSERT_EQUAL(-1, m_controlPointsFive->mapToKey(-1));
    CPPUNIT_ASSERT_EQUAL(-1, m_controlPointsFive->mapToKey(-5));
    CPPUNIT_ASSERT_EQUAL(-2, m_controlPointsFive->mapToKey(-11));
}

void 
ControlPointContainerTests::testGetOffsetToKey()
{
    // test a ControlPointContainer with blocksize 10
    // test positive values
    CPPUNIT_ASSERT_EQUAL(0, m_controlPoints->getOffset(0));
    CPPUNIT_ASSERT_EQUAL(10, m_controlPoints->getOffset(1));
    CPPUNIT_ASSERT_EQUAL(20, m_controlPoints->getOffset(2));
    
    // test negative values
    CPPUNIT_ASSERT_EQUAL(-10, m_controlPoints->getOffset(-1));
    CPPUNIT_ASSERT_EQUAL(-20, m_controlPoints->getOffset(-2));
    CPPUNIT_ASSERT_EQUAL(-30, m_controlPoints->getOffset(-3));
    
    // test a ControlPointContainer with blocksize 5
    CPPUNIT_ASSERT_EQUAL(0, m_controlPointsFive->getOffset(0));
    CPPUNIT_ASSERT_EQUAL(10, m_controlPointsFive->getOffset(1));
    CPPUNIT_ASSERT_EQUAL(-10, m_controlPointsFive->getOffset(-1));        
}

void 
ControlPointContainerTests::testGetTheFourBlocks()
{
    // test a ControlPointContainer with blocksize 10
    m_controlPoints->getFourBlocks(4, 5, m_blockList);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[0]);
    CPPUNIT_ASSERT_EQUAL(1, m_blockList[1]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[2]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[3]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[4]);
    CPPUNIT_ASSERT_EQUAL(1, m_blockList[5]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[6]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[7]);
    
    m_controlPoints->getFourBlocks(5, 5, m_blockList);
    CPPUNIT_ASSERT_EQUAL(1, m_blockList[0]);
    CPPUNIT_ASSERT_EQUAL(1, m_blockList[1]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[2]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[3]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[4]);
    CPPUNIT_ASSERT_EQUAL(1, m_blockList[5]);
    CPPUNIT_ASSERT_EQUAL(1, m_blockList[6]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[7]);
    
    m_controlPoints->getFourBlocks(4, 4, m_blockList);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[0]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[1]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[2]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[3]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[4]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[5]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[6]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[7]);
    
    m_controlPoints->getFourBlocks(5, 4, m_blockList);
    CPPUNIT_ASSERT_EQUAL(1, m_blockList[0]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[1]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[2]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[3]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[4]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[5]);
    CPPUNIT_ASSERT_EQUAL(1, m_blockList[6]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[7]);
    
    // test a ControlPointContainer with blocksize 5
    m_controlPointsFive->getFourBlocks(4, 4, m_blockList);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[0]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[1]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[2]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[3]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[4]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[5]);
    CPPUNIT_ASSERT_EQUAL(0, m_blockList[6]);
    CPPUNIT_ASSERT_EQUAL(-1, m_blockList[7]);
}

void 
ControlPointContainerTests::testHashMapValues()
{
    // test a ControlPointContainer with blocksize 5 and viewsize 10
    m_controlPointsFive->getPoints(0, 0, &m_target);
    CPPUNIT_ASSERT(4 == m_target.size());
    
    unsigned int position = 0;
    
    for(  std::vector<VRS::Vector>::iterator i = m_target.begin(); i < 
            m_target.end(); ++i , position++)
    {             
        if(position == 0)
        {
            CPPUNIT_ASSERT(0 == (*i)[0]);
            CPPUNIT_ASSERT(35 == (*i)[1]);
            CPPUNIT_ASSERT(2 == (*i)[2]);
        }
        else if(position == 1)
        {
            CPPUNIT_ASSERT(-10 == (*i)[0]);
            CPPUNIT_ASSERT(35 == (*i)[1]);
            CPPUNIT_ASSERT(-8 == (*i)[2]);
        }
        else if(position == 2)
        {
            CPPUNIT_ASSERT(-10 == (*i)[0]);
            CPPUNIT_ASSERT(35 == (*i)[1]);
            CPPUNIT_ASSERT(2 == (*i)[2]);
        }
        else
        {
            CPPUNIT_ASSERT(0 == (*i)[0]);
            CPPUNIT_ASSERT(35 == (*i)[1]);
            CPPUNIT_ASSERT(-8 == (*i)[2]);
        }
    }
    m_target.clear();
    
    // test a ControlPointContainer with blocksize 10
    m_controlPoints->getPoints(0, 0, &m_target);
    CPPUNIT_ASSERT(4 == m_target.size());
    
    position = 0;
    
    for(  std::vector<VRS::Vector>::iterator i = m_target.begin(); i < 
            m_target.end(); ++i , position++)
    {
        if(position == 0)
        {
            CPPUNIT_ASSERT(0 == (*i)[0]);
            CPPUNIT_ASSERT(3 == (*i)[1]);
            CPPUNIT_ASSERT(1 == (*i)[2]);
        }
        else if(position == 1)
        {
            CPPUNIT_ASSERT(-10 == (*i)[0]);
            CPPUNIT_ASSERT(3 == (*i)[1]);
            CPPUNIT_ASSERT(-9 == (*i)[2]);
        }
        else if(position == 2)
        {
            CPPUNIT_ASSERT(-10 == (*i)[0]);
            CPPUNIT_ASSERT(3 == (*i)[1]);
            CPPUNIT_ASSERT(1 == (*i)[2]);
        }
        else
        {
            CPPUNIT_ASSERT(0 == (*i)[0]);
            CPPUNIT_ASSERT(3 == (*i)[1]);
            CPPUNIT_ASSERT(-9 == (*i)[2]);
        }
    }
    m_target.clear();
    
    m_controlPoints->getPoints(9, 10, &m_target);
    CPPUNIT_ASSERT(4 == m_target.size());
    
    position = 0;
    
    for(  std::vector<VRS::Vector>::iterator i = m_target.begin(); i < 
            m_target.end(); ++i, position++ )
    {        
        if(position == 0)
        {
            CPPUNIT_ASSERT(10 == (*i)[0]);
            CPPUNIT_ASSERT(3  == (*i)[1]);
            CPPUNIT_ASSERT(11 == (*i)[2]);
        }
        else if(position == 1)
        {
            CPPUNIT_ASSERT(0 == (*i)[0]);
            CPPUNIT_ASSERT(3 == (*i)[1]);
            CPPUNIT_ASSERT(1 == (*i)[2]);
        }
        else if(position == 2)
        {
            CPPUNIT_ASSERT(0  == (*i)[0]);
            CPPUNIT_ASSERT(3  == (*i)[1]);
            CPPUNIT_ASSERT(11 == (*i)[2]);
        }
        else
        {
            CPPUNIT_ASSERT(10 == (*i)[0]);
            CPPUNIT_ASSERT(3  == (*i)[1]);
            CPPUNIT_ASSERT(1  == (*i)[2]);
        }
    }
    m_target.clear();
    
    // test a ControlPointContainer with blocksize 10
    m_controlPoints->getPoints(0, 0, 9, 9, &m_target);
    CPPUNIT_ASSERT(1 == m_target.size());
    
    position = 0;
    
    for(  std::vector<VRS::Vector>::iterator i = m_target.begin(); i < 
            m_target.end(); ++i, position++ )
    {                
        if(position == 0)
        {
            CPPUNIT_ASSERT(0 == (*i)[0]);
            CPPUNIT_ASSERT(3 == (*i)[1]);
            CPPUNIT_ASSERT(1 == (*i)[2]);
        }
    }
    m_target.clear();
    
    // test a ControlPointContainer with blocksize 10
    m_controlPoints->getPoints(0, 0, 10, 9, &m_target);
    CPPUNIT_ASSERT(2 == m_target.size());
    
    position = 0;
    
    for(  std::vector<VRS::Vector>::iterator i = m_target.begin(); i < 
            m_target.end(); ++i, position++ )
    {                
        if(position == 0)
        {
            CPPUNIT_ASSERT(0 == (*i)[0]);
            CPPUNIT_ASSERT(3 == (*i)[1]);
            CPPUNIT_ASSERT(1 == (*i)[2]);
        }
        if(position == 1)
        {
            CPPUNIT_ASSERT(10 == (*i)[0]);
            CPPUNIT_ASSERT(3  == (*i)[1]);
            CPPUNIT_ASSERT(1  == (*i)[2]);
        }
    }
    m_target.clear();
    
    // test a ControlPointContainer with blocksize 10
   m_controlPoints->getPoints(0, 0, -5, 5, &m_target);
   CPPUNIT_ASSERT(2 == m_target.size());
   
   position = 0;
   
   for(  std::vector<VRS::Vector>::iterator i = m_target.begin(); i < 
           m_target.end(); ++i, position++ )
   {                
       if(position == 0)
       {
           CPPUNIT_ASSERT(0 == (*i)[0]);
           CPPUNIT_ASSERT(3 == (*i)[1]);
           CPPUNIT_ASSERT(1 == (*i)[2]);
       }
       if(position == 1)
       {
           CPPUNIT_ASSERT(-10 == (*i)[0]);
           CPPUNIT_ASSERT(3  == (*i)[1]);
           CPPUNIT_ASSERT(1  == (*i)[2]);
       }
   }
   m_target.clear();
   
   // test a ControlPointContainer with blocksize 10
   m_controlPoints->getPoints(0, 0, 19, 19, &m_target);
   CPPUNIT_ASSERT(4 == m_target.size());
   
   position = 0;
   
   for(  std::vector<VRS::Vector>::iterator i = m_target.begin(); i < 
           m_target.end(); ++i , position++)
   {        
       if(position == 0)
       {
           CPPUNIT_ASSERT(0 == (*i)[0]);
           CPPUNIT_ASSERT(3 == (*i)[1]);
           CPPUNIT_ASSERT(1 == (*i)[2]);
       }
       else if(position == 1)
       {
           CPPUNIT_ASSERT(-10 == (*i)[0]);
           CPPUNIT_ASSERT(3 == (*i)[1]);
           CPPUNIT_ASSERT(-9 == (*i)[2]);
       }
       else if(position == 2)
       {
           CPPUNIT_ASSERT(-10 == (*i)[0]);
           CPPUNIT_ASSERT(3 == (*i)[1]);
           CPPUNIT_ASSERT(1 == (*i)[2]);
       }
       else
       {
           CPPUNIT_ASSERT(0 == (*i)[0]);
           CPPUNIT_ASSERT(3 == (*i)[1]);
           CPPUNIT_ASSERT(-9 == (*i)[2]);
       }
   }
   m_target.clear();
   
   // test a ControlPointContainer with blocksize 10
   m_controlPoints->getPoints(0, 0, -10, -10, &m_target);
   CPPUNIT_ASSERT(4 == m_target.size());
   
   position = 0;
   
   for(  std::vector<VRS::Vector>::iterator i = m_target.begin(); i < 
           m_target.end(); ++i , position++)
   {        
       if(position == 0)
       {
           CPPUNIT_ASSERT(0 == (*i)[0]);
           CPPUNIT_ASSERT(3 == (*i)[1]);
           CPPUNIT_ASSERT(1 == (*i)[2]);
       }
       else if(position == 1)
       {
           CPPUNIT_ASSERT(-10 == (*i)[0]);
           CPPUNIT_ASSERT(3 == (*i)[1]);
           CPPUNIT_ASSERT(-9 == (*i)[2]);
       }
       else if(position == 2)
       {
           CPPUNIT_ASSERT(-10 == (*i)[0]);
           CPPUNIT_ASSERT(3 == (*i)[1]);
           CPPUNIT_ASSERT(1 == (*i)[2]);
       }
       else
       {
           CPPUNIT_ASSERT(0 == (*i)[0]);
           CPPUNIT_ASSERT(3 == (*i)[1]);
           CPPUNIT_ASSERT(-9 == (*i)[2]);
       }
   }
   m_target.clear();  
}

}

int
main( int argc, char* argv[] )
{
    // Create the event manager and test controller
    CPPUNIT_NS::TestResult controller;

    // Add a listener that colllects test result
    CPPUNIT_NS::TestResultCollector result;
    controller.addListener( &result );        

    // Add a listener that print dots as test run.
    CPPUNIT_NS::BriefTestProgressListener progress;
    controller.addListener( &progress );      

    // Add the top suite to the test runner
    CPPUNIT_NS::TestRunner runner;
    runner.addTest( CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest() );
    runner.run( controller );

    // Print test in a compiler compatible format.
    CPPUNIT_NS::CompilerOutputter outputter( &result, CPPUNIT_NS::stdCOut() );
    outputter.write(); 

    return result.wasSuccessful() ? 0 : 1;
}

---