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 <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 AbilityMgrTest : public testing::Test {
120 protected:
SetUpTestCase(void)121 static void SetUpTestCase(void)
122 {
123 printf("----------test case with AbilityMgrTest 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_taurus_linux.hap";
132 #else
133 string hapPath = g_testPath + "testnative_hispark_taurus_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 AbilityMgrTest 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(AbilityMgrTest, testClearElement, Function | MediumTest | Level0)
164 {
165 printf("------start testClearElement------\n");
166 ElementName element = { nullptr };
167 bool setResult = SetElementAbilityName(&element, "SecondAbility");
168 if (setResult) {
169 char aName[] = "SecondAbility";
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(AbilityMgrTest, testClearElementIllegal, Function | MediumTest | Level2)
184 {
185 printf("------start testClearElementIllegal------\n");
186 ElementName element = { nullptr };
187 bool setResult = SetElementAbilityName(&element, "SecondAbility");
188 if (setResult) {
189 char aName[] = "SecondAbility";
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(AbilityMgrTest, 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, "SecondAbility");
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, "SecondAbility");
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(AbilityMgrTest, 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(AbilityMgrTest, testClearWantIllegal, Function | MediumTest | Level2)
252 {
253 printf("------start testClearWantIllegal------\n");
254 Want want = { nullptr };
255 ElementName element = { nullptr };
256 bool setResult = SetElementAbilityName(&element, "SecondAbility");
257 if (setResult) {
258 setResult = SetWantElement(&want, element);
259 if (setResult) {
260 char aName[] = "SecondAbility";
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(AbilityMgrTest, 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(AbilityMgrTest, 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(AbilityMgrTest, 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(AbilityMgrTest, 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(AbilityMgrTest, 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, "SecondAbility");
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(AbilityMgrTest, 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(AbilityMgrTest, 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, "SecondAbility");
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 printf("------end testGetBundleNameIllegal------\n");
459 }
460
461 /**
462 * @tc.number : SUB_APPEXECFWK_AMS_API_0031
463 * @tc.name : testGetSrcPathIllegal parameter illegal test
464 * @tc.desc : [C- SOFTWARE -0200]
465 */
466 HWTEST_F(AbilityMgrTest, testGetSrcPathIllegal, Function | MediumTest | Level1)
467 {
468 printf("------start testGetSrcPathIllegal------\n");
469 Want want = { nullptr };
470 ElementName element = { nullptr };
471 SetElementBundleName(&element, "com.openharmony.testnative");
472 SetElementAbilityName(&element, "SecondAbility");
473 SetWantElement(&want, element);
474 int result = StartAbility(&want);
475 sleep(2);
476 printf("ret is %d \n", result);
477 const char * srcPath = GetSrcPath();
478 EXPECT_STREQ(srcPath, "");
479 printf("------end testGetSrcPathIllegal------\n");
480 }
481
482 /**
483 * @tc.number : SUB_APPEXECFWK_AMS_API_0032
484 * @tc.name : testGetDataPath parameter illegal test
485 * @tc.desc : [C- SOFTWARE -0200]
486 */
487 HWTEST_F(AbilityMgrTest, testGetDataPathIllegal, Function | MediumTest | Level1)
488 {
489 printf("------start testGetDataPathIllegal------\n");
490 Want want = { nullptr };
491 ElementName element = { nullptr };
492 SetElementBundleName(&element, "com.openharmony.testnative");
493 SetElementAbilityName(&element, "SecondAbility");
494 SetWantElement(&want, element);
495 int result = StartAbility(&want);
496 sleep(2);
497 printf("ret is %d \n", result);
498 const char * dataPath = GetDataPath();
499 printf("result of GetDataPath is %s \n", dataPath);
500 EXPECT_STREQ(dataPath, "");
501 printf("------end testGetDataPathIllegal------\n");
502 }
503
504 /**
505 * @tc.number : SUB_APPEXECFWK_AMS_API_0019
506 * @tc.name : testDump parameter illegal test
507 * @tc.desc : [C- SOFTWARE -0200]
508 */
509 HWTEST_F(AbilityMgrTest, testDumpIllegal, Function | MediumTest | Level1)
510 {
511 printf("------start testDump------\n");
512 Want want;
513 memset_s(&want, sizeof(Want), 0, sizeof(Want));
514 ElementName element;
515 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
516 SetElementBundleName(&element, "com.openharmony.testnative");
517 SetElementAbilityName(&element, "SecondAbility");
518 SetWantElement(&want, element);
519 Ability *ability = new Ability();
520 int result = ability->StartAbility(want);
521 sleep(2);
522 printf("ret is %d \n", result);
523 EXPECT_EQ(result, 0);
524 char *extra = (char*)"test";
525 ability->Dump(extra);
526 printf("------end testDump------\n");
527 }
528
529 /**
530 * @tc.number : SUB_APPEXECFWK_AMS_API_0033
531 * @tc.name : testStartAbility parameter legal test
532 * @tc.desc : [C- SOFTWARE -0200]
533 */
534 HWTEST_F(AbilityMgrTest, testStartAbility, Function | MediumTest | Level1)
535 {
536 printf("------start testStartAbility------\n");
537 Want want = { nullptr };
538 ElementName element = { nullptr };
539 SetElementBundleName(&element, "com.openharmony.testnative");
540 SetElementAbilityName(&element, "MainAbility");
541 SetWantElement(&want, element);
542 int result = StartAbility(&want);
543 sleep(2);
544 printf("ret is %d \n", result);
545 EXPECT_EQ(result, 0);
546 ClearElement(&element);
547 ClearWant(&want);
548 printf("------end testStartAbility------\n");
549 }
550
551 /**
552 * @tc.number : SUB_APPEXECFWK_AMS_API_0005
553 * @tc.name : testStartAbilityIllegal parameter illegal test
554 * @tc.desc : [C- SOFTWARE -0200]
555 */
556 HWTEST_F(AbilityMgrTest, testStartAbilityIllegal, Function | MediumTest | Level2)
557 {
558 printf("------start testStartAbilityIllegal------\n");
559 int result = StartAbility(nullptr);
560 printf("ret is %d \n", result);
561 int expect = -1;
562 EXPECT_EQ(result, expect);
563 printf("------end testStartAbilityIllegal------\n");
564 }
565
566 /**
567 * @tc.number : SUB_APPEXECFWK_AMS_API_0006
568 * @tc.name : testStopAbility parameter legal test
569 * @tc.desc : [C- SOFTWARE -0200]
570 */
571 HWTEST_F(AbilityMgrTest, testStopAbility, Function | MediumTest | Level0)
572 {
573 printf("------start testStopAbility------\n");
574 Want want = { nullptr };
575 ElementName element = { nullptr };
576 SetElementBundleName(&element, "com.openharmony.testnative");
577 SetElementAbilityName(&element, "ServiceAbility");
578 SetWantElement(&want, element);
579 g_errorCode = StartAbility(&want);
580 sleep(2);
581 printf("ret is %d \n", g_errorCode);
582 EXPECT_EQ(g_errorCode, 0);
583 g_errorCode = StopAbility(&want);
584 sleep(2);
585 printf("ret of stop is %d \n", g_errorCode);
586 EXPECT_EQ(g_errorCode, 0);
587 ClearElement(&element);
588 ClearWant(&want);
589 printf("------end testStopAbility------\n");
590 }
591
592 /**
593 * @tc.number : SUB_APPEXECFWK_AMS_API_0007
594 * @tc.name : testStopAbilityIllegal parameter illegal test
595 * @tc.desc : [C- SOFTWARE -0200]
596 */
597 HWTEST_F(AbilityMgrTest, testStopAbilityIllegal, Function | MediumTest | Level2)
598 {
599 printf("------start testStopAbilityIllegal------\n");
600 g_errorCode = StopAbility(nullptr);
601 printf("ret of stop is %d \n", g_errorCode);
602 EXPECT_EQ(g_errorCode, -1);
603 printf("------end testStopAbilityIllegal------\n");
604 }
605
606 /**
607 * @tc.number : SUB_APPEXECFWK_AMS_API_0008
608 * @tc.name : testConnectAbility parameter legal test
609 * @tc.desc : [C- SOFTWARE -0200]
610 */
611 HWTEST_F(AbilityMgrTest, testConnectAbility, Function | MediumTest | Level1)
612 {
613 printf("------start testConnectAbility------\n");
614 Want want = { nullptr };
615 ElementName element = { nullptr };
616 SetElementBundleName(&element, "com.openharmony.testnative");
617 SetElementAbilityName(&element, "ServiceAbility");
618 SetWantElement(&want, element);
619 sem_init(&g_sem, 0, 0);
620 int result = ConnectAbility(&want, &g_conn, this);
621 struct timespec ts = {};
622 clock_gettime(CLOCK_REALTIME, &ts);
623 ts.tv_sec += WAIT_TIMEOUT;
624 sem_timedwait(&g_sem, &ts);
625 printf("sem exit \n");
626 printf("ret is %d \n ", result);
627 EXPECT_EQ(result, 0);
628 DisconnectAbility(&g_conn);
629 sleep(1);
630 ClearElement(&element);
631 ClearWant(&want);
632 printf("------end testConnectAbility------\n");
633 }
634
635 /**
636 * @tc.number : SUB_APPEXECFWK_AMS_API_0010
637 * @tc.name : testWantMathBundle
638 * @tc.desc : [C- SOFTWARE -0100]
639 * @tc.author : lijiashan
640 */
641 HWTEST_F(AbilityMgrTest, testDisConnectAbility, Function | MediumTest | Level1)
642 {
643 printf("------start testDisConnectAbility------\n");
644 Want want = { nullptr };
645 ElementName element = { nullptr };
646 SetElementBundleName(&element, "com.openharmony.testnative");
647 SetElementAbilityName(&element, "ServiceAbility");
648 SetWantElement(&want, element);
649 sem_init(&g_sem, 0, 0);
650 int result = ConnectAbility(&want, &g_conn, this);
651 struct timespec ts = {};
652 clock_gettime(CLOCK_REALTIME, &ts);
653 ts.tv_sec += WAIT_TIMEOUT;
654 sem_timedwait(&g_sem, &ts);
655 printf("sem exit \n");
656 printf("ret of connect is %d \n ", result);
657 if (g_errorCode == 16) {
658 result = DisconnectAbility(&g_conn);
659 sleep(2);
660 EXPECT_EQ(result, 0);
661 printf("ret of disconnect is %d \n ", result);
662 }
663 ClearElement(&element);
664 ClearWant(&want);
665 printf("------end testDisConnectAbility------\n");
666 }
667
668 /**
669 * @tc.number : SUB_APPEXECFWK_AMS_API_0009
670 * @tc.name : testConnectAbilityIllegal parameter illegal test
671 * @tc.desc : [C- SOFTWARE -0200]
672 */
673 HWTEST_F(AbilityMgrTest, testConnectAbilityIllegal, Function | MediumTest | Level1)
674 {
675 printf("------start testConnectAbilityIllegal------\n");
676 Want want = { nullptr };
677 ElementName element = { nullptr };
678 SetElementBundleName(&element, "com.openharmony.testnative");
679 SetElementAbilityName(&element, "ServiceAbility");
680 SetWantElement(&want, element);
681 g_errorCode = ConnectAbility(nullptr, &g_conn, this);
682 printf("ret1 is %d \n ", g_errorCode);
683 EXPECT_EQ(g_errorCode, -1);
684 g_errorCode = ConnectAbility(&want, nullptr, this);
685 printf("ret2 is %d \n ", g_errorCode);
686 EXPECT_EQ(g_errorCode, -1);
687 ClearElement(&element);
688 ClearWant(&want);
689 printf("------end testConnectAbilityIllegal------\n");
690 }
691
692 /**
693 * @tc.number : SUB_APPEXECFWK_AMS_API_0011
694 * @tc.name : testDisConnectAbilityIllegal parameter illegal test
695 * @tc.desc : [C- SOFTWARE -0200]
696 */
697 HWTEST_F(AbilityMgrTest, testDisConnectAbilityIllegal, Function | MediumTest | Level1)
698 {
699 printf("------start testDisConnectAbilityIllegal------\n");
700 Want want = { nullptr };
701 ElementName element = { nullptr };
702 SetElementBundleName(&element, "com.openharmony.testnative");
703 SetElementAbilityName(&element, "ServiceAbility");
704 SetWantElement(&want, element);
705 sem_init(&g_sem, 0, 0);
706 int result = ConnectAbility(&want, &g_conn, this);
707 struct timespec ts = {};
708 clock_gettime(CLOCK_REALTIME, &ts);
709 ts.tv_sec += WAIT_TIMEOUT;
710 sem_timedwait(&g_sem, &ts);
711 printf("sem exit \n");
712 printf("ret is of connect is %d \n ", g_errorCode);
713 EXPECT_EQ(result, 0);
714 g_errorCode = DisconnectAbility(nullptr);
715 int expect = -10;
716 EXPECT_EQ(g_errorCode, expect);
717 printf("ret of disconnect is %d \n ", g_errorCode);
718 ClearElement(&element);
719 ClearWant(&want);
720 printf("------end testDisConnectAbilityIllegal------\n");
721 }
722
723 /**
724 * @tc.number : SUB_APPEXECFWK_AMS_API_0012
725 * @tc.name : testTerminateAbility parameter legal test
726 * @tc.desc : [C- SOFTWARE -0200]
727 */
728 HWTEST_F(AbilityMgrTest, testTerminateAbility, Function | MediumTest | Level1)
729 {
730 printf("------start testTerminateAbility------\n");
731 Want want = { nullptr };
732 ElementName element = { nullptr };
733 SetElementBundleName(&element, "com.openharmony.testnative");
734 SetElementAbilityName(&element, "SecondAbility");
735 SetWantElement(&want, element);
736 int result1 = StartAbility(&want);
737 sleep(2);
738 printf("result1 of startAbility is %d \n", result1);
739 EXPECT_EQ(result1, 0);
740 Ability *ability = new Ability();
741 int result2 = ability->TerminateAbility();
742 sleep(2);
743 printf("result2 of TerminateAbility is %d \n", result2);
744 EXPECT_EQ(result2, 0);
745 ClearElement(&element);
746 ClearWant(&want);
747 delete ability;
748 printf("------end testTerminateAbility------\n");
749 }
750
751 /**
752 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0001
753 * @tc.name : test Want Match BundleInfo
754 * @tc.desc : [C- SOFTWARE -0200]
755 */
756 HWTEST_F(AbilityMgrTest, testWantMatchBundle, Function | MediumTest | Level1)
757 {
758 printf("------start testWantMathBundle------\n");
759 Want want;
760 memset_s(&want, sizeof(Want), 0, sizeof(Want));
761 ElementName element;
762 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
763 SetElementAbilityName(&element, "MainAbility");
764 SetElementBundleName(&element, "com.openharmony.testnative");
765 SetElementDeviceID(&element, "");
766 SetWantElement(&want, element);
767 AbilityInfo abilityInfo;
768 memset_s(&abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo));
769 g_errorCode = QueryAbilityInfo(&want, &abilityInfo);
770 printf("ret of query is %d \n", g_errorCode);
771 EXPECT_EQ(g_errorCode, 0);
772 if (g_errorCode == 0) {
773 printf("abilityInfo.name is %s \n", abilityInfo.name);
774 }
775 int result = StartAbility(&want);
776 sleep(2);
777 printf("result of startAbility is %d \n", result);
778 EXPECT_EQ(result, 0);
779 printf("element is %s \n", want.element->bundleName);
780 printf("element is %s \n", want.element->abilityName);
781 StopAbility(&want);
782 sleep(1);
783 printf("------end testWantMathBundle------\n");
784 }
785
786 /**
787 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0004
788 * @tc.name : test Want Not Match BundleInfo
789 * @tc.desc : [C- SOFTWARE -0200]
790 */
791 HWTEST_F(AbilityMgrTest, testWantNotMathBundle, Function | MediumTest | Level2)
792 {
793 printf("------start testWantNotMathBundle------\n");
794 Want want;
795 memset_s(&want, sizeof(Want), 0, sizeof(Want));
796 ElementName element;
797 std::string aName = "NoThisAbility";
798 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
799 SetElementAbilityName(&element, aName.c_str());
800 SetElementBundleName(&element, "com.openharmony.nothishap");
801 SetWantElement(&want, element);
802 AbilityInfo abilityInfo;
803 memset_s(&abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo));
804 g_errorCode = QueryAbilityInfo(&want, &abilityInfo);
805 printf("ret is %d \n", g_errorCode);
806 EXPECT_TRUE(g_errorCode != 0);
807 int result = StartAbility(&want);
808 sleep(2);
809 printf("result of startAbility is %d \n", result);
810 EXPECT_TRUE(result == 0);
811 printf("element is %s \n", want.element->bundleName);
812 printf("------end testWantNotMathBundle------\n");
813 }
814
815 /**
816 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0002
817 * @tc.name : testWantOnlyMathBundle
818 * @tc.desc : [C- SOFTWARE -0200]
819 */
820 HWTEST_F(AbilityMgrTest, testWantOnlyMathBundleName, Function | MediumTest | Level1)
821 {
822 printf("------start testWantOnlyMathBundleName------\n");
823 Want want;
824 memset_s(&want, sizeof(Want), 0, sizeof(Want));
825 ElementName element;
826 std::string aName = "Ability";
827 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
828 SetElementAbilityName(&element, aName.c_str());
829 SetElementBundleName(&element, "com.openharmony.testnative");
830 SetWantElement(&want, element);
831 AbilityInfo abilityInfo;
832 memset_s(&abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo));
833 g_errorCode = QueryAbilityInfo(&want, &abilityInfo);
834 printf("ret is %d \n", g_errorCode);
835 EXPECT_TRUE(g_errorCode != 0);
836 int result = StartAbility(&want);
837 sleep(2);
838 printf("result of startAbility is %d \n", result);
839 EXPECT_TRUE(result == 0);
840 printf("element is %s \n", want.element->bundleName);
841 printf("------end testWantOnlyMathBundleName------\n");
842 }
843
844 /**
845 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0003
846 * @tc.name : testWantOnlyMathAbility
847 * @tc.desc : [C- SOFTWARE -0200]
848 */
849 HWTEST_F(AbilityMgrTest, testWantOnlyMathAbility, Function | MediumTest | Level1)
850 {
851 printf("------start testWantOnlyMathAbility------\n");
852 Want want;
853 memset_s(&want, sizeof(Want), 0, sizeof(Want));
854 ElementName element;
855 std::string aName = "MainAbility";
856 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
857 SetElementAbilityName(&element, aName.c_str());
858 SetElementBundleName(&element, "com.openharmony.test");
859 SetWantElement(&want, element);
860 AbilityInfo abilityInfo;
861 memset_s(&abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo));
862 g_errorCode = QueryAbilityInfo(&want, &abilityInfo);
863 printf("ret is %d \n", g_errorCode);
864 EXPECT_TRUE(g_errorCode != 0);
865 int result = StartAbility(&want);
866 sleep(2);
867 printf("result of startAbility is %d \n", result);
868 EXPECT_TRUE(result == 0);
869 printf("element is %s \n", want.element->abilityName);
870 printf("------end testWantOnlyMathAbility------\n");
871 }
872
873 /**
874 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0005
875 * @tc.name : test WantData Match DataLength
876 * @tc.desc : [C- SOFTWARE -0200]
877 */
878 HWTEST_F(AbilityMgrTest, testWantDataMatchLength, Function | MediumTest | Level1)
879 {
880 printf("------start testWantDataMatchLength------\n");
881 Want want;
882 memset_s(&want, sizeof(Want), 0, sizeof(Want));
883 ElementName element;
884 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
885 SetElementAbilityName(&element, "MainAbility");
886 SetElementBundleName(&element, "com.openharmony.testnative");
887 SetWantElement(&want, element);
888 SetWantData(&want, "test", 5);
889 AbilityInfo abilityInfo;
890 memset_s(&abilityInfo, sizeof(AbilityInfo), 0, sizeof(AbilityInfo));
891 g_errorCode = QueryAbilityInfo(&want, &abilityInfo);
892 printf("ret is %d \n", g_errorCode);
893 EXPECT_TRUE(g_errorCode == 0);
894 int result = StartAbility(&want);
895 sleep(2);
896 printf("result of startAbility is %d \n", result);
897 EXPECT_TRUE(result == 0);
898 EXPECT_STREQ((char*)(want.data), "test");
899 EXPECT_EQ(want.dataLength, 5);
900 StopAbility(&want);
901 sleep(1);
902 printf("------end testWantDataMatchLength------\n");
903 }
904
905
906 /**
907 * @tc.number : SUB_APPEXECFWK_AMS_WANT_0006
908 * @tc.name : test WantData Not Match DataLength
909 * @tc.desc : [C- SOFTWARE -0200]
910 */
911 HWTEST_F(AbilityMgrTest, testWantDataNotMatchLength, Function | MediumTest | Level2)
912 {
913 printf("------start testWantDataNotMatchLength------\n");
914 Want want;
915 memset_s(&want, sizeof(Want), 0, sizeof(Want));
916 ElementName element;
917 memset_s(&element, sizeof(ElementName), 0, sizeof(ElementName));
918 SetElementAbilityName(&element, "SecondAbility");
919 SetElementBundleName(&element, "com.openharmony.testnative");
920 SetWantElement(&want, element);
921 SetWantData(&want, "test", 3);
922 int result = StartAbility(&want);
923 sleep(2);
924 printf("result of startAbility is %d \n", result);
925 EXPECT_TRUE(result == 0);
926 EXPECT_EQ(want.dataLength, 3);
927 printf("------end testWantDataNotMatchLength------\n");
928 }
929
930 /**
931 * @tc.number : SUB_APPEXECFWK_AMS_API_0040
932 * @tc.name : PostTask parameter illegal test that callback is null
933 * @tc.desc : [C- SOFTWARE -0200]
934 */
935 HWTEST_F(AbilityMgrTest, testPostTask, Function | MediumTest | Level1)
936 {
937 printf("------start testPostTask------\n");
938 #ifdef __LINUX__
939 string hapPath = g_testPath + "testnative_hispark_taurus_linux.hap";
940 #else
941 string hapPath = g_testPath + "testnative_hispark_taurus_liteos.hap";
942 #endif
943 AbilityEventHandler eventHandler1;
__anon440f19560102null944 auto task = [this, hapPath]{
945 sem_init(&g_sem, 0, 0);
946 InstallParam installParam = { .installLocation = 1, .keepData = false };
947 bool installResult = Install(hapPath.c_str(), &installParam, TestBundleStateCallback);
948 sem_wait(&g_sem);
949 printf("installResult is %d \n", installResult);
950 EXPECT_TRUE(installResult);
951
952 AbilityEventHandler *eventHandler2 = AbilityEventHandler::GetCurrentHandler();
953 eventHandler2->PostQuit();
954 };
955 eventHandler1.PostTask(task);
956 eventHandler1.Run();
957 printf("------end testPostTask------\n");
958 }
959