Commit | Line | Data |
---|---|---|
67016f61 GMF |
1 | /* |
2 | The software in this package is distributed under the GNU General | |
3 | Public License version 2 (with a special exception described below). | |
4 | ||
5 | A copy of GNU General Public License (GPL) is included in this distribution, | |
6 | in the file COPYING.GPL. | |
7 | ||
8 | As a special exception, if other files instantiate templates or use macros | |
9 | or inline functions from this file, or you compile this file and link it | |
10 | with other works to produce a work based on this file, this file | |
11 | does not by itself cause the resulting work to be covered | |
12 | by the GNU General Public License. | |
13 | ||
14 | However the source code for this file must still be made available | |
15 | in accordance with section (3) of the GNU General Public License. | |
16 | ||
17 | This exception does not invalidate any other reasons why a work based | |
18 | on this file might be covered by the GNU General Public License. | |
19 | */ | |
20 | ||
21 | #define BOOST_TEST_MAIN | |
22 | #define BOOST_TEST_DYN_LINK | |
3de1281b | 23 | |
3de1281b GMF |
24 | #include <streambuf> |
25 | ||
67016f61 GMF |
26 | #include <boost/test/unit_test.hpp> |
27 | ||
28 | #include "host/messagepayload.h" | |
29 | ||
2811d686 GMF |
30 | //------------------------------------------------------------------------------ |
31 | ||
32 | MessagePayload create_message_payload( const std::size_t bytes_total ); | |
33 | void fill_message_payload( | |
34 | const std::size_t bytes_total, | |
35 | const uint8_t first_value, | |
36 | MessagePayload& mp | |
37 | ); | |
38 | ||
39 | //------------------------------------------------------------------------------ | |
40 | ||
3de1281b GMF |
41 | MessagePayload create_message_payload( const std::size_t bytes_total ) |
42 | { | |
43 | return MessagePayload( bytes_total ); | |
44 | } | |
45 | ||
46 | void fill_message_payload( | |
47 | const std::size_t bytes_total, | |
48 | const uint8_t first_value, | |
49 | MessagePayload& mp | |
50 | ) | |
51 | { | |
52 | for ( std::size_t byte_index = 0; byte_index < bytes_total; byte_index++ ) | |
53 | { | |
54 | mp[ byte_index ] = static_cast<uint8_t>( first_value + byte_index ); | |
55 | } | |
56 | } | |
57 | ||
2811d686 GMF |
58 | //------------------------------------------------------------------------------ |
59 | ||
67016f61 GMF |
60 | BOOST_AUTO_TEST_SUITE( TestMessagePayload ) |
61 | ||
62 | BOOST_AUTO_TEST_CASE( basic_assignment ) | |
63 | { | |
3de1281b GMF |
64 | MessagePayload mp_filled = create_message_payload( 10 ); |
65 | fill_message_payload( 10, 0xC0, mp_filled ); | |
66 | ||
67 | MessagePayload mp_assigned = create_message_payload( 10 ); | |
68 | mp_assigned = mp_filled; | |
69 | ||
70 | BOOST_CHECK_EQUAL( mp_assigned[0], 0xC0 ); | |
71 | BOOST_CHECK_EQUAL( mp_assigned[1], 0xC1 ); | |
72 | BOOST_CHECK_EQUAL( mp_assigned[2], 0xC2 ); | |
73 | BOOST_CHECK_EQUAL( mp_assigned[3], 0xC3 ); | |
74 | BOOST_CHECK_EQUAL( mp_assigned[4], 0xC4 ); | |
75 | BOOST_CHECK_EQUAL( mp_assigned[5], 0xC5 ); | |
76 | BOOST_CHECK_EQUAL( mp_assigned[6], 0xC6 ); | |
77 | BOOST_CHECK_EQUAL( mp_assigned[7], 0xC7 ); | |
78 | BOOST_CHECK_EQUAL( mp_assigned[8], 0xC8 ); | |
79 | BOOST_CHECK_EQUAL( mp_assigned[9], 0xC9 ); | |
67016f61 GMF |
80 | } |
81 | ||
82 | BOOST_AUTO_TEST_CASE( array_subscript_const ) | |
83 | { | |
3de1281b GMF |
84 | MessagePayload mp_filled = create_message_payload( 10 ); |
85 | fill_message_payload( 10, 0xC0, mp_filled ); | |
86 | ||
87 | const MessagePayload mp_const( mp_filled ); | |
88 | ||
89 | BOOST_CHECK_EQUAL( mp_const[0], 0xC0 ); | |
90 | BOOST_CHECK_EQUAL( mp_const[1], 0xC1 ); | |
91 | BOOST_CHECK_EQUAL( mp_const[2], 0xC2 ); | |
92 | BOOST_CHECK_EQUAL( mp_const[3], 0xC3 ); | |
93 | BOOST_CHECK_EQUAL( mp_const[4], 0xC4 ); | |
94 | BOOST_CHECK_EQUAL( mp_const[5], 0xC5 ); | |
95 | BOOST_CHECK_EQUAL( mp_const[6], 0xC6 ); | |
96 | BOOST_CHECK_EQUAL( mp_const[7], 0xC7 ); | |
97 | BOOST_CHECK_EQUAL( mp_const[8], 0xC8 ); | |
98 | BOOST_CHECK_EQUAL( mp_const[9], 0xC9 ); | |
67016f61 GMF |
99 | } |
100 | ||
101 | BOOST_AUTO_TEST_CASE( array_subscript ) | |
102 | { | |
103 | MessagePayload mp( 10 ); | |
3de1281b GMF |
104 | mp[0] = 0xC0; |
105 | mp[1] = 0xC1; | |
106 | mp[2] = 0xC2; | |
107 | mp[3] = 0xC3; | |
108 | mp[4] = 0xC4; | |
109 | mp[5] = 0xC5; | |
110 | mp[6] = 0xC6; | |
111 | mp[7] = 0xC7; | |
112 | mp[8] = 0xC8; | |
113 | mp[9] = 0xC9; | |
114 | ||
115 | BOOST_CHECK_EQUAL( mp[0], 0xC0 ); | |
116 | BOOST_CHECK_EQUAL( mp[1], 0xC1 ); | |
117 | BOOST_CHECK_EQUAL( mp[2], 0xC2 ); | |
118 | BOOST_CHECK_EQUAL( mp[3], 0xC3 ); | |
119 | BOOST_CHECK_EQUAL( mp[4], 0xC4 ); | |
120 | BOOST_CHECK_EQUAL( mp[5], 0xC5 ); | |
121 | BOOST_CHECK_EQUAL( mp[6], 0xC6 ); | |
122 | BOOST_CHECK_EQUAL( mp[7], 0xC7 ); | |
123 | BOOST_CHECK_EQUAL( mp[8], 0xC8 ); | |
124 | BOOST_CHECK_EQUAL( mp[9], 0xC9 ); | |
67016f61 GMF |
125 | } |
126 | ||
127 | BOOST_AUTO_TEST_CASE( get ) | |
128 | { | |
3de1281b GMF |
129 | MessagePayload mp_filled = create_message_payload( 10 ); |
130 | fill_message_payload( 10, 0xC0, mp_filled ); | |
131 | ||
132 | uint8_t *mp_ptr = mp_filled.get(); | |
133 | BOOST_CHECK_EQUAL( mp_ptr[0], 0xC0 ); | |
134 | BOOST_CHECK_EQUAL( mp_ptr[1], 0xC1 ); | |
135 | BOOST_CHECK_EQUAL( mp_ptr[2], 0xC2 ); | |
136 | BOOST_CHECK_EQUAL( mp_ptr[3], 0xC3 ); | |
137 | BOOST_CHECK_EQUAL( mp_ptr[4], 0xC4 ); | |
138 | BOOST_CHECK_EQUAL( mp_ptr[5], 0xC5 ); | |
139 | BOOST_CHECK_EQUAL( mp_ptr[6], 0xC6 ); | |
140 | BOOST_CHECK_EQUAL( mp_ptr[7], 0xC7 ); | |
141 | BOOST_CHECK_EQUAL( mp_ptr[8], 0xC8 ); | |
142 | BOOST_CHECK_EQUAL( mp_ptr[9], 0xC9 ); | |
67016f61 GMF |
143 | } |
144 | ||
145 | BOOST_AUTO_TEST_CASE( append ) | |
146 | { | |
3de1281b GMF |
147 | MessagePayload mp_original( 10 ); |
148 | fill_message_payload( 10, 0xC0, mp_original ); | |
149 | ||
150 | MessagePayload mp_extra( 10 ); | |
151 | fill_message_payload( 10, 0xB0, mp_extra ); | |
152 | ||
153 | mp_original.append( mp_extra.get(), 10 ); | |
154 | ||
155 | BOOST_CHECK_EQUAL( mp_original[0], 0xC0 ); | |
156 | BOOST_CHECK_EQUAL( mp_original[1], 0xC1 ); | |
157 | BOOST_CHECK_EQUAL( mp_original[2], 0xC2 ); | |
158 | BOOST_CHECK_EQUAL( mp_original[3], 0xC3 ); | |
159 | BOOST_CHECK_EQUAL( mp_original[4], 0xC4 ); | |
160 | BOOST_CHECK_EQUAL( mp_original[5], 0xC5 ); | |
161 | BOOST_CHECK_EQUAL( mp_original[6], 0xC6 ); | |
162 | BOOST_CHECK_EQUAL( mp_original[7], 0xC7 ); | |
163 | BOOST_CHECK_EQUAL( mp_original[8], 0xC8 ); | |
164 | BOOST_CHECK_EQUAL( mp_original[9], 0xC9 ); | |
165 | ||
166 | BOOST_CHECK_EQUAL( mp_original[10], 0xB0 ); | |
167 | BOOST_CHECK_EQUAL( mp_original[11], 0xB1 ); | |
168 | BOOST_CHECK_EQUAL( mp_original[12], 0xB2 ); | |
169 | BOOST_CHECK_EQUAL( mp_original[13], 0xB3 ); | |
170 | BOOST_CHECK_EQUAL( mp_original[14], 0xB4 ); | |
171 | BOOST_CHECK_EQUAL( mp_original[15], 0xB5 ); | |
172 | BOOST_CHECK_EQUAL( mp_original[16], 0xB6 ); | |
173 | BOOST_CHECK_EQUAL( mp_original[17], 0xB7 ); | |
174 | BOOST_CHECK_EQUAL( mp_original[18], 0xB8 ); | |
175 | BOOST_CHECK_EQUAL( mp_original[19], 0xB9 ); | |
67016f61 GMF |
176 | } |
177 | ||
ad545958 GMF |
178 | BOOST_AUTO_TEST_CASE( decode1 ) |
179 | { | |
180 | MessagePayload mp = create_message_payload( 2 ); | |
181 | mp[0] = 0xAA; | |
182 | mp[1] = 0xAA; | |
183 | ||
184 | BOOST_CHECK_EQUAL( mp.decode1( 0, 0 ), true ); | |
185 | BOOST_CHECK_EQUAL( mp.decode1( 0, 1 ), false ); | |
186 | BOOST_CHECK_EQUAL( mp.decode1( 0, 2 ), true ); | |
187 | BOOST_CHECK_EQUAL( mp.decode1( 0, 3 ), false ); | |
188 | BOOST_CHECK_EQUAL( mp.decode1( 0, 4 ), true ); | |
189 | BOOST_CHECK_EQUAL( mp.decode1( 0, 5 ), false ); | |
190 | BOOST_CHECK_EQUAL( mp.decode1( 0, 6 ), true ); | |
191 | BOOST_CHECK_EQUAL( mp.decode1( 0, 7 ), false ); | |
192 | BOOST_CHECK_EQUAL( mp.decode1( 1, 0 ), true ); | |
193 | BOOST_CHECK_EQUAL( mp.decode1( 1, 1 ), false ); | |
194 | BOOST_CHECK_EQUAL( mp.decode1( 1, 2 ), true ); | |
195 | BOOST_CHECK_EQUAL( mp.decode1( 1, 3 ), false ); | |
196 | BOOST_CHECK_EQUAL( mp.decode1( 1, 4 ), true ); | |
197 | BOOST_CHECK_EQUAL( mp.decode1( 1, 5 ), false ); | |
198 | BOOST_CHECK_EQUAL( mp.decode1( 1, 6 ), true ); | |
199 | BOOST_CHECK_EQUAL( mp.decode1( 1, 7 ), false ); | |
200 | } | |
201 | ||
202 | BOOST_AUTO_TEST_CASE( encode1 ) | |
203 | { | |
204 | MessagePayload mp = create_message_payload( 2 ); | |
205 | mp[0] = 0x00; | |
206 | mp[1] = 0xFF; | |
207 | ||
208 | mp.encode1( 0, 0, true ); | |
209 | mp.encode1( 0, 1, false ); | |
210 | mp.encode1( 0, 2, true ); | |
211 | mp.encode1( 0, 3, false ); | |
212 | mp.encode1( 0, 4, true ); | |
213 | mp.encode1( 0, 5, false ); | |
214 | mp.encode1( 0, 6, true ); | |
215 | mp.encode1( 0, 7, false ); | |
216 | mp.encode1( 1, 0, true ); | |
217 | mp.encode1( 1, 1, false ); | |
218 | mp.encode1( 1, 2, true ); | |
219 | mp.encode1( 1, 3, false ); | |
220 | mp.encode1( 1, 4, true ); | |
221 | mp.encode1( 1, 5, false ); | |
222 | mp.encode1( 1, 6, true ); | |
223 | mp.encode1( 1, 7, false ); | |
224 | ||
225 | BOOST_CHECK_EQUAL( mp[0], 0xAA ); | |
226 | BOOST_CHECK_EQUAL( mp[1], 0xAA ); | |
227 | } | |
228 | ||
67016f61 GMF |
229 | BOOST_AUTO_TEST_CASE( decode16 ) |
230 | { | |
3de1281b GMF |
231 | MessagePayload mp = create_message_payload( 10 ); |
232 | fill_message_payload( 10, 0xC0, mp ); | |
233 | ||
234 | BOOST_CHECK_EQUAL( mp.decode16( 0, 1 ), 0xC0C1 ); | |
235 | BOOST_CHECK_EQUAL( mp.decode16( 1, 2 ), 0xC1C2 ); | |
236 | BOOST_CHECK_EQUAL( mp.decode16( 2, 3 ), 0xC2C3 ); | |
237 | BOOST_CHECK_EQUAL( mp.decode16( 3, 4 ), 0xC3C4 ); | |
238 | BOOST_CHECK_EQUAL( mp.decode16( 4, 5 ), 0xC4C5 ); | |
239 | BOOST_CHECK_EQUAL( mp.decode16( 5, 6 ), 0xC5C6 ); | |
240 | BOOST_CHECK_EQUAL( mp.decode16( 6, 7 ), 0xC6C7 ); | |
241 | BOOST_CHECK_EQUAL( mp.decode16( 7, 8 ), 0xC7C8 ); | |
242 | BOOST_CHECK_EQUAL( mp.decode16( 8, 9 ), 0xC8C9 ); | |
67016f61 GMF |
243 | } |
244 | ||
245 | BOOST_AUTO_TEST_CASE( encode16 ) | |
246 | { | |
3de1281b GMF |
247 | MessagePayload mp = create_message_payload( 10 ); |
248 | ||
249 | mp.encode16( 0, 1, 0xC0C1 ); | |
250 | mp.encode16( 1, 2, 0xC1C2 ); | |
251 | mp.encode16( 2, 3, 0xC2C3 ); | |
252 | mp.encode16( 3, 4, 0xC3C4 ); | |
253 | mp.encode16( 4, 5, 0xC4C5 ); | |
254 | mp.encode16( 5, 6, 0xC5C6 ); | |
255 | mp.encode16( 6, 7, 0xC6C7 ); | |
256 | mp.encode16( 7, 8, 0xC7C8 ); | |
257 | mp.encode16( 8, 9, 0xC8C9 ); | |
258 | ||
259 | BOOST_CHECK_EQUAL( mp[0], 0xC0 ); | |
260 | BOOST_CHECK_EQUAL( mp[1], 0xC1 ); | |
261 | BOOST_CHECK_EQUAL( mp[2], 0xC2 ); | |
262 | BOOST_CHECK_EQUAL( mp[3], 0xC3 ); | |
263 | BOOST_CHECK_EQUAL( mp[4], 0xC4 ); | |
264 | BOOST_CHECK_EQUAL( mp[5], 0xC5 ); | |
265 | BOOST_CHECK_EQUAL( mp[6], 0xC6 ); | |
266 | BOOST_CHECK_EQUAL( mp[7], 0xC7 ); | |
267 | BOOST_CHECK_EQUAL( mp[8], 0xC8 ); | |
268 | BOOST_CHECK_EQUAL( mp[9], 0xC9 ); | |
67016f61 GMF |
269 | } |
270 | ||
271 | BOOST_AUTO_TEST_CASE( decode32 ) | |
272 | { | |
3de1281b GMF |
273 | MessagePayload mp = create_message_payload( 10 ); |
274 | fill_message_payload( 10, 0xC0, mp ); | |
275 | ||
276 | BOOST_CHECK_EQUAL( mp.decode32( 0, 3 ), 0xC0C1C2C3 ); | |
277 | BOOST_CHECK_EQUAL( mp.decode32( 1, 4 ), 0xC1C2C3C4 ); | |
278 | BOOST_CHECK_EQUAL( mp.decode32( 2, 5 ), 0xC2C3C4C5 ); | |
279 | BOOST_CHECK_EQUAL( mp.decode32( 3, 6 ), 0xC3C4C5C6 ); | |
280 | BOOST_CHECK_EQUAL( mp.decode32( 4, 7 ), 0xC4C5C6C7 ); | |
281 | BOOST_CHECK_EQUAL( mp.decode32( 5, 8 ), 0xC5C6C7C8 ); | |
282 | BOOST_CHECK_EQUAL( mp.decode32( 6, 9 ), 0xC6C7C8C9 ); | |
67016f61 GMF |
283 | } |
284 | ||
285 | BOOST_AUTO_TEST_CASE( encode32 ) | |
286 | { | |
3de1281b GMF |
287 | MessagePayload mp = create_message_payload( 10 ); |
288 | ||
289 | mp.encode32( 0, 3, 0xC0C1C2C3 ); | |
290 | mp.encode32( 1, 4, 0xC1C2C3C4 ); | |
291 | mp.encode32( 2, 5, 0xC2C3C4C5 ); | |
292 | mp.encode32( 3, 6, 0xC3C4C5C6 ); | |
293 | mp.encode32( 4, 7, 0xC4C5C6C7 ); | |
294 | mp.encode32( 5, 8, 0xC5C6C7C8 ); | |
295 | mp.encode32( 6, 9, 0xC6C7C8C9 ); | |
296 | ||
297 | BOOST_CHECK_EQUAL( mp[0], 0xC0 ); | |
298 | BOOST_CHECK_EQUAL( mp[1], 0xC1 ); | |
299 | BOOST_CHECK_EQUAL( mp[2], 0xC2 ); | |
300 | BOOST_CHECK_EQUAL( mp[3], 0xC3 ); | |
301 | BOOST_CHECK_EQUAL( mp[4], 0xC4 ); | |
302 | BOOST_CHECK_EQUAL( mp[5], 0xC5 ); | |
303 | BOOST_CHECK_EQUAL( mp[6], 0xC6 ); | |
304 | BOOST_CHECK_EQUAL( mp[7], 0xC7 ); | |
305 | BOOST_CHECK_EQUAL( mp[8], 0xC8 ); | |
306 | BOOST_CHECK_EQUAL( mp[9], 0xC9 ); | |
67016f61 GMF |
307 | } |
308 | ||
309 | BOOST_AUTO_TEST_CASE( read ) | |
310 | { | |
3de1281b GMF |
311 | uint8_t numbers[] = { |
312 | 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9 | |
313 | }; | |
a270fcca | 314 | std::size_t numbers_count = sizeof(numbers); |
3de1281b GMF |
315 | |
316 | std::basic_stringbuf<uint8_t> sb; | |
a270fcca | 317 | sb.pubsetbuf( numbers, numbers_count ); |
3de1281b GMF |
318 | std::basic_istream<uint8_t> is( &sb ); |
319 | ||
a270fcca | 320 | MessagePayload mp = create_message_payload( numbers_count ); |
3de1281b GMF |
321 | mp.read( reinterpret_cast<std::istream&>(is) ); |
322 | ||
323 | BOOST_CHECK_EQUAL( mp[0], 0xC0 ); | |
324 | BOOST_CHECK_EQUAL( mp[1], 0xC1 ); | |
325 | BOOST_CHECK_EQUAL( mp[2], 0xC2 ); | |
326 | BOOST_CHECK_EQUAL( mp[3], 0xC3 ); | |
327 | BOOST_CHECK_EQUAL( mp[4], 0xC4 ); | |
328 | BOOST_CHECK_EQUAL( mp[5], 0xC5 ); | |
329 | BOOST_CHECK_EQUAL( mp[6], 0xC6 ); | |
330 | BOOST_CHECK_EQUAL( mp[7], 0xC7 ); | |
331 | BOOST_CHECK_EQUAL( mp[8], 0xC8 ); | |
332 | BOOST_CHECK_EQUAL( mp[9], 0xC9 ); | |
67016f61 GMF |
333 | } |
334 | ||
335 | BOOST_AUTO_TEST_CASE( write ) | |
336 | { | |
3de1281b GMF |
337 | uint8_t numbers[ 10 ]; |
338 | std::fill( numbers, numbers + 9, 0 ); | |
339 | ||
a270fcca GMF |
340 | std::size_t numbers_count = sizeof(numbers); |
341 | ||
3de1281b | 342 | std::basic_stringbuf<uint8_t> sb; |
a270fcca | 343 | sb.pubsetbuf( numbers, numbers_count ); |
3de1281b GMF |
344 | std::basic_ostream<uint8_t> os( &sb ); |
345 | ||
a270fcca GMF |
346 | MessagePayload mp = create_message_payload( numbers_count ); |
347 | fill_message_payload( numbers_count, 0xC0, mp ); | |
3de1281b GMF |
348 | mp.write( reinterpret_cast<std::ostream&>(os) ); |
349 | os.flush(); | |
350 | ||
351 | BOOST_CHECK_EQUAL( numbers[0], 0xC0 ); | |
352 | BOOST_CHECK_EQUAL( numbers[1], 0xC1 ); | |
353 | BOOST_CHECK_EQUAL( numbers[2], 0xC2 ); | |
354 | BOOST_CHECK_EQUAL( numbers[3], 0xC3 ); | |
355 | BOOST_CHECK_EQUAL( numbers[4], 0xC4 ); | |
356 | BOOST_CHECK_EQUAL( numbers[5], 0xC5 ); | |
357 | BOOST_CHECK_EQUAL( numbers[6], 0xC6 ); | |
358 | BOOST_CHECK_EQUAL( numbers[7], 0xC7 ); | |
359 | BOOST_CHECK_EQUAL( numbers[8], 0xC8 ); | |
360 | BOOST_CHECK_EQUAL( numbers[9], 0xC9 ); | |
67016f61 GMF |
361 | } |
362 | ||
363 | BOOST_AUTO_TEST_SUITE_END() |