testShowerParticleIterator.cc

Go to the documentation of this file.

#include <utl/ShowerParticleIterator.h>

#include <Particles/testShowerFileParticleIterator.h>

#include <utl/AugerException.h>
#include <utl/CoordinateSystem.h>
#include <utl/Point.h>
#include <utl/Vector.h>

#include <string>
#include <iterator>
#include <algorithm>
#include <memory>

#include <cppunit/extensions/HelperMacros.h>

using std::vector;
using utl::Particle;
using utl::ShowerParticleIterator;


bool
CompareNames(const Particle& p1, const Particle& p2)
{
  return p1.GetName() == p2.GetName();
}


class TestShowerParticleIterator : public CppUnit::TestFixture
{
  CPPUNIT_TEST_SUITE(TestShowerParticleIterator);
  CPPUNIT_TEST(TestComparison);
  CPPUNIT_TEST_EXCEPTION(TestDereferenceEmpty, utl::InvalidIteratorException);
  CPPUNIT_TEST_EXCEPTION(TestIncrementEmpty, utl::InvalidIteratorException);
  CPPUNIT_TEST_EXCEPTION(TestGetTooMany, utl::InvalidIteratorException);
  CPPUNIT_TEST_EXCEPTION(TestDereferenceAfterLast,
                         utl::InvalidIteratorException);
  CPPUNIT_TEST(TestRetrieval);
  CPPUNIT_TEST(TestRetrievalTwice);
  CPPUNIT_TEST(TestSTLCopy);
  CPPUNIT_TEST(TestSTLEqual);
  CPPUNIT_TEST(TestEmptyList);
  CPPUNIT_TEST(TestEmptyListSkip);
  CPPUNIT_TEST_EXCEPTION(TestEmptyListThrow, utl::InvalidIteratorException);
  CPPUNIT_TEST_EXCEPTION(TestEmptyListSkipThrow, utl::InvalidIteratorException);
  CPPUNIT_TEST_SUITE_END();

private:
  ShowerParticleIterator* fCurrent;
  ShowerParticleIterator* fEnd;

  testShowerFileParticleIterator* fFileIterator;

  vector<Particle> fInsertedParticles;
  vector<Particle> fRetrievedParticles;

  void
  AddParticle(testShowerFileParticleIterator& where)
  {
    Particle p(Particle::eUndefined, utl::Particle::eShower,
               utl::Point(0, 0, 0,
                          utl::CoordinateSystem::GetRootCoordinateSystem()),
               utl::Vector(0, 0, 0,
                           utl::CoordinateSystem::GetRootCoordinateSystem()),
               utl::TimeInterval(0.0), 0.0, 0.0);
    where.AddParticle(p);
    fInsertedParticles.push_back(p);
  }

  void
  AddParticles(testShowerFileParticleIterator& where)
  {
    fInsertedParticles.clear();
    AddParticle(where);
    AddParticle(where);
    AddParticle(where);
    AddParticle(where);           // on purpose not "e"
    AddParticle(where);
  }
public:
  void
  setUp()
  {
    fFileIterator = new testShowerFileParticleIterator;
    AddParticles(*fFileIterator);
    fCurrent = new ShowerParticleIterator(fFileIterator);
    fEnd = new ShowerParticleIterator;
  }

  void
  tearDown()
  {
    delete fEnd;
    delete fCurrent;
    delete fFileIterator;
  }

  void
  TestComparison()
  {
    CPPUNIT_ASSERT(*fCurrent != *fEnd);
    ShowerParticleIterator s;
    CPPUNIT_ASSERT(*fEnd == s);
    ShowerParticleIterator iter = *fCurrent;
    CPPUNIT_ASSERT(*fCurrent == iter);
    ++iter;
    CPPUNIT_ASSERT(*fCurrent != iter);
    CPPUNIT_ASSERT(*fEnd != iter);
  }

  void
  TestDereferenceEmpty()
  {
    Particle p = **fEnd;
  }

  void
  TestIncrementEmpty()
  {
    ++(*fEnd);
  }

  void
  TestGetTooMany()
  {
    int count = 10000;          // avoid infinte loop

    while (*fCurrent != *fEnd && count) {
      --count;
      ++(*fCurrent);
    }

    ++(*fCurrent);
  }

  void
  TestDereferenceAfterLast()
  {
    int count = 10000;          // avoid infinte loop

    while (*fCurrent != *fEnd && count) {
      --count;
      ++(*fCurrent);
    }

    CPPUNIT_ASSERT(count != 0);
    Particle p = **fCurrent;
  }

  void
  TestRetrieval()
  {
    vector<Particle>::iterator cur = fInsertedParticles.begin();
    vector<Particle>::iterator end = fInsertedParticles.end();
    while (*fCurrent != *fEnd && cur != end) {
      CPPUNIT_ASSERT((*fCurrent)->GetName() == cur->GetName());
      CPPUNIT_ASSERT((**fCurrent).GetName() == cur->GetName());
      ++ *fCurrent;
      ++ cur;
    }
    CPPUNIT_ASSERT(*fCurrent == *fEnd);
    CPPUNIT_ASSERT(cur == end);
  }

  void
  TestRetrievalTwice()
  {
    vector<Particle>::iterator cur1 = fInsertedParticles.begin();
    vector<Particle>::iterator end = fInsertedParticles.end();

    while (*fCurrent != *fEnd && cur1 != end) {
      CPPUNIT_ASSERT((*fCurrent)->GetName() == cur1->GetName());
      CPPUNIT_ASSERT((**fCurrent).GetName() == cur1->GetName());
      ++ *fCurrent;
      ++ cur1;
    }
    CPPUNIT_ASSERT(*fCurrent == *fEnd);
    CPPUNIT_ASSERT(cur1 == end);

    ShowerParticleIterator iter2(fFileIterator);
    vector<Particle>::iterator cur2 = fInsertedParticles.begin();
    while (iter2 != *fEnd && cur2 != end) {
      CPPUNIT_ASSERT((iter2)->GetName() == cur2->GetName());
      CPPUNIT_ASSERT((*iter2).GetName() == cur2->GetName());
      ++ iter2;
      ++ cur2;
    }
    CPPUNIT_ASSERT(iter2 == *fEnd);
    CPPUNIT_ASSERT(cur2 == end);
  }

  void
  TestSTLCopy()
  {
    std::copy(*fCurrent, *fEnd,
              std::back_insert_iterator<vector<Particle> > (fRetrievedParticles));
    CPPUNIT_ASSERT(fRetrievedParticles.size() == fInsertedParticles.size());
  }

  void
  TestSTLEqual()
  {
    vector<Particle>::iterator cur = fInsertedParticles.begin();
    CPPUNIT_ASSERT(std::equal(*fCurrent, *fEnd, cur, CompareNames));
  }

  void
  TestEmptyList()
  {
    testShowerFileParticleIterator t;
    ShowerParticleIterator it(&t);

    CPPUNIT_ASSERT(it == *fEnd);
  }

  void
  TestEmptyListSkip()
  {
    testShowerFileParticleIterator t(fInsertedParticles.size());
    AddParticles(t);
    ShowerParticleIterator it(&t);

    CPPUNIT_ASSERT(it == *fEnd);
  }

  void
  TestEmptyListThrow()
  {
    testShowerFileParticleIterator t;
    ShowerParticleIterator it(&t);

    *it;
  }

  void
  TestEmptyListSkipThrow()
  {
    testShowerFileParticleIterator t(fInsertedParticles.size());
    AddParticles(t);
    ShowerParticleIterator it(&t);

    *it;
  }

};


CPPUNIT_TEST_SUITE_REGISTRATION(TestShowerParticleIterator);


// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. -k run-testShowerParticleIterator"
// End: