F´ Flight Software - C/C++ Documentation NASA-v1.6.0
A framework for building embedded system applications to NASA flight quality standards.
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
PortTests.hpp
Go to the documentation of this file.
1// ======================================================================
2// \title PortTests.hpp
3// \author T. Chieu
4// \brief hpp file for port tests
5//
6// \copyright
7// Copyright (C) 2009-2023 California Institute of Technology.
8// ALL RIGHTS RESERVED. United States Government Sponsorship
9// acknowledged.
10//
11// ======================================================================
12
13#include "FppTest/component/active/SerialPortIndexEnumAc.hpp"
14#include "FppTest/component/active/TypedPortIndexEnumAc.hpp"
15#include "test/ut/Tester.hpp"
16
17// ----------------------------------------------------------------------
18// Port test declarations
19// ----------------------------------------------------------------------
20
21#define PORT_TEST_INVOKE_DECL(PORT_KIND, TYPE) \
22 void test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::TYPE& port);
23
24#define PORT_TEST_INVOKE_DECLS(PORT_KIND) \
25 PORT_TEST_INVOKE_DECL(PORT_KIND, NoParams) \
26 PORT_TEST_INVOKE_DECL(PORT_KIND, PrimitiveParams) \
27 PORT_TEST_INVOKE_DECL(PORT_KIND, PortStringParams) \
28 PORT_TEST_INVOKE_DECL(PORT_KIND, EnumParams) \
29 PORT_TEST_INVOKE_DECL(PORT_KIND, ArrayParams) \
30 PORT_TEST_INVOKE_DECL(PORT_KIND, StructParams) \
31 PORT_TEST_INVOKE_DECL(PORT_KIND, NoParamReturn) \
32 PORT_TEST_INVOKE_DECL(PORT_KIND, PrimitiveReturn) \
33 PORT_TEST_INVOKE_DECL(PORT_KIND, EnumReturn) \
34 PORT_TEST_INVOKE_DECL(PORT_KIND, ArrayReturn) \
35 PORT_TEST_INVOKE_DECL(PORT_KIND, StructReturn)
36
37#define PORT_TEST_INVOKE_SERIAL_HELPER_DECL(PORT_KIND) \
38 void invoke##PORT_KIND##SerialPort(NATIVE_INT_TYPE portNum, Fw::SerialBuffer& buf);
39
40#define PORT_TEST_INVOKE_SERIAL_DECL(PORT_KIND, TYPE) \
41 void test##PORT_KIND##PortInvokeSerial(NATIVE_INT_TYPE portNum, FppTest::Types::TYPE& port);
42
43#define PORT_TEST_INVOKE_SERIAL_DECLS(PORT_KIND) \
44 PORT_TEST_INVOKE_SERIAL_DECL(PORT_KIND, NoParams) \
45 PORT_TEST_INVOKE_SERIAL_DECL(PORT_KIND, PrimitiveParams) \
46 PORT_TEST_INVOKE_SERIAL_DECL(PORT_KIND, PortStringParams) \
47 PORT_TEST_INVOKE_SERIAL_DECL(PORT_KIND, EnumParams) \
48 PORT_TEST_INVOKE_SERIAL_DECL(PORT_KIND, ArrayParams) \
49 PORT_TEST_INVOKE_SERIAL_DECL(PORT_KIND, StructParams)
50
51#define PORT_TEST_CHECK_DECL(PORT_KIND, TYPE) void test##PORT_KIND##PortCheck(FppTest::Types::TYPE& port);
52
53#define PORT_TEST_CHECK_DECLS(PORT_KIND) \
54 PORT_TEST_CHECK_DECL(PORT_KIND, NoParams) \
55 PORT_TEST_CHECK_DECL(PORT_KIND, PrimitiveParams) \
56 PORT_TEST_CHECK_DECL(PORT_KIND, PortStringParams) \
57 PORT_TEST_CHECK_DECL(PORT_KIND, EnumParams) \
58 PORT_TEST_CHECK_DECL(PORT_KIND, ArrayParams) \
59 PORT_TEST_CHECK_DECL(PORT_KIND, StructParams) \
60 PORT_TEST_CHECK_DECL(PORT_KIND, NoParamReturn) \
61 PORT_TEST_CHECK_DECL(PORT_KIND, PrimitiveReturn) \
62 PORT_TEST_CHECK_DECL(PORT_KIND, EnumReturn) \
63 PORT_TEST_CHECK_DECL(PORT_KIND, ArrayReturn) \
64 PORT_TEST_CHECK_DECL(PORT_KIND, StructReturn)
65
66#define PORT_TEST_CHECK_SERIAL_DECL(PORT_KIND, TYPE) void test##PORT_KIND##PortCheckSerial(FppTest::Types::TYPE& port);
67
68#define PORT_TEST_CHECK_SERIAL_DECLS(PORT_KIND) \
69 PORT_TEST_CHECK_SERIAL_DECL(PORT_KIND, NoParams) \
70 PORT_TEST_CHECK_SERIAL_DECL(PORT_KIND, PrimitiveParams) \
71 PORT_TEST_CHECK_SERIAL_DECL(PORT_KIND, PortStringParams) \
72 PORT_TEST_CHECK_SERIAL_DECL(PORT_KIND, EnumParams) \
73 PORT_TEST_CHECK_SERIAL_DECL(PORT_KIND, ArrayParams) \
74 PORT_TEST_CHECK_SERIAL_DECL(PORT_KIND, StructParams)
75
76#define PORT_TEST_DECLS_KIND(PORT_KIND) \
77 PORT_TEST_INVOKE_DECLS(PORT_KIND) \
78 PORT_TEST_INVOKE_SERIAL_HELPER_DECL(PORT_KIND) \
79 PORT_TEST_INVOKE_SERIAL_DECLS(PORT_KIND) \
80 PORT_TEST_CHECK_DECLS(PORT_KIND) \
81 PORT_TEST_CHECK_SERIAL_DECLS(PORT_KIND)
82
83#define PORT_TEST_DECLS \
84 PORT_TEST_DECLS_KIND(Sync) \
85 PORT_TEST_DECLS_KIND(Guarded)
86
87#define PORT_TEST_DECLS_ASYNC PORT_TEST_DECLS_KIND(Async)
88
89// ----------------------------------------------------------------------
90// Invoke typed input ports
91// ----------------------------------------------------------------------
92
93#define PORT_TEST_INVOKE_DEFS(PORT_KIND) \
94 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::NoParams& port) { \
95 ASSERT_TRUE(component.isConnected_noArgsOut_OutputPort(portNum)); \
96 \
97 this->invoke_to_noArgs##PORT_KIND(portNum); \
98 } \
99 \
100 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::PrimitiveParams& port) { \
101 ASSERT_TRUE(component.isConnected_primitiveArgsOut_OutputPort(portNum)); \
102 \
103 this->invoke_to_primitiveArgs##PORT_KIND(portNum, port.args.val1, port.args.val2, port.args.val3, \
104 port.args.val4, port.args.val5, port.args.val6); \
105 } \
106 \
107 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::PortStringParams& port) { \
108 ASSERT_TRUE(component.isConnected_stringArgsOut_OutputPort(portNum)); \
109 \
110 this->invoke_to_stringArgs##PORT_KIND(portNum, port.args.val1, port.args.val2, port.args.val3, \
111 port.args.val4); \
112 } \
113 \
114 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::EnumParams& port) { \
115 ASSERT_TRUE(component.isConnected_enumArgsOut_OutputPort(portNum)); \
116 \
117 this->invoke_to_enumArgs##PORT_KIND(portNum, port.args.val1, port.args.val2); \
118 } \
119 \
120 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::ArrayParams& port) { \
121 ASSERT_TRUE(component.isConnected_arrayArgsOut_OutputPort(portNum)); \
122 \
123 this->invoke_to_arrayArgs##PORT_KIND(portNum, port.args.val1, port.args.val2); \
124 } \
125 \
126 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::StructParams& port) { \
127 ASSERT_TRUE(component.isConnected_structArgsOut_OutputPort(portNum)); \
128 \
129 this->invoke_to_structArgs##PORT_KIND(portNum, port.args.val1, port.args.val2); \
130 }
131
132#define PORT_TEST_INVOKE_RETURN_DEFS(PORT_KIND) \
133 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::NoParamReturn& port) { \
134 ASSERT_TRUE(component.isConnected_noArgsReturnOut_OutputPort(portNum)); \
135 \
136 bool returnVal = this->invoke_to_noArgsReturn##PORT_KIND(portNum); \
137 \
138 ASSERT_EQ(returnVal, this->noParamReturnVal.val); \
139 } \
140 \
141 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::PrimitiveReturn& port) { \
142 ASSERT_TRUE(component.isConnected_primitiveReturnOut_OutputPort(portNum)); \
143 \
144 U32 returnVal = this->invoke_to_primitiveReturn##PORT_KIND( \
145 portNum, port.args.val1, port.args.val2, port.args.val3, port.args.val4, port.args.val5, port.args.val6); \
146 \
147 ASSERT_EQ(returnVal, this->primitiveReturnVal.val); \
148 } \
149 \
150 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::EnumReturn& port) { \
151 ASSERT_TRUE(component.isConnected_enumReturnOut_OutputPort(portNum)); \
152 \
153 FormalParamEnum returnVal = this->invoke_to_enumReturn##PORT_KIND(portNum, port.args.val1, port.args.val2); \
154 \
155 ASSERT_EQ(returnVal, this->enumReturnVal.val); \
156 } \
157 \
158 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::ArrayReturn& port) { \
159 ASSERT_TRUE(component.isConnected_arrayReturnOut_OutputPort(portNum)); \
160 \
161 FormalParamArray returnVal = this->invoke_to_arrayReturn##PORT_KIND(portNum, port.args.val1, port.args.val2); \
162 \
163 ASSERT_EQ(returnVal, this->arrayReturnVal.val); \
164 } \
165 \
166 void Tester ::test##PORT_KIND##PortInvoke(NATIVE_INT_TYPE portNum, FppTest::Types::StructReturn& port) { \
167 ASSERT_TRUE(component.isConnected_structReturnOut_OutputPort(portNum)); \
168 \
169 FormalParamStruct returnVal = \
170 this->invoke_to_structReturn##PORT_KIND(portNum, port.args.val1, port.args.val2); \
171 \
172 ASSERT_EQ(returnVal, this->structReturnVal.val); \
173 }
174
175// ----------------------------------------------------------------------
176// Invoke serial input ports
177// ----------------------------------------------------------------------
178
179#define PORT_TEST_INVOKE_SERIAL_HELPER_DEF(PORT_KIND) \
180 void Tester ::invoke##PORT_KIND##SerialPort(NATIVE_INT_TYPE portNum, Fw::SerialBuffer& buf) { \
181 this->invoke_to_serial##PORT_KIND(portNum, buf); \
182 }
183
184#define PORT_TEST_INVOKE_SERIAL_HELPER_DEF_ASYNC \
185 void Tester ::invokeAsyncSerialPort(NATIVE_INT_TYPE portNum, Fw::SerialBuffer& buf) { \
186 Fw::QueuedComponentBase::MsgDispatchStatus status; \
187 \
188 switch (portNum) { \
189 case SerialPortIndex::NO_ARGS: \
190 case SerialPortIndex::PRIMITIVE: \
191 case SerialPortIndex::STRING: \
192 this->invoke_to_serialAsync(portNum, buf); \
193 break; \
194 \
195 case SerialPortIndex::ENUM: \
196 this->invoke_to_serialAsyncAssert(0, buf); \
197 break; \
198 \
199 case SerialPortIndex::ARRAY: \
200 this->invoke_to_serialAsyncBlockPriority(0, buf); \
201 break; \
202 \
203 case SerialPortIndex::STRUCT: \
204 this->invoke_to_serialAsyncDropPriority(0, buf); \
205 break; \
206 } \
207 \
208 status = this->doDispatch(); \
209 \
210 ASSERT_EQ(status, Fw::QueuedComponentBase::MsgDispatchStatus::MSG_DISPATCH_OK); \
211 }
212
213#define PORT_TEST_INVOKE_SERIAL_DEFS(PORT_KIND) \
214 void Tester ::test##PORT_KIND##PortInvokeSerial(NATIVE_INT_TYPE portNum, FppTest::Types::NoParams& port) { \
215 ASSERT_TRUE(component.isConnected_serialOut_OutputPort(portNum)); \
216 \
217 U8 data[0]; \
218 Fw::SerialBuffer buf(data, sizeof(data)); \
219 \
220 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::NO_ARGS, buf); \
221 } \
222 \
223 void Tester ::test##PORT_KIND##PortInvokeSerial(NATIVE_INT_TYPE portNum, FppTest::Types::PrimitiveParams& port) { \
224 ASSERT_TRUE(component.isConnected_serialOut_OutputPort(portNum)); \
225 \
226 Fw::SerializeStatus status; \
227 \
228 /* Check unsuccessful deserialization of first parameter */ \
229 U8 invalidData1[0]; \
230 Fw::SerialBuffer invalidBuf1(invalidData1, sizeof(invalidData1)); \
231 \
232 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::PRIMITIVE, invalidBuf1); \
233 \
234 this->checkSerializeStatusBufferEmpty(); \
235 \
236 /* Check unsuccessful deserialization of second parameter */ \
237 U8 invalidData2[sizeof(U32)]; \
238 Fw::SerialBuffer invalidBuf2(invalidData2, sizeof(invalidData2)); \
239 \
240 status = invalidBuf2.serialize(port.args.val1); \
241 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
242 \
243 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::PRIMITIVE, invalidBuf2); \
244 \
245 this->checkSerializeStatusBufferEmpty(); \
246 \
247 /* Check unsuccessful deserialization of third parameter */ \
248 U8 invalidData3[sizeof(U32) * 2]; \
249 Fw::SerialBuffer invalidBuf3(invalidData3, sizeof(invalidData3)); \
250 \
251 status = invalidBuf3.serialize(port.args.val1); \
252 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
253 \
254 status = invalidBuf3.serialize(port.args.val2); \
255 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
256 \
257 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::PRIMITIVE, invalidBuf3); \
258 \
259 this->checkSerializeStatusBufferEmpty(); \
260 \
261 /* Check unsuccessful deserialization of fourth parameter */ \
262 U8 invalidData4[(sizeof(U32) * 2) + sizeof(F32)]; \
263 Fw::SerialBuffer invalidBuf4(invalidData4, sizeof(invalidData4)); \
264 \
265 status = invalidBuf4.serialize(port.args.val1); \
266 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
267 \
268 status = invalidBuf4.serialize(port.args.val2); \
269 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
270 \
271 status = invalidBuf4.serialize(port.args.val3); \
272 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
273 \
274 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::PRIMITIVE, invalidBuf4); \
275 \
276 this->checkSerializeStatusBufferEmpty(); \
277 \
278 /* Check unsuccessful deserialization of fifth parameter */ \
279 U8 invalidData5[(sizeof(U32) * 2) + (sizeof(F32) * 2)]; \
280 Fw::SerialBuffer invalidBuf5(invalidData5, sizeof(invalidData5)); \
281 \
282 status = invalidBuf5.serialize(port.args.val1); \
283 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
284 \
285 status = invalidBuf5.serialize(port.args.val2); \
286 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
287 \
288 status = invalidBuf5.serialize(port.args.val3); \
289 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
290 \
291 status = invalidBuf5.serialize(port.args.val4); \
292 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
293 \
294 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::PRIMITIVE, invalidBuf5); \
295 \
296 this->checkSerializeStatusBufferEmpty(); \
297 \
298 /* Check unsuccessful deserialization of sixth parameter */ \
299 U8 invalidData6[(sizeof(U32) * 2) + (sizeof(F32) * 2) + sizeof(U8)]; \
300 Fw::SerialBuffer invalidBuf6(invalidData6, sizeof(invalidData6)); \
301 \
302 status = invalidBuf6.serialize(port.args.val1); \
303 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
304 \
305 status = invalidBuf6.serialize(port.args.val2); \
306 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
307 \
308 status = invalidBuf6.serialize(port.args.val3); \
309 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
310 \
311 status = invalidBuf6.serialize(port.args.val4); \
312 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
313 \
314 status = invalidBuf6.serialize(port.args.val5); \
315 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
316 \
317 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::PRIMITIVE, invalidBuf6); \
318 \
319 this->checkSerializeStatusBufferEmpty(); \
320 \
321 /* Check successful serialization */ \
322 U8 data[InputPrimitiveArgsPort::SERIALIZED_SIZE]; \
323 Fw::SerialBuffer buf(data, sizeof(data)); \
324 \
325 status = buf.serialize(port.args.val1); \
326 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
327 \
328 status = buf.serialize(port.args.val2); \
329 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
330 \
331 status = buf.serialize(port.args.val3); \
332 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
333 \
334 status = buf.serialize(port.args.val4); \
335 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
336 \
337 status = buf.serialize(port.args.val5); \
338 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
339 \
340 status = buf.serialize(port.args.val6); \
341 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
342 \
343 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::PRIMITIVE, buf); \
344 \
345 this->checkSerializeStatusSuccess(); \
346 } \
347 \
348 void Tester ::test##PORT_KIND##PortInvokeSerial(NATIVE_INT_TYPE portNum, FppTest::Types::PortStringParams& port) { \
349 ASSERT_TRUE(component.isConnected_serialOut_OutputPort(portNum)); \
350 \
351 Fw::SerializeStatus status; \
352 \
353 /* Check unsuccessful deserialization of first parameter */ \
354 U8 invalidData1[0]; \
355 Fw::SerialBuffer invalidBuf1(invalidData1, sizeof(invalidData1)); \
356 \
357 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::STRING, invalidBuf1); \
358 \
359 this->checkSerializeStatusBufferEmpty(); \
360 \
361 /* Check unsuccessful deserialization of second parameter */ \
362 U8 invalidData2[StringArgsPortStrings::StringSize80::SERIALIZED_SIZE]; \
363 Fw::SerialBuffer invalidBuf2(invalidData2, sizeof(invalidData2)); \
364 \
365 status = invalidBuf2.serialize(port.args.val1); \
366 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
367 \
368 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::STRING, invalidBuf2); \
369 \
370 this->checkSerializeStatusBufferEmpty(); \
371 \
372 /* Check unsuccessful deserialization of third parameter */ \
373 U8 invalidData3[StringArgsPortStrings::StringSize80::SERIALIZED_SIZE * 2]; \
374 Fw::SerialBuffer invalidBuf3(invalidData3, sizeof(invalidData3)); \
375 \
376 status = invalidBuf3.serialize(port.args.val1); \
377 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
378 \
379 status = invalidBuf3.serialize(port.args.val2); \
380 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
381 \
382 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::STRING, invalidBuf3); \
383 \
384 this->checkSerializeStatusBufferEmpty(); \
385 \
386 /* Check unsuccessful deserialization of fourth parameter */ \
387 U8 invalidData4[(StringArgsPortStrings::StringSize80::SERIALIZED_SIZE * 2) + \
388 StringArgsPortStrings::StringSize100::SERIALIZED_SIZE]; \
389 Fw::SerialBuffer invalidBuf4(invalidData4, sizeof(invalidData4)); \
390 \
391 status = invalidBuf4.serialize(port.args.val1); \
392 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
393 \
394 status = invalidBuf4.serialize(port.args.val2); \
395 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
396 \
397 status = invalidBuf4.serialize(port.args.val3); \
398 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
399 \
400 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::STRING, invalidBuf4); \
401 \
402 this->checkSerializeStatusBufferEmpty(); \
403 \
404 /* Check successful serialization */ \
405 U8 data[InputStringArgsPort::SERIALIZED_SIZE]; \
406 Fw::SerialBuffer buf(data, sizeof(data)); \
407 \
408 status = buf.serialize(port.args.val1); \
409 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
410 \
411 status = buf.serialize(port.args.val2); \
412 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
413 \
414 status = buf.serialize(port.args.val3); \
415 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
416 \
417 status = buf.serialize(port.args.val4); \
418 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
419 \
420 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::STRING, buf); \
421 \
422 this->checkSerializeStatusSuccess(); \
423 } \
424 \
425 void Tester ::test##PORT_KIND##PortInvokeSerial(NATIVE_INT_TYPE portNum, FppTest::Types::EnumParams& port) { \
426 ASSERT_TRUE(component.isConnected_serialOut_OutputPort(portNum)); \
427 \
428 Fw::SerializeStatus status; \
429 \
430 /* Check unsuccessful deserialization of first parameter */ \
431 U8 invalidData1[0]; \
432 Fw::SerialBuffer invalidBuf1(invalidData1, sizeof(invalidData1)); \
433 \
434 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::ENUM, invalidBuf1); \
435 \
436 this->checkSerializeStatusBufferEmpty(); \
437 \
438 /* Check unsuccessful deserialization of second parameter */ \
439 U8 invalidData2[FormalParamEnum::SERIALIZED_SIZE]; \
440 Fw::SerialBuffer invalidBuf2(invalidData2, sizeof(invalidData2)); \
441 \
442 status = invalidBuf2.serialize(port.args.val1); \
443 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
444 \
445 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::ENUM, invalidBuf2); \
446 \
447 this->checkSerializeStatusBufferEmpty(); \
448 \
449 /* Check successful serialization */ \
450 U8 data[InputEnumArgsPort::SERIALIZED_SIZE]; \
451 Fw::SerialBuffer buf(data, sizeof(data)); \
452 \
453 status = buf.serialize(port.args.val1); \
454 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
455 \
456 status = buf.serialize(port.args.val2); \
457 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
458 \
459 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::ENUM, buf); \
460 \
461 this->checkSerializeStatusSuccess(); \
462 } \
463 \
464 void Tester ::test##PORT_KIND##PortInvokeSerial(NATIVE_INT_TYPE portNum, FppTest::Types::ArrayParams& port) { \
465 ASSERT_TRUE(component.isConnected_serialOut_OutputPort(portNum)); \
466 \
467 Fw::SerializeStatus status; \
468 \
469 /* Check unsuccessful deserialization of first parameter */ \
470 U8 invalidData1[0]; \
471 Fw::SerialBuffer invalidBuf1(invalidData1, sizeof(invalidData1)); \
472 \
473 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::ARRAY, invalidBuf1); \
474 \
475 this->checkSerializeStatusBufferEmpty(); \
476 \
477 /* Check unsuccessful deserialization of second parameter */ \
478 U8 invalidData2[FormalParamArray::SERIALIZED_SIZE]; \
479 Fw::SerialBuffer invalidBuf2(invalidData2, sizeof(invalidData2)); \
480 \
481 status = invalidBuf2.serialize(port.args.val1); \
482 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
483 \
484 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::ARRAY, invalidBuf2); \
485 \
486 this->checkSerializeStatusBufferEmpty(); \
487 \
488 U8 data[InputArrayArgsPort::SERIALIZED_SIZE]; \
489 Fw::SerialBuffer buf(data, sizeof(data)); \
490 \
491 status = buf.serialize(port.args.val1); \
492 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
493 \
494 status = buf.serialize(port.args.val2); \
495 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
496 \
497 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::ARRAY, buf); \
498 \
499 this->checkSerializeStatusSuccess(); \
500 } \
501 \
502 void Tester ::test##PORT_KIND##PortInvokeSerial(NATIVE_INT_TYPE portNum, FppTest::Types::StructParams& port) { \
503 ASSERT_TRUE(component.isConnected_serialOut_OutputPort(portNum)); \
504 \
505 Fw::SerializeStatus status; \
506 \
507 /* Check unsuccessful deserialization of first parameter */ \
508 U8 invalidData1[0]; \
509 Fw::SerialBuffer invalidBuf1(invalidData1, sizeof(invalidData1)); \
510 \
511 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::STRUCT, invalidBuf1); \
512 \
513 this->checkSerializeStatusBufferEmpty(); \
514 \
515 /* Check unsuccessful deserialization of second parameter */ \
516 U8 invalidData2[FormalParamStruct::SERIALIZED_SIZE]; \
517 Fw::SerialBuffer invalidBuf2(invalidData2, sizeof(invalidData2)); \
518 \
519 status = invalidBuf2.serialize(port.args.val1); \
520 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
521 \
522 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::STRUCT, invalidBuf2); \
523 \
524 this->checkSerializeStatusBufferEmpty(); \
525 \
526 U8 data[InputStructArgsPort::SERIALIZED_SIZE]; \
527 Fw::SerialBuffer buf(data, sizeof(data)); \
528 \
529 status = buf.serialize(port.args.val1); \
530 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
531 \
532 status = buf.serialize(port.args.val2); \
533 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
534 \
535 this->invoke##PORT_KIND##SerialPort(SerialPortIndex::STRUCT, buf); \
536 \
537 this->checkSerializeStatusSuccess(); \
538 }
539
540// ----------------------------------------------------------------------
541// Check history of typed output ports
542// ----------------------------------------------------------------------
543
544#define PORT_TEST_CHECK_DEFS(PORT_KIND) \
545 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::NoParams& port) { \
546 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
547 ASSERT_from_noArgsOut_SIZE(1); \
548 } \
549 \
550 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::PrimitiveParams& port) { \
551 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
552 ASSERT_from_primitiveArgsOut_SIZE(1); \
553 ASSERT_from_primitiveArgsOut(0, port.args.val1, port.args.val2, port.args.val3, port.args.val4, \
554 port.args.val5, port.args.val6); \
555 } \
556 \
557 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::PortStringParams& port) { \
558 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
559 ASSERT_from_stringArgsOut_SIZE(1); \
560 ASSERT_from_stringArgsOut(0, port.args.val1, port.args.val2, port.args.val3, port.args.val4); \
561 } \
562 \
563 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::EnumParams& port) { \
564 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
565 ASSERT_from_enumArgsOut_SIZE(1); \
566 ASSERT_from_enumArgsOut(0, port.args.val1, port.args.val2); \
567 } \
568 \
569 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::ArrayParams& port) { \
570 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
571 ASSERT_from_arrayArgsOut_SIZE(1); \
572 ASSERT_from_arrayArgsOut(0, port.args.val1, port.args.val2); \
573 } \
574 \
575 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::StructParams& port) { \
576 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
577 ASSERT_from_structArgsOut_SIZE(1); \
578 ASSERT_from_structArgsOut(0, port.args.val1, port.args.val2); \
579 }
580
581#define PORT_TEST_CHECK_RETURN_DEFS(PORT_KIND) \
582 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::NoParamReturn& port) { \
583 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
584 ASSERT_from_noArgsReturnOut_SIZE(1); \
585 } \
586 \
587 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::PrimitiveReturn& port) { \
588 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
589 ASSERT_from_primitiveReturnOut_SIZE(1); \
590 ASSERT_from_primitiveReturnOut(0, port.args.val1, port.args.val2, port.args.val3, port.args.val4, \
591 port.args.val5, port.args.val6); \
592 } \
593 \
594 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::EnumReturn& port) { \
595 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
596 ASSERT_from_enumReturnOut_SIZE(1); \
597 ASSERT_from_enumReturnOut(0, port.args.val1, port.args.val2); \
598 } \
599 \
600 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::ArrayReturn& port) { \
601 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
602 ASSERT_from_arrayReturnOut_SIZE(1); \
603 ASSERT_from_arrayReturnOut(0, port.args.val1, port.args.val2); \
604 } \
605 \
606 void Tester ::test##PORT_KIND##PortCheck(FppTest::Types::StructReturn& port) { \
607 ASSERT_FROM_PORT_HISTORY_SIZE(1); \
608 ASSERT_from_structReturnOut_SIZE(1); \
609 ASSERT_from_structReturnOut(0, port.args.val1, port.args.val2); \
610 }
611
612// ----------------------------------------------------------------------
613// Check serial output ports
614// ----------------------------------------------------------------------
615
616#define PORT_TEST_CHECK_SERIAL_DEFS(PORT_KIND) \
617 void Tester ::test##PORT_KIND##PortCheckSerial(FppTest::Types::NoParams& port) {} \
618 \
619 void Tester ::test##PORT_KIND##PortCheckSerial(FppTest::Types::PrimitiveParams& port) { \
620 Fw::SerializeStatus status; \
621 U32 u32, u32Ref; \
622 F32 f32, f32Ref; \
623 bool b, bRef; \
624 \
625 status = this->primitiveBuf.deserialize(u32); \
626 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
627 \
628 status = this->primitiveBuf.deserialize(u32Ref); \
629 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
630 \
631 status = this->primitiveBuf.deserialize(f32); \
632 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
633 \
634 status = this->primitiveBuf.deserialize(f32Ref); \
635 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
636 \
637 status = this->primitiveBuf.deserialize(b); \
638 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
639 \
640 status = this->primitiveBuf.deserialize(bRef); \
641 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
642 \
643 ASSERT_EQ(u32, port.args.val1); \
644 ASSERT_EQ(u32Ref, port.args.val2); \
645 ASSERT_EQ(f32, port.args.val3); \
646 ASSERT_EQ(f32Ref, port.args.val4); \
647 ASSERT_EQ(b, port.args.val5); \
648 ASSERT_EQ(bRef, port.args.val6); \
649 } \
650 \
651 void Tester ::test##PORT_KIND##PortCheckSerial(FppTest::Types::PortStringParams& port) { \
652 Fw::SerializeStatus status; \
653 StringArgsPortStrings::StringSize80 str80, str80Ref; \
654 StringArgsPortStrings::StringSize100 str100, str100Ref; \
655 \
656 status = this->stringBuf.deserialize(str80); \
657 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
658 \
659 status = this->stringBuf.deserialize(str80Ref); \
660 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
661 \
662 status = this->stringBuf.deserialize(str100); \
663 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
664 \
665 status = this->stringBuf.deserialize(str100Ref); \
666 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
667 \
668 ASSERT_EQ(str80, port.args.val1); \
669 ASSERT_EQ(str80Ref, port.args.val2); \
670 ASSERT_EQ(str100, port.args.val3); \
671 ASSERT_EQ(str100Ref, port.args.val4); \
672 } \
673 \
674 void Tester ::test##PORT_KIND##PortCheckSerial(FppTest::Types::EnumParams& port) { \
675 Fw::SerializeStatus status; \
676 FormalParamEnum en, enRef; \
677 \
678 status = this->enumBuf.deserialize(en); \
679 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
680 \
681 status = this->enumBuf.deserialize(enRef); \
682 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
683 \
684 ASSERT_EQ(en, port.args.val1); \
685 ASSERT_EQ(enRef, port.args.val2); \
686 } \
687 \
688 void Tester ::test##PORT_KIND##PortCheckSerial(FppTest::Types::ArrayParams& port) { \
689 Fw::SerializeStatus status; \
690 FormalParamArray a, aRef; \
691 \
692 status = this->arrayBuf.deserialize(a); \
693 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
694 \
695 status = this->arrayBuf.deserialize(aRef); \
696 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
697 \
698 ASSERT_EQ(a, port.args.val1); \
699 ASSERT_EQ(aRef, port.args.val2); \
700 } \
701 \
702 void Tester ::test##PORT_KIND##PortCheckSerial(FppTest::Types::StructParams& port) { \
703 Fw::SerializeStatus status; \
704 FormalParamStruct s, sRef; \
705 \
706 status = this->structBuf.deserialize(s); \
707 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
708 \
709 status = this->structBuf.deserialize(sRef); \
710 ASSERT_EQ(status, Fw::FW_SERIALIZE_OK); \
711 \
712 ASSERT_EQ(s, port.args.val1); \
713 ASSERT_EQ(sRef, port.args.val2); \
714 }
715
716#define PORT_TEST_DEFS(PORT_KIND) \
717 PORT_TEST_INVOKE_DEFS(PORT_KIND) \
718 PORT_TEST_INVOKE_RETURN_DEFS(PORT_KIND) \
719 PORT_TEST_INVOKE_SERIAL_HELPER_DEF(PORT_KIND) \
720 PORT_TEST_INVOKE_SERIAL_DEFS(PORT_KIND) \
721 PORT_TEST_CHECK_DEFS(PORT_KIND) \
722 PORT_TEST_CHECK_RETURN_DEFS(PORT_KIND) \
723 PORT_TEST_CHECK_SERIAL_DEFS(PORT_KIND)
724
725#define PORT_TEST_DEFS_ASYNC \
726 PORT_TEST_INVOKE_DEFS(Async) \
727 PORT_TEST_INVOKE_SERIAL_HELPER_DEF_ASYNC \
728 PORT_TEST_INVOKE_SERIAL_DEFS(Async) \
729 PORT_TEST_CHECK_DEFS(Async) \
730 PORT_TEST_CHECK_SERIAL_DEFS(Async)