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 #include <sys/stat.h>
20 #include <sys/types.h>
21 #include "common.h"
22 #include "relational_store.h"
23 #include "relational_store_error_code.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::NativeRdb;
27
28 class RdbNativeCursorTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
InitRdbConfig()34 static void InitRdbConfig()
35 {
36 config_.dataBaseDir = RDB_TEST_PATH;
37 config_.storeName = "rdb_cursor_test.db";
38 config_.bundleName = "";
39 config_.moduleName = "";
40 config_.securityLevel = OH_Rdb_SecurityLevel::S1;
41 config_.isEncrypt = false;
42 config_.selfSize = sizeof(OH_Rdb_Config);
43 }
44 static OH_Rdb_Config config_;
45 };
46
47 OH_Rdb_Store *cursorTestRdbStore_;
48 OH_Rdb_Config RdbNativeCursorTest::config_ = {0};
SetUpTestCase(void)49 void RdbNativeCursorTest::SetUpTestCase(void)
50 {
51 InitRdbConfig();
52 mkdir(config_.dataBaseDir, 0770);
53 int errCode = 0;
54 char table[] = "test";
55 cursorTestRdbStore_ = OH_Rdb_GetOrOpen(&config_, &errCode);
56 EXPECT_NE(cursorTestRdbStore_, NULL);
57 char createTableSql[] = "CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
58 "data3 FLOAT, data4 BLOB, data5 TEXT);";
59 errCode = OH_Rdb_Execute(cursorTestRdbStore_, createTableSql);
60
61 OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
62 valueBucket->putInt64(valueBucket, "id", 1);
63 valueBucket->putText(valueBucket, "data1", "zhangSan");
64 valueBucket->putInt64(valueBucket, "data2", 12800);
65 valueBucket->putReal(valueBucket, "data3", 100.1);
66 uint8_t arr[] = {1, 2, 3, 4, 5};
67 int len = sizeof(arr) / sizeof(arr[0]);
68 valueBucket->putBlob(valueBucket, "data4", arr, len);
69 valueBucket->putText(valueBucket, "data5", "ABCDEFG");
70 errCode = OH_Rdb_Insert(cursorTestRdbStore_, table, valueBucket);
71 EXPECT_EQ(errCode, 1);
72
73 valueBucket->clear(valueBucket);
74 valueBucket->putInt64(valueBucket, "id", 2);
75 valueBucket->putText(valueBucket, "data1", "liSi");
76 valueBucket->putInt64(valueBucket, "data2", 13800);
77 valueBucket->putReal(valueBucket, "data3", 200.1);
78 valueBucket->putText(valueBucket, "data5", "ABCDEFGH");
79 errCode = OH_Rdb_Insert(cursorTestRdbStore_, table, valueBucket);
80 EXPECT_EQ(errCode, 2);
81
82 valueBucket->clear(valueBucket);
83 valueBucket->putInt64(valueBucket, "id", 3);
84 valueBucket->putText(valueBucket, "data1", "wangWu");
85 valueBucket->putInt64(valueBucket, "data2", 14800);
86 valueBucket->putReal(valueBucket, "data3", 300.1);
87 valueBucket->putText(valueBucket, "data5", "ABCDEFGHI");
88 errCode = OH_Rdb_Insert(cursorTestRdbStore_, table, valueBucket);
89 EXPECT_EQ(errCode, 3);
90
91 valueBucket->destroy(valueBucket);
92 }
93
TearDownTestCase(void)94 void RdbNativeCursorTest::TearDownTestCase(void)
95 {
96 delete cursorTestRdbStore_;
97 cursorTestRdbStore_ = NULL;
98 OH_Rdb_DeleteStore(&config_);
99 }
100
SetUp(void)101 void RdbNativeCursorTest::SetUp(void)
102 {
103 }
104
TearDown(void)105 void RdbNativeCursorTest::TearDown(void)
106 {
107 }
108
109 /**
110 * @tc.name: RDB_Native_cursor_test_001
111 * @tc.desc: Normal testCase of cursor for GetColumnType.
112 * @tc.type: FUNC
113 */
114 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_001, TestSize.Level1)
115 {
116 int errCode = 0;
117 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
118
119 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
120 EXPECT_NE(cursor, NULL);
121 cursor->goToNextRow(cursor);
122
123 OH_ColumnType type;
124 errCode = cursor->getColumnType(cursor, 0, &type);
125 EXPECT_EQ(type, OH_ColumnType::TYPE_INT64);
126
127 errCode = cursor->getColumnType(cursor, 1, &type);
128 EXPECT_EQ(type, OH_ColumnType::TYPE_TEXT);
129
130 errCode = cursor->getColumnType(cursor, 2, &type);
131 EXPECT_EQ(type, OH_ColumnType::TYPE_INT64);
132
133 errCode = cursor->getColumnType(cursor, 3, &type);
134 EXPECT_EQ(type, OH_ColumnType::TYPE_REAL);
135
136 errCode = cursor->getColumnType(cursor, 4, &type);
137 EXPECT_EQ(type, OH_ColumnType::TYPE_BLOB);
138
139 errCode = cursor->getColumnType(cursor, 5, &type);
140 EXPECT_EQ(type, OH_ColumnType::TYPE_TEXT);
141
142 errCode = cursor->getColumnType(nullptr, 5, &type);
143 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
144 errCode = cursor->getColumnType(cursor, -1, &type);
145 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
146 errCode = cursor->getColumnType(cursor, 5, nullptr);
147 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
148
149 predicates->destroy(predicates);
150 cursor->destroy(cursor);
151 }
152
153 /**
154 * @tc.name: RDB_Native_cursor_test_002
155 * @tc.desc: Normal testCase of cursor for GetColumnIndex.
156 * @tc.type: FUNC
157 */
158 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_002, TestSize.Level1)
159 {
160 int errCode = 0;
161 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
162
163 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
164 EXPECT_NE(cursor, NULL);
165
166 int columnIndex;
167 errCode = cursor->getColumnIndex(cursor, "data1", &columnIndex);
168 EXPECT_EQ(columnIndex, 1);
169
170 errCode = cursor->getColumnIndex(cursor, "data2", &columnIndex);
171 EXPECT_EQ(columnIndex, 2);
172
173 errCode = cursor->getColumnIndex(cursor, "data3", &columnIndex);
174 EXPECT_EQ(columnIndex, 3);
175
176 errCode = cursor->getColumnIndex(cursor, "data4", &columnIndex);
177 EXPECT_EQ(columnIndex, 4);
178
179 errCode = cursor->getColumnIndex(cursor, "data5", &columnIndex);
180 EXPECT_EQ(columnIndex, 5);
181
182 errCode = cursor->getColumnIndex(nullptr, "data5", &columnIndex);
183 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
184 errCode = cursor->getColumnIndex(cursor, nullptr, &columnIndex);
185 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
186 errCode = cursor->getColumnIndex(cursor, "data5", nullptr);
187 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
188
189 predicates->destroy(predicates);
190 cursor->destroy(cursor);
191 }
192
193 /**
194 * @tc.name: RDB_Native_cursor_test_003
195 * @tc.desc: Normal testCase of cursor for GetColumnName.
196 * @tc.type: FUNC
197 */
198 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_003, TestSize.Level1)
199 {
200 int errCode = 0;
201 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
202
203 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, NULL, 0);
204 EXPECT_NE(cursor, NULL);
205
206 char name[10];
207 errCode = cursor->getColumnName(cursor, 1, name, 10);
208 EXPECT_EQ(strcmp(name, "data1"), 0);
209
210 errCode = cursor->getColumnName(cursor, 2, name, 6);
211 EXPECT_EQ(strcmp(name, "data2"), 0);
212
213 errCode = cursor->getColumnName(cursor, 3, name, 6);
214 EXPECT_EQ(strcmp(name, "data3"), 0);
215
216 errCode = cursor->getColumnName(cursor, 4, name, 6);
217 EXPECT_EQ(strcmp(name, "data4"), 0);
218
219 errCode = cursor->getColumnName(cursor, 5, name, 6);
220 EXPECT_EQ(strcmp(name, "data5"), 0);
221
222 errCode = cursor->getColumnName(nullptr, 5, name, 6);
223 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
224 errCode = cursor->getColumnName(cursor, 5, nullptr, 6);
225 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
226 errCode = cursor->getColumnName(cursor, 5, name, 0);
227 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
228
229 predicates->destroy(predicates);
230 cursor->destroy(cursor);
231 }
232
233 /**
234 * @tc.name: RDB_Native_cursor_test_004
235 * @tc.desc: Normal testCase of cursor for Getxxx.
236 * @tc.type: FUNC
237 */
238 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_004, TestSize.Level1)
239 {
240 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
241
242 const char *columnNames[] = {"data1", "data2", "data3", "data4"};
243 int len = sizeof(columnNames) / sizeof(columnNames[0]);
244 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, columnNames, len);
245 EXPECT_NE(cursor, NULL);
246
247 int rowCount = 0;
248 cursor->getRowCount(cursor, &rowCount);
249 EXPECT_EQ(rowCount, 3);
250
251 cursor->goToNextRow(cursor);
252
253 int columnCount = 0;
254 cursor->getColumnCount(cursor, &columnCount);
255 EXPECT_EQ(columnCount, 4);
256
257 size_t size = 0;
258 cursor->getSize(cursor, 0, &size);
259 char data1Value[size + 1];
260 cursor->getText(cursor, 0, data1Value, size + 1);
261 EXPECT_EQ(strcmp(data1Value, "zhangSan"), 0);
262
263 int64_t data2Value;
264 cursor->getInt64(cursor, 1, &data2Value);
265 EXPECT_EQ(data2Value, 12800);
266
267 double data3Value;
268 cursor->getReal(cursor, 2, &data3Value);
269 EXPECT_EQ(data3Value, 100.1);
270
271 cursor->getSize(cursor, 3, &size);
272 unsigned char data4Value[size];
273 cursor->getBlob(cursor, 3, data4Value, size);
274 EXPECT_EQ(data4Value[0], 1);
275 EXPECT_EQ(data4Value[1], 2);
276
277 cursor->goToNextRow(cursor);
278
279 cursor->getSize(cursor, 0, &size);
280 char data1Value_1[size + 1];
281 cursor->getText(cursor, 0, data1Value_1, size + 1);
282 EXPECT_EQ(strcmp(data1Value_1, "liSi"), 0);
283
284 cursor->getInt64(cursor, 1, &data2Value);
285 EXPECT_EQ(data2Value, 13800);
286
287 cursor->getReal(cursor, 2, &data3Value);
288 EXPECT_EQ(data3Value, 200.1);
289
290 bool isNull = false;
291 cursor->isNull(cursor, 3, &isNull);
292 EXPECT_EQ(isNull, true);
293
294 predicates->destroy(predicates);
295 cursor->destroy(cursor);
296 }
297
298 /**
299 * @tc.name: RDB_Native_cursor_test_005
300 * @tc.desc: Normal testCase of cursor for anomalous branch.
301 * @tc.type: FUNC
302 */
303 HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_005, TestSize.Level1)
304 {
305 OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
306
307 const char *columnNames[] = {"data1", "data2", "data3", "data4"};
308 int len = sizeof(columnNames) / sizeof(columnNames[0]);
309 OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, columnNames, len);
310 EXPECT_NE(cursor, NULL);
311
312 int rowCount = 0;
313 int errCode = cursor->getRowCount(nullptr, &rowCount);
314 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
315 errCode = cursor->getRowCount(cursor, nullptr);
316 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
317
318 int columnCount = 0;
319 errCode = cursor->getColumnCount(nullptr, &columnCount);
320 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
321 errCode = cursor->getColumnCount(cursor, nullptr);
322 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
323
324 errCode = cursor->goToNextRow(nullptr);
325 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
326
327 size_t size = 0;
328 errCode = cursor->getSize(nullptr, 0, &size);
329 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
330 errCode = cursor->getSize(cursor, 0, nullptr);
331 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
332
333 char data1Value[size + 1];
334 errCode = cursor->getText(nullptr, 0, data1Value, size + 1);
335 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
336 errCode = cursor->getText(cursor, 0, nullptr, size + 1);
337 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
338 errCode = cursor->getText(cursor, 0, data1Value, 0);
339 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
340
341 int64_t data2Value;
342 errCode = cursor->getInt64(nullptr, 1, &data2Value);
343 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
344 errCode = cursor->getInt64(cursor, 1, nullptr);
345 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
346
347 double data3Value;
348 errCode = cursor->getReal(nullptr, 2, &data3Value);
349 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
350 errCode = cursor->getReal(cursor, 2, nullptr);
351 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
352
353 unsigned char data4Value[size];
354 errCode = cursor->getBlob(nullptr, 3, data4Value, size);
355 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
356 errCode = cursor->getBlob(cursor, 3, nullptr, size);
357 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
358 errCode = cursor->getBlob(cursor, 3, data4Value, 0);
359 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
360
361 bool isNull = false;
362 errCode = cursor->isNull(nullptr, 3, &isNull);
363 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
364 errCode = cursor->isNull(cursor, 3, nullptr);
365 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
366
367 errCode = cursor->destroy(nullptr);
368 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
369
370 predicates->destroy(predicates);
371 cursor->destroy(cursor);
372 }