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 = nullptr; 150 ASSERT_EQ(settingDataShare.RegisterObserver(observer), RET_ERR); 151 } 152 153 /** 154 * @tc.name: SettingDatashareTest_UnregisterObserver 155 * @tc.desc: Test UnregisterObserver 156 * @tc.type: FUNC 157 * @tc.require: 158 */ 159 HWTEST_F(SettingDatashareTest, SettingDatashareTest_UnregisterObserver, TestSize.Level1) 160 { 161 CALL_TEST_DEBUG; 162 SettingDataShare settingDataShare; 163 std::string key = "settingDateShare"; 164 sptr<SettingObserver> observer = nullptr; 165 ASSERT_EQ(settingDataShare.UnregisterObserver(observer), RET_ERR); 166 167 observer = new (std::nothrow) SettingObserver; 168 ASSERT_NE(settingDataShare.UnregisterObserver(observer), RET_ERR); 169 } 170 171 /** 172 * @tc.name: SettingDatashareTest_PutStringValue 173 * @tc.desc: Test PutStringValue 174 * @tc.type: FUNC 175 * @tc.require: 176 */ 177 HWTEST_F(SettingDatashareTest, SettingDatashareTest_PutStringValue, TestSize.Level1) 178 { 179 CALL_TEST_DEBUG; 180 SettingDataShare settingDataShare; 181 std::string key = "settingDateShare"; 182 std::string value = "valueObj"; 183 bool needNotify = true; 184 ASSERT_NE(settingDataShare.PutStringValue(key, value, needNotify), RET_ERR); 185 } 186 187 /** 188 * @tc.name: SettingObserverTest_OnChange 189 * @tc.desc: Test OnChange 190 * @tc.type: FUNC 191 * @tc.require: 192 */ 193 HWTEST_F(SettingObserverTest, SettingObserverTest_OnChange, TestSize.Level1) 194 { 195 CALL_DEBUG_ENTER; 196 SettingObserver observer; 197 std::string key = "SettingObserver"; 198 observer.SetKey(key); 199 observer.update_ = nullptr; 200 ASSERT_NO_FATAL_FAILURE(observer.OnChange()); 201 } 202 } // namespace MMI 203 } // namespace OHOS