source: src/vectorunittest.cpp@ 54a746

/*
 * unittest.cpp
 *
 *  Created on: Aug 17, 2009
 *      Author: heber
 */


using namespace std;

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

#include "vectorunittest.hpp"
#include "vector.hpp"
#include "defs.hpp"

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

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


void VectorTest::setUp()
{
};


void VectorTest::tearDown()
{
};

/** UnitTest for Constructors and Vector::IsZero() and Vector::IsOne().
 */
void VectorTest::UnityTest()
{
  Vector zero(0.,0.,0.);
  Vector unit(1.,0.,0.);
  Vector otherunit(1./sqrt(2.),0.,1./sqrt(2.));
  Vector notunit(0.,1.,1.);

  // unity and zero tests
  CPPUNIT_ASSERT_EQUAL( true, zero.IsZero() );
  CPPUNIT_ASSERT_EQUAL( false, zero.IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, unit.IsZero() );
  CPPUNIT_ASSERT_EQUAL( true, unit.IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, notunit.IsOne() );
  CPPUNIT_ASSERT_EQUAL( true, otherunit.IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, otherunit.IsZero() );
};

/** UnitTest for Vector::CopyVector(), Vector::AddVector, Vector::SubtractVector() and Vector::Scale()/
 */
void VectorTest::SimpleAlgebraTest()
{
  Vector zero(0.,0.,0.);
  Vector unit(1.,0.,0.);
  Vector otherunit(0.,1.,0.);
  Vector notunit(0.,1.,1.);
  Vector helper;
  double factor;

  // summation and scaling
  helper.CopyVector(&zero);
  helper.AddVector(&unit);
  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
  helper.CopyVector(&zero);
  helper.SubtractVector(&unit);
  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, helper.IsZero() );
  helper.CopyVector(&zero);
  helper.AddVector(&zero);
  CPPUNIT_ASSERT_EQUAL( true, helper.IsZero() );
  helper.CopyVector(&notunit);
  helper.SubtractVector(&otherunit);
  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
  helper.CopyVector(&unit);
  helper.AddVector(&otherunit);
  CPPUNIT_ASSERT_EQUAL( false, helper.IsOne() );
  helper.CopyVector(&notunit);
  helper.SubtractVector(&unit);
  helper.SubtractVector(&otherunit);
  CPPUNIT_ASSERT_EQUAL( false, helper.IsZero() );
  helper.CopyVector(&unit);
  helper.Scale(0.98);
  CPPUNIT_ASSERT_EQUAL( false, helper.IsOne() );
  helper.CopyVector(&unit);
  helper.Scale(1.);
  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
  helper.CopyVector(&unit);
  factor = 0.98;
  helper.Scale(factor);
  CPPUNIT_ASSERT_EQUAL( false, helper.IsOne() );
  helper.CopyVector(&unit);
  factor = 1.;
  helper.Scale(factor);
  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
};


/** UnitTest for operator versions of Vector::CopyVector(), Vector::AddVector, Vector::SubtractVector() and Vector::Scale().
 */
void VectorTest::OperatorAlgebraTest()
{
  Vector zero(0.,0.,0.);
  Vector unit(1.,0.,0.);
  Vector otherunit(0.,1.,0.);
  Vector notunit(0.,1.,1.);

  // summation and scaling
  CPPUNIT_ASSERT_EQUAL( true, (zero+unit).IsOne() );
  CPPUNIT_ASSERT_EQUAL( true, (zero-unit).IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, (zero-unit).IsZero() );
  CPPUNIT_ASSERT_EQUAL( true, (zero+zero).IsZero() );
  CPPUNIT_ASSERT_EQUAL( true, (notunit-otherunit).IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, (unit+otherunit).IsOne() );
  CPPUNIT_ASSERT_EQUAL( false, (notunit-unit-otherunit).IsZero() );
  CPPUNIT_ASSERT_EQUAL( false, (unit*0.98).IsOne() );
  CPPUNIT_ASSERT_EQUAL( true, (unit*1.).IsOne() );
};

/** UnitTest for scalar products, norms, distances and angles.
 */
void VectorTest::EuclidianTest()
{
  Vector zero(0.,0.,0.);
  Vector unit(1.,0.,0.);
  Vector otherunit(0.,1.,0.);
  Vector notunit(0.,1.,1.);
  Vector two(2.,1.,0.);

  // SCP
  CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(&zero) );
  CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(&unit) );
  CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(&otherunit) );
  CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(&notunit) );
  CPPUNIT_ASSERT_EQUAL( 1., unit.ScalarProduct(&unit) );
  CPPUNIT_ASSERT_EQUAL( 0., otherunit.ScalarProduct(&unit) );
  CPPUNIT_ASSERT_EQUAL( 0., otherunit.ScalarProduct(&unit) );
  CPPUNIT_ASSERT_EQUAL( 1., otherunit.ScalarProduct(&notunit) );
  CPPUNIT_ASSERT_EQUAL( 2., two.ScalarProduct(&unit) );
  CPPUNIT_ASSERT_EQUAL( 1., two.ScalarProduct(&otherunit) );
  CPPUNIT_ASSERT_EQUAL( 1., two.ScalarProduct(&notunit) );

  // Norms
  CPPUNIT_ASSERT_EQUAL( 0., zero.Norm() );
  CPPUNIT_ASSERT_EQUAL( 0., zero.NormSquared() );
  CPPUNIT_ASSERT_EQUAL( 1., unit.Norm() );
  CPPUNIT_ASSERT_EQUAL( 1., unit.NormSquared() );
  CPPUNIT_ASSERT_EQUAL( 1., otherunit.Norm() );
  CPPUNIT_ASSERT_EQUAL( 1., otherunit.NormSquared() );
  CPPUNIT_ASSERT_EQUAL( 2., notunit.NormSquared() );
  CPPUNIT_ASSERT_EQUAL( sqrt(2.), notunit.Norm() );

  // distances
  CPPUNIT_ASSERT_EQUAL( 1., zero.Distance(&unit) );
  CPPUNIT_ASSERT_EQUAL( sqrt(2.), otherunit.Distance(&unit) );
  CPPUNIT_ASSERT_EQUAL( sqrt(2.), zero.Distance(&notunit) );
  CPPUNIT_ASSERT_EQUAL( 1., otherunit.Distance(&notunit) );
  CPPUNIT_ASSERT_EQUAL( sqrt(5.), two.Distance(&notunit) );

  // Angles
  CPPUNIT_ASSERT_EQUAL( M_PI, zero.Angle(&unit) );
};


/********************************************** Main routine **************************************/

int main(int argc, char **argv)
{
  // Get the top level suite from the registry
  CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();

  // Adds the test to the list of test to run
  CppUnit::TextUi::TestRunner runner;
  runner.addTest( suite );

  // Change the default outputter to a compiler error format outputter
  runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
                                                       std::cerr ) );
  // Run the tests.
  bool wasSucessful = runner.run();

  // Return error code 1 if the one of test failed.
  return wasSucessful ? 0 : 1;
};