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_errno.h"
26 #include "datashare_helper.h"
27 #include "datashare_log.h"
28 #include "ext_special_controller.h"
29 #include "extension_manager_proxy.h"
30 #include "general_controller.h"
31 #include "general_controller_provider_impl.h"
32 #include "general_controller_service_impl.h"
33 #include "hap_token_info.h"
34 #include "iservice_registry.h"
35 #include "rdb_data_ability_utils.h"
36 #include "system_ability_definition.h"
37 #include "token_setproc.h"
38
39 namespace OHOS {
40 namespace DataShare {
41 using namespace testing::ext;
42 using namespace OHOS::Security::AccessToken;
43
44 class ControllerTest : 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 ControllerTest::SetUpTestCase(void) {}
TearDownTestCase(void)53 void ControllerTest::TearDownTestCase(void) {}
SetUp(void)54 void ControllerTest::SetUp(void) {}
TearDown(void)55 void ControllerTest::TearDown(void) {}
56
57 /**
58 * @tc.name: ControllerTest_ProviderImplInsertTest_001
59 * @tc.desc: Verify Insert operation with null connection in GeneralControllerProviderImpl
60 * @tc.type: FUNC
61 * @tc.precon: None
62 * @tc.step:
63 1. Create GeneralControllerProviderImpl with null connection and empty URI
64 2. Prepare DataShareValuesBucket with test data
65 3. Call Insert method with empty URI and values bucket
66 4. Check if returned result is negative (indicating failure)
67 * @tc.expect:
68 1. Insert operation returns negative value
69 */
70 HWTEST_F(ControllerTest, ControllerTest_ProviderImplInsertTest_001, TestSize.Level0)
71 {
72 LOG_INFO("ControllerTest_ProviderImplInsertTest_001::Start");
73 Uri uri("");
74 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
75 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
76 DataShare::DataShareValuesBucket valuesBucket;
77 double valueD1 = 20.07;
78 valuesBucket.Put("phoneNumber", valueD1);
79 int result = tempGenConProImp->Insert(uri, valuesBucket);
80 EXPECT_EQ((result < 0), true);
81 LOG_INFO("ControllerTest_ProviderImplInsertTest_001::End");
82 }
83
84 /**
85 * @tc.name: ControllerTest_ProviderImplInsertTest_002
86 * @tc.desc: Verify Insert operation with valid connection but unconnected state in GeneralControllerProviderImpl
87 * @tc.type: FUNC
88 * @tc.precon: None
89 * @tc.step:
90 1. Create DataShareConnection with empty URI
91 2. Create GeneralControllerProviderImpl with the connection and empty URI
92 3. Prepare DataShareValuesBucket with test data
93 4. Call Insert method with empty URI and values bucket
94 5. Check if returned result is negative (indicating failure)
95 * @tc.expect:
96 1. Insert operation returns negative value
97 */
98 HWTEST_F(ControllerTest, ControllerTest_ProviderImplInsertTest_002, TestSize.Level0)
99 {
100 LOG_INFO("ControllerTest_ProviderImplInsertTest_002::Start");
101 Uri uri("");
102 sptr<DataShare::DataShareConnection> connection =
103 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
104 auto dataShareConnection =
__anon068e7a380102(const auto *) 105 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
106 holder->DisconnectDataShareExtAbility();
107 });
108 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
109 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
110 DataShare::DataShareValuesBucket valuesBucket;
111 double valueD1 = 20.07;
112 valuesBucket.Put("phoneNumber", valueD1);
113 int result = tempGenConProImp->Insert(uri, valuesBucket);
114 EXPECT_EQ((result < 0), true);
115 LOG_INFO("ControllerTest_ProviderImplInsertTest_002::End");
116 }
117
118 /**
119 * @tc.name: ControllerTest_ProviderImplUpdateTest_001
120 * @tc.desc: Verify Update operation with null connection in GeneralControllerProviderImpl
121 * @tc.type: FUNC
122 * @tc.precon: None
123 * @tc.step:
124 1. Create GeneralControllerProviderImpl with null connection and empty URI
125 2. Prepare DataSharePredicates and DataShareValuesBucket with test data
126 3. Call Update method with empty URI, predicates and values bucket
127 4. Check if returned result is negative (indicating failure)
128 * @tc.expect:
129 1. Update operation returns negative value
130 */
131 HWTEST_F(ControllerTest, ControllerTest_ProviderImplUpdateTest_001, TestSize.Level0)
132 {
133 LOG_INFO("ControllerTest_ProviderImplUpdateTest_001::Start");
134 Uri uri("");
135 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
136 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
137 DataShare::DataSharePredicates predicates;
138 predicates.EqualTo("name", "Controller_Test001");
139 DataShare::DataShareValuesBucket valuesBucket;
140 valuesBucket.Put("name", "Controller_Test002");
141 int result = tempGenConProImp->Update(uri, predicates, valuesBucket);
142 EXPECT_EQ((result < 0), true);
143 LOG_INFO("ControllerTest_ProviderImplUpdateTest_001::End");
144 }
145
146 /**
147 * @tc.name: ControllerTest_ProviderImplUpdateTest_002
148 * @tc.desc: Verify Update operation with valid connection but unconnected state in GeneralControllerProviderImpl
149 * @tc.type: FUNC
150 * @tc.precon: None
151 * @tc.step:
152 1. Create DataShareConnection with empty URI
153 2. Create GeneralControllerProviderImpl with the connection and empty URI
154 3. Prepare DataSharePredicates and DataShareValuesBucket with test data
155 4. Call Update method with empty URI, predicates and values bucket
156 5. Check if returned result is negative (indicating failure)
157 * @tc.expect:
158 1. Update operation returns negative value
159 */
160 HWTEST_F(ControllerTest, ControllerTest_ProviderImplUpdateTest_002, TestSize.Level0)
161 {
162 LOG_INFO("ControllerTest_ProviderImplUpdateTest_002::Start");
163 Uri uri("");
164 sptr<DataShare::DataShareConnection> connection =
165 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
166 auto dataShareConnection =
__anon068e7a380202(const auto *) 167 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
168 holder->DisconnectDataShareExtAbility();
169 });
170 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
171 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
172 DataShare::DataSharePredicates predicates;
173 predicates.EqualTo("name", "Controller_Test001");
174 DataShare::DataShareValuesBucket valuesBucket;
175 valuesBucket.Put("name", "Controller_Test002");
176 int result = tempGenConProImp->Update(uri, predicates, valuesBucket);
177 EXPECT_EQ((result < 0), true);
178 LOG_INFO("ControllerTest_ProviderImplUpdateTest_002::End");
179 }
180
181 /**
182 * @tc.name: ControllerTest_ProviderImplDeleteTest_001
183 * @tc.desc: Verify Delete operation with null connection in GeneralControllerProviderImpl
184 * @tc.type: FUNC
185 * @tc.precon: None
186 * @tc.step:
187 1. Create GeneralControllerProviderImpl with null connection and empty URI
188 2. Prepare DataSharePredicates with test conditions
189 3. Call Delete method with empty URI and predicates
190 4. Check if returned result is negative (indicating failure)
191 * @tc.expect:
192 1. Delete operation returns negative value
193 */
194 HWTEST_F(ControllerTest, ControllerTest_ProviderImplDeleteTest_001, TestSize.Level0)
195 {
196 LOG_INFO("ControllerTest_ProviderImplDeleteTest_001::Start");
197 Uri uri("");
198 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
199 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
200 DataShare::DataSharePredicates predicates;
201 predicates.EqualTo("name", "Controller_Test001");
202 int result = tempGenConProImp->Delete(uri, predicates);
203 EXPECT_EQ((result < 0), true);
204 LOG_INFO("ControllerTest_ProviderImplDeleteTest_001::End");
205 }
206
207 /**
208 * @tc.name: ControllerTest_ProviderImplDeleteTest_002
209 * @tc.desc: Verify Delete operation with valid connection but unconnected state in GeneralControllerProviderImpl
210 * @tc.type: FUNC
211 * @tc.precon: None
212 * @tc.step:
213 1. Create DataShareConnection with empty URI
214 2. Create GeneralControllerProviderImpl with the connection and empty URI
215 3. Prepare DataSharePredicates with test conditions
216 4. Call Delete method with empty URI and predicates
217 5. Check if returned result is negative (indicating failure)
218 * @tc.expect:
219 1. Delete operation returns negative value
220 */
221 HWTEST_F(ControllerTest, ControllerTest_ProviderImplDeleteTest_002, TestSize.Level0)
222 {
223 LOG_INFO("ControllerTest_ProviderImplDeleteTest_002::Start");
224 Uri uri("");
225 sptr<DataShare::DataShareConnection> connection =
226 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
227 auto dataShareConnection =
__anon068e7a380302(const auto *) 228 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
229 holder->DisconnectDataShareExtAbility();
230 });
231 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
232 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
233 DataShare::DataSharePredicates predicates;
234 predicates.EqualTo("name", "Controller_Test001");
235 int result = tempGenConProImp->Delete(uri, predicates);
236 EXPECT_EQ((result < 0), true);
237 LOG_INFO("ControllerTest_ProviderImplDeleteTest_002::End");
238 }
239
240 /**
241 * @tc.name: Generalcontroller_ServiceImplInsertExTest_001
242 * @tc.desc: Verify InsertEx operation with null connection in GeneralControllerProviderImpl
243 * @tc.type: FUNC
244 * @tc.precon: None
245 * @tc.step:
246 1. Create GeneralControllerProviderImpl with null connection and empty URI
247 2. Prepare DataShareValuesBucket with test data
248 3. Call InsertEx method with empty URI and values bucket
249 4. Check if returned result is (DATA_SHARE_ERROR, 0)
250 * @tc.expect:
251 1. InsertEx operation returns pair(DATA_SHARE_ERROR, 0)
252 */
253 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplInsertExTest_001, TestSize.Level0)
254 {
255 LOG_INFO("Generalcontroller_ServiceImplInsertExTest_001::Start");
256 Uri uri("");
257 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
258 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
259 DataShare::DataShareValuesBucket valuesBucket;
260 double valueD1 = 20.07;
261 valuesBucket.Put("phoneNumber", valueD1);
262 std::pair result = tempGenConProImp->InsertEx(uri, valuesBucket);
263 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
264 EXPECT_EQ(result.second, 0);
265 LOG_INFO("Generalcontroller_ServiceImplInsertExTest_001::End");
266 }
267
268 /**
269 * @tc.name: Generalcontroller_ServiceImplInsertExTest_002
270 * @tc.desc: Verify InsertEx operation with valid connection but unconnected state in GeneralControllerProviderImpl
271 * @tc.type: FUNC
272 * @tc.precon: None
273 * @tc.step:
274 1. Create DataShareConnection with empty URI
275 2. Create GeneralControllerProviderImpl with the connection and empty URI
276 3. Prepare DataShareValuesBucket with test data
277 4. Call InsertEx method with empty URI and values bucket
278 5. Check if returned result is (DATA_SHARE_ERROR, 0)
279 * @tc.expect:
280 1. InsertEx operation returns pair(DATA_SHARE_ERROR, 0)
281 */
282 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplInsertExTest_002, TestSize.Level0)
283 {
284 LOG_INFO("Generalcontroller_ServiceImplInsertExTest_002::Start");
285 Uri uri("");
286 sptr<DataShare::DataShareConnection> connection =
287 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
288 auto dataShareConnection =
__anon068e7a380402(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::DataShareValuesBucket valuesBucket;
295 double valueD1 = 20.07;
296 valuesBucket.Put("phoneNumber", valueD1);
297 std::pair result = tempGenConProImp->InsertEx(uri, valuesBucket);
298 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
299 EXPECT_EQ(result.second, 0);
300 LOG_INFO("Generalcontroller_ServiceImplInsertExTest_002::End");
301 }
302
303 /**
304 * @tc.name: Generalcontroller_ServiceImplUpdateExTest_001
305 * @tc.desc: Verify UpdateEx operation with null connection in GeneralControllerProviderImpl
306 * @tc.type: FUNC
307 * @tc.precon: None
308 * @tc.step:
309 1. Create GeneralControllerProviderImpl with null connection and empty URI
310 2. Prepare DataSharePredicates and DataShareValuesBucket with test data
311 3. Call UpdateEx method with empty URI, predicates and values bucket
312 4. Check if returned result is (DATA_SHARE_ERROR, 0)
313 * @tc.expect:
314 1. UpdateEx operation returns pair(DATA_SHARE_ERROR, 0)
315 */
316 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplUpdateExTest_001, TestSize.Level0)
317 {
318 LOG_INFO("Generalcontroller_ServiceImplUpdateExTest_001::Start");
319 Uri uri("");
320 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
321 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
322 DataShare::DataSharePredicates predicates;
323 predicates.EqualTo("name", "Controller_Test001");
324 DataShare::DataShareValuesBucket valuesBucket;
325 double valueD1 = 20.07;
326 valuesBucket.Put("phoneNumber", valueD1);
327 std::pair result = tempGenConProImp->UpdateEx(uri, predicates, valuesBucket);
328 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
329 EXPECT_EQ(result.second, 0);
330 LOG_INFO("Generalcontroller_ServiceImplUpdateExTest_001::End");
331 }
332
333 /**
334 * @tc.name: Generalcontroller_ServiceImplUpdateExTest_002
335 * @tc.desc: Verify UpdateEx operation with valid connection but unconnected state in GeneralControllerProviderImpl
336 * @tc.type: FUNC
337 * @tc.precon: None
338 * @tc.step:
339 1. Create DataShareConnection with empty URI
340 2. Create GeneralControllerProviderImpl with the connection and empty URI
341 3. Prepare DataSharePredicates and DataShareValuesBucket with test data
342 4. Call UpdateEx method with empty URI, predicates and values bucket
343 5. Check if returned result is (DATA_SHARE_ERROR, 0)
344 * @tc.expect:
345 1. UpdateEx operation returns pair(DATA_SHARE_ERROR, 0)
346 */
347 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplUpdateExTest_002, TestSize.Level0)
348 {
349 LOG_INFO("Generalcontroller_ServiceImplUpdateExTest_002::Start");
350 Uri uri("");
351 sptr<DataShare::DataShareConnection> connection =
352 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
353 auto dataShareConnection =
__anon068e7a380502(const auto *) 354 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
355 holder->DisconnectDataShareExtAbility();
356 });
357 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
358 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
359 DataShare::DataSharePredicates predicates;
360 predicates.EqualTo("name", "Controller_Test001");
361 DataShare::DataShareValuesBucket valuesBucket;
362 double valueD1 = 20.07;
363 valuesBucket.Put("phoneNumber", valueD1);
364 std::pair result = tempGenConProImp->UpdateEx(uri, predicates, valuesBucket);
365 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
366 EXPECT_EQ(result.second, 0);
367 LOG_INFO("Generalcontroller_ServiceImplUpdateExTest_002::End");
368 }
369
370 /**
371 * @tc.name: Generalcontroller_ServiceImplDeleteExTest_001
372 * @tc.desc: Verify DeleteEx operation with null connection in GeneralControllerProviderImpl
373 * @tc.type: FUNC
374 * @tc.precon: None
375 * @tc.step:
376 1. Create GeneralControllerProviderImpl with null connection and empty URI
377 2. Prepare DataSharePredicates with test conditions
378 3. Call DeleteEx method with empty URI and predicates
379 4. Check if returned result is (DATA_SHARE_ERROR, 0)
380 * @tc.expect:
381 1. DeleteEx operation returns pair(DATA_SHARE_ERROR, 0)
382 */
383 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplDeleteExTest_001, TestSize.Level0)
384 {
385 LOG_INFO("Generalcontroller_ServiceImplDeleteExTest_001::Start");
386 Uri uri("");
387 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
388 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
389 DataShare::DataSharePredicates predicates;
390 predicates.EqualTo("name", "Controller_Test001");
391 std::pair result = tempGenConProImp->DeleteEx(uri, predicates);
392 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
393 EXPECT_EQ(result.second, 0);
394 LOG_INFO("Generalcontroller_ServiceImplDeleteExTest_001::End");
395 }
396
397 /**
398 * @tc.name: Generalcontroller_ServiceImplDeleteExTest_002
399 * @tc.desc: Verify DeleteEx operation with valid connection but unconnected state in GeneralControllerProviderImpl
400 * @tc.type: FUNC
401 * @tc.precon: None
402 * @tc.step:
403 1. Create DataShareConnection with empty URI
404 2. Create GeneralControllerProviderImpl with the connection and empty URI
405 3. Prepare DataSharePredicates with test conditions
406 4. Call DeleteEx method with empty URI and predicates
407 5. Check if returned result is (DATA_SHARE_ERROR, 0)
408 * @tc.expect:
409 1. DeleteEx operation returns pair(DATA_SHARE_ERROR, 0)
410 */
411 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplDeleteExTest_002, TestSize.Level0)
412 {
413 LOG_INFO("Generalcontroller_ServiceImplDeleteExTest_002::Start");
414 Uri uri("");
415 sptr<DataShare::DataShareConnection> connection =
416 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
417 auto dataShareConnection =
__anon068e7a380602(const auto *) 418 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
419 holder->DisconnectDataShareExtAbility();
420 });
421 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
422 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
423 DataShare::DataSharePredicates predicates;
424 predicates.EqualTo("name", "Controller_Test001");
425 std::pair result = tempGenConProImp->DeleteEx(uri, predicates);
426 EXPECT_EQ(result.first, DATA_SHARE_ERROR);
427 EXPECT_EQ(result.second, 0);
428 LOG_INFO("Generalcontroller_ServiceImplDeleteExTest_002::End");
429 }
430
431 /**
432 * @tc.name: ControllerTest_ProviderImplQueryTest_001
433 * @tc.desc: Verify Query operation with null connection in GeneralControllerProviderImpl
434 * @tc.type: FUNC
435 * @tc.precon: None
436 * @tc.step:
437 1. Create GeneralControllerProviderImpl with null connection and empty URI
438 2. Prepare DataSharePredicates and column list
439 3. Call Query method with empty URI, predicates and columns
440 4. Check if returned result is nullptr
441 * @tc.expect:
442 1. Query operation returns nullptr
443 */
444 HWTEST_F(ControllerTest, ControllerTest_ProviderImplQueryTest_001, TestSize.Level0)
445 {
446 LOG_INFO("ControllerTest_ProviderImplQueryTest_001::Start");
447 Uri uri("");
448 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
449 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
450 DataShare::DataSharePredicates predicates;
451 predicates.EqualTo("name", "Controller_Test001");
452 vector<string> columns;
453 DatashareBusinessError error;
454 DataShareOption option;
455 auto result = tempGenConProImp->Query(uri, predicates, columns, error, option);
456 EXPECT_EQ(result, nullptr);
457 LOG_INFO("ControllerTest_ProviderImplQueryTest_001::End");
458 }
459
460 /**
461 * @tc.name: ControllerTest_ProviderImplQueryTest_002
462 * @tc.desc: Verify Query operation with valid connection but unconnected state in GeneralControllerProviderImpl
463 * @tc.type: FUNC
464 * @tc.precon: None
465 * @tc.step:
466 1. Create DataShareConnection with empty URI
467 2. Create GeneralControllerProviderImpl with the connection and empty URI
468 3. Prepare DataSharePredicates and column list
469 4. Call Query method with empty URI, predicates and columns
470 5. Check if returned result is nullptr
471 * @tc.expect:
472 1. Query operation returns nullptr
473 */
474 HWTEST_F(ControllerTest, ControllerTest_ProviderImplQueryTest_002, TestSize.Level0)
475 {
476 LOG_INFO("ControllerTest_ProviderImplQueryTest_002::Start");
477 Uri uri("");
478 sptr<DataShare::DataShareConnection> connection =
479 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
480 auto dataShareConnection =
__anon068e7a380702(const auto *) 481 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
482 holder->DisconnectDataShareExtAbility();
483 });
484 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
485 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
486 DataShare::DataSharePredicates predicates;
487 predicates.EqualTo("name", "Controller_Test001");
488 vector<string> columns;
489 DatashareBusinessError error;
490 DataShareOption option;
491 auto result = tempGenConProImp->Query(uri, predicates, columns, error, option);
492 EXPECT_EQ(result, nullptr);
493 LOG_INFO("ControllerTest_ProviderImplQueryTest_002::End");
494 }
495
496 /**
497 * @tc.name: Generalcontroller_ServiceImplRegisterObserverTest_001
498 * @tc.desc: Verify RegisterObserver operation with null connection in GeneralControllerProviderImpl
499 * @tc.type: FUNC
500 * @tc.precon: None
501 * @tc.step:
502 1. Create GeneralControllerProviderImpl with null connection and empty URI
503 2. Call RegisterObserver method with empty URI and null observer
504 3. Verify URI remains empty
505 * @tc.expect:
506 1. URI remains empty after operation
507 */
508 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplRegisterObserverTest_001, TestSize.Level0)
509 {
510 LOG_INFO("Generalcontroller_ServiceImplRegisterObserverTest_001::Start");
511 Uri uri("");
512 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
513 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
514 sptr<AAFwk::IDataAbilityObserver> dataObserver;
515 tempGenConProImp->RegisterObserver(uri, dataObserver);
516 EXPECT_EQ(uri, Uri(""));
517 LOG_INFO("Generalcontroller_ServiceImplRegisterObserverTest_001::End");
518 }
519
520 /**
521 * @tc.name: Generalcontroller_ServiceImplRegisterObserverTest_002
522 * @tc.desc: Verify RegisterObserver with valid connection but unconnected state in GeneralControllerProviderImpl
523 * @tc.type: FUNC
524 * @tc.precon: None
525 * @tc.step:
526 1. Create DataShareConnection with empty URI
527 2. Create GeneralControllerProviderImpl with the connection and empty URI
528 3. Call RegisterObserver method with empty URI and null observer
529 4. Verify URI remains empty
530 * @tc.expect:
531 1. URI remains empty after operation
532 */
533 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplRegisterObserverTest_002, TestSize.Level0)
534 {
535 LOG_INFO("Generalcontroller_ServiceImplRegisterObserverTest_002::Start");
536 Uri uri("");
537 sptr<DataShare::DataShareConnection> connection =
538 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
539 auto dataShareConnection =
__anon068e7a380802(const auto *) 540 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
541 holder->DisconnectDataShareExtAbility();
542 });
543 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
544 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
545 sptr<AAFwk::IDataAbilityObserver> dataObserver;
546 tempGenConProImp->RegisterObserver(uri, dataObserver);
547 EXPECT_EQ(uri, Uri(""));
548 LOG_INFO("Generalcontroller_ServiceImplRegisterObserverTest_002::End");
549 }
550
551 /**
552 * @tc.name: Generalcontroller_ServiceImplUnregisterObserverTest_001
553 * @tc.desc: Verify UnregisterObserver operation with null connection in GeneralControllerProviderImpl
554 * @tc.type: FUNC
555 * @tc.precon: None
556 * @tc.step:
557 1. Create GeneralControllerProviderImpl with null connection and empty URI
558 2. Call UnregisterObserver method with empty URI and null observer
559 3. Verify URI remains empty
560 * @tc.expect:
561 1. URI remains empty after operation
562 */
563 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplUnregisterObserverTest_001, TestSize.Level0)
564 {
565 LOG_INFO("Generalcontroller_ServiceImplUnregisterObserverTest_001::Start");
566 Uri uri("");
567 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
568 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
569 sptr<AAFwk::IDataAbilityObserver> dataObserver;
570 tempGenConProImp->UnregisterObserver(uri, dataObserver);
571 EXPECT_EQ(uri, Uri(""));
572 LOG_INFO("Generalcontroller_ServiceImplUnregisterObserverTest_001::End");
573 }
574
575 /**
576 * @tc.name: Generalcontroller_ServiceImplUnregisterObserverTest_002
577 * @tc.desc: Verify UnregisterObserver with valid connection but unconnected state in GeneralControllerProviderImpl
578 * @tc.type: FUNC
579 * @tc.precon: None
580 * @tc.step:
581 1. Create DataShareConnection with empty URI
582 2. Create GeneralControllerProviderImpl with the connection and empty URI
583 3. Call UnregisterObserver method with empty URI and null observer
584 4. Verify URI remains empty
585 * @tc.expect:
586 1. URI remains empty after operation
587 */
588 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplUnregisterObserverTest_002, TestSize.Level0)
589 {
590 LOG_INFO("Generalcontroller_ServiceImplUnregisterObserverTest_002::Start");
591 Uri uri("");
592 sptr<DataShare::DataShareConnection> connection =
593 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
594 auto dataShareConnection =
__anon068e7a380902(const auto *) 595 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
596 holder->DisconnectDataShareExtAbility();
597 });
598 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
599 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
600 sptr<AAFwk::IDataAbilityObserver> dataObserver;
601 tempGenConProImp->UnregisterObserver(uri, dataObserver);
602 EXPECT_EQ(uri, Uri(""));
603 LOG_INFO("Generalcontroller_ServiceImplUnregisterObserverTest_002::End");
604 }
605
606 /**
607 * @tc.name: Generalcontroller_ServiceImplNotifyChangeTest_001
608 * @tc.desc: Verify NotifyChange operation with null connection in GeneralControllerProviderImpl
609 * @tc.type: FUNC
610 * @tc.precon: None
611 * @tc.step:
612 1. Create GeneralControllerProviderImpl with null connection and empty URI
613 2. Call NotifyChange method with empty URI
614 3. Verify URI remains empty
615 * @tc.expect:
616 1. URI remains empty after operation
617 */
618 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplNotifyChangeTest_001, TestSize.Level0)
619 {
620 LOG_INFO("Generalcontroller_ServiceImplNotifyChangeTest_001::Start");
621 Uri uri("");
622 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
623 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
624 tempGenConProImp->NotifyChange(uri);
625 EXPECT_EQ(uri, Uri(""));
626 LOG_INFO("Generalcontroller_ServiceImplNotifyChangeTest_001::End");
627 }
628
629 /**
630 * @tc.name: Generalcontroller_ServiceImplNotifyChangeTest_002
631 * @tc.desc: Verify NotifyChange with valid connection but unconnected state in GeneralControllerProviderImpl
632 * @tc.type: FUNC
633 * @tc.precon: None
634 * @tc.step:
635 1. Create DataShareConnection with empty URI
636 2. Create GeneralControllerProviderImpl with the connection and empty URI
637 3. Call NotifyChange method with empty URI
638 4. Verify URI remains empty
639 * @tc.expect:
640 1. URI remains empty after operation
641 */
642 HWTEST_F(ControllerTest, Generalcontroller_ServiceImplNotifyChangeTest_002, TestSize.Level0)
643 {
644 LOG_INFO("Generalcontroller_ServiceImplNotifyChangeTest_002::Start");
645 Uri uri("");
646 sptr<DataShare::DataShareConnection> connection =
647 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
648 auto dataShareConnection =
__anon068e7a380a02(const auto *) 649 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
650 holder->DisconnectDataShareExtAbility();
651 });
652 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
653 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
654 tempGenConProImp->NotifyChange(uri);
655 EXPECT_EQ(uri, Uri(""));
656 LOG_INFO("Generalcontroller_ServiceImplNotifyChangeTest_002::End");
657 }
658
659 /**
660 * @tc.name: Generalcontroller_ProviderImpl_RegisterObserverExtProvider_Test_001
661 * @tc.desc: Verify RegisterObserverExtProvider with null connection and unconnected state
662 * @tc.type: FUNC
663 * @tc.precon: None
664 * @tc.step:
665 1. Create provider with null connection and call RegisterObserverExtProvider
666 2. Create provider with valid but unconnected connection and call RegisterObserverExtProvider
667 3. Check return codes for both cases
668 * @tc.expect:
669 1. First call returns E_PROVIDER_CONN_NULL
670 2. Second call returns E_PROVIDER_NOT_CONNECTED
671 */
672 HWTEST_F(ControllerTest, Generalcontroller_ProviderImpl_RegisterObserverExtProvider_Test_001, TestSize.Level0)
673 {
674 LOG_INFO("Generalcontroller_ProviderImpl_RegisterObserverExtProvider_Test_001::Start");
675
676 Uri uri("");
677 // connection is nullptr
678 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
679 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
680 ASSERT_NE(tempGenConProImp, nullptr);
681 sptr<AAFwk::IDataAbilityObserver> dataObserver;
682 // make isDescendants false
683 int ret = tempGenConProImp->RegisterObserverExtProvider(uri, dataObserver, false);
684 EXPECT_EQ(ret, E_PROVIDER_CONN_NULL);
685
686 // connection not null
687 sptr<DataShare::DataShareConnection> connection =
688 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
689 ASSERT_NE(connection, nullptr);
690 auto dataShareConnection =
__anon068e7a380b02(const auto *) 691 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
692 holder->DisconnectDataShareExtAbility();
693 });
694 tempGenConProImp =
695 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
696 ret = tempGenConProImp->RegisterObserverExtProvider(uri, dataObserver, false);
697 EXPECT_EQ(ret, E_PROVIDER_NOT_CONNECTED);
698
699 LOG_INFO("Generalcontroller_ProviderImpl_RegisterObserverExtProvider_Test_001::End");
700 }
701
702 /**
703 * @tc.name: Generalcontroller_ProviderImpl_UnregisterObserverExtProvider_Test_001
704 * @tc.desc: Verify UnregisterObserverExtProvider with null connection and unconnected state
705 * @tc.type: FUNC
706 * @tc.precon: None
707 * @tc.step:
708 1. Create provider with null connection and call UnregisterObserverExtProvider
709 2. Create provider with valid but unconnected connection and call UnregisterObserverExtProvider
710 3. Check return codes for both cases
711 * @tc.expect:
712 1. First call returns E_PROVIDER_CONN_NULL
713 2. Second call returns E_PROVIDER_NOT_CONNECTED
714 */
715 HWTEST_F(ControllerTest, Generalcontroller_ProviderImpl_UnregisterObserverExtProvider_Test_001, TestSize.Level0)
716 {
717 LOG_INFO("Generalcontroller_ProviderImpl_UnregisterObserverExtProvider_Test_001::Start");
718
719 Uri uri("");
720 // connection is nullptr
721 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
722 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
723 ASSERT_NE(tempGenConProImp, nullptr);
724 sptr<AAFwk::IDataAbilityObserver> dataObserver;
725 // make isDescendants false
726 int ret = tempGenConProImp->UnregisterObserverExtProvider(uri, dataObserver);
727 EXPECT_EQ(ret, E_PROVIDER_CONN_NULL);
728
729 // connection not null but dataShareProxy is nullptr
730 sptr<DataShare::DataShareConnection> connection =
731 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
732 ASSERT_NE(connection, nullptr);
733 connection->dataShareProxy_ = nullptr;
734 ASSERT_EQ(connection->dataShareProxy_, nullptr);
735 auto dataShareConnection =
__anon068e7a380c02(const auto *) 736 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
737 holder->DisconnectDataShareExtAbility();
738 });
739 tempGenConProImp =
740 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
741 ret = tempGenConProImp->UnregisterObserverExtProvider(uri, dataObserver);
742 EXPECT_EQ(ret, E_PROVIDER_NOT_CONNECTED);
743
744 LOG_INFO("Generalcontroller_ProviderImpl_UnregisterObserverExtProvider_Test_001::End");
745 }
746
747 /**
748 * @tc.name: Generalcontroller_ProviderImpl_NotifyChangeExtProvider_Test_001
749 * @tc.desc: Verify NotifyChangeExtProvider with null connection and unconnected state
750 * @tc.type: FUNC
751 * @tc.precon: None
752 * @tc.step:
753 1. Create provider with null connection and call NotifyChangeExtProvider
754 2. Create provider with valid but unconnected connection and call NotifyChangeExtProvider
755 3. Check return codes for both cases
756 * @tc.expect:
757 1. First call returns E_PROVIDER_CONN_NULL
758 2. Second call returns E_PROVIDER_NOT_CONNECTED
759 */
760 HWTEST_F(ControllerTest, Generalcontroller_ProviderImpl_NotifyChangeExtProvider_Test_001, TestSize.Level0)
761 {
762 LOG_INFO("Generalcontroller_ProviderImpl_NotifyChangeExtProvider_Test_001::Start");
763
764 Uri uri("");
765 // connection is nullptr
766 ChangeInfo changeInfo = { ChangeInfo::ChangeType::INSERT, { uri } };
767 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
768 std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
769 sptr<AAFwk::IDataAbilityObserver> dataObserver;
770 // make isDescendants false
771 int ret = tempGenConProImp->NotifyChangeExtProvider(changeInfo);
772 EXPECT_EQ(ret, E_PROVIDER_CONN_NULL);
773
774 // connection not null
775 sptr<DataShare::DataShareConnection> connection =
776 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
777 auto dataShareConnection =
__anon068e7a380d02(const auto *) 778 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
779 holder->DisconnectDataShareExtAbility();
780 });
781 tempGenConProImp =
782 std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
783 ret = tempGenConProImp->NotifyChangeExtProvider(changeInfo);
784 EXPECT_EQ(ret, E_PROVIDER_NOT_CONNECTED);
785
786 LOG_INFO("Generalcontroller_ProviderImpl_NotifyChangeExtProvider_Test_001::End");
787 }
788
789 /**
790 * @tc.name: Generalcontroller_ServiceImpl_RegisterObserverExtProvider_Test_001
791 * @tc.desc: Verify RegisterObserverExtProvider operation in GeneralControllerServiceImpl
792 * @tc.type: FUNC
793 * @tc.precon: None
794 * @tc.step:
795 1. Create GeneralControllerServiceImpl with test URI
796 2. Call RegisterObserverExtProvider with empty URI and null observer
797 3. Check return code
798 * @tc.expect:
799 1. Operation returns -1 (failure)
800 */
801 HWTEST_F(ControllerTest, Generalcontroller_ServiceImpl_RegisterObserverExtProvider_Test_001, TestSize.Level0)
802 {
803 LOG_INFO("Generalcontroller_ServiceImpl_RegisterObserverExtProvider_Test_001::Start");
804
805 Uri uri("");
806 std::string extUri = "GeneralControllerServiceImpl";
807
808 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
809 std::make_shared<DataShare::GeneralControllerServiceImpl>(extUri);
810 ASSERT_NE(tempGenConProImp, nullptr);
811 sptr<AAFwk::IDataAbilityObserver> dataObserver;
812
813 int ret = tempGenConProImp->RegisterObserverExtProvider(uri, dataObserver, false);
814 EXPECT_EQ(ret, -1);
815
816 LOG_INFO("Generalcontroller_ServiceImpl_RegisterObserverExtProvider_Test_001::End");
817 }
818
819 /**
820 * @tc.name: Generalcontroller_ServiceImpl_UnregisterObserverExtProvider_Test_001
821 * @tc.desc: Verify UnregisterObserverExtProvider operation in GeneralControllerServiceImpl
822 * @tc.type: FUNC
823 * @tc.precon: None
824 * @tc.step:
825 1. Create GeneralControllerServiceImpl with test URI
826 2. Call UnregisterObserverExtProvider with empty URI and null observer
827 3. Check return code
828 * @tc.expect:
829 1. Operation returns -1 (failure)
830 */
831 HWTEST_F(ControllerTest, Generalcontroller_ServiceImpl_UnregisterObserverExtProvider_Test_001, TestSize.Level0)
832 {
833 LOG_INFO("Generalcontroller_ServiceImpl_UnregisterObserverExtProvider_Test_001::Start");
834
835 Uri uri("");
836 std::string extUri = "GeneralControllerServiceImpl";
837
838 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
839 std::make_shared<DataShare::GeneralControllerServiceImpl>(extUri);
840 ASSERT_NE(tempGenConProImp, nullptr);
841 sptr<AAFwk::IDataAbilityObserver> dataObserver;
842
843 int ret = tempGenConProImp->UnregisterObserverExtProvider(uri, dataObserver);
844 EXPECT_EQ(ret, -1);
845
846 LOG_INFO("Generalcontroller_ServiceImpl_UnregisterObserverExtProvider_Test_001::End");
847 }
848
849 /**
850 * @tc.name: Generalcontroller_ServiceImpl_NotifyChangeExtProvider_Test_001
851 * @tc.desc: Verify NotifyChangeExtProvider operation in GeneralControllerServiceImpl
852 * @tc.type: FUNC
853 * @tc.precon: None
854 * @tc.step:
855 1. Create GeneralControllerServiceImpl with test URI
856 2. Prepare ChangeInfo with empty URI
857 3. Call NotifyChangeExtProvider with the change info
858 4. Check return code
859 * @tc.expect:
860 1. Operation returns -1 (failure)
861 */
862 HWTEST_F(ControllerTest, Generalcontroller_ServiceImpl_NotifyChangeExtProvider_Test_001, TestSize.Level0)
863 {
864 LOG_INFO("Generalcontroller_ServiceImpl_NotifyChangeExtProvider_Test_001::Start");
865
866 Uri uri("");
867 std::string extUri = "GeneralControllerServiceImpl";
868
869 ChangeInfo changeInfo = { ChangeInfo::ChangeType::INSERT, { uri } };
870 // connection is nullptr
871 std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
872 std::make_shared<DataShare::GeneralControllerServiceImpl>(extUri);
873 ASSERT_NE(tempGenConProImp, nullptr);
874 sptr<AAFwk::IDataAbilityObserver> dataObserver;
875
876 int ret = tempGenConProImp->NotifyChangeExtProvider(changeInfo);
877 EXPECT_EQ(ret, -1);
878
879 LOG_INFO("Generalcontroller_ServiceImpl_NotifyChangeExtProvider_Test_001::End");
880 }
881
882 /**
883 * @tc.name: ControllerTest_ExtSpecialControllerOpenFileTest_001
884 * @tc.desc: Verify OpenFile operation with null connection in ExtSpecialController
885 * @tc.type: FUNC
886 * @tc.precon: None
887 * @tc.step:
888 1. Create ExtSpecialController with null connection and empty URI
889 2. Call OpenFile with empty URI and test mode
890 3. Check if returned result is negative
891 * @tc.expect:
892 1. OpenFile operation returns negative value
893 */
894 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerOpenFileTest_001, TestSize.Level0)
895 {
896 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileTest_001::Start");
897 Uri uri("");
898 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
899 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
900 std::string mode = "test001";
901 int result = tempExtSpeCon->OpenFile(uri, mode);
902 EXPECT_EQ((result < 0), true);
903 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileTest_001::End");
904 }
905
906 /**
907 * @tc.name: ControllerTest_ExtSpecialControllerOpenFileTest_002
908 * @tc.desc: Verify OpenFile operation with valid connection but unconnected state in ExtSpecialController
909 * @tc.type: FUNC
910 * @tc.precon: None
911 * @tc.step:
912 1. Create DataShareConnection with empty URI
913 2. Create ExtSpecialController with the connection and empty URI
914 3. Call OpenFile with empty URI and test mode
915 4. Check if returned result is negative
916 * @tc.expect:
917 1. OpenFile operation returns negative value
918 */
919 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerOpenFileTest_002, TestSize.Level0)
920 {
921 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileTest_002::Start");
922 Uri uri("");
923 sptr<DataShare::DataShareConnection> connection =
924 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
925 auto dataShareConnection =
__anon068e7a380e02(const auto *) 926 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
927 holder->DisconnectDataShareExtAbility();
928 });
929 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
930 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
931 std::string mode = "test001";
932 int result = tempExtSpeCon->OpenFile(uri, mode);
933 EXPECT_EQ((result < 0), true);
934 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileTest_002::End");
935 }
936
937 /**
938 * @tc.name: ControllerTest_ExtSpecialControllerOpenFileWithErrCodeTest_001
939 * @tc.desc: Verify OpenFileWithErrCode function with null connection in ExtSpecialController
940 * @tc.type: FUNC
941 * @tc.precon: None
942 * @tc.step:
943 1. Create ExtSpecialController with null connection and empty URI
944 2. Call OpenFileWithErrCode with empty URI, test mode and error code
945 3. Check if returned file descriptor is -1
946 * @tc.expect:
947 1. OpenFileWithErrCode returns -1
948 */
949 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerOpenFileWithErrCodeTest_001, TestSize.Level0)
950 {
951 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileWithErrCodeTest_001::Start");
952 Uri uri("");
953 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
954 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
955 std::string mode = "test001";
956 int32_t errCode = 0;
957 int fd = tempExtSpeCon->OpenFileWithErrCode(uri, mode, errCode);
958 EXPECT_EQ(fd, -1);
959 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileWithErrCodeTest_001::End");
960 }
961
962 /**
963 * @tc.name: ControllerTest_ExtSpecialControllerOpenFileWithErrCodeTest_002
964 * @tc.desc: Verify OpenFileWithErrCode function with valid connection but unconnected state in ExtSpecialController
965 * @tc.type: FUNC
966 * @tc.precon: None
967 * @tc.step:
968 1. Create DataShareConnection with empty URI
969 2. Create ExtSpecialController with the connection and empty URI
970 3. Call OpenFileWithErrCode with empty URI, test mode and error code
971 4. Check if returned file descriptor is -1
972 * @tc.expect:
973 1. OpenFileWithErrCode returns -1
974 */
975 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerOpenFileWithErrCodeTest_002, TestSize.Level0)
976 {
977 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileWithErrCodeTest_002::Start");
978 Uri uri("");
979 sptr<DataShare::DataShareConnection> connection =
980 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
981 auto dataShareConnection =
__anon068e7a380f02(const auto *) 982 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
983 holder->DisconnectDataShareExtAbility();
984 });
985 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
986 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
987 std::string mode = "test001";
988 int32_t errCode = 0;
989 int fd = tempExtSpeCon->OpenFileWithErrCode(uri, mode, errCode);
990 EXPECT_EQ(fd, -1);
991 LOG_INFO("ControllerTest_ExtSpecialControllerOpenFileWithErrCodeTest_002::End");
992 }
993
994 /**
995 * @tc.name: ControllerTest_ExtSpecialControllerOpenRawFileTest_001
996 * @tc.desc: Verify OpenRawFile operation with null connection in ExtSpecialController
997 * @tc.type: FUNC
998 * @tc.precon: None
999 * @tc.step:
1000 1. Create ExtSpecialController with null connection and empty URI
1001 2. Call OpenRawFile with empty URI and test mode
1002 3. Check if returned result is negative
1003 * @tc.expect:
1004 1. OpenRawFile operation returns negative value
1005 */
1006 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerOpenRawFileTest_001, TestSize.Level0)
1007 {
1008 LOG_INFO("ControllerTest_ExtSpecialControllerOpenRawFileTest_001::Start");
1009 Uri uri("");
1010 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1011 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
1012 std::string mode = "test001";
1013 int result = tempExtSpeCon->OpenRawFile(uri, mode);
1014 EXPECT_EQ((result < 0), true);
1015 LOG_INFO("ControllerTest_ExtSpecialControllerOpenRawFileTest_001::End");
1016 }
1017
1018 /**
1019 * @tc.name: ControllerTest_ExtSpecialControlleOpenRawFileTest_002
1020 * @tc.desc: Verify OpenRawFile operation with valid connection but unconnected state in ExtSpecialController
1021 * @tc.type: FUNC
1022 * @tc.precon: None
1023 * @tc.step:
1024 1. Create DataShareConnection with empty URI
1025 2. Create ExtSpecialController with the connection and empty URI
1026 3. Call OpenRawFile with empty URI and test mode
1027 4. Check if returned result is negative
1028 * @tc.expect:
1029 1. OpenRawFile operation returns negative value
1030 */
1031 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControlleOpenRawFileTest_002, TestSize.Level0)
1032 {
1033 LOG_INFO("ControllerTest_ExtSpecialControllerOpenRawFileTest_002::Start");
1034 Uri uri("");
1035 sptr<DataShare::DataShareConnection> connection =
1036 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
1037 auto dataShareConnection =
__anon068e7a381002(const auto *) 1038 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
1039 holder->DisconnectDataShareExtAbility();
1040 });
1041 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1042 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
1043 std::string mode = "test001";
1044 int result = tempExtSpeCon->OpenRawFile(uri, mode);
1045 EXPECT_EQ((result < 0), true);
1046 LOG_INFO("ControllerTest_ExtSpecialControllerOpenRawFileTest_002::End");
1047 }
1048
1049 /**
1050 * @tc.name: ControllerTest_ExtSpecialControllerGetTypeTest_001
1051 * @tc.desc: Verify GetType operation with null connection in ExtSpecialController
1052 * @tc.type: FUNC
1053 * @tc.precon: None
1054 * @tc.step:
1055 1. Create ExtSpecialController with null connection and empty URI
1056 2. Call GetType with empty URI
1057 3. Check if returned result is empty string
1058 * @tc.expect:
1059 1. GetType operation returns empty string
1060 */
1061 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerGetTypeTest_001, TestSize.Level0)
1062 {
1063 LOG_INFO("ControllerTest_ExtSpecialControllerGetTypeTest_001::Start");
1064 Uri uri("");
1065 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1066 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
1067 std::string result = tempExtSpeCon->GetType(uri);
1068 EXPECT_EQ(result, "");
1069 LOG_INFO("ControllerTest_ExtSpecialControllerGetTypeTest_001::End");
1070 }
1071
1072 /**
1073 * @tc.name: ControllerTest_ExtSpecialControlleGetTypeTest_002
1074 * @tc.desc: Verify GetType operation with valid connection but unconnected state in ExtSpecialController
1075 * @tc.type: FUNC
1076 * @tc.precon: None
1077 * @tc.step:
1078 1. Create DataShareConnection with empty URI
1079 2. Create ExtSpecialController with the connection and empty URI
1080 3. Call GetType with empty URI
1081 4. Check if returned result is empty string
1082 * @tc.expect:
1083 1. GetType operation returns empty string
1084 */
1085 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControlleGetTypeTest_002, TestSize.Level0)
1086 {
1087 LOG_INFO("ControllerTest_ExtSpecialControllerGetTypeTest_002::Start");
1088 Uri uri("");
1089 sptr<DataShare::DataShareConnection> connection =
1090 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
1091 auto dataShareConnection =
__anon068e7a381102(const auto *) 1092 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
1093 holder->DisconnectDataShareExtAbility();
1094 });
1095 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1096 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
1097 std::string result = tempExtSpeCon->GetType(uri);
1098 EXPECT_EQ(result, "");
1099 LOG_INFO("ControllerTest_ExtSpecialControllerGetTypeTest_002::End");
1100 }
1101
1102 /**
1103 * @tc.name: ControllerTest_ExtSpecialControllerBatchInsertTest_001
1104 * @tc.desc: Verify BatchInsert operation with null connection in ExtSpecialController
1105 * @tc.type: FUNC
1106 * @tc.precon: None
1107 * @tc.step:
1108 1. Create ExtSpecialController with null connection and empty URI
1109 2. Prepare vector of DataShareValuesBucket with test data
1110 3. Call BatchInsert with empty URI and values vector
1111 4. Check if returned result is negative
1112 * @tc.expect:
1113 1. BatchInsert operation returns negative value
1114 */
1115 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchInsertTest_001, TestSize.Level0)
1116 {
1117 LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_001::Start");
1118 Uri uri("");
1119 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1120 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
1121 DataShare::DataShareValuesBucket valuesBucket1;
1122 valuesBucket1.Put("name", "dataShareTest006");
1123 valuesBucket1.Put("phoneNumber", 20.6);
1124 DataShare::DataShareValuesBucket valuesBucket2;
1125 valuesBucket2.Put("name", "dataShareTest007");
1126 valuesBucket2.Put("phoneNumber", 20.5);
1127 std::vector<DataShare::DataShareValuesBucket> values;
1128 values.push_back(valuesBucket1);
1129 values.push_back(valuesBucket2);
1130 int result = tempExtSpeCon->BatchInsert(uri, values);
1131 EXPECT_EQ((result < 0), true);
1132 LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_001::End");
1133 }
1134
1135 /**
1136 * @tc.name: ControllerTest_ExtSpecialControllerBatchInsertTest_002
1137 * @tc.desc: Verify BatchInsert operation with valid connection but unconnected state in ExtSpecialController
1138 * @tc.type: FUNC
1139 * @tc.precon: None
1140 * @tc.step:
1141 1. Create DataShareConnection with empty URI
1142 2. Create ExtSpecialController with the connection and empty URI
1143 3. Prepare vector of DataShareValuesBucket with test data
1144 4. Call BatchInsert with empty URI and values vector
1145 5. Check if returned result is negative
1146 * @tc.expect:
1147 1. BatchInsert operation returns negative value
1148 */
1149 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchInsertTest_002, TestSize.Level0)
1150 {
1151 LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_002::Start");
1152 Uri uri("");
1153 sptr<DataShare::DataShareConnection> connection =
1154 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
1155 auto dataShareConnection =
__anon068e7a381202(const auto *) 1156 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
1157 holder->DisconnectDataShareExtAbility();
1158 });
1159 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1160 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
1161 DataShare::DataShareValuesBucket valuesBucket1;
1162 valuesBucket1.Put("name", "dataShareTest006");
1163 valuesBucket1.Put("phoneNumber", 20.6);
1164 DataShare::DataShareValuesBucket valuesBucket2;
1165 valuesBucket2.Put("name", "dataShareTest007");
1166 valuesBucket2.Put("phoneNumber", 20.5);
1167 std::vector<DataShare::DataShareValuesBucket> values;
1168 values.push_back(valuesBucket1);
1169 values.push_back(valuesBucket2);
1170 int result = tempExtSpeCon->BatchInsert(uri, values);
1171 EXPECT_EQ((result < 0), true);
1172 LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_002::End");
1173 }
1174
1175 /**
1176 * @tc.name: ControllerTest_ExtSpecialControllerBatchUpdateTest_001
1177 * @tc.desc: Verify BatchUpdate operation with null connection in ExtSpecialController
1178 * @tc.type: FUNC
1179 * @tc.precon: None
1180 * @tc.step:
1181 1. Create ExtSpecialController with null connection and empty URI
1182 2. Prepare empty UpdateOperations and results vector
1183 3. Call BatchUpdate with operations and results
1184 4. Check if returned result is -1
1185 * @tc.expect:
1186 1. BatchUpdate operation returns -1
1187 */
1188 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchUpdateTest_001, TestSize.Level0)
1189 {
1190 LOG_INFO("ControllerTest_ExtSpecialControllerBatchUpdateTest_001::Start");
1191 Uri uri("");
1192 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1193 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
1194 DataShare::UpdateOperations operations;
1195 std::vector<DataShare::BatchUpdateResult> results;
1196 int result = tempExtSpeCon->BatchUpdate(operations, results);
1197 EXPECT_EQ(result, -1);
1198 LOG_INFO("ControllerTest_ExtSpecialControllerBatchUpdateTest_001::End");
1199 }
1200
1201 /**
1202 * @tc.name: ControllerTest_ExtSpecialControllerBatchUpdateTest_002
1203 * @tc.desc: Verify BatchUpdate operation with valid connection but unconnected state in ExtSpecialController
1204 * @tc.type: FUNC
1205 * @tc.precon: None
1206 * @tc.step:
1207 1. Create DataShareConnection with empty URI
1208 2. Create ExtSpecialController with the connection and empty URI
1209 3. Prepare empty UpdateOperations and results vector
1210 4. Call BatchUpdate with operations and results
1211 5. Check if returned result is -1
1212 * @tc.expect:
1213 1. BatchUpdate operation returns -1
1214 */
1215 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchUpdateTest_002, TestSize.Level0)
1216 {
1217 LOG_INFO("ControllerTest_ExtSpecialControllerBatchUpdateTest_002::Start");
1218 Uri uri("");
1219 sptr<DataShare::DataShareConnection> connection =
1220 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
1221 auto dataShareConnection =
__anon068e7a381302(const auto *) 1222 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
1223 holder->DisconnectDataShareExtAbility();
1224 });
1225 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1226 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
1227 DataShare::UpdateOperations operations;
1228 std::vector<DataShare::BatchUpdateResult> results;
1229 int result = tempExtSpeCon->BatchUpdate(operations, results);
1230 EXPECT_EQ(result, -1);
1231 LOG_INFO("ControllerTest_ExtSpecialControllerBatchUpdateTest_002::End");
1232 }
1233
1234 /**
1235 * @tc.name: ControllerTest_ExtSpecialControllerInsertExtTest_001
1236 * @tc.desc: Verify InsertExt operation with null connection in ExtSpecialController
1237 * @tc.type: FUNC
1238 * @tc.precon: None
1239 * @tc.step:
1240 1. Create ExtSpecialController with null connection and empty URI
1241 2. Prepare DataShareValuesBucket with test data and result string
1242 3. Call InsertExt with empty URI, values bucket and result string
1243 4. Check if returned result is -1
1244 * @tc.expect:
1245 1. InsertExt operation returns -1
1246 */
1247 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerInsertExtTest_001, TestSize.Level0)
1248 {
1249 LOG_INFO("ControllerTest_ExtSpecialControllerInsertExtTest_001::Start");
1250 Uri uri("");
1251 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1252 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
1253 DataShare::DataShareValuesBucket valuesBucket;
1254 valuesBucket.Put("name", "dataShareTest006");
1255 valuesBucket.Put("phoneNumber", 20.6);
1256 std::string result1 = "test001";
1257 int result = tempExtSpeCon->InsertExt(uri, valuesBucket, result1);
1258 EXPECT_EQ(result, -1);
1259 LOG_INFO("ControllerTest_ExtSpecialControllerInsertExtTest_001::End");
1260 }
1261
1262 /**
1263 * @tc.name: ControllerTest_ExtSpecialControllerInsertExtTest_002
1264 * @tc.desc: Verify InsertExt operation with valid connection but unconnected state in ExtSpecialController
1265 * @tc.type: FUNC
1266 * @tc.precon: None
1267 * @tc.step:
1268 1. Create DataShareConnection with empty URI
1269 2. Create ExtSpecialController with the connection and empty URI
1270 3. Prepare DataShareValuesBucket with test data and result string
1271 4. Call InsertExt with empty URI, values bucket and result string
1272 5. Check if returned result is -1
1273 * @tc.expect:
1274 1. InsertExt operation returns -1
1275 */
1276 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerInsertExtTest_002, TestSize.Level0)
1277 {
1278 LOG_INFO("ControllerTest_ExtSpecialControllerInsertExtTest_002::Start");
1279 Uri uri("");
1280 sptr<DataShare::DataShareConnection> connection =
1281 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
1282 auto dataShareConnection =
__anon068e7a381402(const auto *) 1283 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
1284 holder->DisconnectDataShareExtAbility();
1285 });
1286 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1287 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
1288 DataShare::DataShareValuesBucket valuesBucket;
1289 valuesBucket.Put("name", "dataShareTest006");
1290 valuesBucket.Put("phoneNumber", 20.6);
1291 std::string result1 = "test001";
1292 int result = tempExtSpeCon->InsertExt(uri, valuesBucket, result1);
1293 EXPECT_EQ(result, -1);
1294 LOG_INFO("ControllerTest_ExtSpecialControllerInsertExtTest_002::End");
1295 }
1296
1297 /**
1298 * @tc.name: ControllerTest_ExtSpecialControllerExecuteBatchTest_001
1299 * @tc.desc: Verify ExecuteBatch operation with null connection in ExtSpecialController
1300 * @tc.type: FUNC
1301 * @tc.precon: None
1302 * @tc.step:
1303 1. Create ExtSpecialController with null connection and empty URI
1304 2. Prepare empty OperationStatement vector and ExecResultSet
1305 3. Call ExecuteBatch with statements and result set
1306 4. Check if returned result is -1
1307 * @tc.expect:
1308 1. ExecuteBatch operation returns -1
1309 */
1310 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerExecuteBatchTest_001, TestSize.Level0)
1311 {
1312 LOG_INFO("ControllerTest_ExtSpecialControllerExecuteBatchTest_001::Start");
1313 Uri uri("");
1314 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1315 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
1316 std::vector<DataShare::OperationStatement> statements;
1317 std::vector<DataShare::BatchUpdateResult> results;
1318 ExecResultSet result1;
1319 int result = tempExtSpeCon->ExecuteBatch(statements, result1);
1320 EXPECT_EQ(result, -1);
1321 LOG_INFO("ControllerTest_ExtSpecialControllerExecuteBatchTest_001::End");
1322 }
1323
1324 /**
1325 * @tc.name: ControllerTest_ExtSpecialControllerExecuteBatchTest_002
1326 * @tc.desc: Verify ExecuteBatch operation with valid connection but unconnected state in ExtSpecialController
1327 * @tc.type: FUNC
1328 * @tc.precon: None
1329 * @tc.step:
1330 1. Create DataShareConnection with empty URI
1331 2. Create ExtSpecialController with the connection and empty URI
1332 3. Prepare empty OperationStatement vector and ExecResultSet
1333 4. Call ExecuteBatch with statements and result set
1334 5. Check if returned result is -1
1335 * @tc.expect:
1336 1. ExecuteBatch operation returns -1
1337 */
1338 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerExecuteBatchTest_002, TestSize.Level0)
1339 {
1340 LOG_INFO("ControllerTest_ExtSpecialControllerExecuteBatchTest_002::Start");
1341 Uri uri("");
1342 sptr<DataShare::DataShareConnection> connection =
1343 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
1344 auto dataShareConnection =
__anon068e7a381502(const auto *) 1345 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
1346 holder->DisconnectDataShareExtAbility();
1347 });
1348 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1349 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
1350 std::vector<DataShare::OperationStatement> statements;
1351 std::vector<DataShare::BatchUpdateResult> results;
1352 ExecResultSet result1;
1353 int result = tempExtSpeCon->ExecuteBatch(statements, result1);
1354 EXPECT_EQ(result, -1);
1355 LOG_INFO("ControllerTest_ExtSpecialControllerExecuteBatchTest_002::End");
1356 }
1357
1358 /**
1359 * @tc.name: ControllerTest_ExtSpecialControllerGetFileTypesTest_001
1360 * @tc.desc: Verify GetFileTypes operation with null connection in ExtSpecialController
1361 * @tc.type: FUNC
1362 * @tc.precon: None
1363 * @tc.step:
1364 1. Create ExtSpecialController with null connection and empty URI
1365 2. Call GetFileTypes with empty URI and test type string
1366 3. Check if returned result is empty vector
1367 * @tc.expect:
1368 1. GetFileTypes operation returns empty vector
1369 */
1370 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerGetFileTypesTest_001, TestSize.Level0)
1371 {
1372 LOG_INFO("ControllerTest_ExtSpecialControllerGetFileTypesTest_001::Start");
1373 Uri uri("");
1374 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1375 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
1376 std::string getFileTypes = "test001";
1377 std::vector<std::string> result = tempExtSpeCon->GetFileTypes(uri, getFileTypes);
1378 EXPECT_EQ(result, std::vector<std::string>());
1379 LOG_INFO("ControllerTest_ExtSpecialControllerGetFileTypesTest_001::End");
1380 }
1381
1382 /**
1383 * @tc.name: ControllerTest_ExtSpecialControlleGetFileTypesTest_002
1384 * @tc.desc: Verify GetFileTypes operation with valid connection but unconnected state in ExtSpecialController
1385 * @tc.type: FUNC
1386 * @tc.precon: None
1387 * @tc.step:
1388 1. Create DataShareConnection with empty URI
1389 2. Create ExtSpecialController with the connection and empty URI
1390 3. Call GetFileTypes with empty URI and test type string
1391 4. Check if returned result is empty vector
1392 * @tc.expect:
1393 1. GetFileTypes operation returns empty vector
1394 */
1395 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControlleGetFileTypesTest_002, TestSize.Level0)
1396 {
1397 LOG_INFO("ControllerTest_ExtSpecialControllerGetFileTypesTest_002::Start");
1398 Uri uri("");
1399 sptr<DataShare::DataShareConnection> connection =
1400 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
1401 auto dataShareConnection =
__anon068e7a381602(const auto *) 1402 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
1403 holder->DisconnectDataShareExtAbility();
1404 });
1405 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1406 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
1407 std::string getFileTypes = "test001";
1408 std::vector<std::string> result = tempExtSpeCon->GetFileTypes(uri, getFileTypes);
1409 EXPECT_EQ(result, std::vector<std::string>());
1410 LOG_INFO("ControllerTest_ExtSpecialControllerGetFileTypesTest_002::End");
1411 }
1412
1413 /**
1414 * @tc.name: ControllerTest_ExtSpecialControllerNormalizeUriTest_001
1415 * @tc.desc: Verify NormalizeUri operation with null connection in ExtSpecialController
1416 * @tc.type: FUNC
1417 * @tc.precon: None
1418 * @tc.step:
1419 1. Create ExtSpecialController with null connection and empty URI
1420 2. Call NormalizeUri with empty URI
1421 3. Check if returned result is empty URI
1422 * @tc.expect:
1423 1. NormalizeUri operation returns empty URI
1424 */
1425 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerNormalizeUriTest_001, TestSize.Level0)
1426 {
1427 LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_001::Start");
1428 Uri uri("");
1429 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1430 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
1431 Uri result = tempExtSpeCon->NormalizeUri(uri);
1432 EXPECT_EQ(result, Uri(""));
1433 LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_001::End");
1434 }
1435
1436 /**
1437 * @tc.name: ControllerTest_ExtSpecialControllerNormalizeUriTest_002
1438 * @tc.desc: Verify NormalizeUri operation with valid connection but unconnected state in ExtSpecialController
1439 * @tc.type: FUNC
1440 * @tc.precon: None
1441 * @tc.step:
1442 1. Create DataShareConnection with empty URI
1443 2. Create ExtSpecialController with the connection and empty URI
1444 3. Call NormalizeUri with empty URI
1445 4. Check if returned result is empty URI
1446 * @tc.expect:
1447 1. NormalizeUri operation returns empty URI
1448 */
1449 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerNormalizeUriTest_002, TestSize.Level0)
1450 {
1451 LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_002::Start");
1452 Uri uri("");
1453 sptr<DataShare::DataShareConnection> connection =
1454 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
1455 auto dataShareConnection =
__anon068e7a381702(const auto *) 1456 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
1457 holder->DisconnectDataShareExtAbility();
1458 });
1459 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1460 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
1461 Uri result = tempExtSpeCon->NormalizeUri(uri);
1462 EXPECT_EQ(result, Uri(""));
1463 LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_002::End");
1464 }
1465
1466 /**
1467 * @tc.name: ControllerTest_ExtSpecialControllerDenormalizeUriTest_001
1468 * @tc.desc: Verify DenormalizeUri operation with null connection in ExtSpecialController
1469 * @tc.type: FUNC
1470 * @tc.precon: None
1471 * @tc.step:
1472 1. Create ExtSpecialController with null connection and empty URI
1473 2. Call DenormalizeUri with empty URI
1474 3. Check if returned result is empty URI
1475 * @tc.expect:
1476 1. DenormalizeUri operation returns empty URI
1477 */
1478 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerDenormalizeUriTest_001, TestSize.Level0)
1479 {
1480 LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_001::Start");
1481 Uri uri("");
1482 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1483 std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
1484 Uri result = tempExtSpeCon->DenormalizeUri(uri);
1485 EXPECT_EQ(result, Uri(""));
1486 LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_001::End");
1487 }
1488
1489 /**
1490 * @tc.name: ControllerTest_ExtSpecialControllerDenormalizeUriTest_002
1491 * @tc.desc: Verify DenormalizeUri operation with valid connection but unconnected state in ExtSpecialController
1492 * @tc.type: FUNC
1493 * @tc.precon: None
1494 * @tc.step:
1495 1. Create DataShareConnection with empty URI
1496 2. Create ExtSpecialController with the connection and empty URI
1497 3. Call DenormalizeUri with empty URI
1498 4. Check if returned result is empty URI
1499 * @tc.expect:
1500 1. DenormalizeUri operation returns empty URI
1501 */
1502 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerDenormalizeUriTest_002, TestSize.Level0)
1503 {
1504 LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_002::Start");
1505 Uri uri("");
1506 sptr<DataShare::DataShareConnection> connection =
1507 new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
1508 auto dataShareConnection =
__anon068e7a381802(const auto *) 1509 std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
1510 holder->DisconnectDataShareExtAbility();
1511 });
1512 std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
1513 std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
1514 Uri result = tempExtSpeCon->DenormalizeUri(uri);
1515 EXPECT_EQ(result, Uri(""));
1516 LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_002::End");
1517 }
1518 } // namespace DataShare
1519 } // namespace OHOS
1520