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 "completed_callback.h"
19 #include "event_handler.h"
20 #include "element_name.h"
21 #include "base_types.h"
22 #include "pending_want.h"
23 #define private public
24 #define protected public
25 #include "trigger_info.h"
26 #undef private
27 #undef protected
28 #include "want.h"
29 #include "want_params.h"
30 #include "want_receiver_stub.h"
31 #include "bool_wrapper.h"
32 #include "start_options.h"
33 
34 using namespace testing::ext;
35 using namespace OHOS::AAFwk;
36 using namespace OHOS;
37 using OHOS::AppExecFwk::ElementName;
38 using namespace OHOS::AppExecFwk;
39 using vector_str = std::vector<std::string>;
40 
41 namespace OHOS::AbilityRuntime::WantAgent {
42 class TriggerInfoTest : public testing::Test {
43 public:
TriggerInfoTest()44     TriggerInfoTest()
45     {}
~TriggerInfoTest()46     ~TriggerInfoTest()
47     {}
48     static void SetUpTestCase(void);
49     static void TearDownTestCase(void);
50     void SetUp();
51     void TearDown();
52 };
53 
SetUpTestCase(void)54 void TriggerInfoTest::SetUpTestCase(void)
55 {}
56 
TearDownTestCase(void)57 void TriggerInfoTest::TearDownTestCase(void)
58 {}
59 
SetUp(void)60 void TriggerInfoTest::SetUp(void)
61 {}
62 
TearDown(void)63 void TriggerInfoTest::TearDown(void)
64 {}
65 
66 /*
67  * @tc.number    : TriggerInfo_0100
68  * @tc.name      : TriggerInfo Constructors
69  * @tc.desc      : 1.def Constructors
70  */
71 HWTEST_F(TriggerInfoTest, TriggerInfo_0100, Function | MediumTest | Level1)
72 {
73     TriggerInfo triggerInfo;
74     EXPECT_EQ(triggerInfo.permission_, "");
75     EXPECT_EQ(triggerInfo.extraInfo_, nullptr);
76     EXPECT_EQ(triggerInfo.want_, nullptr);
77     EXPECT_EQ(triggerInfo.resultCode_, 0);
78 }
79 
80 /*
81  * @tc.number    : TriggerInfo_0200
82  * @tc.name      : TriggerInfo Constructors
83  * @tc.desc      : 1.def Constructors
84  */
85 HWTEST_F(TriggerInfoTest, TriggerInfo_0200, Function | MediumTest | Level1)
86 {
87     std::string permission = "nihao";
88     std::shared_ptr<Want> want = std::make_shared<Want>();
89     ElementName element("device", "bundleName", "abilityName");
90     want->SetElement(element);
91     bool value = true;
92     std::string key = "key";
93     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
94     wParams->SetParam(key, Boolean::Box(value));
95     int resultCode = 10;
96     TriggerInfo triggerInfo(permission, wParams, want, resultCode);
97     EXPECT_EQ(triggerInfo.permission_, permission);
98     EXPECT_NE(triggerInfo.extraInfo_, wParams);
99     EXPECT_EQ(Boolean::Unbox(IBoolean::Query(triggerInfo.extraInfo_->GetParam(key))), value);
100     EXPECT_NE(triggerInfo.want_, want);
101     EXPECT_EQ(triggerInfo.want_->GetElement().GetBundleName(), "bundleName");
102     EXPECT_EQ(triggerInfo.want_->GetElement().GetAbilityName(), "abilityName");
103     EXPECT_EQ(triggerInfo.resultCode_, resultCode);
104 }
105 
106 /*
107  * @tc.number    : TriggerInfo_0300
108  * @tc.name      : TriggerInfo Constructors
109  * @tc.desc      : 1.copy Constructors
110  */
111 HWTEST_F(TriggerInfoTest, TriggerInfo_0300, Function | MediumTest | Level1)
112 {
113     std::string permission = "nihao";
114     std::shared_ptr<Want> want = std::make_shared<Want>();
115     ElementName element("device", "bundleName", "abilityName");
116     want->SetElement(element);
117     bool value = true;
118     std::string key = "key";
119     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
120     wParams->SetParam(key, Boolean::Box(value));
121     int resultCode = 10;
122     TriggerInfo triggerInfo(permission, wParams, want, resultCode);
123     EXPECT_EQ(triggerInfo.permission_, permission);
124     EXPECT_NE(triggerInfo.extraInfo_, wParams);
125     EXPECT_EQ(Boolean::Unbox(IBoolean::Query(triggerInfo.extraInfo_->GetParam(key))), value);
126     EXPECT_NE(triggerInfo.want_, want);
127     EXPECT_EQ(triggerInfo.want_->GetElement().GetBundleName(), "bundleName");
128     EXPECT_EQ(triggerInfo.want_->GetElement().GetAbilityName(), "abilityName");
129     EXPECT_EQ(triggerInfo.resultCode_, resultCode);
130     TriggerInfo triggerInfo1(triggerInfo);
131     EXPECT_EQ(triggerInfo1.permission_, triggerInfo.permission_);
132     EXPECT_NE(triggerInfo1.extraInfo_, triggerInfo.extraInfo_);
133     EXPECT_EQ(Boolean::Unbox(IBoolean::Query(triggerInfo1.extraInfo_->GetParam(key))), value);
134     EXPECT_NE(triggerInfo1.want_, triggerInfo.want_);
135     EXPECT_EQ(triggerInfo1.want_->GetElement().GetBundleName(), "bundleName");
136     EXPECT_EQ(triggerInfo1.want_->GetElement().GetAbilityName(), "abilityName");
137     EXPECT_EQ(triggerInfo1.resultCode_, triggerInfo.resultCode_);
138 }
139 
140 /*
141  * @tc.number    : TriggerInfo_0400
142  * @tc.name      : TriggerInfo::Builder SetPermission
143  * @tc.desc      : 1.SetPermission
144  */
145 HWTEST_F(TriggerInfoTest, TriggerInfo_0400, Function | MediumTest | Level1)
146 {
147     std::shared_ptr<TriggerInfo::Builder> builder = std::make_shared<TriggerInfo::Builder>();
148     builder->SetPermission("nihao");
149     EXPECT_EQ(builder->permission_, "nihao");
150 }
151 
152 /*
153  * @tc.number    : TriggerInfo_0500
154  * @tc.name      : TriggerInfo::Builder SetWantParams
155  * @tc.desc      : 1.SetWantParams
156  */
157 HWTEST_F(TriggerInfoTest, TriggerInfo_0500, Function | MediumTest | Level1)
158 {
159     std::shared_ptr<TriggerInfo::Builder> builder = std::make_shared<TriggerInfo::Builder>();
160     bool value = true;
161     std::string key = "key";
162     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
163     wParams->SetParam(key, Boolean::Box(value));
164     builder->SetWantParams(wParams);
165     EXPECT_EQ(Boolean::Unbox(IBoolean::Query(builder->params_->GetParam(key))), value);
166 }
167 
168 /*
169  * @tc.number    : TriggerInfo_0600
170  * @tc.name      : TriggerInfo::Builder SetWant
171  * @tc.desc      : 1.SetWant
172  */
173 HWTEST_F(TriggerInfoTest, TriggerInfo_0600, Function | MediumTest | Level1)
174 {
175     std::shared_ptr<TriggerInfo::Builder> builder = std::make_shared<TriggerInfo::Builder>();
176     std::shared_ptr<Want> want = std::make_shared<Want>();
177     ElementName element("device", "bundleName", "abilityName");
178     want->SetElement(element);
179     builder->SetWant(want);
180     EXPECT_EQ(builder->want_->GetElement().GetBundleName(), "bundleName");
181     EXPECT_EQ(builder->want_->GetElement().GetAbilityName(), "abilityName");
182 }
183 
184 /*
185  * @tc.number    : TriggerInfo_0700
186  * @tc.name      : TriggerInfo::Builder SetResultCode
187  * @tc.desc      : 1.SetResultCode
188  */
189 HWTEST_F(TriggerInfoTest, TriggerInfo_0700, Function | MediumTest | Level1)
190 {
191     std::shared_ptr<TriggerInfo::Builder> builder = std::make_shared<TriggerInfo::Builder>();
192     int resultCode = 100;
193     builder->SetResultCode(resultCode);
194     EXPECT_EQ(builder->resultCode_, resultCode);
195 }
196 
197 /*
198  * @tc.number    : TriggerInfo_0800
199  * @tc.name      : TriggerInfo::Builder Build
200  * @tc.desc      : 1.Build,Great TriggerInfo object
201  */
202 HWTEST_F(TriggerInfoTest, TriggerInfo_0800, Function | MediumTest | Level1)
203 {
204     std::shared_ptr<TriggerInfo::Builder> builder = std::make_shared<TriggerInfo::Builder>();
205     builder->SetPermission("nihao");
206     bool value = true;
207     std::string key = "key";
208     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
209     wParams->SetParam(key, Boolean::Box(value));
210     builder->SetWantParams(wParams);
211     std::shared_ptr<Want> want = std::make_shared<Want>();
212     ElementName element("device", "bundleName", "abilityName");
213     want->SetElement(element);
214     builder->SetWant(want);
215     int resultCode = 100;
216     builder->SetResultCode(resultCode);
217 
218     auto info = builder->Build();
219     EXPECT_NE(info, nullptr);
220     EXPECT_EQ(info->permission_, "nihao");
221     EXPECT_EQ(Boolean::Unbox(IBoolean::Query(info->extraInfo_->GetParam(key))), value);
222     EXPECT_EQ(info->want_->GetElement().GetBundleName(), "bundleName");
223     EXPECT_EQ(info->want_->GetElement().GetAbilityName(), "abilityName");
224     EXPECT_EQ(info->resultCode_, resultCode);
225 }
226 
227 
228 /*
229  * @tc.number    : TriggerInfo_0900
230  * @tc.name      : TriggerInfo::Builder SetStartOptions
231  * @tc.desc      : 1.SetStartOptions
232  */
233 HWTEST_F(TriggerInfoTest, TriggerInfo_0900, Function | MediumTest | Level1)
234 {
235     std::shared_ptr<TriggerInfo::Builder> builder = std::make_shared<TriggerInfo::Builder>();
236     std::shared_ptr<AAFwk::StartOptions> startOptions = std::make_shared<AAFwk::StartOptions>();
237     builder->SetStartOptions(startOptions);
238     EXPECT_EQ(builder->startOptions_->GetWindowMode(), 0);
239 }
240 
241 /*
242  * @tc.number    : TriggerInfo_0100
243  * @tc.name      : TriggerInfo Constructors
244  * @tc.desc      : 1.def Constructors
245  */
246 HWTEST_F(TriggerInfoTest, TriggerInfo_operator_0100, Function | MediumTest | Level1)
247 {
248     std::string permission = "nihao";
249     std::shared_ptr<Want> want = std::make_shared<Want>();
250     ElementName element("device", "bundleName", "abilityName");
251     want->SetElement(element);
252     bool value = true;
253     std::string key = "key";
254     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
255     wParams->SetParam(key, Boolean::Box(value));
256     int resultCode = 10;
257     TriggerInfo triggerInfo1(permission, wParams, want, resultCode);
258     TriggerInfo triggerInfo2;
259     triggerInfo2 = triggerInfo1;
260     EXPECT_EQ(triggerInfo2.permission_, permission);
261     EXPECT_NE(triggerInfo2.extraInfo_, wParams);
262     EXPECT_EQ(Boolean::Unbox(IBoolean::Query(triggerInfo2.extraInfo_->GetParam(key))), value);
263     EXPECT_NE(triggerInfo2.want_, want);
264     EXPECT_EQ(triggerInfo2.want_->GetElement().GetBundleName(), "bundleName");
265     EXPECT_EQ(triggerInfo2.want_->GetElement().GetAbilityName(), "abilityName");
266     EXPECT_EQ(triggerInfo2.resultCode_, resultCode);
267 }
268 
269 }  // namespace OHOS::AbilityRuntime::WantAgent
270