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
CmdTests.hpp
Go to the documentation of this file.
1// ======================================================================
2// \title CmdTests.hpp
3// \author T. Chieu
4// \brief hpp file for command 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 "test/ut/Tester.hpp"
14
15// ----------------------------------------------------------------------
16// Command test declarations
17// ----------------------------------------------------------------------
18
19#define CMD_TEST_INVOKE_DECL(TYPE) void invoke##TYPE##Command(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf);
20
21#define CMD_TEST_INVOKE_DECLS \
22 CMD_TEST_INVOKE_DECL(NoArgs) \
23 CMD_TEST_INVOKE_DECL(Primitive) \
24 CMD_TEST_INVOKE_DECL(String) \
25 CMD_TEST_INVOKE_DECL(Enum) \
26 CMD_TEST_INVOKE_DECL(Array) \
27 CMD_TEST_INVOKE_DECL(Struct)
28
29#define CMD_TEST_INVOKE_DECLS_ASYNC \
30 CMD_TEST_INVOKE_DECL(AsyncNoArgs) \
31 CMD_TEST_INVOKE_DECL(AsyncPrimitive) \
32 CMD_TEST_INVOKE_DECL(AsyncString) \
33 CMD_TEST_INVOKE_DECL(AsyncEnum) \
34 CMD_TEST_INVOKE_DECL(AsyncArray) \
35 CMD_TEST_INVOKE_DECL(AsyncStruct)
36
37#define CMD_TEST_DECL(TYPE, ASYNC) void test##ASYNC##Command(NATIVE_INT_TYPE portNum, FppTest::Types::TYPE& data);
38
39#define CMD_TEST_DECLS \
40 CMD_TEST_INVOKE_DECLS \
41 CMD_TEST_DECL(NoParams, ) \
42 CMD_TEST_DECL(PrimitiveParams, ) \
43 CMD_TEST_DECL(CmdStringParams, ) \
44 CMD_TEST_DECL(EnumParam, ) \
45 CMD_TEST_DECL(ArrayParam, ) \
46 CMD_TEST_DECL(StructParam, )
47
48#define CMD_TEST_DECLS_ASYNC \
49 CMD_TEST_INVOKE_DECLS_ASYNC \
50 CMD_TEST_DECL(NoParams, Async) \
51 CMD_TEST_DECL(PrimitiveParams, Async) \
52 CMD_TEST_DECL(CmdStringParams, Async) \
53 CMD_TEST_DECL(EnumParam, Async) \
54 CMD_TEST_DECL(ArrayParam, Async) \
55 CMD_TEST_DECL(StructParam, Async)
56
57// ----------------------------------------------------------------------
58// Command test definitions
59// ----------------------------------------------------------------------
60
61#define CMD_TEST_INVOKE_DEFS \
62 void Tester ::invokeNoArgsCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
63 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_NO_ARGS, 1, buf); \
64 } \
65 \
66 void Tester ::invokePrimitiveCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
67 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_PRIMITIVE, 1, buf); \
68 } \
69 \
70 void Tester ::invokeStringCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
71 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_STRINGS, 1, buf); \
72 } \
73 \
74 void Tester ::invokeEnumCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
75 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_ENUM, 1, buf); \
76 } \
77 \
78 void Tester ::invokeArrayCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
79 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_ARRAY, 1, buf); \
80 } \
81 \
82 void Tester ::invokeStructCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
83 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_STRUCT, 1, buf); \
84 }
85
86#define CMD_TEST_INVOKE_DEFS_ASYNC \
87 void Tester ::invokeAsyncNoArgsCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
88 Fw::QueuedComponentBase::MsgDispatchStatus status; \
89 \
90 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_ASYNC_NO_ARGS, 1, buf); \
91 status = this->doDispatch(); \
92 \
93 ASSERT_EQ(status, Fw::QueuedComponentBase::MsgDispatchStatus::MSG_DISPATCH_OK); \
94 } \
95 \
96 void Tester ::invokeAsyncPrimitiveCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
97 Fw::QueuedComponentBase::MsgDispatchStatus status; \
98 \
99 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_ASYNC_PRIMITIVE, 1, buf); \
100 status = this->doDispatch(); \
101 \
102 ASSERT_EQ(status, Fw::QueuedComponentBase::MsgDispatchStatus::MSG_DISPATCH_OK); \
103 } \
104 \
105 void Tester ::invokeAsyncStringCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
106 Fw::QueuedComponentBase::MsgDispatchStatus status; \
107 \
108 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_ASYNC_STRINGS, 1, buf); \
109 status = this->doDispatch(); \
110 \
111 ASSERT_EQ(status, Fw::QueuedComponentBase::MsgDispatchStatus::MSG_DISPATCH_OK); \
112 } \
113 \
114 void Tester ::invokeAsyncEnumCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
115 Fw::QueuedComponentBase::MsgDispatchStatus status; \
116 \
117 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_ASYNC_ENUM, 1, buf); \
118 status = this->doDispatch(); \
119 \
120 ASSERT_EQ(status, Fw::QueuedComponentBase::MsgDispatchStatus::MSG_DISPATCH_OK); \
121 } \
122 \
123 void Tester ::invokeAsyncArrayCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
124 Fw::QueuedComponentBase::MsgDispatchStatus status; \
125 \
126 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_ASYNC_ARRAY, 1, buf); \
127 status = this->doDispatch(); \
128 \
129 ASSERT_EQ(status, Fw::QueuedComponentBase::MsgDispatchStatus::MSG_DISPATCH_OK); \
130 } \
131 \
132 void Tester ::invokeAsyncStructCommand(NATIVE_INT_TYPE portNum, Fw::CmdArgBuffer& buf) { \
133 Fw::QueuedComponentBase::MsgDispatchStatus status; \
134 \
135 this->invoke_to_cmdOut(portNum, component.OPCODE_CMD_ASYNC_STRUCT, 1, buf); \
136 status = this->doDispatch(); \
137 \
138 ASSERT_EQ(status, Fw::QueuedComponentBase::MsgDispatchStatus::MSG_DISPATCH_OK); \
139 }
140
141#define CMD_TEST_DEFS(ASYNC) \
142 void Tester ::test##ASYNC##Command(NATIVE_INT_TYPE portNum, FppTest::Types::NoParams& data) { \
143 ASSERT_TRUE(component.isConnected_cmdRegOut_OutputPort(portNum)); \
144 ASSERT_TRUE(component.isConnected_cmdResponseOut_OutputPort(portNum)); \
145 \
146 component.regCommands(); \
147 \
148 Fw::CmdArgBuffer buf; \
149 \
150 /* Test success */ \
151 this->invoke##ASYNC##NoArgsCommand(portNum, buf); \
152 ASSERT_EQ(cmdResp, Fw::CmdResponse::OK); \
153 \
154 /* Test too many arguments */ \
155 buf.serialize(0); \
156 this->invoke##ASYNC##NoArgsCommand(portNum, buf); \
157 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
158 } \
159 \
160 void Tester ::test##ASYNC##Command(NATIVE_INT_TYPE portNum, FppTest::Types::PrimitiveParams& data) { \
161 ASSERT_TRUE(component.isConnected_cmdRegOut_OutputPort(portNum)); \
162 ASSERT_TRUE(component.isConnected_cmdResponseOut_OutputPort(portNum)); \
163 \
164 component.regCommands(); \
165 \
166 Fw::CmdArgBuffer buf; \
167 \
168 /* Test incorrect deserialization of first argument */ \
169 this->invoke##ASYNC##PrimitiveCommand(portNum, buf); \
170 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
171 \
172 /* Test incorrect deserialization of second argument */ \
173 buf.serialize(data.args.val1); \
174 this->invoke##ASYNC##PrimitiveCommand(portNum, buf); \
175 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
176 \
177 /* Test incorrect deserialization of third argument */ \
178 buf.serialize(data.args.val2); \
179 this->invoke##ASYNC##PrimitiveCommand(portNum, buf); \
180 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
181 \
182 /* Test incorrect deserialization of fourth argument */ \
183 buf.serialize(data.args.val3); \
184 this->invoke##ASYNC##PrimitiveCommand(portNum, buf); \
185 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
186 \
187 /* Test incorrect deserialization of fifth argument */ \
188 buf.serialize(data.args.val4); \
189 this->invoke##ASYNC##PrimitiveCommand(portNum, buf); \
190 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
191 \
192 /* Test incorrect deserialization of sixth argument */ \
193 buf.serialize(data.args.val5); \
194 this->invoke##ASYNC##PrimitiveCommand(portNum, buf); \
195 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
196 \
197 /* Test success */ \
198 buf.serialize(data.args.val6); \
199 this->invoke##ASYNC##PrimitiveCommand(portNum, buf); \
200 \
201 ASSERT_EQ(cmdResp, Fw::CmdResponse::OK); \
202 ASSERT_EQ(component.primitiveCmd.args.val1, data.args.val1); \
203 ASSERT_EQ(component.primitiveCmd.args.val2, data.args.val2); \
204 ASSERT_EQ(component.primitiveCmd.args.val3, data.args.val3); \
205 ASSERT_EQ(component.primitiveCmd.args.val4, data.args.val4); \
206 ASSERT_EQ(component.primitiveCmd.args.val5, data.args.val5); \
207 ASSERT_EQ(component.primitiveCmd.args.val6, data.args.val6); \
208 \
209 /* Test too many arguments */ \
210 buf.serialize(data.args.val5); \
211 this->invoke##ASYNC##PrimitiveCommand(portNum, buf); \
212 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
213 } \
214 \
215 void Tester ::test##ASYNC##Command(NATIVE_INT_TYPE portNum, FppTest::Types::CmdStringParams& data) { \
216 ASSERT_TRUE(component.isConnected_cmdRegOut_OutputPort(portNum)); \
217 ASSERT_TRUE(component.isConnected_cmdResponseOut_OutputPort(portNum)); \
218 \
219 component.regCommands(); \
220 \
221 Fw::CmdArgBuffer buf; \
222 \
223 /* Test incorrect serialization of first argument */ \
224 this->invoke##ASYNC##StringCommand(portNum, buf); \
225 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
226 \
227 /* Test incorrect serialization of second argument */ \
228 buf.serialize(data.args.val1); \
229 this->invoke##ASYNC##StringCommand(portNum, buf); \
230 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
231 \
232 /* Test success */ \
233 buf.serialize(data.args.val2); \
234 this->invoke##ASYNC##StringCommand(portNum, buf); \
235 \
236 ASSERT_EQ(cmdResp, Fw::CmdResponse::OK); \
237 ASSERT_EQ(component.stringCmd.args.val1, data.args.val1); \
238 ASSERT_EQ(component.stringCmd.args.val2, data.args.val2); \
239 \
240 /* Test too many arguments */ \
241 buf.serialize(data.args.val1); \
242 this->invoke##ASYNC##StringCommand(portNum, buf); \
243 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
244 } \
245 \
246 void Tester ::test##ASYNC##Command(NATIVE_INT_TYPE portNum, FppTest::Types::EnumParam& data) { \
247 ASSERT_TRUE(component.isConnected_cmdRegOut_OutputPort(portNum)); \
248 ASSERT_TRUE(component.isConnected_cmdResponseOut_OutputPort(portNum)); \
249 \
250 component.regCommands(); \
251 \
252 Fw::CmdArgBuffer buf; \
253 \
254 /* Test incorrect serialization of first argument */ \
255 this->invoke##ASYNC##EnumCommand(portNum, buf); \
256 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
257 \
258 /* Test success */ \
259 buf.serialize(data.args.val); \
260 this->invoke##ASYNC##EnumCommand(portNum, buf); \
261 \
262 ASSERT_EQ(cmdResp, Fw::CmdResponse::OK); \
263 ASSERT_EQ(component.enumCmd.args.val, data.args.val); \
264 \
265 /* Test too many arguments */ \
266 buf.serialize(data.args.val); \
267 this->invoke##ASYNC##EnumCommand(portNum, buf); \
268 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
269 } \
270 \
271 void Tester ::test##ASYNC##Command(NATIVE_INT_TYPE portNum, FppTest::Types::ArrayParam& data) { \
272 ASSERT_TRUE(component.isConnected_cmdRegOut_OutputPort(portNum)); \
273 ASSERT_TRUE(component.isConnected_cmdResponseOut_OutputPort(portNum)); \
274 \
275 component.regCommands(); \
276 \
277 Fw::CmdArgBuffer buf; \
278 \
279 /* Test incorrect serialization of first argument */ \
280 this->invoke##ASYNC##ArrayCommand(portNum, buf); \
281 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
282 \
283 /* Test success */ \
284 buf.serialize(data.args.val); \
285 this->invoke##ASYNC##ArrayCommand(portNum, buf); \
286 \
287 ASSERT_EQ(cmdResp, Fw::CmdResponse::OK); \
288 ASSERT_EQ(component.arrayCmd.args.val, data.args.val); \
289 \
290 /* Test too many arguments */ \
291 buf.serialize(data.args.val); \
292 this->invoke##ASYNC##ArrayCommand(portNum, buf); \
293 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
294 } \
295 \
296 void Tester ::test##ASYNC##Command(NATIVE_INT_TYPE portNum, FppTest::Types::StructParam& data) { \
297 ASSERT_TRUE(component.isConnected_cmdRegOut_OutputPort(portNum)); \
298 ASSERT_TRUE(component.isConnected_cmdResponseOut_OutputPort(portNum)); \
299 \
300 component.regCommands(); \
301 \
302 Fw::CmdArgBuffer buf; \
303 \
304 /* Test incorrect serialization of first argument */ \
305 this->invoke##ASYNC##StructCommand(portNum, buf); \
306 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
307 \
308 /* Test success */ \
309 buf.serialize(data.args.val); \
310 this->invoke##ASYNC##StructCommand(portNum, buf); \
311 \
312 ASSERT_EQ(cmdResp, Fw::CmdResponse::OK); \
313 ASSERT_EQ(component.structCmd.args.val, data.args.val); \
314 \
315 /* Test too many arguments */ \
316 buf.serialize(data.args.val); \
317 this->invoke##ASYNC##StructCommand(portNum, buf); \
318 ASSERT_EQ(cmdResp, Fw::CmdResponse::FORMAT_ERROR); \
319 }