PhoenixMock  1.8.7
Tools to split/merge/print mock used in Phoenix
main.cpp
Go to the documentation of this file.
1 /***************************************
2  Auteur : Pierre Aubert
3  Mail : pierre.aubert@lapp.in2p3.fr
4  Licence : CeCILL-C
5 ****************************************/
6 
7 #include "data_stream_assert.h"
8 #include "data_stream_check_value.h"
9 
10 #include "data_size.h"
11 #include "data_message.h"
12 
14 void testSimpleDataMessage(){
15  long unsigned int dataUInt64(42lu);
16  std::vector<char> messageUInt64(data_size(dataUInt64));
17  //Put data in message
18  char* iterUInt64 = (char*)messageUInt64.data();
19  data_stream_assert(data_message_save(iterUInt64, dataUInt64)); //Save the message
20  char* loadIterUInt64 = (char*)messageUInt64.data();
21  long unsigned int outUInt64(0lu);
22  data_stream_assert(data_message_load(loadIterUInt64, outUInt64)); //Load the message
23  data_stream_assert(checkValue("long unsigned int", dataUInt64, outUInt64));
24 
25  unsigned int dataUInt32(42u);
26  std::vector<char> messageUInt32(data_size(dataUInt32));
27  //Put data in message
28  char* iterUInt32 = (char*)messageUInt32.data();
29  data_stream_assert(data_message_save(iterUInt32, dataUInt32)); //Save the message
30  char* loadIterUInt32 = (char*)messageUInt32.data();
31  unsigned int outUInt32(0lu);
32  data_stream_assert(data_message_load(loadIterUInt32, outUInt32)); //Load the message
33  data_stream_assert(checkValue("unsigned int", dataUInt32, outUInt32));
34 
35  unsigned short dataUInt16(42u);
36  std::vector<char> messageUInt16(data_size(dataUInt16));
37  //Put data in message
38  char* iterUInt16 = (char*)messageUInt16.data();
39  data_stream_assert(data_message_save(iterUInt16, dataUInt32)); //Save the message
40  char* loadIterUInt16 = (char*)messageUInt16.data();
41  unsigned short outUInt16(0lu);
42  data_stream_assert(data_message_load(loadIterUInt16, outUInt16)); //Load the message
43  data_stream_assert(checkValue("unsigned short", dataUInt16, outUInt16));
44 
45  unsigned char dataUInt8(42u);
46  std::vector<char> messageUInt8(data_size(dataUInt8));
47  //Put data in message
48  char* iterUInt8 = (char*)messageUInt8.data();
49  data_stream_assert(data_message_save(iterUInt8, dataUInt32)); //Save the message
50  char* loadIterUInt8 = (char*)messageUInt8.data();
51  unsigned char outUInt8(0lu);
52  data_stream_assert(data_message_load(loadIterUInt8, outUInt8)); //Load the message
53  data_stream_assert(checkValue("unsigned char", dataUInt8, outUInt8));
54 
55 
56  long int dataInt64(42lu);
57  std::vector<char> messageInt64(data_size(dataInt64));
58  //Put data in message
59  char* iterInt64 = (char*)messageInt64.data();
60  data_stream_assert(data_message_save(iterInt64, dataInt64)); //Save the message
61  char* loadIterInt64 = (char*)messageInt64.data();
62  long int outInt64(0lu);
63  data_stream_assert(data_message_load(loadIterInt64, outInt64)); //Load the message
64  data_stream_assert(checkValue("long int", dataInt64, outInt64));
65 
66  int dataInt32(42u);
67  std::vector<char> messageInt32(data_size(dataInt32));
68  //Put data in message
69  char* iterInt32 = (char*)messageInt32.data();
70  data_stream_assert(data_message_save(iterInt32, dataInt32)); //Save the message
71  char* loadIterInt32 = (char*)messageInt32.data();
72  int outInt32(0lu);
73  data_stream_assert(data_message_load(loadIterInt32, outInt32)); //Load the message
74  data_stream_assert(checkValue("int", dataInt32, outInt32));
75 
76  short dataInt16(42u);
77  std::vector<char> messageInt16(data_size(dataInt16));
78  //Put data in message
79  char* iterInt16 = (char*)messageInt16.data();
80  data_stream_assert(data_message_save(iterInt16, dataInt32)); //Save the message
81  char* loadIterInt16 = (char*)messageInt16.data();
82  short outInt16(0lu);
83  data_stream_assert(data_message_load(loadIterInt16, outInt16)); //Load the message
84  data_stream_assert(checkValue("short", dataInt16, outInt16));
85 
86  char dataInt8(42u);
87  std::vector<char> messageInt8(data_size(dataInt8));
88  //Put data in message
89  char* iterInt8 = (char*)messageInt8.data();
90  data_stream_assert(data_message_save(iterInt8, dataInt32)); //Save the message
91  char* loadIterInt8 = (char*)messageInt8.data();
92  char outInt8(0lu);
93  data_stream_assert(data_message_load(loadIterInt8, outInt8)); //Load the message
94  data_stream_assert(checkValue("char", dataInt8, outInt8));
95 
96  bool dataBool(true);
97  std::vector<char> messageBool(data_size(dataBool));
98  //Put data in message
99  char* iterBool = (char*)messageBool.data();
100  data_stream_assert(data_message_save(iterBool, dataBool)); //Save the message
101  char* loadIterBool = (char*)messageBool.data();
102  bool outBool(false);
103  data_stream_assert(data_message_load(loadIterBool, outBool)); //Load the message
104  data_stream_assert(checkValue("bool", dataBool, outBool));
105 
106  float dataFloat(3.14f);
107  std::vector<char> messageFloat(data_size(dataFloat));
108  //Put data in message
109  char* iterFloat = (char*)messageFloat.data();
110  data_stream_assert(data_message_save(iterFloat, dataFloat)); //Save the message
111  char* loadIterFloat = (char*)messageFloat.data();
112  float outFloat(0.0f);
113  data_stream_assert(data_message_load(loadIterFloat, outFloat)); //Load the message
114  data_stream_assert(checkValue("float", dataFloat, outFloat));
115 
116  double dataDouble(58.9);
117  std::vector<char> messageDouble(data_size(dataDouble));
118  //Put data in message
119  char* iterDouble = (char*)messageDouble.data();
120  data_stream_assert(data_message_save(iterDouble, dataDouble)); //Save the message
121  char* loadIterDouble = (char*)messageDouble.data();
122  double outDouble(0.0);
123  data_stream_assert(data_message_load(loadIterDouble, outDouble)); //Load the message
124  data_stream_assert(checkValue("double", dataDouble, outDouble));
125 }
126 
128 void testVectorDataMessage(){
129  size_t nbValue(10lu);
130 
131  std::vector<long unsigned int> vecUInt64;
132  for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(i);}
133  std::vector<char> messageUInt64(data_size(vecUInt64));
134  //Put data in message
135  char* iterUInt64 = (char*)messageUInt64.data();
136  data_stream_assert(data_message_save(iterUInt64, vecUInt64)); //Save the message
137  char* loadIterUInt64 = (char*)messageUInt64.data();
138  std::vector<long unsigned int> outVecUInt64(0lu);
139  data_stream_assert(data_message_load(loadIterUInt64, outVecUInt64)); //Load the message
140  data_stream_assert(checkValue("std::vector<long unsigned int>", outVecUInt64, vecUInt64));
141 
142  std::vector<unsigned int> vecUInt32;
143  for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(i);}
144  std::vector<char> messageUInt32(data_size(vecUInt32));
145  //Put data in message
146  char* iterUInt32 = (char*)messageUInt32.data();
147  data_stream_assert(data_message_save(iterUInt32, vecUInt32)); //Save the message
148  char* loadIterUInt32 = (char*)messageUInt32.data();
149  std::vector<unsigned int> outVecUInt32(0lu);
150  data_stream_assert(data_message_load(loadIterUInt32, outVecUInt32)); //Load the message
151  data_stream_assert(checkValue("std::vector<unsigned int>", outVecUInt32, vecUInt32));
152 
153  std::vector<unsigned short> vecUInt16;
154  for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(i);}
155  std::vector<char> messageUInt16(data_size(vecUInt16));
156  //Put data in message
157  char* iterUInt16 = (char*)messageUInt16.data();
158  data_stream_assert(data_message_save(iterUInt16, vecUInt16)); //Save the message
159  char* loadIterUInt16 = (char*)messageUInt16.data();
160  std::vector<unsigned short> outVecUInt16(0lu);
161  data_stream_assert(data_message_load(loadIterUInt16, outVecUInt16)); //Load the message
162  data_stream_assert(checkValue("std::vector<unsigned short>", outVecUInt16, vecUInt16));
163 
164  std::vector<unsigned char> vecUInt8;
165  for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(i);}
166  std::vector<char> messageUInt8(data_size(vecUInt8));
167  //Put data in message
168  char* iterUInt8 = (char*)messageUInt8.data();
169  data_stream_assert(data_message_save(iterUInt8, vecUInt8)); //Save the message
170  char* loadIterUInt8 = (char*)messageUInt8.data();
171  std::vector<unsigned char> outVecUInt8(0lu);
172  data_stream_assert(data_message_load(loadIterUInt8, outVecUInt8)); //Load the message
173  data_stream_assert(checkValue("std::vector<unsigned char>", outVecUInt8, vecUInt8));
174 
175 
176  std::vector<long int> vecInt64;
177  for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(i);}
178  std::vector<char> messageInt64(data_size(vecInt64));
179  //Put data in message
180  char* iterInt64 = (char*)messageInt64.data();
181  data_stream_assert(data_message_save(iterInt64, vecInt64)); //Save the message
182  char* loadIterInt64 = (char*)messageInt64.data();
183  std::vector<long int> outVecInt64(0lu);
184  data_stream_assert(data_message_load(loadIterInt64, outVecInt64)); //Load the message
185  data_stream_assert(checkValue("std::vector<long int>", outVecInt64, vecInt64));
186 
187  std::vector<int> vecInt32;
188  for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(i);}
189  std::vector<char> messageInt32(data_size(vecInt32));
190  //Put data in message
191  char* iterInt32 = (char*)messageInt32.data();
192  data_stream_assert(data_message_save(iterInt32, vecInt32)); //Save the message
193  char* loadIterInt32 = (char*)messageInt32.data();
194  std::vector<int> outVecInt32(0lu);
195  data_stream_assert(data_message_load(loadIterInt32, outVecInt32)); //Load the message
196  data_stream_assert(checkValue("std::vector<int>", outVecInt32, vecInt32));
197 
198  std::vector<short> vecInt16;
199  for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(i);}
200  std::vector<char> messageInt16(data_size(vecInt16));
201  //Put data in message
202  char* iterInt16 = (char*)messageInt16.data();
203  data_stream_assert(data_message_save(iterInt16, vecInt16)); //Save the message
204  char* loadIterInt16 = (char*)messageInt16.data();
205  std::vector<short> outVecInt16(0lu);
206  data_stream_assert(data_message_load(loadIterInt16, outVecInt16)); //Load the message
207  data_stream_assert(checkValue("std::vector<short>", outVecInt16, vecInt16));
208 
209  std::vector<char> vecInt8;
210  for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(i);}
211  std::vector<char> messageInt8(data_size(vecInt8));
212  //Put data in message
213  char* iterInt8 = (char*)messageInt8.data();
214  data_stream_assert(data_message_save(iterInt8, vecInt8)); //Save the message
215  char* loadIterInt8 = (char*)messageInt8.data();
216  std::vector<char> outVecInt8(0lu);
217  data_stream_assert(data_message_load(loadIterInt8, outVecInt8)); //Load the message
218  data_stream_assert(checkValue("std::vector<char>", outVecInt8, vecInt8));
219 }
220 
222 void testListDataMessage(){
223  size_t nbValue(10lu);
224 
225  std::list<long unsigned int> vecUInt64;
226  for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(i);}
227  std::vector<char> messageUInt64(data_size(vecUInt64));
228  //Put data in message
229  char* iterUInt64 = (char*)messageUInt64.data();
230  data_stream_assert(data_message_save(iterUInt64, vecUInt64)); //Save the message
231  char* loadIterUInt64 = (char*)messageUInt64.data();
232  std::list<long unsigned int> outVecUInt64(0lu);
233  data_stream_assert(data_message_load(loadIterUInt64, outVecUInt64)); //Load the message
234  data_stream_assert(checkValue("std::list<long unsigned int>", outVecUInt64, vecUInt64));
235 
236  std::list<unsigned int> vecUInt32;
237  for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(i);}
238  std::vector<char> messageUInt32(data_size(vecUInt32));
239  //Put data in message
240  char* iterUInt32 = (char*)messageUInt32.data();
241  data_stream_assert(data_message_save(iterUInt32, vecUInt32)); //Save the message
242  char* loadIterUInt32 = (char*)messageUInt32.data();
243  std::list<unsigned int> outVecUInt32(0lu);
244  data_stream_assert(data_message_load(loadIterUInt32, outVecUInt32)); //Load the message
245  data_stream_assert(checkValue("std::list<unsigned int>", outVecUInt32, vecUInt32));
246 
247  std::list<unsigned short> vecUInt16;
248  for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(i);}
249  std::vector<char> messageUInt16(data_size(vecUInt16));
250  //Put data in message
251  char* iterUInt16 = (char*)messageUInt16.data();
252  data_stream_assert(data_message_save(iterUInt16, vecUInt16)); //Save the message
253  char* loadIterUInt16 = (char*)messageUInt16.data();
254  std::list<unsigned short> outVecUInt16(0lu);
255  data_stream_assert(data_message_load(loadIterUInt16, outVecUInt16)); //Load the message
256  data_stream_assert(checkValue("std::list<unsigned short>", outVecUInt16, vecUInt16));
257 
258  std::list<unsigned char> vecUInt8;
259  for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(i);}
260  std::vector<char> messageUInt8(data_size(vecUInt8));
261  //Put data in message
262  char* iterUInt8 = (char*)messageUInt8.data();
263  data_stream_assert(data_message_save(iterUInt8, vecUInt8)); //Save the message
264  char* loadIterUInt8 = (char*)messageUInt8.data();
265  std::list<unsigned char> outVecUInt8(0lu);
266  data_stream_assert(data_message_load(loadIterUInt8, outVecUInt8)); //Load the message
267  data_stream_assert(checkValue("std::list<unsigned char>", outVecUInt8, vecUInt8));
268 
269 
270  std::list<long int> vecInt64;
271  for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(i);}
272  std::vector<char> messageInt64(data_size(vecInt64));
273  //Put data in message
274  char* iterInt64 = (char*)messageInt64.data();
275  data_stream_assert(data_message_save(iterInt64, vecInt64)); //Save the message
276  char* loadIterInt64 = (char*)messageInt64.data();
277  std::list<long int> outVecInt64(0lu);
278  data_stream_assert(data_message_load(loadIterInt64, outVecInt64)); //Load the message
279  data_stream_assert(checkValue("std::list<long int>", outVecInt64, vecInt64));
280 
281  std::list<int> vecInt32;
282  for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(i);}
283  std::vector<char> messageInt32(data_size(vecInt32));
284  //Put data in message
285  char* iterInt32 = (char*)messageInt32.data();
286  data_stream_assert(data_message_save(iterInt32, vecInt32)); //Save the message
287  char* loadIterInt32 = (char*)messageInt32.data();
288  std::list<int> outVecInt32(0lu);
289  data_stream_assert(data_message_load(loadIterInt32, outVecInt32)); //Load the message
290  data_stream_assert(checkValue("std::list<int>", outVecInt32, vecInt32));
291 
292  std::list<short> vecInt16;
293  for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(i);}
294  std::vector<char> messageInt16(data_size(vecInt16));
295  //Put data in message
296  char* iterInt16 = (char*)messageInt16.data();
297  data_stream_assert(data_message_save(iterInt16, vecInt16)); //Save the message
298  char* loadIterInt16 = (char*)messageInt16.data();
299  std::list<short> outVecInt16(0lu);
300  data_stream_assert(data_message_load(loadIterInt16, outVecInt16)); //Load the message
301  data_stream_assert(checkValue("std::list<short>", outVecInt16, vecInt16));
302 
303  std::list<char> vecInt8;
304  for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(i);}
305  std::vector<char> messageInt8(data_size(vecInt8));
306  //Put data in message
307  char* iterInt8 = (char*)messageInt8.data();
308  data_stream_assert(data_message_save(iterInt8, vecInt8)); //Save the message
309  char* loadIterInt8 = (char*)messageInt8.data();
310  std::list<char> outVecInt8(0lu);
311  data_stream_assert(data_message_load(loadIterInt8, outVecInt8)); //Load the message
312  data_stream_assert(checkValue("std::list<char>", outVecInt8, vecInt8));
313 }
314 
316 void testMapDataMessage(){
317  size_t nbValue(10lu);
318 
319  std::map<long unsigned int, long unsigned int> mapUInt64UInt64;
320  for(size_t i(0lu); i < nbValue; ++i){mapUInt64UInt64[i] = 2lu*i;}
321  std::vector<char> messageUInt64UInt64(data_size(mapUInt64UInt64));
322  //Put data in message
323  char* iterUIntUInt64 = (char*)messageUInt64UInt64.data();
324  data_stream_assert(data_message_save(iterUIntUInt64, mapUInt64UInt64)); //Save the message
325  char* loadIterUIntUInt64 = (char*)messageUInt64UInt64.data();
326  std::map<long unsigned int, long unsigned int> outVecUInt64UInt64;
327  data_stream_assert(data_message_load(loadIterUIntUInt64, outVecUInt64UInt64)); //Load the message
328  data_stream_assert(checkValue("std::map<long unsigned int, long unsigned int>", outVecUInt64UInt64, mapUInt64UInt64));
329 
330  std::map<unsigned int, unsigned int> mapUInt32UInt32;
331  for(size_t i(0lu); i < nbValue; ++i){mapUInt32UInt32[i] = 2lu*i;}
332  std::vector<char> messageUInt32UInt32(data_size(mapUInt32UInt32));
333  //Put data in message
334  char* iterUIntUInt32 = (char*)messageUInt32UInt32.data();
335  data_stream_assert(data_message_save(iterUIntUInt32, mapUInt32UInt32)); //Save the message
336  char* loadIterUIntUInt32 = (char*)messageUInt32UInt32.data();
337  std::map<unsigned int, unsigned int> outVecUInt32UInt32;
338  data_stream_assert(data_message_load(loadIterUIntUInt32, outVecUInt32UInt32)); //Load the message
339  data_stream_assert(checkValue("std::map<unsigned int, unsigned int>", outVecUInt32UInt32, mapUInt32UInt32));
340 
341  std::map<unsigned short, unsigned short> mapUInt16UInt16;
342  for(size_t i(0lu); i < nbValue; ++i){mapUInt16UInt16[i] = 2lu*i;}
343  std::vector<char> messageUInt16UInt16(data_size(mapUInt16UInt16));
344  //Put data in message
345  char* iterUIntUInt16 = (char*)messageUInt16UInt16.data();
346  data_stream_assert(data_message_save(iterUIntUInt16, mapUInt16UInt16)); //Save the message
347  char* loadIterUIntUInt16 = (char*)messageUInt16UInt16.data();
348  std::map<unsigned short, unsigned short> outVecUInt16UInt16;
349  data_stream_assert(data_message_load(loadIterUIntUInt16, outVecUInt16UInt16)); //Load the message
350  data_stream_assert(checkValue("std::map<unsigned short, unsigned short>", outVecUInt16UInt16, mapUInt16UInt16));
351 
352  std::map<unsigned char, unsigned char> mapUInt8UInt8;
353  for(size_t i(0lu); i < nbValue; ++i){mapUInt8UInt8[i] = 2lu*i;}
354  std::vector<char> messageUInt8UInt8(data_size(mapUInt8UInt8));
355  //Put data in message
356  char* iterUIntUInt8 = (char*)messageUInt8UInt8.data();
357  data_stream_assert(data_message_save(iterUIntUInt8, mapUInt8UInt8)); //Save the message
358  char* loadIterUIntUInt8 = (char*)messageUInt8UInt8.data();
359  std::map<unsigned char, unsigned char> outVecUInt8UInt8;
360  data_stream_assert(data_message_load(loadIterUIntUInt8, outVecUInt8UInt8)); //Load the message
361  data_stream_assert(checkValue("std::map<unsigned char, unsigned char>", outVecUInt8UInt8, mapUInt8UInt8));
362 
363 
364  std::map<long int, long int> mapInt64Int64;
365  for(size_t i(0lu); i < nbValue; ++i){mapInt64Int64[i] = 2lu*i;}
366  std::vector<char> messageInt64Int64(data_size(mapInt64Int64));
367  //Put data in message
368  char* iterIntInt64 = (char*)messageInt64Int64.data();
369  data_stream_assert(data_message_save(iterIntInt64, mapInt64Int64)); //Save the message
370  char* loadIterIntInt64 = (char*)messageInt64Int64.data();
371  std::map<long int, long int> outVecInt64Int64;
372  data_stream_assert(data_message_load(loadIterIntInt64, outVecInt64Int64)); //Load the message
373  data_stream_assert(checkValue("std::map<long int, long int>", outVecInt64Int64, mapInt64Int64));
374 
375  std::map<int, int> mapInt32Int32;
376  for(size_t i(0lu); i < nbValue; ++i){mapInt32Int32[i] = 2lu*i;}
377  std::vector<char> messageInt32Int32(data_size(mapInt32Int32));
378  //Put data in message
379  char* iterIntInt32 = (char*)messageInt32Int32.data();
380  data_stream_assert(data_message_save(iterIntInt32, mapInt32Int32)); //Save the message
381  char* loadIterIntInt32 = (char*)messageInt32Int32.data();
382  std::map<int, int> outVecInt32Int32;
383  data_stream_assert(data_message_load(loadIterIntInt32, outVecInt32Int32)); //Load the message
384  data_stream_assert(checkValue("std::map<int, int>", outVecInt32Int32, mapInt32Int32));
385 
386  std::map<short, short> mapInt16Int16;
387  for(size_t i(0lu); i < nbValue; ++i){mapInt16Int16[i] = 2lu*i;}
388  std::vector<char> messageInt16Int16(data_size(mapInt16Int16));
389  //Put data in message
390  char* iterIntInt16 = (char*)messageInt16Int16.data();
391  data_stream_assert(data_message_save(iterIntInt16, mapInt16Int16)); //Save the message
392  char* loadIterIntInt16 = (char*)messageInt16Int16.data();
393  std::map<short, short> outVecInt16Int16;
394  data_stream_assert(data_message_load(loadIterIntInt16, outVecInt16Int16)); //Load the message
395  data_stream_assert(checkValue("std::map<short, short>", outVecInt16Int16, mapInt16Int16));
396 
397  std::map<char, char> mapInt8Int8;
398  for(size_t i(0lu); i < nbValue; ++i){mapInt8Int8[i] = 2lu*i;}
399  std::vector<char> messageInt8Int8(data_size(mapInt8Int8));
400  //Put data in message
401  char* iterIntInt8 = (char*)messageInt8Int8.data();
402  data_stream_assert(data_message_save(iterIntInt8, mapInt8Int8)); //Save the message
403  char* loadIterIntInt8 = (char*)messageInt8Int8.data();
404  std::map<char, char> outVecInt8Int8;
405  data_stream_assert(data_message_load(loadIterIntInt8, outVecInt8Int8)); //Load the message
406  data_stream_assert(checkValue("std::map<char, char>", outVecInt8Int8, mapInt8Int8));
407 }
408 
410 void testVectorPairDataMessage(){
411  size_t nbValue(10lu);
412 
413  std::vector<std::pair<long unsigned int, long unsigned int> > vecUInt64;
414  for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(std::pair<long unsigned int, long unsigned int>(i,2lu*i));}
415  std::vector<char> messageUInt64(data_size(vecUInt64));
416  //Put data in message
417  char* iterUInt64 = (char*)messageUInt64.data();
418  data_stream_assert(data_message_save(iterUInt64, vecUInt64)); //Save the message
419  char* loadIterUInt64 = (char*)messageUInt64.data();
420  std::vector<std::pair<long unsigned int, long unsigned int> > outVecUInt64(0lu);
421  data_stream_assert(data_message_load(loadIterUInt64, outVecUInt64)); //Load the message
422  data_stream_assert(checkValue("std::vector<std::pair<long unsigned int, long unsigned int> >", outVecUInt64, vecUInt64));
423 
424  std::vector<std::pair<unsigned int, unsigned int> > vecUInt32;
425  for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(std::pair<unsigned int, unsigned int>(i,2lu*i));}
426  std::vector<char> messageUInt32(data_size(vecUInt32));
427  //Put data in message
428  char* iterUInt32 = (char*)messageUInt32.data();
429  data_stream_assert(data_message_save(iterUInt32, vecUInt32)); //Save the message
430  char* loadIterUInt32 = (char*)messageUInt32.data();
431  std::vector<std::pair<unsigned int, unsigned int> > outVecUInt32(0lu);
432  data_stream_assert(data_message_load(loadIterUInt32, outVecUInt32)); //Load the message
433  data_stream_assert(checkValue("std::vector<std::pair<unsigned int, unsigned int> >", outVecUInt32, vecUInt32));
434 
435  std::vector<std::pair<unsigned short, unsigned short> > vecUInt16;
436  for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(std::pair<unsigned short, unsigned short>(i,2lu*i));}
437  std::vector<char> messageUInt16(data_size(vecUInt16));
438  //Put data in message
439  char* iterUInt16 = (char*)messageUInt16.data();
440  data_stream_assert(data_message_save(iterUInt16, vecUInt16)); //Save the message
441  char* loadIterUInt16 = (char*)messageUInt16.data();
442  std::vector<std::pair<unsigned short, unsigned short> > outVecUInt16(0lu);
443  data_stream_assert(data_message_load(loadIterUInt16, outVecUInt16)); //Load the message
444  data_stream_assert(checkValue("std::vector<std::pair<unsigned short, unsigned short> >", outVecUInt16, vecUInt16));
445 
446  std::vector<std::pair<unsigned char, unsigned char> > vecUInt8;
447  for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(std::pair<unsigned char, unsigned char>(i,2lu*i));}
448  std::vector<char> messageUInt8(data_size(vecUInt8));
449  //Put data in message
450  char* iterUInt8 = (char*)messageUInt8.data();
451  data_stream_assert(data_message_save(iterUInt8, vecUInt8)); //Save the message
452  char* loadIterUInt8 = (char*)messageUInt8.data();
453  std::vector<std::pair<unsigned char, unsigned char> > outVecUInt8(0lu);
454  data_stream_assert(data_message_load(loadIterUInt8, outVecUInt8)); //Load the message
455  data_stream_assert(checkValue("std::vector<std::pair<unsigned char, unsigned char> >", outVecUInt8, vecUInt8));
456 
457 
458  std::vector<std::pair<long int, long int> > vecInt64;
459  for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(std::pair<long int, long int>(i,2lu*i));}
460  std::vector<char> messageInt64(data_size(vecInt64));
461  //Put data in message
462  char* iterInt64 = (char*)messageInt64.data();
463  data_stream_assert(data_message_save(iterInt64, vecInt64)); //Save the message
464  char* loadIterInt64 = (char*)messageInt64.data();
465  std::vector<std::pair<long int, long int> > outVecInt64(0lu);
466  data_stream_assert(data_message_load(loadIterInt64, outVecInt64)); //Load the message
467  data_stream_assert(checkValue("std::vector<std::pair<long int, long int> >", outVecInt64, vecInt64));
468 
469  std::vector<std::pair<int, int> > vecInt32;
470  for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(std::pair<int, int>(i,2lu*i));}
471  std::vector<char> messageInt32(data_size(vecInt32));
472  //Put data in message
473  char* iterInt32 = (char*)messageInt32.data();
474  data_stream_assert(data_message_save(iterInt32, vecInt32)); //Save the message
475  char* loadIterInt32 = (char*)messageInt32.data();
476  std::vector<std::pair<int, int> > outVecInt32(0lu);
477  data_stream_assert(data_message_load(loadIterInt32, outVecInt32)); //Load the message
478  data_stream_assert(checkValue("std::vector<std::pair<int, int> >", outVecInt32, vecInt32));
479 
480  std::vector<std::pair<short, short> > vecInt16;
481  for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(std::pair<short, short>(i,2lu*i));}
482  std::vector<char> messageInt16(data_size(vecInt16));
483  //Put data in message
484  char* iterInt16 = (char*)messageInt16.data();
485  data_stream_assert(data_message_save(iterInt16, vecInt16)); //Save the message
486  char* loadIterInt16 = (char*)messageInt16.data();
487  std::vector<std::pair<short, short> > outVecInt16(0lu);
488  data_stream_assert(data_message_load(loadIterInt16, outVecInt16)); //Load the message
489  data_stream_assert(checkValue("std::vector<std::pair<short, short> >", outVecInt16, vecInt16));
490 
491  std::vector<std::pair<char, char> > vecInt8;
492  for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(std::pair<char, char>(i,2lu*i));}
493  std::vector<char> messageInt8(data_size(vecInt8));
494  //Put data in message
495  char* iterInt8 = (char*)messageInt8.data();
496  data_stream_assert(data_message_save(iterInt8, vecInt8)); //Save the message
497  char* loadIterInt8 = (char*)messageInt8.data();
498  std::vector<std::pair<char, char> > outVecInt8(0lu);
499  data_stream_assert(data_message_load(loadIterInt8, outVecInt8)); //Load the message
500  data_stream_assert(checkValue("std::vector<std::pair<char, char> >", outVecInt8, vecInt8));
501 }
502 
504 void testListPairDataMessage(){
505  size_t nbValue(10lu);
506 
507  std::list<std::pair<long unsigned int, long unsigned int> > vecUInt64;
508  for(size_t i(0lu); i < nbValue; ++i){vecUInt64.push_back(std::pair<long unsigned int, long unsigned int>(i,i));}
509  size_t sizeVecUInt64 = data_size(vecUInt64);
510  data_stream_assert(checkValue("std::list<std::pair<long unsigned int, long unsigned int> >", sizeVecUInt64, 2lu*8lu*nbValue + 8lu));
511 
512  std::list<std::pair<unsigned int, unsigned int> > vecUInt32;
513  for(size_t i(0lu); i < nbValue; ++i){vecUInt32.push_back(std::pair<unsigned int, unsigned int>(i,i));}
514  size_t sizeVecUInt32 = data_size(vecUInt32);
515  data_stream_assert(checkValue("std::list<std::pair<unsigned int, unsigned int> >", sizeVecUInt32, 2lu*4lu*nbValue + 8lu));
516 
517  std::list<std::pair<unsigned short, unsigned short> > vecUInt16;
518  for(size_t i(0lu); i < nbValue; ++i){vecUInt16.push_back(std::pair<unsigned short, unsigned short>(i,i));}
519  size_t sizeVecUInt16 = data_size(vecUInt16);
520  data_stream_assert(checkValue("std::list<std::pair<unsigned short, unsigned short> >", sizeVecUInt16, 2lu*2lu*nbValue + 8lu));
521 
522  std::list<std::pair<unsigned char, unsigned char> > vecUInt8;
523  for(size_t i(0lu); i < nbValue; ++i){vecUInt8.push_back(std::pair<unsigned char, unsigned char>(i,i));}
524  size_t sizeVecUInt8 = data_size(vecUInt8);
525  data_stream_assert(checkValue("std::list<std::pair<unsigned char, unsigned char> >", sizeVecUInt8, 2lu*1lu*nbValue + 8lu));
526 
527 
528  std::list<std::pair<long int, long int> > vecInt64;
529  for(size_t i(0lu); i < nbValue; ++i){vecInt64.push_back(std::pair<long int, long int>(i,i));}
530  size_t sizeVecInt64 = data_size(vecInt64);
531  data_stream_assert(checkValue("std::list<std::pair<long int, long int> >", sizeVecInt64, 2lu*8lu*nbValue + 8lu));
532 
533  std::list<std::pair<int,int> > vecInt32;
534  for(size_t i(0lu); i < nbValue; ++i){vecInt32.push_back(std::pair<int,int>(i,i));}
535  size_t sizeVecInt32 = data_size(vecInt32);
536  data_stream_assert(checkValue("std::list<std::pair<int,int> >", sizeVecInt32, 2lu*4lu*nbValue + 8lu));
537 
538  std::list<std::pair<short, short> > vecInt16;
539  for(size_t i(0lu); i < nbValue; ++i){vecInt16.push_back(std::pair<short, short>(i,i));}
540  size_t sizeVecInt16 = data_size(vecInt16);
541  data_stream_assert(checkValue("std::list<std::pair<short, short> >", sizeVecInt16, 2lu*2lu*nbValue + 8lu));
542 
543  std::list<std::pair<char, char> > vecInt8;
544  for(size_t i(0lu); i < nbValue; ++i){vecInt8.push_back(std::pair<char, char>(i,i));}
545  size_t sizeVecInt8 = data_size(vecInt8);
546  data_stream_assert(checkValue("std::list<std::pair<char, char> >", sizeVecInt8, 2lu*1lu*nbValue + 8lu));
547 }
548 
550 void testStringDataMessage(){
551  std::string str("One thing to say");
552  std::vector<char> messageStr(data_size(str));
553  char* iterStr = (char*)messageStr.data();
554  data_stream_assert(data_message_save(iterStr, str)); //Save the message
555  std::string outStr("");
556  char* loadIterStr = (char*)messageStr.data();
557  data_stream_assert(data_message_load(loadIterStr, outStr)); //Load the message
558 
559 // std::cout << "testStringDataMessage : outStr("<<outStr<<"), str("<<str<<")" << std::endl;
560  data_stream_assert(str == outStr);
561 }
562 
563 int main(int argc, char** argv){
564  testSimpleDataMessage();
565  testVectorDataMessage();
566  testListDataMessage();
567  testMapDataMessage();
568  testVectorPairDataMessage();
569  testListPairDataMessage();
570  testStringDataMessage();
571  return 0;
572 }
573 
testSimpleDataMessage
void testSimpleDataMessage()
Test if data size is Ok.
Definition: main.cpp:14
data_message.h
data_stream_assert
#define data_stream_assert(isOk)
Definition: data_stream_assert.h:17
data_stream_assert.h
testVectorDataMessage
void testVectorDataMessage()
Test if data size is Ok.
Definition: main.cpp:128
data_size
size_t data_size(T &data)
Get size of data.
Definition: data_size.h:17
testStringDataMessage
void testStringDataMessage()
Test if data size is Ok.
Definition: main.cpp:550
checkValue
bool checkValue(const std::string &testName, size_t givenSize, size_t referenceSize)
Check given value compare to the reference size.
Definition: main.cpp:16
data_stream_check_value.h
testVectorPairDataMessage
void testVectorPairDataMessage()
Test if data size is Ok.
Definition: main.cpp:410
data_message_save
bool data_message_save(Stream &iter, T &data)
Save data in a message.
Definition: data_message.h:18
testListDataMessage
void testListDataMessage()
Test if data size is Ok.
Definition: main.cpp:222
createReleaseCurl.str
str
Definition: createReleaseCurl.py:128
data_size.h
data_message_load
bool data_message_load(char *&iter, T &data)
Load data from a message.
Definition: data_message.h:60
testMapDataMessage
void testMapDataMessage()
Test if data size is Ok.
Definition: main.cpp:316
testListPairDataMessage
void testListPairDataMessage()
Test if data size is Ok.
Definition: main.cpp:504
main
int main(int argc, char **argv)
Definition: main.cpp:85