RawDAQDataConstructor.h

Go to the documentation of this file.

/* 
 * File:   RawDAQDataConstructor.h
 * Author: denis
 *
 * This is a base class for RawDAQData class constructor
 *
 * Created on September 20, 2012, 2:09 PM
 */

#ifndef RAWDAQDATACONSTRUCTOR_H
#define RAWDAQDATACONSTRUCTOR_H
#include "DAQDataFormats/RawDAQData.h"
#include "UnitTestTrace.h"
#include "messagefacility/MessageLogger/MessageLogger.h"        // LOG_ERROR

#include <boost/lexical_cast.hpp>

#define CHECK_FIELD(FIELD_NAME)                                                                 \
        bool     checkField_##FIELD_NAME(daqdataformats::CURRENT_CLASS* dataformat) const {     \
            if(!setFieldToTestValue_##FIELD_NAME(dataformat)) {                                 \
                    LOG_ERROR("UNITTEST") << std::endl<< __PRETTY_FUNCTION__                    \
                                          <<"\nsetFieldToTestValue_"<<#FIELD_NAME<<" failed.\n" \
                                          <<"Test value = "<<TEST_VALUE_##FIELD_NAME<<"\n";     \
                    if(getVersion(dataformat) > rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)\
                        LOG_ERROR("UNITTEST")<<"version =  "<<getVersion(dataformat)<<"\n";     \
                    return false;                                                               \
            }                                                                                   \
            if(getFieldValue_##FIELD_NAME(dataformat) != TEST_VALUE_##FIELD_NAME){              \
                    LOG_ERROR("UNITTEST") << std::endl<< __PRETTY_FUNCTION__                    \
                                          <<"\ngetFieldToTestValue_"<<#FIELD_NAME<<" failed.\n" \
                                          <<"Test value = "<<TEST_VALUE_##FIELD_NAME            \
                                          <<" but get is "                                      \
                                          << getFieldValue_##FIELD_NAME(dataformat)<<"\n";      \
                    if(getVersion(dataformat) > rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)\
                        LOG_ERROR("UNITTEST")<<"version =  "<<getVersion(dataformat)<<"\n";     \
                    return false;                                                               \
            }                                                                                   \
                                                                                                \
            std::string suceed_string = "Checking BitField in ";                                \
            suceed_string.append(__PRETTY_FUNCTION__);                                          \
            suceed_string.append(" field ");                                                    \
            suceed_string.append(#FIELD_NAME);                                                  \
            suceed_string.append(" suceeded for version =  ");                                  \
            suceed_string.append(boost::lexical_cast<std::string>(getVersion(dataformat)));     \
            suceed_string.append(" (set to ");                                                  \
            suceed_string.append(boost::lexical_cast<std::string>(TEST_VALUE_##FIELD_NAME));    \
            suceed_string.append(" received ");                                                 \
            suceed_string.append(boost::lexical_cast<std::string>(getFieldValue_##FIELD_NAME(dataformat))); \
            suceed_string.append(").");                                                         \
                                                                                                \
            if(!setFieldToZeroValue_##FIELD_NAME(dataformat)){                                  \
                    LOG_ERROR("UNITTEST")<<"\nsetFieldToZeroValue_"<<#FIELD_NAME<<" failed.\n"  \
                             <<"version =  "<<getVersion(dataformat)<<"\n";                     \
                    return false;                                                               \
            }                                                                                   \
            if(getFieldValue_##FIELD_NAME(dataformat) != 0) {                                   \
                    LOG_ERROR("UNITTEST")<<"\ngetFieldValue_"<<#FIELD_NAME<<" failed.\n"        \
                             <<"Should be zero"                                                 \
                             <<" but get is "<<getFieldValue_##FIELD_NAME(dataformat)<<"\n"     \
                             <<"version =  "<<getVersion(dataformat)<<"\n";                     \
                    return false;                                                               \
            }                                                                                   \
            LOG_DEBUG("UNITTEST")<< suceed_string;                                              \
            return true;                                                                        \
        }

#define DEFINE_TESTVALUE_CUSTOM(FIELD_NAME, TYPE) \
        bool     setFieldToTestValue_##FIELD_NAME(daqdataformats::CURRENT_CLASS* dataformat) const {return dataformat->set##FIELD_NAME(boost::lexical_cast< TYPE >(TEST_VALUE_##FIELD_NAME));} \
        bool     setFieldToZeroValue_##FIELD_NAME(daqdataformats::CURRENT_CLASS* dataformat) const {return dataformat->set##FIELD_NAME(boost::lexical_cast< TYPE >(0));}  \
        uint64_t getFieldValue_##FIELD_NAME(const daqdataformats::CURRENT_CLASS* dataformat) const {return boost::lexical_cast<uint64_t> (dataformat->get##FIELD_NAME());} \
        CHECK_FIELD(FIELD_NAME)

#define DEFINE_TESTVALUE(FIELD_NAME)       DEFINE_TESTVALUE_CUSTOM(FIELD_NAME, uint32_t)
#define DEFINE_TESTVALUE_BOOL(FIELD_NAME)  DEFINE_TESTVALUE_CUSTOM(FIELD_NAME, bool)
#define DEFINE_TESTVALUE_64(FIELD_NAME)    DEFINE_TESTVALUE_CUSTOM(FIELD_NAME, uint64_t)

#define DEFINE_TESTVALUE_IS(FIELD_NAME) \
        bool     setFieldToTestValue_##FIELD_NAME(daqdataformats::CURRENT_CLASS* dataformat) const {return dataformat->set##FIELD_NAME(boost::lexical_cast<bool>(TEST_VALUE_##FIELD_NAME));} \
        bool     setFieldToZeroValue_##FIELD_NAME(daqdataformats::CURRENT_CLASS* dataformat) const {return dataformat->set##FIELD_NAME(boost::lexical_cast<bool>(0));}  \
        uint64_t getFieldValue_##FIELD_NAME(const daqdataformats::CURRENT_CLASS* dataformat) const {return boost::lexical_cast<uint64_t> (dataformat->is##FIELD_NAME());} \
        CHECK_FIELD(FIELD_NAME)


/// Assert checking get/set of the the field is good
#define ASSERT_CHECK_FIELD(FIELD_NAME) CPPUNIT_ASSERT(_mainDFConstructor->checkField_##FIELD_NAME(df));

#define ASSERT_PRINT_IS_NOT_UNKNOWN    CPPUNIT_ASSERT(!isPrintDataFormatUnknownVersion(df));

/// Assert that the get method for a field is not allowed
#define ASSERT_GET_IS_NOT_ALLOWED(FIELD_NAME)                       \
        {                                                           \
            bool succeed = true;                                    \
            try{                                                    \
                _mainDFConstructor->getFieldValue_##FIELD_NAME(df); \
            }                                                       \
            catch(daqdataformats::DataFormatException& e){          \
                succeed = false;                                    \
            }                                                       \
            if(succeed){                                            \
                    LOG_ERROR("UNITTEST")<<"Getting "               \
                                         <<#FIELD_NAME              \
                                         <<" succeded."             \
                                         <<"Should have failed\n";  \
            }                                                       \
            CPPUNIT_ASSERT(!succeed);                               \
        }

/// Assert that the set method for a field is not allowed
#define ASSERT_SET_IS_NOT_ALLOWED(FIELD_NAME)                             \
        {                                                                 \
            bool succeed = true;                                          \
            try{                                                          \
                _mainDFConstructor->setFieldToTestValue_##FIELD_NAME(df); \
            }                                                             \
            catch(daqdataformats::DataFormatException& e){                \
                succeed = false;                                          \
            }                                                             \
            if(succeed){                                                  \
                    LOG_ERROR("UNITTEST")<<"Setting "                     \
                                         <<#FIELD_NAME                    \
                                         <<" succeded."                   \
                                         <<"Should have failed\n";        \
            }                                                             \
            CPPUNIT_ASSERT(!succeed);                                     \
        }

/// Assert that both get and set methods for a field are not allowed
#define ASSERT_GETANDSET_IS_NOT_ALLOWED(FIELD_NAME) ASSERT_GET_IS_NOT_ALLOWED(FIELD_NAME) \
                                                    ASSERT_SET_IS_NOT_ALLOWED(FIELD_NAME)



namespace daqdataformats {
class RawDAQDataConstructor {
public:
    RawDAQDataConstructor();
    RawDAQDataConstructor(const version_t);
    virtual ~RawDAQDataConstructor();

    /// method to create a filled dataformat with a given version
    ///
    virtual daqdataformats::RawDAQData* getFilledDataFormat(const version_t) const = 0;
    /// method to create an empty dataformat with a given version
    virtual daqdataformats::RawDAQData* getEmptyDataFormat(const version_t) const = 0;

    /// method to Fill the input dataformat
    virtual bool fillDataFormat(daqdataformats::RawDAQData*)const  = 0;
    /// Get version of the input dataformat
    virtual version_t getVersion(const daqdataformats::RawDAQData*) const { return -1;}

    /// Get maximum version for the dataformat
    version_t  getMaximumVersion() const {return _maximumVersion;}
    
protected:
    /// Bool to uint abd backwards conversions
    uint32_t boolToUint32_t (const bool     number ) const {  return ((number) ? 1 : 0); }
    bool     uint32_tToBool (const uint32_t number ) const {  return ((number) ? true : false); }

protected:

    /// Maximum version of the dataformat
    version_t _maximumVersion;
};
}// end of namespace

#endif  /* RAWDAQDATACONSTRUCTOR_H */