RawDAQDataUnitTest.h

Go to the documentation of this file.

/* 
 * File:   RawDAQDataUnitTest.h
 * Author: denis
 *
 * Base class for RawDAQData unittest
 *
 * Created on September 20, 2012, 4:43 PM
 */

#ifndef RAWDAQDATAUNITTEST_H
#define RAWDAQDATAUNITTEST_H
#include <cppunit/extensions/HelperMacros.h>
//#include "DAQDataFormats/../unittest/RawDAQDataConstructor.h"
#include "RawDAQDataConstructor.h"

#include <DAQDataFormats/DataFormatException.h>

#include <boost/shared_ptr.hpp>

namespace daqdataformats {

/// Perform some action that depends on iver
#define VERSION_LOOP_iver(ACTION)                                                      \
    {                                                                                  \
        const version_t maximum_version = _dataFormatConstructor->getMaximumVersion(); \
        if(maximum_version > rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION) {        \
            for(int iver = 0; iver <= maximum_version; ++iver){                        \
                ACTION;                                                                \
            }                                                                          \
        }                                                                              \
    }
        

/// Assert some action that depends on iver
#define ASSERT_VERSION_LOOP_iver(ACTION) VERSION_LOOP_iver(CPPUNIT_ASSERT(ACTION))

/// Standard function that checks Deep Copy Constructor
#define DEFINE_checkDeepCopyConstructor(CLASS)                                                                 \
         void checkDeepCopyConstructor(){                                                                      \
          LOG_DEBUG("UNITTEST")<<__PRETTY_FUNCTION__<<std::endl;                                               \
          if(_dataFormatConstructor->getMaximumVersion() == rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)   \
                CPPUNIT_ASSERT(checkDeepCopyConstructor(rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION));     \
            else                                                                                               \
                ASSERT_VERSION_LOOP_iver(checkDeepCopyConstructor(iver));                                      \
         }                                                                                                \
         bool checkDeepCopyConstructor(const version_t ver) const {                                       \
            if(ver != rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)                                    \
                LOG_DEBUG("UNITTEST")<<__PRETTY_FUNCTION__<<" for version "<<ver<<std::endl;              \
            boost::shared_ptr<CLASS> format_nonzero((CLASS*)_mainDFConstructor->getFilledDataFormat(ver));\
            CLASS deep_copy(*(format_nonzero.get()));                                                     \
            if(compareDataFormats(format_nonzero.get(), &deep_copy) != DATAFORMATS_ARE_THE_SAME){         \
                LOG_ERROR("UNITTEST")<<"Failure in "<<__PRETTY_FUNCTION__<<" at "<<__LINE__<<"\n"         \
                                     <<"Nonzero format:\n"                                                \
                                     <<*(format_nonzero.get())                                            \
                                     <<"Copied format:\n"                                                 \
                                     <<deep_copy;                                                         \
                return false;                                                                             \
            }                                                                                             \
            return true;                                                                                  \
         }

/// Standard function that checks Shallow Copy Constructor
#define DEFINE_checkShallowCopyConstructor(CLASS)                                                              \
         void checkShallowCopyConstructor() {                                                                  \
            LOG_DEBUG("UNITTEST")<<__PRETTY_FUNCTION__<<std::endl;                                             \
            if(_dataFormatConstructor->getMaximumVersion() == rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION) \
                CPPUNIT_ASSERT(checkShallowCopyConstructor(rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION));  \
            else                                                                                               \
                ASSERT_VERSION_LOOP_iver(checkShallowCopyConstructor(iver));                                   \
         }                                                                                                     \
         bool checkShallowCopyConstructor(const version_t ver) const {                                         \
            if(ver != rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)                                         \
                LOG_DEBUG("UNITTEST")<<__PRETTY_FUNCTION__<<" for version "<<ver<<std::endl;                   \
            boost::shared_ptr<CLASS> format_nonzero((CLASS*)_mainDFConstructor->getFilledDataFormat(ver));     \
            CLASS shallow_copy((void*)(format_nonzero.get()->getBuffer()));                                    \
            if(compareDataFormats(format_nonzero.get(), &shallow_copy) != DATAFORMATS_ARE_THE_SAME){           \
                LOG_ERROR("UNITTEST")<<"Failure in "<<__PRETTY_FUNCTION__<<" at "<<__LINE__<<"\n"              \
                                     <<"Nonzero format:\n"                                                     \
                                     <<*(format_nonzero.get())                                                 \
                                     <<"Copied format:\n"                                                      \
                                     <<shallow_copy;                                                           \
                return false;                                                                                  \
            }                                                                                                  \
            return true;                                                                                       \
         }

#define DEFINE_testReadDataIntoSameVersion                 \
    void testReadDataIntoSameVersion()    {                \
    LOG_DEBUG("UNITTEST")<<__PRETTY_FUNCTION__<<std::endl; \
    CPPUNIT_ASSERT(checkReadDataIntoSameVersion());        \
}

#define DEFINE_testReadDataIntoUnknownVersion \
    void testReadDataIntoUnknownVersion() {LOG_DEBUG("UNITTEST")<<__PRETTY_FUNCTION__<<std::endl; CPPUNIT_ASSERT(checkReadDataIntoUnknownVersion());}

    
/// Enumeration of the two dataformat comparisson results
enum DATAFORMAT_COMPARE_RESULTS{
         DATAFORMATS_ARE_DIFFERENT = 1
        ,DATAFORMATS_ARE_THE_SAME
        ,FIRST_CONTAINS_SECOND
        ,SECOND_CONTAINS_FIRST
};

std::string getNameForResults(const DATAFORMAT_COMPARE_RESULTS res);


/// Base class for RawDAQData unittest
class RawDAQDataUnitTest : public CPPUNIT_NS::TestFixture {
public:
    RawDAQDataUnitTest(RawDAQDataConstructor*);
    ~RawDAQDataUnitTest();

    /// Check all field gets and sets for all versions
    virtual void basicFieldGetAndSetChecks() {
        VERSION_LOOP_iver(basicFieldGetAndSetChecksForGivenVersion(iver));
    };

    /// Check Deep Copy Constructors for all versions
    virtual void checkDeepCopyConstructor()    {};

    /// Check Shallow Copy Constructors for all versions
    virtual void checkShallowCopyConstructor() {};

    /// Some setup/teardown methods that Unittest require
    void setUp()   {}
    void tearDown(){}

protected:

    /// Check all field gets and sets for a given version
    virtual void basicFieldGetAndSetChecksForGivenVersion(const version_t) {};

    /// Check readData for all versions of the dataformat
    bool checkReadDataIntoSameVersion() const;
    /// Check readData for all versions of the dataformat
    bool checkReadDataIntoUnknownVersion() const;

    /// Check constructors - deep copy and shallow copy
    virtual bool checkDeepCopyConstructor   (const version_t) const = 0;
    virtual bool checkShallowCopyConstructor(const version_t) const = 0;

    /// Are the two data formats the same?
    virtual DATAFORMAT_COMPARE_RESULTS compareDataFormats(const RawDAQData*, const RawDAQData*) const;
    virtual bool compareDataFormats(const RawDAQData*, const RawDAQData*, const DATAFORMAT_COMPARE_RESULTS) const;

    /// Sometimes print() can print "DAQDataFormat is of unknown version"
    bool isPrintDataFormatUnknownVersion(const RawDAQData*) const;
    
private:

    /// Check readData of a given version into a dataformat with initially unknown version
    bool checkReadDataIntoUnknownVersion(const version_t) const;
    /// Check readData of a given version into a dataformat with initially same version
    bool checkReadDataIntoSameVersion   (const version_t) const;

    /// Check readData of a given version into a dataformat with a different version
    /// It is allowed to have either
    /// 1. (initialformat_version == readingformat_version) AND (initialformat_version != UnknownVersion)
    /// 2. (initialformat_version != UnknownVersion) AND (readingformat_version == UnknownVersion)
    bool checkReadData(const version_t initialformat_version, const version_t readingformat_version) const;

    /// Resize input vector to at least the size of the input dataformats
    bool resizeBufferToSizeOfDataFormats(std::vector<uint32_t>&, const RawDAQData*) const;
    
    /// Resize input vector to the maximum size of two input dataformats
    bool resizeBufferToSizeOfDataFormats(std::vector<uint32_t>&, const RawDAQData*, const RawDAQData*) const;

    std::string getDifferenceBetweenStrings(const std::string, const std::string) const;
    std::string getDifferenceBetweenStrings(const RawDAQData*, const RawDAQData*) const;

protected:
    /// Pointer to RawDAQDataConstructor
    RawDAQDataConstructor*  _dataFormatConstructor;

};

}// end of namespace

#endif  /* RAWDAQDATAUNITTEST_H */