1 /**
2 * Copyright (c) 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 <log.h>
17 #include <semaphore.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string>
21
22 #include "gtest/gtest.h"
23 #include "securec.h"
24
25 #include "ability.h"
26 #include "ability_connection.h"
27 #include "ability_env.h"
28 #include "ability_event_handler.h"
29 #include "ability_manager.h"
30 #include "ability_slice.h"
31 #include "abilityms_client.h"
32 #include "bundle_manager.h"
33 #include "want.h"
34
35 using namespace std;
36 using namespace testing::ext;
37 using namespace OHOS;
38 static int32_t g_errorCode = -1;
39 static sem_t g_sem;
40 static const int32_t WAIT_TIMEOUT = 30;
41 static bool g_installState = false;
42 static string g_testPath;
43
44 extern "C" {
HOS_SystemInit(void)45 void __attribute__((weak)) HOS_SystemInit(void){};
46 }
47
48 /* install callback */
TestBundleStateCallback(const uint8_t resultCode,const void * resultMessage)49 static void TestBundleStateCallback(const uint8_t resultCode, const void *resultMessage)
50 {
51 HILOG_DEBUG(HILOG_MODULE_APP, "TestBundleStateCallback resultCode: %d", resultCode);
52 HILOG_DEBUG(HILOG_MODULE_APP, "TestBundleStateCallback resultMessage: %s", (char *) resultMessage);
53 g_installState = (resultCode == 0);
54 g_errorCode = resultCode;
55 sem_post(&g_sem);
56 }
57
58 /* *
59 * get current dir
60 * @return string current file path of the test suits
61 */
GetCurDir()62 static string GetCurDir()
63 {
64 string filePath = "";
65 char *buffer;
66 if ((buffer = getcwd(NULL, 0)) == NULL) {
67 perror("get file path error");
68 } else {
69 printf("Current Dir: %s\r\n", buffer);
70 filePath = buffer;
71 free(buffer);
72 }
73 return filePath + "/";
74 }
75
76 /* connectAbility callback */
OnAbilityConnectDone(ElementName * elementName,SvcIdentity * serviceSid,int resultCode,void * storeData)77 static void OnAbilityConnectDone(ElementName *elementName, SvcIdentity *serviceSid, int resultCode, void *storeData)
78 {
79 printf("OnAbilityConnectDone, serviceSid is %p \n", serviceSid);
80 printf("elementName is %s, %s \n", elementName->bundleName, elementName->abilityName);
81 ClearElement(elementName);
82 if (serviceSid == nullptr) {
83 return;
84 }
85 printf("ipc callback success \n");
86 // push data
87 IpcIo request;
88 char data[IPC_IO_DATA_MAX];
89 IpcIoInit(&request, data, IPC_IO_DATA_MAX, 0);
90 int32_t data1 = 10;
91 int32_t data2 = 6;
92 IpcIoPushInt32(&request, data1);
93 IpcIoPushInt32(&request, data2);
94 // send and getReply
95 IpcIo reply = {nullptr};
96 uintptr_t ptr = 0;
97 Transact(NULL, *serviceSid, 0, &request, &reply, LITEIPC_FLAG_DEFAULT, &ptr);
98 g_errorCode = IpcIoPopInt32(&reply);
99 if (g_errorCode != 0) {
100 printf("execute add method, result is %d\n", g_errorCode);
101 }
102 if (ptr != 0) {
103 FreeBuffer(nullptr, reinterpret_cast<void *>(ptr));
104 }
105 sem_post(&g_sem);
106 }
107
OnAbilityDisconnectDone(ElementName * elementName,int resultCode,void * storeData)108 static void OnAbilityDisconnectDone(ElementName *elementName, int resultCode, void *storeData)
109 {
110 printf("OnAbilityDisconnectDone\n");
111 }
112
113
114 static IAbilityConnection g_conn = {
115 .OnAbilityConnectDone = OnAbilityConnectDone,
116 .OnAbilityDisconnectDone = OnAbilityDisconnectDone
117 };
118
119 class AbilityMgrTest2 : public testing::Test {
120 protected:
SetUpTestCase(void)121 static void SetUpTestCase(void)
122 {
123 printf("----------test case with AbilityMgrTest2 start-------------\n");
124 HOS_SystemInit();
125 AbilityMsClient::GetInstance().Initialize();
126 sem_init(&g_sem, 0, 0);
127 bool installResult = false;
128 InstallParam installParam = { .installLocation = 1, .keepData = false };
129 g_testPath = GetCurDir();
130 #ifdef __LINUX__
131 string hapPath = g_testPath + "testnative_hispark_aries_linux.hap";
132 #else
133 string hapPath = g_testPath + "testnative_hispark_aries_liteos.hap";
134 #endif
135 installResult = Install(hapPath.c_str(), &installParam, TestBundleStateCallback);
136 struct timespec ts = {};
137 clock_gettime(CLOCK_REALTIME, &ts);
138 ts.tv_sec += WAIT_TIMEOUT;
139 sem_timedwait(&g_sem, &ts);
140 if (installResult) {
141 printf("sem exit \n");
142 }
143 }
TearDownTestCase(void)144 static void TearDownTestCase(void)
145 {
146 bool uninstallResult = false;
147 sem_init(&g_sem, 0, 0);
148 InstallParam installParam = { .installLocation = 1, .keepData = false };
149 uninstallResult = Uninstall("com.openharmony.testnative", &installParam, TestBundleStateCallback);
150 sem_wait(&g_sem);
151 if (uninstallResult) {
152 printf("sem exit \n");
153 }
154 printf("----------test case with AbilityMgrTest2 end-------------\n");
155 }
156 };
157
158 /**
159 * @tc.number : SUB_APPEXECFWK_AMS_API_0013
160 * @tc.name : testClearElement parameter legal test
161 * @tc.desc : [C- SOFTWARE -0200]
162 */
163 HWTEST_F(AbilityMgrTest2, testClearElement, Function | MediumTest | Level0)
164 {
165 printf("------start testClearElement------\n");
166 ElementName element = { nullptr };
167 bool setResult = SetElementAbilityName(&element, "ServiceAbility");
168 if (setResult) {
169 char aName[] = "ServiceAbility";
170 EXPECT_STREQ(element.abilityName, aName);
171 printf("abilityName is %s \n", element.abilityName);
172 ClearElement(&element);
173 EXPECT_STREQ(element.abilityName, nullptr);
174 }
175 printf("------end testClearElement------\n");
176 }
177
178 /**
179 * @tc.number : SUB_APPEXECFWK_AMS_API_0014
180 * @tc.name : testClearElement parameter illegal test
181 * @tc.desc : [C- SOFTWARE -0200]
182 */
183 HWTEST_F(AbilityMgrTest2, testClearElementIllegal, Function | MediumTest | Level2)
184 {
185 printf("------start testClearElementIllegal------\n");
186 ElementName element = { nullptr };
187 bool setResult = SetElementAbilityName(&element, "ServiceAbility");
188 if (setResult) {
189 char aName[] = "ServiceAbility";
190 EXPECT_STREQ(element.abilityName, aName);
191 printf("abilityName is %s \n", element.abilityName);
192 ClearElement(nullptr);
193 EXPECT_STREQ(element.abilityName, aName);
194 printf("AbilityName of element is %s \n", element.abilityName);
195 }
196 printf("------end testClearElementIllegal------\n");
197 }
198
199 /**
200 * @tc.number : SUB_APPEXECFWK_AMS_API_0015
201 * @tc.name : testSetWantElement parameter legal test
202 * @tc.desc : [C- SOFTWARE -0200]
203 */
204 HWTEST_F(AbilityMgrTest2, testSetWantElement, Function | MediumTest | Level0)
205 {
206 printf("------start testSetWantElement------\n");
207 Want want = { nullptr };
208 ElementName element = { nullptr };
209 SetElementDeviceID(&element, "0001000");
210 SetElementBundleName(&element, "com.openharmony.testnative");
211 SetElementAbilityName(&element, "ServiceAbility");
212 if (element.abilityName != nullptr) {
213 bool setResult = SetWantElement(&want, element);
214 if (setResult) {
215 EXPECT_STREQ(want.element->deviceId, "0001000");
216 EXPECT_STREQ(want.element->abilityName, "ServiceAbility");
217 EXPECT_STREQ(want.element->bundleName, "com.openharmony.testnative");
218 }
219 }
220 ClearElement(&element);
221 ClearWant(&want);
222 printf("------end testSetWantElement------\n");
223 }
224
225 /**
226 * @tc.number : SUB_APPEXECFWK_AMS_API_0016
227 * @tc.name : testSetWantElement parameter illegal test
228 * @tc.desc : [C- SOFTWARE -0200]
229 */
230 HWTEST_F(AbilityMgrTest2, testSetWantElementIllegal, Function | MediumTest | Level2)
231 {
232 printf("------start testSetWantElementIllegal------\n");
233 Want want = { nullptr };
234 ElementName element = { nullptr };
235 bool setResult = SetWantElement(&want, element);
236 if (setResult) {
237 EXPECT_STREQ(want.element->deviceId, nullptr);
238 EXPECT_STREQ(want.element->abilityName, nullptr);
239 EXPECT_STREQ(want.element->bundleName, nullptr);
240 }
241 ClearElement(&element);
242 ClearWant(&want);
243 printf("------end testSetWantElementIllegal------\n");
244 }
245
246 /**
247 * @tc.number : SUB_APPEXECFWK_AMS_API_0022
248 * @tc.name : testClearWant parameter illegal test
249 * @tc.desc : [C- SOFTWARE -0200]
250 */
251 HWTEST_F(AbilityMgrTest2, testClearWantIllegal, Function | MediumTest | Level2)
252 {
253 printf("------start testClearWantIllegal------\n");
254 Want want = { nullptr };
255 ElementName element = { nullptr };
256 bool setResult = SetElementAbilityName(&element, "ServiceAbility");
257 if (setResult) {
258 setResult = SetWantElement(&want, element);
259 if (setResult) {
260 char aName[] = "ServiceAbility";
261 EXPECT_STREQ(want.element->abilityName, aName);
262 printf("abilityName is %s \n", want.element->abilityName);
263 ClearWant(nullptr);
264 EXPECT_STREQ(want.element->abilityName, aName);
265 }
266 }
267 ClearElement(&element);
268 ClearWant(&want);
269 printf("------end testClearWantIllegal------\n");
270 }
271
272 /**
273 * @tc.number : SUB_APPEXECFWK_AMS_API_0025
274 * @tc.name : testWantToUri parameter legal test
275 * @tc.desc : [C- SOFTWARE -0200]
276 */
277 HWTEST_F(AbilityMgrTest2, testWantToUri, Function | MediumTest | Level0)
278 {
279 printf("------start testWantToUri------\n");
280 Want want = { nullptr };
281 ElementName element = { nullptr };
282 SetElementDeviceID(&element, "0001000");
283 SetElementBundleName(&element, "com.openharmony.testnative");
284 SetElementAbilityName(&element, "SecondAbility");
285 if (element.abilityName !=nullptr) {
286 bool setResult = SetWantElement(&want, element);
287 if (setResult) {
288 const char *uri = WantToUri(want);
289 printf("uri is %s \n", uri);
290 const char *expectResult = "#Want;device=0001000;bundle=com.openharmony.testnative;ability=SecondAbility;end";
291 EXPECT_STREQ(uri, expectResult);
292 free((void*)uri);
293 }
294 }
295 ClearElement(&element);
296 ClearWant(&want);
297 printf("------end testWantToUri------\n");
298 }
299
300 /**
301 * @tc.number : SUB_APPEXECFWK_AMS_API_0026
302 * @tc.name : testWantToUri parameter illegal test
303 * @tc.desc : [C- SOFTWARE -0200]
304 */
305 HWTEST_F(AbilityMgrTest2, testWantToUriIllegal, Function | MediumTest | Level2)
306 {
307 printf("------start testWantToUriIllegal------\n");
308 Want want = { nullptr };
309 const char *uri = WantToUri(want);
310 printf("uri is %s \n", uri);
311 const char *expectResult = "#Want;device=;bundle=;ability=;end";
312 EXPECT_STREQ(uri, expectResult);
313 if (uri != nullptr) {
314 free((void*)uri);
315 }
316 printf("------end testWantToUriIllegal------\n");
317 }
318
319 /**
320 * @tc.number : SUB_APPEXECFWK_AMS_API_0017
321 * @tc.name : testSetWantDate parameter legal test
322 * @tc.desc : [C- SOFTWARE -0200]
323 */
324 HWTEST_F(AbilityMgrTest2, testSetWantDate, Function | MediumTest | Level0)
325 {
326 printf("------start testSetWantDate------\n");
327 Want want = { nullptr };
328 SetWantData(&want, "test", 5);
329 if (want.data != nullptr) {
330 printf("data is %s \n", (char*)(want.data));
331 printf("dataLength is %d \n", want.dataLength);
332 EXPECT_STREQ((char*)(want.data), "test");
333 EXPECT_TRUE(want.dataLength == 5);
334 }
335 ClearWant(&want);
336 printf("------end testSetWantDate------\n");
337 }
338
339 /**
340 * @tc.number : SUB_APPEXECFWK_AMS_API_0018
341 * @tc.name : testSetWantDate parameter illegal test
342 * @tc.desc : [C- SOFTWARE -0200]
343 */
344 HWTEST_F(AbilityMgrTest2, testSetWantDateIllegal, Function | MediumTest | Level2)
345 {
346 printf("------start testSetWantDateIllegal------\n");
347 Want want = { nullptr };
348 SetWantData(&want, "test", -1);
349 printf("dataLength is %d \n", want.dataLength);
350 EXPECT_STREQ((char*)(want.data), nullptr);
351 EXPECT_TRUE(want.dataLength == 0);
352 SetWantData(&want, nullptr, 0);
353 printf("dataLength is %d \n", want.dataLength);
354 EXPECT_STREQ((char*)(want.data), nullptr);
355 EXPECT_TRUE(want.dataLength == 0);
356 printf("------end testSetWantDateIllegal------\n");
357 }
358
359 /**
360 * @tc.number : SUB_APPEXECFWK_AMS_API_0023
361 * @tc.name : testWantParseUri parameter legal test
362 * @tc.desc : [C- SOFTWARE -0200]
363 */
364 HWTEST_F(AbilityMgrTest2, testWantParseUri, Function | MediumTest | Level0)
365 {
366 printf("------start testWantParseUri------\n");
367 Want want = { nullptr };
368 ElementName element = { nullptr };
369 SetElementDeviceID(&element, "0001000");
370 SetElementBundleName(&element, "com.openharmony.testnative");
371 SetElementAbilityName(&element, "ServiceAbility");
372 if (element.abilityName != nullptr) {
373 bool setResult = SetWantElement(&want, element);
374 if (setResult) {
375 const char *uri = WantToUri(want);
376 Want *want2 = WantParseUri(uri);
377 printf("uri is %s \n", uri);
378 if (uri != nullptr) {
379 free((void*)uri);
380 }
381 EXPECT_STREQ(want2->element->deviceId, want.element->deviceId);
382 EXPECT_STREQ(want2->element->abilityName, want.element->abilityName);
383 EXPECT_STREQ(want2->element->bundleName, want.element->bundleName);
384 free(want2);
385 }
386 }
387 ClearElement(&element);
388 ClearWant(&want);
389 printf("------end testWantParseUri------\n");
390 }
391
392 /**
393 * @tc.number : SUB_APPEXECFWK_AMS_API_0024
394 * @tc.name : testWantParseUri parameter illegal test
395 * @tc.desc : [C- SOFTWARE -0200]
396 */
397 HWTEST_F(AbilityMgrTest2, testWantParseUriIllegal, Function | MediumTest | Level2)
398 {
399 printf("------start testWantParseUriIllegal------\n");
400 Want want = { nullptr };
401 ElementName element = { nullptr };
402 SetElementBundleName(&element, nullptr);
403 SetWantElement(&want, element);
404 const char *uri = WantToUri(want);
405 // empty
406 printf("uri is %s \n", uri);
407 Want *want2 = WantParseUri(uri);
408 if (uri != nullptr) {
409 free((void*)uri);
410 }
411 if (want2 != nullptr) {
412 printf("want is %s \n", want2->element->bundleName);
413 EXPECT_STREQ(want2->element->deviceId, "");
414 EXPECT_STREQ(want2->element->abilityName, "");
415 EXPECT_STREQ(want2->element->bundleName, "");
416 free(want2);
417 }
418 // nullptr
419 Want *want4 = WantParseUri(nullptr);
420 printf("want4 is %p \n", want4);
421 EXPECT_TRUE(want4 == nullptr);
422 const char *str = "test";
423 // error format
424 Want *want1 = WantParseUri(str);
425 printf("want is %p \n", want1);
426 EXPECT_TRUE(want1 == nullptr);
427 Want *want3 = WantParseUri("");
428 printf("want is %p \n", want3);
429 EXPECT_TRUE(want3 == nullptr);
430 free(want1);
431 free(want3);
432 ClearElement(&element);
433 ClearWant(&want);
434 printf("------end testWantParseUriIllegal------\n");
435 }
436
437 /**
438 * @tc.number : SUB_APPEXECFWK_AMS_API_0030
439 * @tc.name : testGetBundleNameIllegal parameter illegal test
440 * @tc.desc : [C- SOFTWARE -0200]
441 */
442 HWTEST_F(AbilityMgrTest2, testGetBundleNameIllegal, Function | MediumTest | Level1)
443 {
444 printf("------start testGetBundleNameIllegal------\n");
445 Want want;
446 memset_s(&want, sizeof(Want), 0, sizeof(Want));
447 ElementName element;
448 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
449 SetElementBundleName(&element, "com.openharmony.testnative");
450 SetElementAbilityName(&element, "ServiceAbility");
451 SetWantElement(&want, element);
452 int result = StartAbility(&want);
453 sleep(2);
454 printf("ret is %d \n", result);
455 const char * bundleName1 = GetBundleName();
456 printf("result of GetBundleName is %s \n", bundleName1);
457 EXPECT_STREQ(bundleName1, "");
458 g_errorCode = StopAbility(&want);
459 sleep(2);
460 printf("------end testGetBundleNameIllegal------\n");
461 }
462
463 /**
464 * @tc.number : SUB_APPEXECFWK_AMS_API_0031
465 * @tc.name : testGetSrcPathIllegal parameter illegal test
466 * @tc.desc : [C- SOFTWARE -0200]
467 */
468 HWTEST_F(AbilityMgrTest2, testGetSrcPathIllegal, Function | MediumTest | Level1)
469 {
470 printf("------start testGetSrcPathIllegal------\n");
471 Want want = { nullptr };
472 ElementName element = { nullptr };
473 SetElementBundleName(&element, "com.openharmony.testnative");
474 SetElementAbilityName(&element, "ServiceAbility");
475 SetWantElement(&want, element);
476 int result = StartAbility(&want);
477 sleep(2);
478 printf("ret is %d \n", result);
479 const char * srcPath = GetSrcPath();
480 printf("result of GetSrcPath is %s \n", srcPath);
481 EXPECT_STREQ(srcPath, "");
482 g_errorCode = StopAbility(&want);
483 sleep(2);
484 printf("------end testGetSrcPathIllegal------\n");
485 }
486
487 /**
488 * @tc.number : SUB_APPEXECFWK_AMS_API_0032
489 * @tc.name : testGetDataPath parameter illegal test
490 * @tc.desc : [C- SOFTWARE -0200]
491 */
492 HWTEST_F(AbilityMgrTest2, testGetDataPathIllegal, Function | MediumTest | Level1)
493 {
494 printf("------start testGetDataPathIllegal------\n");
495 Want want = { nullptr };
496 ElementName element = { nullptr };
497 SetElementBundleName(&element, "com.openharmony.testnative");
498 SetElementAbilityName(&element, "ServiceAbility");
499 SetWantElement(&want, element);
500 int result = StartAbility(&want);
501 sleep(2);
502 printf("ret is %d \n", result);
503 const char * dataPath = GetDataPath();
504 printf("result of GetDataPath is %s \n", dataPath);
505 EXPECT_STREQ(dataPath, "");
506 g_errorCode = StopAbility(&want);
507 sleep(2);
508 printf("------end testGetDataPathIllegal------\n");
509 }
510
511 /**
512 * @tc.number : SUB_APPEXECFWK_AMS_API_0019
513 * @tc.name : testDump parameter illegal test
514 * @tc.desc : [C- SOFTWARE -0200]
515 */
516 HWTEST_F(AbilityMgrTest2, testDumpIllegal, Function | MediumTest | Level1)
517 {
518 printf("------start testDump------\n");
519 Want want;
520 memset_s(&want, sizeof(Want), 0, sizeof(Want));
521 ElementName element;
522 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
523 SetElementBundleName(&element, "com.openharmony.testnative");
524 SetElementAbilityName(&element, "ServiceAbility");
525 SetWantElement(&want, element);
526 Ability *ability = new Ability();
527 int result = ability->StartAbility(want);
528 sleep(2);
529 printf("ret is %d \n", result);
530 EXPECT_EQ(result, 0);
531 char *extra = (char*)"test";
532 ability->Dump(extra);
533 g_errorCode = StopAbility(&want);
534 sleep(2);
535 printf("------end testDump------\n");
536 }
537
538 /**
539 * @tc.number : SUB_APPEXECFWK_AMS_API_0033
540 * @tc.name : testStartAbility parameter legal test
541 * @tc.desc : [C- SOFTWARE -0200]
542 */
543 HWTEST_F(AbilityMgrTest2, testStartAbility, Function | MediumTest | Level1)
544 {
545 printf("------start testStartAbility------\n");
546 Want want = { nullptr };
547 ElementName element = { nullptr };
548 SetElementBundleName(&element, "com.openharmony.testnative");
549 SetElementAbilityName(&element, "ServiceAbility");
550 SetWantElement(&want, element);
551 int result = StartAbility(&want);
552 sleep(2);
553 printf("ret is %d \n", result);
554 EXPECT_EQ(result, 0);
555 g_errorCode = StopAbility(&want);
556 sleep(2);
557 ClearElement(&element);
558 ClearWant(&want);
559 printf("------end testStartAbility------\n");
560 }
561
562 /**
563 * @tc.number : SUB_APPEXECFWK_AMS_API_0005
564 * @tc.name : testStartAbilityIllegal parameter illegal test
565 * @tc.desc : [C- SOFTWARE -0200]
566 */
567 HWTEST_F(AbilityMgrTest2, testStartAbilityIllegal, Function | MediumTest | Level2)
568 {
569 printf("------start testStartAbilityIllegal------\n");
570 int result = StartAbility(nullptr);
571 printf("ret is %d \n", result);
572 int expect = -1;
573 EXPECT_EQ(result, expect);
574 printf("------end testStartAbilityIllegal------\n");
575 }
576
577 /**
578 * @tc.number : SUB_APPEXECFWK_AMS_API_0006
579 * @tc.name : testStopAbility parameter legal test
580 * @tc.desc : [C- SOFTWARE -0200]
581 */
582 HWTEST_F(AbilityMgrTest2, testStopAbility, Function | MediumTest | Level0)
583 {
584 printf("------start testStopAbility------\n");
585 Want want = { nullptr };
586 ElementName element = { nullptr };
587 SetElementBundleName(&element, "com.openharmony.testnative");
588 SetElementAbilityName(&element, "ServiceAbility");
589 SetWantElement(&want, element);
590 g_errorCode = StartAbility(&want);
591 sleep(2);
592 printf("ret is %d \n", g_errorCode);
593 EXPECT_EQ(g_errorCode, 0);
594 g_errorCode = StopAbility(&want);
595 sleep(2);
596 printf("ret of stop is %d \n", g_errorCode);
597 EXPECT_EQ(g_errorCode, 0);
598 ClearElement(&element);
599 ClearWant(&want);
600 printf("------end testStopAbility------\n");
601 }
602
603 /**
604 * @tc.number : SUB_APPEXECFWK_AMS_API_0007
605 * @tc.name : testStopAbilityIllegal parameter illegal test
606 * @tc.desc : [C- SOFTWARE -0200]
607 */
608 HWTEST_F(AbilityMgrTest2, testStopAbilityIllegal, Function | MediumTest | Level2)
609 {
610 printf("------start testStopAbilityIllegal------\n");
611 g_errorCode = StopAbility(nullptr);
612 printf("ret of stop is %d \n", g_errorCode);
613 EXPECT_EQ(g_errorCode, -1);
614 printf("------end testStopAbilityIllegal------\n");
615 }
616
617 /**
618 * @tc.number : SUB_APPEXECFWK_AMS_API_0009
619 * @tc.name : testConnectAbilityIllegal parameter illegal test
620 * @tc.desc : [C- SOFTWARE -0200]
621 */
622 HWTEST_F(AbilityMgrTest2, testConnectAbilityIllegal, Function | MediumTest | Level1)
623 {
624 printf("------start testConnectAbilityIllegal------\n");
625 Want want = { nullptr };
626 ElementName element = { nullptr };
627 SetElementBundleName(&element, "com.openharmony.testnative");
628 SetElementAbilityName(&element, "ServiceAbility");
629 SetWantElement(&want, element);
630 g_errorCode = ConnectAbility(nullptr, &g_conn, this);
631 printf("ret1 is %d \n ", g_errorCode);
632 EXPECT_EQ(g_errorCode, -1);
633 g_errorCode = ConnectAbility(&want, nullptr, this);
634 printf("ret2 is %d \n ", g_errorCode);
635 EXPECT_EQ(g_errorCode, -1);
636 ClearElement(&element);
637 ClearWant(&want);
638 printf("------end testConnectAbilityIllegal------\n");
639 }
640
641 /**
642 * @tc.number : SUB_APPEXECFWK_AMS_API_0012
643 * @tc.name : testTerminateAbility parameter legal test
644 * @tc.desc : [C- SOFTWARE -0200]
645 */
646 HWTEST_F(AbilityMgrTest2, testTerminateAbility, Function | MediumTest | Level1)
647 {
648 printf("------start testTerminateAbility------\n");
649 Want want = { nullptr };
650 ElementName element = { nullptr };
651 SetElementBundleName(&element, "com.openharmony.testnative");
652 SetElementAbilityName(&element, "ServiceAbility");
653 SetWantElement(&want, element);
654 int result1 = StartAbility(&want);
655 sleep(2);
656 printf("result1 of startAbility is %d \n", result1);
657 EXPECT_EQ(result1, 0);
658 Ability *ability = new Ability();
659 int result2 = ability->TerminateAbility();
660 sleep(2);
661 printf("result2 of TerminateAbility is %d \n", result2);
662 EXPECT_EQ(result2, 0);
663 ClearElement(&element);
664 ClearWant(&want);
665 delete ability;
666 printf("------end testTerminateAbility------\n");
667 }
668
669 /**
670 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0004
671 * @tc.name : test Want Not Match BundleInfo
672 * @tc.desc : [C- SOFTWARE -0200]
673 */
674 HWTEST_F(AbilityMgrTest2, testWantNotMathBundle, Function | MediumTest | Level2)
675 {
676 printf("------start testWantNotMathBundle------\n");
677 Want want;
678 memset_s(&want, sizeof(Want), 0, sizeof(Want));
679 ElementName element;
680 std::string aName = "NoThisAbility";
681 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
682 SetElementAbilityName(&element, aName.c_str());
683 SetElementBundleName(&element, "com.openharmony.nothishap");
684 SetWantElement(&want, element);
685 AbilityInfo abilityInfo;
686 memset_s(&abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo));
687 g_errorCode = QueryAbilityInfo(&want, &abilityInfo);
688 printf("ret is %d \n", g_errorCode);
689 EXPECT_TRUE(g_errorCode != 0);
690 int result = StartAbility(&want);
691 sleep(2);
692 printf("result of startAbility is %d \n", result);
693 EXPECT_TRUE(result == 0);
694 printf("element is %s \n", want.element->bundleName);
695 g_errorCode = StopAbility(&want);
696 sleep(2);
697 ClearElement(&element);
698 ClearWant(&want);
699 printf("------end testWantNotMathBundle------\n");
700 }
701
702 /**
703 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0002
704 * @tc.name : testWantOnlyMathBundle
705 * @tc.desc : [C- SOFTWARE -0200]
706 */
707 HWTEST_F(AbilityMgrTest2, testWantOnlyMathBundleName, Function | MediumTest | Level1)
708 {
709 printf("------start testWantOnlyMathBundleName------\n");
710 Want want;
711 memset_s(&want, sizeof(Want), 0, sizeof(Want));
712 ElementName element;
713 std::string aName = "Ability";
714 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
715 SetElementAbilityName(&element, aName.c_str());
716 SetElementBundleName(&element, "com.openharmony.testnative");
717 SetWantElement(&want, element);
718 AbilityInfo abilityInfo;
719 memset_s(&abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo));
720 g_errorCode = QueryAbilityInfo(&want, &abilityInfo);
721 printf("ret is %d \n", g_errorCode);
722 EXPECT_TRUE(g_errorCode != 0);
723 int result = StartAbility(&want);
724 sleep(2);
725 printf("result of startAbility is %d \n", result);
726 EXPECT_TRUE(result == 0);
727 printf("element is %s \n", want.element->bundleName);
728 g_errorCode = StopAbility(&want);
729 sleep(2);
730 ClearElement(&element);
731 ClearWant(&want);
732 printf("------end testWantOnlyMathBundleName------\n");
733 }
734
735 /**
736 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0003
737 * @tc.name : testWantOnlyMathAbility
738 * @tc.desc : [C- SOFTWARE -0200]
739 */
740 HWTEST_F(AbilityMgrTest2, testWantOnlyMathAbility, Function | MediumTest | Level1)
741 {
742 printf("------start testWantOnlyMathAbility------\n");
743 Want want;
744 memset_s(&want, sizeof(Want), 0, sizeof(Want));
745 ElementName element;
746 std::string aName = "ServiceAbility";
747 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
748 SetElementAbilityName(&element, aName.c_str());
749 SetElementBundleName(&element, "com.openharmony.test");
750 SetWantElement(&want, element);
751 AbilityInfo abilityInfo;
752 memset_s(&abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo));
753 g_errorCode = QueryAbilityInfo(&want, &abilityInfo);
754 printf("ret is %d \n", g_errorCode);
755 EXPECT_TRUE(g_errorCode != 0);
756 int result = StartAbility(&want);
757 sleep(2);
758 printf("result of startAbility is %d \n", result);
759 EXPECT_TRUE(result == 0);
760 printf("element is %s \n", want.element->abilityName);
761 g_errorCode = StopAbility(&want);
762 sleep(2);
763 ClearElement(&element);
764 ClearWant(&want);
765 printf("------end testWantOnlyMathAbility------\n");
766 }
767
768 /**
769 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0006
770 * @tc.name : test WantData Not Match DataLength
771 * @tc.desc : [C- SOFTWARE -0200]
772 */
773 HWTEST_F(AbilityMgrTest2, testWantDataNotMatchLength, Function | MediumTest | Level2)
774 {
775 printf("------start testWantDataNotMatchLength------\n");
776 Want want;
777 memset_s(&want, sizeof(Want), 0, sizeof(Want));
778 ElementName element;
779 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
780 SetElementAbilityName(&element, "ServiceAbility");
781 SetElementBundleName(&element, "com.openharmony.testnative");
782 SetWantElement(&want, element);
783 SetWantData(&want, "test", 3);
784 int result = StartAbility(&want);
785 sleep(2);
786 printf("result of startAbility is %d \n", result);
787 EXPECT_TRUE(result == 0);
788 EXPECT_EQ(want.dataLength, 3);
789 g_errorCode = StopAbility(&want);
790 sleep(2);
791 ClearElement(&element);
792 ClearWant(&want);
793 printf("------end testWantDataNotMatchLength------\n");
794 }
795
796 /**
797 * @tc.number : SUB_APPEXECFWK_AMS_API_0040
798 * @tc.name : PostTask parameter illegal test that callback is null
799 * @tc.desc : [C- SOFTWARE -0200]
800 */
801 HWTEST_F(AbilityMgrTest2, testPostTask, Function | MediumTest | Level1)
802 {
803 printf("------start testPostTask------\n");
804 #ifdef __LINUX__
805 string hapPath = g_testPath + "testnative_hispark_aries_linux.hap";
806 #else
807 string hapPath = g_testPath + "testnative_hispark_aries_liteos.hap";
808 #endif
809 AbilityEventHandler eventHandler1;
__anonc61d5f280102null810 auto task = [this, hapPath]{
811 sem_init(&g_sem, 0, 0);
812 InstallParam installParam = { .installLocation = 1, .keepData = false };
813 bool installResult = Install(hapPath.c_str(), &installParam, TestBundleStateCallback);
814 sem_wait(&g_sem);
815 printf("installResult is %d \n", installResult);
816 EXPECT_TRUE(installResult);
817
818 AbilityEventHandler *eventHandler2 = AbilityEventHandler::GetCurrentHandler();
819 eventHandler2->PostQuit();
820 };
821 eventHandler1.PostTask(task);
822 eventHandler1.Run();
823 printf("------end testPostTask------\n");
824 }
825