1 /*
2 * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <stdlib.h>
17 #include <string.h>
18 #include "cmsis_os.h"
19 #include "securec.h"
20 #include "hctest.h"
21 #include "samgr_lite.h"
22
23 #define OPER_INTERVAL 200 // 200 ms
24 #define PRESSURE_BASE 10
25
26 enum MessageId {
27 MSG_NO = 1, // receiver does not send response
28 MSG_RT = 2, // receiver send response
29 MSG_FW = 3, // receiver forward message
30 MSG_RT_MULTI = 4, // receiver send response
31 };
32
33 struct Payload {
34 int id;
35 const char *name;
36 int value;
37 };
38
39 typedef struct DemoApi {
40 INHERIT_IUNKNOWN;
41 int32 (*SAMGR_SendRequestProxy)(const Identity *identity, const Request *request, Handler handler);
42 } DemoApi;
43
44 typedef struct DemoFeature {
45 INHERIT_FEATURE;
46 INHERIT_IUNKNOWNENTRY(DemoApi);
47 Identity identity;
48 int featureCalledCount;
49 BOOL featureStatus;
50 } DemoFeature;
51
52 typedef struct DefaultFeatureApi {
53 INHERIT_IUNKNOWN;
54 } DefaultFeatureApi;
55
56 typedef struct ExampleService {
57 INHERIT_SERVICE;
58 INHERIT_IUNKNOWNENTRY(DefaultFeatureApi);
59 Identity identity;
60 } ExampleService;
61
SAMGR_SendRequestProxy(const Identity * identity,const Request * request,Handler handler)62 static int32 SAMGR_SendRequestProxy(const Identity *identity, const Request *request, Handler handler)
63 {
64 return SAMGR_SendRequest(identity, request, handler);
65 }
66
GetName(Service * service)67 static const char *GetName(Service *service)
68 {
69 (void)service;
70 return "serviceName601";
71 }
72
Initialize(Service * service,Identity identity)73 static BOOL Initialize(Service *service, Identity identity)
74 {
75 ExampleService *example = (ExampleService *)service;
76 example->identity = identity;
77 return TRUE;
78 }
79
MessageHandle(Service * service,Request * msg)80 static BOOL MessageHandle(Service *service, Request *msg)
81 {
82 (void)service;
83 (void)msg;
84 return FALSE;
85 }
86
GetTaskConfig(Service * service)87 static TaskConfig GetTaskConfig(Service *service)
88 {
89 (void)service;
90 TaskConfig config = {LEVEL_HIGH, PRI_ABOVE_NORMAL, 0x800, 20, SHARED_TASK}; // share with broadcast
91 return config;
92 }
93
94 static ExampleService g_service = {
95 .GetName = GetName,
96 .Initialize = Initialize,
97 .MessageHandle = MessageHandle,
98 .GetTaskConfig = GetTaskConfig,
99 .ref = 1,
100 .iUnknown = {
101 DEFAULT_IUNKNOWN_IMPL,
102 }
103 };
104
FEATURE_GetName(Feature * feature)105 static const char *FEATURE_GetName(Feature *feature)
106 {
107 (void)feature;
108 return "featureName601";
109 }
110
FEATURE_GetName02(Feature * feature)111 static const char *FEATURE_GetName02(Feature *feature)
112 {
113 (void)feature;
114 return "featureName602";
115 }
116
FEATURE_GetName03(Feature * feature)117 static const char *FEATURE_GetName03(Feature *feature)
118 {
119 (void)feature;
120 return "featureName603";
121 }
122
FEATURE_OnInitialize(Feature * feature,Service * parent,Identity identity)123 static void FEATURE_OnInitialize(Feature *feature, Service *parent, Identity identity)
124 {
125 DemoFeature *demoFeature = (DemoFeature *)feature;
126 demoFeature->identity = identity;
127 (void)parent;
128 }
129
FEATURE_OnStop(Feature * feature,Identity identity)130 static void FEATURE_OnStop(Feature *feature, Identity identity)
131 {
132 (void)feature;
133 (void)identity;
134 }
135
FEATURE_OnMessage(Feature * feature,Request * request)136 static BOOL FEATURE_OnMessage(Feature *feature, Request *request)
137 {
138 (void)request;
139 DemoFeature *demoFeature = (DemoFeature *)feature;
140 demoFeature->featureCalledCount++;
141 demoFeature->featureStatus = TRUE;
142
143 return TRUE;
144 }
145
FEATURE_OnMessage02(Feature * feature,Request * request)146 static BOOL FEATURE_OnMessage02(Feature *feature, Request *request)
147 {
148 int32 returnCode = 0;
149 DemoFeature *demoFeature = (DemoFeature *)feature;
150 demoFeature->featureCalledCount++;
151
152 switch (request->msgId) {
153 case MSG_NO:
154 returnCode = 0;
155 break;
156 case MSG_RT:
157 {
158 Response response = {
159 .data = "Yes, you did!",
160 .len = 0,
161 };
162 returnCode = SAMGR_SendResponse(request, &response);
163 };
164 break;
165 case MSG_FW:
166 {
167 Response response = {
168 .data = "Yes, you did!",
169 .len = 0,
170 };
171 request->msgId = MSG_NO;
172 IUnknown *iUnknownX = SAMGR_GetInstance()->GetFeatureApi("serviceName601", "featureName602");
173 DemoFeature *featureX = GET_OBJECT(iUnknownX, DemoFeature, iUnknown);
174 returnCode = SAMGR_SendResponseByIdentity(&featureX->identity, request, &response);
175 };
176 break;
177 }
178 demoFeature->featureStatus = ((returnCode == 0) ? TRUE : FALSE);
179 return demoFeature->featureStatus;
180 }
181
FEATURE_OnMessage03(Feature * feature,Request * request)182 static BOOL FEATURE_OnMessage03(Feature *feature, Request *request)
183 {
184 int32 returnCode = 0;
185 DemoFeature *demoFeature = (DemoFeature *)feature;
186 demoFeature->featureCalledCount++;
187
188 switch (request->msgId) {
189 case MSG_NO:
190 returnCode = 0;
191 break;
192 case MSG_RT:
193 {
194 Response response = {
195 .data = "Yes, you did!",
196 .len = 0,
197 };
198 returnCode = SAMGR_SendResponse(request, &response);
199 };
200 break;
201 case MSG_FW:
202 {
203 Response response = {
204 .data = "Yes, you did!",
205 .len = 0,
206 };
207 request->msgId = MSG_NO;
208 IUnknown *iUnknownX = SAMGR_GetInstance()->GetFeatureApi("serviceName601", "featureName602");
209 DemoFeature *featureX = GET_OBJECT(iUnknownX, DemoFeature, iUnknown);
210 returnCode = SAMGR_SendResponseByIdentity(&featureX->identity, request, &response);
211 };
212 break;
213 case MSG_RT_MULTI:
214 {
215 Response response = {
216 .data = "Yes, you did!",
217 .len = 0,
218 };
219 int tempCode = SAMGR_SendResponse(request, &response);
220 if (tempCode != 0) {
221 printf("[hctest]E failed to SendResponse rt: %d \n", tempCode);
222 returnCode++;
223 }
224 };
225 break;
226 }
227 demoFeature->featureStatus = ((returnCode == 0) ? TRUE : FALSE);
228 return demoFeature->featureStatus;
229 }
230
231 static DemoFeature g_feature = {
232 .GetName = FEATURE_GetName,
233 .OnInitialize = FEATURE_OnInitialize,
234 .OnStop = FEATURE_OnStop,
235 .OnMessage = FEATURE_OnMessage,
236 .ref = 1,
237 .iUnknown = {
238 DEFAULT_IUNKNOWN_IMPL,
239 .SAMGR_SendRequestProxy = SAMGR_SendRequestProxy,
240 },
241 .identity = {-1, -1, NULL},
242 .featureCalledCount = 0,
243 .featureStatus = TRUE,
244 };
245 static DemoFeature g_feature02 = {
246 .GetName = FEATURE_GetName02,
247 .OnInitialize = FEATURE_OnInitialize,
248 .OnStop = FEATURE_OnStop,
249 .OnMessage = FEATURE_OnMessage02,
250 .ref = 0,
251 .iUnknown = {
252 DEFAULT_IUNKNOWN_IMPL,
253 .SAMGR_SendRequestProxy = SAMGR_SendRequestProxy,
254 },
255 .identity = {-1, 1, NULL},
256 .featureCalledCount = 0,
257 .featureStatus = TRUE,
258 };
259 static DemoFeature g_feature03 = {
260 .GetName = FEATURE_GetName03,
261 .OnInitialize = FEATURE_OnInitialize,
262 .OnStop = FEATURE_OnStop,
263 .OnMessage = FEATURE_OnMessage03,
264 .ref = 0,
265 .iUnknown = {
266 DEFAULT_IUNKNOWN_IMPL,
267 .SAMGR_SendRequestProxy = SAMGR_SendRequestProxy,
268 },
269 .identity = {-1, 2, NULL},
270 .featureCalledCount = 0,
271 .featureStatus = TRUE,
272 };
273
ServiceInit(void)274 static void ServiceInit(void)
275 {
276 BOOL result = SAMGR_GetInstance()->RegisterService((Service *)&g_service);
277 if (result == FALSE) {
278 printf("[hctest]E RegisterService failed \n");
279 }
280 }
281 SYSEX_SERVICE_INIT(ServiceInit);
282
FeatureInit(void)283 static void FeatureInit(void)
284 {
285 BOOL result1 = SAMGR_GetInstance()->RegisterDefaultFeatureApi("serviceName601", GET_IUNKNOWN(g_feature));
286
287 BOOL result2 = SAMGR_GetInstance()->RegisterFeature("serviceName601", (Feature *)&g_feature02);
288 BOOL result3 = SAMGR_GetInstance()->RegisterFeatureApi("serviceName601", "featureName602",
289 GET_IUNKNOWN(g_feature02));
290
291 BOOL result4 = SAMGR_GetInstance()->RegisterFeature("serviceName601", (Feature *)&g_feature03);
292 BOOL result5 = SAMGR_GetInstance()->RegisterFeatureApi("serviceName601", "featureName603",
293 GET_IUNKNOWN(g_feature03));
294 if (result1 == FALSE || result2 == FALSE || result3 == FALSE || result4 == FALSE || result5 == FALSE) {
295 printf("[hctest]E failed to register feature or api.\n");
296 }
297 }
298 SYSEX_FEATURE_INIT(FeatureInit);
299
GetIUnknown(const char * serviceName,const char * featureName)300 static DemoApi *GetIUnknown(const char *serviceName, const char *featureName)
301 {
302 DemoApi *demoApi = NULL;
303 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(serviceName, featureName);
304 if (iUnknown == NULL) {
305 printf("[hctest]failed to GetFeatureApi.\n");
306 return NULL;
307 }
308 int result = iUnknown->QueryInterface(iUnknown, 0, (void **)&demoApi);
309 if (result == 0 && demoApi != NULL) {
310 return demoApi;
311 } else {
312 printf("[hctest]failed to QueryInterface.\n");
313 return NULL;
314 }
315 }
316
ReleaseIUnknown(DemoApi * demoApi)317 static void ReleaseIUnknown(DemoApi *demoApi)
318 {
319 demoApi->Release((IUnknown *)demoApi);
320 }
321
DemoHandlerAndCheck(const Request * request,const Response * response)322 static void DemoHandlerAndCheck(const Request *request, const Response *response)
323 {
324 (void)request;
325 (void)response;
326 }
327
DemoHandler(const Request * request,const Response * response)328 static void DemoHandler(const Request *request, const Response *response)
329 {
330 (void)request;
331 (void)response;
332 }
333
334 LITE_TEST_SUIT(test, samgr, SendResponseTestSuite);
335
SendResponseTestSuiteSetUp(void)336 static BOOL SendResponseTestSuiteSetUp(void)
337 {
338 osDelay(OPER_INTERVAL);
339 return TRUE;
340 }
341
SendResponseTestSuiteTearDown(void)342 static BOOL SendResponseTestSuiteTearDown(void)
343 {
344 return TRUE;
345 }
346
347 /**
348 * @tc.number : DMSLite_SAMGR_SendResponse_0010
349 * @tc.name : Receiver send response successfully
350 * @tc.desc : [C- SOFTWARE -0200]
351 */
352 LITE_TEST_CASE(SendResponseTestSuite, testSendResponse0010, Function | MediumTest | Level2)
353 {
354 DemoApi *demoApi = GetIUnknown("serviceName601", "featureName602");
355 if (demoApi == NULL) {
356 TEST_FAIL();
357 }
358 Request request = {.msgId = MSG_RT, .msgValue = 0};
359 char *body = "I wanna async call good result!";
360 request.len = (int16)(strlen(body) + 1);
361 request.data = malloc(request.len);
362 if (request.data == NULL) {
363 TEST_FAIL();
364 }
365 strcpy_s(request.data, request.len, body);
366
367 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName601", "featureName603");
368 if (iUnknown == NULL) {
369 TEST_FAIL();
370 }
371 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
372 demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, DemoHandlerAndCheck);
373
374 osDelay(OPER_INTERVAL);
375 TEST_ASSERT_EQUAL_INT(feature->featureStatus == TRUE, TRUE);
376 ReleaseIUnknown(demoApi);
377 }
378
379 /**
380 * @tc.number : DMSLite_SAMGR_SendResponse_0020
381 * @tc.name : Receiver can not send response if sender has not register callback
382 * @tc.desc : [C- SOFTWARE -0200]
383 */
384 LITE_TEST_CASE(SendResponseTestSuite, testSendResponse0020, Function | MediumTest | Level2)
385 {
386 DemoApi *demoApi = GetIUnknown("serviceName601", "featureName602");
387 if (demoApi == NULL) {
388 TEST_FAIL();
389 }
390 Request request = {.msgId = MSG_RT, .msgValue = 0};
391 char *body = "I wanna async call good result!";
392 request.len = (int16)(strlen(body) + 1);
393 request.data = malloc(request.len);
394 if (request.data == NULL) {
395 TEST_FAIL();
396 }
397 strcpy_s(request.data, request.len, body);
398
399 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName601", "featureName603");
400 if (iUnknown == NULL) {
401 TEST_FAIL();
402 }
403 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
404 demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, NULL);
405
406 osDelay(OPER_INTERVAL);
407 TEST_ASSERT_EQUAL_INT(feature->featureStatus == FALSE, TRUE);
408 ReleaseIUnknown(demoApi);
409 }
410
411 /**
412 * @tc.number : DMSLite_SAMGR_SendResponse_0030
413 * @tc.name : Receiver send response to itself successfully
414 * @tc.desc : [C- SOFTWARE -0200]
415 */
416 LITE_TEST_CASE(SendResponseTestSuite, testSendResponse0030, Function | MediumTest | Level2)
417 {
418 DemoApi *demoApi = GetIUnknown("serviceName601", "featureName603");
419 if (demoApi == NULL) {
420 TEST_FAIL();
421 }
422 Request request = {.msgId = MSG_RT, .msgValue = 0};
423 char *body = "I wanna async call good result!";
424 request.len = (int16)(strlen(body) + 1);
425 request.data = malloc(request.len);
426 if (request.data == NULL) {
427 TEST_FAIL();
428 }
429 strcpy_s(request.data, request.len, body);
430
431 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName601", "featureName603");
432 if (iUnknown == NULL) {
433 TEST_FAIL();
434 }
435 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
436 demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, DemoHandler);
437
438 osDelay(OPER_INTERVAL);
439 TEST_ASSERT_EQUAL_INT(feature->featureStatus == TRUE, TRUE);
440 ReleaseIUnknown(demoApi);
441 }
442
443 /**
444 * @tc.number : DMSLite_SAMGR_SendResponseByIdentity_0010
445 * @tc.name : Receiver forward message successfully
446 * @tc.desc : [C- SOFTWARE -0200]
447 */
448 LITE_TEST_CASE(SendResponseTestSuite, testSendResponseByIdentity0010, Function | MediumTest | Level2)
449 {
450 DemoApi *demoApi = GetIUnknown("serviceName601", "featureName602");
451 if (demoApi == NULL) {
452 TEST_FAIL();
453 }
454 Request request = {.msgId = MSG_FW, .msgValue = 0};
455 char *body = "I wanna async call good result!";
456 request.len = (int16)(strlen(body) + 1);
457 request.data = malloc(request.len);
458 if (request.data == NULL) {
459 TEST_FAIL();
460 }
461 strcpy_s(request.data, request.len, body);
462
463 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName601", "featureName603");
464 if (iUnknown == NULL) {
465 TEST_FAIL();
466 }
467 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
468 feature->featureStatus = FALSE;
469 demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, DemoHandlerAndCheck);
470
471 osDelay(OPER_INTERVAL);
472 TEST_ASSERT_EQUAL_INT(feature->featureStatus == TRUE, TRUE);
473
474 ReleaseIUnknown(demoApi);
475 }
476
477 /**
478 * @tc.number : DMSLite_SAMGR_SendResponseByIdentity_0020
479 * @tc.name : Receiver can not forward message if the sender has not registered handler
480 * @tc.desc : [C- SOFTWARE -0200]
481 */
482 LITE_TEST_CASE(SendResponseTestSuite, testSendResponseByIdentity0020, Function | MediumTest | Level2)
483 {
484 DemoApi *demoApi = GetIUnknown("serviceName601", "featureName602");
485 if (demoApi == NULL) {
486 TEST_FAIL();
487 }
488 Request request = {.msgId = MSG_FW, .msgValue = 0};
489 char *body = "I wanna async call good result!";
490 request.len = (int16)(strlen(body) + 1);
491 request.data = malloc(request.len);
492 if (request.data == NULL) {
493 TEST_FAIL();
494 }
495 strcpy_s(request.data, request.len, body);
496
497 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName601", "featureName603");
498 if (iUnknown == NULL) {
499 TEST_FAIL();
500 }
501 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
502 demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, NULL);
503
504 osDelay(OPER_INTERVAL);
505 TEST_ASSERT_EQUAL_INT(feature->featureStatus == FALSE, TRUE);
506
507 ReleaseIUnknown(demoApi);
508 }
509
510 RUN_TEST_SUITE(SendResponseTestSuite);