1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include <string>
19 
20 #include "common.h"
21 #include "rdb_errno.h"
22 #include "rdb_helper.h"
23 #include "rdb_open_callback.h"
24 
25 using namespace testing::ext;
26 using namespace OHOS::NativeRdb;
27 
28 class RdbStepResultSetGetRowTest : public testing::Test {
29 public:
30     static void SetUpTestCase(void);
31     static void TearDownTestCase(void);
32     void SetUp();
33     void TearDown();
34 
35     static const std::string DATABASE_NAME;
36     static std::shared_ptr<RdbStore> store;
37 };
38 
39 const std::string RdbStepResultSetGetRowTest::DATABASE_NAME = RDB_TEST_PATH + "stepResultSet_getRow_test.db";
40 std::shared_ptr<RdbStore> RdbStepResultSetGetRowTest::store = nullptr;
41 
42 class RdbStepResultSetGetOpenCallback : public RdbOpenCallback {
43 public:
44     int OnCreate(RdbStore &store) override;
45     int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
46 };
47 
OnCreate(RdbStore & store)48 int RdbStepResultSetGetOpenCallback::OnCreate(RdbStore &store)
49 {
50     return E_OK;
51 }
52 
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)53 int RdbStepResultSetGetOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
54 {
55     return E_OK;
56 }
57 
SetUpTestCase(void)58 void RdbStepResultSetGetRowTest::SetUpTestCase(void)
59 {
60     int errCode = E_OK;
61     RdbHelper::DeleteRdbStore(DATABASE_NAME);
62     RdbStoreConfig config(RdbStepResultSetGetRowTest::DATABASE_NAME);
63     RdbStepResultSetGetOpenCallback helper;
64     RdbStepResultSetGetRowTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
65     EXPECT_NE(RdbStepResultSetGetRowTest::store, nullptr);
66     EXPECT_EQ(errCode, E_OK);
67 }
68 
TearDownTestCase(void)69 void RdbStepResultSetGetRowTest::TearDownTestCase(void)
70 {
71     RdbHelper::ClearCache();
72     RdbHelper::DeleteRdbStore(RdbStepResultSetGetRowTest::DATABASE_NAME);
73 }
74 
SetUp(void)75 void RdbStepResultSetGetRowTest::SetUp(void)
76 {
77     store->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, "
78                       "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
79 }
80 
TearDown(void)81 void RdbStepResultSetGetRowTest::TearDown(void)
82 {
83     store->ExecuteSql("DROP TABLE IF EXISTS test");
84 }
85 
86 /* *
87  * @tc.name: RdbStore_StepResultSet_GetRow_001
88  * @tc.desc: test StepResultSet GetRow
89  * @tc.type: FUNC
90  * @tc.require: AR000FKD4F
91  */
92 HWTEST_F(RdbStepResultSetGetRowTest, RdbStore_StepResultSet_GetRow_001, TestSize.Level1)
93 {
94     int64_t rowId;
95     ValuesBucket valuesBucket;
96     valuesBucket.PutInt("id", ValueObject(1));
97     int errorCode = RdbStepResultSetGetRowTest::store->Insert(rowId, "test", valuesBucket);
98     EXPECT_EQ(E_OK, errorCode);
99     EXPECT_EQ(1, rowId);
100 
101     std::shared_ptr<ResultSet> resultSet = RdbStepResultSetGetRowTest::store->QueryByStep("SELECT * FROM test");
102     EXPECT_NE(resultSet, nullptr);
103 
104     EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
105 
106     int iRet = E_ERROR;
107     RowEntity rowEntity;
108     iRet = resultSet->GetRow(rowEntity);
109     EXPECT_EQ(E_OK, iRet);
110 
111     int idValue = rowEntity.Get("id");
112     EXPECT_EQ(1, idValue);
113 
114     int idValueByIndex = rowEntity.Get(0);
115     EXPECT_EQ(1, idValueByIndex);
116 
117     std::map<std::string, ValueObject> rowEntityTmp = rowEntity.Get();
118     ValueObject valueObjectTmp = rowEntityTmp["id"];
119     int id;
120     valueObjectTmp.GetInt(id);
121     EXPECT_EQ(1, id);
122 
123     std::map<std::string, ValueObject> rowEntityTmp2 = rowEntity.Steal();
124     ValueObject valueObjectTmp2 = rowEntityTmp2["id"];
125     id = 0;
126     valueObjectTmp2.GetInt(id);
127     EXPECT_EQ(1, id);
128     rowEntityTmp = rowEntity.Get();
129     EXPECT_EQ(0, rowEntityTmp.size());
130 
131     resultSet->Close();
132 }
133 
134 /* *
135  * @tc.name: RdbStore_StepResultSet_GetRow_002
136  * @tc.desc: test StepResultSet GetRow
137  * @tc.type: FUNC
138  * @tc.require: AR000FKD4F
139  */
140 HWTEST_F(RdbStepResultSetGetRowTest, RdbStore_StepResultSet_GetRow_002, TestSize.Level1)
141 {
142     ValuesBucket valuesBucket;
143     valuesBucket.PutNull("data1");
144     valuesBucket.PutNull("data2");
145     valuesBucket.PutNull("data3");
146     valuesBucket.PutNull("data4");
147     valuesBucket.PutNull("data5");
148     int64_t rowId;
149     int errorCode = RdbStepResultSetGetRowTest::store->Insert(rowId, "test", valuesBucket);
150     EXPECT_EQ(E_OK, errorCode);
151     EXPECT_EQ(1, rowId);
152 
153     std::shared_ptr<ResultSet> resultSet = RdbStepResultSetGetRowTest::store->QueryByStep("SELECT * FROM test");
154     EXPECT_NE(resultSet, nullptr);
155 
156     EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
157 
158     int iRet = E_ERROR;
159     RowEntity rowEntity;
160     iRet = resultSet->GetRow(rowEntity);
161     EXPECT_EQ(E_OK, iRet);
162 
163     int idValue = rowEntity.Get("id");
164     EXPECT_EQ(1, idValue);
165 
166     int idValueByIndex = rowEntity.Get(0);
167     EXPECT_EQ(1, idValueByIndex);
168 
169     resultSet->Close();
170 }
171 
172 /* *
173  * @tc.name: RdbStore_StepResultSet_GetRow_003
174  * @tc.desc: test StepResultSet GetRow
175  * @tc.type: FUNC
176  * @tc.require: AR000FKD4F
177  */
178 HWTEST_F(RdbStepResultSetGetRowTest, RdbStore_StepResultSet_GetRow_003, TestSize.Level1)
179 {
180     ValuesBucket valuesBucket;
181     valuesBucket.PutString("data1", "olleh");
182     valuesBucket.PutInt("data2", 20);
183     valuesBucket.PutDouble("data3", 2.0);
184     valuesBucket.PutBlob("data4", { 4, 3, 2, 1 });
185     valuesBucket.PutBool("data5", true);
186     int64_t rowId;
187     int errorCode = RdbStepResultSetGetRowTest::store->Insert(rowId, "test", valuesBucket);
188     EXPECT_EQ(E_OK, errorCode);
189     EXPECT_EQ(1, rowId);
190 
191     std::shared_ptr<ResultSet> resultSet = RdbStepResultSetGetRowTest::store->QueryByStep("SELECT * FROM test");
192     EXPECT_NE(resultSet, nullptr);
193 
194     EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
195 
196     int iRet = E_ERROR;
197     RowEntity rowEntity;
198     iRet = resultSet->GetRow(rowEntity);
199     EXPECT_EQ(E_OK, iRet);
200 
201     int idValue = rowEntity.Get("id");
202     std::string data1Value = rowEntity.Get("data1");
203     int data2Value = rowEntity.Get("data2");
204     double data3Value = rowEntity.Get("data3");
205     std::vector<uint8_t> data4Value = rowEntity.Get("data4");
206     int data5Value = rowEntity.Get("data5");
207     EXPECT_EQ(1, idValue);
208     EXPECT_EQ("olleh", data1Value);
209     EXPECT_EQ(20, data2Value);
210     EXPECT_EQ(2.0, data3Value);
211     EXPECT_EQ(1, data4Value[3]);
212     EXPECT_EQ(1, data5Value);
213 
214     int idValueByIndex = rowEntity.Get(0);
215     std::string data1ValueByIndex = rowEntity.Get(1);
216     int data2ValueByIndex = rowEntity.Get(2);
217     double data3ValueByIndex = rowEntity.Get(3);
218     std::vector<uint8_t> data4ValueByIndex = rowEntity.Get(4);
219     int data5ValueByIndex = rowEntity.Get(5);
220     EXPECT_EQ(1, idValueByIndex);
221     EXPECT_EQ("olleh", data1ValueByIndex);
222     EXPECT_EQ(20, data2ValueByIndex);
223     EXPECT_EQ(2.0, data3ValueByIndex);
224     EXPECT_EQ(1, data4ValueByIndex[3]);
225     EXPECT_EQ(1, data5ValueByIndex);
226 
227     resultSet->Close();
228 }
229 
230 /* *
231  * @tc.name: RdbStore_StepResultSet_GetRow_004
232  * @tc.desc: test StepResultSet GetRow
233  * @tc.type: FUNC
234  * @tc.require: AR000FKD4F
235  */
236 HWTEST_F(RdbStepResultSetGetRowTest, RdbStore_StepResultSet_GetRow_004, TestSize.Level1)
237 {
238     ValuesBucket valuesBucket;
239     valuesBucket.PutString("data1", "");
240     valuesBucket.PutInt("data2", 10);
241     valuesBucket.PutDouble("data3", 1.0);
242     valuesBucket.PutBlob("data4", { 1, 2, 3, 4 });
243     valuesBucket.PutBool("data5", true);
244     int64_t rowId;
245     int errorCode = RdbStepResultSetGetRowTest::store->Insert(rowId, "test", valuesBucket);
246     EXPECT_EQ(E_OK, errorCode);
247     EXPECT_EQ(1, rowId);
248 
249     std::shared_ptr<ResultSet> resultSet =
250         RdbStepResultSetGetRowTest::store->QueryByStep("SELECT data1, data2 FROM test");
251     EXPECT_NE(resultSet, nullptr);
252 
253     EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
254 
255     int iRet = E_ERROR;
256     RowEntity rowEntity;
257     iRet = resultSet->GetRow(rowEntity);
258     EXPECT_EQ(E_OK, iRet);
259 
260     std::string data1Value = rowEntity.Get("data1");
261     EXPECT_EQ("", data1Value);
262 
263     std::string data1ValueByIndex = rowEntity.Get(0);
264     EXPECT_EQ("", data1ValueByIndex);
265 
266     resultSet->Close();
267 }
268 
269 /* *
270  * @tc.name: RdbStore_StepResultSet_GetRow_005
271  * @tc.desc: Abnormal testCase of GetRow for rowEntity, if params of Get() is invalid
272  * @tc.type: FUNC
273  */
274 HWTEST_F(RdbStepResultSetGetRowTest, RdbStore_StepResultSet_GetRow_005, TestSize.Level2)
275 {
276     ValuesBucket valuesBucket;
277     valuesBucket.PutString("data1", "keep");
278     valuesBucket.PutInt("data2", 10);
279 
280     int64_t rowId;
281     EXPECT_EQ(E_OK, RdbStepResultSetGetRowTest::store->Insert(rowId, "test", valuesBucket));
282     EXPECT_EQ(1, rowId);
283 
284     std::shared_ptr<ResultSet> resultSet =
285         RdbStepResultSetGetRowTest::store->QueryByStep("SELECT data1, data2 FROM test");
286     EXPECT_NE(nullptr, resultSet);
287 
288     EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
289 
290     RowEntity rowEntity;
291     EXPECT_EQ(E_OK, resultSet->GetRow(rowEntity));
292 
293     EXPECT_EQ(ValueObjectType::TYPE_NULL, rowEntity.Get("data3").GetType());
294     EXPECT_EQ(ValueObjectType::TYPE_NULL, rowEntity.Get(-1).GetType());
295     EXPECT_EQ(ValueObjectType::TYPE_NULL, rowEntity.Get(2).GetType());
296 
297     resultSet->Close();
298 }
299 
300 /* *
301  * @tc.name: RdbStore_StepResultSet_GetRow_006
302  * @tc.desc: Abnormal testCase of GetRow for rowEntity, if close resultSet before GetRow
303  * @tc.type: FUNC
304  */
305 HWTEST_F(RdbStepResultSetGetRowTest, RdbStore_StepResultSet_GetRow_006, TestSize.Level2)
306 {
307     ValuesBucket valuesBucket;
308     valuesBucket.PutString("data1", "keep");
309     valuesBucket.PutInt("data2", 10);
310 
311     int64_t rowId;
312     EXPECT_EQ(E_OK, RdbStepResultSetGetRowTest::store->Insert(rowId, "test", valuesBucket));
313     EXPECT_EQ(1, rowId);
314 
315     std::shared_ptr<ResultSet> resultSet =
316         RdbStepResultSetGetRowTest::store->QueryByStep("SELECT data1, data2 FROM test");
317     EXPECT_NE(nullptr, resultSet);
318 
319     EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
320 
321     EXPECT_EQ(E_OK, resultSet->Close());
322 
323     RowEntity rowEntity;
324     EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GetRow(rowEntity));
325 }
326