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 observer->key_ = "settingDateShare"; 151 std::string strUri = "strUri"; 152 settingDataShare.isDataShareReady_ = false; 153 ASSERT_NE(settingDataShare.RegisterObserver(observer, strUri), RET_ERR); 154 settingDataShare.isDataShareReady_ = true; 155 ASSERT_NE(settingDataShare.RegisterObserver(observer, strUri), RET_ERR); 156 } 157 158 /** 159 * @tc.name: SettingDatashareTest_UnregisterObserver 160 * @tc.desc: Test UnregisterObserver 161 * @tc.type: FUNC 162 * @tc.require: 163 */ 164 HWTEST_F(SettingDatashareTest, SettingDatashareTest_UnregisterObserver, TestSize.Level1) 165 { 166 CALL_TEST_DEBUG; 167 SettingDataShare settingDataShare; 168 std::string key = "settingDateShare"; 169 sptr<SettingObserver> observer = new (std::nothrow) SettingObserver; 170 observer->key_ = "settingDateShare"; 171 std::string strUri = "strUri"; 172 settingDataShare.isDataShareReady_ = false; 173 ASSERT_NE(settingDataShare.UnregisterObserver(observer, strUri), RET_ERR); 174 settingDataShare.isDataShareReady_ = true; 175 ASSERT_NE(settingDataShare.UnregisterObserver(observer, strUri), RET_ERR); 176 } 177 178 /** 179 * @tc.name: SettingDatashareTest_PutStringValue 180 * @tc.desc: Test PutStringValue 181 * @tc.type: FUNC 182 * @tc.require: 183 */ 184 HWTEST_F(SettingDatashareTest, SettingDatashareTest_PutStringValue, TestSize.Level1) 185 { 186 CALL_TEST_DEBUG; 187 SettingDataShare settingDataShare; 188 std::string key = "settingDateShare"; 189 std::string value = "valueObj"; 190 bool needNotify = true; 191 ASSERT_NE(settingDataShare.PutStringValue(key, value, needNotify), RET_ERR); 192 } 193 194 /** 195 * @tc.name: SettingObserverTest_OnChange 196 * @tc.desc: Test OnChange 197 * @tc.type: FUNC 198 * @tc.require: 199 */ 200 HWTEST_F(SettingObserverTest, SettingObserverTest_OnChange, TestSize.Level1) 201 { 202 CALL_DEBUG_ENTER; 203 SettingObserver observer; 204 std::string key = "SettingObserver"; 205 observer.SetKey(key); 206 observer.update_ = nullptr; 207 ASSERT_NO_FATAL_FAILURE(observer.OnChange()); 208 } 209 210 /** 211 * @tc.name: SettingObserverTest_CreateDataShareHelper 212 * @tc.desc: Test CreateDataShareHelper 213 * @tc.type: FUNC 214 * @tc.require: 215 */ 216 HWTEST_F(SettingObserverTest, SettingObserverTest_CreateDataShareHelper, TestSize.Level1) 217 { 218 CALL_DEBUG_ENTER; 219 SettingDataShare settingDataShare; 220 std::string str = "createdatasharehelper"; 221 ASSERT_NO_FATAL_FAILURE(settingDataShare.CreateDataShareHelper(str)); 222 str = ""; 223 ASSERT_NO_FATAL_FAILURE(settingDataShare.CreateDataShareHelper(str)); 224 } 225 226 /** 227 * @tc.name: SettingObserverTest_AssembleUri 228 * @tc.desc: Test AssembleUri 229 * @tc.type: FUNC 230 * @tc.require: 231 */ 232 HWTEST_F(SettingObserverTest, SettingObserverTest_AssembleUri, TestSize.Level1) 233 { 234 CALL_DEBUG_ENTER; 235 SettingDataShare settingDataShare; 236 std::string key = ""; 237 std::string strui = ""; 238 ASSERT_NO_FATAL_FAILURE(settingDataShare.AssembleUri(key, strui)); 239 240 key = "close_fingerprint_nav_event_key"; 241 ASSERT_NO_FATAL_FAILURE(settingDataShare.AssembleUri(key, strui)); 242 243 strui = "AssembleUri"; 244 ASSERT_NO_FATAL_FAILURE(settingDataShare.AssembleUri(key, strui)); 245 } 246 247 /** 248 * @tc.name: SettingObserverTest_CheckIfSettingsDataReady 249 * @tc.desc: Test CheckIfSettingsDataReady 250 * @tc.type: FUNC 251 * @tc.require: 252 */ 253 HWTEST_F(SettingObserverTest, SettingObserverTest_CheckIfSettingsDataReady, TestSize.Level1) 254 { 255 CALL_DEBUG_ENTER; 256 SettingDataShare settingDataShare; 257 settingDataShare.isDataShareReady_ = true; 258 bool ret = false; 259 ret = settingDataShare.CheckIfSettingsDataReady(); 260 ASSERT_TRUE(ret); 261 262 settingDataShare.isDataShareReady_ = false; 263 ret = settingDataShare.CheckIfSettingsDataReady(); 264 ASSERT_TRUE(ret); 265 } 266 } // namespace MMI 267 } // namespace OHOS