main.cpp File Reference

#include "data_stream_assert.h"
#include "data_stream_check_value.h"
#include "data_size.h"
#include "data_message.h"

Include dependency graph for main.cpp:

Go to the source code of this file.

Functions
int	main (int argc, char **argv)
void	testListDataMessage ()
	Test if data size is Ok. More...
void	testListPairDataMessage ()
	Test if data size is Ok. More...
void	testMapDataMessage ()
	Test if data size is Ok. More...
void	testSimpleDataMessage ()
	Test if data size is Ok. More...
void	testStringDataMessage ()
	Test if data size is Ok. More...
void	testVectorDataMessage ()
	Test if data size is Ok. More...
void	testVectorPairDataMessage ()
	Test if data size is Ok. More...

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 563 of file main.cpp.

                               {
        testSimpleDataMessage();
        testVectorDataMessage();
        testListDataMessage();
        testMapDataMessage();
        testVectorPairDataMessage();
        testListPairDataMessage();
        testStringDataMessage();
        return 0;
}

References testListDataMessage(), testListPairDataMessage(), testMapDataMessage(), testSimpleDataMessage(), testStringDataMessage(), testVectorDataMessage(), and testVectorPairDataMessage().

Here is the call graph for this function:

testListDataMessage()

void testListDataMessage

(

)

Test if data size is Ok.

Definition at line 222 of file main.cpp.

                          {
        size_t nbValue(10lu);
        
        std::list<long unsigned int> vecUInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(i);}
        std::vector<char> messageUInt64(data_size(vecUInt64));
        //Put data in message
        char* iterUInt64 = (char*)messageUInt64.data();
        data_stream_assert(data_message_save(iterUInt64, vecUInt64));                   //Save the message
        char* loadIterUInt64 = (char*)messageUInt64.data();
        std::list<long unsigned int> outVecUInt64(0lu);
        data_stream_assert(data_message_load(loadIterUInt64, outVecUInt64));            //Load the message
        data_stream_assert(checkValue("std::list<long unsigned int>", outVecUInt64, vecUInt64));
        
        std::list<unsigned int> vecUInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(i);}
        std::vector<char> messageUInt32(data_size(vecUInt32));
        //Put data in message
        char* iterUInt32 = (char*)messageUInt32.data();
        data_stream_assert(data_message_save(iterUInt32, vecUInt32));                   //Save the message
        char* loadIterUInt32 = (char*)messageUInt32.data();
        std::list<unsigned int> outVecUInt32(0lu);
        data_stream_assert(data_message_load(loadIterUInt32, outVecUInt32));            //Load the message
        data_stream_assert(checkValue("std::list<unsigned int>", outVecUInt32, vecUInt32));
        
        std::list<unsigned short> vecUInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(i);}
        std::vector<char> messageUInt16(data_size(vecUInt16));
        //Put data in message
        char* iterUInt16 = (char*)messageUInt16.data();
        data_stream_assert(data_message_save(iterUInt16, vecUInt16));                   //Save the message
        char* loadIterUInt16 = (char*)messageUInt16.data();
        std::list<unsigned short> outVecUInt16(0lu);
        data_stream_assert(data_message_load(loadIterUInt16, outVecUInt16));            //Load the message
        data_stream_assert(checkValue("std::list<unsigned short>", outVecUInt16, vecUInt16));
        
        std::list<unsigned char> vecUInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(i);}
        std::vector<char> messageUInt8(data_size(vecUInt8));
        //Put data in message
        char* iterUInt8 = (char*)messageUInt8.data();
        data_stream_assert(data_message_save(iterUInt8, vecUInt8));                     //Save the message
        char* loadIterUInt8 = (char*)messageUInt8.data();
        std::list<unsigned char> outVecUInt8(0lu);
        data_stream_assert(data_message_load(loadIterUInt8, outVecUInt8));              //Load the message
        data_stream_assert(checkValue("std::list<unsigned char>", outVecUInt8, vecUInt8));
        
        
        std::list<long int> vecInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(i);}
        std::vector<char> messageInt64(data_size(vecInt64));
        //Put data in message
        char* iterInt64 = (char*)messageInt64.data();
        data_stream_assert(data_message_save(iterInt64, vecInt64));                     //Save the message
        char* loadIterInt64 = (char*)messageInt64.data();
        std::list<long int> outVecInt64(0lu);
        data_stream_assert(data_message_load(loadIterInt64, outVecInt64));              //Load the message
        data_stream_assert(checkValue("std::list<long int>", outVecInt64, vecInt64));
        
        std::list<int> vecInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(i);}
        std::vector<char> messageInt32(data_size(vecInt32));
        //Put data in message
        char* iterInt32 = (char*)messageInt32.data();
        data_stream_assert(data_message_save(iterInt32, vecInt32));                     //Save the message
        char* loadIterInt32 = (char*)messageInt32.data();
        std::list<int> outVecInt32(0lu);
        data_stream_assert(data_message_load(loadIterInt32, outVecInt32));              //Load the message
        data_stream_assert(checkValue("std::list<int>", outVecInt32, vecInt32));
        
        std::list<short> vecInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(i);}
        std::vector<char> messageInt16(data_size(vecInt16));
        //Put data in message
        char* iterInt16 = (char*)messageInt16.data();
        data_stream_assert(data_message_save(iterInt16, vecInt16));                     //Save the message
        char* loadIterInt16 = (char*)messageInt16.data();
        std::list<short> outVecInt16(0lu);
        data_stream_assert(data_message_load(loadIterInt16, outVecInt16));              //Load the message
        data_stream_assert(checkValue("std::list<short>", outVecInt16, vecInt16));
        
        std::list<char> vecInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(i);}
        std::vector<char> messageInt8(data_size(vecInt8));
        //Put data in message
        char* iterInt8 = (char*)messageInt8.data();
        data_stream_assert(data_message_save(iterInt8, vecInt8));                       //Save the message
        char* loadIterInt8 = (char*)messageInt8.data();
        std::list<char> outVecInt8(0lu);
        data_stream_assert(data_message_load(loadIterInt8, outVecInt8));                //Load the message
        data_stream_assert(checkValue("std::list<char>", outVecInt8, vecInt8));
}

References checkValue(), data_message_load(), data_message_save(), data_size(), and data_stream_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testListPairDataMessage()

void testListPairDataMessage

(

)

Test if data size is Ok.

Definition at line 504 of file main.cpp.

                              {
        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));
}

References checkValue(), data_size(), and data_stream_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testMapDataMessage()

void testMapDataMessage

(

)

Test if data size is Ok.

Definition at line 316 of file main.cpp.

                         {
        size_t nbValue(10lu);
        
        std::map<long unsigned int, long unsigned int> mapUInt64UInt64;
        for(size_t i(0lu); i < nbValue; ++i){mapUInt64UInt64[i] = 2lu*i;}
        std::vector<char> messageUInt64UInt64(data_size(mapUInt64UInt64));
        //Put data in message
        char* iterUIntUInt64 = (char*)messageUInt64UInt64.data();
        data_stream_assert(data_message_save(iterUIntUInt64, mapUInt64UInt64));                 //Save the message
        char* loadIterUIntUInt64 = (char*)messageUInt64UInt64.data();
        std::map<long unsigned int, long unsigned int> outVecUInt64UInt64;
        data_stream_assert(data_message_load(loadIterUIntUInt64, outVecUInt64UInt64));          //Load the message
        data_stream_assert(checkValue("std::map<long unsigned int, long unsigned int>", outVecUInt64UInt64, mapUInt64UInt64));
        
        std::map<unsigned int, unsigned int> mapUInt32UInt32;
        for(size_t i(0lu); i < nbValue; ++i){mapUInt32UInt32[i] = 2lu*i;}
        std::vector<char> messageUInt32UInt32(data_size(mapUInt32UInt32));
        //Put data in message
        char* iterUIntUInt32 = (char*)messageUInt32UInt32.data();
        data_stream_assert(data_message_save(iterUIntUInt32, mapUInt32UInt32));                 //Save the message
        char* loadIterUIntUInt32 = (char*)messageUInt32UInt32.data();
        std::map<unsigned int, unsigned int> outVecUInt32UInt32;
        data_stream_assert(data_message_load(loadIterUIntUInt32, outVecUInt32UInt32));          //Load the message
        data_stream_assert(checkValue("std::map<unsigned int, unsigned int>", outVecUInt32UInt32, mapUInt32UInt32));
        
        std::map<unsigned short, unsigned short> mapUInt16UInt16;
        for(size_t i(0lu); i < nbValue; ++i){mapUInt16UInt16[i] = 2lu*i;}
        std::vector<char> messageUInt16UInt16(data_size(mapUInt16UInt16));
        //Put data in message
        char* iterUIntUInt16 = (char*)messageUInt16UInt16.data();
        data_stream_assert(data_message_save(iterUIntUInt16, mapUInt16UInt16));                 //Save the message
        char* loadIterUIntUInt16 = (char*)messageUInt16UInt16.data();
        std::map<unsigned short, unsigned short> outVecUInt16UInt16;
        data_stream_assert(data_message_load(loadIterUIntUInt16, outVecUInt16UInt16));          //Load the message
        data_stream_assert(checkValue("std::map<unsigned short, unsigned short>", outVecUInt16UInt16, mapUInt16UInt16));
        
        std::map<unsigned char, unsigned char> mapUInt8UInt8;
        for(size_t i(0lu); i < nbValue; ++i){mapUInt8UInt8[i] = 2lu*i;}
        std::vector<char> messageUInt8UInt8(data_size(mapUInt8UInt8));
        //Put data in message
        char* iterUIntUInt8 = (char*)messageUInt8UInt8.data();
        data_stream_assert(data_message_save(iterUIntUInt8, mapUInt8UInt8));                    //Save the message
        char* loadIterUIntUInt8 = (char*)messageUInt8UInt8.data();
        std::map<unsigned char, unsigned char> outVecUInt8UInt8;
        data_stream_assert(data_message_load(loadIterUIntUInt8, outVecUInt8UInt8));             //Load the message
        data_stream_assert(checkValue("std::map<unsigned char, unsigned char>", outVecUInt8UInt8, mapUInt8UInt8));
        
        
        std::map<long int, long int> mapInt64Int64;
        for(size_t i(0lu); i < nbValue; ++i){mapInt64Int64[i] = 2lu*i;}
        std::vector<char> messageInt64Int64(data_size(mapInt64Int64));
        //Put data in message
        char* iterIntInt64 = (char*)messageInt64Int64.data();
        data_stream_assert(data_message_save(iterIntInt64, mapInt64Int64));                     //Save the message
        char* loadIterIntInt64 = (char*)messageInt64Int64.data();
        std::map<long int, long int> outVecInt64Int64;
        data_stream_assert(data_message_load(loadIterIntInt64, outVecInt64Int64));              //Load the message
        data_stream_assert(checkValue("std::map<long int, long int>", outVecInt64Int64, mapInt64Int64));
        
        std::map<int, int> mapInt32Int32;
        for(size_t i(0lu); i < nbValue; ++i){mapInt32Int32[i] = 2lu*i;}
        std::vector<char> messageInt32Int32(data_size(mapInt32Int32));
        //Put data in message
        char* iterIntInt32 = (char*)messageInt32Int32.data();
        data_stream_assert(data_message_save(iterIntInt32, mapInt32Int32));                     //Save the message
        char* loadIterIntInt32 = (char*)messageInt32Int32.data();
        std::map<int, int> outVecInt32Int32;
        data_stream_assert(data_message_load(loadIterIntInt32, outVecInt32Int32));              //Load the message
        data_stream_assert(checkValue("std::map<int, int>", outVecInt32Int32, mapInt32Int32));
        
        std::map<short, short> mapInt16Int16;
        for(size_t i(0lu); i < nbValue; ++i){mapInt16Int16[i] = 2lu*i;}
        std::vector<char> messageInt16Int16(data_size(mapInt16Int16));
        //Put data in message
        char* iterIntInt16 = (char*)messageInt16Int16.data();
        data_stream_assert(data_message_save(iterIntInt16, mapInt16Int16));                     //Save the message
        char* loadIterIntInt16 = (char*)messageInt16Int16.data();
        std::map<short, short> outVecInt16Int16;
        data_stream_assert(data_message_load(loadIterIntInt16, outVecInt16Int16));              //Load the message
        data_stream_assert(checkValue("std::map<short, short>", outVecInt16Int16, mapInt16Int16));
        
        std::map<char, char> mapInt8Int8;
        for(size_t i(0lu); i < nbValue; ++i){mapInt8Int8[i] = 2lu*i;}
        std::vector<char> messageInt8Int8(data_size(mapInt8Int8));
        //Put data in message
        char* iterIntInt8 = (char*)messageInt8Int8.data();
        data_stream_assert(data_message_save(iterIntInt8, mapInt8Int8));                        //Save the message
        char* loadIterIntInt8 = (char*)messageInt8Int8.data();
        std::map<char, char> outVecInt8Int8;
        data_stream_assert(data_message_load(loadIterIntInt8, outVecInt8Int8));         //Load the message
        data_stream_assert(checkValue("std::map<char, char>", outVecInt8Int8, mapInt8Int8));
}

References checkValue(), data_message_load(), data_message_save(), data_size(), and data_stream_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testSimpleDataMessage()

void testSimpleDataMessage

(

)

Test if data size is Ok.

Definition at line 14 of file main.cpp.

                            {
        long unsigned int dataUInt64(42lu);
        std::vector<char> messageUInt64(data_size(dataUInt64));
        //Put data in message
        char* iterUInt64 = (char*)messageUInt64.data();
        data_stream_assert(data_message_save(iterUInt64, dataUInt64));                  //Save the message
        char* loadIterUInt64 = (char*)messageUInt64.data();
        long unsigned int outUInt64(0lu);
        data_stream_assert(data_message_load(loadIterUInt64, outUInt64));               //Load the message
        data_stream_assert(checkValue("long unsigned int", dataUInt64, outUInt64));
        
        unsigned int dataUInt32(42u);
        std::vector<char> messageUInt32(data_size(dataUInt32));
        //Put data in message
        char* iterUInt32 = (char*)messageUInt32.data();
        data_stream_assert(data_message_save(iterUInt32, dataUInt32));                  //Save the message
        char* loadIterUInt32 = (char*)messageUInt32.data();
        unsigned int outUInt32(0lu);
        data_stream_assert(data_message_load(loadIterUInt32, outUInt32));               //Load the message
        data_stream_assert(checkValue("unsigned int", dataUInt32, outUInt32));
        
        unsigned short dataUInt16(42u);
        std::vector<char> messageUInt16(data_size(dataUInt16));
        //Put data in message
        char* iterUInt16 = (char*)messageUInt16.data();
        data_stream_assert(data_message_save(iterUInt16, dataUInt32));                  //Save the message
        char* loadIterUInt16 = (char*)messageUInt16.data();
        unsigned short outUInt16(0lu);
        data_stream_assert(data_message_load(loadIterUInt16, outUInt16));               //Load the message
        data_stream_assert(checkValue("unsigned short", dataUInt16, outUInt16));
        
        unsigned char dataUInt8(42u);
        std::vector<char> messageUInt8(data_size(dataUInt8));
        //Put data in message
        char* iterUInt8 = (char*)messageUInt8.data();
        data_stream_assert(data_message_save(iterUInt8, dataUInt32));                   //Save the message
        char* loadIterUInt8 = (char*)messageUInt8.data();
        unsigned char outUInt8(0lu);
        data_stream_assert(data_message_load(loadIterUInt8, outUInt8));         //Load the message
        data_stream_assert(checkValue("unsigned char", dataUInt8, outUInt8));
        
        
        long int dataInt64(42lu);
        std::vector<char> messageInt64(data_size(dataInt64));
        //Put data in message
        char* iterInt64 = (char*)messageInt64.data();
        data_stream_assert(data_message_save(iterInt64, dataInt64));                    //Save the message
        char* loadIterInt64 = (char*)messageInt64.data();
        long int outInt64(0lu);
        data_stream_assert(data_message_load(loadIterInt64, outInt64));         //Load the message
        data_stream_assert(checkValue("long int", dataInt64, outInt64));
        
        int dataInt32(42u);
        std::vector<char> messageInt32(data_size(dataInt32));
        //Put data in message
        char* iterInt32 = (char*)messageInt32.data();
        data_stream_assert(data_message_save(iterInt32, dataInt32));                    //Save the message
        char* loadIterInt32 = (char*)messageInt32.data();
        int outInt32(0lu);
        data_stream_assert(data_message_load(loadIterInt32, outInt32));         //Load the message
        data_stream_assert(checkValue("int", dataInt32, outInt32));
        
        short dataInt16(42u);
        std::vector<char> messageInt16(data_size(dataInt16));
        //Put data in message
        char* iterInt16 = (char*)messageInt16.data();
        data_stream_assert(data_message_save(iterInt16, dataInt32));                    //Save the message
        char* loadIterInt16 = (char*)messageInt16.data();
        short outInt16(0lu);
        data_stream_assert(data_message_load(loadIterInt16, outInt16));         //Load the message
        data_stream_assert(checkValue("short", dataInt16, outInt16));
        
        char dataInt8(42u);
        std::vector<char> messageInt8(data_size(dataInt8));
        //Put data in message
        char* iterInt8 = (char*)messageInt8.data();
        data_stream_assert(data_message_save(iterInt8, dataInt32));                     //Save the message
        char* loadIterInt8 = (char*)messageInt8.data();
        char outInt8(0lu);
        data_stream_assert(data_message_load(loadIterInt8, outInt8));           //Load the message
        data_stream_assert(checkValue("char", dataInt8, outInt8));
        
        bool dataBool(true);
        std::vector<char> messageBool(data_size(dataBool));
        //Put data in message
        char* iterBool = (char*)messageBool.data();
        data_stream_assert(data_message_save(iterBool, dataBool));                      //Save the message
        char* loadIterBool = (char*)messageBool.data();
        bool outBool(false);
        data_stream_assert(data_message_load(loadIterBool, outBool));           //Load the message
        data_stream_assert(checkValue("bool", dataBool, outBool));
        
        float dataFloat(3.14f);
        std::vector<char> messageFloat(data_size(dataFloat));
        //Put data in message
        char* iterFloat = (char*)messageFloat.data();
        data_stream_assert(data_message_save(iterFloat, dataFloat));                    //Save the message
        char* loadIterFloat = (char*)messageFloat.data();
        float outFloat(0.0f);
        data_stream_assert(data_message_load(loadIterFloat, outFloat));         //Load the message
        data_stream_assert(checkValue("float", dataFloat, outFloat));
        
        double dataDouble(58.9);
        std::vector<char> messageDouble(data_size(dataDouble));
        //Put data in message
        char* iterDouble = (char*)messageDouble.data();
        data_stream_assert(data_message_save(iterDouble, dataDouble));                  //Save the message
        char* loadIterDouble = (char*)messageDouble.data();
        double outDouble(0.0);
        data_stream_assert(data_message_load(loadIterDouble, outDouble));               //Load the message
        data_stream_assert(checkValue("double", dataDouble, outDouble));
}

References checkValue(), data_message_load(), data_message_save(), data_size(), and data_stream_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testStringDataMessage()

void testStringDataMessage

(

)

Test if data size is Ok.

Definition at line 550 of file main.cpp.

                            {
        std::string str("One thing to say");
        std::vector<char> messageStr(data_size(str));
        char* iterStr = (char*)messageStr.data();
        data_stream_assert(data_message_save(iterStr, str));                    //Save the message
        std::string outStr("");
        char* loadIterStr = (char*)messageStr.data();
        data_stream_assert(data_message_load(loadIterStr, outStr));             //Load the message
        
//      std::cout << "testStringDataMessage : outStr("<<outStr<<"), str("<<str<<")" << std::endl;
        data_stream_assert(str == outStr);
}

References data_message_load(), data_message_save(), data_size(), data_stream_assert, and createReleaseCurl::str.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testVectorDataMessage()

void testVectorDataMessage

(

)

Test if data size is Ok.

Definition at line 128 of file main.cpp.

                            {
        size_t nbValue(10lu);
        
        std::vector<long unsigned int> vecUInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(i);}
        std::vector<char> messageUInt64(data_size(vecUInt64));
        //Put data in message
        char* iterUInt64 = (char*)messageUInt64.data();
        data_stream_assert(data_message_save(iterUInt64, vecUInt64));                   //Save the message
        char* loadIterUInt64 = (char*)messageUInt64.data();
        std::vector<long unsigned int> outVecUInt64(0lu);
        data_stream_assert(data_message_load(loadIterUInt64, outVecUInt64));            //Load the message
        data_stream_assert(checkValue("std::vector<long unsigned int>", outVecUInt64, vecUInt64));
        
        std::vector<unsigned int> vecUInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(i);}
        std::vector<char> messageUInt32(data_size(vecUInt32));
        //Put data in message
        char* iterUInt32 = (char*)messageUInt32.data();
        data_stream_assert(data_message_save(iterUInt32, vecUInt32));                   //Save the message
        char* loadIterUInt32 = (char*)messageUInt32.data();
        std::vector<unsigned int> outVecUInt32(0lu);
        data_stream_assert(data_message_load(loadIterUInt32, outVecUInt32));            //Load the message
        data_stream_assert(checkValue("std::vector<unsigned int>", outVecUInt32, vecUInt32));
        
        std::vector<unsigned short> vecUInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(i);}
        std::vector<char> messageUInt16(data_size(vecUInt16));
        //Put data in message
        char* iterUInt16 = (char*)messageUInt16.data();
        data_stream_assert(data_message_save(iterUInt16, vecUInt16));                   //Save the message
        char* loadIterUInt16 = (char*)messageUInt16.data();
        std::vector<unsigned short> outVecUInt16(0lu);
        data_stream_assert(data_message_load(loadIterUInt16, outVecUInt16));            //Load the message
        data_stream_assert(checkValue("std::vector<unsigned short>", outVecUInt16, vecUInt16));
        
        std::vector<unsigned char> vecUInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(i);}
        std::vector<char> messageUInt8(data_size(vecUInt8));
        //Put data in message
        char* iterUInt8 = (char*)messageUInt8.data();
        data_stream_assert(data_message_save(iterUInt8, vecUInt8));                     //Save the message
        char* loadIterUInt8 = (char*)messageUInt8.data();
        std::vector<unsigned char> outVecUInt8(0lu);
        data_stream_assert(data_message_load(loadIterUInt8, outVecUInt8));              //Load the message
        data_stream_assert(checkValue("std::vector<unsigned char>", outVecUInt8, vecUInt8));
        
        
        std::vector<long int> vecInt64;
        for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(i);}
        std::vector<char> messageInt64(data_size(vecInt64));
        //Put data in message
        char* iterInt64 = (char*)messageInt64.data();
        data_stream_assert(data_message_save(iterInt64, vecInt64));                     //Save the message
        char* loadIterInt64 = (char*)messageInt64.data();
        std::vector<long int> outVecInt64(0lu);
        data_stream_assert(data_message_load(loadIterInt64, outVecInt64));              //Load the message
        data_stream_assert(checkValue("std::vector<long int>", outVecInt64, vecInt64));
        
        std::vector<int> vecInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(i);}
        std::vector<char> messageInt32(data_size(vecInt32));
        //Put data in message
        char* iterInt32 = (char*)messageInt32.data();
        data_stream_assert(data_message_save(iterInt32, vecInt32));                     //Save the message
        char* loadIterInt32 = (char*)messageInt32.data();
        std::vector<int> outVecInt32(0lu);
        data_stream_assert(data_message_load(loadIterInt32, outVecInt32));              //Load the message
        data_stream_assert(checkValue("std::vector<int>", outVecInt32, vecInt32));
        
        std::vector<short> vecInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(i);}
        std::vector<char> messageInt16(data_size(vecInt16));
        //Put data in message
        char* iterInt16 = (char*)messageInt16.data();
        data_stream_assert(data_message_save(iterInt16, vecInt16));                     //Save the message
        char* loadIterInt16 = (char*)messageInt16.data();
        std::vector<short> outVecInt16(0lu);
        data_stream_assert(data_message_load(loadIterInt16, outVecInt16));              //Load the message
        data_stream_assert(checkValue("std::vector<short>", outVecInt16, vecInt16));
        
        std::vector<char> vecInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(i);}
        std::vector<char> messageInt8(data_size(vecInt8));
        //Put data in message
        char* iterInt8 = (char*)messageInt8.data();
        data_stream_assert(data_message_save(iterInt8, vecInt8));                       //Save the message
        char* loadIterInt8 = (char*)messageInt8.data();
        std::vector<char> outVecInt8(0lu);
        data_stream_assert(data_message_load(loadIterInt8, outVecInt8));                //Load the message
        data_stream_assert(checkValue("std::vector<char>", outVecInt8, vecInt8));
}

References checkValue(), data_message_load(), data_message_save(), data_size(), and data_stream_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testVectorPairDataMessage()

void testVectorPairDataMessage

(

)

Test if data size is Ok.

Definition at line 410 of file main.cpp.

                                {
        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,2lu*i));}
        std::vector<char> messageUInt64(data_size(vecUInt64));
        //Put data in message
        char* iterUInt64 = (char*)messageUInt64.data();
        data_stream_assert(data_message_save(iterUInt64, vecUInt64));                   //Save the message
        char* loadIterUInt64 = (char*)messageUInt64.data();
        std::vector<std::pair<long unsigned int, long unsigned int> > outVecUInt64(0lu);
        data_stream_assert(data_message_load(loadIterUInt64, outVecUInt64));            //Load the message
        data_stream_assert(checkValue("std::vector<std::pair<long unsigned int, long unsigned int> >", outVecUInt64, vecUInt64));
        
        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,2lu*i));}
        std::vector<char> messageUInt32(data_size(vecUInt32));
        //Put data in message
        char* iterUInt32 = (char*)messageUInt32.data();
        data_stream_assert(data_message_save(iterUInt32, vecUInt32));                   //Save the message
        char* loadIterUInt32 = (char*)messageUInt32.data();
        std::vector<std::pair<unsigned int, unsigned int> > outVecUInt32(0lu);
        data_stream_assert(data_message_load(loadIterUInt32, outVecUInt32));            //Load the message
        data_stream_assert(checkValue("std::vector<std::pair<unsigned int, unsigned int> >", outVecUInt32, vecUInt32));
        
        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,2lu*i));}
        std::vector<char> messageUInt16(data_size(vecUInt16));
        //Put data in message
        char* iterUInt16 = (char*)messageUInt16.data();
        data_stream_assert(data_message_save(iterUInt16, vecUInt16));                   //Save the message
        char* loadIterUInt16 = (char*)messageUInt16.data();
        std::vector<std::pair<unsigned short, unsigned short> > outVecUInt16(0lu);
        data_stream_assert(data_message_load(loadIterUInt16, outVecUInt16));            //Load the message
        data_stream_assert(checkValue("std::vector<std::pair<unsigned short, unsigned short> >", outVecUInt16, vecUInt16));
        
        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,2lu*i));}
        std::vector<char> messageUInt8(data_size(vecUInt8));
        //Put data in message
        char* iterUInt8 = (char*)messageUInt8.data();
        data_stream_assert(data_message_save(iterUInt8, vecUInt8));                     //Save the message
        char* loadIterUInt8 = (char*)messageUInt8.data();
        std::vector<std::pair<unsigned char, unsigned char> > outVecUInt8(0lu);
        data_stream_assert(data_message_load(loadIterUInt8, outVecUInt8));              //Load the message
        data_stream_assert(checkValue("std::vector<std::pair<unsigned char, unsigned char> >", outVecUInt8, vecUInt8));
        
        
        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,2lu*i));}
        std::vector<char> messageInt64(data_size(vecInt64));
        //Put data in message
        char* iterInt64 = (char*)messageInt64.data();
        data_stream_assert(data_message_save(iterInt64, vecInt64));                     //Save the message
        char* loadIterInt64 = (char*)messageInt64.data();
        std::vector<std::pair<long int, long int> > outVecInt64(0lu);
        data_stream_assert(data_message_load(loadIterInt64, outVecInt64));              //Load the message
        data_stream_assert(checkValue("std::vector<std::pair<long int, long int> >", outVecInt64, vecInt64));
        
        std::vector<std::pair<int, int> > vecInt32;
        for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(std::pair<int, int>(i,2lu*i));}
        std::vector<char> messageInt32(data_size(vecInt32));
        //Put data in message
        char* iterInt32 = (char*)messageInt32.data();
        data_stream_assert(data_message_save(iterInt32, vecInt32));                     //Save the message
        char* loadIterInt32 = (char*)messageInt32.data();
        std::vector<std::pair<int, int> > outVecInt32(0lu);
        data_stream_assert(data_message_load(loadIterInt32, outVecInt32));              //Load the message
        data_stream_assert(checkValue("std::vector<std::pair<int, int> >", outVecInt32, vecInt32));
        
        std::vector<std::pair<short, short> > vecInt16;
        for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(std::pair<short, short>(i,2lu*i));}
        std::vector<char> messageInt16(data_size(vecInt16));
        //Put data in message
        char* iterInt16 = (char*)messageInt16.data();
        data_stream_assert(data_message_save(iterInt16, vecInt16));                     //Save the message
        char* loadIterInt16 = (char*)messageInt16.data();
        std::vector<std::pair<short, short> > outVecInt16(0lu);
        data_stream_assert(data_message_load(loadIterInt16, outVecInt16));              //Load the message
        data_stream_assert(checkValue("std::vector<std::pair<short, short> >", outVecInt16, vecInt16));
        
        std::vector<std::pair<char, char> > vecInt8;
        for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(std::pair<char, char>(i,2lu*i));}
        std::vector<char> messageInt8(data_size(vecInt8));
        //Put data in message
        char* iterInt8 = (char*)messageInt8.data();
        data_stream_assert(data_message_save(iterInt8, vecInt8));                       //Save the message
        char* loadIterInt8 = (char*)messageInt8.data();
        std::vector<std::pair<char, char> > outVecInt8(0lu);
        data_stream_assert(data_message_load(loadIterInt8, outVecInt8));                //Load the message
        data_stream_assert(checkValue("std::vector<std::pair<char, char> >", outVecInt8, vecInt8));
}

References checkValue(), data_message_load(), data_message_save(), data_size(), and data_stream_assert.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: