main.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "data_stream_assert.h"
#include "data_size.h"
 
 
bool checkValue(const std::string & testName, size_t givenSize, size_t referenceSize){
//      std::cout << "checkValue : "<<testName<<" => " << givenSize << ", reference ("<<referenceSize<<")" << std::endl;
        if(givenSize != referenceSize){std::cerr << "checkValue : "<<testName<<" wrong size givenSize("<<givenSize<<") != referenceSize("<<referenceSize<<")" << std::endl;}
        return givenSize == referenceSize;
}
 
void testSimpleDataSize(){
        long unsigned int dataUint64(42lu);
        size_t sizeUint64 = data_size(dataUint64);
        data_stream_assert(checkValue("long unsigned int", sizeUint64, 8lu));
        
        unsigned int dataUint32(42lu);
        size_t sizeUint32 = data_size(dataUint32);
        data_stream_assert(checkValue("unsigned int", sizeUint32, 4lu));
        
        unsigned short dataUint16(42lu);
        size_t sizeUint16 = data_size(dataUint16);
        data_stream_assert(checkValue("unsigned short", sizeUint16, 2lu));
        
        unsigned char dataUint8(42lu);
        size_t sizeUint8 = data_size(dataUint8);
        data_stream_assert(checkValue("unsigned char", sizeUint8, 1lu));
        
        size_t dataint64(42lu);
        size_t sizeint64 = data_size(dataint64);
        data_stream_assert(checkValue("long int", sizeint64, 8lu));
        
        int dataint32(42lu);
        size_t sizeint32 = data_size(dataint32);
        data_stream_assert(checkValue("int", sizeint32, 4lu));
        
        short dataint16(42lu);
        size_t sizeint16 = data_size(dataint16);
        data_stream_assert(checkValue("short", sizeint16, 2lu));
        
        char dataint8(42lu);
        size_t sizeint8 = data_size(dataint8);
        data_stream_assert(checkValue("char", sizeint8, 1lu));
}
 
void testVectorDataSize(){
        size_t nbValue(10lu);
        
        std::vector<long unsigned int> vecUInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(i);}
        size_t sizeVecUint64 = data_size(vecUInt64);
        data_stream_assert(checkValue("std::vector<long unsigned int>", sizeVecUint64, 8lu*nbValue + 8lu));
        
        std::vector<unsigned int> vecUInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(i);}
        size_t sizeVecUint32 = data_size(vecUInt32);
        data_stream_assert(checkValue("std::vector<unsigned int>", sizeVecUint32, 4lu*nbValue + 8lu));
        
        std::vector<unsigned short> vecUInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(i);}
        size_t sizeVecUint16 = data_size(vecUInt16);
        data_stream_assert(checkValue("std::vector<unsigned short>", sizeVecUint16, 2lu*nbValue + 8lu));
        
        std::vector<unsigned char> vecUInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(i);}
        size_t sizeVecUint8 = data_size(vecUInt8);
        data_stream_assert(checkValue("std::vector<unsigned char>", sizeVecUint8, 1lu*nbValue + 8lu));
        
        
        std::vector<long int> vecInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(i);}
        size_t sizeVecInt64 = data_size(vecInt64);
        data_stream_assert(checkValue("std::vector<long int>", sizeVecInt64, 8lu*nbValue + 8lu));
        
        std::vector<int> vecInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(i);}
        size_t sizeVecInt32 = data_size(vecInt32);
        data_stream_assert(checkValue("std::vector<int>", sizeVecInt32, 4lu*nbValue + 8lu));
        
        std::vector<short> vecInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(i);}
        size_t sizeVecInt16 = data_size(vecInt16);
        data_stream_assert(checkValue("std::vector<short>", sizeVecInt16, 2lu*nbValue + 8lu));
        
        std::vector<char> vecInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(i);}
        size_t sizeVecInt8 = data_size(vecInt8);
        data_stream_assert(checkValue("std::vector<char>", sizeVecInt8, 1lu*nbValue + 8lu));
}
 
void testListDataSize(){
        size_t nbValue(10lu);
        
        std::list<long unsigned int> vecUInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(i);}
        size_t sizeVecUint64 = data_size(vecUInt64);
        data_stream_assert(checkValue("std::list<long unsigned int>", sizeVecUint64, 8lu*nbValue + 8lu));
        
        std::list<unsigned int> vecUInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(i);}
        size_t sizeVecUint32 = data_size(vecUInt32);
        data_stream_assert(checkValue("std::list<unsigned int>", sizeVecUint32, 4lu*nbValue + 8lu));
        
        std::list<unsigned short> vecUInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(i);}
        size_t sizeVecUint16 = data_size(vecUInt16);
        data_stream_assert(checkValue("std::list<unsigned short>", sizeVecUint16, 2lu*nbValue + 8lu));
        
        std::list<unsigned char> vecUInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(i);}
        size_t sizeVecUint8 = data_size(vecUInt8);
        data_stream_assert(checkValue("std::list<unsigned char>", sizeVecUint8, 1lu*nbValue + 8lu));
        
        
        std::list<long int> vecInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(i);}
        size_t sizeVecInt64 = data_size(vecInt64);
        data_stream_assert(checkValue("std::list<long int>", sizeVecInt64, 8lu*nbValue + 8lu));
        
        std::list<int> vecInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(i);}
        size_t sizeVecInt32 = data_size(vecInt32);
        data_stream_assert(checkValue("std::list<int>", sizeVecInt32, 4lu*nbValue + 8lu));
        
        std::list<short> vecInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(i);}
        size_t sizeVecInt16 = data_size(vecInt16);
        data_stream_assert(checkValue("std::list<short>", sizeVecInt16, 2lu*nbValue + 8lu));
        
        std::list<char> vecInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(i);}
        size_t sizeVecInt8 = data_size(vecInt8);
        data_stream_assert(checkValue("std::list<char>", sizeVecInt8, 1lu*nbValue + 8lu));
}
 
void testMapDataSize(){
        size_t nbValue(10lu);
        
        std::map<long unsigned int, long unsigned int> mapUInt64UInt64;
        for(size_t i(0lu); i < nbValue; ++i){mapUInt64UInt64[i] = i;}
        size_t sizeMapUint64Uint64 = data_size(mapUInt64UInt64);
        data_stream_assert(checkValue("std::map<long unsigned int, long unsigned int>", sizeMapUint64Uint64, 8lu*nbValue + 8lu*nbValue + 8lu));
        
        std::map<unsigned short, unsigned int> mapUInt16UInt32;
        for(size_t i(0lu); i < nbValue; ++i){mapUInt16UInt32[i] = i;}
        size_t sizeMapUint16Uint32 = data_size(mapUInt16UInt32);
        data_stream_assert(checkValue("std::map<unsigned short, unsigned int>", sizeMapUint16Uint32, 2lu*nbValue + 4lu*nbValue + 8lu));
        
        std::map<long int, long int> mapInt64Int64;
        for(size_t i(0lu); i < nbValue; ++i){mapInt64Int64[i] = i;}
        size_t sizeMapInt64Int64 = data_size(mapInt64Int64);
        data_stream_assert(checkValue("std::map<long int, long int>", sizeMapInt64Int64, 8lu*nbValue + 8lu*nbValue + 8lu));
        
        std::map<short, int> mapInt16Int32;
        for(size_t i(0lu); i < nbValue; ++i){mapInt16Int32[i] = i;}
        size_t sizeMapInt16Int32 = data_size(mapInt16Int32);
        data_stream_assert(checkValue("std::map<short, int>", sizeMapInt16Int32, 2lu*nbValue + 4lu*nbValue + 8lu));
}
 
void testVectorPairDataSize(){
        size_t nbValue(10lu);
        
        std::vector<std::pair<long unsigned int, long unsigned int> > vecUInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(std::pair<long unsigned int, long unsigned int>(i,i));}
        size_t sizeVecUint64 = data_size(vecUInt64);
        data_stream_assert(checkValue("std::vector<std::pair<long unsigned int, long unsigned int> >", sizeVecUint64, 2lu*8lu*nbValue + 8lu));
        
        std::vector<std::pair<unsigned int, unsigned int> > vecUInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(std::pair<unsigned int, unsigned int>(i,i));}
        size_t sizeVecUint32 = data_size(vecUInt32);
        data_stream_assert(checkValue("std::vector<std::pair<unsigned int, unsigned int> >", sizeVecUint32, 2lu*4lu*nbValue + 8lu));
        
        std::vector<std::pair<unsigned short, unsigned short> > vecUInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(std::pair<unsigned short, unsigned short>(i,i));}
        size_t sizeVecUint16 = data_size(vecUInt16);
        data_stream_assert(checkValue("std::vector<std::pair<unsigned short, unsigned short> >", sizeVecUint16, 2lu*2lu*nbValue + 8lu));
        
        std::vector<std::pair<unsigned char, unsigned char> > vecUInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(std::pair<unsigned char, unsigned char>(i,i));}
        size_t sizeVecUint8 = data_size(vecUInt8);
        data_stream_assert(checkValue("std::vector<std::pair<unsigned char, unsigned char> >", sizeVecUint8, 2lu*1lu*nbValue + 8lu));
        
        
        std::vector<std::pair<long int, long int> > vecInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(std::pair<long int, long int>(i,i));}
        size_t sizeVecInt64 = data_size(vecInt64);
        data_stream_assert(checkValue("std::vector<std::pair<long int, long int> >", sizeVecInt64, 2lu*8lu*nbValue + 8lu));
        
        std::vector<std::pair<int,int> > vecInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(std::pair<int,int>(i,i));}
        size_t sizeVecInt32 = data_size(vecInt32);
        data_stream_assert(checkValue("std::vector<std::pair<int,int> >", sizeVecInt32, 2lu*4lu*nbValue + 8lu));
        
        std::vector<std::pair<short, short> > vecInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(std::pair<short, short>(i,i));}
        size_t sizeVecInt16 = data_size(vecInt16);
        data_stream_assert(checkValue("std::vector<std::pair<short, short> >", sizeVecInt16, 2lu*2lu*nbValue + 8lu));
        
        std::vector<std::pair<char, char> > vecInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(std::pair<char, char>(i,i));}
        size_t sizeVecInt8 = data_size(vecInt8);
        data_stream_assert(checkValue("std::vector<std::pair<char, char> >", sizeVecInt8, 2lu*1lu*nbValue + 8lu));
}
 
void testListPairDataSize(){
        size_t nbValue(10lu);
        
        std::list<std::pair<long unsigned int, long unsigned int> > vecUInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(std::pair<long unsigned int, long unsigned int>(i,i));}
        size_t sizeVecUint64 = data_size(vecUInt64);
        data_stream_assert(checkValue("std::list<std::pair<long unsigned int, long unsigned int> >", sizeVecUint64, 2lu*8lu*nbValue + 8lu));
        
        std::list<std::pair<unsigned int, unsigned int> > vecUInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(std::pair<unsigned int, unsigned int>(i,i));}
        size_t sizeVecUint32 = data_size(vecUInt32);
        data_stream_assert(checkValue("std::list<std::pair<unsigned int, unsigned int> >", sizeVecUint32, 2lu*4lu*nbValue + 8lu));
        
        std::list<std::pair<unsigned short, unsigned short> > vecUInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(std::pair<unsigned short, unsigned short>(i,i));}
        size_t sizeVecUint16 = data_size(vecUInt16);
        data_stream_assert(checkValue("std::list<std::pair<unsigned short, unsigned short> >", sizeVecUint16, 2lu*2lu*nbValue + 8lu));
        
        std::list<std::pair<unsigned char, unsigned char> > vecUInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(std::pair<unsigned char, unsigned char>(i,i));}
        size_t sizeVecUint8 = data_size(vecUInt8);
        data_stream_assert(checkValue("std::list<std::pair<unsigned char, unsigned char> >", sizeVecUint8, 2lu*1lu*nbValue + 8lu));
        
        
        std::list<std::pair<long int, long int> > vecInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(std::pair<long int, long int>(i,i));}
        size_t sizeVecInt64 = data_size(vecInt64);
        data_stream_assert(checkValue("std::list<std::pair<long int, long int> >", sizeVecInt64, 2lu*8lu*nbValue + 8lu));
        
        std::list<std::pair<int,int> > vecInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(std::pair<int,int>(i,i));}
        size_t sizeVecInt32 = data_size(vecInt32);
        data_stream_assert(checkValue("std::list<std::pair<int,int> >", sizeVecInt32, 2lu*4lu*nbValue + 8lu));
        
        std::list<std::pair<short, short> > vecInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(std::pair<short, short>(i,i));}
        size_t sizeVecInt16 = data_size(vecInt16);
        data_stream_assert(checkValue("std::list<std::pair<short, short> >", sizeVecInt16, 2lu*2lu*nbValue + 8lu));
        
        std::list<std::pair<char, char> > vecInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(std::pair<char, char>(i,i));}
        size_t sizeVecInt8 = data_size(vecInt8);
        data_stream_assert(checkValue("std::list<std::pair<char, char> >", sizeVecInt8, 2lu*1lu*nbValue + 8lu));
}
 
void testStringDataSize(){
        std::string str("One thing to say");
        size_t sizeStr = data_size(str);
        data_stream_assert(checkValue("std::string", sizeStr, 16lu + 8lu));
}
 
int main(int argc, char** argv){
        testSimpleDataSize();
        testVectorDataSize();
        testListDataSize();
        testMapDataSize();
        testVectorPairDataSize();
        testListPairDataSize();
        testStringDataSize();
        return 0;
}