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 } else { 90 std::string packageName = "packageName"; 91 abilityInfo_->SetPackageName(packageName); 92 EXPECT_STREQ(abilityInfo_->GetPackageName().c_str(), packageName.c_str()); 93 } 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 } else { 108 abilityInfo_->SetAccessibilityAbilityType(1); 109 EXPECT_EQ(abilityInfo_->GetAccessibilityAbilityType(), 1); 110 } 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 } else { 125 abilityInfo_->SetCapabilityValues(1); 126 EXPECT_EQ(abilityInfo_->GetCapabilityValues(), 1); 127 } 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 } else { 142 abilityInfo_->SetEventTypes(1); 143 EXPECT_EQ(abilityInfo_->GetEventTypes(), 1); 144 } 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 } else { 159 EXPECT_TRUE(!(abilityInfo_->IsImportant())); 160 } 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 } else { 175 EXPECT_TRUE(!(abilityInfo_->NeedHide())); 176 } 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 } else { 191 EXPECT_STREQ(abilityInfo_->GetLabel().c_str(), "label"); 192 } 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 } else { 207 EXPECT_STREQ(abilityInfo_->GetDescription().c_str(), "description"); 208 } 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 } else { 223 std::string id = "bundleName/name"; 224 EXPECT_STREQ(abilityInfo_->GetId().c_str(), id.c_str()); 225 } 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 } else { 240 EXPECT_STREQ(abilityInfo_->GetName().c_str(), "name"); 241 } 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 } else { 256 EXPECT_STREQ(abilityInfo_->GetModuleName().c_str(), "moduleName"); 257 } 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 } else { 272 std::vector<std::string> names = {"BundleName1", "BundleName2"}; 273 abilityInfo_->SetFilterBundleNames(names); 274 int32_t index = 0; 275 for (auto &name : abilityInfo_->GetFilterBundleNames()) { 276 if (!index) { 277 EXPECT_STREQ(name.c_str(), "BundleName1"); 278 } else { 279 EXPECT_STREQ(name.c_str(), "BundleName2"); 280 } 281 index++; 282 } 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 } else { 298 EXPECT_STREQ(abilityInfo_->GetSettingsAbility().c_str(), "settingsAbility"); 299 } 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 } else { 314 EXPECT_EQ(abilityInfo_->GetStaticCapabilityValues(), 1); 315 } 316 GTEST_LOG_(INFO) << "GetStaticCapabilityValues_001 end"; 317 } 318 } // namespace Accessibility 319 } // namespace OHOS