From ac0749c9ad47ca828ede7704892f4ede89ab41fc Mon Sep 17 00:00:00 2001 From: htt1997 Date: Mon, 31 Mar 2025 19:49:58 +0800 Subject: [PATCH] update Signed-off-by: htt1997 --- .../native/rdb/include/connection.h | 1 - .../native/rdb/include/rd_connection.h | 1 - .../native/rdb/include/sqlite_connection.h | 1 - .../native/rdb/include/transaction_impl.h | 1 - .../native/rdb/src/rd_connection.cpp | 5 - .../native/rdb/src/rdb_store_impl.cpp | 2 +- .../native/rdb/src/rdb_store_manager.cpp | 4 +- .../native/rdb/src/sqlite_connection.cpp | 5 - .../native/rdb/src/transaction_impl.cpp | 17 +- .../unittest/src/RdbStoreTransaction.test.js | 2 +- .../rdb/unittest/rdb_store_impl_test.cpp | 2 +- .../native/rdb/unittest/transaction_test.cpp | 245 ++- .../unittest/rdb_store_test.cpp | 1944 ---------------- .../unittest/relational_store_test.cpp | 1953 ----------------- 14 files changed, 246 insertions(+), 3937 deletions(-) delete mode 100644 relational_store/test/native/relational_store_test/unittest/rdb_store_test.cpp delete mode 100644 relational_store/test/native/relational_store_test/unittest/relational_store_test.cpp diff --git a/relational_store/frameworks/native/rdb/include/connection.h b/relational_store/frameworks/native/rdb/include/connection.h index ee06e2b1..dd8e291e 100644 --- a/relational_store/frameworks/native/rdb/include/connection.h +++ b/relational_store/frameworks/native/rdb/include/connection.h @@ -63,7 +63,6 @@ public: virtual std::pair CreateStatement(const std::string &sql, SConn conn) = 0; virtual int32_t GetDBType() const = 0; virtual bool IsWriter() const = 0; - virtual bool IsInTrans() const = 0; virtual int32_t ReSetKey(const RdbStoreConfig &config) = 0; virtual int32_t TryCheckPoint(bool timeout) = 0; virtual int32_t LimitWalSize() = 0; diff --git a/relational_store/frameworks/native/rdb/include/rd_connection.h b/relational_store/frameworks/native/rdb/include/rd_connection.h index e9737849..7d0da643 100644 --- a/relational_store/frameworks/native/rdb/include/rd_connection.h +++ b/relational_store/frameworks/native/rdb/include/rd_connection.h @@ -41,7 +41,6 @@ public: std::pair CreateStatement(const std::string &sql, SConn conn) override; int32_t GetDBType() const override; bool IsWriter() const override; - bool IsInTrans() const override; int32_t ReSetKey(const RdbStoreConfig &config) override; int32_t TryCheckPoint(bool timeout) override; int32_t LimitWalSize() override; diff --git a/relational_store/frameworks/native/rdb/include/sqlite_connection.h b/relational_store/frameworks/native/rdb/include/sqlite_connection.h index b9e120ea..b1ab71ef 100644 --- a/relational_store/frameworks/native/rdb/include/sqlite_connection.h +++ b/relational_store/frameworks/native/rdb/include/sqlite_connection.h @@ -56,7 +56,6 @@ public: int32_t GetJournalMode() override; std::pair CreateStatement(const std::string &sql, SConn conn) override; bool IsWriter() const override; - bool IsInTrans() const override; int SubscribeTableChanges(const Notifier ¬ifier) override; int GetMaxVariable() const override; int32_t GetDBType() const override; diff --git a/relational_store/frameworks/native/rdb/include/transaction_impl.h b/relational_store/frameworks/native/rdb/include/transaction_impl.h index fe133482..954e3e6a 100644 --- a/relational_store/frameworks/native/rdb/include/transaction_impl.h +++ b/relational_store/frameworks/native/rdb/include/transaction_impl.h @@ -56,7 +56,6 @@ public: private: static std::string GetBeginSql(int32_t type); int32_t Begin(int32_t type); - bool IsInTransaction(); int32_t CloseInner(bool connRecycle = true); std::shared_ptr GetStore(); void AddResultSet(std::weak_ptr resultSet); diff --git a/relational_store/frameworks/native/rdb/src/rd_connection.cpp b/relational_store/frameworks/native/rdb/src/rd_connection.cpp index 52c543e3..f84b475c 100644 --- a/relational_store/frameworks/native/rdb/src/rd_connection.cpp +++ b/relational_store/frameworks/native/rdb/src/rd_connection.cpp @@ -360,10 +360,5 @@ ExchangeStrategy RdConnection::GenerateExchangeStrategy(const SlaveStatus &statu { return ExchangeStrategy::NOT_HANDLE; } - -bool RdConnection::IsInTrans() const -{ - return false; -} } // namespace NativeRdb } // namespace OHOS \ No newline at end of file diff --git a/relational_store/frameworks/native/rdb/src/rdb_store_impl.cpp b/relational_store/frameworks/native/rdb/src/rdb_store_impl.cpp index a2f5e0bf..e6371c60 100644 --- a/relational_store/frameworks/native/rdb/src/rdb_store_impl.cpp +++ b/relational_store/frameworks/native/rdb/src/rdb_store_impl.cpp @@ -2583,7 +2583,7 @@ bool RdbStoreImpl::IsSlaveDiffFromMaster() const int32_t RdbStoreImpl::ExchangeSlaverToMaster() { - if (isReadOnly_ || rebuild_ != RebuiltType::NONE) { + if (isReadOnly_ || isMemoryRdb_ || rebuild_ != RebuiltType::NONE) { return E_OK; } auto [errCode, conn] = GetConn(false); diff --git a/relational_store/frameworks/native/rdb/src/rdb_store_manager.cpp b/relational_store/frameworks/native/rdb/src/rdb_store_manager.cpp index 17b2c0e6..283e63ce 100644 --- a/relational_store/frameworks/native/rdb/src/rdb_store_manager.cpp +++ b/relational_store/frameworks/native/rdb/src/rdb_store_manager.cpp @@ -105,7 +105,6 @@ std::shared_ptr RdbStoreManager::GetRdbStore( } std::tie(errCode, rdbStore) = OpenStore(config, path); if (errCode != E_OK || rdbStore == nullptr) { - LOG_ERROR("OpenStore failed. path:%{public}s, rc=%{public}d", SqliteUtils::Anonymous(path).c_str(), errCode); return nullptr; } if (rdbStore->GetConfig().GetRoleType() == OWNER && !rdbStore->GetConfig().IsReadOnly()) { @@ -116,8 +115,7 @@ std::shared_ptr RdbStoreManager::GetRdbStore( (void)rdbStore->ExchangeSlaverToMaster(); errCode = ProcessOpenCallback(*rdbStore, version, openCallback); if (errCode != E_OK) { - LOG_ERROR("fail, path:%{public}s ProcessOpenCallback errCode:%{public}d", - SqliteUtils::Anonymous(rdbStore->GetConfig().GetPath()).c_str(), errCode); + LOG_ERROR("Callback fail, path:%{public}s code:%{public}d", SqliteUtils::Anonymous(path).c_str(), errCode); return nullptr; } } diff --git a/relational_store/frameworks/native/rdb/src/sqlite_connection.cpp b/relational_store/frameworks/native/rdb/src/sqlite_connection.cpp index 55673379..b8a3c732 100644 --- a/relational_store/frameworks/native/rdb/src/sqlite_connection.cpp +++ b/relational_store/frameworks/native/rdb/src/sqlite_connection.cpp @@ -1597,10 +1597,5 @@ int32_t SqliteConnection::Restore(const RdbStoreConfig &config, const std::strin Connection::Delete(slaveConfig.GetPath()); return E_OK; } - -bool SqliteConnection::IsInTrans() const -{ - return sqlite3_get_autocommit(dbHandle_) == 0; -} } // namespace NativeRdb } // namespace OHOS \ No newline at end of file diff --git a/relational_store/frameworks/native/rdb/src/transaction_impl.cpp b/relational_store/frameworks/native/rdb/src/transaction_impl.cpp index 0f0cc72d..b9b7adc1 100644 --- a/relational_store/frameworks/native/rdb/src/transaction_impl.cpp +++ b/relational_store/frameworks/native/rdb/src/transaction_impl.cpp @@ -95,16 +95,6 @@ int32_t TransactionImpl::Begin(int32_t type) return E_OK; } -bool TransactionImpl::IsInTransaction() -{ - std::lock_guard lock(mutex_); - if (connection_ == nullptr) { - LOG_ERROR("connection already closed"); - return false; - } - return connection_->IsInTrans(); -} - int32_t TransactionImpl::Commit() { std::lock_guard lock(mutex_); @@ -245,13 +235,8 @@ std::pair TransactionImpl::Update( LOG_ERROR("transaction already close"); return { E_ALREADY_CLOSED, -1 }; } - auto [errCode, rows] = store->Update( + return store->Update( predicates.GetTableName(), row, predicates.GetWhereClause(), predicates.GetBindArgs(), resolution); - if (resolution == Resolution::ON_CONFLICT_ROLLBACK && errCode == E_SQLITE_CONSTRAINT && !IsInTransaction()) { - LOG_WARN("transaction already rollback, start close!"); - CloseInner(); - } - return { errCode, rows }; } std::pair TransactionImpl::Delete( diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbStoreTransaction.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbStoreTransaction.test.js index 4262cdb1..0f07730e 100644 --- a/relational_store/test/js/relationalstore/unittest/src/RdbStoreTransaction.test.js +++ b/relational_store/test/js/relationalstore/unittest/src/RdbStoreTransaction.test.js @@ -2038,7 +2038,7 @@ describe('rdbStoreTransactionTest', function () { expect(null).assertFail() } catch (e) { console.log(TAG + e + " code: " + e.code); - expect(e.code).assertEqual(14800021); + expect(e.code).assertEqual(14800014); } console.log(TAG + "testON_CONFLICT_ROLLBACKInTransaction0022 success"); } diff --git a/relational_store/test/native/rdb/unittest/rdb_store_impl_test.cpp b/relational_store/test/native/rdb/unittest/rdb_store_impl_test.cpp index 28012329..1ee2e704 100644 --- a/relational_store/test/native/rdb/unittest/rdb_store_impl_test.cpp +++ b/relational_store/test/native/rdb/unittest/rdb_store_impl_test.cpp @@ -813,7 +813,7 @@ HWTEST_F(RdbStoreImplTest, Normal_ClearCacheTest_001, TestSize.Level2) } EXPECT_EQ(errCode, E_OK); EXPECT_EQ(1000, id); - + int rowCount; std::shared_ptr resultSet = store->QueryByStep("SELECT * FROM test"); EXPECT_NE(resultSet, nullptr); diff --git a/relational_store/test/native/rdb/unittest/transaction_test.cpp b/relational_store/test/native/rdb/unittest/transaction_test.cpp index d649cf0e..657f2272 100644 --- a/relational_store/test/native/rdb/unittest/transaction_test.cpp +++ b/relational_store/test/native/rdb/unittest/transaction_test.cpp @@ -414,7 +414,7 @@ HWTEST_F(TransactionTest, RdbStore_Transaction_008, TestSize.Level1) result = transaction->Insert("test1", row, ConflictResolution::ON_CONFLICT_ROLLBACK); ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT); ASSERT_EQ(result.second, -1); - ASSERT_EQ(transaction->Commit(), E_ALREADY_CLOSED); + ASSERT_EQ(transaction->Commit(), E_SQLITE_ERROR); auto resultSet = store->QueryByStep("SELECT * FROM test1"); ASSERT_NE(resultSet, nullptr); @@ -451,7 +451,7 @@ HWTEST_F(TransactionTest, RdbStore_Transaction_009, TestSize.Level1) "test1", row, "id = ?", std::vector{ "1" }, ConflictResolution::ON_CONFLICT_ROLLBACK); ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT); ASSERT_EQ(result.second, 0); - ASSERT_EQ(transaction->Commit(), E_ALREADY_CLOSED); + ASSERT_EQ(transaction->Commit(), E_SQLITE_ERROR); auto resultSet = store->QueryByStep("SELECT * FROM test1"); ASSERT_NE(resultSet, nullptr); @@ -489,7 +489,7 @@ HWTEST_F(TransactionTest, RdbStore_Transaction_010, TestSize.Level1) result = transaction->Update(row, predicates, ConflictResolution::ON_CONFLICT_ROLLBACK); ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT); ASSERT_EQ(result.second, 0); - ASSERT_EQ(transaction->Commit(), E_ALREADY_CLOSED); + ASSERT_EQ(transaction->Commit(), E_SQLITE_ERROR); auto resultSet = store->QueryByStep("SELECT * FROM test1"); ASSERT_NE(resultSet, nullptr); @@ -530,7 +530,7 @@ HWTEST_F(TransactionTest, RdbStore_Transaction_011, TestSize.Level1) result = transaction->BatchInsertWithConflictResolution("test1", rows, ConflictResolution::ON_CONFLICT_ROLLBACK); ASSERT_EQ(result.first, E_SQLITE_CONSTRAINT); ASSERT_EQ(result.second, 0); - ASSERT_EQ(transaction->Commit(), E_ALREADY_CLOSED); + ASSERT_EQ(transaction->Commit(), E_SQLITE_ERROR); auto resultSet = store->QueryByStep("SELECT * FROM test1"); ASSERT_NE(resultSet, nullptr); @@ -957,3 +957,240 @@ HWTEST_F(TransactionTest, RdbStore_Transaction_020, TestSize.Level1) EXPECT_EQ(ret, E_OK); EXPECT_EQ(rowCount, 1); } + +/** + * @tc.name: RdbStore_Transaction_021 + * @tc.desc: Abnormal testcase of Insert after commit. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_021, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + auto [err, rows] = transaction->Insert( + "test", UTUtils::SetRowData(UTUtils::g_rowData[0]), Transaction::NO_ACTION); + EXPECT_EQ(err, E_ALREADY_CLOSED); +} + +/** + * @tc.name: RdbStore_Transaction_022 + * @tc.desc: Abnormal testcase of BatchInsert after commit. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_022, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + Transaction::Rows rows{ + UTUtils::SetRowData(UTUtils::g_rowData[0]), + UTUtils::SetRowData(UTUtils::g_rowData[1]), + UTUtils::SetRowData(UTUtils::g_rowData[2]), + }; + auto result = transaction->BatchInsert("test", rows); + ASSERT_EQ(result.first, E_ALREADY_CLOSED); + ASSERT_EQ(result.second, -1); +} + +/** + * @tc.name: RdbStore_Transaction_023 + * @tc.desc: Abnormal testcase of BatchInsert after commit. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_023, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + Transaction::RefRows rows; + rows.Put(UTUtils::SetRowData(UTUtils::g_rowData[0])); + rows.Put(UTUtils::SetRowData(UTUtils::g_rowData[1])); + rows.Put(UTUtils::SetRowData(UTUtils::g_rowData[2])); + auto result = transaction->BatchInsert("test", rows); + ASSERT_EQ(result.first, E_ALREADY_CLOSED); + ASSERT_EQ(result.second, -1); +} + +/** + * @tc.name: RdbStore_Transaction_024 + * @tc.desc: Abnormal testcase of BatchInsertWithConflictResolution after commit. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_024, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + ValuesBuckets rows; + for (int i = 0; i < 5; i++) { + Transaction::Row row; + row.Put("id", i); + row.Put("name", "Jim"); + rows.Put(row); + } + auto result = transaction->BatchInsertWithConflictResolution( + "test", rows, ConflictResolution::ON_CONFLICT_ROLLBACK); + ASSERT_EQ(result.first, E_ALREADY_CLOSED); +} + +/** + * @tc.name: RdbStore_Transaction_025 + * @tc.desc: Abnormal testcase of Update after commit. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_025, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + auto result = transaction->Update("test", UTUtils::SetRowData(UTUtils::g_rowData[1]), "id=1"); + ASSERT_EQ(result.first, E_ALREADY_CLOSED); +} + +/** + * @tc.name: RdbStore_Transaction_026 + * @tc.desc: Abnormal testcase of Update after commit. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_026, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + AbsRdbPredicates predicates("test"); + predicates.EqualTo("id", ValueObject(2)); + auto result = transaction->Update(UTUtils::SetRowData(UTUtils::g_rowData[2]), predicates); + ASSERT_EQ(result.first, E_ALREADY_CLOSED); +} + +/** + * @tc.name: RdbStore_Transaction_027 + * @tc.desc: Abnormal testcase of Delete after commit. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_027, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + auto result = transaction->Delete("test", "id=1"); + ASSERT_EQ(result.first, E_ALREADY_CLOSED); + ASSERT_EQ(result.second, -1); + + AbsRdbPredicates predicates("test"); + predicates.EqualTo("id", ValueObject(2)); + result = transaction->Delete(predicates); + ASSERT_EQ(result.first, E_ALREADY_CLOSED); + ASSERT_EQ(result.second, -1); +} + +/** + * @tc.name: RdbStore_Transaction_028 + * @tc.desc: Abnormal testcase of QueryByStep after commit. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_028, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + auto result = transaction->QueryByStep("SELECT * FROM test"); + ASSERT_EQ(result, nullptr); + + AbsRdbPredicates predicates("test"); + predicates.EqualTo("id", ValueObject(2)); + result = transaction->QueryByStep(predicates); + ASSERT_EQ(result, nullptr); +} + +/** + * @tc.name: RdbStore_Transaction_029 + * @tc.desc: Abnormal testcase of QueryByStep after commit. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_029, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + auto result = transaction->Execute(CREATE_TABLE_SQL); + ASSERT_EQ(result.first, E_ALREADY_CLOSED); +} + +/** + * @tc.name: RdbStore_Transaction_030 + * @tc.desc: Abnormal testcase of commit after commit and rollback. + * @tc.type: FUNC + */ +HWTEST_F(TransactionTest, RdbStore_Transaction_030, TestSize.Level1) +{ + std::shared_ptr &store = TransactionTest::store_; + + auto [ret, transaction] = store->CreateTransaction(Transaction::DEFERRED); + ASSERT_EQ(ret, E_OK); + ASSERT_NE(transaction, nullptr); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_OK); + + ret = transaction->Commit(); + EXPECT_EQ(ret, E_ALREADY_CLOSED); + + ret = transaction->Rollback(); + EXPECT_EQ(ret, E_ALREADY_CLOSED); +} \ No newline at end of file diff --git a/relational_store/test/native/relational_store_test/unittest/rdb_store_test.cpp b/relational_store/test/native/relational_store_test/unittest/rdb_store_test.cpp deleted file mode 100644 index 6b9ac6a3..00000000 --- a/relational_store/test/native/relational_store_test/unittest/rdb_store_test.cpp +++ /dev/null @@ -1,1944 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include - -#include -#include - -#include "common.h" -#include "rdb_errno.h" -#include "rdb_helper.h" -#include "rdb_open_callback.h" -#include "rdb_store_impl.h" -#include "relational_store_delegate.h" -#include "relational_store_manager.h" -#include "sqlite_connection.h" - -using namespace testing::ext; -using namespace OHOS::NativeRdb; - -class RdbTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(void); - void SetUp(); - void TearDown(); - - static const std::string DATABASE_NAME; - -protected: - std::shared_ptr store_; -}; - -const std::string RdbTest::DATABASE_NAME = RDB_TEST_PATH + "stepResultSet_impl_test.db"; - -class RdbTestOpenCallback : public RdbOpenCallback { -public: - int OnCreate(RdbStore &store) override; - int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override; -}; - -int RdbTestOpenCallback::OnCreate(RdbStore &store) -{ - return E_OK; -} - -int RdbTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion) -{ - return E_OK; -} - -void RdbTest::SetUpTestCase(void) -{ -} - -void RdbTest::TearDownTestCase(void) -{ -} - -void RdbTest::SetUp(void) -{ - store_ = nullptr; - int errCode = RdbHelper::DeleteRdbStore(DATABASE_NAME); - EXPECT_EQ(E_OK, errCode); - RdbStoreConfig config(RdbTest::DATABASE_NAME); - RdbTestOpenCallback helper; - store_ = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store_, nullptr); - EXPECT_EQ(errCode, E_OK); -} - -void RdbTest::TearDown(void) -{ - store_ = nullptr; - RdbHelper::ClearCache(); - int errCode = RdbHelper::DeleteRdbStore(DATABASE_NAME); - EXPECT_EQ(E_OK, errCode); -} - -/* * - * @tc.name: GetModifyTimeByRowIdTest_001 - * @tc.desc: Normal testCase for GetModifyTime, get timestamp by id - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, GetModifyTimeByRowIdTest_001, TestSize.Level2) -{ - store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_RdbTest_integer_log " - "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, " - "data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - int64_t rowId; - ValuesBucket valuesBucket; - valuesBucket.PutInt("data_key", ValueObject(1)); - valuesBucket.PutInt("timestamp", ValueObject(1000000000)); - int errorCode = store_->Insert(rowId, "naturalbase_rdb_aux_RdbTest_integer_log", valuesBucket); - EXPECT_EQ(E_OK, errorCode); - EXPECT_EQ(1, rowId); - - std::vector PKey = { 1 }; - std::map result = store_->GetModifyTime("RdbTest_integer", "ROWID", PKey); - int size = result.size(); - EXPECT_EQ(1, size); - EXPECT_EQ(100000, int64_t(result[1])); - - store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_RdbTest_integer_log"); -} - -/* * - * @tc.name: GetModifyTimeByRowIdTest_002 - * @tc.desc: Abnormal testCase for GetModifyTime, get timestamp by id, - * resultSet is empty or table name is not exist - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, GetModifyTimeByRowIdTest_002, TestSize.Level2) -{ - store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_RdbTest_integer_log " - "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, " - "data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - int64_t rowId; - ValuesBucket valuesBucket; - valuesBucket.PutInt("data_key", ValueObject(2)); - int errorCode = store_->Insert(rowId, "naturalbase_rdb_aux_RdbTest_integer_log", valuesBucket); - EXPECT_EQ(E_OK, errorCode); - EXPECT_EQ(1, rowId); - - // resultSet is empty - std::vector PKey = { 1 }; - std::map result = store_->GetModifyTime("RdbTest_integer", "ROWID", PKey); - int size = result.size(); - EXPECT_EQ(0, size); - - // table name is not exist , resultSet is null - result = store_->GetModifyTime("test", "ROWID", PKey); - size = result.size(); - EXPECT_EQ(0, size); - - store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_RdbTest_integer_log"); -} - -/* * - * @tc.name: GetModifyTimeByRowIdTest_003 - * @tc.desc: Abnormal testCase for GetModifyTime, get timestamp by id, - * resultSet is empty or table name is not exist - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, GetModifyTimeByRowIdTest_003, TestSize.Level2) -{ - store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_RdbTest_integer_log " - "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, " - "data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - int64_t rowId; - ValuesBucket valuesBucket; - valuesBucket.PutInt("data_key", ValueObject(1)); - int errorCode = store_->Insert(rowId, "naturalbase_rdb_aux_RdbTest_integer_log", valuesBucket); - EXPECT_EQ(E_OK, errorCode); - EXPECT_EQ(1, rowId); - - std::vector PKey = { 1 }; - RdbStore::ModifyTime resultMapTmp = store_->GetModifyTime("RdbTest_integer", "ROWID", PKey); - std::map resultMap = std::map(resultMapTmp); - EXPECT_EQ(1, resultMap.size()); - - RdbStore::ModifyTime resultPtrTmp = store_->GetModifyTime("RdbTest_integer", "ROWID", PKey); - std::shared_ptr resultPtr = std::shared_ptr(resultPtrTmp); - int count = 0; - resultPtr->GetRowCount(count); - EXPECT_EQ(1, count); - - RdbStore::ModifyTime result = store_->GetModifyTime("RdbTest_integer", "ROWID", PKey); - RdbStore::PRIKey key = result.GetOriginKey(std::vector{}); - RdbStore::PRIKey monostate = std::monostate(); - EXPECT_EQ(monostate, key); - EXPECT_EQ(8, result.GetMaxOriginKeySize()); - - store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_RdbTest_integer_log"); -} - -/* * - * @tc.name: GetModifyTime_001 - * @tc.desc: Abnormal testCase for GetModifyTime, tablename columnName, keys is empty, - * and resultSet is null or empty - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, GetModifyTime_001, TestSize.Level2) -{ - store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_RdbTest_integer_log " - "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, " - "data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - - // table name is "" - std::vector PKey = { 1 }; - std::map result = store_->GetModifyTime("", "data_key", PKey); - int size = result.size(); - EXPECT_EQ(0, size); - - // table name is not exist , query resultSet is null - result = store_->GetModifyTime("test", "data_key", PKey); - size = result.size(); - EXPECT_EQ(0, size); - - // columnName is "" - result = store_->GetModifyTime("test", "", PKey); - size = result.size(); - EXPECT_EQ(0, size); - - // keys is empty - std::vector emptyPRIKey; - result = store_->GetModifyTime("test", "data_key", emptyPRIKey); - size = result.size(); - EXPECT_EQ(0, size); - - store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_RdbTest_integer_log"); -} - -/* * - * @tc.name: GetModifyTime_002 - * @tc.desc: Abnormal testCase for GetModifyTime, get timestamp by data3 ,if query resultSet is empty - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, GetModifyTime_002, TestSize.Level2) -{ - store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_RdbTest_integer_log " - "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, hash_key INTEGER, " - "data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - - std::vector PKey = { 1 }; - std::map result = store_->GetModifyTime("RdbTest_integer", "data3", PKey); - EXPECT_EQ(0, result.size()); - - store_->ExecuteSql("DROP TABLE IF EXISTS naturalbase_rdb_aux_RdbTest_integer_log"); -} - -/* * - * @tc.name: Rdb_BatchInsertTest_001 - * @tc.desc: Abnormal testCase for BatchInsert, if initialBatchValues is empty - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_BatchInsertTest_001, TestSize.Level2) -{ - std::vector valuesBuckets; - int64_t insertNum = 1; - int ret = store_->BatchInsert(insertNum, "test", valuesBuckets); - EXPECT_EQ(0, insertNum); - EXPECT_EQ(E_OK, ret); -} - -/* * - * @tc.name: Rdb_QueryTest_001 - * @tc.desc: Abnormal testCase for Query, if table name is empty - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_QueryTest_001, TestSize.Level2) -{ - int errCode = E_OK; - store_->Query(errCode, true, "", {}, "", std::vector{}, "", "", "", 1, 0); - EXPECT_NE(E_OK, errCode); -} - -/* * - * @tc.name: Rdb_QueryTest_002 - * @tc.desc: Normal testCase for Query, get * form test - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_QueryTest_002, TestSize.Level2) -{ - store_->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, " - "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - int errCode = E_OK; - store_->Query(errCode, true, "test", {}, "", std::vector{}, "", "", "", 1, 0); - EXPECT_EQ(E_OK, errCode); - - store_->ExecuteSql("DROP TABLE IF EXISTS test"); -} - -/* * - * @tc.name: Rdb_RemoteQueryTest_001 - * @tc.desc: Abnormal testCase for RemoteQuery - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_RemoteQueryTest_001, TestSize.Level2) -{ - int errCode = E_OK; - AbsRdbPredicates predicates("test"); - predicates.EqualTo("id", 1); - - // GetRdbService failed if rdbstoreconfig bundlename_ empty - auto ret = store_->RemoteQuery("", predicates, {}, errCode); - EXPECT_EQ(E_INVALID_ARGS, errCode); - EXPECT_EQ(nullptr, ret); - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); - - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetName("RdbStore_impl_test.db"); - config.SetBundleName("com.example.distributed.rdb"); - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_EQ(E_OK, errCode); - - // GetRdbService succeeded if configuration file has already been configured - ret = store->RemoteQuery("", predicates, {}, errCode); - EXPECT_NE(E_OK, errCode); - EXPECT_EQ(nullptr, ret); - - store = nullptr; - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); -} - -/* * - * @tc.name: Rdb_RollbackTest_001 - * @tc.desc: Abnormal testCase for Rollback - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_RollbackTest_001, TestSize.Level2) -{ - int ret = store_->RollBack(); - EXPECT_EQ(OHOS::NativeRdb::E_NO_TRANSACTION_IN_SESSION, ret); -} - -/* * - * @tc.name: Rdb_CommitTest_001 - * @tc.desc: Abnormal testCase for Commit,if not use BeginTransaction - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_CommitTest_001, TestSize.Level2) -{ - int ret = store_->Commit(); - EXPECT_EQ(E_OK, ret); -} - -/* * - * @tc.name: Rdb_BackupTest_001 - * @tc.desc: Abnormal testCase for Backup - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_BackupTest_001, TestSize.Level2) -{ - int errCode = E_OK; - std::string databasePath = RDB_TEST_PATH + "test.db"; - std::vector destEncryptKey; - // isEncrypt_ is false, and destEncryptKey is emtpy - errCode = store_->Backup(databasePath, destEncryptKey); - EXPECT_EQ(E_OK, errCode); - RdbHelper::DeleteRdbStore(databasePath); - - // isEncrypt_ is false, and destEncryptKey is not emtpy - destEncryptKey.push_back(1); - errCode = store_->Backup(databasePath, destEncryptKey); - EXPECT_EQ(E_OK, errCode); - store_ = nullptr; - RdbHelper::DeleteRdbStore(DATABASE_NAME); - RdbHelper::DeleteRdbStore(databasePath); - - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetEncryptStatus(true); - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_EQ(E_OK, errCode); - - // isEncrypt_ is true, and destEncryptKey is not emtpy - errCode = store->Backup(databasePath, destEncryptKey); - EXPECT_EQ(E_OK, errCode); - RdbHelper::DeleteRdbStore(databasePath); - - // isEncrypt_ is true, and destEncryptKey is not emtpy - destEncryptKey.pop_back(); - errCode = store->Backup(databasePath, destEncryptKey); - EXPECT_EQ(E_OK, errCode); - store = nullptr; - RdbHelper::DeleteRdbStore(databasePath); - RdbHelper::DeleteRdbStore(DATABASE_NAME); -} - -/* * - * @tc.name: Rdb_SqlitConnectionTest_001 - * @tc.desc: Abnormal testCase for SetPageSize, - * return ok if open db again and set same page size - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_SqlitConnectionTest_001, TestSize.Level2) -{ - const std::string DATABASE_NAME = RDB_TEST_PATH + "SqlitConnectionOpenTest.db"; - RdbStoreConfig config(DATABASE_NAME); - config.SetReadOnly(false); - config.SetPageSize(1024); - auto [errCode, connection] = Connection::Create(config, true); - EXPECT_NE(nullptr, connection); - auto [err, statement] = connection->CreateStatement("PRAGMA page_size", connection); - auto [error, object] = statement->ExecuteForValue(); - EXPECT_EQ(E_OK, error); - EXPECT_EQ(1024, static_cast(object)); - - std::tie(errCode, connection) = Connection::Create(config, true); - EXPECT_NE(nullptr, connection); -} - -/* * - * @tc.name: Rdb_ConnectionPoolTest_001 - * @tc.desc: Abnormal testCase for ConfigLocale - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_ConnectionPoolTest_001, TestSize.Level2) -{ - const std::string DATABASE_NAME = RDB_TEST_PATH + "ConnectionOpenTest.db"; - int errCode = E_OK; - RdbStoreConfig config(DATABASE_NAME); - config.SetReadConSize(1); - config.SetStorageMode(StorageMode::MODE_DISK); - - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_EQ(E_OK, errCode); - - auto connectionPool = ConnectionPool::Create(config, errCode); - EXPECT_NE(nullptr, connectionPool); - EXPECT_EQ(E_OK, errCode); - - // connecting database - auto connection = connectionPool->AcquireConnection(true); - EXPECT_NE(nullptr, connection); - errCode = connectionPool->ConfigLocale("AbnormalTest"); - EXPECT_EQ(OHOS::NativeRdb::E_DATABASE_BUSY, errCode); - - store = nullptr; - RdbHelper::DeleteRdbStore(DATABASE_NAME); -} - -/* * - * @tc.name: Rdb_ConnectionPoolTest_002 - * @tc.desc: Abnormal testCase for AcquireConnection/AcquireTransaction - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_ConnectionPoolTest_002, TestSize.Level2) -{ - const std::string DATABASE_NAME = RDB_TEST_PATH + "ConnectionTest.db"; - int errCode = E_OK; - RdbStoreConfig config(DATABASE_NAME); - config.SetReadConSize(1); - config.SetStorageMode(StorageMode::MODE_DISK); - auto connectionPool = ConnectionPool::Create(config, errCode); - EXPECT_NE(nullptr, connectionPool); - EXPECT_EQ(E_OK, errCode); - - // repeat AcquireReader without release - auto connection = connectionPool->AcquireConnection(true); - EXPECT_NE(nullptr, connection); - connection = connectionPool->AcquireConnection(true); - EXPECT_NE(nullptr, connection); - connection = connectionPool->AcquireConnection(true); - EXPECT_NE(nullptr, connection); - - // repeat AcquireWriter without release - connection = connectionPool->AcquireConnection(false); - EXPECT_NE(nullptr, connection); - connection = connectionPool->AcquireConnection(false); - EXPECT_EQ(nullptr, connection); - connection = connectionPool->AcquireConnection(false); - EXPECT_NE(nullptr, connection); - - // repeat AcquireTransaction without release - errCode = connectionPool->AcquireTransaction(); - EXPECT_EQ(E_OK, errCode); - errCode = connectionPool->AcquireTransaction(); - EXPECT_NE(E_OK, errCode); - connectionPool->ReleaseTransaction(); -} - -/* * - * @tc.name: Rdb_ConnectionPoolTest_003 - * @tc.desc: Abnormal testCase for ChangeDbFileForRestore - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_ConnectionPoolTest_0023, TestSize.Level2) -{ - const std::string DATABASE_NAME = RDB_TEST_PATH + "ConnectionTest.db"; - int errCode = E_OK; - RdbStoreConfig config(DATABASE_NAME); - config.SetReadConSize(1); - config.SetStorageMode(StorageMode::MODE_DISK); - auto connectionPool = ConnectionPool::Create(config, errCode); - EXPECT_NE(nullptr, connectionPool); - EXPECT_EQ(E_OK, errCode); - - const std::string newPath = DATABASE_NAME; - const std::string backupPath = DATABASE_NAME; - const std::vector newKey; - - // newPath == currentPath, writeConnectionUsed == true - auto connection = connectionPool->AcquireConnection(false); - SlaveStatus curStatus; - errCode = connectionPool->ChangeDbFileForRestore(newPath, backupPath, newKey, curStatus); - EXPECT_EQ(E_ERROR, errCode); - connection = nullptr; - // newPath == currentPath - errCode = connectionPool->ChangeDbFileForRestore(newPath, backupPath, newKey, curStatus); - EXPECT_NE(E_OK, errCode); - // newPath != currentPath - const std::string newPath2 = RDB_TEST_PATH + "tmp.db"; - errCode = connectionPool->ChangeDbFileForRestore(newPath2, backupPath, newKey, curStatus); - EXPECT_EQ(E_ERROR, errCode); -} - -HWTEST_F(RdbTest, NotifyDataChangeTest_001, TestSize.Level2) -{ - const std::string DATABASE_NAME = RDB_TEST_PATH + "SqlitConnectionOpenTest.db"; - RdbStoreConfig config(DATABASE_NAME); - config.SetReadOnly(false); - config.SetPageSize(1024); - auto [errCode, connection] = SqliteConnection::Create(config, true); - EXPECT_NE(nullptr, connection); - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(nullptr, store); -} - -HWTEST_F(RdbTest, NotifyDataChangeTest_002, TestSize.Level2) -{ - int errCode = E_OK; - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetReadOnly(false); - config.SetPageSize(1024); - config.SetBundleName("callback.test2"); - config.SetSearchable(true); - config.SetStorageMode(StorageMode::MODE_DISK); - // register callback - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(nullptr, store); - store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t2;"); - store->ExecuteSql("CREATE TABLE if not exists test_callback_t2 " - "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, " - "data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - // set TrackerTable - DistributedDB::TrackerSchema tracker; - tracker.tableName = "test_callback_t2"; - tracker.extendColName = ""; - tracker.trackerColNames = { "id", "timestamp" }; - using Delegate = DistributedDB::RelationalStoreDelegate; - DistributedDB::RelationalStoreManager rStoreManager("test_app", "test_user_id", 0); - Delegate::Option option; - Delegate *g_delegate = nullptr; - EXPECT_EQ(RdbTest::DATABASE_NAME, "/data/test/stepResultSet_impl_test.db"); - int status = rStoreManager.OpenStore(RdbTest::DATABASE_NAME, "test_callback_t2", option, g_delegate); - EXPECT_EQ(E_OK, status); - auto delegatePtr = std::shared_ptr( - g_delegate, [&rStoreManager](Delegate *delegate) { rStoreManager.CloseStore(delegate); }); - int setStatus = delegatePtr->SetTrackerTable(tracker); - EXPECT_EQ(E_OK, setStatus); - - int64_t rowId; - ValuesBucket valuesBucket; - valuesBucket.PutInt("data_key", ValueObject(1)); - valuesBucket.PutInt("timestamp", ValueObject(1000000000)); - int errorCode = store->Insert(rowId, "test_callback_t2", valuesBucket); - EXPECT_EQ(E_OK, errorCode); - EXPECT_EQ(1, rowId); - store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t2;"); -} - -HWTEST_F(RdbTest, NotifyDataChangeTest_003, TestSize.Level2) -{ - int errCode = E_OK; - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetReadOnly(false); - config.SetPageSize(1024); - config.SetBundleName("callback.test3"); - config.SetSearchable(true); - config.SetStorageMode(StorageMode::MODE_DISK); - - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - - store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t3;"); - - store->ExecuteSql("CREATE TABLE if not exists test_callback_t3 " - "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, " - "data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - // set TrackerTable - DistributedDB::TrackerSchema tracker; - tracker.tableName = "test_callback_t3"; - tracker.extendColName = ""; - tracker.trackerColNames = { "id", "timestamp" }; - using Delegate = DistributedDB::RelationalStoreDelegate; - DistributedDB::RelationalStoreManager rStoreManager("test_app", "test_user_id", 0); - Delegate::Option option; - Delegate *g_delegate = nullptr; - EXPECT_EQ(RdbTest::DATABASE_NAME, "/data/test/stepResultSet_impl_test.db"); - int status = rStoreManager.OpenStore(RdbTest::DATABASE_NAME, "test_callback_t3", option, g_delegate); - EXPECT_EQ(E_OK, status); - auto delegatePtr = std::shared_ptr( - g_delegate, [&rStoreManager](Delegate *delegate) { rStoreManager.CloseStore(delegate); }); - int setStatus = delegatePtr->SetTrackerTable(tracker); - EXPECT_EQ(E_OK, setStatus); - - int64_t rowId; - ValuesBucket valuesBucket; - valuesBucket.PutInt("data_key", ValueObject(1)); - valuesBucket.PutInt("timestamp", ValueObject(1000000000)); - int errorCode = store->Insert(rowId, "test_callback_t3", valuesBucket); - EXPECT_EQ(E_OK, errorCode); - EXPECT_EQ(1, rowId); - errorCode = store->ExecuteSql("UPDATE test_callback_t3 SET timestamp = 100 WHERE id = 1;"); - EXPECT_EQ(E_OK, errorCode); - - store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t3;"); -} - -/* * - * @tc.name: Rdb_QuerySharingResourceTest_001 - * @tc.desc: QuerySharingResource testCase - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_QuerySharingResourceTest_001, TestSize.Level2) -{ - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); - int errCode = E_OK; - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetName("RdbStore_impl_test.db"); - config.SetBundleName("com.example.distributed.rdb"); - - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - EXPECT_EQ(errCode, E_OK); - AbsRdbPredicates predicates("test"); - predicates.EqualTo("id", 1); - - auto ret = store->QuerySharingResource(predicates, {}); - EXPECT_NE(E_OK, ret.first); - EXPECT_EQ(nullptr, ret.second); - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); -} - -/* * - * @tc.name: Rdb_QuerySharingResourceTest_002 - * @tc.desc: QuerySharingResource testCase - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Rdb_QuerySharingResourceTest_002, TestSize.Level2) -{ - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); - int errCode = E_OK; - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetName("RdbStore_impl_test.db"); - config.SetBundleName("com.example.distributed.rdb"); - - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - EXPECT_EQ(errCode, E_OK); - store->ExecuteSql("CREATE TABLE test_resource " - "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, " - "data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - int64_t rowId; - ValuesBucket valuesBucket; - valuesBucket.PutInt("data_key", ValueObject(1)); - valuesBucket.PutInt("timestamp", ValueObject(1000000000)); - int errorCode = store->Insert(rowId, "test_resource", valuesBucket); - EXPECT_EQ(E_OK, errorCode); - EXPECT_EQ(1, rowId); - AbsRdbPredicates predicates("test_resource"); - predicates.EqualTo("data_key", 1); - - auto [status, resultSet] = store->QuerySharingResource(predicates, { "id", "data_key" }); - EXPECT_NE(E_OK, status); - ASSERT_EQ(nullptr, resultSet); - - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); -} - -/* * - * @tc.name: CleanDirtyDataTest_001 - * @tc.desc: Abnormal testCase for CleanDirtyData - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Abnormal_CleanDirtyDataTest_001, TestSize.Level2) -{ - store_->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, " - "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - int errCode = E_OK; - - // tabel is empty - std::string table = ""; - uint64_t cursor = UINT64_MAX; - errCode = RdbTest::store_->CleanDirtyData(table, cursor); - EXPECT_EQ(E_INVALID_ARGS, errCode); - - table = "test"; - errCode = RdbTest::store_->CleanDirtyData(table, cursor); - EXPECT_EQ(E_ERROR, errCode); - store_->ExecuteSql("DROP TABLE IF EXISTS test"); -} - -/* * - * @tc.name: ClearCacheTest_001 - * @tc.desc: Normal testCase for ClearCache - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Normal_ClearCacheTest_001, TestSize.Level2) -{ - store_->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, " - "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);"); - int errCode = E_OK; - int64_t id; - ValuesBucket valuesBucket; - valuesBucket.PutString("data1", std::string("zhangsan")); - valuesBucket.PutInt("data2", 10); - errCode = store_->Insert(id, "test", valuesBucket); - EXPECT_EQ(errCode, E_OK); - EXPECT_EQ(1, id); - - int rowCount; - std::shared_ptr resultSet = store_->QueryByStep("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - resultSet->GetRowCount(rowCount); - EXPECT_EQ(rowCount, 1); - int64_t currentMemory = sqlite3_memory_used(); - EXPECT_EQ(E_OK, resultSet->Close()); - EXPECT_LT(sqlite3_memory_used(), currentMemory); -} - -/* * - * @tc.name: LockCloudContainerTest - * @tc.desc: lock cloudContainer testCase - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, LockCloudContainerTest, TestSize.Level2) -{ - int errCode = E_OK; - // GetRdbService failed if rdbstoreconfig bundlename_ empty - auto ret = store_->LockCloudContainer(); - EXPECT_EQ(E_INVALID_ARGS, ret.first); - EXPECT_EQ(0, ret.second); - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); - - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetName("RdbStore_impl_test.db"); - config.SetBundleName("com.example.distributed.rdb"); - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_EQ(E_OK, errCode); - // GetRdbService succeeded if configuration file has already been configured - ret = store->LockCloudContainer(); - EXPECT_NE(E_OK, ret.first); - store = nullptr; - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); -} - -/* * - * @tc.name: UnlockCloudContainerTest - * @tc.desc: unlock cloudContainer testCase - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, UnlockCloudContainerTest, TestSize.Level2) -{ - int errCode = E_OK; - // GetRdbService failed if rdbstoreconfig bundlename_ empty - auto result = store_->UnlockCloudContainer(); - EXPECT_EQ(E_INVALID_ARGS, result); - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); - - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetName("RdbStore_impl_test.db"); - config.SetBundleName("com.example.distributed.rdb"); - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_EQ(E_OK, errCode); - // GetRdbService succeeded if configuration file has already been configured - result = store->UnlockCloudContainer(); - EXPECT_NE(E_OK, result); - store = nullptr; - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); -} - -/* * - * @tc.name: LockCloudContainerTest001 - * @tc.desc: lock cloudContainer testCase - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, LockCloudContainerTest001, TestSize.Level2) -{ - int errCode = E_OK; - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetName("RdbStore_impl_test.db"); - config.SetBundleName("com.example.distributed.rdb"); - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - ASSERT_NE(store, nullptr); - EXPECT_EQ(E_OK, errCode); - // GetRdbService succeeded if configuration file has already been configured - auto ret = store->RdbStore::LockCloudContainer(); - EXPECT_EQ(E_OK, ret.first); - EXPECT_EQ(0, ret.second); - store = nullptr; - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); -} - -/* * - * @tc.name: UnlockCloudContainerTest001 - * @tc.desc: unlock cloudContainer testCase - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, UnlockCloudContainerTest001, TestSize.Level2) -{ - int errCode = E_OK; - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetName("RdbStore_impl_test.db"); - config.SetBundleName("com.example.distributed.rdb"); - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - ASSERT_NE(store, nullptr); - EXPECT_EQ(E_OK, errCode); - // GetRdbService succeeded if configuration file has already been configured - auto result = store->RdbStore::UnlockCloudContainer(); - EXPECT_EQ(E_OK, result); - store = nullptr; - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); -} - -/* * - * @tc.name: SetSearchableTest - * @tc.desc: SetSearchable testCase - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, SetSearchableTest, TestSize.Level2) -{ - int errCode = E_OK; - RdbStoreConfig config(RdbTest::DATABASE_NAME); - config.SetBundleName(""); - RdbTestOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_EQ(E_OK, errCode); - - int result = store->SetSearchable(true); - EXPECT_EQ(E_INVALID_ARGS, result); - RdbHelper::DeleteRdbStore(RdbTest::DATABASE_NAME); - - config.SetBundleName("com.example.distributed.rdb"); - EXPECT_EQ(E_OK, errCode); - store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_EQ(E_OK, errCode); - result = store->SetSearchable(true); - EXPECT_EQ(E_OK, result); -} - -/* * - * @tc.name: RdbStore_Delete_001 - * @tc.desc: normal testcase of SqliteSharedResultSet for move - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_001, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - int ret = rstSet->GoToRow(1); - EXPECT_EQ(ret, E_OK); - - int rowCnt = -1; - ret = rstSet->GetRowCount(rowCnt); - EXPECT_EQ(rowCnt, 3); - - std::string colName = ""; - rstSet->GetColumnName(1, colName); - EXPECT_EQ(colName, "data1"); - - rstSet->GetColumnName(2, colName); - EXPECT_EQ(colName, "data2"); - - rstSet->GetColumnName(3, colName); - EXPECT_EQ(colName, "data3"); - - rstSet->GetColumnName(4, colName); - EXPECT_EQ(colName, "data4"); - - std::string valueStr = ""; - rstSet->GetString(0, valueStr); - EXPECT_EQ(valueStr, "2"); - - rstSet->GetString(1, valueStr); - EXPECT_EQ(valueStr, "2"); - - int64_t valuelg = 0; - rstSet->GetLong(2, valuelg); - EXPECT_EQ(valuelg, -5); - - double valueDb = 0.0; - rstSet->GetDouble(3, valueDb); - EXPECT_EQ(valueDb, 2.5); - - std::vector blob; - rstSet->GetBlob(4, blob); - int sz = blob.size(); - EXPECT_EQ(sz, 0); - - rstSet->GoTo(1); - rstSet->GetString(0, valueStr); - EXPECT_EQ(valueStr, "3"); - - rstSet->GetString(1, valueStr); - EXPECT_EQ(valueStr, "hello world"); - - rstSet->GetLong(2, valuelg); - EXPECT_EQ(valuelg, 3); - - rstSet->GetDouble(3, valueDb); - EXPECT_EQ(valueDb, 1.8); - - rstSet->GetBlob(4, blob); - sz = blob.size(); - EXPECT_EQ(sz, 0); - - bool isNull = false; - rstSet->IsColumnNull(4, isNull); - EXPECT_EQ(isNull, true); - - ret = -1; - ret = rstSet->GoToPreviousRow(); - EXPECT_EQ(ret, E_OK); - ret = -1; - ret = rstSet->GoToPreviousRow(); - EXPECT_EQ(ret, E_OK); - - rstSet->GetString(0, valueStr); - EXPECT_EQ(valueStr, "1"); - - rstSet->GetString(1, valueStr); - EXPECT_EQ(valueStr, "hello"); - - rstSet->GetLong(2, valuelg); - EXPECT_EQ(valuelg, 10); - - rstSet->GetDouble(3, valueDb); - EXPECT_EQ(valueDb, 1.0); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_002 - * @tc.desc: normal testcase of SqliteSharedResultSet for goToNextRow - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_002, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - int pos = -2; - rstSet->GetRowIndex(pos); - EXPECT_EQ(pos, -1); - bool isStart = true; - rstSet->IsStarted(isStart); - EXPECT_EQ(isStart, false); - bool isAtFirstRow = true; - rstSet->IsAtFirstRow(isAtFirstRow); - EXPECT_EQ(isAtFirstRow, false); - bool isEnded = true; - rstSet->IsEnded(isEnded); - EXPECT_EQ(isEnded, false); - - int retN1 = rstSet->GoToNextRow(); - EXPECT_EQ(retN1, E_OK); - rstSet->GetRowIndex(pos); - EXPECT_EQ(pos, 0); - rstSet->IsStarted(isStart); - EXPECT_EQ(isStart, true); - rstSet->IsAtFirstRow(isAtFirstRow); - EXPECT_EQ(isAtFirstRow, true); - isEnded = true; - rstSet->IsEnded(isEnded); - EXPECT_EQ(isEnded, false); - - int retN2 = rstSet->GoToNextRow(); - EXPECT_EQ(retN2, E_OK); - rstSet->GetRowIndex(pos); - EXPECT_EQ(pos, 1); - isStart = false; - rstSet->IsStarted(isStart); - EXPECT_EQ(isStart, true); - isAtFirstRow = true; - rstSet->IsAtFirstRow(isAtFirstRow); - EXPECT_EQ(isAtFirstRow, false); - isEnded = true; - rstSet->IsEnded(isEnded); - EXPECT_EQ(isEnded, false); - - int retN3 = rstSet->GoToNextRow(); - EXPECT_EQ(retN3, E_OK); - rstSet->GetRowIndex(pos); - EXPECT_EQ(pos, 2); - isStart = false; - rstSet->IsStarted(isStart); - EXPECT_EQ(isStart, true); - isAtFirstRow = true; - rstSet->IsAtFirstRow(isAtFirstRow); - EXPECT_EQ(isAtFirstRow, false); - bool isAtLastRow = false; - rstSet->IsAtLastRow(isAtLastRow); - EXPECT_EQ(isAtLastRow, true); - - int retN = rstSet->GoToNextRow(); - EXPECT_EQ(retN, E_ERROR); - rstSet->GetRowIndex(pos); - EXPECT_EQ(pos, 3); - isStart = false; - rstSet->IsStarted(isStart); - EXPECT_EQ(isStart, true); - isAtFirstRow = true; - rstSet->IsAtFirstRow(isAtFirstRow); - EXPECT_EQ(isAtFirstRow, false); - isEnded = false; - rstSet->IsEnded(isEnded); - EXPECT_EQ(isEnded, true); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_003 - * @tc.desc: normal testcase of SqliteSharedResultSet for moveFirst - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_003, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - int retF = rstSet->GoToFirstRow(); - EXPECT_EQ(retF, E_OK); - int index = -1; - rstSet->GetRowIndex(index); - EXPECT_EQ(index, 0); - bool isAtFirstRow = false; - rstSet->IsAtFirstRow(isAtFirstRow); - EXPECT_EQ(isAtFirstRow, true); - bool isStd = false; - rstSet->IsStarted(isStd); - EXPECT_EQ(isStd, true); - - int retN = rstSet->GoToNextRow(); - EXPECT_EQ(retN, E_OK); - rstSet->GetRowIndex(index); - EXPECT_EQ(index, 1); - isAtFirstRow = true; - rstSet->IsAtFirstRow(isAtFirstRow); - EXPECT_EQ(isAtFirstRow, false); - isStd = false; - rstSet->IsStarted(isStd); - EXPECT_EQ(isStd, true); - - int retGf = rstSet->GoToFirstRow(); - EXPECT_EQ(retGf, E_OK); - rstSet->GetRowIndex(index); - EXPECT_EQ(index, 0); - isAtFirstRow = false; - rstSet->IsAtFirstRow(isAtFirstRow); - EXPECT_EQ(isAtFirstRow, true); - isStd = false; - rstSet->IsStarted(isStd); - EXPECT_EQ(isStd, true); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_004 - * @tc.desc: normal testcase of SqliteSharedResultSet for getInt - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_004, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - int64_t valueInt = 0; - int ret = rstSet->GetLong(0, valueInt); - EXPECT_EQ(ret, E_INVALID_STATEMENT); - - int retF = rstSet->GoToFirstRow(); - EXPECT_EQ(retF, E_OK); - rstSet->GetLong(0, valueInt); - EXPECT_EQ(valueInt, 1); - rstSet->GetLong(2, valueInt); - EXPECT_EQ(valueInt, 10); - rstSet->GetLong(3, valueInt); - EXPECT_EQ(valueInt, 1); - - int retN = rstSet->GoToNextRow(); - EXPECT_EQ(retN, E_OK); - rstSet->GetLong(0, valueInt); - EXPECT_EQ(valueInt, 2); - valueInt = 0; - rstSet->GetLong(0, valueInt); - EXPECT_EQ(valueInt, 2); - valueInt = 0; - rstSet->GetLong(1, valueInt); - EXPECT_EQ(valueInt, 2); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_005 - * @tc.desc: normal testcase of SqliteSharedResultSet for getString - * @tc.type: FUNC - */ - -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_005, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - std::string valueStr = ""; - int ret1 = rstSet->GetString(0, valueStr); - EXPECT_EQ(ret1, E_INVALID_STATEMENT); - - int retF = rstSet->GoToFirstRow(); - EXPECT_EQ(retF, E_OK); - valueStr = ""; - rstSet->GetString(1, valueStr); - EXPECT_EQ(valueStr, "hello"); - rstSet->GetString(2, valueStr); - EXPECT_EQ(valueStr, "10"); - rstSet->GetString(3, valueStr); - EXPECT_EQ(valueStr, "1"); - - int ret2 = rstSet->GetString(4, valueStr); - EXPECT_EQ(ret2, E_OK); - - valueStr = ""; - int colCnt = 0; - rstSet->GetColumnCount(colCnt); - int ret3 = rstSet->GetString(colCnt, valueStr); - EXPECT_EQ(ret3, E_INVALID_COLUMN_INDEX); - - int retN = rstSet->GoToNextRow(); - EXPECT_EQ(retN, E_OK); - rstSet->GetString(0, valueStr); - EXPECT_EQ(valueStr, "2"); - valueStr = ""; - rstSet->GetString(1, valueStr); - EXPECT_EQ(valueStr, "2"); - rstSet->GetString(2, valueStr); - EXPECT_EQ(valueStr, "-5"); - rstSet->GetString(3, valueStr); - EXPECT_EQ(valueStr, "2.5"); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_006 - * @tc.desc: normal testcase of SqliteSharedResultSet for getDouble - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_006, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - double valueDb = 0.0; - int ret = rstSet->GetDouble(0, valueDb); - EXPECT_EQ(ret, E_INVALID_STATEMENT); - - int retF = rstSet->GoToFirstRow(); - EXPECT_EQ(retF, E_OK); - rstSet->GetDouble(0, valueDb); - EXPECT_EQ(valueDb, 1.0); - std::string valueStr = ""; - rstSet->GetString(1, valueStr); - EXPECT_EQ(valueStr, "hello"); - rstSet->GetDouble(2, valueDb); - EXPECT_EQ(valueDb, 10.0); - rstSet->GetDouble(3, valueDb); - EXPECT_EQ(valueDb, 1.0); - - int colCnt = 0; - rstSet->GetColumnCount(colCnt); - int ret1 = rstSet->GetDouble(colCnt, valueDb); - EXPECT_EQ(ret1, E_INVALID_COLUMN_INDEX); - - int retN = rstSet->GoToNextRow(); - EXPECT_EQ(retN, E_OK); - rstSet->GetDouble(0, valueDb); - EXPECT_EQ(valueDb, 2.0); - valueDb = 0.0; - rstSet->GetDouble(1, valueDb); - EXPECT_EQ(valueDb, 2.0); - - rstSet->GetDouble(2, valueDb); - EXPECT_EQ(valueDb, -5.0); - rstSet->GetDouble(3, valueDb); - EXPECT_EQ(valueDb, 2.5); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_007 - * @tc.desc: normal testcase of SqliteSharedResultSet for getBlob - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_007, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - int retF = rstSet->GoToFirstRow(); - EXPECT_EQ(retF, E_OK); - - std::vector blobVec; - rstSet->GetBlob(4, blobVec); - EXPECT_EQ(blobVec[0], 66); - - int retN = rstSet->GoToNextRow(); - EXPECT_EQ(retN, E_OK); - blobVec.clear(); - rstSet->GetBlob(4, blobVec); - int blobSz = blobVec.size(); - EXPECT_EQ(blobSz, 0); - - int retN1 = rstSet->GoToNextRow(); - EXPECT_EQ(retN1, E_OK); - blobVec.clear(); - rstSet->GetBlob(4, blobVec); - EXPECT_EQ(blobSz, 0); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_008 - * @tc.desc: normal testcase of SqliteSharedResultSet for getColumnTypeForIndex - * @tc.type: FUNC - */ - -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_008, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - ColumnType colType; - int ret = rstSet->GetColumnType(0, colType); - EXPECT_EQ(ret, E_INVALID_STATEMENT); - int retF = rstSet->GoToFirstRow(); - EXPECT_EQ(retF, E_OK); - - rstSet->GetColumnType(0, colType); - EXPECT_EQ(colType, ColumnType::TYPE_INTEGER); - - bool isColNull = true; - rstSet->IsColumnNull(0, isColNull); - EXPECT_EQ(isColNull, false); - - rstSet->GetColumnType(1, colType); - EXPECT_EQ(colType, ColumnType::TYPE_STRING); - - isColNull = true; - rstSet->IsColumnNull(0, isColNull); - EXPECT_EQ(isColNull, false); - - rstSet->GetColumnType(2, colType); - EXPECT_EQ(colType, ColumnType::TYPE_INTEGER); - rstSet->GetColumnType(3, colType); - EXPECT_EQ(colType, ColumnType::TYPE_FLOAT); - rstSet->GetColumnType(4, colType); - EXPECT_EQ(colType, ColumnType::TYPE_BLOB); - - int colCnt = 0; - rstSet->GetColumnCount(colCnt); - int ret1 = rstSet->GetColumnType(colCnt, colType); - EXPECT_EQ(ret1, E_INVALID_COLUMN_INDEX); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_009 - * @tc.desc: normal testcase of SqliteSharedResultSet for getColumnIndexForName - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_009, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - int colIndex = 0; - rstSet->GetColumnIndex("data1", colIndex); - EXPECT_EQ(colIndex, 1); - - rstSet->GetColumnIndex("data2", colIndex); - EXPECT_EQ(colIndex, 2); - - rstSet->GetColumnIndex("data3", colIndex); - EXPECT_EQ(colIndex, 3); - - rstSet->GetColumnIndex("data4", colIndex); - EXPECT_EQ(colIndex, 4); - - rstSet->GetColumnIndex("datax", colIndex); - EXPECT_EQ(colIndex, -1); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_010 - * @tc.desc: normal testcase of SqliteSharedResultSet for getColumnNameForIndex - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_010, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - std::vector allColNamesVec; - rstSet->GetAllColumnNames(allColNamesVec); - - std::string colName = ""; - rstSet->GetColumnName(1, colName); - EXPECT_EQ(colName, "data1"); - EXPECT_EQ(allColNamesVec[1], colName); - - rstSet->GetColumnName(2, colName); - EXPECT_EQ(colName, "data2"); - EXPECT_EQ(allColNamesVec[2], colName); - - rstSet->GetColumnName(3, colName); - EXPECT_EQ(colName, "data3"); - rstSet->GetColumnName(4, colName); - EXPECT_EQ(colName, "data4"); - - int colCnt = 0; - rstSet->GetColumnCount(colCnt); - int ret = rstSet->GetColumnName(colCnt, colName); - EXPECT_EQ(ret, E_INVALID_COLUMN_INDEX); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_011 - * @tc.desc: normal testcase of SqliteSharedResultSet - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_011, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - int retF = rstSet->GoToFirstRow(); - EXPECT_EQ(retF, E_OK); - - bool isAtFrtRow = false; - rstSet->IsAtFirstRow(isAtFrtRow); - EXPECT_EQ(isAtFrtRow, true); - - bool isStarted = false; - rstSet->IsStarted(isStarted); - EXPECT_EQ(isStarted, true); - - int64_t valueInt = 0; - rstSet->GetLong(2, valueInt); - EXPECT_EQ(valueInt, 10); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_012 - * @tc.desc: normal testcase of SqliteSharedResultSet for getLong - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_012, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - int64_t valueInt = 0; - int ret = rstSet->GetLong(0, valueInt); - EXPECT_EQ(ret, E_INVALID_STATEMENT); - - int retF = rstSet->GoToFirstRow(); - EXPECT_EQ(retF, E_OK); - rstSet->GetLong(0, valueInt); - EXPECT_EQ(valueInt, 1.0); - std::string valueStr = ""; - rstSet->GetString(1, valueStr); - EXPECT_EQ(valueStr, "hello"); - rstSet->GetLong(2, valueInt); - EXPECT_EQ(valueInt, 10.0); - rstSet->GetLong(3, valueInt); - EXPECT_EQ(valueInt, 1.0); - - int colCnt = 0; - rstSet->GetColumnCount(colCnt); - int ret1 = rstSet->GetLong(colCnt, valueInt); - EXPECT_EQ(ret1, E_INVALID_COLUMN_INDEX); - - int retN = rstSet->GoToNextRow(); - EXPECT_EQ(retN, E_OK); - rstSet->GetLong(0, valueInt); - EXPECT_EQ(valueInt, 2.0); - valueInt = 0; - rstSet->GetLong(1, valueInt); - EXPECT_EQ(valueInt, 2.0); - rstSet->GetLong(2, valueInt); - EXPECT_EQ(valueInt, -5.0); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_013 - * @tc.desc: normal testcase of SqliteSharedResultSet for fillBlock - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_013, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - SqliteSharedResultSet *pSqlSharedRstSet = static_cast(rstSet.get()); - bool isBk = pSqlSharedRstSet->HasBlock(); - EXPECT_EQ(isBk, true); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} -/* * - * @tc.name: Sqlite_Shared_Result_Set_014 - * @tc.desc: normal testcase of SqliteSharedResultSet for getBlock - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_014, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - SqliteSharedResultSet *pSqlSharedRstSet = static_cast(rstSet.get()); - bool isBk = pSqlSharedRstSet->HasBlock(); - EXPECT_EQ(isBk, true); - - int retF = rstSet->GoToFirstRow(); - EXPECT_EQ(retF, E_OK); - OHOS::AppDataFwk::SharedBlock *pBk = pSqlSharedRstSet->GetBlock(); - EXPECT_NE(pBk, nullptr); - - std::string path = RdbTest::store->GetPath(); - std::string path1 = pBk->Name(); - - EXPECT_EQ(path, "/data/test/shared_test.db"); - EXPECT_EQ(path1, "/data/test/shared_test.db"); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} -/* * - * @tc.name: Sqlite_Shared_Result_Set_015 - * @tc.desc: normal testcase of SqliteSharedResultSet for setBlock - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_015, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - SqliteSharedResultSet *pSqlSharedRstSet = static_cast(rstSet.get()); - bool isBk = pSqlSharedRstSet->HasBlock(); - EXPECT_EQ(isBk, true); - - int retN = rstSet->GoToNextRow(); - EXPECT_EQ(retN, E_OK); - - std::string path = RdbTest::store->GetPath(); - OHOS::AppDataFwk::SharedBlock *pBk = pSqlSharedRstSet->GetBlock(); - std::string path1 = pBk->Name(); - - EXPECT_EQ(path, "/data/test/shared_test.db"); - EXPECT_EQ(path1, "/data/test/shared_test.db"); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_016 - * @tc.desc: normal testcase of SqliteSharedResultSet for setFillWindowForwardOnly - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_016, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - SqliteSharedResultSet *pSqlSharedRstSet = static_cast(rstSet.get()); - bool isBk = pSqlSharedRstSet->HasBlock(); - EXPECT_EQ(isBk, true); - - pSqlSharedRstSet->PickFillBlockStartPosition(0, 0); - pSqlSharedRstSet->SetFillBlockForwardOnly(true); - pSqlSharedRstSet->GoToFirstRow(); - - OHOS::AppDataFwk::SharedBlock *pBk = pSqlSharedRstSet->GetBlock(); - EXPECT_NE(pBk, nullptr); - std::string path = RdbTest::store->GetPath(); - std::string path1 = pBk->Name(); - - EXPECT_EQ(path, "/data/test/shared_test.db"); - EXPECT_EQ(path1, "/data/test/shared_test.db"); - - int rowCnt = 0; - pSqlSharedRstSet->GetRowCount(rowCnt); - int rowCntBk = pBk->GetRowNum(); - - EXPECT_EQ(rowCnt, rowCntBk); - - rstSet->Close(); - bool isClosedFlag = rstSet->IsClosed(); - EXPECT_EQ(isClosedFlag, true); -} - -/* * - * @tc.name: Sqlite_Shared_Result_Set_017 - * @tc.desc: normal testcase of SqliteSharedResultSet for setExtensions and getExtensions - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, Sqlite_Shared_Result_Set_017, TestSize.Level1) -{ - GenerateDefaultTable(); - std::vector selectionArgs; - std::unique_ptr rstSet = RdbTest::store->QuerySql("SELECT * FROM test", selectionArgs); - EXPECT_NE(rstSet, nullptr); - - int rowCnt = 0; - rstSet->GetRowCount(rowCnt); - EXPECT_EQ(rowCnt, 3); - int ret = rstSet->GoToLastRow(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_Transaction_001 - * @tc.desc: test RdbStore BaseTransaction - * @tc.type: FUNC - * @tc.author: chenxi - */ -HWTEST_F(RdbTest, RdbStore_Transaction_001, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - int ret = store->BeginTransaction(); - EXPECT_EQ(ret, E_OK); - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 19); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("wangyjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, id); - - ret = store->Commit(); - EXPECT_EQ(ret, E_OK); - - int64_t count; - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 3); - - int deletedRows; - ret = store->Delete(deletedRows, "test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(deletedRows, 3); -} - -/** - * @tc.name: RdbStore_Transaction_002 - * @tc.desc: test RdbStore BaseTransaction - * @tc.type: FUNC - * @tc.author: chenxi - */ -HWTEST_F(RdbTest, RdbStore_Transaction_002, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - int ret = store->BeginTransaction(); - EXPECT_EQ(ret, E_OK); - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 19); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("wangyjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, id); - - ret = store->Commit(); - EXPECT_EQ(ret, E_OK); - - int64_t count; - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 3); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); - - int deletedRows; - ret = store->Delete(deletedRows, "test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(deletedRows, 3); -} - -/** - * @tc.name: RdbStore_NestedTransaction_001 - * @tc.desc: test RdbStore BaseTransaction - * @tc.type: FUNC - * @tc.author: chenxi - */ -HWTEST_F(RdbTest, RdbStore_NestedTransaction_001, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - int ret = store->BeginTransaction(); - EXPECT_EQ(ret, E_OK); - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - ret = store->BeginTransaction(); - EXPECT_EQ(ret, E_OK); - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 19); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - ret = store->Commit(); // not commit - EXPECT_EQ(ret, E_OK); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("wangyjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, id); - - ret = store->Commit(); - EXPECT_EQ(ret, E_OK); - - int64_t count; - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 3); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); - - int deletedRows; - ret = store->Delete(deletedRows, "test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(deletedRows, 3); -} - -/** - * @tc.name: RdbStore_NestedTransaction_002 - * @tc.desc: test RdbStore BaseTransaction - * @tc.type: FUNC - * @tc.author: chenxi - */ -HWTEST_F(RdbTest, RdbStore_NestedTransaction_002, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - int ret = store->BeginTransaction(); - EXPECT_EQ(ret, E_OK); - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - ret = store->BeginTransaction(); - EXPECT_EQ(ret, E_OK); - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 19); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - ret = store->Commit(); - EXPECT_EQ(ret, E_OK); - ret = store->Commit(); // commit - EXPECT_EQ(ret, E_OK); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("wangyjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, id); - - int64_t count; - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 3); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); - - int deletedRows; - ret = store->Delete(deletedRows, "test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(deletedRows, 3); -} - -/** - * @tc.name: RdbStore_NestedTransaction_003 - * @tc.desc: test RdbStore BaseTransaction - * @tc.type: FUNC - * @tc.author: chenxi - */ -HWTEST_F(RdbTest, RdbStore_NestedTransaction_003, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - int ret = store->BeginTransaction(); - EXPECT_EQ(ret, E_OK); - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - ret = store->BeginTransaction(); - EXPECT_EQ(ret, E_OK); - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 19); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - ret = store->Commit(); // not commit - EXPECT_EQ(ret, E_OK); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("wangyjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, id); - - ret = store->Commit(); // not commit - EXPECT_EQ(ret, E_OK); - - int64_t count; - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 3); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); - - int deletedRows; - ret = store->Delete(deletedRows, "test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(deletedRows, 3); -} \ No newline at end of file diff --git a/relational_store/test/native/relational_store_test/unittest/relational_store_test.cpp b/relational_store/test/native/relational_store_test/unittest/relational_store_test.cpp deleted file mode 100644 index 2ee9264c..00000000 --- a/relational_store/test/native/relational_store_test/unittest/relational_store_test.cpp +++ /dev/null @@ -1,1953 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include - -#include - -#include "common.h" -#include "logger.h" -#include "rdb_errno.h" -#include "rdb_helper.h" -#include "rdb_open_callback.h" - -using namespace testing::ext; -using namespace OHOS::NativeRdb; - -class RdbTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(void); - void SetUp(); - void TearDown(); - void QueryCheck1(std::shared_ptr &store) const; - void QueryCheck2(std::shared_ptr &store) const; - - static const std::string MAIN_DATABASE_NAME; - static const std::string ATTACHED_DATABASE_NAME; - static const std::string DATABASE_NAME; - static std::shared_ptr store; -}; - -const std::string RdbTest::MAIN_DATABASE_NAME = RDB_TEST_PATH + "main.db"; -const std::string RdbTest::DATABASE_NAME = RDB_TEST_PATH + "delete_test.db"; -const std::string RdbTest::DATABASE_NAME = RDB_TEST_PATH + "update_test.db"; -std::shared_ptr RdbTest::store = nullptr; - -class DeleteTestOpenCallback : public RdbOpenCallback { -public: - int OnCreate(RdbStore &rdbStore) override; - int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override; - static const std::string CREATE_TABLE_TEST; -}; - -std::string const DeleteTestOpenCallback::CREATE_TABLE_TEST = - std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, " - "name TEXT NOT NULL, age INTEGER, salary " - "REAL, blobType BLOB)"); - -int DeleteTestOpenCallback::OnCreate(RdbStore &store) -{ - return store.ExecuteSql(CREATE_TABLE_TEST); -} - -int DeleteTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion) -{ - return E_OK; -} - -class MainOpenCallback : public RdbOpenCallback { -public: - int OnCreate(RdbStore &rdbStore) override; - int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override; - static const std::string CREATE_TABLE_TEST; -}; - -std::string const MainOpenCallback::CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test1(id INTEGER PRIMARY KEY " - "AUTOINCREMENT, name TEXT NOT NULL)"; - -int MainOpenCallback::OnCreate(RdbStore &store) -{ - return store.ExecuteSql(CREATE_TABLE_TEST); -} - -int MainOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion) -{ - return E_OK; -} - -const std::string RdbTest::ATTACHED_DATABASE_NAME = RDB_TEST_PATH + "attached.db"; - -class AttachedOpenCallback : public RdbOpenCallback { -public: - int OnCreate(RdbStore &rdbStore) override; - int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override; - static const std::string CREATE_TABLE_TEST; -}; - -std::string const AttachedOpenCallback::CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test2(id INTEGER PRIMARY KEY " - "AUTOINCREMENT, name TEXT NOT NULL)"; - -int AttachedOpenCallback::OnCreate(RdbStore &store) -{ - return store.ExecuteSql(CREATE_TABLE_TEST); -} - -int AttachedOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion) -{ - return E_OK; -} - -void RdbTest::SetUpTestCase(void) -{ - RdbStoreConfig attachedConfig(RdbTest::ATTACHED_DATABASE_NAME); - AttachedOpenCallback attachedHelper; - int errCode = E_OK; - std::shared_ptr attachedStore = RdbHelper::GetRdbStore(attachedConfig, 1, attachedHelper, errCode); - EXPECT_NE(attachedStore, nullptr); -} - -void RdbTest::TearDownTestCase(void) -{ - RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME); - RdbHelper::DeleteRdbStore(ATTACHED_DATABASE_NAME); -} - -void RdbTest::SetUp(void) -{ -} - -void RdbTest::TearDown(void) -{ - RdbHelper::ClearCache(); -} - -/** - * @tc.name: RdbStore_Attach_001 - * @tc.desc: test attach, attach is not supported in wal mode - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Attach_001, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::MAIN_DATABASE_NAME); - MainOpenCallback helper; - int errCode = E_OK; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - - int ret = store->ExecuteSql("ATTACH '" + ATTACHED_DATABASE_NAME + "' as attached"); - EXPECT_EQ(ret, E_NOT_SUPPORTED_ATTACH_IN_WAL_MODE); - - ret = store->ExecuteSql("attach '" + ATTACHED_DATABASE_NAME + "' as attached"); - EXPECT_EQ(ret, E_NOT_SUPPORTED_ATTACH_IN_WAL_MODE); -} - -/** - * @tc.name: RdbStore_Attach_002 - * @tc.desc: test RdbStore attach - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Attach_002, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::MAIN_DATABASE_NAME); - config.SetJournalMode(JournalMode::MODE_TRUNCATE); - MainOpenCallback helper; - int errCode = E_OK; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - - int ret = store->ExecuteSql("ATTACH DATABASE '" + ATTACHED_DATABASE_NAME + "' as 'attached'"); - EXPECT_EQ(ret, E_OK); - - int64_t id; - ValuesBucket values; - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - ret = store->Insert(id, "test1", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(id, 1); - - values.Clear(); - values.PutInt("id", 1); - values.PutString("name", std::string("lisi")); - ret = store->Insert(id, "test2", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(id, 1); - - QueryCheck1(store); - - ret = store->ExecuteSql("DETACH DATABASE 'attached'"); - EXPECT_EQ(ret, E_OK); - - QueryCheck2(store); - - ret = store->ExecuteSql("attach database '" + ATTACHED_DATABASE_NAME + "' as 'attached'"); - EXPECT_EQ(ret, E_OK); - - ret = store->ExecuteSql("detach database 'attached'"); - EXPECT_EQ(ret, E_OK); -} - -void RdbTest::QueryCheck1(std::shared_ptr &store) const -{ - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test1"); - EXPECT_NE(resultSet, nullptr); - int ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - int columnIndex; - int intVal; - ret = resultSet->GetColumnIndex("id", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(intVal, 1); - std::string strVal; - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(strVal, "zhangsan"); - - resultSet = store->QuerySql("SELECT * FROM test2"); - EXPECT_NE(resultSet, nullptr); - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetColumnIndex("id", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(intVal, 1); - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(strVal, "lisi"); -} - -void RdbTest::QueryCheck2(std::shared_ptr &store) const -{ - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test1"); - EXPECT_NE(resultSet, nullptr); - int ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - int columnIndex; - int intVal; - ret = resultSet->GetColumnIndex("id", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(intVal, 1); - std::string strVal; - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(strVal, "zhangsan"); - - // detached, no table test2 - resultSet = store->QuerySql("SELECT * FROM test2"); - EXPECT_NE(resultSet, nullptr); -} - -/** - * @tc.name: RdbStore_Delete_001 - * @tc.desc: test RdbStore update, select id and update one row - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Delete_001, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - int deletedRows; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 19); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("wangyjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, id); - - ret = store->Delete(deletedRows, "test", "id = 1"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, deletedRows); - - std::unique_ptr resultSet = - store->QuerySql("SELECT * FROM test WHERE id = ?", std::vector{ "1" }); - EXPECT_NE(resultSet, nullptr); - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ERROR); - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); - - resultSet = store->QuerySql("SELECT * FROM test WHERE id = ?", std::vector{ "2" }); - EXPECT_NE(resultSet, nullptr); - ret = resultSet->GoToFirstRow(); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ERROR); - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); - - resultSet = store->QuerySql("SELECT * FROM test WHERE id = 3", std::vector()); - EXPECT_NE(resultSet, nullptr); - ret = resultSet->GoToFirstRow(); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ERROR); - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_Delete_002 - * @tc.desc: test RdbStore update, select id and update one row - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Delete_002, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - int deletedRows; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 19); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("wangyjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, id); - - ret = store->Delete(deletedRows, "test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, deletedRows); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ERROR); - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_Encrypt_Decrypt_Test_001 - * @tc.desc: test RdbStore Get Encrypt Store - * @tc.type: FUNC - * @tc.require: - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Encrypt_01, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::ENCRYPTED_DATABASE_NAME); - config.SetEncryptStatus(true); - config.SetBundleName("com.example.TestEncrypt1"); - EncryptTestOpenCallback helper; - int errCode; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); -} - -/** - * @tc.name: RdbStore_Encrypt_Decrypt_Test_002 - * @tc.desc: test RdbStore Get Unencrypted Store - * @tc.type: FUNC - * @tc.require: - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Encrypt_02, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::UNENCRYPTED_DATABASE_NAME); - config.SetEncryptStatus(false); - config.SetBundleName("com.example.TestEncrypt2"); - EncryptTestOpenCallback helper; - int errCode; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); -} - -/** - * @tc.name: RdbStore_Encrypt_Decrypt_Test_003 - * @tc.desc: test create encrypted Rdb and insert data ,then query - * @tc.type: FUNC - * @tc.require: - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Encrypt_03, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::ENCRYPTED_DATABASE_NAME); - config.SetEncryptStatus(true); - config.SetBundleName("com.example.TestEncrypt3"); - EncryptTestOpenCallback helper; - int errCode; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - - int columnIndex; - int intVal; - std::string strVal; - double dVal; - std::vector blob; - - ret = resultSet->GetColumnIndex("id", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, intVal); - - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ("zhangsan", strVal); - - ret = resultSet->GetColumnIndex("age", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(18, intVal); - - ret = resultSet->GetColumnIndex("salary", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetDouble(columnIndex, dVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(100.5, dVal); - - ret = resultSet->GetColumnIndex("blobType", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetBlob(columnIndex, blob); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, static_cast(blob.size())); - EXPECT_EQ(1, blob[0]); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ERROR); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_Encrypt_Decrypt_Test_004 - * @tc.desc: test RdbStore key file. - * @tc.type: FUNC - * @tc.require: - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Encrypt_04, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::ENCRYPTED_DATABASE_NAME); - config.SetEncryptStatus(true); - config.SetBundleName("com.example.TestEncrypt4"); - EncryptTestOpenCallback helper; - int errCode; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - std::string keyPath = RDB_TEST_PATH + "key/encrypted.pub_key"; - int ret = access(keyPath.c_str(), F_OK); - EXPECT_EQ(ret, 0); - - RdbHelper::DeleteRdbStore(RdbTest::ENCRYPTED_DATABASE_NAME); - ret = access(keyPath.c_str(), F_OK); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name: RdbStore_Encrypt_Decrypt_Test_005 - * @tc.desc: test RdbStore Get Encrypted Store with empty boundlename - * @tc.type: FUNC - * @tc.require: - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Encrypt_05, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::ENCRYPTED_DATABASE_NAME); - config.SetEncryptStatus(true); - config.SetBundleName(""); - EncryptTestOpenCallback helper; - int errCode; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_EQ(store, nullptr); -} - -/** - * @tc.name: RdbStore_Encrypt_Decrypt_Test_006 - * @tc.desc: test SaveSecretKeyToFile when KeyFileType isNot PUB_KEY_FILE - * @tc.type: FUNC - * @tc.require: - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Encrypt_06, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::ENCRYPTED_DATABASE_NAME); - config.SetEncryptStatus(true); - config.SetBundleName("com.example.TestEncrypt6"); - EncryptTestOpenCallback helper; - int errCode; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - bool ret = - RdbSecurityManager::GetInstance().CheckKeyDataFileExists(RdbSecurityManager::KeyFileType::PUB_KEY_BAK_FILE); - EXPECT_EQ(ret, false); - std::vector key = RdbSecurityManager::GetInstance().GenerateRandomNum(RdbSecurityManager::RDB_KEY_SIZE); - bool flag = - RdbSecurityManager::GetInstance().SaveSecretKeyToFile(RdbSecurityManager::KeyFileType::PUB_KEY_BAK_FILE, key); - EXPECT_EQ(flag, true); -} - -/** - * @tc.name: RdbStore_Encrypt_Decrypt_Test_007 - * @tc.desc: test GetRdbPassword when KeyFileType isNot PUB_KEY_FILE - * @tc.type: FUNC - * @tc.require: - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Encrypt_07, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::ENCRYPTED_DATABASE_NAME); - config.SetEncryptStatus(true); - config.SetBundleName("com.example.TestEncrypt7"); - EncryptTestOpenCallback helper; - int errCode; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - auto key = RdbSecurityManager::GetInstance().GetRdbPassword(RdbSecurityManager::KeyFileType::PUB_KEY_BAK_FILE); - RdbPassword password = {}; - EXPECT_EQ(key, password); -} - -/** - * @tc.name: RdbStore_Encrypt_Decrypt_Test_008 - * @tc.desc: test RemoveSuffix when pos == std::string::npos - * @tc.type: FUNC - * @tc.require: - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Encrypt_08, TestSize.Level1) -{ - std::string path = RDB_TEST_PATH + "test"; - RdbStoreConfig config(path); - config.SetEncryptStatus(true); - config.SetBundleName("com.example.TestEncrypt8"); - EncryptTestOpenCallback helper; - int errCode; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); -} - -/** - * @tc.name: RdbStore_Encrypt_Decrypt_Test_009 - * @tc.desc: test GetKeyDistributedStatus and SetKeyDistributedStatus - * @tc.type: FUNC - * @tc.require: - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Encrypt_09, TestSize.Level1) -{ - RdbStoreConfig config(RdbTest::ENCRYPTED_DATABASE_NAME); - config.SetEncryptStatus(true); - config.SetBundleName("com.example.TestEncrypt9"); - EncryptTestOpenCallback helper; - int errCode; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - - bool distributedStatus = false; - int ret = RdbSecurityManager::GetInstance().GetKeyDistributedStatus( - RdbSecurityManager::KeyFileType::PUB_KEY_FILE, distributedStatus); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(distributedStatus, false); - ret = RdbSecurityManager::GetInstance().GetKeyDistributedStatus( - RdbSecurityManager::KeyFileType::PUB_KEY_BAK_FILE, distributedStatus); - EXPECT_EQ(ret, E_ERROR); - EXPECT_EQ(distributedStatus, false); - ret = - RdbSecurityManager::GetInstance().SetKeyDistributedStatus(RdbSecurityManager::KeyFileType::PUB_KEY_FILE, true); - EXPECT_EQ(ret, E_OK); - ret = RdbSecurityManager::GetInstance().GetKeyDistributedStatus( - RdbSecurityManager::KeyFileType::PUB_KEY_FILE, distributedStatus); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(distributedStatus, true); - ret = RdbSecurityManager::GetInstance().SetKeyDistributedStatus( - RdbSecurityManager::KeyFileType::PUB_KEY_BAK_FILE, distributedStatus); - EXPECT_EQ(ret, E_ERROR); -} - -/** - * @tc.name: RdbStore_Execute_001 - * @tc.desc: test RdbStore Execute - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Execute_001, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 19); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("wangyjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, id); - - int64_t count; - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 3); - - ret = store->ExecuteSql("DELETE FROM test WHERE age = ? OR age = ?", - std::vector{ ValueObject(std::string("18")), ValueObject(std ::string("20")) }); - EXPECT_EQ(ret, E_OK); - - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test where age = 19"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 1); - - ret = store->ExecuteSql("DELETE FROM test WHERE age = 19"); - EXPECT_EQ(ret, E_OK); - - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 0); -} - -/** - * @tc.name: RdbStore_Execute_002 - * @tc.desc: test RdbStore Execute - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Execute_002, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 19); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(2, id); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("wangyjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(3, id); - - int64_t count; - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test", std::vector()); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 3); - - ret = store->ExecuteSql("DELETE FROM test WHERE age = ? OR age = ?", - std::vector{ ValueObject(std::string("18")), ValueObject(std ::string("20")) }); - EXPECT_EQ(ret, E_OK); - - ret = store->ExecuteAndGetLong( - count, "SELECT COUNT(*) FROM test where age = ?", std::vector{ ValueObject(std::string("19")) }); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 1); - - ret = store->ExecuteSql("DELETE FROM test WHERE age = 19"); - EXPECT_EQ(ret, E_OK); - - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test", std::vector()); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(count, 0); - - ret = store->ExecuteSql("DROP TABLE IF EXISTS test"); - EXPECT_EQ(ret, E_OK); - - ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test"); - EXPECT_EQ(ret, -1); -} - -/** - * @tc.name: RdbStore_Execute_003 - * @tc.desc: test RdbStore Execute - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Execute_003, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t pageSize; - int ret = store->ExecuteAndGetLong(pageSize, "PRAGMA page_size"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(pageSize, 4096); - - std::string journalMode; - ret = store->ExecuteAndGetString(journalMode, "PRAGMA journal_mode"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(journalMode, "wal"); -} - -/** - * @tc.name: RdbStore_Insert_001 - * @tc.desc: test RdbStore insert - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Insert_001, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 2); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - values.Clear(); - values.PutInt("id", 3); - values.PutString("name", std::string("lisi")); - values.PutInt("age", 20L); - values.PutDouble("salary", 100.5f); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, id); - - RdbTest::CheckResultSet(store); -} - -void RdbTest::CheckResultSet(std::shared_ptr &store) -{ - std::unique_ptr resultSet = - store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector{ "zhangsan" }); - EXPECT_NE(resultSet, nullptr); - - int columnIndex; - int intVal; - std::string strVal; - ColumnType columnType; - int position; - int ret = resultSet->GetRowIndex(position); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(position, -1); - - ret = resultSet->GetColumnType(0, columnType); - EXPECT_EQ(ret, E_INVALID_STATEMENT); - - ret = resultSet->GoToFirstRow(); - EXPECT_EQ(ret, E_OK); - - ret = resultSet->GetColumnIndex("id", columnIndex); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(columnIndex, 0); - ret = resultSet->GetColumnType(columnIndex, columnType); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(columnType, ColumnType::TYPE_INTEGER); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, intVal); - - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetColumnType(columnIndex, columnType); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(columnType, ColumnType::TYPE_STRING); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ("zhangsan", strVal); - - RdbTest::CheckAge(resultSet); - RdbTest::CheckSalary(resultSet); - RdbTest::CheckBlob(resultSet); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ERROR); - - ret = resultSet->GetColumnType(columnIndex, columnType); - EXPECT_EQ(ret, E_INVALID_STATEMENT); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -void RdbTest::CheckAge(std::unique_ptr &resultSet) -{ - int columnIndex; - int intVal; - ColumnType columnType; - int ret = resultSet->GetColumnIndex("age", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetColumnType(columnIndex, columnType); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(columnType, ColumnType::TYPE_INTEGER); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(18, intVal); -} - -void RdbTest::CheckSalary(std::unique_ptr &resultSet) -{ - int columnIndex; - double dVal; - ColumnType columnType; - int ret = resultSet->GetColumnIndex("salary", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetColumnType(columnIndex, columnType); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(columnType, ColumnType::TYPE_FLOAT); - ret = resultSet->GetDouble(columnIndex, dVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(100.5, dVal); -} - -void RdbTest::CheckBlob(std::unique_ptr &resultSet) -{ - int columnIndex; - std::vector blob; - ColumnType columnType; - int ret = resultSet->GetColumnIndex("blobType", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetColumnType(columnIndex, columnType); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(columnType, ColumnType::TYPE_BLOB); - ret = resultSet->GetBlob(columnIndex, blob); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, static_cast(blob.size())); - EXPECT_EQ(1, blob[0]); - EXPECT_EQ(2, blob[1]); - EXPECT_EQ(3, blob[2]); -} - -/** - * @tc.name: RdbStore_Replace_001 - * @tc.desc: test RdbStore replace - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Replace_001, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->Replace(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - - int columnIndex; - int intVal; - std::string strVal; - double dVal; - std::vector blob; - - ret = resultSet->GetColumnIndex("id", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, intVal); - - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ("zhangsan", strVal); - - ret = resultSet->GetColumnIndex("age", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(18, intVal); - - ret = resultSet->GetColumnIndex("salary", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetDouble(columnIndex, dVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(100.5, dVal); - - ret = resultSet->GetColumnIndex("blobType", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetBlob(columnIndex, blob); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, static_cast(blob.size())); - EXPECT_EQ(1, blob[0]); - EXPECT_EQ(2, blob[1]); - EXPECT_EQ(3, blob[2]); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ERROR); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_Replace_002 - * @tc.desc: test RdbStore replace - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_Replace_002, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->Replace(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - - int columnIndex; - int intVal; - std::string strVal; - double dVal; - std::vector blob; - - ret = resultSet->GetColumnIndex("id", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, intVal); - - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ("zhangsan", strVal); - - ret = resultSet->GetColumnIndex("age", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(18, intVal); - - ret = resultSet->GetColumnIndex("salary", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetDouble(columnIndex, dVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(200.5, dVal); - - ret = resultSet->GetColumnIndex("blobType", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetBlob(columnIndex, blob); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, static_cast(blob.size())); - EXPECT_EQ(1, blob[0]); - EXPECT_EQ(2, blob[1]); - EXPECT_EQ(3, blob[2]); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ERROR); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_InsertWithConflictResolution_001_002 - * @tc.desc: test RdbStore InsertWithConflictResolution - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_InsertWithConflictResolution_001_002, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - - // default is ConflictResolution::ON_CONFLICT_NONE - int ret = store->InsertWithConflictResolution(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->InsertWithConflictResolution(id, "test", values); - EXPECT_EQ(ret, RdbTest::E_SQLITE_CONSTRAINT); -} - -/** - * @tc.name: RdbStore_InsertWithConflictResolution_003_004 - * @tc.desc: test RdbStore InsertWithConflictResolution - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_InsertWithConflictResolution_003_004, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_ROLLBACK); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_ROLLBACK); - EXPECT_EQ(ret, RdbTest::E_SQLITE_CONSTRAINT); -} - -/** - * @tc.name: RdbStore_InsertWithConflictResolution_005 - * @tc.desc: test RdbStore InsertWithConflictResolution - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_InsertWithConflictResolution_005, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_IGNORE); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_IGNORE); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(id, -1); -} - -/** - * @tc.name: RdbStore_InsertWithConflictResolution_006_007 - * @tc.desc: test RdbStore InsertWithConflictResolution - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, RdbStore_InsertWithConflictResolution_006_007, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int64_t id; - ValuesBucket values; - - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_REPLACE); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.Clear(); - values.PutInt("id", 1); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 18); - values.PutDouble("salary", 200.5); - values.PutBlob("blobType", std::vector{ 4, 5, 6 }); - ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_REPLACE); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(id, 1); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - - int columnIndex; - int intVal; - std::string strVal; - double dVal; - std::vector blob; - - ret = resultSet->GetColumnIndex("id", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, intVal); - - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ("zhangsan", strVal); - - ret = resultSet->GetColumnIndex("age", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(18, intVal); - - ret = resultSet->GetColumnIndex("salary", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetDouble(columnIndex, dVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(200.5, dVal); - - ret = resultSet->GetColumnIndex("blobType", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetBlob(columnIndex, blob); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(3, static_cast(blob.size())); - EXPECT_EQ(4, blob[0]); - EXPECT_EQ(5, blob[1]); - EXPECT_EQ(6, blob[2]); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ERROR); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_BatchInsert_001 - * @tc.desc: test RdbStore BatchInsert - * @tc.type: FUNC - * @tc.require: issueI5GZGX - */ -HWTEST_F(RdbTest, RdbStore_BatchInsert_001, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - ValuesBucket values; - - values.PutString("name", "zhangsan"); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - - std::vector valuesBuckets; - for (int i = 0; i < 100; i++) { - valuesBuckets.push_back(values); - } - int64_t insertNum = 0; - int ret = store->BatchInsert(insertNum, "test", valuesBuckets); - EXPECT_EQ(E_OK, ret); - EXPECT_EQ(100, insertNum); - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - int rowCount = 0; - resultSet->GetRowCount(rowCount); - EXPECT_EQ(100, rowCount); -} - -/** - * @tc.name: ValueObject_TEST_001 - * @tc.desc: test ValueObject - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, ValueObject_TEST_001, TestSize.Level1) -{ - ValueObject obj = ValueObject(); - ValueObjectType type = obj.GetType(); - EXPECT_EQ(type, ValueObjectType::TYPE_NULL); -} - -/** - * @tc.name: ValueObject_TEST_002 - * @tc.desc: test ValueObject - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, ValueObject_TEST_002, TestSize.Level1) -{ - int inputVal = 5; - int outputVal = 0; - ValueObject obj = ValueObject(inputVal); - ValueObjectType type = obj.GetType(); - EXPECT_EQ(type, ValueObjectType::TYPE_INT); - int ret = obj.GetInt(outputVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(outputVal, 5); -} - -/** - * @tc.name: ValueObject_TEST_003 - * @tc.desc: test ValueObject - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, ValueObject_TEST_003, TestSize.Level1) -{ - bool inputVal = true; - bool outputVal = false; - ValueObject obj = ValueObject(inputVal); - ValueObjectType type = obj.GetType(); - EXPECT_EQ(type, ValueObjectType::TYPE_BOOL); - int ret = obj.GetBool(outputVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(outputVal, true); -} - -/** - * @tc.name: ValueObject_TEST_004 - * @tc.desc: test ValueObject - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, ValueObject_TEST_004, TestSize.Level1) -{ - std::string inputVal = "hello"; - std::string outputVal = ""; - ValueObject obj = ValueObject(inputVal); - ValueObjectType type = obj.GetType(); - EXPECT_EQ(type, ValueObjectType::TYPE_STRING); - int ret = obj.GetString(outputVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(outputVal, "hello"); -} - -/** - * @tc.name: ValueObject_TEST_005 - * @tc.desc: test ValueObject - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, ValueObject_TEST_005, TestSize.Level1) -{ - std::vector inputVal = { 'h', 'e', 'l', 'l', 'o' }; - std::vector outputVal; - ValueObject obj = ValueObject(inputVal); - ValueObjectType type = obj.GetType(); - EXPECT_EQ(type, ValueObjectType::TYPE_BLOB); - int ret = obj.GetBlob(outputVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(static_cast(outputVal.size()), 5); - EXPECT_EQ(outputVal[0], 'h'); - EXPECT_EQ(outputVal[1], 'e'); - EXPECT_EQ(outputVal[2], 'l'); - EXPECT_EQ(outputVal[3], 'l'); - EXPECT_EQ(outputVal[4], 'o'); -} - -/** - * @tc.name: ValueObject_TEST_006 - * @tc.desc: test ValueObject - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, ValueObject_TEST_006, TestSize.Level1) -{ - int inputVal = 5; - ValueObject obj = ValueObject(inputVal); - ValueObject obj1 = ValueObject(); - obj1 = obj; - ValueObjectType type = obj1.GetType(); - EXPECT_EQ(type, ValueObjectType::TYPE_INT); -} - -/** - * @tc.name: ValuesBucket_001 - * @tc.desc: test ValuesBucket - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, ValuesBucket_001, TestSize.Level1) -{ - ValuesBucket values; - values.PutInt("id", 1); - values.PutNull("name"); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - - int size = values.Size(); - EXPECT_EQ(size, 5); - bool contains = values.HasColumn("name"); - EXPECT_EQ(contains, true); - ValueObject obj; - contains = values.GetObject("salary", obj); - double val = 0.0; - ValueObjectType type = obj.GetType(); - EXPECT_EQ(type, ValueObjectType::TYPE_DOUBLE); - int ret = obj.GetDouble(val); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(val, 100.5); - - values.Delete("name"); - size = values.Size(); - EXPECT_EQ(size, 4); - contains = values.HasColumn("name"); - EXPECT_EQ(contains, false); - - values.Clear(); - size = values.Size(); - EXPECT_EQ(size, 0); - contains = values.HasColumn("salary"); - EXPECT_EQ(contains, false); -} - -/** - * @tc.name: ValuesBucket_002 - * @tc.desc: test ValuesBucket - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, ValuesBucket_002, TestSize.Level1) -{ - int errCode = E_OK; - const std::string dbPath = RDB_TEST_PATH + "InterfaceTest.db"; - RdbStoreConfig config(dbPath); - MyOpenCallback helper; - std::shared_ptr store = RdbHelper::GetRdbStore(config, 1, helper, errCode); - EXPECT_NE(store, nullptr); - EXPECT_EQ(errCode, E_OK); - - int64_t id; - ValuesBucket values; - values.PutInt("id", 1); - values.PutNull("name"); - values.PutInt("age", 18); - values.PutDouble("salary", 100.5); - values.PutBlob("blobType", std::vector{ 1, 2, 3 }); - int ret = store->Insert(id, "test", values); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - std::unique_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - int columnIndex; - std::string strVal; - - ret = resultSet->GoToFirstRow(); - EXPECT_EQ(ret, E_OK); - - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - - resultSet->Close(); - resultSet = nullptr; - store = nullptr; - ret = RdbHelper::DeleteRdbStore(dbPath); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: ValuesBucket_003 - * @tc.desc: test ValuesBucket - * @tc.type: FUNC - * @tc.author: - */ -HWTEST_F(RdbTest, ValuesBucket_003, TestSize.Level1) -{ - ValuesBucket values; - values.PutBool("boolType", true); - values.PutLong("longType", 1); - - int size = values.Size(); - EXPECT_EQ(size, 2); - bool contains = values.HasColumn("boolType"); - EXPECT_EQ(contains, true); - ValueObject obj; - contains = values.GetObject("boolType", obj); - ValueObjectType type = obj.GetType(); - EXPECT_EQ(type, ValueObjectType::TYPE_BOOL); - bool val1 = false; - int ret = obj.GetBool(val1); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(val1, true); - - contains = values.HasColumn("longType"); - EXPECT_EQ(contains, true); - contains = values.GetObject("longType", obj); - type = obj.GetType(); - EXPECT_EQ(type, ValueObjectType::TYPE_INT64); - int64_t val2 = 0; - ret = obj.GetLong(val2); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(val2, 1); -} - -/** - * @tc.name: RdbStore_UpdateWithConflictResolution_001 - * @tc.desc: test RdbStore UpdateWithConflictResolution - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, RdbStore_UpdateWithConflictResolution_001, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - ValuesBucket values; - int changedRows; - int64_t id; - - int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - // update lisi age=19 to wangjing age=20 - values.PutInt("id", 3); - values.PutString("name", std::string("wangjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = 19"); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, changedRows); - - std::shared_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector{ 1, 2, 3 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector{ 7, 8, 9 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ROW_OUT_RANGE); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_UpdateWithConflictResolution_002 - * @tc.desc: test RdbStore UpdateWithConflictResolution - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, RdbStore_UpdateWithConflictResolution_002, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - ValuesBucket values; - int changedRows; - int64_t id; - - int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - // update lisi age=19 to zhangsan age=20 - values.PutInt("id", 3); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector{ "19" }, - ConflictResolution::ON_CONFLICT_NONE); - EXPECT_EQ(ret, E_SQLITE_CONSTRAINT); - - std::shared_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector{ 1, 2, 3 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector{ 4, 5, 6 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ROW_OUT_RANGE); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_UpdateWithConflictResolution_003 - * @tc.desc: test RdbStore UpdateWithConflictResolution - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, RdbStore_UpdateWithConflictResolution_003, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - ValuesBucket values; - int changedRows; - int64_t id; - - int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - // update lisi age=19 to wangjing age=20 - values.PutInt("id", 3); - values.PutString("name", std::string("wangjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector{ "19" }, - ConflictResolution::ON_CONFLICT_ROLLBACK); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, changedRows); - - std::shared_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector{ 1, 2, 3 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector{ 7, 8, 9 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ROW_OUT_RANGE); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_UpdateWithConflictResolution_004 - * @tc.desc: test RdbStore UpdateWithConflictResolution - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, RdbStore_UpdateWithConflictResolution_004, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - ValuesBucket values; - int changedRows; - int64_t id; - - int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - // update lisi age=19 to zhangsan age=20 - values.PutInt("id", 3); - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector{ "19" }, - ConflictResolution::ON_CONFLICT_ROLLBACK); - EXPECT_EQ(ret, E_SQLITE_CONSTRAINT); - - std::shared_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector{ 1, 2, 3 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector{ 4, 5, 6 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ROW_OUT_RANGE); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_UpdateWithConflictResolution_005 - * @tc.desc: test RdbStore UpdateWithConflictResolution - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, RdbStore_UpdateWithConflictResolution_005, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - ValuesBucket values; - int changedRows; - int64_t id; - - int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - // update lisi age=19 to wangjing age=20 - values.PutInt("id", 3); - values.PutString("name", std::string("wangjing")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - values.PutBlob("blobType", std::vector{ 7, 8, 9 }); - ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector{ "19" }, - ConflictResolution::ON_CONFLICT_REPLACE); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, changedRows); - - std::shared_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector{ 1, 2, 3 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - RdbTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector{ 7, 8, 9 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ROW_OUT_RANGE); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_UpdateWithConflictResolution_006 - * @tc.desc: test RdbStore UpdateWithConflictResolution - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, RdbStore_UpdateWithConflictResolution_006, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - ValuesBucket values; - int changedRows; - int64_t id; - - int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[1])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(2, id); - - // update lisi age=19 to zhangsan age=20 - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector{ "19" }, - ConflictResolution::ON_CONFLICT_REPLACE); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(changedRows, 1); - - std::shared_ptr resultSet = store->QuerySql("SELECT * FROM test"); - EXPECT_NE(resultSet, nullptr); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_OK); - - RdbTest::ExpectValue(resultSet, RowData{ 2, "zhangsan", 20, 300.5, std::vector{ 4, 5, 6 } }); - - ret = resultSet->GoToNextRow(); - EXPECT_EQ(ret, E_ROW_OUT_RANGE); - - ret = resultSet->Close(); - EXPECT_EQ(ret, E_OK); -} - -/** - * @tc.name: RdbStore_UpdateWithConflictResolution_007 - * @tc.desc: test RdbStore UpdateWithConflictResolution - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, RdbStore_UpdateWithConflictResolution_007, TestSize.Level1) -{ - std::shared_ptr &store = RdbTest::store; - - int changedRows; - int64_t id; - ValuesBucket values; - - int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0])); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(1, id); - - values.PutInt("id", 2); - values.PutInt("age", 19); - ret = store->UpdateWithConflictResolution( - changedRows, "test", values, "age = ?", std::vector{ "18" }, static_cast(6)); - EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret); - EXPECT_EQ(0, changedRows); - - values.Clear(); - values.PutInt("id", 2); - values.PutInt("age", 19); - ret = store->UpdateWithConflictResolution( - changedRows, "test", values, "age = ?", std::vector{ "18" }, static_cast(-1)); - EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret); - EXPECT_EQ(0, changedRows); -} - -/** - * @tc.name: RdbStore_UpdateSqlBuilder_001 - * @tc.desc: test RdbStore UpdateSqlBuilder - * @tc.type: FUNC - */ -HWTEST_F(RdbTest, RdbStore_UpdateSqlBuilder_001, TestSize.Level1) -{ - ValuesBucket values; - values.PutString("name", std::string("zhangsan")); - values.PutInt("age", 20); - values.PutDouble("salary", 300.5); - - std::vector bindArgs; - std::string updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector{ "19" }, "", - "age = ?", "", "", INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE); - EXPECT_EQ(updateSql, "UPDATE test SET age=?,name=?,salary=? WHERE age = ?"); - - updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector{}, "", "", "", "", - INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE); - EXPECT_EQ(updateSql, "UPDATE test SET age=?,name=?,salary=?"); -} - -void RdbTest::ExpectValue(const std::shared_ptr &resultSet, const RowData &expect) -{ - EXPECT_NE(nullptr, resultSet); - int columnIndex; - int intVal; - int ret; - - if (expect.id != -1) { - ret = resultSet->GetColumnIndex("id", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(expect.id, intVal); - } - if (expect.name != "") { - std::string strVal; - ret = resultSet->GetColumnIndex("name", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetString(columnIndex, strVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(expect.name, strVal); - } - if (expect.age != -1) { - ret = resultSet->GetColumnIndex("age", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetInt(columnIndex, intVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(expect.age, intVal); - } - if (expect.salary != -1) { - double dVal; - ret = resultSet->GetColumnIndex("salary", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetDouble(columnIndex, dVal); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(expect.salary, dVal); - } - if (expect.blobType.size() != 0) { - std::vector blob; - ret = resultSet->GetColumnIndex("blobType", columnIndex); - EXPECT_EQ(ret, E_OK); - ret = resultSet->GetBlob(columnIndex, blob); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(expect.blobType.size(), static_cast(blob.size())); - for (int i = 0; i < expect.blobType.size(); i++) { - EXPECT_EQ(expect.blobType[i], blob[i]); - } - } -} -- Gitee