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 <gtest/gtest.h>
17
18 #include "ability.h"
19 #include "ability_impl.h"
20 #include "ability_state.h"
21 #include "abs_shared_result_set.h"
22 #include "hilog_wrapper.h"
23 #include "context_deal.h"
24 #include "continuation_manager.h"
25 #include "continuation_handler.h"
26 #include "data_ability_predicates.h"
27 #include "mock_ability_impl.h"
28 #include "mock_ability_lifecycle_callbacks.h"
29 #include "mock_ability_token.h"
30 #include "mock_continuation_ability.h"
31 #include "ohos_application.h"
32 #include "page_ability_impl.h"
33 #include "values_bucket.h"
34
35 namespace OHOS {
36 namespace AppExecFwk {
37 using namespace testing::ext;
38 using namespace OHOS;
39 using namespace OHOS::AppExecFwk;
40
41 class ContinuationTest : public testing::Test {
42 public:
ContinuationTest()43 ContinuationTest() : continuationManager_(nullptr), ability_(nullptr), abilityInfo_(nullptr),
44 continueToken_(nullptr)
45 {}
~ContinuationTest()46 ~ContinuationTest()
47 {}
48 std::shared_ptr<ContinuationManager> continuationManager_;
49 std::shared_ptr<Ability> ability_;
50 std::shared_ptr<AbilityInfo> abilityInfo_;
51 sptr<IRemoteObject> continueToken_;
52
53 static void SetUpTestCase(void);
54 static void TearDownTestCase(void);
55 void SetUp();
56 void TearDown();
57 };
58
SetUpTestCase(void)59 void ContinuationTest::SetUpTestCase(void)
60 {}
61
TearDownTestCase(void)62 void ContinuationTest::TearDownTestCase(void)
63 {}
64
SetUp(void)65 void ContinuationTest::SetUp(void)
66 {
67 continuationManager_ = std::make_shared<ContinuationManager>();
68 continueToken_ = sptr<IRemoteObject>(new (std::nothrow)MockAbilityToken());
69 abilityInfo_ = std::make_shared<AbilityInfo>();
70 abilityInfo_->name = "ability";
71 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
72 std::shared_ptr<EventRunner> eventRunner = EventRunner::Create(abilityInfo_->name);
73 sptr<AbilityThread> abilityThread = sptr<AbilityThread>(new (std::nothrow)AbilityThread());
74 std::shared_ptr<AbilityHandler> handler = std::make_shared<AbilityHandler>(eventRunner, abilityThread);
75 ability_ = std::make_shared<MockContinuationAbility>();
76 ability_->Init(abilityInfo_, application, handler, continueToken_);
77 }
78
TearDown(void)79 void ContinuationTest::TearDown(void)
80 {}
81
82 /*
83 * @tc.name: continue_manager_init_001
84 * @tc.desc: init ContinuationManager with illegal ability
85 * @tc.type: FUNC
86 * @tc.require: AR000GI8IP
87 */
88 HWTEST_F(ContinuationTest, continue_manager_init_001, TestSize.Level1)
89 {
90 GTEST_LOG_(INFO) << "continue_manager_init_001 start";
91
92 std::weak_ptr<ContinuationManager> continuationManager = continuationManager_;
93 std::weak_ptr<Ability> abilityTmp = ability_;
94 std::shared_ptr<ContinuationHandler> continuationHandler =
95 std::make_shared<ContinuationHandler>(continuationManager, abilityTmp);
96 std::shared_ptr<Ability> ability = nullptr;
97 bool result = continuationManager_->Init(ability, continueToken_, abilityInfo_, continuationHandler);
98 EXPECT_FALSE(result);
99 GTEST_LOG_(INFO) << "continue_manager_init_001 end";
100 }
101
102 /*
103 * @tc.name: continue_manager_init_002
104 * @tc.desc: init ContinuationManager with illegal continueToken
105 * @tc.type: FUNC
106 * @tc.require: AR000GI8IP
107 */
108 HWTEST_F(ContinuationTest, continue_manager_init_002, TestSize.Level1)
109 {
110 GTEST_LOG_(INFO) << "continue_manager_init_002 start";
111
112 std::weak_ptr<ContinuationManager> continuationManager = continuationManager_;
113 std::weak_ptr<Ability> abilityTmp = ability_;
114 std::shared_ptr<ContinuationHandler> continuationHandler =
115 std::make_shared<ContinuationHandler>(continuationManager, abilityTmp);
116 sptr<IRemoteObject> continueToken = nullptr;
117 bool result = continuationManager_->Init(ability_, continueToken, abilityInfo_, continuationHandler);
118 EXPECT_FALSE(result);
119 GTEST_LOG_(INFO) << "continue_manager_init_002 end";
120 }
121
122 /*
123 * @tc.name: continue_manager_start_continuation_001
124 * @tc.desc: call StartContinuation
125 * @tc.type: FUNC
126 * @tc.require: AR000GI8IP
127 */
128 HWTEST_F(ContinuationTest, continue_manager_start_continuation_001, TestSize.Level1)
129 {
130 GTEST_LOG_(INFO) << "continue_manager_start_continuation_001 start";
131
132 std::weak_ptr<ContinuationManager> continuationManager = continuationManager_;
133 std::weak_ptr<Ability> abilityTmp = ability_;
134 std::shared_ptr<ContinuationHandler> continuationHandler =
135 std::make_shared<ContinuationHandler>(continuationManager, abilityTmp);
136 continuationManager_->Init(ability_, continueToken_, abilityInfo_, continuationHandler);
137 bool startResult = continuationManager_->StartContinuation();
138 EXPECT_TRUE(startResult);
139 GTEST_LOG_(INFO) << "continue_manager_start_continuation_001 end";
140 }
141
142 /*
143 * @tc.name: continue_manager_save_data_001
144 * @tc.desc: call SaveData
145 * @tc.type: FUNC
146 * @tc.require: AR000GI8IP
147 */
148 HWTEST_F(ContinuationTest, continue_manager_save_data_001, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "continue_manager_save_data_001 start";
151
152 std::weak_ptr<ContinuationManager> continuationManager = continuationManager_;
153 std::weak_ptr<Ability> abilityTmp = ability_;
154 std::shared_ptr<ContinuationHandler> continuationHandler =
155 std::make_shared<ContinuationHandler>(continuationManager, abilityTmp);
156 continuationManager_->Init(ability_, continueToken_, abilityInfo_, continuationHandler);
157 WantParams wantParams;
158 bool saveDataResult = continuationManager_->SaveData(wantParams);
159 EXPECT_TRUE(saveDataResult);
160 GTEST_LOG_(INFO) << "continue_manager_save_data_001 end";
161 }
162
163 /*
164 * @tc.name: continue_handler_start_continue_001
165 * @tc.desc: call HandleStartContinuation with illegal token
166 * @tc.type: FUNC
167 * @tc.require: AR000GI8IP
168 */
169 HWTEST_F(ContinuationTest, continue_handler_start_continue_001, TestSize.Level1)
170 {
171 GTEST_LOG_(INFO) << "continue_handler_start_continue_001 start";
172
173 std::shared_ptr<Ability> ability = std::make_shared<MockContinuationAbility>();
174 sptr<IRemoteObject> continueToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
175 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
176 std::weak_ptr<ContinuationManager> continuationManager = continuationManager_;
177 std::weak_ptr<Ability> abilityTmp = ability;
178 std::shared_ptr<ContinuationHandler> continuationHandler =
179 std::make_shared<ContinuationHandler>(continuationManager, abilityTmp);
180 bool result = continuationHandler->HandleStartContinuation(nullptr, "mock_deviceId");
181 EXPECT_FALSE(result);
182 GTEST_LOG_(INFO) << "continue_handler_start_continue_001 end";
183 }
184
185 /*
186 * @tc.name: continue_handler_start_continue_002
187 * @tc.desc: call HandleStartContinuation without call SetAbilityInfo
188 * @tc.type: FUNC
189 * @tc.require: AR000GI8IP
190 */
191 HWTEST_F(ContinuationTest, continue_handler_start_continue_002, TestSize.Level1)
192 {
193 GTEST_LOG_(INFO) << "continue_handler_start_continue_002 start";
194
195 std::shared_ptr<Ability> ability = std::make_shared<MockContinuationAbility>();
196 sptr<IRemoteObject> continueToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
197 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
198 std::weak_ptr<ContinuationManager> continuationManager = continuationManager_;
199 std::weak_ptr<Ability> abilityTmp = ability;
200 std::shared_ptr<ContinuationHandler> continuationHandler =
201 std::make_shared<ContinuationHandler>(continuationManager, abilityTmp);
202 bool result = continuationHandler->HandleStartContinuation(continueToken, "mock_deviceId");
203 EXPECT_FALSE(result);
204 GTEST_LOG_(INFO) << "continue_handler_start_continue_002 end";
205 }
206 } // namespace AppExecFwk
207 } // namespace OHOS
208