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