testTraces.cc

Go to the documentation of this file.

#include <iostream>

#include <tst/Verify.h>

#include <utl/Trace.h>
#include <utl/MultiTrace.h>
#include <utl/TraceAlgorithm.h>
#include <utl/AugerException.h>

#include <cppunit/extensions/HelperMacros.h>

using namespace std;
using namespace utl;
using namespace tst;


class testTraces : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(testTraces);
  CPPUNIT_TEST(testEqualAndCopyCtor);
  CPPUNIT_TEST(testFillTrace);
  CPPUNIT_TEST(testOperators);
  CPPUNIT_TEST(testAlgorithms);
  CPPUNIT_TEST(testMultiTrace);
  CPPUNIT_TEST(testCtor);
  CPPUNIT_TEST_EXCEPTION(testBinException1, InvalidTraceBoundException);
  CPPUNIT_TEST_EXCEPTION(testBinException2, InvalidTraceBoundException);

  // add tests for multitraces

  CPPUNIT_TEST_SUITE_END();

private:
  TraceI* traceOfInts;
  TraceD* traceOfDoubles;
  TraceD* traceForCentroid;
  TraceI* traceOneElement;
  TraceD* traceForMedian;
  TraceI* traceForMedian2;
  TraceI* traceForMedian3;

public:
  void
  setUp()
  {
    traceOfInts = new TraceI(100, 100);
    for (int i = traceOfInts->GetStart(); i < int(traceOfInts->GetStop()); ++i)
      (*traceOfInts)[i] = i;

    traceOfDoubles = new TraceD(3, 10);
    double start = 4;
    for (TraceD::Iterator it = traceOfDoubles->Begin();
         it != traceOfDoubles->End(); ++it)
      *it = start++;

    traceForCentroid = new TraceD(3, 10);
    (*traceForCentroid)[0] = 1.0;
    (*traceForCentroid)[1] = 5.0;
    (*traceForCentroid)[2] = 1.0;

    traceOneElement = new TraceI(1, 1);
    (*traceOneElement)[0] = 1;

    traceForMedian = new TraceD(8, 1);
    (*traceForMedian)[0] = -5;
    (*traceForMedian)[1] = 0;
    (*traceForMedian)[2] = 1000;
    (*traceForMedian)[3] = 7.2;
    (*traceForMedian)[4] = -1.8;
    (*traceForMedian)[5] = 70;
    (*traceForMedian)[6] = 4;
    (*traceForMedian)[7] = 5;

    traceForMedian2 = new TraceI(8, 1);
    (*traceForMedian2)[0] = -5;
    (*traceForMedian2)[1] = 0;
    (*traceForMedian2)[2] = 1000;
    (*traceForMedian2)[3] = 7;
    (*traceForMedian2)[4] = -2;
    (*traceForMedian2)[5] = 70;
    (*traceForMedian2)[6] = 4;
    (*traceForMedian2)[7] = 5;

    traceForMedian3 = new TraceI(8, 1);
    (*traceForMedian3)[0] = -5;
    (*traceForMedian3)[1] = 0;
    (*traceForMedian3)[2] = 1000;
    (*traceForMedian3)[3] = 7;
    (*traceForMedian3)[4] = -2;
    (*traceForMedian3)[5] = 70;
    (*traceForMedian3)[6] = 4;
    (*traceForMedian3)[7] = 4;
  }

  void
  tearDown()
  {
    delete traceOfInts;
    delete traceOfDoubles;
    delete traceForCentroid;
    delete traceOneElement;
    delete traceForMedian;
    delete traceForMedian2;
    delete traceForMedian3;
  }

  void
  testEqualAndCopyCtor()
  {
    TraceI copyI(*traceOfInts);
    CPPUNIT_ASSERT(copyI == *traceOfInts);
    CPPUNIT_ASSERT(!(copyI != *traceOfInts));
    TraceD copyD(*traceOfDoubles);
    CPPUNIT_ASSERT(!(copyD != *traceOfDoubles));
  }

  void
  testFillTrace()
  {
    CPPUNIT_ASSERT(Verify<Equal>((*traceOfInts)[35], 35));
    CPPUNIT_ASSERT(Verify<Equal>(traceOfInts->At(45), 45));
    CPPUNIT_ASSERT(Verify<Equal>(traceOfInts->GetSize(), TraceI::SizeType(100)));
    CPPUNIT_ASSERT(Verify<Equal>(traceOfInts->GetSize(),
                   traceOfInts->GetStop() - traceOfInts->GetStart()));

    // copy ctor
    {
      TraceI copy(*traceOfInts);
      for (TraceI::Iterator it = copy.Begin(), jt = traceOfInts->Begin();
           it != copy.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, *jt));
    }

    // adopt trace from array
    {
      short int uns[] = { 0, 1, 2 };
      TraceI adopted;
      adopted.Adopt(uns, 3);
      for (TraceI::SizeType i = 0; i != adopted.GetSize(); ++i)
        CPPUNIT_ASSERT(Verify<Equal>(adopted[i], int(i)));
    }
  }

  void
  testOperators()
  {
    *traceOfInts *= 3;
    CPPUNIT_ASSERT(Verify<Equal>((*traceOfInts)[10], 30));
    *traceOfInts += 10;
    CPPUNIT_ASSERT(Verify<Equal>((*traceOfInts)[20], 70));
    *traceOfInts -= 10;
    CPPUNIT_ASSERT(Verify<Equal>((*traceOfInts)[30], 90));
    *traceOfInts /= 3;
    CPPUNIT_ASSERT(Verify<Equal>((*traceOfInts)[40], 40));

    // assignment =
    {
      TraceI copy = *traceOfInts;
      for (TraceI::SizeType i = copy.GetStart(); i < copy.GetStop(); ++i)
        CPPUNIT_ASSERT(Verify<Equal>((*traceOfInts)[i], copy[i]));
    }

    // unary -
    {
      const TraceI negTrace(-(*traceOfInts));
      for (TraceI::ConstIterator it = negTrace.Begin(), jt = traceOfInts->Begin();
           it != negTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, -(*jt)));
    }

    // operator +
    {
      const TraceI twiceTrace(*traceOfInts + (*traceOfInts));
      for (TraceI::SizeType i = twiceTrace.GetStart(); i < twiceTrace.GetStop(); ++i)
        CPPUNIT_ASSERT(Verify<Equal>(twiceTrace[i], 2*(*traceOfInts)[i]));
    }
    {
      const TraceI addTrace(*traceOfInts + 13);
      for (TraceI::ConstIterator it = addTrace.Begin(), jt = traceOfInts->Begin();
           it != addTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, *jt + 13));
    }
    {
      const TraceI addLeftTrace(10 + (*traceOfInts));
      for (TraceI::ConstIterator it = addLeftTrace.Begin(), jt = traceOfInts->Begin();
           it != addLeftTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, 10 + (*jt)));
    }

    // operator -
    {
      const TraceI zeroTrace(*traceOfInts - (*traceOfInts));
      for (TraceI::ConstIterator it = zeroTrace.Begin(); it != zeroTrace.End(); ++it)
        CPPUNIT_ASSERT(Verify<Equal>(*it, 0));
    }
    {
      const TraceI subTrace(*traceOfInts - 13);
      for (TraceI::ConstIterator it = subTrace.Begin(), jt = traceOfInts->Begin();
           it != subTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, *jt - 13));
    }
    {
      const TraceI subLeftTrace(10 - (*traceOfInts));
      for (TraceI::ConstIterator it = subLeftTrace.Begin(), jt = traceOfInts->Begin();
           it != subLeftTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, 10 - (*jt)));
    }

    // operator *
    {
      const TraceI sqrTrace(*traceOfInts * (*traceOfInts));
      for (TraceI::ConstIterator it = sqrTrace.Begin(), jt = traceOfInts->Begin();
           it != sqrTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, (*jt)*(*jt)));
    }
    {
      const TraceI mulTrace(*traceOfInts * 3);
      for (TraceI::ConstIterator it = mulTrace.Begin(), jt = traceOfInts->Begin();
           it != mulTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, *jt * 3));
    }
    {
      const TraceI mulLeftTrace(2 * (*traceOfInts));
      for (TraceI::ConstIterator it = mulLeftTrace.Begin(), jt = traceOfInts->Begin();
           it != mulLeftTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, 2 * (*jt)));
    }

    // operator /
    {
      const TraceI divTrace(*traceOfInts / 5);
      for (TraceI::ConstIterator it = divTrace.Begin(), jt = traceOfInts->Begin();
           it != divTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, *jt / 5));
    }

    // promotion
    {
      const TraceD pTrace(*traceOfInts / 2.);
      TraceI::ConstIterator jt = traceOfInts->Begin();
      for (TraceD::ConstIterator it = pTrace.Begin(); it != pTrace.End(); ++it, ++jt)
        CPPUNIT_ASSERT(Verify<Equal>(*it, *jt / 2.));
    }

  }

  void
  testAlgorithms()
  {
    // min
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Min(*traceOneElement, 0, 0), 1.0));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Min(*traceOfDoubles, 1, 1), 5.0));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Min(*traceOfDoubles, 0, 2), 4.0));
    // max
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Max(*traceOneElement, 0, 0), 1.0));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Max(*traceOfDoubles, 1, 1), 5.0));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Max(*traceOfDoubles, 0, 2), 6.0));
    // median
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Median(*traceOneElement, 0, 0), 1.0));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Median(*traceOfDoubles, 0, 2), 5.0));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Median(*traceForMedian, 0, 7), 4.5));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Median(*traceForMedian2, 0, 7), 4.5));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Median(*traceForMedian3, 0, 7), 4.));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Median(*traceForMedian, 0, 7, 1), 4.5));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Median(*traceForMedian2, 0, 7, 1), 4.5));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Median(*traceForMedian3, 0, 7, 1), 4.));
    // sum
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Sum(*traceOfDoubles, 0, 2), 15.0));
    // mean
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Mean(*traceOfDoubles, 0, 2), 5.0));
    // RMS
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::RMS(*traceOfDoubles, 0, 2), sqrt(2.0/3.0)));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::RMS(*traceOfDoubles, 0, 1), sqrt(0.25)));
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::RMS(*traceOfDoubles, 1, 1), 0.0));
    // Centroid
    CPPUNIT_ASSERT(Verify<CloseTo>(TraceAlgorithm::Centroid(*traceForCentroid, 0, 2), 1.5));
  }

  void
  testBinException1()
  {
    // bins in wrong order
    TraceAlgorithm::Mean(*traceOfDoubles, 2, 0);
  }

  void
  testBinException2()
  {
    // last bin too big
    TraceAlgorithm::Mean(*traceOfDoubles, 0, 999);
  }

  void
  testMultiTrace()
  {
    MultiTraceI mtrace;
    mtrace.AddTrace(3, 10, 0);
    mtrace.GetTrace(0)[0] = 0;
    mtrace.GetTrace(0)[1] = 1;
    mtrace.GetTrace(0)[2] = 2;

    // HasLabel
    CPPUNIT_ASSERT(Verify<Equal>(mtrace.HasLabel(0), true));
    CPPUNIT_ASSERT(Verify<Equal>(mtrace.HasLabel(1), false));

    // Add more traces
    mtrace.AddTrace(*traceOfInts, 1);
    mtrace.AddTrace(*traceOfInts, 2);
    CPPUNIT_ASSERT(Verify<Equal>(mtrace.GetNLabels(), 3U));

    // multitrace accessor
    TraceI& traceSource = mtrace.GetTrace(1);
    CPPUNIT_ASSERT(Verify<Equal>(traceSource[3], 3));

    // multitrace iterator
    {
      int i = 0;
      for (MultiTraceI::Iterator it = mtrace.Begin();
           it != mtrace.End(); ++it, ++i)
        CPPUNIT_ASSERT(Verify<Equal>(it->GetLabel(), i));
    }

    // copy ctor
    {
      int i = 0;
      const MultiTraceI mcopy = mtrace;
      for (MultiTraceI:: ConstIterator it = mcopy.Begin();
           it != mcopy.End(); ++it, ++i) {

        CPPUNIT_ASSERT(Verify<Equal>(it->GetLabel(), i));

        const TraceI ta = it->GetTrace();
        for (int j = 0; j < 3; ++j)
          CPPUNIT_ASSERT(Verify<Equal>(ta[j], j));
      }
    }
    // postincrement
    // TO ADD
  }

  void
  testCtor()
  {
    TraceI t(10, 10, 10);

    for (TraceI::ConstIterator it = t.Begin();
         it != t.End(); ++it)
      CPPUNIT_ASSERT(Verify<Equal>(*it, 10));
  }

};

CPPUNIT_TEST_SUITE_REGISTRATION(testTraces);

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: