1 /*
2 * Copyright (C) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "app_details_meta_item.h"
17 #include "app_details_rdb_item.h"
18 #include "cpp/condition_variable.h"
19 #include "cpp/mutex.h"
20 #include "cpp/task.h"
21 #include "skill.h"
22 #include "gtest/gtest.h"
23 #include <chrono>
24 #include <memory>
25 #include <mutex>
26 #include <semaphore>
27 #include <string>
28 #include <thread>
29 #include <vector>
30 #include "app_domain_verify_hilog.h"
31 #include "rdb_helper.h"
32 #include "app_details_rdb_open_callback.h"
33 #include "app_details_rdb_const_define.h"
34 #define private public
35 #define protected public
36 #include "app_details_rdb_data_manager.h"
37 #include "app_details_rdb_open_callback.h"
38 #include "bundle_verify_status_info.h"
39 #undef private
40 #undef protected
41 #include "mock_rdb.h"
42
43 namespace OHOS::AppDomainVerify {
44 using namespace testing;
45 using namespace testing::ext;
46 class AppDetailsRdbMgrTest : public testing::Test {
47 public:
48 static void SetUpTestCase(void);
49 static void TearDownTestCase(void);
50 void SetUp();
51 void TearDown();
52 static std::string rdbName;
53 static std::string rdbPath;
54 static int rdbVersion;
55 };
56
57 std::string AppDetailsRdbMgrTest::rdbName = "test.db";
58 std::string AppDetailsRdbMgrTest::rdbPath = "/data/test/";
59 int AppDetailsRdbMgrTest::rdbVersion = 1;
60
SetUpTestCase(void)61 void AppDetailsRdbMgrTest::SetUpTestCase(void)
62 {
63 }
64
TearDownTestCase(void)65 void AppDetailsRdbMgrTest::TearDownTestCase(void)
66 {
67 }
68
SetUp(void)69 void AppDetailsRdbMgrTest::SetUp(void)
70 {
71 }
72
TearDown(void)73 void AppDetailsRdbMgrTest::TearDown(void)
74 {
75 std::vector<std::string> tmpFileVec = { rdbPath + rdbName, rdbPath + rdbName + "-shm", rdbPath + rdbName + "-wal" };
76 for (auto& filePath : tmpFileVec) {
77 (void)remove(filePath.c_str());
78 }
79 }
80
81 /**
82 * @tc.name: AppDetailsRdbMgrTest001
83 * @tc.desc: test table op
84 * @tc.type: FUNC
85 */
86 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest001, TestSize.Level0)
87 {
88 RdbConfigInfo info;
89 info.rdbName = AppDetailsRdbMgrTest::rdbName;
90 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
91 info.version = AppDetailsRdbMgrTest::rdbVersion;
92 auto rdbMgr = std::make_shared<AppDetailsRdbDataMgr>(info);
93 bool ret = rdbMgr->DeleteTable("app_details");
94 ASSERT_TRUE(ret);
95 ret = rdbMgr->CreateTable("app_details");
96 ASSERT_TRUE(ret);
97 ret = rdbMgr->CreateTable("app_details_tmp");
98 ASSERT_TRUE(ret);
99 ret = rdbMgr->DeleteTable("app_details_del");
100 ASSERT_TRUE(ret);
101 ret = rdbMgr->RenameTable("app_details", "app_details_del");
102 ASSERT_TRUE(ret);
103 ret = rdbMgr->DeleteTable("app_details_del");
104 ASSERT_TRUE(ret);
105 ret = rdbMgr->DeleteTable("app_details_tmp");
106 ASSERT_TRUE(ret);
107 ASSERT_TRUE(rdbMgr->GetDbVersion() == std::to_string(APP_DETAILS_RDB_VERSION));
108 }
109
110 /**
111 * @tc.name: AppDetailsRdbMgrTest002
112 * @tc.desc: test insert del query op
113 * @tc.type: FUNC
114 */
115 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest002, TestSize.Level0)
116 {
117 RdbConfigInfo info;
118 info.rdbName = AppDetailsRdbMgrTest::rdbName;
119 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
120 info.version = AppDetailsRdbMgrTest::rdbVersion;
121 auto rdbMgr = std::make_shared<AppDetailsRdbDataMgr>(info);
122 bool ret = rdbMgr->DeleteTable("app_details");
123 ASSERT_TRUE(ret);
124 ret = rdbMgr->CreateTable("app_details");
125 ASSERT_TRUE(ret);
126 std::vector<AppDetailsRdbItem> itemVec;
127 AppDetailsRdbItem item;
128 item.id = "111";
129 item.scheme = "https";
130 item.domain = "www.test.com";
131 item.pathType = "path";
132 item.path = "test";
133 item.bundleName = "com.test.bundleNameTest";
134 itemVec.push_back(item);
135 ret = rdbMgr->InsertDataBatch("app_details", itemVec);
136 ASSERT_TRUE(ret);
137 ret = rdbMgr->CreateRegularIndex("app_details", DETAILS_DOMAIN);
138 ASSERT_TRUE(ret);
139 std::vector<AppDetailsRdbItem> itemRetVec;
140 ret = rdbMgr->QueryDataByDomain("app_details", item.domain, itemRetVec);
141 ASSERT_TRUE(ret);
142 ASSERT_TRUE(itemRetVec.size() != 0);
143 auto rdbitem = itemRetVec[0];
144 ASSERT_EQ(rdbitem.bundleName, item.bundleName);
145 ret = rdbMgr->DeleteTable("app_details");
146 ASSERT_TRUE(ret);
147 }
148
149 /**
150 * @tc.name: AppDetailsRdbMgrTest003
151 * @tc.desc: test meta data
152 * @tc.type: FUNC
153 */
154 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest003, TestSize.Level0)
155 {
156 RdbConfigInfo info;
157 info.rdbName = AppDetailsRdbMgrTest::rdbName;
158 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
159 info.version = AppDetailsRdbMgrTest::rdbVersion;
160 auto rdbMgr = std::make_shared<AppDetailsRdbDataMgr>(info);
161 bool ret = rdbMgr->CreateMetaData();
162 ASSERT_TRUE(ret);
163 ret = rdbMgr->CreateMetaData();
164 ASSERT_TRUE(ret);
165 MetaItem item;
166 item.tableExtInfo = "tableExtInfo";
167 item.tableName = "app_details";
168 item.tableVersion = "1.0";
169 item.updateTime = "111111";
170 std::vector<MetaItem> itemVec;
171 itemVec.push_back(item);
172 ret = rdbMgr->UpdateMetaData(itemVec);
173 ASSERT_TRUE(ret);
174 MetaItem queryItem;
175 ret = rdbMgr->QueryMetaData(item.tableName, queryItem);
176 ASSERT_TRUE(ret);
177 ASSERT_TRUE(queryItem.tableExtInfo == item.tableExtInfo);
178 ret = rdbMgr->DeleteTable("META_DATA");
179 ASSERT_TRUE(ret);
180 }
181
182 /**
183 * @tc.name: AppDetailsRdbMgrTest004
184 * @tc.desc: test transaction
185 * @tc.type: FUNC
186 */
187 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest004, TestSize.Level0)
188 {
189 RdbConfigInfo info;
190 info.rdbName = AppDetailsRdbMgrTest::rdbName;
191 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
192 info.version = AppDetailsRdbMgrTest::rdbVersion;
193 auto rdbMgr = std::make_shared<AppDetailsRdbDataMgr>(info);
194 auto ret = rdbMgr->CreateTable("app_details");
195 std::vector<AppDetailsRdbItem> itemVec;
196 AppDetailsRdbItem item;
197 item.id = "111";
198 item.scheme = "https";
199 item.domain = "www.test.com";
200 item.pathType = "path";
201 item.path = "test";
202 item.bundleName = "com.test.bundleNameTest";
203 itemVec.push_back(item);
204 ret = rdbMgr->InsertDataBatch("app_details", itemVec);
205 ASSERT_TRUE(ret);
__anona2bd5c1a0102() 206 bool retFlag = rdbMgr->ExecWithTrans([&]() -> bool {
207 auto ret = rdbMgr->DeleteTable("app_details");
208 return false;
209 });
210 ASSERT_FALSE(retFlag);
211 std::vector<AppDetailsRdbItem> result;
212 ret = rdbMgr->QueryDataByDomain("app_details", item.domain, result);
213 ASSERT_TRUE(ret);
__anona2bd5c1a0202() 214 retFlag = rdbMgr->ExecWithTrans([&]() -> bool {
215 auto ret = rdbMgr->DeleteTable("app_details");
216 return true;
217 });
218 ASSERT_TRUE(retFlag);
219 result.clear();
220 ret = rdbMgr->QueryDataByDomain("app_details", item.domain, result);
221 ASSERT_FALSE(ret);
222 }
223
224 /**
225 * @tc.name: AppDetailsRdbMgrTest005
226 * @tc.desc: test delayClose
227 * @tc.type: FUNC
228 */
229 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest005, TestSize.Level0)
230 {
231 RdbConfigInfo info;
232 info.rdbName = AppDetailsRdbMgrTest::rdbName;
233 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
234 info.version = AppDetailsRdbMgrTest::rdbVersion;
235 auto rdbMgr = std::make_shared<AppDetailsRdbDataMgr>(info);
236 auto rdbStore = rdbMgr->GetRdbStore();
237 ASSERT_TRUE(rdbStore != nullptr);
238 rdbMgr->PostDelayCloseTask(100);
239 std::this_thread::sleep_for(std::chrono::milliseconds(200));
240 ASSERT_TRUE(rdbMgr->rdbStore_ == nullptr);
241 }
242
243 /**
244 * @tc.name: AppDetailsRdbMgrTest006
245 * @tc.desc: test trans for muti table
246 * @tc.type: FUNC
247 */
248 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest006, TestSize.Level0)
249 {
250 RdbConfigInfo info;
251 info.rdbName = AppDetailsRdbMgrTest::rdbName;
252 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
253 info.version = AppDetailsRdbMgrTest::rdbVersion;
254 auto rdbMgr = std::make_shared<AppDetailsRdbDataMgr>(info);
255 auto ret = rdbMgr->CreateTable("app_details");
256 rdbMgr->closeHandler_->RemoveTask("closeRdb");
257 std::vector<AppDetailsRdbItem> itemVec;
258 AppDetailsRdbItem item;
259 item.id = "111";
260 item.scheme = "https";
261 item.domain = "www.test.com";
262 item.pathType = "path";
263 item.path = "test";
264 item.bundleName = "com.test.bundleNameTest";
265 itemVec.push_back(item);
266 ret = rdbMgr->InsertDataBatch("app_details", itemVec);
267 std::vector<AppDetailsRdbItem> result;
268 std::atomic_bool checkFlag = false;
269 std::binary_semaphore sem(0);
270 ret = rdbMgr->QueryDataByDomain("app_details", item.domain, result);
271 ASSERT_TRUE(ret);
272 ASSERT_TRUE(result.size() != 0);
__anona2bd5c1a0302() 273 auto task = [&sem, &checkFlag, rdbMgr]() {
274 rdbMgr->ExecWithTrans([&sem, &checkFlag]() -> bool {
275 sem.acquire();
276 checkFlag = true;
277 return true;
278 });
279 return;
280 };
281 rdbMgr->closeHandler_->PostTask(task, "closeRdb", 0);
282 std::this_thread::sleep_for(std::chrono::milliseconds(500));
283 bool flag = rdbMgr->rdbStore_->IsInTransaction();
284 ASSERT_TRUE(flag);
285 ASSERT_FALSE(checkFlag);
286 result.clear();
287 ASSERT_TRUE(result.size() == 0);
288 ret = rdbMgr->QueryDataByDomain("app_details", "www.test.com", result);
289 ASSERT_TRUE(result.size() != 0);
290 sem.release();
291 std::this_thread::sleep_for(std::chrono::milliseconds(10));
292 ASSERT_TRUE(checkFlag);
293 }
294 /**
295 * @tc.name: AppDetailsRdbCallBackTest001
296 * @tc.desc: test trans for muti table
297 * @tc.type: FUNC
298 */
299 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbCallBackTest001, TestSize.Level0)
300 {
301 RdbConfigInfo rdbConfig;
302 rdbConfig.rdbName = AppDetailsRdbMgrTest::rdbName;
303 rdbConfig.rdbPath = AppDetailsRdbMgrTest::rdbPath;
304 rdbConfig.version = AppDetailsRdbMgrTest::rdbVersion;
305 int32_t errCode = NativeRdb::E_OK;
306 AppDetailsRdbOpenCallback callback(rdbConfig);
307
308 NativeRdb::RdbStoreConfig rdbStoreConfig(rdbConfig.rdbPath + rdbConfig.rdbName);
309 rdbStoreConfig.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
310 auto rdbStored = NativeRdb::RdbHelper::GetRdbStore(rdbStoreConfig, rdbConfig.version, callback, errCode);
311 ASSERT_TRUE(callback.OnCreate(*rdbStored) == NativeRdb::E_OK);
312 ASSERT_TRUE(callback.OnUpgrade(*rdbStored, 3, 3) == NativeRdb::E_OK);
313 ASSERT_TRUE(callback.OnDowngrade(*rdbStored, 2, 1) == NativeRdb::E_OK);
314 ASSERT_TRUE(callback.onCorruption("") == NativeRdb::E_OK);
315 }
316
317 /**
318 * @tc.name: AppDetailsRdbMgrTest007
319 * @tc.desc: test meta data
320 * @tc.type: FUNC
321 */
322 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest007, TestSize.Level0)
323 {
324 RdbConfigInfo info;
325 info.rdbName = AppDetailsRdbMgrTest::rdbName;
326 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
327 info.version = AppDetailsRdbMgrTest::rdbVersion;
328 auto rdbMgr = std::make_shared<AppDetailsRdbDataMgr>(info);
329 auto ret = rdbMgr->CreateTable("app_details");
330 EXPECT_TRUE(ret);
331 MetaItem itemQ;
332 ret = rdbMgr->QueryMetaData("app_details", itemQ);
333 EXPECT_FALSE(ret);
334 ret = rdbMgr->DeleteTable("app_details");
335 EXPECT_TRUE(ret);
336 }
337
338 /**
339 * @tc.name: AppDetailsRdbMgrTest008
340 * @tc.desc: test meta data
341 * @tc.type: FUNC
342 */
343 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest008, TestSize.Level0)
344 {
345 RdbConfigInfo info;
346 info.rdbName = AppDetailsRdbMgrTest::rdbName;
347 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
348 info.version = AppDetailsRdbMgrTest::rdbVersion;
349 auto rdbMgr = std::make_shared<AppDetailsRdbDataMgr>(info);
350 bool ret = rdbMgr->CreateMetaData();
351 EXPECT_TRUE(ret);
352 std::string colName = "col1";
353 ret = rdbMgr->CreateRegularIndex("META_DATA", colName);
354 EXPECT_FALSE(ret);
355 ret = rdbMgr->DeleteTable("META_DATA");
356 EXPECT_TRUE(ret);
357 }
358
359 /**
360 * @tc.name: AppDetailsRdbMgrTest009
361 * @tc.desc: test meta data
362 * @tc.type: FUNC
363 */
364 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbMgrTest009, TestSize.Level0)
365 {
366 RdbConfigInfo info;
367 info.rdbName = AppDetailsRdbMgrTest::rdbName;
368 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
369 info.version = AppDetailsRdbMgrTest::rdbVersion;
370 auto rdbMgr = std::make_shared<AppDetailsRdbDataMgr>(info);
371 bool ret = rdbMgr->CreateMetaData();
372 ASSERT_TRUE(ret);
373 auto version = rdbMgr->GetDbVersion();
374 EXPECT_NE(version, "");
375 }
376
377 class RdbStoreToTest : public NativeRdb::RdbStore {
378 public:
379 int Delete(int& deletedRows, const std::string& table, const std::string& whereClause = "",
380 const Values& args = {}) override;
381 std::shared_ptr<AbsSharedResultSet> QuerySql(const std::string& sql, const Values& args = {}) override;
382 std::shared_ptr<ResultSet> QueryByStep(
383 const std::string& sql, const Values& args = {}, bool preCount = true) override;
384 int GetVersion(int& version) override;
385 int SetVersion(int version) override;
386 };
387
Delete(int & deletedRows,const std::string & table,const std::string & whereClause,const Values & args)388 int RdbStoreToTest::Delete(
389 int& deletedRows, const std::string& table, const std::string& whereClause, const Values& args)
390 {
391 return -1;
392 }
393
QuerySql(const std::string & sql,const Values & args)394 std::shared_ptr<AbsSharedResultSet> RdbStoreToTest::QuerySql(const std::string& sql, const Values& args)
395 {
396 return nullptr;
397 }
398
QueryByStep(const std::string & sql,const Values & args,bool preCount)399 std::shared_ptr<ResultSet> RdbStoreToTest::QueryByStep(const std::string& sql, const Values& args, bool preCount)
400 {
401 return nullptr;
402 }
403
GetVersion(int & version)404 int RdbStoreToTest::GetVersion(int& version)
405 {
406 return version;
407 }
408
SetVersion(int version)409 int RdbStoreToTest::SetVersion(int version)
410 {
411 return version;
412 }
413
414 /**
415 * @tc.name: AppDetailsRdbOpenCallback001
416 * @tc.desc: test meta data
417 * @tc.type: FUNC
418 */
419 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbOpenCallback001, TestSize.Level0)
420 {
421 RdbConfigInfo info;
422 info.rdbName = AppDetailsRdbMgrTest::rdbName;
423 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
424 info.version = AppDetailsRdbMgrTest::rdbVersion;
425 AppDetailsRdbOpenCallback rdbMgr(info);
426 RdbStoreToTest rdbStore;
427 auto ret = rdbMgr.OnUpgrade(rdbStore, 1, 2);
428 EXPECT_EQ(ret, NativeRdb::E_OK);
429 }
430
431 /**
432 * @tc.name: AppDetailsRdbOpenCallback002
433 * @tc.desc: test meta data
434 * @tc.type: FUNC
435 */
436 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbOpenCallback002, TestSize.Level0)
437 {
438 RdbConfigInfo info;
439 info.rdbName = AppDetailsRdbMgrTest::rdbName;
440 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
441 info.version = AppDetailsRdbMgrTest::rdbVersion;
442 AppDetailsRdbOpenCallback rdbMgr(info);
443 RdbStoreToTest rdbStore;
444 auto ret = rdbMgr.OnUpgrade(rdbStore, 2, 1);
445 EXPECT_EQ(ret, NativeRdb::E_OK);
446 }
447
448 /**
449 * @tc.name: AppDetailsRdbOpenCallback003
450 * @tc.desc: test meta data
451 * @tc.type: FUNC
452 */
453 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbOpenCallback003, TestSize.Level0)
454 {
455 RdbConfigInfo info;
456 info.rdbName = AppDetailsRdbMgrTest::rdbName;
457 info.rdbPath = AppDetailsRdbMgrTest::rdbPath;
458 info.version = AppDetailsRdbMgrTest::rdbVersion;
459 AppDetailsRdbOpenCallback rdbMgr(info);
460 std::string databaseFile = "databaseFile";
461 auto ret = rdbMgr.onCorruption(databaseFile);
462 EXPECT_EQ(ret, NativeRdb::E_OK);
463 }
464
465 /**
466 * @tc.name: VerifyResultInfo001
467 * @tc.desc: test meta data
468 * @tc.type: FUNC
469 */
470 HWTEST_F(AppDetailsRdbMgrTest, VerifyResultInfo001, TestSize.Level0)
471 {
472 VerifyResultInfo info;
473 auto ret = info.Dump();
474 EXPECT_NE(ret, "");
475 }
476
477 /**
478 * @tc.name: AppDetailsRdbItemTest001
479 * @tc.desc: AppDetailsRdbItem test
480 * @tc.type: FUNC
481 */
482 HWTEST_F(AppDetailsRdbMgrTest, AppDetailsRdbItemTest001, TestSize.Level0)
483 {
484 std::shared_ptr<MockResultSet> moc = std::make_shared<MockResultSet>();
485 EXPECT_CALL(*moc, GetString(DETAILS_ID_INDEX, _)).WillOnce(Return(1));
486 std::shared_ptr<AbsSharedResultSet> impl = moc;
487 AppDetailsRdbItem item;
488 ASSERT_FALSE(item.GetRdbItem(impl));
489
490 std::shared_ptr<MockResultSet> moc1 = std::make_shared<MockResultSet>();
491 EXPECT_CALL(*moc1, GetString(DETAILS_ID_INDEX, _)).WillOnce(Return(0));
492 EXPECT_CALL(*moc1, GetString(DETAILS_SCHEME_INDEX, _)).WillOnce(Return(1));
493 impl = moc1;
494 ASSERT_FALSE(item.GetRdbItem(impl));
495
496 std::shared_ptr<MockResultSet> moc2 = std::make_shared<MockResultSet>();
497 EXPECT_CALL(*moc2, GetString(DETAILS_ID_INDEX, _)).WillOnce(Return(0));
498 EXPECT_CALL(*moc2, GetString(DETAILS_SCHEME_INDEX, _)).WillOnce(Return(0));
499 EXPECT_CALL(*moc2, GetString(DETAILS_DOMAIN_INDEX, _)).WillOnce(Return(1));
500 impl = moc2;
501 ASSERT_FALSE(item.GetRdbItem(impl));
502
503 std::shared_ptr<MockResultSet> moc3 = std::make_shared<MockResultSet>();
504 EXPECT_CALL(*moc3, GetString(DETAILS_ID_INDEX, _)).WillOnce(Return(0));
505 EXPECT_CALL(*moc3, GetString(DETAILS_SCHEME_INDEX, _)).WillOnce(Return(0));
506 EXPECT_CALL(*moc3, GetString(DETAILS_DOMAIN_INDEX, _)).WillOnce(Return(0));
507 EXPECT_CALL(*moc3, GetString(DETAILS_PATH_TYPE_INDEX, _)).WillOnce(Return(1));
508 impl = moc3;
509 ASSERT_FALSE(item.GetRdbItem(impl));
510
511 std::shared_ptr<MockResultSet> moc4 = std::make_shared<MockResultSet>();
512 EXPECT_CALL(*moc4, GetString(DETAILS_ID_INDEX, _)).WillOnce(Return(0));
513 EXPECT_CALL(*moc4, GetString(DETAILS_SCHEME_INDEX, _)).WillOnce(Return(0));
514 EXPECT_CALL(*moc4, GetString(DETAILS_DOMAIN_INDEX, _)).WillOnce(Return(0));
515 EXPECT_CALL(*moc4, GetString(DETAILS_PATH_TYPE_INDEX, _)).WillOnce(Return(0));
516 EXPECT_CALL(*moc4, GetString(DETAILS_PATH_INDEX, _)).WillOnce(Return(1));
517 impl = moc4;
518 ASSERT_FALSE(item.GetRdbItem(impl));
519
520 std::shared_ptr<MockResultSet> moc5 = std::make_shared<MockResultSet>();
521 EXPECT_CALL(*moc5, GetString(DETAILS_ID_INDEX, _)).WillOnce(Return(0));
522 EXPECT_CALL(*moc5, GetString(DETAILS_SCHEME_INDEX, _)).WillOnce(Return(0));
523 EXPECT_CALL(*moc5, GetString(DETAILS_DOMAIN_INDEX, _)).WillOnce(Return(0));
524 EXPECT_CALL(*moc5, GetString(DETAILS_PATH_TYPE_INDEX, _)).WillOnce(Return(0));
525 EXPECT_CALL(*moc5, GetString(DETAILS_PATH_INDEX, _)).WillOnce(Return(0));
526 EXPECT_CALL(*moc5, GetString(DETAILS_BUNDLE_NAME_INDEX, _)).WillOnce(Return(1));
527 impl = moc5;
528 ASSERT_FALSE(item.GetRdbItem(impl));
529 }
530
531 /**
532 * @tc.name: MetaItemTest001
533 * @tc.desc: MetaItem test
534 * @tc.type: FUNC
535 */
536 HWTEST_F(AppDetailsRdbMgrTest, MetaItemTest001, TestSize.Level0)
537 {
538 std::shared_ptr<MockResultSet> moc = std::make_shared<MockResultSet>();
539 EXPECT_CALL(*moc, GetString(META_TABLE_NAME_INDEX, _)).WillOnce(Return(1));
540 std::shared_ptr<AbsSharedResultSet> impl = moc;
541 MetaItem item;
542 ASSERT_FALSE(item.GetRdbItem(impl));
543
544 std::shared_ptr<MockResultSet> moc2 = std::make_shared<MockResultSet>();
545 EXPECT_CALL(*moc2, GetString(META_TABLE_NAME_INDEX, _)).WillOnce(Return(0));
546 EXPECT_CALL(*moc2, GetString(META_TABLE_VERSION_INDEX, _)).WillOnce(Return(1));
547 impl = moc2;
548 ASSERT_FALSE(item.GetRdbItem(impl));
549
550 std::shared_ptr<MockResultSet> moc3 = std::make_shared<MockResultSet>();
551 EXPECT_CALL(*moc3, GetString(META_TABLE_NAME_INDEX, _)).WillOnce(Return(0));
552 EXPECT_CALL(*moc3, GetString(META_TABLE_VERSION_INDEX, _)).WillOnce(Return(0));
553 EXPECT_CALL(*moc3, GetString(META_TABLE_EXT_INFO_INDEX, _)).WillOnce(Return(1));
554 impl = moc3;
555 ASSERT_FALSE(item.GetRdbItem(impl));
556
557 std::shared_ptr<MockResultSet> moc4 = std::make_shared<MockResultSet>();
558 EXPECT_CALL(*moc4, GetString(META_TABLE_NAME_INDEX, _)).WillOnce(Return(0));
559 EXPECT_CALL(*moc4, GetString(META_TABLE_VERSION_INDEX, _)).WillOnce(Return(0));
560 EXPECT_CALL(*moc4, GetString(META_TABLE_EXT_INFO_INDEX, _)).WillOnce(Return(0));
561 EXPECT_CALL(*moc4, GetString(META_UPDATE_TIME_INDEX, _)).WillOnce(Return(1));
562 impl = moc4;
563 ASSERT_FALSE(item.GetRdbItem(impl));
564 }
565 }
566