1 /*
2  * Copyright (C) 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 #include <memory>
18 #include "accessibility_ability_info.h"
19 
20 using namespace testing;
21 using namespace testing::ext;
22 
23 namespace OHOS {
24 namespace Accessibility {
25 class AccessibilityAbilityInfoUnitTest : public ::testing::Test {
26 public:
AccessibilityAbilityInfoUnitTest()27     AccessibilityAbilityInfoUnitTest()
28     {}
~AccessibilityAbilityInfoUnitTest()29     ~AccessibilityAbilityInfoUnitTest()
30     {}
SetUpTestCase()31     static void SetUpTestCase()
32     {
33         GTEST_LOG_(INFO) << "AccessibilityAbilityInfoUnitTest Start";
34     }
TearDownTestCase()35     static void TearDownTestCase()
36     {
37         GTEST_LOG_(INFO) << "AccessibilityAbilityInfoUnitTest End";
38     }
SetUp()39     void SetUp()
40     {
41         GTEST_LOG_(INFO) << "AccessibilityAbilityInfoUnitTest SetUp() Start";
42         AccessibilityAbilityInitParams params;
43         params.bundleName = "bundleName";
44         params.description = "description";
45         params.label = "label";
46         params.moduleName = "moduleName";
47         params.name = "name";
48         params.rationale = "rationale";
49         params.settingsAbility = "settingsAbility";
50         params.staticCapabilities = 1;
51         params.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_SPOKEN;
52         params.isImportant = true;
53         params.needHide = false;
54         abilityInfo_ = std::make_shared<AccessibilityAbilityInfo>(params);
55         GTEST_LOG_(INFO) << "AccessibilityAbilityInfoUnitTest SetUp() End";
56     };
TearDown()57     void TearDown()
58     {
59         GTEST_LOG_(INFO) << "AccessibilityAbilityInfoUnitTest TearDown()";
60         abilityInfo_ = nullptr;
61     }
62 
63     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo_ = nullptr;
64 };
65 
66 /**
67  * @tc.number: AccessibilityAbilityInfo_001
68  * @tc.name: AccessibilityAbilityInfo
69  * @tc.desc: Test function AccessibilityAbilityInfo
70  */
71 HWTEST_F(AccessibilityAbilityInfoUnitTest, AccessibilityAbilityInfo_001, TestSize.Level1)
72 {
73     GTEST_LOG_(INFO) << "AccessibilityAbilityInfo_001 start";
74     std::shared_ptr<AccessibilityAbilityInfo> info = std::make_shared<AccessibilityAbilityInfo>();
75     EXPECT_TRUE(info);
76     GTEST_LOG_(INFO) << "AccessibilityAbilityInfo_001 end";
77 }
78 
79 /**
80  * @tc.number: SetPackageName_001
81  * @tc.name: SetPackageName
82  * @tc.desc: Test function SetPackageName
83  */
84 HWTEST_F(AccessibilityAbilityInfoUnitTest, SetPackageName_001, TestSize.Level1)
85 {
86     GTEST_LOG_(INFO) << "SetPackageName_001 start";
87     if (!abilityInfo_) {
88         GTEST_LOG_(INFO) << "abilityInfo_ is null";
89         return;
90     }
91     std::string packageName = "packageName";
92     abilityInfo_->SetPackageName(packageName);
93     EXPECT_STREQ(abilityInfo_->GetPackageName().c_str(), packageName.c_str());
94     GTEST_LOG_(INFO) << "SetPackageName_001 end";
95 }
96 
97 /**
98  * @tc.number: SetAccessibilityAbilityType_001
99  * @tc.name: SetAccessibilityAbilityType
100  * @tc.desc: Test function SetAccessibilityAbilityType
101  */
102 HWTEST_F(AccessibilityAbilityInfoUnitTest, SetAccessibilityAbilityType_001, TestSize.Level1)
103 {
104     GTEST_LOG_(INFO) << "SetAccessibilityAbilityType_001 start";
105     if (!abilityInfo_) {
106         GTEST_LOG_(INFO) << "abilityInfo_ is null";
107         return;
108     }
109     abilityInfo_->SetAccessibilityAbilityType(1);
110     EXPECT_EQ(abilityInfo_->GetAccessibilityAbilityType(), 1);
111     GTEST_LOG_(INFO) << "SetAccessibilityAbilityType_001 end";
112 }
113 
114 /**
115  * @tc.number: SetCapabilityValues_001
116  * @tc.name: SetCapabilityValues
117  * @tc.desc: Test function SetCapabilityValues
118  */
119 HWTEST_F(AccessibilityAbilityInfoUnitTest, SetCapabilityValues_001, TestSize.Level1)
120 {
121     GTEST_LOG_(INFO) << "SetCapabilityValues_001 start";
122     if (!abilityInfo_) {
123         GTEST_LOG_(INFO) << "abilityInfo_ is null";
124         return;
125     }
126     abilityInfo_->SetCapabilityValues(1);
127     EXPECT_EQ(abilityInfo_->GetCapabilityValues(), 1);
128     GTEST_LOG_(INFO) << "SetCapabilityValues_001 end";
129 }
130 
131 /**
132  * @tc.number: SetEventTypes_001
133  * @tc.name: SetEventTypes
134  * @tc.desc: Test function SetEventTypes
135  */
136 HWTEST_F(AccessibilityAbilityInfoUnitTest, SetEventTypes_001, TestSize.Level1)
137 {
138     GTEST_LOG_(INFO) << "SetEventTypes_001 start";
139     if (!abilityInfo_) {
140         GTEST_LOG_(INFO) << "abilityInfo_ is null";
141         return;
142     }
143     abilityInfo_->SetEventTypes(1);
144     EXPECT_EQ(abilityInfo_->GetEventTypes(), 1);
145     GTEST_LOG_(INFO) << "SetEventTypes_001 end";
146 }
147 
148 /**
149  * @tc.number: IsImportant_001
150  * @tc.name: IsImportant
151  * @tc.desc: Test function IsImportant
152  */
153 HWTEST_F(AccessibilityAbilityInfoUnitTest, IsImportant_001, TestSize.Level1)
154 {
155     GTEST_LOG_(INFO) << "IsImportant_001 start";
156     if (!abilityInfo_) {
157         GTEST_LOG_(INFO) << "abilityInfo_ is null";
158         return;
159     }
160     EXPECT_TRUE(!(abilityInfo_->IsImportant()));
161     GTEST_LOG_(INFO) << "IsImportant_001 end";
162 }
163 
164 /**
165  * @tc.number: NeedHide_001
166  * @tc.name: NeedHide
167  * @tc.desc: Test function NeedHide
168  */
169 HWTEST_F(AccessibilityAbilityInfoUnitTest, NeedHide_001, TestSize.Level1)
170 {
171     GTEST_LOG_(INFO) << "NeedHide_001 start";
172     if (!abilityInfo_) {
173         GTEST_LOG_(INFO) << "abilityInfo_ is null";
174         return;
175     }
176     EXPECT_TRUE(!(abilityInfo_->NeedHide()));
177     GTEST_LOG_(INFO) << "NeedHide_001 end";
178 }
179 
180 /**
181  * @tc.number: GetLabel_001
182  * @tc.name: GetLabel
183  * @tc.desc: Test function GetLabel
184  */
185 HWTEST_F(AccessibilityAbilityInfoUnitTest, GetLabel_001, TestSize.Level1)
186 {
187     GTEST_LOG_(INFO) << "GetLabel_001 start";
188     if (!abilityInfo_) {
189         GTEST_LOG_(INFO) << "abilityInfo_ is null";
190         return;
191     }
192     EXPECT_STREQ(abilityInfo_->GetLabel().c_str(), "label");
193     GTEST_LOG_(INFO) << "GetLabel_001 end";
194 }
195 
196 /**
197  * @tc.number: GetDescription_001
198  * @tc.name: GetDescription
199  * @tc.desc: Test function GetDescription
200  */
201 HWTEST_F(AccessibilityAbilityInfoUnitTest, GetDescription_001, TestSize.Level1)
202 {
203     GTEST_LOG_(INFO) << "GetDescription_001 start";
204     if (!abilityInfo_) {
205         GTEST_LOG_(INFO) << "abilityInfo_ is null";
206         return;
207     }
208     EXPECT_STREQ(abilityInfo_->GetDescription().c_str(), "description");
209     GTEST_LOG_(INFO) << "GetDescription_001 end";
210 }
211 
212 /**
213  * @tc.number: GetId_001
214  * @tc.name: GetId
215  * @tc.desc: Test function GetId
216  */
217 HWTEST_F(AccessibilityAbilityInfoUnitTest, GetId_001, TestSize.Level1)
218 {
219     GTEST_LOG_(INFO) << "GetId_001 start";
220     if (!abilityInfo_) {
221         GTEST_LOG_(INFO) << "abilityInfo_ is null";
222         return;
223     }
224     std::string id = "bundleName/name";
225     EXPECT_STREQ(abilityInfo_->GetId().c_str(), id.c_str());
226     GTEST_LOG_(INFO) << "GetId_001 end";
227 }
228 
229 /**
230  * @tc.number: GetName_001
231  * @tc.name: GetName
232  * @tc.desc: Test function GetName
233  */
234 HWTEST_F(AccessibilityAbilityInfoUnitTest, GetName_001, TestSize.Level1)
235 {
236     GTEST_LOG_(INFO) << "GetName_001 start";
237     if (!abilityInfo_) {
238         GTEST_LOG_(INFO) << "abilityInfo_ is null";
239         return;
240     }
241     EXPECT_STREQ(abilityInfo_->GetName().c_str(), "name");
242     GTEST_LOG_(INFO) << "GetName_001 end";
243 }
244 
245 /**
246  * @tc.number: GetModuleName_001
247  * @tc.name: GetModuleName
248  * @tc.desc: Test function GetModuleName
249  */
250 HWTEST_F(AccessibilityAbilityInfoUnitTest, GetModuleName_001, TestSize.Level1)
251 {
252     GTEST_LOG_(INFO) << "GetModuleName_001 start";
253     if (!abilityInfo_) {
254         GTEST_LOG_(INFO) << "abilityInfo_ is null";
255         return;
256     }
257     EXPECT_STREQ(abilityInfo_->GetModuleName().c_str(), "moduleName");
258     GTEST_LOG_(INFO) << "GetModuleName_001 end";
259 }
260 
261 /**
262  * @tc.number: SetFilterBundleNames_001
263  * @tc.name: SetFilterBundleNames
264  * @tc.desc: Test function SetFilterBundleNames
265  */
266 HWTEST_F(AccessibilityAbilityInfoUnitTest, SetFilterBundleNames_001, TestSize.Level1)
267 {
268     GTEST_LOG_(INFO) << "SetFilterBundleNames_001 start";
269     if (!abilityInfo_) {
270         GTEST_LOG_(INFO) << "abilityInfo_ is null";
271         return;
272     }
273     std::vector<std::string> names = {"BundleName1", "BundleName2"};
274     abilityInfo_->SetFilterBundleNames(names);
275     int32_t index = 0;
276     for (auto &name : abilityInfo_->GetFilterBundleNames()) {
277         if (!index) {
278             EXPECT_STREQ(name.c_str(), "BundleName1");
279         } else {
280             EXPECT_STREQ(name.c_str(), "BundleName2");
281         }
282         index++;
283     }
284     GTEST_LOG_(INFO) << "SetFilterBundleNames_001 end";
285 }
286 
287 /**
288  * @tc.number: GetSettingsAbility_001
289  * @tc.name: GetSettingsAbility
290  * @tc.desc: Test function GetSettingsAbility
291  */
292 HWTEST_F(AccessibilityAbilityInfoUnitTest, GetSettingsAbility_001, TestSize.Level1)
293 {
294     GTEST_LOG_(INFO) << "GetSettingsAbility_001 start";
295     if (!abilityInfo_) {
296         GTEST_LOG_(INFO) << "abilityInfo_ is null";
297         return;
298     }
299     EXPECT_STREQ(abilityInfo_->GetSettingsAbility().c_str(), "settingsAbility");
300     GTEST_LOG_(INFO) << "GetSettingsAbility_001 end";
301 }
302 
303 /**
304  * @tc.number: GetStaticCapabilityValues_001
305  * @tc.name: GetStaticCapabilityValues
306  * @tc.desc: Test function GetStaticCapabilityValues
307  */
308 HWTEST_F(AccessibilityAbilityInfoUnitTest, GetStaticCapabilityValues_001, TestSize.Level1)
309 {
310     GTEST_LOG_(INFO) << "GetStaticCapabilityValues_001 start";
311     if (!abilityInfo_) {
312         GTEST_LOG_(INFO) << "abilityInfo_ is null";
313         return;
314     }
315     EXPECT_EQ(abilityInfo_->GetStaticCapabilityValues(), 1);
316     GTEST_LOG_(INFO) << "GetStaticCapabilityValues_001 end";
317 }
318 } // namespace Accessibility
319 } // namespace OHOS