F´ Flight Software - C/C++ Documentation NASA-v1.6.0
A framework for building embedded system applications to NASA flight quality standards.
Loading...
Searching...
No Matches
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)