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, // receiver does not send response
28 MSG_RT, // receiver send response
29 MSG_FW, // receiver forward message
30 };
31
32 struct Payload {
33 int id;
34 const char *name;
35 int value;
36 };
37
38 typedef struct DemoApi {
39 INHERIT_IUNKNOWN;
40 BOOL(*SyncCall)
41 (IUnknown *iUnknown, struct Payload *payload);
42 int32 (*SAMGR_SendRequestProxy)(const Identity *identity, const Request *request, Handler handler);
43 } DemoApi;
44
45 typedef struct DemoFeature {
46 INHERIT_FEATURE;
47 INHERIT_IUNKNOWNENTRY(DemoApi);
48 Identity identity;
49 int featureCalledCount;
50 BOOL featureStatus;
51 char *latestRequest;
52 } DemoFeature;
53
54 typedef struct DefaultFeatureApi {
55 INHERIT_IUNKNOWN;
56 } DefaultFeatureApi;
57
58 typedef struct ExampleService {
59 INHERIT_SERVICE;
60 INHERIT_IUNKNOWNENTRY(DefaultFeatureApi);
61 Identity identity;
62 } ExampleService;
63
SyncCall(IUnknown * iUnknown,struct Payload * payload)64 static BOOL SyncCall(IUnknown *iUnknown, struct Payload *payload)
65 {
66 (void)iUnknown;
67 if (payload != NULL && payload->id >= 0 && payload->name != NULL) {
68 return TRUE;
69 } else {
70 return FALSE;
71 }
72 }
73
SAMGR_SendRequestProxy(const Identity * identity,const Request * request,Handler handler)74 static int32 SAMGR_SendRequestProxy(const Identity *identity, const Request *request, Handler handler)
75 {
76 return SAMGR_SendRequest(identity, request, handler);
77 }
78
GetName(Service * service)79 static const char *GetName(Service *service)
80 {
81 (void)service;
82 return "serviceName501";
83 }
84
Initialize(Service * service,Identity identity)85 static BOOL Initialize(Service *service, Identity identity)
86 {
87 ExampleService *example = (ExampleService *)service;
88 example->identity = identity;
89 return TRUE;
90 }
91
MessageHandle(Service * service,Request * msg)92 static BOOL MessageHandle(Service *service, Request *msg)
93 {
94 (void)service;
95 (void)msg;
96 return FALSE;
97 }
98
GetTaskConfig(Service * service)99 static TaskConfig GetTaskConfig(Service *service)
100 {
101 (void)service;
102 TaskConfig config = {LEVEL_HIGH, PRI_ABOVE_NORMAL, 0x800, 20, SHARED_TASK};
103 return config;
104 }
105
106 static ExampleService g_service = {
107 .GetName = GetName,
108 .Initialize = Initialize,
109 .MessageHandle = MessageHandle,
110 .GetTaskConfig = GetTaskConfig,
111 .ref = 1,
112 .iUnknown = {
113 DEFAULT_IUNKNOWN_IMPL,
114 }
115 };
116
FEATURE_GetName(Feature * feature)117 static const char *FEATURE_GetName(Feature *feature)
118 {
119 (void)feature;
120 return "featureName501";
121 }
122
FEATURE_GetName02(Feature * feature)123 static const char *FEATURE_GetName02(Feature *feature)
124 {
125 (void)feature;
126 return "featureName502";
127 }
128
FEATURE_GetName03(Feature * feature)129 static const char *FEATURE_GetName03(Feature *feature)
130 {
131 (void)feature;
132 return "featureName503";
133 }
134
FEATURE_OnInitialize(Feature * feature,Service * parent,Identity identity)135 static void FEATURE_OnInitialize(Feature *feature, Service *parent, Identity identity)
136 {
137 DemoFeature *demoFeature = (DemoFeature *)feature;
138 demoFeature->identity = identity;
139 (void)parent;
140 }
141
FEATURE_OnStop(Feature * feature,Identity identity)142 static void FEATURE_OnStop(Feature *feature, Identity identity)
143 {
144 (void)feature;
145 (void)identity;
146 }
147
FEATURE_OnMessage(Feature * feature,Request * request)148 static BOOL FEATURE_OnMessage(Feature *feature, Request *request)
149 {
150 int32 returnCode = 0;;
151 DemoFeature *demoFeature = (DemoFeature *)feature;
152 demoFeature->featureCalledCount++;
153
154 if (demoFeature->latestRequest != NULL) {
155 free(demoFeature->latestRequest);
156 }
157 int requestLen;
158 if (request->len > 0) {
159 requestLen = request->len;
160 } else {
161 requestLen = strlen((char *)request->data) + 1;
162 }
163 demoFeature->latestRequest = (char *)malloc(requestLen * sizeof(char));
164 if (demoFeature->latestRequest == NULL) {
165 TEST_FAIL();
166 }
167 errno_t error = strcpy_s(demoFeature->latestRequest, requestLen, (char *)request->data);
168 if (error != EOK) {
169 TEST_FAIL();
170 }
171
172 switch (request->msgId) {
173 case MSG_NO:
174 returnCode = 0;
175 break;
176 case MSG_RT:
177 {
178 Response response = {
179 .data = "Yes, you did!",
180 .len = 0,
181 };
182 returnCode = SAMGR_SendResponse(request, &response);
183 };
184 break;
185 case MSG_FW:
186 {
187 returnCode = 0;
188 };
189 break;
190 }
191 demoFeature->featureStatus = ((returnCode == 0) ? TRUE : FALSE);
192 return demoFeature->featureStatus;
193 }
194
FEATURE_OnMessage02(Feature * feature,Request * request)195 static BOOL FEATURE_OnMessage02(Feature *feature, Request *request)
196 {
197 int32 returnCode = 0;
198 DemoFeature *demoFeature = (DemoFeature *)feature;
199 demoFeature->featureCalledCount++;
200
201 if (demoFeature->latestRequest != NULL) {
202 free(demoFeature->latestRequest);
203 }
204 int requestLen;
205 if (request->len > 0) {
206 requestLen = request->len;
207 } else {
208 requestLen = strlen((char *)request->data) + 1;
209 }
210 demoFeature->latestRequest = (char *)malloc(requestLen * sizeof(char));
211 if (demoFeature->latestRequest == NULL) {
212 TEST_FAIL();
213 }
214 errno_t error = strcpy_s(demoFeature->latestRequest, requestLen, (char *)request->data);
215 if (error != EOK) {
216 TEST_FAIL();
217 }
218
219 switch (request->msgId) {
220 case MSG_NO:
221 returnCode = 0;
222 break;
223 case MSG_RT:
224 {
225 Response response = {
226 .data = "Yes, you did!",
227 .len = 0,
228 };
229 returnCode = SAMGR_SendResponse(request, &response);
230 };
231 break;
232 case MSG_FW:
233 {
234 returnCode = 0;
235 };
236 break;
237 }
238 demoFeature->featureStatus = ((returnCode == 0) ? TRUE : FALSE);
239 return demoFeature->featureStatus;
240 }
241
FEATURE_OnMessage03(Feature * feature,Request * request)242 static BOOL FEATURE_OnMessage03(Feature *feature, Request *request)
243 {
244 int32 returnCode = 0;
245 DemoFeature *demoFeature = (DemoFeature *)feature;
246 demoFeature->featureCalledCount++;
247
248 if (demoFeature->latestRequest != NULL) {
249 free(demoFeature->latestRequest);
250 }
251 int requestLen;
252 if (request->len > 0) {
253 requestLen = request->len;
254 } else {
255 requestLen = strlen((char *)request->data) + 1;
256 }
257 demoFeature->latestRequest = (char *)malloc(requestLen * sizeof(char));
258 if (demoFeature->latestRequest == NULL) {
259 TEST_FAIL();
260 }
261 errno_t error = strcpy_s(demoFeature->latestRequest, requestLen, (char *)request->data);
262 if (error != EOK) {
263 TEST_FAIL();
264 }
265
266 switch (request->msgId) {
267 case MSG_NO:
268 returnCode = 0;
269 break;
270 case MSG_RT:
271 {
272 Response response = {
273 .data = "Yes, you did!",
274 .len = 0,
275 };
276 returnCode = SAMGR_SendResponse(request, &response);
277 };
278 break;
279 case MSG_FW:
280 {
281 returnCode = 0;
282 };
283 break;
284 }
285 demoFeature->featureStatus = ((returnCode == 0) ? TRUE : FALSE);
286 return demoFeature->featureStatus;
287 }
288
289 static DemoFeature g_feature = {
290 .GetName = FEATURE_GetName,
291 .OnInitialize = FEATURE_OnInitialize,
292 .OnStop = FEATURE_OnStop,
293 .OnMessage = FEATURE_OnMessage,
294 .ref = 1,
295 .iUnknown = {
296 DEFAULT_IUNKNOWN_IMPL,
297 .SyncCall = SyncCall,
298 .SAMGR_SendRequestProxy = SAMGR_SendRequestProxy,
299 },
300 .identity = {-1, -1, NULL},
301 .featureCalledCount = 0,
302 .featureStatus = TRUE,
303 .latestRequest = NULL,
304 };
305 static DemoFeature g_feature02 = {
306 .GetName = FEATURE_GetName02,
307 .OnInitialize = FEATURE_OnInitialize,
308 .OnStop = FEATURE_OnStop,
309 .OnMessage = FEATURE_OnMessage02,
310 .ref = 0,
311 .iUnknown = {
312 DEFAULT_IUNKNOWN_IMPL,
313 .SyncCall = SyncCall,
314 .SAMGR_SendRequestProxy = SAMGR_SendRequestProxy,
315 },
316 .identity = {-1, 1, NULL},
317 .featureCalledCount = 0,
318 .featureStatus = TRUE,
319 .latestRequest = NULL,
320 };
321 static DemoFeature g_feature03 = {
322 .GetName = FEATURE_GetName03,
323 .OnInitialize = FEATURE_OnInitialize,
324 .OnStop = FEATURE_OnStop,
325 .OnMessage = FEATURE_OnMessage03,
326 .ref = 0,
327 .iUnknown = {
328 DEFAULT_IUNKNOWN_IMPL,
329 .SyncCall = SyncCall,
330 .SAMGR_SendRequestProxy = SAMGR_SendRequestProxy,
331 },
332 .identity = {-1, 2, NULL},
333 .featureCalledCount = 0,
334 .featureStatus = TRUE,
335 .latestRequest = NULL,
336 };
337
ServiceInit(void)338 static void ServiceInit(void)
339 {
340 BOOL result = SAMGR_GetInstance()->RegisterService((Service *)&g_service);
341 if (result == FALSE) {
342 printf("[hctest]E RegisterService failed. \n");
343 }
344 }
345 SYSEX_SERVICE_INIT(ServiceInit);
346
FeatureInit(void)347 static void FeatureInit(void)
348 {
349 BOOL result1 = SAMGR_GetInstance()->RegisterDefaultFeatureApi("serviceName501", GET_IUNKNOWN(g_feature));
350
351 BOOL result2 = SAMGR_GetInstance()->RegisterFeature("serviceName501", (Feature *)&g_feature02);
352 BOOL result3 = SAMGR_GetInstance()->RegisterFeatureApi("serviceName501", "featureName502",
353 GET_IUNKNOWN(g_feature02));
354
355 BOOL result4 = SAMGR_GetInstance()->RegisterFeature("serviceName501", (Feature *)&g_feature03);
356 BOOL result5 = SAMGR_GetInstance()->RegisterFeatureApi("serviceName501", "featureName503",
357 GET_IUNKNOWN(g_feature03));
358 if (result1 == FALSE || result2 == FALSE || result3 == FALSE || result4 == FALSE || result5 == FALSE) {
359 printf("[hctest]E failed to register feature or api.\n");
360 }
361 }
362 SYSEX_FEATURE_INIT(FeatureInit);
363
GetIUnknown(const char * serviceName,const char * featureName)364 static DemoApi *GetIUnknown(const char *serviceName, const char *featureName)
365 {
366 DemoApi *demoApi = NULL;
367 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(serviceName, featureName);
368 if (iUnknown == NULL) {
369 printf("[hctest]failed to GetFeatureApi.\n");
370 return NULL;
371 }
372 int result = iUnknown->QueryInterface(iUnknown, 0, (void **)&demoApi);
373 if (result == 0 && demoApi != NULL) {
374 return demoApi;
375 } else {
376 printf("[hctest]failed to QueryInterface.\n");
377 return NULL;
378 }
379 }
380
ReleaseIUnknown(DemoApi * demoApi)381 static void ReleaseIUnknown(DemoApi *demoApi)
382 {
383 demoApi->Release((IUnknown *)demoApi);
384 }
385
DemoHandlerAndCheck(const Request * request,const Response * response)386 static void DemoHandlerAndCheck(const Request *request, const Response *response)
387 {
388 (void)request;
389 (void)response;
390 }
391
392 LITE_TEST_SUIT(test, samgr, SendRequestTestSuite);
393
SendRequestTestSuiteSetUp(void)394 static BOOL SendRequestTestSuiteSetUp(void)
395 {
396 osDelay(OPER_INTERVAL);
397 return TRUE;
398 }
399
SendRequestTestSuiteTearDown(void)400 static BOOL SendRequestTestSuiteTearDown(void)
401 {
402 return TRUE;
403 }
404
405 /**
406 * @tc.number : DMSLite_SAMGR_SyncCall_0010
407 * @tc.name : Samgr support synchronous call
408 * @tc.desc : [C- SOFTWARE -0200]
409 */
410 LITE_TEST_CASE(SendRequestTestSuite, testSyncCall0010, Function | MediumTest | Level1)
411 {
412 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
413 if (demoApi == NULL) {
414 TEST_FAIL();
415 }
416 struct Payload payload = {
417 .id = 0, // api will return true
418 .name = "I wanna sync call good result!",
419 .value = 1};
420 BOOL result = demoApi->SyncCall((IUnknown *)demoApi, &payload);
421 TEST_ASSERT_EQUAL_INT(result, TRUE);
422
423 struct Payload payloadX = {
424 .id = -1, // api will return false
425 .name = "I wanna sync call good result!",
426 .value = 1};
427 result = demoApi->SyncCall((IUnknown *)demoApi, &payloadX);
428 TEST_ASSERT_EQUAL_INT(result, FALSE);
429
430 ReleaseIUnknown(demoApi);
431 }
432
433 /**
434 * @tc.number : DMSLite_SAMGR_SendRequest_0010
435 * @tc.name : Samgr support asynchronous call
436 * @tc.desc : [C- SOFTWARE -0200]
437 */
438 LITE_TEST_CASE(SendRequestTestSuite, testSendRequest0010, Function | MediumTest | Level1)
439 {
440 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
441 if (demoApi == NULL) {
442 TEST_FAIL();
443 }
444 Request request = {.msgId = MSG_RT, .msgValue = 0};
445 char *body = "I wanna async call good result!";
446 request.len = (int16)(strlen(body) + 1);
447 request.data = malloc(request.len);
448 if (request.data == NULL) {
449 TEST_FAIL();
450 }
451 strcpy_s(request.data, request.len, body);
452
453 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName501", "featureName503");
454 if (iUnknown == NULL) {
455 TEST_FAIL();
456 }
457 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
458
459 feature->featureCalledCount = 0;
460 int32 result = demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, NULL);
461 TEST_ASSERT_EQUAL_INT(result == 0, TRUE);
462
463 osDelay(OPER_INTERVAL);
464 TEST_ASSERT_EQUAL_INT(feature->featureCalledCount == 1, TRUE);
465 TEST_ASSERT_EQUAL_INT(strcmp(feature->latestRequest, body), 0);
466
467 ReleaseIUnknown(demoApi);
468 }
469
470 /**
471 * @tc.number : DMSLite_SAMGR_SendRequest_0020
472 * @tc.name : Feature can send an asynchronous message to itself
473 * @tc.desc : [C- SOFTWARE -0200]
474 */
475 LITE_TEST_CASE(SendRequestTestSuite, testSendRequest0020, Function | MediumTest | Level2)
476 {
477 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
478 if (demoApi == NULL) {
479 TEST_FAIL();
480 }
481 Request request = {.msgId = MSG_RT, .msgValue = 0};
482 char *body = "I wanna async call good result!";
483 request.len = (int16)(strlen(body) + 1);
484 request.data = malloc(request.len);
485 if (request.data == NULL) {
486 TEST_FAIL();
487 }
488 strcpy_s(request.data, request.len, body);
489
490 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName501", "featureName502");
491 if (iUnknown == NULL) {
492 TEST_FAIL();
493 }
494 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
495
496 feature->featureCalledCount = 0;
497 int32 result = demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, NULL);
498 TEST_ASSERT_EQUAL_INT(result == 0, TRUE);
499
500 osDelay(OPER_INTERVAL);
501 TEST_ASSERT_EQUAL_INT(feature->featureCalledCount == 1, TRUE);
502 TEST_ASSERT_EQUAL_INT(strcmp(feature->latestRequest, body), 0);
503
504 ReleaseIUnknown(demoApi);
505 }
506
507 /**
508 * @tc.number : DMSLite_SAMGR_SendRequest_0030
509 * @tc.name : Feature failed to send an asynchronous message if the specified identity does not exist
510 * @tc.desc : [C- SOFTWARE -0200]
511 */
512 LITE_TEST_CASE(SendRequestTestSuite, testSendRequest0030, Function | MediumTest | Level2)
513 {
514 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
515 if (demoApi == NULL) {
516 TEST_FAIL();
517 }
518 Request request = {.msgId = MSG_RT, .msgValue = 0};
519 char *body = "I wanna async call good result!";
520 request.len = (int16)(strlen(body) + 1);
521 request.data = malloc(request.len);
522 if (request.data == NULL) {
523 TEST_FAIL();
524 }
525 strcpy_s(request.data, request.len, body);
526
527 Identity identityX = {-1, -200, NULL};
528 int32 result = demoApi->SAMGR_SendRequestProxy(&identityX, &request, NULL);
529 TEST_ASSERT_EQUAL_INT(result != 0, TRUE);
530
531 free(request.data);
532 request.data = NULL;
533 ReleaseIUnknown(demoApi);
534 }
535
536 /**
537 * @tc.number : DMSLite_SAMGR_SendRequest_0040
538 * @tc.name : Feature can send an asynchronous message with length is 0
539 * @tc.desc : [C- SOFTWARE -0200]
540 */
541 LITE_TEST_CASE(SendRequestTestSuite, testSendRequest0040, Function | MediumTest | Level2)
542 {
543 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
544 if (demoApi == NULL) {
545 TEST_FAIL();
546 }
547 Request request = {.msgId = MSG_RT, .msgValue = 0};
548 request.len = 0;
549 request.data = "I wanna async call good result!";
550
551 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName501", "featureName503");
552 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
553
554 feature->featureCalledCount = 0;
555 int32 result = demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, NULL);
556 TEST_ASSERT_EQUAL_INT(result == 0, TRUE);
557
558 osDelay(OPER_INTERVAL);
559 TEST_ASSERT_EQUAL_INT(feature->featureCalledCount == 1, TRUE);
560
561 ReleaseIUnknown(demoApi);
562 }
563
564 /**
565 * @tc.number : DMSLite_SAMGR_SendRequest_0050
566 * @tc.name : Feature failed to send an asynchronous message if id or request is NULL
567 * @tc.desc : [C- SOFTWARE -0200]
568 */
569 LITE_TEST_CASE(SendRequestTestSuite, testSendRequest0050, Function | MediumTest | Level2)
570 {
571 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
572 if (demoApi == NULL) {
573 TEST_FAIL();
574 }
575 Request request = {.msgId = MSG_RT, .msgValue = 0};
576 char *body = "";
577 request.len = (int16)(strlen(body) + 1);
578 request.data = malloc(request.len);
579 if (request.data == NULL) {
580 TEST_FAIL();
581 }
582 strcpy_s(request.data, request.len, body);
583
584 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName501", "featureName503");
585 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
586
587 int32 result = demoApi->SAMGR_SendRequestProxy(NULL, &request, NULL);
588 TEST_ASSERT_EQUAL_INT(result != 0, TRUE);
589
590 result = demoApi->SAMGR_SendRequestProxy(&feature->identity, NULL, NULL);
591 TEST_ASSERT_EQUAL_INT(result != 0, TRUE);
592
593 free(request.data);
594 request.data = NULL;
595 ReleaseIUnknown(demoApi);
596 }
597
598 /**
599 * @tc.number : DMSLite_SAMGR_SendRequest_0060
600 * @tc.name : Samgr will not check the matching relationship between len and data
601 * @tc.desc : [C- SOFTWARE -0200]
602 */
603 LITE_TEST_CASE(SendRequestTestSuite, testSendRequest0060, Function | MediumTest | Level2)
604 {
605 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
606 if (demoApi == NULL) {
607 TEST_FAIL();
608 }
609 Request request = {.msgId = MSG_NO, .msgValue = 0};
610 char *body = "I wanna async call good result!";
611 request.len = 0;
612 request.data = "I wanna async call good result!";
613 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName501", "featureName503");
614 if (iUnknown == NULL) {
615 TEST_FAIL();
616 }
617 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
618
619 int32 result = demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, NULL);
620 TEST_ASSERT_EQUAL_INT(result == 0, TRUE);
621
622 Request request2 = {.msgId = MSG_NO, .msgValue = 0};
623 request2.len = (int16)(strlen(body) + 1);
624 request2.data = malloc(request2.len);
625 if (request2.data == NULL) {
626 TEST_FAIL();
627 }
628 strcpy_s(request2.data, request2.len, body);
629
630 result = demoApi->SAMGR_SendRequestProxy(&feature->identity, &request2, NULL);
631 TEST_ASSERT_EQUAL_INT(result == 0, TRUE);
632
633 ReleaseIUnknown(demoApi);
634 }
635
636 /**
637 * @tc.number : DMSLite_SAMGR_SendRequest_0070
638 * @tc.name : Feature send an asynchronous message and register handler then can receive response
639 * @tc.desc : [C- SOFTWARE -0200]
640 */
641 LITE_TEST_CASE(SendRequestTestSuite, testSendRequest0070, Function | MediumTest | Level2)
642 {
643 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
644 if (demoApi == NULL) {
645 TEST_FAIL();
646 }
647 Request request = {.msgId = MSG_RT, .msgValue = 0};
648 char *body = "I wanna async call good result!";
649 request.len = (int16)(strlen(body) + 1);
650 request.data = malloc(request.len);
651 if (request.data == NULL) {
652 TEST_FAIL();
653 }
654 strcpy_s(request.data, request.len, body);
655
656 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName501", "featureName503");
657 if (iUnknown == NULL) {
658 TEST_FAIL();
659 }
660 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
661
662 int32 result = demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, DemoHandlerAndCheck);
663 TEST_ASSERT_EQUAL_INT(result, 0);
664 TEST_ASSERT_EQUAL_INT(strcmp(feature->latestRequest, body), 0);
665
666 ReleaseIUnknown(demoApi);
667 }
668
669 /**
670 * @tc.number : DMSLite_SAMGR_SendRequest_0080
671 * @tc.name : Feature send an asynchronous message repeatedly, no memory leak
672 * @tc.desc : [C- SOFTWARE -0200]
673 */
674 LITE_TEST_CASE(SendRequestTestSuite, testSendRequest0080, Function | MediumTest | Level2)
675 {
676 for (int i = 0; i < PRESSURE_BASE; i++) {
677 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
678 if (demoApi == NULL) {
679 TEST_FAIL();
680 }
681 Request request = {.msgId = MSG_RT, .msgValue = 0};
682 char *body = "I wanna async call good result!";
683 request.len = (int16)(strlen(body) + 1);
684 request.data = malloc(request.len);
685 if (request.data == NULL) {
686 TEST_FAIL();
687 }
688 strcpy_s(request.data, request.len, body);
689
690 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName501", "featureName503");
691 if (iUnknown == NULL) {
692 TEST_FAIL();
693 }
694 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
695
696 int32 result = demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, DemoHandlerAndCheck);
697 TEST_ASSERT_EQUAL_INT(result, 0);
698 TEST_ASSERT_EQUAL_INT(strcmp(feature->latestRequest, body), 0);
699
700 ReleaseIUnknown(demoApi);
701 }
702 }
703
704 /**
705 * @tc.number : DMSLite_SAMGR_SendRequest_0090
706 * @tc.name : Feature send an asynchronous message with 0 len repeatedly, no memory leak
707 * @tc.desc : [C- SOFTWARE -0200]
708 */
709 LITE_TEST_CASE(SendRequestTestSuite, testSendRequest0090, Function | MediumTest | Level2)
710 {
711 for (int i = 0; i < PRESSURE_BASE; i++) {
712 DemoApi *demoApi = GetIUnknown("serviceName501", "featureName502");
713 if (demoApi == NULL) {
714 TEST_FAIL();
715 }
716 Request request = {.msgId = MSG_RT, .msgValue = 0};
717 char body[]= "I wanna async call good result!";
718 request.len = 0;
719 request.data = body;
720
721 IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi("serviceName501", "featureName503");
722 if (iUnknown == NULL) {
723 TEST_FAIL();
724 }
725 DemoFeature *feature = GET_OBJECT(iUnknown, DemoFeature, iUnknown);
726
727 int32 result = demoApi->SAMGR_SendRequestProxy(&feature->identity, &request, DemoHandlerAndCheck);
728 TEST_ASSERT_EQUAL_INT(result, 0);
729 TEST_ASSERT_EQUAL_INT(strcmp(feature->latestRequest, body), 0);
730
731 ReleaseIUnknown(demoApi);
732 }
733 }
734
735 RUN_TEST_SUITE(SendRequestTestSuite);