1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <gtest/gtest.h>
16 #include <sys/stat.h>
17 #include <sys/types.h>
18
19 #include <string>
20
21 #include "accesstoken_kit.h"
22 #include "common.h"
23 #include "grd_api_manager.h"
24 #include "oh_data_utils.h"
25 #include "rdb_errno.h"
26 #include "rdb_helper.h"
27 #include "rdb_ndk_utils.h"
28 #include "relational_store.h"
29 #include "relational_store_error_code.h"
30 #include "relational_store_impl.h"
31 #include "relational_store_inner_types.h"
32 #include "token_setproc.h"
33
34 using namespace testing::ext;
35 using namespace OHOS::NativeRdb;
36 using namespace OHOS::Security::AccessToken;
37 using namespace OHOS::RdbNdk;
38
39 class RdbNativeStoreConfigV2Test : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
InitRdbConfig()45 static OH_Rdb_ConfigV2 *InitRdbConfig()
46 {
47 OH_Rdb_ConfigV2 *config = OH_Rdb_CreateConfig();
48 EXPECT_NE(config, nullptr);
49 OH_Rdb_SetDatabaseDir(config, RDB_TEST_PATH);
50 OH_Rdb_SetStoreName(config, "rdb_store_test.db");
51 OH_Rdb_SetBundleName(config, "com.ohos.example.distributedndk");
52 OH_Rdb_SetEncrypted(config, false);
53 OH_Rdb_SetSecurityLevel(config, OH_Rdb_SecurityLevel::S1);
54 OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL1);
55
56 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetDbType(config, RDB_SQLITE));
57 return config;
58 }
59 };
60
SetUpTestCase(void)61 void RdbNativeStoreConfigV2Test::SetUpTestCase(void)
62 {
63 }
64
TearDownTestCase(void)65 void RdbNativeStoreConfigV2Test::TearDownTestCase(void)
66 {
67 }
68
SetUp(void)69 void RdbNativeStoreConfigV2Test::SetUp(void)
70 {
71 }
72
TearDown(void)73 void RdbNativeStoreConfigV2Test::TearDown(void)
74 {
75 }
76
77 /**
78 * @tc.name: RDB_Native_store_test_001
79 * @tc.desc: Normal testCase of store for Update、Query.
80 * @tc.type: FUNC
81 */
82 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_001, TestSize.Level1)
83 {
84 mkdir(RDB_TEST_PATH, 0770);
85 int errCode = 0;
86 auto config = InitRdbConfig();
87 auto storeConfigV2TestRdbStore = OH_Rdb_CreateOrOpen(config, &errCode);
88 EXPECT_NE(storeConfigV2TestRdbStore, NULL);
89 char createTableSql[] = "CREATE TABLE store_test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, data2 INTEGER, "
90 "data3 FLOAT, data4 BLOB, data5 TEXT);";
91 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_Execute(storeConfigV2TestRdbStore, createTableSql));
92 char dropTableSql[] = "DROP TABLE IF EXISTS store_test";
93 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_Execute(storeConfigV2TestRdbStore, dropTableSql));
94
95 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_CloseStore(storeConfigV2TestRdbStore));
96 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_DeleteStoreV2(config));
97 OH_Rdb_DestroyConfig(config);
98 }
99
VdbTest002(const OH_Rdb_ConfigV2 * config)100 void VdbTest002(const OH_Rdb_ConfigV2 *config)
101 {
102 int errCode = OH_Rdb_ErrCode::RDB_OK;
103 auto store = OH_Rdb_CreateOrOpen(config, &errCode);
104 EXPECT_NE(store, nullptr);
105
106 char createTableSql[] = "CREATE TABLE t1(id INT PRIMARY KEY, repr floatvector(4));";
107 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, createTableSql));
108
109 int64_t trxId = 0;
110 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_BeginTransWithTrxId(store, &trxId));
111 char insertSql[] = "INSERT INTO t1 VALUES(2, '[1, 2, 3, 4]');";
112 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, trxId, insertSql));
113 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_CommitByTrxId(store, trxId));
114
115 char querySql[] = "SELECT * FROM t1;";
116 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(store, querySql);
117 EXPECT_NE(cursor, nullptr);
118 int rowCount = 0;
119 cursor->getRowCount(cursor, &rowCount);
120 EXPECT_EQ(1, rowCount);
121 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, cursor->goToNextRow(cursor));
122 int64_t intVal = 0;
123 cursor->getInt64(cursor, 0, &intVal);
124 EXPECT_EQ(2, intVal); // Expect to get 2 as the result
125 cursor->destroy(cursor);
126
127 char dropSql[] = "DROP TABLE IF EXISTS t1;";
128 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, dropSql));
129
130 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_DeleteStoreV2(config));
131 }
132
133 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_002, TestSize.Level1)
134 {
135 auto config = InitRdbConfig();
136 int errCode = OH_Rdb_SetDbType(config, RDB_CAYLEY);
137 EXPECT_TRUE(((!OHOS::NativeRdb::IsUsingArkData()) && errCode == OH_Rdb_ErrCode::RDB_E_NOT_SUPPORTED) ||
138 (OHOS::NativeRdb::IsUsingArkData() && errCode == OH_Rdb_ErrCode::RDB_OK));
139 if (OHOS::NativeRdb::IsUsingArkData()) {
140 VdbTest002(config);
141 }
142 OH_Rdb_DestroyConfig(config);
143 }
144
145 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_003, TestSize.Level1)
146 {
147 int numType = 0;
148 const int *supportTypeList = OH_Rdb_GetSupportedDbType(&numType);
149 EXPECT_NE(supportTypeList, nullptr);
150 EXPECT_TRUE(((!OHOS::NativeRdb::IsUsingArkData()) && numType == 1) || // 1 means only contain RDB_SQLITE
151 ((OHOS::NativeRdb::IsUsingArkData()) && numType == 2)); // 2 means both contain RDB_SQLITE and RDB_CAYLEY
152 EXPECT_EQ(RDB_SQLITE, supportTypeList[0]);
153 if (OHOS::NativeRdb::IsUsingArkData()) {
154 EXPECT_EQ(RDB_CAYLEY, supportTypeList[1]); // 1st element must be RDB_CAYLEY
155 }
156 }
157
158 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_004, TestSize.Level1)
159 {
160 auto config = InitRdbConfig();
161 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetDatabaseDir(config, nullptr));
162 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetStoreName(config, nullptr));
163 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetBundleName(config, nullptr));
164 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetModuleName(config, nullptr));
165
166 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetDatabaseDir(config, ""));
167 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetStoreName(config, ""));
168 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetBundleName(config, ""));
169 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetModuleName(config, ""));
170
171 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetEncrypted(config, false));
172 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetEncrypted(config, true));
173
174 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetSecurityLevel(config, S1));
175 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetSecurityLevel(config, S2));
176 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetSecurityLevel(config, S3));
177 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetSecurityLevel(config, S4));
178 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetSecurityLevel(config, 0)); // 0 is invalid secure level
179 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetSecurityLevel(config, -1)); // -1 is invalid secure level
180 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetSecurityLevel(config, 5)); // 5 is invalid secure level
181
182 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL1));
183 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL2));
184 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL3));
185 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL4));
186 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL5));
187
188 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetArea(config, -1)); // -1 is invalid area level
189 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetArea(config, 0)); // 0 is invalid area level
190 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetArea(config, 8)); // 8 is invalid area level
191
192 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetDbType(config, RDB_SQLITE));
193 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetDbType(config, 0)); // 0 is invalid db type level
194 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetDbType(config, 6)); // 6 is invalid db type level
195 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetDbType(config, -1)); // -1 is invalid db type level
196 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetSemanticIndex(config, true));
197 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetSemanticIndex(config, false));
198
199 const int *supportList = OH_Rdb_GetSupportedDbType(nullptr);
200 EXPECT_EQ(nullptr, supportList);
201
202 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_DestroyConfig(nullptr));
203 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_DestroyConfig(config));
204 }
205
VdbTest003(const OH_Rdb_ConfigV2 * config)206 void VdbTest003(const OH_Rdb_ConfigV2 *config)
207 {
208 int errCode = OH_Rdb_ErrCode::RDB_OK;
209 auto store = OH_Rdb_CreateOrOpen(config, &errCode);
210 EXPECT_NE(store, nullptr);
211
212 char createTableSql[] = "CREATE TABLE t1(id INT PRIMARY KEY, repr floatvector(4));";
213 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, createTableSql));
214
215 char createIndexSql[] = "CREATE INDEX diskann_idx ON t1 USING GSDISKANN(repr L2);";
216 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, createIndexSql));
217
218 int64_t trxId = 0;
219 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_BeginTransWithTrxId(store, &trxId));
220 char insertSql[] = "INSERT INTO t1 VALUES(1, '[1, 2, 3, 4]');";
221 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, trxId, insertSql));
222 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_CommitByTrxId(store, trxId));
223
224 char insertSql2[] = "INSERT INTO t1 VALUES(2, '[2, 2, 3, 4]');";
225 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, insertSql2));
226
227 char deleteSql[] = "DELETE FROM t1 WHERE id = 1;";
228 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, deleteSql));
229
230 char dropSql[] = "DROP TABLE IF EXISTS t1;";
231 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, dropSql));
232
233 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_DeleteStoreV2(config));
234 }
235
236 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_005, TestSize.Level1)
237 {
238 auto config = InitRdbConfig();
239 int errCode = OH_Rdb_SetDbType(config, RDB_CAYLEY);
240 EXPECT_TRUE(((!OHOS::NativeRdb::IsUsingArkData()) && errCode == OH_Rdb_ErrCode::RDB_E_NOT_SUPPORTED) ||
241 (OHOS::NativeRdb::IsUsingArkData() && errCode == OH_Rdb_ErrCode::RDB_OK));
242 if (OHOS::NativeRdb::IsUsingArkData()) {
243 VdbTest003(config);
244 }
245 OH_Rdb_DestroyConfig(config);
246 }
247
GetRandVector(uint32_t maxElementNum,uint16_t dim)248 string GetRandVector(uint32_t maxElementNum, uint16_t dim)
249 {
250 auto now = std::chrono::high_resolution_clock::now();
251 auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
252 unsigned int randomNumberSeed = static_cast<unsigned int>(ns);
253 std::string res = "[";
254 for (uint16_t i = 0; i < dim; i++) {
255 uint32_t intPart = maxElementNum == 0 ? 0 : (rand_r(&randomNumberSeed) % maxElementNum);
256 intPart += 1;
257 // 10 is used to limit the number after the decimal point to a maximum of 10.
258 uint32_t tenths = (rand_r(&randomNumberSeed) % 10);
259 res += std::to_string(intPart);
260 res += ".000";
261 res += std::to_string(tenths);
262 res += ", ";
263 }
264 res.pop_back();
265 res.pop_back();
266 res += "]";
267 return res;
268 }
269
VdbTest004(const OH_Rdb_ConfigV2 * config)270 void VdbTest004(const OH_Rdb_ConfigV2 *config)
271 {
272 int errCode = OH_Rdb_ErrCode::RDB_OK;
273 auto store = OH_Rdb_CreateOrOpen(config, &errCode);
274 EXPECT_NE(store, nullptr);
275
276 char createTableSql[] = "CREATE TABLE t1(id INT PRIMARY KEY, repr floatvector(4));";
277 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, createTableSql));
278
279 char createIndexSql[] = "CREATE INDEX diskann_idx ON t1 USING GSDISKANN(repr L2);";
280 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, createIndexSql));
281
282 uint32_t maxIntPart = 100;
283 uint32_t numSamples = 100;
284 uint32_t dim = 4;
285
286 for (uint16_t i = 0; i < numSamples; i++) {
287 std::string sqlInsert =
288 "INSERT INTO t1 VALUES(" + std::to_string(i) + ", '" + GetRandVector(maxIntPart, dim) + "');";
289 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, sqlInsert.data()));
290 }
291 for (uint16_t i = 0; i < numSamples; i++) {
292 std::string sqlDelete = "DELETE FROM t1 WHERE id = " + std::to_string(i) + ";";
293 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, sqlDelete.data()));
294 }
295
296 char dropSql[] = "DROP TABLE IF EXISTS t1;";
297 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_ExecuteByTrxId(store, 0, dropSql));
298
299 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_DeleteStoreV2(config));
300 }
301
302 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_006, TestSize.Level1)
303 {
304 auto config = InitRdbConfig();
305 int errCode = OH_Rdb_SetDbType(config, RDB_CAYLEY);
306 EXPECT_TRUE(((!OHOS::NativeRdb::IsUsingArkData()) && errCode == OH_Rdb_ErrCode::RDB_E_NOT_SUPPORTED) ||
307 (OHOS::NativeRdb::IsUsingArkData() && errCode == OH_Rdb_ErrCode::RDB_OK));
308 if (OHOS::NativeRdb::IsUsingArkData()) {
309 VdbTest004(config);
310 }
311 OH_Rdb_DestroyConfig(config);
312 }
313
314 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_007, TestSize.Level1)
315 {
316 auto config = InitRdbConfig();
317 int errCode = OH_Rdb_SetPersistent(config, true);
318 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_OK);
319 errCode = OH_Rdb_SetPersistent(config, false);
320 EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_OK);
321 OH_Rdb_DestroyConfig(config);
322 }
323
324 /**
325 * @tc.name: RDB_Native_store_test_008
326 * @tc.desc: invalid args test.
327 * @tc.type: FUNC
328 */
329 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_008, TestSize.Level1)
330 {
331 int errCode = 0;
332 auto config = InitRdbConfig();
333 EXPECT_EQ(OH_Rdb_DeleteStoreV2(nullptr), OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
334 EXPECT_EQ(OH_Rdb_CreateOrOpen(nullptr, &errCode), nullptr);
335 EXPECT_EQ(OH_Rdb_CreateOrOpen(config, nullptr), nullptr);
336
337 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetPersistent(nullptr, true));
338 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetTokenizer(nullptr, Rdb_Tokenizer::RDB_NONE_TOKENIZER));
339
340 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetArea(nullptr, false));
341 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetEncrypted(nullptr, false));
342 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetDbType(nullptr, RDB_SQLITE));
343 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS, OH_Rdb_SetSecurityLevel(nullptr, S1));
344 OH_Rdb_DestroyConfig(config);
345 }
346
347 /**
348 * @tc.name: RDB_ICU_TEST001
349 * @tc.desc: test apis of icu
350 * @tc.type: FUNC
351 */
352 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_ICU_TEST001, TestSize.Level1)
353 {
354 mkdir(RDB_TEST_PATH, 0770);
355 auto config = InitRdbConfig();
356
357 // invalid param test
358 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS,
359 OH_Rdb_SetTokenizer(config, static_cast<Rdb_Tokenizer>(Rdb_Tokenizer::RDB_NONE_TOKENIZER - 1)));
360 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_INVALID_ARGS,
361 OH_Rdb_SetTokenizer(config, static_cast<Rdb_Tokenizer>(Rdb_Tokenizer::RDB_CUSTOM_TOKENIZER + 1)));
362
363 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetTokenizer(config, Rdb_Tokenizer::RDB_NONE_TOKENIZER));
364 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetTokenizer(config, Rdb_Tokenizer::RDB_CUSTOM_TOKENIZER));
365 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetTokenizer(config, Rdb_Tokenizer::RDB_ICU_TOKENIZER));
366
367 int numType = 0;
368 const int *supportTypeList = OH_Rdb_GetSupportedDbType(&numType);
369 EXPECT_NE(supportTypeList, nullptr);
370 if (numType == 2) {
371 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetDbType(config, RDB_CAYLEY));
372 EXPECT_EQ(OH_Rdb_ErrCode::RDB_E_NOT_SUPPORTED,
373 OH_Rdb_SetTokenizer(config, Rdb_Tokenizer::RDB_ICU_TOKENIZER));
374 }
375
376 OH_Rdb_DestroyConfig(config);
377 }
378
379 /**
380 * @tc.name: RDB_ICU_TEST002
381 * @tc.desc: test apis of icu
382 * @tc.type: FUNC
383 */
384 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_ICU_TEST002, TestSize.Level1)
385 {
386 mkdir(RDB_TEST_PATH, 0770);
387 int errCode = 0;
388 auto config = InitRdbConfig();
389
390 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_SetTokenizer(config, Rdb_Tokenizer::RDB_ICU_TOKENIZER));
391 auto storeConfigV2TestRdbStore = OH_Rdb_CreateOrOpen(config, &errCode);
392 EXPECT_NE(storeConfigV2TestRdbStore, NULL);
393
394 char createTableSql[] = "CREATE VIRTUAL TABLE example USING fts4(name, content, tokenize=icu zh_CN);";
395 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_Execute(storeConfigV2TestRdbStore, createTableSql));
396
397 char insertSql1[] =
398 "INSERT INTO example(name, content) VALUES('文档1', '这是一个测试文档，用于测试中文文本的分词和索引。');";
399 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_Execute(storeConfigV2TestRdbStore, insertSql1));
400
401 char insertSql2[] =
402 "INSERT INTO example(name, content) VALUES('文档2', '我们将使用这个示例来演示如何在SQLite中进行全文搜索。');";
403 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_Execute(storeConfigV2TestRdbStore, insertSql2));
404
405 char insertSql3[] =
406 "INSERT INTO example(name, content) VALUES('文档3', 'ICU分词器能够很好地处理中文文本的分词和分析。');";
407 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_Execute(storeConfigV2TestRdbStore, insertSql3));
408
409 char querySql[] = "SELECT * FROM example WHERE example MATCH '测试';";
410 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_Execute(storeConfigV2TestRdbStore, querySql));
411
412 OH_Cursor *cursor = OH_Rdb_ExecuteQuery(storeConfigV2TestRdbStore, querySql);
413 EXPECT_NE(cursor, nullptr);
414 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, cursor->goToNextRow(cursor));
415
416 int columnIndex = -1;
417 errCode = cursor->getColumnIndex(cursor, "name", &columnIndex);
418 EXPECT_EQ(columnIndex, 0);
419 char name[10];
420 errCode = cursor->getColumnName(cursor, columnIndex, name, 10);
421 EXPECT_EQ(strcmp(name, "name"), 0);
422
423 size_t size = 0;
424 cursor->getSize(cursor, columnIndex, &size);
425 char data1Value[size + 1];
426 cursor->getText(cursor, columnIndex, data1Value, size + 1);
427 EXPECT_EQ(strcmp(data1Value, "文档1"), 0);
428
429 errCode = cursor->getColumnIndex(cursor, "content", &columnIndex);
430 char name2[10];
431 errCode = cursor->getColumnName(cursor, columnIndex, name2, 10);
432 EXPECT_EQ(strcmp(name2, "content"), 0);
433
434 cursor->getSize(cursor, columnIndex, &size);
435 char data2Value[size + 1];
436 cursor->getText(cursor, columnIndex, data2Value, size + 1);
437 EXPECT_EQ(strcmp(data2Value, "这是一个测试文档，用于测试中文文本的分词和索引。"), 0);
438
439 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_CloseStore(storeConfigV2TestRdbStore));
440 EXPECT_EQ(OH_Rdb_ErrCode::RDB_OK, OH_Rdb_DeleteStoreV2(config));
441 OH_Rdb_DestroyConfig(config);
442 }
443
444 /**
445 * @tc.name: RDB_Native_store_test_009
446 * @tc.desc: test apis of config interface OH_Rdb_SetCustomDir.
447 * @tc.type: FUNC
448 */
449 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_009, TestSize.Level1)
450 {
451 const char *customDir = "test";
452 auto ret = OH_Rdb_SetCustomDir(nullptr, customDir);
453 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
454
455 ret = OH_Rdb_SetCustomDir(nullptr, "12345678901234567890123456789012345678901234567890"
456 "12345678901234567890123456789012345678901234567890123456789012345678901234567890");
457 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
458
459 OH_Rdb_ConfigV2 *confg = OH_Rdb_CreateConfig();
460 EXPECT_NE(confg, nullptr);
461 ret = OH_Rdb_SetCustomDir(confg, nullptr);
462 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
463
464 ret = OH_Rdb_SetCustomDir(confg, customDir);
465 EXPECT_EQ(ret, RDB_OK);
466
467 ret = OH_Rdb_DestroyConfig(confg);
468 EXPECT_EQ(ret, RDB_OK);
469 }
470
471 /**
472 * @tc.name: RDB_Native_store_test_010
473 * @tc.desc: test apis of config interface OH_Rdb_SetReadOnly.
474 * @tc.type: FUNC
475 */
476 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_010, TestSize.Level1)
477 {
478 OH_Rdb_ConfigV2 *confg = OH_Rdb_CreateConfig();
479 EXPECT_NE(confg, nullptr);
480
481 auto ret = OH_Rdb_SetReadOnly(nullptr, true);
482 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
483
484 ret = OH_Rdb_SetReadOnly(confg, true);
485 EXPECT_EQ(ret, RDB_OK);
486
487 ret = OH_Rdb_SetReadOnly(confg, false);
488 EXPECT_EQ(ret, RDB_OK);
489
490 ret = OH_Rdb_DestroyConfig(confg);
491 EXPECT_EQ(ret, RDB_OK);
492 }
493
494 /**
495 * @tc.name: RDB_Native_store_test_011
496 * @tc.desc: test apis of config interface OH_Rdb_SetPlugins.
497 * @tc.type: FUNC
498 */
499 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_011, TestSize.Level1)
500 {
501 OH_Rdb_ConfigV2 *confg = OH_Rdb_CreateConfig();
502 EXPECT_NE(confg, nullptr);
503
504 const char *plugins[] = { "1" };
505 auto ret = OH_Rdb_SetPlugins(nullptr, plugins, 1);
506 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
507
508 ret = OH_Rdb_SetPlugins(confg, nullptr, 1);
509 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
510
511 ret = OH_Rdb_SetPlugins(confg, plugins, 0);
512 EXPECT_EQ(ret, RDB_OK);
513
514 ret = OH_Rdb_SetPlugins(confg, plugins, 1);
515 EXPECT_EQ(ret, RDB_OK);
516
517 const char *pluginsNew[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "0", "x" };
518 ret = OH_Rdb_SetPlugins(confg, pluginsNew, sizeof(pluginsNew) / sizeof(pluginsNew[0]) - 1);
519 EXPECT_EQ(ret, RDB_OK);
520
521 ret = OH_Rdb_SetPlugins(confg, pluginsNew, sizeof(pluginsNew) / sizeof(pluginsNew[0]));
522 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
523
524 ret = OH_Rdb_DestroyConfig(confg);
525 EXPECT_EQ(ret, RDB_OK);
526 }
527
528 /**
529 * @tc.name: RDB_Native_store_test_012
530 * @tc.desc: test apis of config interface OH_Rdb_SetCryptoParam.
531 * @tc.type: FUNC
532 */
533 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_012, TestSize.Level1)
534 {
535 OH_Rdb_ConfigV2 *confg = OH_Rdb_CreateConfig();
536 EXPECT_NE(confg, nullptr);
537
538 OH_Rdb_CryptoParam *crypto = OH_Rdb_CreateCryptoParam();
539 EXPECT_NE(crypto, NULL);
540
541 auto ret = OH_Rdb_SetCryptoParam(nullptr, crypto);
542 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
543
544 ret = OH_Rdb_SetCryptoParam(confg, nullptr);
545 EXPECT_EQ(ret, RDB_E_INVALID_ARGS);
546
547 ret = OH_Rdb_SetCryptoParam(confg, crypto);
548 EXPECT_EQ(ret, RDB_OK);
549
550 ret = OH_Rdb_DestroyCryptoParam(crypto);
551 EXPECT_EQ(ret, RDB_OK);
552
553 ret = OH_Rdb_DestroyConfig(confg);
554 EXPECT_EQ(ret, RDB_OK);
555 }
556
557 /**
558 * @tc.name: RDB_Native_store_test_013
559 * @tc.desc: abnormal test of RdbNdkUtils::GetRdbStoreConfig, when config is null.
560 * @tc.type: FUNC
561 */
562 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_013, TestSize.Level1)
563 {
564 auto [errCode, rdbConfig] = RdbNdkUtils::GetRdbStoreConfig(nullptr);
565 EXPECT_EQ(errCode, OHOS::NativeRdb::E_INVALID_ARGS);
566 }
567
568 /**
569 * @tc.name: RDB_Native_store_test_014
570 * @tc.desc: abnormal test of RdbNdkUtils::GetRdbStoreConfig, when securityLevel overlimit.
571 * @tc.type: FUNC
572 */
573 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_014, TestSize.Level1)
574 {
575 OH_Rdb_ConfigV2 *config = OH_Rdb_CreateConfig();
576 EXPECT_NE(config, nullptr);
577 std::shared_ptr<const char> autoRelease = std::shared_ptr<const char>("RDB_Native_store_test_014",
__anond6d5b9040102(const char *) 578 [config](const char *) {
579 OH_Rdb_DestroyConfig(config);
580 });
581 EXPECT_EQ(OH_Rdb_SetDatabaseDir(config, RDB_TEST_PATH), RDB_OK);
582 EXPECT_EQ(OH_Rdb_SetStoreName(config, "rdb_store_test.db"), RDB_OK);
583 EXPECT_EQ(OH_Rdb_SetBundleName(config, "com.ohos.example.distributedndk"), RDB_OK);
584 EXPECT_EQ(OH_Rdb_SetPersistent(config, true), RDB_OK);
585 config->securityLevel = -1;
586 auto [errCode1, _] = RdbNdkUtils::GetRdbStoreConfig(config);
587 EXPECT_EQ(errCode1, OHOS::NativeRdb::E_INVALID_ARGS);
588
589 config->securityLevel = 10;
590 auto [errCode2, __] = RdbNdkUtils::GetRdbStoreConfig(config);
591 EXPECT_EQ(errCode2, OHOS::NativeRdb::E_INVALID_ARGS);
592 }
593
594 /**
595 * @tc.name: RDB_Native_store_test_015
596 * @tc.desc: abnormal test of RdbNdkUtils::GetRdbStoreConfig, when securityLevel overlimit.
597 * @tc.type: FUNC
598 */
599 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_015, TestSize.Level1)
600 {
601 OH_Rdb_ConfigV2 *config = OH_Rdb_CreateConfig();
602 EXPECT_NE(config, nullptr);
603 std::shared_ptr<const char> autoRelease = std::shared_ptr<const char>("RDB_Native_store_test_015",
__anond6d5b9040202(const char *) 604 [config](const char *) {
605 OH_Rdb_DestroyConfig(config);
606 });
607 EXPECT_EQ(OH_Rdb_SetDatabaseDir(config, RDB_TEST_PATH), RDB_OK);
608 EXPECT_EQ(OH_Rdb_SetStoreName(config, "rdb_store_test.db"), RDB_OK);
609 EXPECT_EQ(OH_Rdb_SetBundleName(config, "com.ohos.example.distributedndk"), RDB_OK);
610 EXPECT_EQ(OH_Rdb_SetPersistent(config, false), RDB_OK);
611 EXPECT_EQ(OH_Rdb_SetSecurityLevel(config, S1), RDB_OK);
612 config->area = -1;
613 auto [errCode1, _] = RdbNdkUtils::GetRdbStoreConfig(config);
614 EXPECT_EQ(errCode1, OHOS::NativeRdb::E_INVALID_ARGS);
615
616 config->area = 10;
617 auto [errCode2, __] = RdbNdkUtils::GetRdbStoreConfig(config);
618 EXPECT_EQ(errCode2, OHOS::NativeRdb::E_INVALID_ARGS);
619 }
620
621 /**
622 * @tc.name: RDB_Native_store_test_016
623 * @tc.desc: abnormal test of RdbNdkUtils::GetRdbStoreConfig, when dbType overlimit.
624 * @tc.type: FUNC
625 */
626 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_016, TestSize.Level1)
627 {
628 OH_Rdb_ConfigV2 *config = OH_Rdb_CreateConfig();
629 EXPECT_NE(config, nullptr);
630 std::shared_ptr<const char> autoRelease = std::shared_ptr<const char>("RDB_Native_store_test_016",
__anond6d5b9040302(const char *) 631 [config](const char *) {
632 OH_Rdb_DestroyConfig(config);
633 });
634 EXPECT_EQ(OH_Rdb_SetDatabaseDir(config, RDB_TEST_PATH), RDB_OK);
635 EXPECT_EQ(OH_Rdb_SetStoreName(config, "rdb_store_test.db"), RDB_OK);
636 EXPECT_EQ(OH_Rdb_SetBundleName(config, "com.ohos.example.distributedndk"), RDB_OK);
637 EXPECT_EQ(OH_Rdb_SetPersistent(config, true), RDB_OK);
638 EXPECT_EQ(OH_Rdb_SetSecurityLevel(config, S1), RDB_OK);
639 EXPECT_EQ(OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL1), RDB_OK);
640 config->dbType = -1;
641 auto [errCode1, _] = RdbNdkUtils::GetRdbStoreConfig(config);
642 EXPECT_EQ(errCode1, OHOS::NativeRdb::E_INVALID_ARGS);
643
644 config->dbType = 10;
645 auto [errCode2, __] = RdbNdkUtils::GetRdbStoreConfig(config);
646 EXPECT_EQ(errCode2, OHOS::NativeRdb::E_INVALID_ARGS);
647 }
648
649 /**
650 * @tc.name: RDB_Native_store_test_017
651 * @tc.desc: abnormal test of RdbNdkUtils::GetRdbStoreConfig, when token overlimit.
652 * @tc.type: FUNC
653 */
654 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_017, TestSize.Level1)
655 {
656 OH_Rdb_ConfigV2 *config = OH_Rdb_CreateConfig();
657 EXPECT_NE(config, nullptr);
658 std::shared_ptr<const char> autoRelease = std::shared_ptr<const char>("RDB_Native_store_test_017",
__anond6d5b9040402(const char *) 659 [config](const char *) {
660 OH_Rdb_DestroyConfig(config);
661 });
662 EXPECT_EQ(OH_Rdb_SetDatabaseDir(config, RDB_TEST_PATH), RDB_OK);
663 EXPECT_EQ(OH_Rdb_SetStoreName(config, "rdb_store_test.db"), RDB_OK);
664 EXPECT_EQ(OH_Rdb_SetBundleName(config, "com.ohos.example.distributedndk"), RDB_OK);
665 EXPECT_EQ(OH_Rdb_SetPersistent(config, true), RDB_OK);
666 EXPECT_EQ(OH_Rdb_SetSecurityLevel(config, S1), RDB_OK);
667 EXPECT_EQ(OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL1), RDB_OK);
668 config->token = -1;
669 auto [errCode1, _] = RdbNdkUtils::GetRdbStoreConfig(config);
670 EXPECT_EQ(errCode1, OHOS::NativeRdb::E_INVALID_ARGS);
671
672 config->token = 10;
673 auto [errCode2, __] = RdbNdkUtils::GetRdbStoreConfig(config);
674 EXPECT_EQ(errCode2, OHOS::NativeRdb::E_INVALID_ARGS);
675 }
676
677 /**
678 * @tc.name: RDB_Native_store_test_018
679 * @tc.desc: abnormal test of RdbNdkUtils::GetRdbStoreConfig, when magicNum error.
680 * @tc.type: FUNC
681 */
682 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_018, TestSize.Level1)
683 {
684 OH_Rdb_ConfigV2 *config = OH_Rdb_CreateConfig();
685 EXPECT_NE(config, nullptr);
686 std::shared_ptr<const char> autoRelease = std::shared_ptr<const char>("RDB_Native_store_test_018",
__anond6d5b9040502(const char *) 687 [config](const char *) {
688 OH_Rdb_DestroyConfig(config);
689 });
690 EXPECT_EQ(OH_Rdb_SetDatabaseDir(config, RDB_TEST_PATH), RDB_OK);
691 EXPECT_EQ(OH_Rdb_SetStoreName(config, "rdb_store_test.db"), RDB_OK);
692 EXPECT_EQ(OH_Rdb_SetBundleName(config, "com.ohos.example.distributedndk"), RDB_OK);
693 EXPECT_EQ(OH_Rdb_SetPersistent(config, true), RDB_OK);
694 EXPECT_EQ(OH_Rdb_SetSecurityLevel(config, S1), RDB_OK);
695 EXPECT_EQ(OH_Rdb_SetArea(config, RDB_SECURITY_AREA_EL1), RDB_OK);
696 config->magicNum = 0;
697 auto [errCode1, _] = RdbNdkUtils::GetRdbStoreConfig(config);
698 EXPECT_EQ(errCode1, OHOS::NativeRdb::E_INVALID_ARGS);
699 }
700
701 /**
702 * @tc.name: RDB_Native_store_test_019
703 * @tc.desc: abnormal test of RdbNdkUtils::GetRdbStoreConfig, when magicNum error.
704 * @tc.type: FUNC
705 */
706 HWTEST_F(RdbNativeStoreConfigV2Test, RDB_Native_store_test_019, TestSize.Level1)
707 {
708 OH_Rdb_ConfigV2 *config = OH_Rdb_CreateConfig();
709 EXPECT_NE(config, nullptr);
710 std::shared_ptr<const char> autoRelease = std::shared_ptr<const char>("RDB_Native_store_test_019",
__anond6d5b9040602(const char *) 711 [config](const char *) {
712 OH_Rdb_DestroyConfig(config);
713 });
714 EXPECT_EQ(OH_Rdb_SetSemanticIndex(config, true), RDB_OK);
715 EXPECT_NE(OH_Rdb_SetSemanticIndex(nullptr, true), RDB_OK);
716 }
717