testBasicVector.cc

Go to the documentation of this file.

#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/AxialVector.h>
#include <utl/TransformationMatrix.h>
#include <utl/GeometryException.h>
#include <tst/Verify.h>
#include <utl/Triple.h>
#include "testBasicVectorHelper.h"

#include <cppunit/extensions/HelperMacros.h>

#include <cmath>

using namespace utl;
using namespace tst;
using std::cos;
using std::sin;

#define TEST_COLLECTION(Type_) \
  CPPUNIT_TEST_EXCEPTION(testConstructorThrow<Type_>, CoordinateSystemException); \
  CPPUNIT_TEST(testConstructor<Type_>); \
  CPPUNIT_TEST(testConstructorCylindrical<Type_>); \
  CPPUNIT_TEST(testConstructorSpherical<Type_>); \
  CPPUNIT_TEST_EXCEPTION(testTransformation<Type_>, CoordinateSystemException); \
  CPPUNIT_TEST(testOperations<Type_>)


class testBasicVector : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(testBasicVector);
  TEST_COLLECTION(Point);
  TEST_COLLECTION(Vector);
  TEST_COLLECTION(AxialVector);
  CPPUNIT_TEST(testNormalize);
  CPPUNIT_TEST_SUITE_END();

private:
  template<class VectorType>
  void
  testConstructorThrow()
  {
    const CoordinateSystemPtr CsNull;
    const VectorType v(0,0,0, CsNull);
  }

  template<class VectorType>
  void
  testConstructor()
  {
    const CoordinateSystemPtr cs = CoordinateSystem::GetRootCoordinateSystem();
    const VectorType p(0,0,0, cs);

    CPPUNIT_ASSERT(Verify<CloseTo>(p.GetX(cs), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(p.GetY(cs), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(p.GetZ(cs), 0.));
    CPPUNIT_ASSERT(Verify<CloseTo>(
      p.GetCoordinates(cs), Triple(0,0,0)
    ));

    const VectorType q(1,2,3, cs);
    CPPUNIT_ASSERT(Verify<CloseTo>(q.GetX(cs), 1.));
    CPPUNIT_ASSERT(Verify<CloseTo>(q.GetY(cs), 2.));
    CPPUNIT_ASSERT(Verify<CloseTo>(q.GetZ(cs), 3.));
    CPPUNIT_ASSERT(Verify<CloseTo>(
      q.GetCoordinates(cs), Triple(1,2,3)
    ));

    const VectorType x(1,0,0, cs);
    CPPUNIT_ASSERT(Verify<CloseTo>(
      x.GetSphericalCoordinates(cs), Triple(1,M_PI/2,0)
    ));

    const VectorType x2(1,0,0, cs, VectorType::kCartesian);
    CPPUNIT_ASSERT(Verify<CloseTo>((x-x2).GetR(cs), 0.));

    const VectorType x3(1,0,0, cs, tst::cartesian<VectorType>());
    CPPUNIT_ASSERT(Verify<CloseTo>((x-x3).GetR(cs), 0.));
  }

  template<class VectorType>
  void
  testConstructorCylindrical()
  {
    const double root2 = std::sqrt(2.);

    const CoordinateSystemPtr cs = CoordinateSystem::GetRootCoordinateSystem();

    const VectorType p(1,M_PI/4,2, cs, VectorType::kCylindrical);
    CPPUNIT_ASSERT(Verify<CloseTo>(
      p.GetCoordinates(cs), Triple(root2/2,root2/2,2)
    ));

    const VectorType q(1,M_PI/4,2, cs, tst::cylindrical<VectorType>());
    CPPUNIT_ASSERT(Verify<CloseTo>(
      q.GetCoordinates(cs), Triple(root2/2,root2/2,2)
    ));
  }

  template<class VectorType>
  void
  testConstructorSpherical()
  {
    const double root2 = std::sqrt(2.);

    const CoordinateSystemPtr cs = CoordinateSystem::GetRootCoordinateSystem();

    const VectorType p1(1,M_PI/2,M_PI/4, cs, VectorType::kSpherical);
    CPPUNIT_ASSERT(Verify<CloseTo>(
      p1.GetCoordinates(cs), Triple(root2/2,root2/2,0)
    ));

    const VectorType p2(1,M_PI/4,M_PI/3, cs, VectorType::kSpherical);
    CPPUNIT_ASSERT(Verify<CloseTo>(
      p2.GetCoordinates(cs),
      Triple(root2/2*cos(M_PI/3), root2/2*sin(M_PI/3), root2/2)
    ));

    const VectorType p3(1,M_PI/4,M_PI/3, cs, tst::spherical<VectorType>());
    CPPUNIT_ASSERT(Verify<CloseTo>(
      p3.GetCoordinates(cs),
      Triple(root2/2*cos(M_PI/3), root2/2*sin(M_PI/3), root2/2)
    ));
  }

  template<class VectorType>
  void
  testTransformation()
  {
    const CoordinateSystemPtr csNull;
    const CoordinateSystemPtr cs = CoordinateSystem::GetRootCoordinateSystem();
    const VectorType v(0, 0, 0, cs);
    v.TransformTo(csNull);
  }

  template<class VectorType>
  void
  testOperations()
  {
    const CoordinateSystemPtr cs = CoordinateSystem::GetRootCoordinateSystem();

    const VectorType v1(0,0,0, cs);
    CPPUNIT_ASSERT(Verify<CloseTo>(v1.GetR(cs), 0.));

    VectorType v2(1,0,0, cs);
    v2 *= 2;
    CPPUNIT_ASSERT(Verify<CloseTo>(
      v2.GetCoordinates(cs), Triple(2,0,0)
    ));
    v2 /= 4;
    CPPUNIT_ASSERT(Verify<CloseTo>(
      v2.GetCoordinates(cs), Triple(0.5,0,0)
    ));

    CPPUNIT_ASSERT(v1 != v2);
    const VectorType v3(0.5, 0, 0, cs);
    CPPUNIT_ASSERT(v2 == v3);

    CPPUNIT_ASSERT(v1 == v1);
    CPPUNIT_ASSERT(Verify<Not<CloseTo>>(
      v1.GetCoordinates(cs), v2.GetCoordinates(cs)
    ));
  }

  void
  testNormalize()
  {
    const CoordinateSystemPtr cs = CoordinateSystem::GetRootCoordinateSystem();
    Vector v1(2,3,4, cs);
    v1.Normalize();
    CPPUNIT_ASSERT(Verify<CloseTo>(v1.GetR2(cs), 1.));
    CPPUNIT_ASSERT(Verify<CloseTo>(v1.GetR(cs), 1.));

    AxialVector v2(2,3,4, cs);
    v2.Normalize();
    CPPUNIT_ASSERT(Verify<CloseTo>(v2.GetR2(cs), 1.));
    CPPUNIT_ASSERT(Verify<CloseTo>(v2.GetR(cs), 1.));
  }

};


CPPUNIT_TEST_SUITE_REGISTRATION(testBasicVector);