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 #include <chrono>
16 #include <condition_variable>
17 #include <cstdio>
18 #include <gtest/gtest.h>
19 #include <mutex>
20 #include <set>
21 #include <thread>
22
23 #include "ability_lifecycle_executor.h"
24 #include "ability_manager_errors.h"
25 #include "ability_manager_service.h"
26 #include "ams_data_ability_test_def.h"
27 #include "app_mgr_service.h"
28 #include "common_event.h"
29 #include "common_event_manager.h"
30 #include "event.h"
31 #include "hilog_wrapper.h"
32 #include "module_test_dump_util.h"
33 #include "sa_mgr_client.h"
34 #include "semaphore_ex.h"
35 #include "stoperator.h"
36 #include "system_ability_definition.h"
37 #include "st_ability_util.h"
38 #include "uri.h"
39
40 namespace {
41 using namespace testing::ext;
42 using namespace OHOS;
43 using namespace OHOS::AAFwk;
44 using namespace OHOS::AppExecFwk;
45 using namespace OHOS::MTUtil;
46 using namespace OHOS::EventFwk;
47 using Uri = OHOS::Uri;
48 using namespace OHOS::STtools;
49 using namespace OHOS::STABUtil;
50
51 using MAP_STR_STR = std::map<std::string, std::string>;
52 using VECTOR_STR = std::vector<std::string>;
53 namespace {
54 static const std::string BUNDLE_NAME_BASE = "com.ohos.amsst.AppData";
55 static const std::string ABILITY_NAME_BASE = "AmsStDataAbility";
56 static const std::string HAP_NAME_BASE = "amsDataSystemTest";
57 static const int ABILITY_CODE_BASE = 100;
58 }
59
PublishEvent(const std::string & eventName,const int & code,const std::string & data)60 bool PublishEvent(const std::string &eventName, const int &code, const std::string &data)
61 {
62 Want want;
63 want.SetAction(eventName);
64 CommonEventData commonData;
65 commonData.SetWant(want);
66 commonData.SetCode(code);
67 commonData.SetData(data);
68 return CommonEventManager::PublishCommonEvent(commonData);
69 }
70
71 class AmsDataAbilityTest : public testing::Test {
72 public:
73 static void SetUpTestCase(void);
74 static void TearDownTestCase(void);
75 void SetUp();
76 void TearDown();
77
78 void ResetSystem() const;
79 static bool SubscribeEvent();
80 void ReInstallBundle() const;
81 void UnInstallBundle() const;
82 static sptr<IAppMgr> appMgrService;
83 static sptr<IAbilityManager> abilityMgrService;
84 static int TestWaitCompleted(Event &event, const std::string &eventName, const int code, const int timeout = 10);
85 static void TestCompleted(Event &event, const std::string &eventName, const int code);
86
87 static STtools::Event event;
88
89 class AppEventSubscriber : public CommonEventSubscriber {
90 public:
AppEventSubscriber(const CommonEventSubscribeInfo & sp)91 explicit AppEventSubscriber(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp)
92 {
93 PageAbilityState_ = {
94 {"onStart", AbilityLifecycleExecutor::LifecycleState::INACTIVE},
95 {"OnStop", AbilityLifecycleExecutor::LifecycleState::INITIAL},
96 {"OnActive", AbilityLifecycleExecutor::LifecycleState::ACTIVE},
97 {"OnInactive", AbilityLifecycleExecutor::LifecycleState::INACTIVE},
98 {"OnBackground", AbilityLifecycleExecutor::LifecycleState::BACKGROUND},
99 };
100 DataAbilityState_ = {
101 {"OnStart"},
102 {"Insert"},
103 {"Delete"},
104 {"Update"},
105 {"Query"},
106 {"GetFileTypes"},
107 {"OpenFile"},
108 {"Default"},
109 };
110 AbilityOperator_ = {
111 {"Insert"},
112 {"Delete"},
113 {"Update"},
114 {"Query"},
115 {"GetFileTypes"},
116 {"OpenFile"},
117 };
118 };
~AppEventSubscriber()119 ~AppEventSubscriber()
120 {
121 PageAbilityState_ = {};
122 DataAbilityState_ = {};
123 };
124 virtual void OnReceiveEvent(const CommonEventData &data) override;
125 std::unordered_map<std::string, int> PageAbilityState_;
126 std::set<std::string> DataAbilityState_;
127 std::set<std::string> AbilityOperator_;
128 };
129 };
130
131 STtools::Event AmsDataAbilityTest::event = STtools::Event();
132
OnReceiveEvent(const CommonEventData & data)133 void AmsDataAbilityTest::AppEventSubscriber::OnReceiveEvent(const CommonEventData &data)
134 {
135 GTEST_LOG_(INFO) << "OnReceiveEvent: event=" << data.GetWant().GetAction();
136 GTEST_LOG_(INFO) << "OnReceiveEvent: data=" << data.GetData();
137 GTEST_LOG_(INFO) << "OnReceiveEvent: code=" << data.GetCode();
138
139 std::string eventName = data.GetWant().GetAction();
140 if (eventName.compare(ABILITY_EVENT_NAME) == 0) {
141 std::string target = data.GetData();
142 if (target.find(" ") != target.npos) {
143 AmsDataAbilityTest::TestCompleted(event, target, data.GetCode());
144 return;
145 }
146
147 if (PAGE_ABILITY_CODE == data.GetCode() / ABILITY_CODE_BASE) { // page ability
148 EXPECT_TRUE(PageAbilityState_.find(target) != PageAbilityState_.end());
149 AmsDataAbilityTest::TestCompleted(event, target, data.GetCode());
150 return;
151 } else if (DATA_ABILITY_CODE == data.GetCode() / ABILITY_CODE_BASE) { // data ability
152 std::string target = data.GetData();
153 EXPECT_TRUE(DataAbilityState_.find(target) != DataAbilityState_.end());
154 AmsDataAbilityTest::TestCompleted(event, target, data.GetCode());
155 return;
156 }
157 }
158 }
159
SetUpTestCase(void)160 void AmsDataAbilityTest::SetUpTestCase(void)
161 {
162 if (!SubscribeEvent()) {
163 GTEST_LOG_(INFO) << "SubscribeEvent error";
164 }
165 }
166
TearDownTestCase(void)167 void AmsDataAbilityTest::TearDownTestCase(void)
168 {}
169
SetUp(void)170 void AmsDataAbilityTest::SetUp(void)
171 {
172 ReInstallBundle();
173 STAbilityUtil::CleanMsg(event);
174 ResetSystem();
175
176 abilityMgrService = STAbilityUtil::GetAbilityManagerService();
177 appMgrService = STAbilityUtil::GetAppMgrService();
178 }
179
TearDown(void)180 void AmsDataAbilityTest::TearDown(void)
181 {
182 UnInstallBundle();
183 STAbilityUtil::CleanMsg(event);
184 }
185
SubscribeEvent()186 bool AmsDataAbilityTest::SubscribeEvent()
187 {
188 std::vector<std::string> eventList = {"event_data_ability_callback"};
189 MatchingSkills matchingSkills;
190 for (const auto &e : eventList) {
191 matchingSkills.AddEvent(e);
192 }
193 CommonEventSubscribeInfo subscribeInfo(matchingSkills);
194 subscribeInfo.SetPriority(1);
195 auto subscriber = std::make_shared<AppEventSubscriber>(subscribeInfo);
196 return CommonEventManager::SubscribeCommonEvent(subscriber);
197 }
198
ReInstallBundle() const199 void AmsDataAbilityTest::ReInstallBundle() const
200 {
201 std::vector<std::string> bundleNameSuffix = {"A", "B", "C"};
202 for (std::string suffix : bundleNameSuffix) {
203 STAbilityUtil::Install(HAP_NAME_BASE + suffix);
204 }
205 }
206
UnInstallBundle() const207 void AmsDataAbilityTest::UnInstallBundle() const
208 {
209 std::vector<std::string> bundleNameSuffix = {"A", "B", "C"};
210 for (std::string suffix : bundleNameSuffix) {
211 STAbilityUtil::Uninstall(BUNDLE_NAME_BASE + suffix);
212 }
213 }
214
215 sptr<IAppMgr> AmsDataAbilityTest::appMgrService = nullptr;
216 sptr<IAbilityManager> AmsDataAbilityTest::abilityMgrService = nullptr;
217
ResetSystem() const218 void AmsDataAbilityTest::ResetSystem() const
219 {
220 GTEST_LOG_(INFO) << "ResetSystem";
221 }
222
TestWaitCompleted(Event & event,const std::string & eventName,const int code,const int timeout)223 int AmsDataAbilityTest::TestWaitCompleted(Event &event, const std::string &eventName, const int code, const int timeout)
224 {
225 GTEST_LOG_(INFO) << "TestWaitCompleted : " << eventName << " " << code;
226 return STAbilityUtil::WaitCompleted(event, eventName, code, timeout);
227 }
228
TestCompleted(Event & event,const std::string & eventName,const int code)229 void AmsDataAbilityTest::TestCompleted(Event &event, const std::string &eventName, const int code)
230 {
231 GTEST_LOG_(INFO) << "TestCompleted : " << eventName << " " << code;
232 return STAbilityUtil::Completed(event, eventName, code);
233 }
234
235 /**
236 * @tc.number : AMS_Data_Ability_00100
237 * @tc.name : data ability ST 001
238 * @tc.desc : start InsertOperator of data ability by page ability in the same app.
239 */
240 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_00100, Function | MediumTest | Level1)
241 {
242 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00100 start";
243 STAbilityUtil::CleanMsg(event);
244
245 std::string bundleName = BUNDLE_NAME_BASE + "A";
246 std::string abilityName = ABILITY_NAME_BASE + "PageA";
247
248 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
249 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
250 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "A", ABILITY_NAME_BASE + "DataA", OPERATOR_INSERT);
251 first->AddChildOperator(second);
252 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
253
254 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
255
256 GTEST_LOG_(INFO) << "StartAbility start";
257 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
258 GTEST_LOG_(INFO) << eCode;
259 GTEST_LOG_(INFO) << "StartAbility done";
260 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
261 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
262 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
263
264 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_A_CODE), 0);
265 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_INSERT, ABILITY_DATA_A_CODE), 0);
266 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_INSERT + " " + DEFAULT_INSERT_RESULT, ABILITY_PAGE_A_CODE), 0);
267
268 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00100 end";
269 }
270
271 /**
272 * @tc.number : AMS_Data_Ability_00200
273 * @tc.name : data ability ST 002
274 * @tc.desc : start DeleteOperator of data ability by page ability in the same app.
275 */
276 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_00200, Function | MediumTest | Level1)
277 {
278 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00200 start";
279 STAbilityUtil::CleanMsg(event);
280
281 std::string bundleName = BUNDLE_NAME_BASE + "A";
282 std::string abilityName = ABILITY_NAME_BASE + "PageA";
283 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
284 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
285 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "A", ABILITY_NAME_BASE + "DataA", OPERATOR_DELETE);
286 first->AddChildOperator(second);
287 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
288
289 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
290
291 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
292 GTEST_LOG_(INFO) << eCode;
293 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
294 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
295 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
296
297 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_A_CODE), 0);
298 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_DELETE, ABILITY_DATA_A_CODE), 0);
299 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_DELETE + " " + DEFAULT_DELETE_RESULT, ABILITY_PAGE_A_CODE), 0);
300
301 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00200 end";
302 }
303
304 /**
305 * @tc.number : AMS_Data_Ability_00300
306 * @tc.name : data ability ST 003
307 * @tc.desc : start UpdateOperator of data ability by page ability in the same app.
308 */
309 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_00300, Function | MediumTest | Level1)
310 {
311 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00300 start";
312 STAbilityUtil::CleanMsg(event);
313
314 std::string bundleName = BUNDLE_NAME_BASE + "A";
315 std::string abilityName = ABILITY_NAME_BASE + "PageA";
316 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
317 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
318 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "A", ABILITY_NAME_BASE + "DataA", OPERATOR_UPDATE);
319 first->AddChildOperator(second);
320 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
321
322 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
323
324 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
325 GTEST_LOG_(INFO) << eCode;
326 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
327 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
328 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
329
330 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_A_CODE), 0);
331 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_UPDATE, ABILITY_DATA_A_CODE), 0);
332 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_UPDATE + " " + DEFAULT_UPDATE_RESULT, ABILITY_PAGE_A_CODE), 0);
333
334 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00300 end";
335 }
336
337 /**
338 * @tc.number : AMS_Data_Ability_00400
339 * @tc.name : data ability ST 004
340 * @tc.desc : start OpenFileOperator of data ability by page ability in the same app.
341 */
342 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_00400, Function | MediumTest | Level1)
343 {
344 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00400 start";
345 STAbilityUtil::CleanMsg(event);
346
347 std::string bundleName = BUNDLE_NAME_BASE + "A";
348 std::string abilityName = ABILITY_NAME_BASE + "PageA";
349 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
350 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
351 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "A", ABILITY_NAME_BASE + "DataA", OPERATOR_OPENFILE);
352 first->AddChildOperator(second);
353 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
354
355 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
356
357 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
358 GTEST_LOG_(INFO) << eCode;
359 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
360 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
361 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
362
363 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_A_CODE), 0);
364 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_OPENFILE, ABILITY_DATA_A_CODE), 0);
365 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_OPENFILE + " " + DEFAULT_OPENFILE_RESULT, ABILITY_PAGE_A_CODE), 0);
366
367 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00400 end";
368 }
369
370 /**
371 * @tc.number : AMS_Data_Ability_00500
372 * @tc.name : data ability ST 005
373 * @tc.desc : start GetFileTypesOperator of data ability by page ability in the same app.
374 */
375 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_00500, Function | MediumTest | Level1)
376 {
377 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00500 start";
378 STAbilityUtil::CleanMsg(event);
379
380 std::string bundleName = BUNDLE_NAME_BASE + "A";
381 std::string abilityName = ABILITY_NAME_BASE + "PageA";
382 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
383 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
384 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "A", ABILITY_NAME_BASE + "DataA", OPERATOR_GETFILETYPES);
385 first->AddChildOperator(second);
386 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
387
388 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
389
390 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
391 GTEST_LOG_(INFO) << eCode;
392 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
393 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
394 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
395
396 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_A_CODE), 0);
397 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_GETFILETYPES, ABILITY_DATA_A_CODE), 0);
398 EXPECT_EQ(
399 TestWaitCompleted(event, OPERATOR_GETFILETYPES + " " + DEFAULT_GETFILETYPE_RESULT, ABILITY_PAGE_A_CODE), 0);
400
401 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00500 end";
402 }
403
404 /**
405 * @tc.number : AMS_Data_Ability_00600
406 * @tc.name : data ability ST 006
407 * @tc.desc : start QueryOperator of data ability by page ability in the same app.
408 */
409 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_00600, Function | MediumTest | Level1)
410 {
411 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00600 start";
412 STAbilityUtil::CleanMsg(event);
413
414 std::string bundleName = BUNDLE_NAME_BASE + "A";
415 std::string abilityName = ABILITY_NAME_BASE + "PageA";
416 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
417 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
418 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "A", ABILITY_NAME_BASE + "DataA", OPERATOR_QUERY);
419 first->AddChildOperator(second);
420 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
421
422 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
423
424 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
425 GTEST_LOG_(INFO) << eCode;
426 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
427 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
428 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
429
430 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_A_CODE), 0);
431 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY, ABILITY_DATA_A_CODE), 0);
432 PublishEvent(TEST_EVENT_NAME, ABILITY_DATA_A_CODE, OPERATOR_QUERY);
433
434 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_QUERY + " " + DEFAULT_QUERY_RESULT, ABILITY_PAGE_A_CODE), 0);
435
436 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00600 end";
437 }
438
439 /**
440 * @tc.number : AMS_Data_Ability_00700
441 * @tc.name : data ability ST 007
442 * @tc.desc : start InsertOperator of data ability by page ability in different app.
443 */
444 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_00700, Function | MediumTest | Level1)
445 {
446 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00700 start";
447 STAbilityUtil::CleanMsg(event);
448
449 std::string bundleName = BUNDLE_NAME_BASE + "A";
450 std::string abilityName = ABILITY_NAME_BASE + "PageA";
451 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
452 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
453 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_INSERT);
454 first->AddChildOperator(second);
455 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
456
457 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
458
459 GTEST_LOG_(INFO) << "StartAbility start";
460 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
461 GTEST_LOG_(INFO) << eCode;
462 GTEST_LOG_(INFO) << "StartAbility done";
463 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
464 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
465 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
466
467 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C1_CODE), 0);
468 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_INSERT, ABILITY_DATA_C1_CODE), 0);
469 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_INSERT + " " + DEFAULT_INSERT_RESULT, ABILITY_PAGE_A_CODE), 0);
470
471 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00700 end";
472 }
473
474 /**
475 * @tc.number : AMS_Data_Ability_00800
476 * @tc.name : data ability ST 008
477 * @tc.desc : start DeleteOperator of data ability by page ability in different app.
478 */
479 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_00800, Function | MediumTest | Level1)
480 {
481 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00800 start";
482 STAbilityUtil::CleanMsg(event);
483
484 std::string bundleName = BUNDLE_NAME_BASE + "A";
485 std::string abilityName = ABILITY_NAME_BASE + "PageA";
486 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
487 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
488 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_DELETE);
489 first->AddChildOperator(second);
490 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
491
492 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
493
494 GTEST_LOG_(INFO) << "StartAbility start";
495 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
496 GTEST_LOG_(INFO) << eCode;
497 GTEST_LOG_(INFO) << "StartAbility done";
498 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
499 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
500 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
501
502 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C1_CODE), 0);
503 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_DELETE, ABILITY_DATA_C1_CODE), 0);
504 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_DELETE + " " + DEFAULT_DELETE_RESULT, ABILITY_PAGE_A_CODE), 0);
505
506 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00800 end";
507 }
508
509 /**
510 * @tc.number : AMS_Data_Ability_00900
511 * @tc.name : data ability ST 009
512 * @tc.desc : start UpdateOperator of data ability by page ability in different app.
513 */
514 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_00900, Function | MediumTest | Level1)
515 {
516 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00900 start";
517 STAbilityUtil::CleanMsg(event);
518
519 std::string bundleName = BUNDLE_NAME_BASE + "A";
520 std::string abilityName = ABILITY_NAME_BASE + "PageA";
521 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
522 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
523 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_UPDATE);
524 first->AddChildOperator(second);
525 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
526
527 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
528
529 GTEST_LOG_(INFO) << "StartAbility start";
530 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
531 GTEST_LOG_(INFO) << eCode;
532 GTEST_LOG_(INFO) << "StartAbility done";
533 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
534 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
535 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
536
537 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C1_CODE), 0);
538 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_UPDATE, ABILITY_DATA_C1_CODE), 0);
539 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_UPDATE + " " + DEFAULT_UPDATE_RESULT, ABILITY_PAGE_A_CODE), 0);
540
541 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_00900 end";
542 }
543
544 /**
545 * @tc.number : AMS_Data_Ability_01000
546 * @tc.name : data ability ST 010
547 * @tc.desc : start OpenFileOperator of data ability by page ability in different app.
548 */
549 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_01000, Function | MediumTest | Level1)
550 {
551 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01000 start";
552 STAbilityUtil::CleanMsg(event);
553
554 std::string bundleName = BUNDLE_NAME_BASE + "A";
555 std::string abilityName = ABILITY_NAME_BASE + "PageA";
556 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
557 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
558 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_OPENFILE);
559 first->AddChildOperator(second);
560 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
561
562 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
563
564 GTEST_LOG_(INFO) << "StartAbility start";
565 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
566 GTEST_LOG_(INFO) << eCode;
567 GTEST_LOG_(INFO) << "StartAbility done";
568 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
569 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
570 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
571
572 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C1_CODE), 0);
573 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_OPENFILE, ABILITY_DATA_C1_CODE), 0);
574 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_OPENFILE + " " + DEFAULT_OPENFILE_RESULT, ABILITY_PAGE_A_CODE), 0);
575
576 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01000 end";
577 }
578
579 /**
580 * @tc.number : AMS_Data_Ability_01100
581 * @tc.name : data ability ST 011
582 * @tc.desc : start GetFileTypesOperator of data ability by page ability in different app.
583 */
584 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_01100, Function | MediumTest | Level1)
585 {
586 using namespace STtools;
587 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01100 start";
588 STAbilityUtil::CleanMsg(event);
589
590 std::string bundleName = BUNDLE_NAME_BASE + "A";
591 std::string abilityName = ABILITY_NAME_BASE + "PageA";
592 std::shared_ptr<StOperator> first =
593 std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName, OPERATOR_DEFAULT);
594 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
595 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_GETFILETYPES);
596 first->AddChildOperator(second);
597 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
598
599 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
600
601 GTEST_LOG_(INFO) << "StartAbility start";
602 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
603 GTEST_LOG_(INFO) << eCode;
604 GTEST_LOG_(INFO) << "StartAbility done";
605 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
606 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
607 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
608
609 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C1_CODE), 0);
610 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_GETFILETYPES, ABILITY_DATA_C1_CODE), 0);
611
612 EXPECT_EQ(
613 TestWaitCompleted(event, OPERATOR_GETFILETYPES + " " + DEFAULT_GETFILETYPE_RESULT, ABILITY_PAGE_A_CODE), 0);
614
615 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01100 end";
616 }
617
618 /**
619 * @tc.number : AMS_Data_Ability_01200
620 * @tc.name : data ability ST 012
621 * @tc.desc : start QueryOperator of data ability by page ability in different app.
622 */
623 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_01200, Function | MediumTest | Level1)
624 {
625 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01200 start";
626 STAbilityUtil::CleanMsg(event);
627
628 std::string bundleName = BUNDLE_NAME_BASE + "A";
629 std::string abilityName = ABILITY_NAME_BASE + "PageA";
630 std::shared_ptr<StOperator> first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName);
631 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
632 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_QUERY);
633 first->AddChildOperator(second);
634 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
635
636 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
637
638 GTEST_LOG_(INFO) << "StartAbility start";
639 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
640 GTEST_LOG_(INFO) << eCode;
641 GTEST_LOG_(INFO) << "StartAbility done";
642 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
643 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
644 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
645
646 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C1_CODE), 0);
647 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY, ABILITY_DATA_C1_CODE), 0);
648 PublishEvent(TEST_EVENT_NAME, ABILITY_DATA_C1_CODE, OPERATOR_QUERY);
649
650 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_QUERY + " " + OPERATOR_QUERY, ABILITY_PAGE_A_CODE), 0);
651
652 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01200 end";
653 }
654
655 /**
656 * @tc.number : AMS_Data_Ability_01300
657 * @tc.name : data ability ST 013
658 * @tc.desc : start InsertOperator of data ability by data ability in the same app.
659 */
660 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_01300, Function | MediumTest | Level1)
661 {
662 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01300 start";
663 STAbilityUtil::CleanMsg(event);
664
665 std::string bundleName = BUNDLE_NAME_BASE + "A";
666 std::string abilityName = ABILITY_NAME_BASE + "PageA";
667 std::shared_ptr<StOperator> first =
668 std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName, OPERATOR_DEFAULT);
669 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
670 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_QUERY);
671 std::shared_ptr<StOperator> third = std::make_shared<StOperator>(
672 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC2", OPERATOR_QUERY);
673 first->AddChildOperator(second);
674 second->AddChildOperator(third);
675 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
676
677 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
678
679 GTEST_LOG_(INFO) << "StartAbility start";
680 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
681 GTEST_LOG_(INFO) << eCode;
682 GTEST_LOG_(INFO) << "StartAbility done";
683 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
684 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
685 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
686
687 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C1_CODE), 0);
688 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY, ABILITY_DATA_C1_CODE), 0);
689 PublishEvent(TEST_EVENT_NAME, ABILITY_DATA_C1_CODE, DATA_STATE_QUERY);
690
691 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C2_CODE), 0);
692 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY, ABILITY_DATA_C2_CODE), 0);
693 PublishEvent(TEST_EVENT_NAME, ABILITY_DATA_C2_CODE, DATA_STATE_QUERY);
694 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_QUERY + " " + DEFAULT_QUERY_RESULT, ABILITY_DATA_C1_CODE), 0);
695
696 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_QUERY + " " + DEFAULT_QUERY_RESULT, ABILITY_PAGE_A_CODE), 0);
697
698 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01300 end";
699 }
700
701 /**
702 * @tc.number : AMS_Data_Ability_01400
703 * @tc.name : data ability ST 014
704 * @tc.desc : start InsertOperator of data ability by data ability in different app.
705 */
706 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_01400, Function | MediumTest | Level1)
707 {
708 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01400 start";
709 STAbilityUtil::CleanMsg(event);
710
711 std::string bundleName = BUNDLE_NAME_BASE + "A";
712 std::string abilityName = ABILITY_NAME_BASE + "PageA";
713 std::shared_ptr<StOperator> first =
714 std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName, OPERATOR_DEFAULT);
715 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
716 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "A", ABILITY_NAME_BASE + "DataA", OPERATOR_QUERY);
717 std::shared_ptr<StOperator> third = std::make_shared<StOperator>(
718 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "B", ABILITY_NAME_BASE + "DataB", OPERATOR_INSERT);
719 first->AddChildOperator(second);
720 second->AddChildOperator(third);
721 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
722
723 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
724
725 GTEST_LOG_(INFO) << "StartAbility start";
726 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
727 GTEST_LOG_(INFO) << eCode;
728 GTEST_LOG_(INFO) << "StartAbility done";
729 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
730 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
731 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
732
733 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_A_CODE), 0);
734 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY, ABILITY_DATA_A_CODE), 0);
735 PublishEvent(TEST_EVENT_NAME, ABILITY_DATA_A_CODE, DATA_STATE_QUERY);
736
737 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_B_CODE), 0);
738 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_INSERT, ABILITY_DATA_B_CODE), 0);
739
740 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_INSERT + " " + DEFAULT_INSERT_RESULT, ABILITY_DATA_A_CODE), 0);
741
742 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_QUERY + " " + DEFAULT_QUERY_RESULT, ABILITY_PAGE_A_CODE), 0);
743
744 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01400 end";
745 }
746
747 /**
748 * @tc.number : AMS_Data_Ability_01500
749 * @tc.name : data ability ST 015
750 * @tc.desc : start InsertOperator of data ability by the same data ability.
751 */
752 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_01500, Function | MediumTest | Level1)
753 {
754 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01500 start";
755 STAbilityUtil::CleanMsg(event);
756
757 std::string bundleName = BUNDLE_NAME_BASE + "A";
758 std::string abilityName = ABILITY_NAME_BASE + "PageA";
759 std::shared_ptr<StOperator> first =
760 std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName, OPERATOR_DEFAULT);
761 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
762 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_QUERY);
763 std::shared_ptr<StOperator> third = std::make_shared<StOperator>(
764 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_INSERT);
765 first->AddChildOperator(second);
766 second->AddChildOperator(third);
767 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
768
769 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
770
771 GTEST_LOG_(INFO) << "StartAbility start";
772 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
773 GTEST_LOG_(INFO) << eCode;
774 GTEST_LOG_(INFO) << "StartAbility done";
775 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
776 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
777 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
778
779 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C1_CODE), 0);
780 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY, ABILITY_DATA_C1_CODE), 0);
781 PublishEvent(TEST_EVENT_NAME, ABILITY_DATA_C1_CODE, DATA_STATE_QUERY);
782
783 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_INSERT, ABILITY_DATA_C1_CODE), 0);
784 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_INSERT + " " + DEFAULT_INSERT_RESULT, ABILITY_DATA_C1_CODE), 0);
785
786 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_QUERY + " " + DEFAULT_QUERY_RESULT, ABILITY_PAGE_A_CODE), 0);
787
788 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01500 end";
789 }
790
791 /**
792 * @tc.number : AMS_Data_Ability_01600
793 * @tc.name : data ability ST 016
794 * @tc.desc : start InsertOperator of data ability by two page ability in different app.
795 */
796 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_016, Function | MediumTest | Level1)
797 {
798 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01600 start";
799 STAbilityUtil::CleanMsg(event);
800
801 std::string bundleName = BUNDLE_NAME_BASE + "A";
802 std::string abilityName = ABILITY_NAME_BASE + "PageA";
803 std::shared_ptr<StOperator> first =
804 std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName, OPERATOR_DEFAULT);
805 std::shared_ptr<StOperator> second = std::make_shared<StOperator>(
806 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC2", OPERATOR_INSERT);
807 first->AddChildOperator(second);
808 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
809
810 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
811 GTEST_LOG_(INFO) << "StartAbility1 start";
812 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
813 GTEST_LOG_(INFO) << eCode;
814 GTEST_LOG_(INFO) << "StartAbility1 done";
815
816 bundleName = BUNDLE_NAME_BASE + "B";
817 abilityName = ABILITY_NAME_BASE + "PageB";
818 first = std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName, OPERATOR_DEFAULT);
819 second = std::make_shared<StOperator>(
820 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC2", OPERATOR_INSERT);
821 first->AddChildOperator(second);
822 vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
823
824 want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
825 GTEST_LOG_(INFO) << "StartAbility2 start";
826 eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
827 GTEST_LOG_(INFO) << eCode;
828 GTEST_LOG_(INFO) << "StartAbility2 done";
829
830 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
831 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
832 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
833
834 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C2_CODE), 0);
835 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_INSERT, ABILITY_DATA_C2_CODE), 0);
836 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_INSERT + " " + DEFAULT_INSERT_RESULT, ABILITY_PAGE_A_CODE), 0);
837
838 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_B_CODE), 0);
839 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_B_CODE), 0);
840 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_B_CODE, PAGE_STATE_ONACTIVE);
841
842 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_INSERT, ABILITY_DATA_C2_CODE), 0);
843 EXPECT_EQ(TestWaitCompleted(event, OPERATOR_INSERT + " " + DEFAULT_INSERT_RESULT, ABILITY_PAGE_B_CODE), 0);
844
845 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01600 end";
846 }
847
848 /**
849 * @tc.number : AMS_Data_Ability_01700
850 * @tc.name : data ability ST 017
851 * @tc.desc : start some data ability by some page ability and data ability.
852 */
853 HWTEST_F(AmsDataAbilityTest, AMS_Data_Ability_01700, Function | MediumTest | Level1)
854 {
855 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01700 start";
856 STAbilityUtil::CleanMsg(event);
857
858 std::string bundleName = BUNDLE_NAME_BASE + "A";
859 std::string abilityName = ABILITY_NAME_BASE + "PageA";
860 std::shared_ptr<StOperator> first =
861 std::make_shared<StOperator>(ABILITY_TYPE_PAGE, bundleName, abilityName, OPERATOR_DEFAULT);
862 std::shared_ptr<StOperator> second1 = std::make_shared<StOperator>(
863 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_INSERT);
864 std::shared_ptr<StOperator> second2 = std::make_shared<StOperator>(
865 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "B", ABILITY_NAME_BASE + "DataB", OPERATOR_QUERY);
866 std::shared_ptr<StOperator> third1 = std::make_shared<StOperator>(
867 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_DELETE);
868 std::shared_ptr<StOperator> second3 = std::make_shared<StOperator>(
869 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC2", OPERATOR_INSERT);
870 std::shared_ptr<StOperator> second4 = std::make_shared<StOperator>(
871 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "A", ABILITY_NAME_BASE + "DataA", OPERATOR_QUERY);
872 std::shared_ptr<StOperator> third2 = std::make_shared<StOperator>(
873 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC1", OPERATOR_QUERY);
874 std::shared_ptr<StOperator> four = std::make_shared<StOperator>(
875 ABILITY_TYPE_DATA, BUNDLE_NAME_BASE + "C", ABILITY_NAME_BASE + "DataC2", OPERATOR_DELETE);
876 first->AddChildOperator(second1);
877 first->AddChildOperator(second2);
878 second2->AddChildOperator(third1);
879 first->AddChildOperator(second3);
880 first->AddChildOperator(second4);
881 second4->AddChildOperator(third2);
882 third2->AddChildOperator(four);
883
884 std::vector<string> vectorOperator = STAbilityUtil::SerializationStOperatorToVector(*first);
885
886 Want want = STAbilityUtil::MakeWant(DEVICE_ID, abilityName, bundleName, vectorOperator);
887
888 GTEST_LOG_(INFO) << "StartAbility start";
889 ErrCode eCode = STAbilityUtil::StartAbility(want, abilityMgrService);
890 GTEST_LOG_(INFO) << eCode;
891 GTEST_LOG_(INFO) << "StartAbility done";
892 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONSTART, ABILITY_PAGE_A_CODE), 0);
893 EXPECT_EQ(TestWaitCompleted(event, PAGE_STATE_ONACTIVE, ABILITY_PAGE_A_CODE), 0);
894 PublishEvent(TEST_EVENT_NAME, ABILITY_PAGE_A_CODE, PAGE_STATE_ONACTIVE);
895 // second1
896 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C1_CODE), 0);
897 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_INSERT, ABILITY_DATA_C1_CODE), 0);
898
899 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_INSERT + " " + DEFAULT_INSERT_RESULT, ABILITY_PAGE_A_CODE), 0);
900
901 // second2
902 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_B_CODE), 0);
903 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY, ABILITY_DATA_B_CODE), 0);
904 PublishEvent(TEST_EVENT_NAME, ABILITY_DATA_B_CODE, DATA_STATE_QUERY);
905 // third1
906 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_DELETE, ABILITY_DATA_C1_CODE), 0);
907
908 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_DELETE + " " + DEFAULT_DELETE_RESULT, ABILITY_DATA_B_CODE), 0);
909 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY + " " + DEFAULT_QUERY_RESULT, ABILITY_PAGE_A_CODE), 0);
910
911 // second3
912 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_C2_CODE), 0);
913 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_INSERT, ABILITY_DATA_C2_CODE), 0);
914
915 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_INSERT + " " + DEFAULT_INSERT_RESULT, ABILITY_PAGE_A_CODE), 0);
916
917 // second4
918 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_ONSTART, ABILITY_DATA_A_CODE), 0);
919 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY, ABILITY_DATA_A_CODE), 0);
920 PublishEvent(TEST_EVENT_NAME, ABILITY_DATA_A_CODE, DATA_STATE_QUERY);
921 // third2
922 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY, ABILITY_DATA_C1_CODE), 0);
923 PublishEvent(TEST_EVENT_NAME, ABILITY_DATA_C1_CODE, DATA_STATE_QUERY);
924 // four
925 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_DELETE, ABILITY_DATA_C2_CODE), 0);
926
927 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_DELETE + " " + DEFAULT_DELETE_RESULT, ABILITY_DATA_C1_CODE), 0);
928 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY + " " + DEFAULT_QUERY_RESULT, ABILITY_DATA_A_CODE), 0);
929 EXPECT_EQ(TestWaitCompleted(event, DATA_STATE_QUERY + " " + DEFAULT_QUERY_RESULT, ABILITY_PAGE_A_CODE), 0);
930
931 GTEST_LOG_(INFO) << "AmsDataAbilityTest AMS_Data_Ability_01700 end";
932 }
933 } // namespace