Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	tmp_project/DataStream/TESTS/TEST_DATA_MESSAGE/main.cpp	Lines:	444	444	100.0 %
Date:	2024-12-09 15:30:52	Branches:	992	992	100.0 %

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/

#include "data_stream_assert.h"
#include "data_stream_check_value.h"

#include "data_size.h"
#include "data_message.h"

///Test if data size is Ok
void testSimpleDataMessage(){
	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));
}

///Test if data size is Ok
void testVectorDataMessage(){
	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));
}

///Test if data size is Ok
void testListDataMessage(){
	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));
}

///Test if data size is Ok
void testMapDataMessage(){
	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));
}

///Test if data size is Ok
void testVectorPairDataMessage(){
	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));
}

///Test if data size is Ok
void testListPairDataMessage(){
	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));
}

///Test if data size is Ok
void testStringDataMessage(){
	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);
}

int main(int argc, char** argv){
	testSimpleDataMessage();
	testVectorDataMessage();
	testListDataMessage();
	testMapDataMessage();
	testVectorPairDataMessage();
	testListPairDataMessage();
	testStringDataMessage();
	return 0;
}


Generated by: GCOVR (Version 4.2)