1 /*
2 * Copyright (C) 2021-2022 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
18 #include <condition_variable>
19
20 #include "abs_shared_result_set.h"
21 #include "accesstoken_kit.h"
22 #include "data_ability_observer_interface.h"
23 #include "dataobs_mgr_changeinfo.h"
24 #include "datashare_connection.h"
25 #include "datashare_helper.h"
26 #include "datashare_log.h"
27 #include "ext_special_controller.h"
28 #include "extension_manager_proxy.h"
29 #include "general_controller.h"
30 #include "general_controller_provider_impl.h"
31 #include "hap_token_info.h"
32 #include "iservice_registry.h"
33 #include "rdb_data_ability_utils.h"
34 #include "system_ability_definition.h"
35 #include "token_setproc.h"
36
37 namespace OHOS {
38 namespace DataShare {
39 using namespace testing::ext;
40 using namespace OHOS::Security::AccessToken;
41
42 class ControllerTest : public testing::Test {
43 public:
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
46 void SetUp();
47 void TearDown();
48 };
49
SetUpTestCase(void)50 void ControllerTest::SetUpTestCase(void) {}
TearDownTestCase(void)51 void ControllerTest::TearDownTestCase(void) {}
SetUp(void)52 void ControllerTest::SetUp(void) {}
TearDown(void)53 void ControllerTest::TearDown(void) {}
54
55 HWTEST_F(ControllerTest, ControllerTest_ProviderImplInsertTest_001, TestSize.Level0)
56 {
57 LOG_INFO("ControllerTest_ProviderImplInsertTest_001::Start");
58 Uri uri("");
59 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
60 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
61 DataShare::DataShareValuesBucket valuesBucket;
62 double valueD1 = 20.07;
63 valuesBucket.Put("phoneNumber", valueD1);
64 int result = tempGenConProImp->Insert(uri, valuesBucket);
65 EXPECT_EQ((result < 0), true);
66 LOG_INFO("ControllerTest_ProviderImplInsertTest_001::End");
67 }
68
69 HWTEST_F(ControllerTest, ControllerTest_ProviderImplInsertTest_002, TestSize.Level0)
70 {
71 LOG_INFO("ControllerTest_ProviderImplInsertTest_002::Start");
72 Uri uri("");
73 sptr<DataShare::DataShareConnection> connection =
74 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
75 auto dataShareConnection =
__anonb8f763160102(const auto *) 76 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
77 holder->DisconnectDataShareExtAbility();
78 });
79 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
80 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
81 DataShare::DataShareValuesBucket valuesBucket;
82 double valueD1 = 20.07;
83 valuesBucket.Put("phoneNumber", valueD1);
84 int result = tempGenConProImp->Insert(uri, valuesBucket);
85 EXPECT_EQ((result < 0), true);
86 LOG_INFO("ControllerTest_ProviderImplInsertTest_002::End");
87 }
88
89 HWTEST_F(ControllerTest, ControllerTest_ProviderImplUpdateTest_001, TestSize.Level0)
90 {
91 LOG_INFO("ControllerTest_ProviderImplUpdateTest_001::Start");
92 Uri uri("");
93 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
94 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
95 DataShare::DataSharePredicates predicates;
96 predicates.EqualTo("name", "Controller_Test001");
97 DataShare::DataShareValuesBucket valuesBucket;
98 valuesBucket.Put("name", "Controller_Test002");
99 int result = tempGenConProImp->Update(uri, predicates, valuesBucket);
100 EXPECT_EQ((result < 0), true);
101 LOG_INFO("ControllerTest_ProviderImplUpdateTest_001::End");
102 }
103
104 HWTEST_F(ControllerTest, ControllerTest_ProviderImplUpdateTest_002, TestSize.Level0)
105 {
106 LOG_INFO("ControllerTest_ProviderImplUpdateTest_002::Start");
107 Uri uri("");
108 sptr<DataShare::DataShareConnection> connection =
109 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
110 auto dataShareConnection =
__anonb8f763160202(const auto *) 111 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
112 holder->DisconnectDataShareExtAbility();
113 });
114 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
115 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
116 DataShare::DataSharePredicates predicates;
117 predicates.EqualTo("name", "Controller_Test001");
118 DataShare::DataShareValuesBucket valuesBucket;
119 valuesBucket.Put("name", "Controller_Test002");
120 int result = tempGenConProImp->Update(uri, predicates, valuesBucket);
121 EXPECT_EQ((result < 0), true);
122 LOG_INFO("ControllerTest_ProviderImplUpdateTest_002::End");
123 }
124
125 HWTEST_F(ControllerTest, ControllerTest_ProviderImplDeleteTest_001, TestSize.Level0)
126 {
127 LOG_INFO("ControllerTest_ProviderImplDeleteTest_001::Start");
128 Uri uri("");
129 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
130 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
131 DataShare::DataSharePredicates predicates;
132 predicates.EqualTo("name", "Controller_Test001");
133 int result = tempGenConProImp->Delete(uri, predicates);
134 EXPECT_EQ((result < 0), true);
135 LOG_INFO("ControllerTest_ProviderImplDeleteTest_001::End");
136 }
137
138 HWTEST_F(ControllerTest, ControllerTest_ProviderImplDeleteTest_002, TestSize.Level0)
139 {
140 LOG_INFO("ControllerTest_ProviderImplDeleteTest_002::Start");
141 Uri uri("");
142 sptr<DataShare::DataShareConnection> connection =
143 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
144 auto dataShareConnection =
__anonb8f763160302(const auto *) 145 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
146 holder->DisconnectDataShareExtAbility();
147 });
148 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
149 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
150 DataShare::DataSharePredicates predicates;
151 predicates.EqualTo("name", "Controller_Test001");
152 int result = tempGenConProImp->Delete(uri, predicates);
153 EXPECT_EQ((result < 0), true);
154 LOG_INFO("ControllerTest_ProviderImplDeleteTest_002::End");
155 }
156
157 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplInsertExTest_001, TestSize.Level0)
158 {
159 LOG_INFO("Generalcontroller_ServiceImplInsertExTest_001::Start");
160 Uri uri("");
161 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
162 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
163 DataShare::DataShareValuesBucket valuesBucket;
164 double valueD1 = 20.07;
165 valuesBucket.Put("phoneNumber", valueD1);
166 std::pair result = tempGenConProImp->InsertEx(uri, valuesBucket);
167 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
168 EXPECT_EQ(result.second, 0);
169 LOG_INFO("Generalcontroller_ServiceImplInsertExTest_001::End");
170 }
171
172 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplInsertExTest_002, TestSize.Level0)
173 {
174 LOG_INFO("Generalcontroller_ServiceImplInsertExTest_002::Start");
175 Uri uri("");
176 sptr<DataShare::DataShareConnection> connection =
177 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
178 auto dataShareConnection =
__anonb8f763160402(const auto *) 179 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
180 holder->DisconnectDataShareExtAbility();
181 });
182 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
183 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
184 DataShare::DataShareValuesBucket valuesBucket;
185 double valueD1 = 20.07;
186 valuesBucket.Put("phoneNumber", valueD1);
187 std::pair result = tempGenConProImp->InsertEx(uri, valuesBucket);
188 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
189 EXPECT_EQ(result.second, 0);
190 LOG_INFO("Generalcontroller_ServiceImplInsertExTest_002::End");
191 }
192
193 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplUpdateExTest_001, TestSize.Level0)
194 {
195 LOG_INFO("Generalcontroller_ServiceImplUpdateExTest_001::Start");
196 Uri uri("");
197 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
198 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
199 DataShare::DataSharePredicates predicates;
200 predicates.EqualTo("name", "Controller_Test001");
201 DataShare::DataShareValuesBucket valuesBucket;
202 double valueD1 = 20.07;
203 valuesBucket.Put("phoneNumber", valueD1);
204 std::pair result = tempGenConProImp->UpdateEx(uri, predicates, valuesBucket);
205 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
206 EXPECT_EQ(result.second, 0);
207 LOG_INFO("Generalcontroller_ServiceImplUpdateExTest_001::End");
208 }
209
210 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplUpdateExTest_002, TestSize.Level0)
211 {
212 LOG_INFO("Generalcontroller_ServiceImplUpdateExTest_001::Start");
213 Uri uri("");
214 sptr<DataShare::DataShareConnection> connection =
215 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
216 auto dataShareConnection =
__anonb8f763160502(const auto *) 217 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
218 holder->DisconnectDataShareExtAbility();
219 });
220 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
221 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
222 DataShare::DataSharePredicates predicates;
223 predicates.EqualTo("name", "Controller_Test001");
224 DataShare::DataShareValuesBucket valuesBucket;
225 double valueD1 = 20.07;
226 valuesBucket.Put("phoneNumber", valueD1);
227 std::pair result = tempGenConProImp->UpdateEx(uri, predicates, valuesBucket);
228 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
229 EXPECT_EQ(result.second, 0);
230 LOG_INFO("Generalcontroller_ServiceImplUpdateExTest_002::End");
231 }
232
233 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplDeleteExTest_001, TestSize.Level0)
234 {
235 LOG_INFO("Generalcontroller_ServiceImplDeleteExTest_001::Start");
236 Uri uri("");
237 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
238 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
239 DataShare::DataSharePredicates predicates;
240 predicates.EqualTo("name", "Controller_Test001");
241 std::pair result = tempGenConProImp->DeleteEx(uri, predicates);
242 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
243 EXPECT_EQ(result.second, 0);
244 LOG_INFO("Generalcontroller_ServiceImplDeleteExTest_001::End");
245 }
246
247 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplDeleteExTest_002, TestSize.Level0)
248 {
249 LOG_INFO("Generalcontroller_ServiceImplDeleteExTest_002::Start");
250 Uri uri("");
251 sptr<DataShare::DataShareConnection> connection =
252 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
253 auto dataShareConnection =
__anonb8f763160602(const auto *) 254 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
255 holder->DisconnectDataShareExtAbility();
256 });
257 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
258 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
259 DataShare::DataSharePredicates predicates;
260 predicates.EqualTo("name", "Controller_Test001");
261 std::pair result = tempGenConProImp->DeleteEx(uri, predicates);
262 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
263 EXPECT_EQ(result.second, 0);
264 LOG_INFO("Generalcontroller_ServiceImplDeleteExTest_002::End");
265 }
266
267 HWTEST_F(ControllerTest, ControllerTest_ProviderImplQueryTest_001, TestSize.Level0)
268 {
269 LOG_INFO("ControllerTest_ProviderImplQueryTest_001::Start");
270 Uri uri("");
271 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
272 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
273 DataShare::DataSharePredicates predicates;
274 predicates.EqualTo("name", "Controller_Test001");
275 vector<string> columns;
276 DatashareBusinessError error;
277 auto result = tempGenConProImp->Query(uri, predicates, columns, error);
278 EXPECT_EQ(result, nullptr);
279 LOG_INFO("ControllerTest_ProviderImplQueryTest_001::End");
280 }
281
282 HWTEST_F(ControllerTest, ControllerTest_ProviderImplQueryTest_002, TestSize.Level0)
283 {
284 LOG_INFO("ControllerTest_ProviderImplQueryTest_002::Start");
285 Uri uri("");
286 sptr<DataShare::DataShareConnection> connection =
287 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
288 auto dataShareConnection =
__anonb8f763160702(const auto *) 289 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
290 holder->DisconnectDataShareExtAbility();
291 });
292 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
293 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
294 DataShare::DataSharePredicates predicates;
295 predicates.EqualTo("name", "Controller_Test001");
296 vector<string> columns;
297 DatashareBusinessError error;
298 auto result = tempGenConProImp->Query(uri, predicates, columns, error);
299 EXPECT_EQ(result, nullptr);
300 LOG_INFO("ControllerTest_ProviderImplQueryTest_002::End");
301 }
302
303 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplRegisterObserverTest_001, TestSize.Level0)
304 {
305 LOG_INFO("Generalcontroller_ServiceImplRegisterObserverTest_001::Start");
306 Uri uri("");
307 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
308 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
309 sptr<AAFwk::IDataAbilityObserver> dataObserver;
310 tempGenConProImp->RegisterObserver(uri, dataObserver);
311 EXPECT_EQ(uri, Uri(""));
312 LOG_INFO("Generalcontroller_ServiceImplRegisterObserverTest_001::End");
313 }
314
315 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplRegisterObserverTest_002, TestSize.Level0)
316 {
317 LOG_INFO("Generalcontroller_ServiceImplRegisterObserverTest_002::Start");
318 Uri uri("");
319 sptr<DataShare::DataShareConnection> connection =
320 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
321 auto dataShareConnection =
__anonb8f763160802(const auto *) 322 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
323 holder->DisconnectDataShareExtAbility();
324 });
325 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
326 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
327 sptr<AAFwk::IDataAbilityObserver> dataObserver;
328 tempGenConProImp->RegisterObserver(uri, dataObserver);
329 EXPECT_EQ(uri, Uri(""));
330 LOG_INFO("Generalcontroller_ServiceImplRegisterObserverTest_002::End");
331 }
332
333 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplUnregisterObserverTest_001, TestSize.Level0)
334 {
335 LOG_INFO("Generalcontroller_ServiceImplUnregisterObserverTest_001::Start");
336 Uri uri("");
337 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
338 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
339 sptr<AAFwk::IDataAbilityObserver> dataObserver;
340 tempGenConProImp->UnregisterObserver(uri, dataObserver);
341 EXPECT_EQ(uri, Uri(""));
342 LOG_INFO("Generalcontroller_ServiceImplUnregisterObserverTest_001::End");
343 }
344
345 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplUnregisterObserverTest_002, TestSize.Level0)
346 {
347 LOG_INFO("Generalcontroller_ServiceImplUnregisterObserverTest_002::Start");
348 Uri uri("");
349 sptr<DataShare::DataShareConnection> connection =
350 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
351 auto dataShareConnection =
__anonb8f763160902(const auto *) 352 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
353 holder->DisconnectDataShareExtAbility();
354 });
355 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
356 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
357 sptr<AAFwk::IDataAbilityObserver> dataObserver;
358 tempGenConProImp->UnregisterObserver(uri, dataObserver);
359 EXPECT_EQ(uri, Uri(""));
360 LOG_INFO("Generalcontroller_ServiceImplUnregisterObserverTest_002::End");
361 }
362
363 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplNotifyChangeTest_001, TestSize.Level0)
364 {
365 LOG_INFO("Generalcontroller_ServiceImplNotifyChangeTest_001::Start");
366 Uri uri("");
367 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
368 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
369 tempGenConProImp->NotifyChange(uri);
370 EXPECT_EQ(uri, Uri(""));
371 LOG_INFO("Generalcontroller_ServiceImplNotifyChangeTest_001::End");
372 }
373
374 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplNotifyChangeTest_002, TestSize.Level0)
375 {
376 LOG_INFO("Generalcontroller_ServiceImplNotifyChangeTest_002::Start");
377 Uri uri("");
378 sptr<DataShare::DataShareConnection> connection =
379 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
380 auto dataShareConnection =
__anonb8f763160a02(const auto *) 381 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
382 holder->DisconnectDataShareExtAbility();
383 });
384 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
385 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
386 tempGenConProImp->NotifyChange(uri);
387 EXPECT_EQ(uri, Uri(""));
388 LOG_INFO("Generalcontroller_ServiceImplNotifyChangeTest_002::End");
389 }
390
391 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerOpenFileTest_001, TestSize.Level0)
392 {
393 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileTest_001::Start");
394 Uri uri("");
395 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
396 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
397 std::string mode = "test001";
398 int result = tempExtSpeCon->OpenFile(uri, mode);
399 EXPECT_EQ((result < 0), true);
400 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileTest_001::End");
401 }
402
403 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerOpenFileTest_002, TestSize.Level0)
404 {
405 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileTest_002::Start");
406 Uri uri("");
407 sptr<DataShare::DataShareConnection> connection =
408 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
409 auto dataShareConnection =
__anonb8f763160b02(const auto *) 410 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
411 holder->DisconnectDataShareExtAbility();
412 });
413 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
414 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
415 std::string mode = "test001";
416 int result = tempExtSpeCon->OpenFile(uri, mode);
417 EXPECT_EQ((result < 0), true);
418 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileTest_002::End");
419 }
420
421 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerOpenRawFileTest_001, TestSize.Level0)
422 {
423 LOG_INFO("ControllerTest_ExtSpecialControllerOpenRawFileTest_001::Start");
424 Uri uri("");
425 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
426 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
427 std::string mode = "test001";
428 int result = tempExtSpeCon->OpenRawFile(uri, mode);
429 EXPECT_EQ((result < 0), true);
430 LOG_INFO("ControllerTest_ExtSpecialControllerOpenRawFileTest_001::End");
431 }
432
433 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControlleOpenRawFileTest_002, TestSize.Level0)
434 {
435 LOG_INFO("ControllerTest_ExtSpecialControllerOpenRawFileTest_002::Start");
436 Uri uri("");
437 sptr<DataShare::DataShareConnection> connection =
438 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
439 auto dataShareConnection =
__anonb8f763160c02(const auto *) 440 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
441 holder->DisconnectDataShareExtAbility();
442 });
443 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
444 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
445 std::string mode = "test001";
446 int result = tempExtSpeCon->OpenRawFile(uri, mode);
447 EXPECT_EQ((result < 0), true);
448 LOG_INFO("ControllerTest_ExtSpecialControllerOpenRawFileTest_002::End");
449 }
450
451 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerGetTypeTest_001, TestSize.Level0)
452 {
453 LOG_INFO("ControllerTest_ExtSpecialControllerGetTypeTest_001::Start");
454 Uri uri("");
455 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
456 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
457 std::string result = tempExtSpeCon->GetType(uri);
458 EXPECT_EQ(result, "");
459 LOG_INFO("ControllerTest_ExtSpecialControllerGetTypeTest_001::End");
460 }
461
462 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControlleGetTypeTest_002, TestSize.Level0)
463 {
464 LOG_INFO("ControllerTest_ExtSpecialControllerGetTypeTest_002::Start");
465 Uri uri("");
466 sptr<DataShare::DataShareConnection> connection =
467 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
468 auto dataShareConnection =
__anonb8f763160d02(const auto *) 469 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
470 holder->DisconnectDataShareExtAbility();
471 });
472 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
473 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
474 std::string result = tempExtSpeCon->GetType(uri);
475 EXPECT_EQ(result, "");
476 LOG_INFO("ControllerTest_ExtSpecialControllerGetTypeTest_002::End");
477 }
478
479 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchInsertTest_001, TestSize.Level0)
480 {
481 LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_001::Start");
482 Uri uri("");
483 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
484 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
485 DataShare::DataShareValuesBucket valuesBucket1;
486 valuesBucket1.Put("name", "dataShareTest006");
487 valuesBucket1.Put("phoneNumber", 20.6);
488 DataShare::DataShareValuesBucket valuesBucket2;
489 valuesBucket2.Put("name", "dataShareTest007");
490 valuesBucket2.Put("phoneNumber", 20.5);
491 std::vector<DataShare::DataShareValuesBucket> values;
492 values.push_back(valuesBucket1);
493 values.push_back(valuesBucket2);
494 int result = tempExtSpeCon->BatchInsert(uri, values);
495 EXPECT_EQ((result < 0), true);
496 LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_001::End");
497 }
498
499 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchInsertTest_002, TestSize.Level0)
500 {
501 LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_002::Start");
502 Uri uri("");
503 sptr<DataShare::DataShareConnection> connection =
504 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
505 auto dataShareConnection =
__anonb8f763160e02(const auto *) 506 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
507 holder->DisconnectDataShareExtAbility();
508 });
509 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
510 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
511 DataShare::DataShareValuesBucket valuesBucket1;
512 valuesBucket1.Put("name", "dataShareTest006");
513 valuesBucket1.Put("phoneNumber", 20.6);
514 DataShare::DataShareValuesBucket valuesBucket2;
515 valuesBucket2.Put("name", "dataShareTest007");
516 valuesBucket2.Put("phoneNumber", 20.5);
517 std::vector<DataShare::DataShareValuesBucket> values;
518 values.push_back(valuesBucket1);
519 values.push_back(valuesBucket2);
520 int result = tempExtSpeCon->BatchInsert(uri, values);
521 EXPECT_EQ((result < 0), true);
522 LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_002::End");
523 }
524
525 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchUpdateTest_001, TestSize.Level0)
526 {
527 LOG_INFO("ControllerTest_ExtSpecialControllerBatchUpdateTest_001::Start");
528 Uri uri("");
529 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
530 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
531 DataShare::UpdateOperations operations;
532 std::vector<DataShare::BatchUpdateResult> results;
533 int result = tempExtSpeCon->BatchUpdate(operations, results);
534 EXPECT_EQ(result, -1);
535 LOG_INFO("ControllerTest_ExtSpecialControllerBatchUpdateTest_001::End");
536 }
537
538 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchUpdateTest_002, TestSize.Level0)
539 {
540 LOG_INFO("ControllerTest_ExtSpecialControllerBatchUpdateTest_002::Start");
541 Uri uri("");
542 sptr<DataShare::DataShareConnection> connection =
543 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
544 auto dataShareConnection =
__anonb8f763160f02(const auto *) 545 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
546 holder->DisconnectDataShareExtAbility();
547 });
548 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
549 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
550 DataShare::UpdateOperations operations;
551 std::vector<DataShare::BatchUpdateResult> results;
552 int result = tempExtSpeCon->BatchUpdate(operations, results);
553 EXPECT_EQ(result, -1);
554 LOG_INFO("ControllerTest_ExtSpecialControllerBatchUpdateTest_002::End");
555 }
556
557 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerInsertExtTest_001, TestSize.Level0)
558 {
559 LOG_INFO("ControllerTest_ExtSpecialControllerInsertExtTest_001::Start");
560 Uri uri("");
561 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
562 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
563 DataShare::DataShareValuesBucket valuesBucket;
564 valuesBucket.Put("name", "dataShareTest006");
565 valuesBucket.Put("phoneNumber", 20.6);
566 std::string result1 = "test001";
567 int result = tempExtSpeCon->InsertExt(uri, valuesBucket, result1);
568 EXPECT_EQ(result, -1);
569 LOG_INFO("ControllerTest_ExtSpecialControllerInsertExtTest_001::End");
570 }
571
572 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerInsertExtTest_002, TestSize.Level0)
573 {
574 LOG_INFO("ControllerTest_ExtSpecialControllerInsertExtTest_002::Start");
575 Uri uri("");
576 sptr<DataShare::DataShareConnection> connection =
577 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
578 auto dataShareConnection =
__anonb8f763161002(const auto *) 579 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
580 holder->DisconnectDataShareExtAbility();
581 });
582 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
583 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
584 DataShare::DataShareValuesBucket valuesBucket;
585 valuesBucket.Put("name", "dataShareTest006");
586 valuesBucket.Put("phoneNumber", 20.6);
587 std::string result1 = "test001";
588 int result = tempExtSpeCon->InsertExt(uri, valuesBucket, result1);
589 EXPECT_EQ(result, -1);
590 LOG_INFO("ControllerTest_ExtSpecialControllerInsertExtTest_002::End");
591 }
592
593 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerExecuteBatchTest_001, TestSize.Level0)
594 {
595 LOG_INFO("ControllerTest_ExtSpecialControllerExecuteBatchTest_001::Start");
596 Uri uri("");
597 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
598 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
599 std::vector<DataShare::OperationStatement> statements;
600 std::vector<DataShare::BatchUpdateResult> results;
601 ExecResultSet result1;
602 int result = tempExtSpeCon->ExecuteBatch(statements, result1);
603 EXPECT_EQ(result, -1);
604 LOG_INFO("ControllerTest_ExtSpecialControllerExecuteBatchTest_001::End");
605 }
606
607 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerExecuteBatchTest_002, TestSize.Level0)
608 {
609 LOG_INFO("ControllerTest_ExtSpecialControllerExecuteBatchTest_002::Start");
610 Uri uri("");
611 sptr<DataShare::DataShareConnection> connection =
612 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
613 auto dataShareConnection =
__anonb8f763161102(const auto *) 614 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
615 holder->DisconnectDataShareExtAbility();
616 });
617 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
618 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
619 std::vector<DataShare::OperationStatement> statements;
620 std::vector<DataShare::BatchUpdateResult> results;
621 ExecResultSet result1;
622 int result = tempExtSpeCon->ExecuteBatch(statements, result1);
623 EXPECT_EQ(result, -1);
624 LOG_INFO("ControllerTest_ExtSpecialControllerExecuteBatchTest_002::End");
625 }
626
627 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerGetFileTypesTest_001, TestSize.Level0)
628 {
629 LOG_INFO("ControllerTest_ExtSpecialControllerGetFileTypesTest_001::Start");
630 Uri uri("");
631 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
632 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
633 std::string getFileTypes = "test001";
634 std::vector<std::string> result = tempExtSpeCon->GetFileTypes(uri, getFileTypes);
635 EXPECT_EQ(result, std::vector<std::string>());
636 LOG_INFO("ControllerTest_ExtSpecialControllerGetFileTypesTest_001::End");
637 }
638
639 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControlleGetFileTypesTest_002, TestSize.Level0)
640 {
641 LOG_INFO("ControllerTest_ExtSpecialControllerGetFileTypesTest_002::Start");
642 Uri uri("");
643 sptr<DataShare::DataShareConnection> connection =
644 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
645 auto dataShareConnection =
__anonb8f763161202(const auto *) 646 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
647 holder->DisconnectDataShareExtAbility();
648 });
649 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
650 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
651 std::string getFileTypes = "test001";
652 std::vector<std::string> result = tempExtSpeCon->GetFileTypes(uri, getFileTypes);
653 EXPECT_EQ(result, std::vector<std::string>());
654 LOG_INFO("ControllerTest_ExtSpecialControllerGetFileTypesTest_002::End");
655 }
656
657 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerNormalizeUriTest_001, TestSize.Level0)
658 {
659 LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_001::Start");
660 Uri uri("");
661 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
662 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
663 Uri result = tempExtSpeCon->NormalizeUri(uri);
664 EXPECT_EQ(result, Uri(""));
665 LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_001::End");
666 }
667
668 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerNormalizeUriTest_002, TestSize.Level0)
669 {
670 LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_002::Start");
671 Uri uri("");
672 sptr<DataShare::DataShareConnection> connection =
673 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
674 auto dataShareConnection =
__anonb8f763161302(const auto *) 675 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
676 holder->DisconnectDataShareExtAbility();
677 });
678 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
679 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
680 Uri result = tempExtSpeCon->NormalizeUri(uri);
681 EXPECT_EQ(result, Uri(""));
682 LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_002::End");
683 }
684
685 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerDenormalizeUriTest_001, TestSize.Level0)
686 {
687 LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_001::Start");
688 Uri uri("");
689 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
690 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
691 Uri result = tempExtSpeCon->DenormalizeUri(uri);
692 EXPECT_EQ(result, Uri(""));
693 LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_001::End");
694 }
695
696 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerDenormalizeUriTest_002, TestSize.Level0)
697 {
698 LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_002::Start");
699 Uri uri("");
700 sptr<DataShare::DataShareConnection> connection =
701 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
702 auto dataShareConnection =
__anonb8f763161402(const auto *) 703 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
704 holder->DisconnectDataShareExtAbility();
705 });
706 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
707 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
708 Uri result = tempExtSpeCon->DenormalizeUri(uri);
709 EXPECT_EQ(result, Uri(""));
710 LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_002::End");
711 }
712 } // namespace DataShare
713 } // namespace OHOS
714