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