testValidatrix.cc

Go to the documentation of this file.

#include <fstream>
#include <stdlib.h>
#include <boost/format.hpp>
#include <cppunit/extensions/HelperMacros.h>
#include <utl/System.h>
#include <tst/Verify.h>
#include <tst/Validatrix.h>
#include <utl/Trace.h>
#include <utl/AugerUnits.h>

using namespace tst::Validatrix;
using namespace std;
using namespace boost;
//using utl::TraceD;
using utl::nanosecond;




class TestValidatrix : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(TestValidatrix);
  CPPUNIT_TEST(TestBuiltin);
  CPPUNIT_TEST(TestBuiltinFail);
  CPPUNIT_TEST(TestTraceD);
  CPPUNIT_TEST(TestVectorUnsignedShort);
  CPPUNIT_TEST(TestVectorUnsignedShortFail);
  CPPUNIT_TEST(TestZeroLengthVector);
  CPPUNIT_TEST_EXCEPTION(TestEmptyStreams, utl::DoesNotComputeException);
  CPPUNIT_TEST_SUITE_END();

  template<int n, class FStream>
  class Streams {
  public:
    Streams(const string& prefix)
    {
      for (int i = 0; i < n; ++i) {
        fFilename[i] = (format("%1%%2%.trx") % prefix % i).str();
        fStream[i].open(fFilename[i].c_str());
        CPPUNIT_ASSERT(fStream[i].is_open());
      }
    }

    ~Streams() { Close(); }

    template<int i>
    FStream& Get() { return fStream[i]; }

    void
    Delete()
    {
      Close();
      string command = "rm";
      for (int i = 0; i < n; ++i)
        command.append(string(" ") + fFilename[i]);
      utl::System(command);
    }
  
  private:
    void
    Close()
    {
      for (int i = 0; i < n; ++i)
        if (fStream[i].is_open())
          fStream[i].close();
    }

    Streams(const Streams&);
    Streams& operator=(const Streams&);
    
    FStream fStream[n];
    string fFilename[n];
  };

public:
  void setUp() { }

  void tearDown() { }

  void
  TestBuiltin()
  {
    const string prefix = "foo_1_";
    {
      Streams<2, ofstream> f(prefix);

      int i = 13;
      unsigned u = 100;
      double d = 3.14;
      double dd = 137;

      f.Get<0>() << BeLabel("test") << BeEqual(i) << BeEqual(u) << BeCloseAbs(d) << BeCloseRel(dd);
      f.Get<1>() << BeLabel("test") << BeEqual(i) << BeEqual(u) << BeCloseAbs(d) << BeCloseRel(dd);
    }

    {
      Streams<2, ifstream> f(prefix);

      const bool test = Compare(f.Get<0>(), f.Get<1>());
      CPPUNIT_ASSERT(test);

      if (test)
        f.Delete();
    }
  }

  void
  TestBuiltinFail()
  {
    const string prefix = "foo_2_";
    {
      Streams<2, ofstream> f(prefix);

      int i = 13;
      unsigned u = 100;
      double d = 3.14;
      double dd = 137;

      f.Get<0>()
        << BeLabel("test")
        << BeEqual(i) << BeEqual(u) << BeCloseAbs(d) << BeCloseRel(dd);
      f.Get<1>()
        << BeLabel("tast")
        << BeEqual(i-1) << BeEqual(u+1) << BeCloseAbs(d+0.1) << BeCloseRel(dd*1.01);
    }

    {
      Streams<2, ifstream> f(prefix);

      tst::Expected();
      const bool test = Compare(f.Get<0>(), f.Get<1>(), /*failOnFirst=*/false);
      CPPUNIT_ASSERT(!test);

      if (!test)
        f.Delete();
    }
  }

  void
  TestTraceD()
  {
    const string prefix = "foo_3_";
    {
      Streams<2, ofstream> f(prefix);

      const int size = 768;
      utl::TraceD trace(size, 25*nanosecond);

      for (int i = 0; i < size; ++i)
        trace[i] = 3.14*(i+1);

      f.Get<0>()
        << BeLabel("some trace shit")
        << BeCloseRel(trace) << endl
        << BeLabel("again")
        << BeCloseAbs(trace, /*tolerance*/1);

      // this should not cross the default tolerance
      for (int i = 0; i < size; ++i)
        trace[i] += 1e-8;

      f.Get<1>()
        << BeLabel("some trace shit")
        << BeCloseRel(trace) << endl;

      // this should not cross the absolute tolerance of 1
      for (int i = 0; i < size; ++i)
        trace[i] += 0.5;

      f.Get<1>()
        << BeLabel("again")
        << BeCloseAbs(trace, 1);
    }
    {
      Streams<2, ifstream> f(prefix);

      const bool test = Compare(f.Get<0>(), f.Get<1>());
      CPPUNIT_ASSERT(test);

      if (test)
        f.Delete();
    }
  }

  void
  TestVectorUnsignedShort()
  {
    const string prefix = "foo_4_";
    {
      Streams<2, ofstream> f(prefix);

      vector<unsigned short> vec(100, 13U);
      for (int i = 50; i < 60; ++i)
        vec[i] = (unsigned short)(i);

      f.Get<0>() << BeLabel("some vector shit") << BeEqual(vec);
      f.Get<1>() << BeLabel("some vector shit") << BeEqual(vec);
    }
    {
     Streams<2, ifstream> f(prefix);

      const bool test = Compare(f.Get<0>(), f.Get<1>());
      CPPUNIT_ASSERT(test);

      if (test)
        f.Delete();
    }
  }

  void
  TestVectorUnsignedShortFail()
  {
    const string prefix = "foo_5_";
    {
      Streams<2, ofstream> f(prefix);

      vector<unsigned short> vec1(100, 13U);
      for (int i = 50; i < 60; ++i)
        vec1[i] = (unsigned short)(i);
      vector<unsigned short> vec2 = vec1;
      vec2[99] = 0U;

      f.Get<0>() << BeLabel("some vector shit") << BeEqual(vec1);
      f.Get<1>() << BeLabel("some vector shit") << BeEqual(vec2);
    }
    {
     Streams<2, ifstream> f(prefix);

      const bool test = Compare(f.Get<0>(), f.Get<1>());
      CPPUNIT_ASSERT(!test);

      if (!test)
        f.Delete();
    }
  }

  void
  TestZeroLengthVector()
  {
    const string prefix = "foo_6_";
    {
      Streams<2, ofstream> f(prefix);

      vector<double> vec;

      f.Get<0>() << BeLabel("empty vector") << BeEqual(vec);
      f.Get<1>() << BeLabel("empty vector") << BeEqual(vec);
    }
    {
     Streams<2, ifstream> f(prefix);

      const bool test = Compare(f.Get<0>(), f.Get<1>());
      CPPUNIT_ASSERT(test);

      if (test)
        f.Delete();
    }
  }

  void
  TestEmptyStreams()
  {
    {
      ofstream f1("f1.trx");
      f1 << BeEqual(1);
    }

    ifstream f1("f1.trx");
    ifstream f2("f2.trx");
    const bool test = Compare(f1, f2);
    CPPUNIT_ASSERT(!test);
    f2.close();
    utl::System("rm f1.trx f2.trx");
  }

};


CPPUNIT_TEST_SUITE_REGISTRATION(TestValidatrix);


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