1 /*
2 * Copyright (c) 2021-2022 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 #define private public
19 #define protected public
20 #include "implicit_start_processor.h"
21 #undef private
22 #undef protected
23
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace OHOS::AppExecFwk;
27
28 namespace OHOS {
29 namespace AAFwk {
30
31 class ImplicitStartProcessorTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void ImplicitStartProcessorTest::SetUpTestCase(void)
40 {}
TearDownTestCase(void)41 void ImplicitStartProcessorTest::TearDownTestCase(void)
42 {}
SetUp()43 void ImplicitStartProcessorTest::SetUp()
44 {}
TearDown()45 void ImplicitStartProcessorTest::TearDown()
46 {}
47
48 /*
49 * Feature: ImplicitStartProcessor
50 * Function: ImplicitStartAbility
51 * SubFunction: NA
52 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbility
53 * EnvConditions: NA
54 * CaseDescription: Verify ImplicitStartAbility
55 */
56 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbility_001, TestSize.Level1)
57 {
58 auto processor = std::make_shared<ImplicitStartProcessor>();
59 AbilityRequest request;
60 int32_t userId = 0;
61 bool res = processor->ImplicitStartAbility(request, userId);
62 EXPECT_TRUE(res);
63 }
64
65 /*
66 * Feature: ImplicitStartProcessor
67 * Function: CheckImplicitStartExtensionIsValid
68 * SubFunction: NA
69 * FunctionPoints:ImplicitStartProcessor CheckImplicitStartExtensionIsValid
70 * EnvConditions: NA
71 * CaseDescription: Verify CheckImplicitStartExtensionIsValid
72 */
73 HWTEST_F(ImplicitStartProcessorTest, CheckImplicitStartExtensionIsValid_001, TestSize.Level1)
74 {
75 auto processor = std::make_shared<ImplicitStartProcessor>();
76 AbilityRequest request;
77 ExtensionAbilityInfo extensionInfo;
78 Want want;
79 want.SetElementName("bundle", "");
80 request.want = want;
81 bool res = processor->CheckImplicitStartExtensionIsValid(request, extensionInfo);
82 EXPECT_TRUE(res);
83 }
84
85 /*
86 * Feature: ImplicitStartProcessor
87 * Function: CheckImplicitStartExtensionIsValid
88 * SubFunction: NA
89 * FunctionPoints:ImplicitStartProcessor CheckImplicitStartExtensionIsValid
90 * EnvConditions: NA
91 * CaseDescription: Verify CheckImplicitStartExtensionIsValid
92 */
93 HWTEST_F(ImplicitStartProcessorTest, CheckImplicitStartExtensionIsValid_002, TestSize.Level1)
94 {
95 auto processor = std::make_shared<ImplicitStartProcessor>();
96 AbilityRequest request;
97 ExtensionAbilityInfo extensionInfo;
98 Want want;
99 want.SetElementName("", "");
100 request.want = want;
101 extensionInfo.type = ExtensionAbilityType::WORK_SCHEDULER;
102 bool res = processor->CheckImplicitStartExtensionIsValid(request, extensionInfo);
103 EXPECT_FALSE(res);
104 }
105
106 /*
107 * Feature: ImplicitStartProcessor
108 * Function: CheckImplicitStartExtensionIsValid
109 * SubFunction: NA
110 * FunctionPoints:ImplicitStartProcessor CheckImplicitStartExtensionIsValid
111 * EnvConditions: NA
112 * CaseDescription: Verify CheckImplicitStartExtensionIsValid
113 */
114 HWTEST_F(ImplicitStartProcessorTest, CheckImplicitStartExtensionIsValid_003, TestSize.Level1)
115 {
116 auto processor = std::make_shared<ImplicitStartProcessor>();
117 AbilityRequest request;
118 ExtensionAbilityInfo extensionInfo;
119 Want want;
120 want.SetElementName("", "");
121 request.want = want;
122 extensionInfo.type = ExtensionAbilityType::FORM;
123 bool res = processor->CheckImplicitStartExtensionIsValid(request, extensionInfo);
124 EXPECT_TRUE(res);
125 }
126
127 /*
128 * Feature: ImplicitStartProcessor
129 * Function: ImplicitStartAbilityInner
130 * SubFunction: NA
131 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbilityInner
132 * EnvConditions: NA
133 * CaseDescription: Verify ImplicitStartAbilityInner
134 */
135 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbilityInner_001, TestSize.Level1)
136 {
137 auto processor = std::make_shared<ImplicitStartProcessor>();
138 Want want;
139 AbilityRequest request;
140 int32_t userId = 0;
141 request.callType = AbilityCallType::START_OPTIONS_TYPE;
142 bool res = processor->ImplicitStartAbilityInner(want, request, userId);
143 EXPECT_NE(res, ERR_OK);
144 }
145
146 /*
147 * Feature: ImplicitStartProcessor
148 * Function: ImplicitStartAbilityInner
149 * SubFunction: NA
150 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbilityInner
151 * EnvConditions: NA
152 * CaseDescription: Verify ImplicitStartAbilityInner
153 */
154 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbilityInner_002, TestSize.Level1)
155 {
156 auto processor = std::make_shared<ImplicitStartProcessor>();
157 Want want;
158 AbilityRequest request;
159 int32_t userId = 0;
160 request.callType = AbilityCallType::START_SETTINGS_TYPE;
161 bool res = processor->ImplicitStartAbilityInner(want, request, userId);
162 EXPECT_NE(res, ERR_OK);
163 }
164
165 /*
166 * Feature: ImplicitStartProcessor
167 * Function: ImplicitStartAbilityInner
168 * SubFunction: NA
169 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbilityInner
170 * EnvConditions: NA
171 * CaseDescription: Verify ImplicitStartAbilityInner
172 */
173 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbilityInner_003, TestSize.Level1)
174 {
175 auto processor = std::make_shared<ImplicitStartProcessor>();
176 Want want;
177 AbilityRequest request;
178 int32_t userId = 0;
179 request.callType = AbilityCallType::START_EXTENSION_TYPE;
180 bool res = processor->ImplicitStartAbilityInner(want, request, userId);
181 EXPECT_NE(res, ERR_OK);
182 }
183
184 /*
185 * Feature: ImplicitStartProcessor
186 * Function: ImplicitStartAbilityInner
187 * SubFunction: NA
188 * FunctionPoints:ImplicitStartProcessor ImplicitStartAbilityInner
189 * EnvConditions: NA
190 * CaseDescription: Verify ImplicitStartAbilityInner
191 */
192 HWTEST_F(ImplicitStartProcessorTest, ImplicitStartAbilityInner_004, TestSize.Level1)
193 {
194 auto processor = std::make_shared<ImplicitStartProcessor>();
195 Want want;
196 AbilityRequest request;
197 int32_t userId = 0;
198 request.callType = AbilityCallType::CALL_REQUEST_TYPE;
199 bool res = processor->ImplicitStartAbilityInner(want, request, userId);
200 EXPECT_NE(res, ERR_OK);
201 }
202
203 /*
204 * Feature: ImplicitStartProcessor
205 * Function: CallStartAbilityInner
206 * SubFunction: NA
207 * FunctionPoints:ImplicitStartProcessor CallStartAbilityInner
208 * EnvConditions: NA
209 * CaseDescription: Verify CallStartAbilityInner
210 */
211 HWTEST_F(ImplicitStartProcessorTest, CallStartAbilityInner_001, TestSize.Level1)
212 {
213 auto processor = std::make_shared<ImplicitStartProcessor>();
214 int32_t userId = 0;
215 Want want;
__anon8cb797f70102() 216 ImplicitStartProcessor::StartAbilityClosure callBack = []() -> int32_t {
217 return 1;
218 };
219 AbilityCallType callType = AbilityCallType::INVALID_TYPE;
220 bool res = processor->CallStartAbilityInner(userId, want, callBack, callType);
221 EXPECT_NE(res, ERR_OK);
222 }
223
224 /*
225 * Feature: ImplicitStartProcessor
226 * Function: CallStartAbilityInner
227 * SubFunction: NA
228 * FunctionPoints:ImplicitStartProcessor CallStartAbilityInner
229 * EnvConditions: NA
230 * CaseDescription: Verify CallStartAbilityInner
231 */
232 HWTEST_F(ImplicitStartProcessorTest, CallStartAbilityInner_002, TestSize.Level1)
233 {
234 auto processor = std::make_shared<ImplicitStartProcessor>();
235 int32_t userId = 0;
236 Want want;
__anon8cb797f70202() 237 ImplicitStartProcessor::StartAbilityClosure callBack = []() -> int32_t {
238 return 1;
239 };
240 AbilityCallType callType = AbilityCallType::CALL_REQUEST_TYPE;
241 bool res = processor->CallStartAbilityInner(userId, want, callBack, callType);
242 EXPECT_NE(res, ERR_OK);
243 }
244
245 /*
246 * Feature: ImplicitStartProcessor
247 * Function: CallStartAbilityInner
248 * SubFunction: NA
249 * FunctionPoints:ImplicitStartProcessor CallStartAbilityInner
250 * EnvConditions: NA
251 * CaseDescription: Verify CallStartAbilityInner
252 */
253 HWTEST_F(ImplicitStartProcessorTest, CallStartAbilityInner_003, TestSize.Level1)
254 {
255 auto processor = std::make_shared<ImplicitStartProcessor>();
256 int32_t userId = 0;
257 Want want;
__anon8cb797f70302() 258 ImplicitStartProcessor::StartAbilityClosure callBack = []() -> int32_t {
259 return ERR_OK;
260 };
261 AbilityCallType callType = AbilityCallType::CALL_REQUEST_TYPE;
262 bool res = processor->CallStartAbilityInner(userId, want, callBack, callType);
263 EXPECT_EQ(res, ERR_OK);
264 }
265 } // namespace AAFwk
266 } // namespace OHOS
267