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 #include <gtest/gtest.h>
16 #include <unistd.h>
17 #include <memory>
18 #include "accesstoken_kit.h"
19 #include "ams_mgr_proxy.h"
20 #include "data_share_manager_impl.h"
21 #include "data_share_service_proxy.h"
22 #include "datashare_helper.h"
23 #include "datashare_log.h"
24 #include "datashare_template.h"
25 #include "hap_token_info.h"
26 #include "iservice_registry.h"
27 #include "system_ability_definition.h"
28 #include "token_setproc.h"
29 #include "datashare_errno.h"
30 #include "published_data_subscriber_manager.h"
31 #include "rdb_subscriber_manager.h"
32 #include "ishared_result_set_stub.h"
33 #include "message_parcel.h"
34 #include "ikvstore_data_service.h"
35 #include "shared_block.h"
36 #include "datashare_block_writer_impl.h"
37 #include "datashare_connection.h"
38
39 namespace OHOS {
40 namespace DataShare {
41 using namespace testing::ext;
42 using namespace OHOS::Security::AccessToken;
43
44 class AbnormalBranchTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47 static void TearDownTestCase(void);
48 void SetUp();
49 void TearDown();
50 };
51
SetUpTestCase(void)52 void AbnormalBranchTest::SetUpTestCase(void)
53 {
54 }
TearDownTestCase(void)55 void AbnormalBranchTest::TearDownTestCase(void)
56 {
57 }
SetUp(void)58 void AbnormalBranchTest::SetUp(void)
59 {
60 }
TearDown(void)61 void AbnormalBranchTest::TearDown(void)
62 {
63 }
64
65 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_shareBlock_Null_Test_001, TestSize.Level0)
66 {
67 LOG_INFO("AbnormalBranchTest_shareBlock_Null_Test_001::Start");
68 DataShareBlockWriterImpl impl;
69 int result = impl.AllocRow();
70 EXPECT_EQ(result, E_ERROR);
71 result = impl.Write(1);
72 EXPECT_EQ(result, E_ERROR);
73 int64_t intValue = 0;
74 result = impl.Write(1, intValue);
75 EXPECT_EQ(result, E_ERROR);
76 double doubleValue = 0.0;
77 result = impl.Write(1, doubleValue);
78 EXPECT_EQ(result, E_ERROR);
79 uint8_t *unitValue = nullptr;
80 result = impl.Write(1, unitValue, 0);
81 EXPECT_EQ(result, E_ERROR);
82 char *charValue = nullptr;
83 result = impl.Write(1, charValue, 0);
84 EXPECT_EQ(result, E_ERROR);
85 LOG_INFO("AbnormalBranchTest_shareBlock_Null_Test_001::End");
86 }
87
88 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_ResultSetStubNull_Test_001, TestSize.Level0)
89 {
90 LOG_INFO("AbnormalBranchTest_ResultSetStubNull_Test_001::Start");
91 ISharedResultSetStub stub(nullptr);
92 std::shared_ptr<DataShareResultSet> result = nullptr;
93 OHOS::MessageParcel parcel;
94 sptr<ISharedResultSet> resultSet = stub.CreateStub(result, parcel);
95 EXPECT_EQ(resultSet, nullptr);
96 LOG_INFO("AbnormalBranchTest_ResultSetStubNull_Test_001::End");
97 }
98
99 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_RegisterClientDeathObserverNull_Test_001, TestSize.Level0)
100 {
101 LOG_INFO("AbnormalBranchTest_RegisterClientDeathObserverNull_Test_001::Start");
102 DataShareKvServiceProxy proxy(nullptr);
103 std::string appId;
104 uint32_t result = proxy.RegisterClientDeathObserver(appId, nullptr);
105 EXPECT_EQ(result, -1);
106 LOG_INFO("AbnormalBranchTest_RegisterClientDeathObserverNull_Test_001::End");
107 }
108
109 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_mReadOnlyInvalid_Test_001, TestSize.Level0)
110 {
111 LOG_INFO("AbnormalBranchTest_mReadOnlyInvalid_Test_001::Start");
112 std::string name;
113 size_t size = 0;
114 bool readOnly = true;
115 AppDataFwk::SharedBlock temp(name, nullptr, size, readOnly);
116 int result = temp.Clear();
117 EXPECT_EQ(result, AppDataFwk::SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
118 result = temp.SetColumnNum(1);
119 EXPECT_EQ(result, AppDataFwk::SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
120 result = temp.AllocRow();
121 EXPECT_EQ(result, AppDataFwk::SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
122 result = temp.FreeLastRow();
123 EXPECT_EQ(result, AppDataFwk::SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
124 int64_t intValue = 0;
125 result = temp.PutLong(1, 1, intValue);
126 EXPECT_EQ(result, AppDataFwk::SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
127 double doubleValue = 0.0;
128 result = temp.PutDouble(1, 1, doubleValue);
129 EXPECT_EQ(result, AppDataFwk::SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
130 result = temp.PutNull(1, 1);
131 EXPECT_EQ(result, AppDataFwk::SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
132 result = temp.SetRawData(nullptr, size);
133 EXPECT_EQ(result, AppDataFwk::SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
134 LOG_INFO("AbnormalBranchTest_mReadOnlyInvalid_Test_001::End");
135 }
136
137 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_CreatorPossibleNull_Test_002, TestSize.Level0)
138 {
139 LOG_INFO("AbnormalBranchTest_CreatorPossibleNull_Test_002::Start");
140 std::string strUri;
141 CreateOptions options;
142 options.token_ = nullptr;
143 options.isProxy_ = false;
144 std::string bundleName;
145 std::shared_ptr<DataShareHelper> dataHelper = DataShare::DataShareHelper::Creator(strUri, options, bundleName);
146 EXPECT_EQ(dataHelper, nullptr);
147 LOG_INFO("AbnormalBranchTest_CreatorPossibleNull_Test_002::End");
148 }
149
150 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_AddObserversProxyNull_Test_001, TestSize.Level0)
151 {
152 LOG_INFO("AbnormalBranchTest_AddObserversProxyNull_Test_001::Start");
153 void *subscriber = nullptr;
154 std::shared_ptr<DataShareServiceProxy> proxy = nullptr;
155 const std::vector<std::string> uris = {};
156 int64_t subscriberId = 0;
__anon05ec3e4b0102(const PublishedDataChangeNode &changeNode)157 const PublishedDataCallback callback = [](const PublishedDataChangeNode &changeNode){};
158 std::vector<OperationResult> results = PublishedDataSubscriberManager::GetInstance().AddObservers(subscriber,
159 proxy, uris, subscriberId, callback);
160 EXPECT_EQ(results.size(), uris.size());
161 LOG_INFO("AbnormalBranchTest_AddObserversProxyNull_Test_001::End");
162 }
163
164 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_AddObserversProxyNull_Test_002, TestSize.Level0)
165 {
166 LOG_INFO("AbnormalBranchTest_AddObserversProxyNull_Test_002::Start");
167 void *subscriber = nullptr;
168 std::shared_ptr<DataShareServiceProxy> proxy = nullptr;
169 const std::vector<std::string> uris = {};
170 TemplateId templateId;
__anon05ec3e4b0202(const RdbChangeNode &changeNode)171 const RdbCallback callback = [](const RdbChangeNode &changeNode){};
172 std::vector<OperationResult> results = RdbSubscriberManager::GetInstance().AddObservers(subscriber, proxy, uris,
173 templateId, callback);
174 EXPECT_EQ(results.size(), uris.size());
175 LOG_INFO("AbnormalBranchTest_AddObserversProxyNull_Test_002::End");
176 }
177
178 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_DelObserversProxyNull_Test_001, TestSize.Level0)
179 {
180 LOG_INFO("AbnormalBranchTest_DelObserversProxyNull_Test_001::Start");
181 void *subscriber = nullptr;
182 std::shared_ptr<DataShareServiceProxy> proxy = nullptr;
183 const std::vector<std::string> uris = {};
184 int64_t subscriberId = 0;
185 std::vector<OperationResult> results = PublishedDataSubscriberManager::GetInstance().DelObservers(subscriber,
186 proxy);
187 EXPECT_EQ(results.size(), uris.size());
188 results = PublishedDataSubscriberManager::GetInstance().DelObservers(subscriber, proxy, uris, subscriberId);
189 EXPECT_EQ(results.size(), uris.size());
190 LOG_INFO("AbnormalBranchTest_DelObserversProxyNull_Test_001::End");
191 }
192
193 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_DelObserversProxyNull_Test_002, TestSize.Level0)
194 {
195 LOG_INFO("AbnormalBranchTest_DelObserversProxyNull_Test_002::Start");
196 void *subscriber = nullptr;
197 std::shared_ptr<DataShareServiceProxy> proxy = nullptr;
198 const std::vector<std::string> uris = {};
199 TemplateId templateId;
200 std::vector<OperationResult> results = RdbSubscriberManager::GetInstance().DelObservers(subscriber, proxy, uris,
201 templateId);
202 EXPECT_EQ(results.size(), uris.size());
203 results = RdbSubscriberManager::GetInstance().DelObservers(subscriber, proxy);
204 EXPECT_EQ(results.size(), uris.size());
205 LOG_INFO("AbnormalBranchTest_DelObserversProxyNull_Test_002::End");
206 }
207
208 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_EnableObserversProxyNull_Test_001, TestSize.Level0)
209 {
210 LOG_INFO("AbnormalBranchTest_EnableObserversProxyNull_Test_001::Start");
211 void *subscriber = nullptr;
212 std::shared_ptr<DataShareServiceProxy> proxy = nullptr;
213 const std::vector<std::string> uris = {};
214 int64_t subscriberId = 0;
215 std::vector<OperationResult> results = PublishedDataSubscriberManager::GetInstance().EnableObservers(subscriber,
216 proxy, uris, subscriberId);
217 EXPECT_EQ(results.size(), uris.size());
218 LOG_INFO("AbnormalBranchTest_EnableObserversProxyNull_Test_001::End");
219 }
220
221 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_EnableObserversProxyNull_Test_002, TestSize.Level0)
222 {
223 LOG_INFO("AbnormalBranchTest_EnableObserversProxyNull_Test_002::Start");
224 void *subscriber = nullptr;
225 std::shared_ptr<DataShareServiceProxy> proxy = nullptr;
226 const std::vector<std::string> uris = {};
227 TemplateId templateId;
228 std::vector<OperationResult> results = RdbSubscriberManager::GetInstance().EnableObservers(subscriber, proxy,
229 uris, templateId);
230 EXPECT_EQ(results.size(), uris.size());
231 LOG_INFO("AbnormalBranchTest_EnableObserversProxyNull_Test_002::End");
232 }
233
234 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_DisableObserversProxyNull_Test_001, TestSize.Level0)
235 {
236 LOG_INFO("AbnormalBranchTest_DisableObserversProxyNull_Test_001::Start");
237 void *subscriber = nullptr;
238 std::shared_ptr<DataShareServiceProxy> proxy = nullptr;
239 const std::vector<std::string> uris = {};
240 int64_t subscriberId = 0;
241 std::vector<OperationResult> results = PublishedDataSubscriberManager::GetInstance().DisableObservers(subscriber,
242 proxy, uris, subscriberId);
243 EXPECT_EQ(results.size(), uris.size());
244 LOG_INFO("AbnormalBranchTest_DisableObserversProxyNull_Test_001::End");
245 }
246
247 HWTEST_F(AbnormalBranchTest, AbnormalBranchTest_DisableObserversProxyNull_Test_002, TestSize.Level0)
248 {
249 LOG_INFO("AbnormalBranchTest_DisableObserversProxyNull_Test_002::Start");
250 void *subscriber = nullptr;
251 std::shared_ptr<DataShareServiceProxy> proxy = nullptr;
252 const std::vector<std::string> uris = {};
253 TemplateId templateId;
254 std::vector<OperationResult> results = RdbSubscriberManager::GetInstance().DisableObservers(subscriber, proxy,
255 uris, templateId);
256 EXPECT_EQ(results.size(), uris.size());
257 LOG_INFO("AbnormalBranchTest_DisableObserversProxyNull_Test_002::End");
258 }
259
260 HWTEST_F(AbnormalBranchTest, PublishDelObserversTest001, TestSize.Level0)
261 {
262 LOG_INFO("PublishDelObserversTest001::Start");
263 void *subscriber = nullptr;
264 auto proxy = DataShareManagerImpl::GetServiceProxy();
265 std::vector<std::string> uris = {};
266 std::string uri = "datashare:///com.test/db0/tbl0";
267 uris.push_back(uri);
268 int64_t subscriberId = 0;
269 std::vector<OperationResult> results = PublishedDataSubscriberManager::GetInstance().DisableObservers(subscriber,
270 nullptr, uris, subscriberId);
271 EXPECT_EQ(results.size(), 0);
272 results = PublishedDataSubscriberManager::GetInstance().DelObservers(subscriber,
273 proxy, uris, subscriberId);
274 EXPECT_EQ(results.size(), uris.size());
275 proxy = nullptr;
276 PublishedDataSubscriberManager::GetInstance().RecoverObservers(proxy);
277 LOG_INFO("PublishDelObserversTest001::End");
278 }
279
280 HWTEST_F(AbnormalBranchTest, PublishedDataSubscriberManagerOperatorTest001, TestSize.Level0)
281 {
282 LOG_INFO("PublishedDataSubscriberManagerOperatorTest001::Start");
__anon05ec3e4b0302(const PublishedDataChangeNode &changeNode)283 const PublishedDataCallback callback = [](const PublishedDataChangeNode &changeNode){};
284 PublishedDataObserver ob(callback);
285 PublishedDataObserver obCompare(callback);
286 EXPECT_TRUE(ob != obCompare);
287 EXPECT_FALSE(ob == obCompare);
288 LOG_INFO("PublishedDataSubscriberManagerOperatorTest001::End");
289 }
290
291 HWTEST_F(AbnormalBranchTest, RdbDelObserversTest001, TestSize.Level0)
292 {
293 LOG_INFO("RdbDelObserversTest001::Start");
294 void *subscriber = nullptr;
295 auto proxy = DataShareManagerImpl::GetServiceProxy();
296 std::vector<std::string> uris = {};
297 std::string uri = "datashare:///com.test/db0/tbl0";
298 uris.push_back(uri);
299 TemplateId templateId;
300 std::vector<OperationResult> results = RdbSubscriberManager::GetInstance().DelObservers(subscriber,
301 proxy, uris, templateId);
302 EXPECT_EQ(results.size(), uris.size());
303 proxy = nullptr;
304 PublishedDataSubscriberManager::GetInstance().RecoverObservers(proxy);
305 LOG_INFO("RdbDelObserversTest001::End");
306 }
307
308 HWTEST_F(AbnormalBranchTest, RdbDisableObserversTest001, TestSize.Level0)
309 {
310 LOG_INFO("RdbDisableObserversTest001::Start");
311 void *subscriber = nullptr;
312 auto proxy = DataShareManagerImpl::GetServiceProxy();
313 std::vector<std::string> uris = {};
314 std::string uri = "datashare:///com.test/db0/tbl0";
315 uris.push_back(uri);
316 TemplateId templateId;
317 std::vector<OperationResult> results = RdbSubscriberManager::GetInstance().DisableObservers(subscriber,
318 nullptr, uris, templateId);
319 EXPECT_EQ(results.size(), 0);
320 results = RdbSubscriberManager::GetInstance().DisableObservers(subscriber,
321 proxy, uris, templateId);
322 EXPECT_EQ(results.size(), uris.size());
323 proxy = nullptr;
324 RdbSubscriberManager::GetInstance().RecoverObservers(proxy);
325 LOG_INFO("RdbDisableObserversTest001::End");
326 }
327
328 HWTEST_F(AbnormalBranchTest, RdbSubscriberManagerOperatorTest001, TestSize.Level0)
329 {
330 LOG_INFO("RdbSubscriberManagerOperatorTest001::Start");
__anon05ec3e4b0402(const RdbChangeNode &changeNode)331 const RdbCallback callback = [](const RdbChangeNode &changeNode){};
332 RdbObserver ob(callback);
333 RdbObserver obCompare(callback);
334 EXPECT_TRUE(ob != obCompare);
335 EXPECT_FALSE(ob == obCompare);
336 LOG_INFO("RdbSubscriberManagerOperatorTest001::End");
337 }
338
339 HWTEST_F(AbnormalBranchTest, RegisterClientDeathObserverTest001, TestSize.Level0)
340 {
341 LOG_INFO("RegisterClientDeathObserverTest001::Start");\
342 auto datashareManager = new DataShareManagerImpl();
343 datashareManager->dataMgrService_ = nullptr;
344 datashareManager->bundleName_ = "";
345 datashareManager->clientDeathObserverPtr_ = nullptr;
346 datashareManager->RegisterClientDeathObserver();
347 datashareManager->dataMgrService_ = datashareManager->GetDistributedDataManager();
348 EXPECT_NE(datashareManager->dataMgrService_, nullptr);
349 datashareManager->RegisterClientDeathObserver();
350 EXPECT_EQ(datashareManager->clientDeathObserverPtr_, nullptr);
351 datashareManager->bundleName_ = "com.testbundlename";
352 datashareManager->RegisterClientDeathObserver();
353 EXPECT_NE(datashareManager->clientDeathObserverPtr_, nullptr);
354 datashareManager->RegisterClientDeathObserver();
355 LOG_INFO("RegisterClientDeathObserverTest001::End");
356 }
357
358 HWTEST_F(AbnormalBranchTest, AmsMgrProxyOnProxyDiedTest001, TestSize.Level0)
359 {
360 LOG_INFO("AmsMgrProxyOnProxyDiedTest001::Start");\
361 AmsMgrProxy* proxy = new AmsMgrProxy();
362 proxy->sa_ = nullptr;
363 proxy->proxy_ = nullptr;
364 proxy->OnProxyDied();
365 delete proxy;
366 proxy = new AmsMgrProxy();
367 proxy->sa_ = nullptr;
368 proxy->proxy_ = nullptr;
369 proxy->ConnectSA();
370 EXPECT_NE(proxy->sa_, nullptr);
371 EXPECT_NE(proxy->proxy_, nullptr);
372 EXPECT_NE(proxy->deathRecipient_, nullptr);
373 proxy->OnProxyDied();
374 delete proxy;
375 LOG_INFO("AmsMgrProxyOnProxyDiedTest001::End");
376 }
377
378 HWTEST_F(AbnormalBranchTest, DataShareServiceProxySubscribeRdbDataTest001, TestSize.Level0)
379 {
380 LOG_INFO("DataShareServiceProxySubscribeRdbDataTest001::Start");\
381 AmsMgrProxy* proxy = new AmsMgrProxy();
382 proxy->sa_ = nullptr;
383 proxy->proxy_ = nullptr;
384 proxy->OnProxyDied();
385 delete proxy;
386 proxy = new AmsMgrProxy();
387 proxy->sa_ = nullptr;
388 proxy->proxy_ = nullptr;
389 proxy->ConnectSA();
390 EXPECT_NE(proxy->sa_, nullptr);
391 EXPECT_NE(proxy->proxy_, nullptr);
392 EXPECT_NE(proxy->deathRecipient_, nullptr);
393 proxy->OnProxyDied();
394 delete proxy;
395 LOG_INFO("DataShareServiceProxySubscribeRdbDataTest001::End");
396 }
397
398 HWTEST_F(AbnormalBranchTest, SubscribeRdbDataTest001, TestSize.Level0)
399 {
400 LOG_INFO("EnableSubscribePublishedDataTest001::Start");
401 std::vector<std::string> uris = {};
402 TemplateId templateId;
403 sptr<IDataProxyRdbObserver> observer = OHOS::sptr<IDataProxyRdbObserver>(nullptr);
404 auto proxy = DataShareManagerImpl::GetServiceProxy();
405 auto resultset = proxy->SubscribeRdbData(uris, templateId, observer);
406 EXPECT_EQ(resultset.size(), 0);
407 LOG_INFO("EnableSubscribePublishedDataTest001::End");
408 }
409
410 HWTEST_F(AbnormalBranchTest, SubscribePublishedDataTest001, TestSize.Level0)
411 {
412 LOG_INFO("SubscribePublishedDataTest001::Start");
413 std::vector<std::string> uris = {};
414 int64_t subscriberId = 1;
415 sptr<IDataProxyPublishedDataObserver> observer = OHOS::sptr<IDataProxyPublishedDataObserver>(nullptr);
416 auto proxy = DataShareManagerImpl::GetServiceProxy();
417 auto resultset = proxy->SubscribePublishedData(uris, subscriberId, observer);
418 EXPECT_EQ(resultset.size(), 0);
419 LOG_INFO("SubscribePublishedDataTest001::End");
420 }
421 } // namespace DataShare
422 } // namespace OHOS