1 /* 2 * Copyright (c) 2023 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 "setting_datashare.h" 19 #include "setting_observer.h" 20 #include "event_log_helper.h" 21 #include "mmi_log.h" 22 23 #undef MMI_LOG_TAG 24 #define MMI_LOG_TAG "SettingDatashareTest" 25 26 namespace OHOS { 27 namespace MMI { 28 namespace { 29 using namespace testing::ext; 30 } // namespace 31 32 class SettingDatashareTest : public testing::Test { 33 public: SetUpTestCase(void)34 static void SetUpTestCase(void) {} TearDownTestCase(void)35 static void TearDownTestCase(void) {} SetUp(void)36 void SetUp(void) {} TearDown(void)37 void TearDown(void) {} 38 }; 39 40 class SettingObserverTest : public testing::Test { 41 public: SetUpTestCase(void)42 static void SetUpTestCase(void) {} TearDownTestCase(void)43 static void TearDownTestCase(void) {} 44 }; 45 46 /** 47 * @tc.name: SettingDatashareTest_GetIntValue 48 * @tc.desc: Test GetIntValue 49 * @tc.type: FUNC 50 * @tc.require: 51 */ 52 HWTEST_F(SettingDatashareTest, SettingDatashareTest_GetIntValue, TestSize.Level1) 53 { 54 CALL_TEST_DEBUG; 55 SettingDataShare settingDataShare; 56 std::string key = "settingDateShare"; 57 int32_t value = 123; 58 ASSERT_NE(settingDataShare.GetIntValue(key, value), ERR_OK); 59 } 60 61 /** 62 * @tc.name: SettingDatashareTest_PutIntValue 63 * @tc.desc: Test PutIntValue 64 * @tc.type: FUNC 65 * @tc.require: 66 */ 67 HWTEST_F(SettingDatashareTest, SettingDatashareTest_PutIntValue, TestSize.Level1) 68 { 69 CALL_TEST_DEBUG; 70 SettingDataShare settingDataShare; 71 std::string key = "settingDateShare"; 72 int32_t value = 123; 73 bool needNotify = true; 74 ASSERT_EQ(settingDataShare.PutIntValue(key, value, needNotify), ERR_OK); 75 } 76 77 /** 78 * @tc.name: SettingDatashareTest_PutLongValue 79 * @tc.desc: Test PutLongValue 80 * @tc.type: FUNC 81 * @tc.require: 82 */ 83 HWTEST_F(SettingDatashareTest, SettingDatashareTest_PutLongValue, TestSize.Level1) 84 { 85 CALL_TEST_DEBUG; 86 SettingDataShare settingDataShare; 87 std::string key = "settingDateShare"; 88 int64_t value = 123; 89 bool needNotify = true; 90 ASSERT_EQ(settingDataShare.PutLongValue(key, value, needNotify), ERR_OK); 91 } 92 93 /** 94 * @tc.name: SettingDatashareTest_PutBoolValue 95 * @tc.desc: Test PutBoolValue 96 * @tc.type: FUNC 97 * @tc.require: 98 */ 99 HWTEST_F(SettingDatashareTest, SettingDatashareTest_PutBoolValue, TestSize.Level1) 100 { 101 CALL_TEST_DEBUG; 102 SettingDataShare settingDataShare; 103 std::string key = "settingDateShare"; 104 bool value = true; 105 bool needNotify = true; 106 ASSERT_EQ(settingDataShare.PutBoolValue(key, value, needNotify), ERR_OK); 107 } 108 109 /** 110 * @tc.name: SettingDatashareTest_IsValidKey 111 * @tc.desc: Test IsValidKey 112 * @tc.type: FUNC 113 * @tc.require: 114 */ 115 HWTEST_F(SettingDatashareTest, SettingDatashareTest_IsValidKey, TestSize.Level1) 116 { 117 CALL_TEST_DEBUG; 118 SettingDataShare settingDataShare; 119 std::string key = "settingDateShare"; 120 ASSERT_FALSE(settingDataShare.IsValidKey(key)); 121 } 122 123 /** 124 * @tc.name: SettingDatashareTest_ExecRegisterCb 125 * @tc.desc: Test ExecRegisterCb 126 * @tc.type: FUNC 127 * @tc.require: 128 */ 129 HWTEST_F(SettingDatashareTest, SettingDatashareTest_ExecRegisterCb, TestSize.Level1) 130 { 131 CALL_TEST_DEBUG; 132 SettingDataShare settingDataShare; 133 std::string key = "settingDateShare"; 134 sptr<SettingObserver> observer = nullptr; 135 ASSERT_NO_FATAL_FAILURE(settingDataShare.ExecRegisterCb(observer)); 136 } 137 138 /** 139 * @tc.name: SettingDatashareTest_RegisterObserver 140 * @tc.desc: Test RegisterObserver 141 * @tc.type: FUNC 142 * @tc.require: 143 */ 144 HWTEST_F(SettingDatashareTest, SettingDatashareTest_RegisterObserver, TestSize.Level1) 145 { 146 CALL_TEST_DEBUG; 147 SettingDataShare settingDataShare; 148 std::string key = "settingDateShare"; 149 sptr<SettingObserver> observer = new (std::nothrow) SettingObserver; 150 ASSERT_NE(observer, nullptr); 151 observer->key_ = "settingDateShare"; 152 std::string strUri = "strUri"; 153 settingDataShare.isDataShareReady_ = false; 154 ASSERT_NE(settingDataShare.RegisterObserver(observer, strUri), RET_ERR); 155 settingDataShare.isDataShareReady_ = true; 156 ASSERT_NE(settingDataShare.RegisterObserver(observer, strUri), RET_ERR); 157 delete(observer); 158 observer = nullptr; 159 } 160 161 /** 162 * @tc.name: SettingDatashareTest_UnregisterObserver 163 * @tc.desc: Test UnregisterObserver 164 * @tc.type: FUNC 165 * @tc.require: 166 */ 167 HWTEST_F(SettingDatashareTest, SettingDatashareTest_UnregisterObserver, TestSize.Level1) 168 { 169 CALL_TEST_DEBUG; 170 SettingDataShare settingDataShare; 171 std::string key = "settingDateShare"; 172 sptr<SettingObserver> observer = new (std::nothrow) SettingObserver; 173 ASSERT_NE(observer, nullptr); 174 observer->key_ = "settingDateShare"; 175 std::string strUri = "strUri"; 176 settingDataShare.isDataShareReady_ = false; 177 ASSERT_NE(settingDataShare.UnregisterObserver(observer, strUri), RET_ERR); 178 settingDataShare.isDataShareReady_ = true; 179 ASSERT_NE(settingDataShare.UnregisterObserver(observer, strUri), RET_ERR); 180 delete(observer); 181 observer = nullptr; 182 } 183 184 /** 185 * @tc.name: SettingDatashareTest_PutStringValue 186 * @tc.desc: Test PutStringValue 187 * @tc.type: FUNC 188 * @tc.require: 189 */ 190 HWTEST_F(SettingDatashareTest, SettingDatashareTest_PutStringValue, TestSize.Level1) 191 { 192 CALL_TEST_DEBUG; 193 SettingDataShare settingDataShare; 194 std::string key = "settingDateShare"; 195 std::string value = "valueObj"; 196 bool needNotify = true; 197 ASSERT_NE(settingDataShare.PutStringValue(key, value, needNotify), RET_ERR); 198 } 199 200 /** 201 * @tc.name: SettingObserverTest_OnChange 202 * @tc.desc: Test OnChange 203 * @tc.type: FUNC 204 * @tc.require: 205 */ 206 HWTEST_F(SettingObserverTest, SettingObserverTest_OnChange, TestSize.Level1) 207 { 208 CALL_DEBUG_ENTER; 209 SettingObserver observer; 210 std::string key = "SettingObserver"; 211 observer.SetKey(key); 212 observer.update_ = nullptr; 213 ASSERT_NO_FATAL_FAILURE(observer.OnChange()); 214 } 215 216 /** 217 * @tc.name: SettingObserverTest_CreateDataShareHelper 218 * @tc.desc: Test CreateDataShareHelper 219 * @tc.type: FUNC 220 * @tc.require: 221 */ 222 HWTEST_F(SettingObserverTest, SettingObserverTest_CreateDataShareHelper, TestSize.Level1) 223 { 224 CALL_DEBUG_ENTER; 225 SettingDataShare settingDataShare; 226 std::string str = "createdatasharehelper"; 227 ASSERT_NO_FATAL_FAILURE(settingDataShare.CreateDataShareHelper(str)); 228 str = ""; 229 ASSERT_NO_FATAL_FAILURE(settingDataShare.CreateDataShareHelper(str)); 230 } 231 232 /** 233 * @tc.name: SettingObserverTest_AssembleUri 234 * @tc.desc: Test AssembleUri 235 * @tc.type: FUNC 236 * @tc.require: 237 */ 238 HWTEST_F(SettingObserverTest, SettingObserverTest_AssembleUri, TestSize.Level1) 239 { 240 CALL_DEBUG_ENTER; 241 SettingDataShare settingDataShare; 242 std::string key = ""; 243 std::string strui = ""; 244 ASSERT_NO_FATAL_FAILURE(settingDataShare.AssembleUri(key, strui)); 245 246 key = "close_fingerprint_nav_event_key"; 247 ASSERT_NO_FATAL_FAILURE(settingDataShare.AssembleUri(key, strui)); 248 249 strui = "AssembleUri"; 250 ASSERT_NO_FATAL_FAILURE(settingDataShare.AssembleUri(key, strui)); 251 } 252 253 /** 254 * @tc.name: SettingObserverTest_CheckIfSettingsDataReady 255 * @tc.desc: Test CheckIfSettingsDataReady 256 * @tc.type: FUNC 257 * @tc.require: 258 */ 259 HWTEST_F(SettingObserverTest, SettingObserverTest_CheckIfSettingsDataReady, TestSize.Level1) 260 { 261 CALL_DEBUG_ENTER; 262 SettingDataShare settingDataShare; 263 settingDataShare.isDataShareReady_ = true; 264 bool ret = false; 265 ret = settingDataShare.CheckIfSettingsDataReady(); 266 ASSERT_TRUE(ret); 267 268 settingDataShare.isDataShareReady_ = false; 269 ret = settingDataShare.CheckIfSettingsDataReady(); 270 ASSERT_TRUE(ret); 271 } 272 273 /** 274 * @tc.name: SettingObserverTest_CheckIfSettingsDataReady 275 * @tc.desc: Test CheckIfSettingsDataReady 276 * @tc.type: FUNC 277 * @tc.require: 278 */ 279 HWTEST_F(SettingObserverTest, CheckIfSettingsDataReadyTest1, TestSize.Level1) 280 { 281 CALL_DEBUG_ENTER; 282 SettingDataShare settingDataShare; 283 settingDataShare.isDataShareReady_ = true; 284 settingDataShare.remoteObj_ = nullptr; 285 ASSERT_NO_FATAL_FAILURE(settingDataShare.CheckIfSettingsDataReady()); 286 } 287 288 /** 289 * @tc.name: CheckIfSettingsUnregisterObserver20 290 * @tc.desc: Test CheckIfSettingsDataReady 291 * @tc.type: FUNC 292 * @tc.require: 293 */ 294 HWTEST_F(SettingObserverTest, CheckIfSettingsUnregisterObserver20, TestSize.Level1) 295 { 296 CALL_DEBUG_ENTER; 297 SettingDataShare settingDataShare; 298 settingDataShare.isDataShareReady_ = false; 299 settingDataShare.remoteObj_ = nullptr; 300 ASSERT_NO_FATAL_FAILURE(settingDataShare.CheckIfSettingsDataReady()); 301 } 302 } // namespace MMI 303 } // namespace OHOS