1 /*
2  * Copyright (c) 2021 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_common.h"
22 #include "rdb_errno.h"
23 #include "rdb_helper.h"
24 #include "rdb_open_callback.h"
25 
26 using namespace testing::ext;
27 using namespace OHOS::NativeRdb;
28 
29 class RdbStoreInsertTest : public testing::Test {
30 public:
31     static void SetUpTestCase(void);
32     static void TearDownTestCase(void);
33     void SetUp();
34     void TearDown();
35     void CheckResultSet(std::shared_ptr<RdbStore> &store);
36     void CheckAge(std::shared_ptr<ResultSet> &resultSet);
37     void CheckSalary(std::shared_ptr<ResultSet> &resultSet);
38     void CheckBlob(std::shared_ptr<ResultSet> &resultSet);
39 
40     static const std::string DATABASE_NAME;
41     static std::shared_ptr<RdbStore> store;
42 };
43 
44 const std::string RdbStoreInsertTest::DATABASE_NAME = RDB_TEST_PATH + "insert_test.db";
45 std::shared_ptr<RdbStore> RdbStoreInsertTest::store = nullptr;
46 
47 class InsertTestOpenCallback : public RdbOpenCallback {
48 public:
49     int OnCreate(RdbStore &store) override;
50     int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
51     static const std::string CREATE_TABLE_TEST;
52 };
53 
54 const std::string InsertTestOpenCallback::CREATE_TABLE_TEST =
55     std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
56                                                                   "name TEXT NOT NULL, age INTEGER, salary "
57                                                                   "REAL, blobType BLOB)");
58 
OnCreate(RdbStore & store)59 int InsertTestOpenCallback::OnCreate(RdbStore &store)
60 {
61     return store.ExecuteSql(CREATE_TABLE_TEST);
62 }
63 
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)64 int InsertTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
65 {
66     return E_OK;
67 }
68 
SetUpTestCase(void)69 void RdbStoreInsertTest::SetUpTestCase(void)
70 {
71     int errCode = E_OK;
72     RdbStoreConfig config(RdbStoreInsertTest::DATABASE_NAME);
73     InsertTestOpenCallback helper;
74     RdbStoreInsertTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
75     EXPECT_NE(RdbStoreInsertTest::store, nullptr);
76 }
77 
TearDownTestCase(void)78 void RdbStoreInsertTest::TearDownTestCase(void)
79 {
80     RdbHelper::DeleteRdbStore(RdbStoreInsertTest::DATABASE_NAME);
81 }
82 
SetUp(void)83 void RdbStoreInsertTest::SetUp(void)
84 {
85     store->ExecuteSql("DELETE FROM test");
86 }
87 
TearDown(void)88 void RdbStoreInsertTest::TearDown(void)
89 {
90 }
91 
92 /**
93  * @tc.name: RdbStore_Insert_001
94  * @tc.desc: test RdbStore insert
95  * @tc.type: FUNC
96  */
97 HWTEST_F(RdbStoreInsertTest, RdbStore_Insert_001, TestSize.Level1)
98 {
99     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
100 
101     int64_t id;
102     ValuesBucket values;
103 
104     values.PutInt("id", 1);
105     values.PutString("name", std::string("zhangsan"));
106     values.PutInt("age", 18);
107     values.PutDouble("salary", 100.5);
108     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
109     int ret = store->Insert(id, "test", values);
110     EXPECT_EQ(ret, E_OK);
111     EXPECT_EQ(1, id);
112 
113     values.Clear();
114     values.PutInt("id", 2);
115     values.PutString("name", std::string("lisi"));
116     values.PutInt("age", 18);
117     values.PutDouble("salary", 100.5);
118     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
119     ret = store->Insert(id, "test", values);
120     EXPECT_EQ(ret, E_OK);
121     EXPECT_EQ(2, id);
122 
123     values.Clear();
124     values.PutInt("id", 3);
125     values.PutString("name", std::string("lisi"));
126     values.PutInt("age", 20L);
127     values.PutDouble("salary", 100.5f);
128     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
129     ret = store->Insert(id, "test", values);
130     EXPECT_EQ(ret, E_OK);
131     EXPECT_EQ(3, id);
132 
133     RdbStoreInsertTest::CheckResultSet(store);
134 }
135 
CheckResultSet(std::shared_ptr<RdbStore> & store)136 void RdbStoreInsertTest::CheckResultSet(std::shared_ptr<RdbStore> &store)
137 {
138     std::shared_ptr<ResultSet> resultSet =
139         store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
140     EXPECT_NE(resultSet, nullptr);
141 
142     int columnIndex;
143     int intVal;
144     std::string strVal;
145     ColumnType columnType;
146     int position;
147     int ret = resultSet->GetRowIndex(position);
148     EXPECT_EQ(ret, E_OK);
149     EXPECT_EQ(position, -1);
150 
151     ret = resultSet->GetColumnType(0, columnType);
152     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
153 
154     ret = resultSet->GoToFirstRow();
155     EXPECT_EQ(ret, E_OK);
156 
157     ret = resultSet->GetColumnIndex("id", columnIndex);
158     EXPECT_EQ(ret, E_OK);
159     EXPECT_EQ(columnIndex, 0);
160     ret = resultSet->GetColumnType(columnIndex, columnType);
161     EXPECT_EQ(ret, E_OK);
162     EXPECT_EQ(columnType, ColumnType::TYPE_INTEGER);
163     ret = resultSet->GetInt(columnIndex, intVal);
164     EXPECT_EQ(ret, E_OK);
165     EXPECT_EQ(1, intVal);
166 
167     ret = resultSet->GetColumnIndex("name", columnIndex);
168     EXPECT_EQ(ret, E_OK);
169     ret = resultSet->GetColumnType(columnIndex, columnType);
170     EXPECT_EQ(ret, E_OK);
171     EXPECT_EQ(columnType, ColumnType::TYPE_STRING);
172     ret = resultSet->GetString(columnIndex, strVal);
173     EXPECT_EQ(ret, E_OK);
174     EXPECT_EQ("zhangsan", strVal);
175 
176     RdbStoreInsertTest::CheckAge(resultSet);
177     RdbStoreInsertTest::CheckSalary(resultSet);
178     RdbStoreInsertTest::CheckBlob(resultSet);
179 
180     ret = resultSet->GoToNextRow();
181     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
182 
183     ret = resultSet->GetColumnType(columnIndex, columnType);
184     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
185 
186     ret = resultSet->Close();
187     EXPECT_EQ(ret, E_OK);
188 }
189 
CheckAge(std::shared_ptr<ResultSet> & resultSet)190 void RdbStoreInsertTest::CheckAge(std::shared_ptr<ResultSet> &resultSet)
191 {
192     int columnIndex;
193     int intVal;
194     ColumnType columnType;
195     int ret = resultSet->GetColumnIndex("age", columnIndex);
196     EXPECT_EQ(ret, E_OK);
197     ret = resultSet->GetColumnType(columnIndex, columnType);
198     EXPECT_EQ(ret, E_OK);
199     EXPECT_EQ(columnType, ColumnType::TYPE_INTEGER);
200     ret = resultSet->GetInt(columnIndex, intVal);
201     EXPECT_EQ(ret, E_OK);
202     EXPECT_EQ(18, intVal);
203 }
204 
CheckSalary(std::shared_ptr<ResultSet> & resultSet)205 void RdbStoreInsertTest::CheckSalary(std::shared_ptr<ResultSet> &resultSet)
206 {
207     int columnIndex;
208     double dVal;
209     ColumnType columnType;
210     int ret = resultSet->GetColumnIndex("salary", columnIndex);
211     EXPECT_EQ(ret, E_OK);
212     ret = resultSet->GetColumnType(columnIndex, columnType);
213     EXPECT_EQ(ret, E_OK);
214     EXPECT_EQ(columnType, ColumnType::TYPE_FLOAT);
215     ret = resultSet->GetDouble(columnIndex, dVal);
216     EXPECT_EQ(ret, E_OK);
217     EXPECT_EQ(100.5, dVal);
218 }
219 
CheckBlob(std::shared_ptr<ResultSet> & resultSet)220 void RdbStoreInsertTest::CheckBlob(std::shared_ptr<ResultSet> &resultSet)
221 {
222     int columnIndex;
223     std::vector<uint8_t> blob;
224     ColumnType columnType;
225     int ret = resultSet->GetColumnIndex("blobType", columnIndex);
226     EXPECT_EQ(ret, E_OK);
227     ret = resultSet->GetColumnType(columnIndex, columnType);
228     EXPECT_EQ(ret, E_OK);
229     EXPECT_EQ(columnType, ColumnType::TYPE_BLOB);
230     ret = resultSet->GetBlob(columnIndex, blob);
231     EXPECT_EQ(ret, E_OK);
232     EXPECT_EQ(3, static_cast<int>(blob.size()));
233     EXPECT_EQ(1, blob[0]);
234     EXPECT_EQ(2, blob[1]);
235     EXPECT_EQ(3, blob[2]);
236 }
237 
238 /**
239  * @tc.name: RdbStore_Insert_002
240  * @tc.desc: test RdbStore insert
241  * @tc.type: FUNC
242  */
243 HWTEST_F(RdbStoreInsertTest, RdbStore_Insert_002, TestSize.Level1)
244 {
245     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
246 
247     int64_t id;
248     ValuesBucket values;
249     values.PutInt("id", 1);
250     values.PutString("name", std::string("zhangsan"));
251     values.PutInt("age", 18);
252     values.PutDouble("salary", 100.5);
253     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
254     int ret = store->Insert(id, "", values); // empty table name
255     EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
256 
257     ret = store->Insert(id, "wrongTable", values); // no such table
258     EXPECT_EQ(ret, E_SQLITE_ERROR);
259 }
260 
261 /**
262  * @tc.name: RdbStore_Insert_003
263  * @tc.desc: test RdbStore insert
264  * @tc.type: FUNC
265  */
266 HWTEST_F(RdbStoreInsertTest, RdbStore_Insert_003, TestSize.Level1)
267 {
268     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
269 
270     int64_t id;
271     ValuesBucket emptyBucket;
272     int ret = store->Insert(id, "test", emptyBucket);
273     EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
274 
275     ValuesBucket values;
276     values.PutInt("id", 1);
277     values.PutString("name", std::string("zhangsan"));
278     values.PutInt("age", 18);
279     values.PutDouble("wrongColumn", 100.5); // no such column
280     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
281     ret = store->Insert(id, "test", values);
282     EXPECT_EQ(ret, E_SQLITE_ERROR);
283 }
284 
285 /**
286  * @tc.name: RdbStore_Replace_001
287  * @tc.desc: test RdbStore replace
288  * @tc.type: FUNC
289  */
290 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_001, TestSize.Level1)
291 {
292     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
293 
294     int64_t id;
295     ValuesBucket values;
296 
297     int ret = store->Replace(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
298     EXPECT_EQ(ret, E_OK);
299     EXPECT_EQ(1, id);
300 
301     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
302     EXPECT_NE(resultSet, nullptr);
303 
304     ret = resultSet->GoToNextRow();
305     EXPECT_EQ(ret, E_OK);
306 
307     int columnIndex;
308     int intVal;
309     std::string strVal;
310 
311     ret = resultSet->GetColumnIndex("id", columnIndex);
312     EXPECT_EQ(ret, E_OK);
313     ret = resultSet->GetInt(columnIndex, intVal);
314     EXPECT_EQ(ret, E_OK);
315     EXPECT_EQ(1, intVal);
316 
317     ret = resultSet->GetColumnIndex("name", columnIndex);
318     EXPECT_EQ(ret, E_OK);
319     ret = resultSet->GetString(columnIndex, strVal);
320     EXPECT_EQ(ret, E_OK);
321     EXPECT_EQ("zhangsan", strVal);
322 
323     ret = resultSet->GetColumnIndex("age", columnIndex);
324     EXPECT_EQ(ret, E_OK);
325     ret = resultSet->GetInt(columnIndex, intVal);
326     EXPECT_EQ(ret, E_OK);
327     EXPECT_EQ(18, intVal);
328 
329     ret = resultSet->GoToNextRow();
330     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
331 
332     ret = resultSet->Close();
333     EXPECT_EQ(ret, E_OK);
334 }
335 
336 /**
337  * @tc.name: RdbStore_Replace_002
338  * @tc.desc: test RdbStore replace
339  * @tc.type: FUNC
340  */
341 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_002, TestSize.Level1)
342 {
343     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
344 
345     int64_t id;
346     ValuesBucket values;
347 
348     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
349     EXPECT_EQ(ret, E_OK);
350     EXPECT_EQ(1, id);
351 
352     values.Clear();
353     values.PutInt("id", 1);
354     values.PutString("name", std::string("zhangsan"));
355     values.PutInt("age", 18);
356     values.PutDouble("salary", 200.5);
357     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
358     ret = store->Replace(id, "test", values);
359     EXPECT_EQ(ret, E_OK);
360     EXPECT_EQ(1, id);
361 
362     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
363     EXPECT_NE(resultSet, nullptr);
364 
365     ret = resultSet->GoToNextRow();
366     EXPECT_EQ(ret, E_OK);
367 
368     int columnIndex;
369     int intVal;
370     std::string strVal;
371 
372     ret = resultSet->GetColumnIndex("id", columnIndex);
373     EXPECT_EQ(ret, E_OK);
374     ret = resultSet->GetInt(columnIndex, intVal);
375     EXPECT_EQ(ret, E_OK);
376     EXPECT_EQ(1, intVal);
377 
378     ret = resultSet->GetColumnIndex("name", columnIndex);
379     EXPECT_EQ(ret, E_OK);
380     ret = resultSet->GetString(columnIndex, strVal);
381     EXPECT_EQ(ret, E_OK);
382     EXPECT_EQ("zhangsan", strVal);
383 
384     ret = resultSet->GetColumnIndex("age", columnIndex);
385     EXPECT_EQ(ret, E_OK);
386     ret = resultSet->GetInt(columnIndex, intVal);
387     EXPECT_EQ(ret, E_OK);
388     EXPECT_EQ(18, intVal);
389 
390     ret = resultSet->GoToNextRow();
391     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
392 
393     ret = resultSet->Close();
394     EXPECT_EQ(ret, E_OK);
395 }
396 
397 /**
398  * @tc.name: RdbStore_Replace_003
399  * @tc.desc: test RdbStore Replace
400  * @tc.type: FUNC
401  */
402 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_003, TestSize.Level1)
403 {
404     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
405 
406     int64_t id;
407     ValuesBucket values;
408     values.PutInt("id", 1);
409     values.PutString("name", std::string("zhangsan"));
410     values.PutInt("age", 18);
411     values.PutDouble("salary", 100.5);
412     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
413     int ret = store->Replace(id, "", values); // empty table name
414     EXPECT_EQ(ret, E_EMPTY_TABLE_NAME);
415 
416     ret = store->Replace(id, "wrongTable", values); // no such table
417     EXPECT_EQ(ret, E_SQLITE_ERROR);
418 }
419 
420 /**
421  * @tc.name: RdbStore_Replace_004
422  * @tc.desc: test RdbStore Replace
423  * @tc.type: FUNC
424  */
425 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_004, TestSize.Level1)
426 {
427     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
428 
429     int64_t id;
430     ValuesBucket emptyBucket;
431     int ret = store->Replace(id, "test", emptyBucket);
432     EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
433 
434     ValuesBucket values;
435     values.PutInt("id", 1);
436     values.PutString("name", std::string("zhangsan"));
437     values.PutInt("age", 18);
438     values.PutDouble("wrongColumn", 100.5); // no such column
439     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
440     ret = store->Replace(id, "test", values);
441     EXPECT_EQ(ret, E_SQLITE_ERROR);
442 }
443 
444 /**
445  * @tc.name: RdbStore_Replace_005
446  * @tc.desc: test RdbStore replace
447  * @tc.type: FUNC
448  */
449 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_005, TestSize.Level1)
450 {
451     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
452 
453     int64_t id;
454 
455     int ret = store->Replace(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
456     EXPECT_EQ(ret, E_OK);
457     EXPECT_EQ(1, id);
458 
459     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
460     EXPECT_NE(resultSet, nullptr);
461 
462     ret = resultSet->GoToNextRow();
463     EXPECT_EQ(ret, E_OK);
464 
465     int columnIndex;
466     double dVal;
467     std::vector<uint8_t> blob;
468 
469     ret = resultSet->GetColumnIndex("salary", columnIndex);
470     EXPECT_EQ(ret, E_OK);
471     ret = resultSet->GetDouble(columnIndex, dVal);
472     EXPECT_EQ(ret, E_OK);
473     EXPECT_EQ(100.5, dVal);
474 
475     ret = resultSet->GetColumnIndex("blobType", columnIndex);
476     EXPECT_EQ(ret, E_OK);
477     ret = resultSet->GetBlob(columnIndex, blob);
478     EXPECT_EQ(ret, E_OK);
479     EXPECT_EQ(3, static_cast<int>(blob.size()));
480     EXPECT_EQ(1, blob[0]);
481     EXPECT_EQ(2, blob[1]);
482     EXPECT_EQ(3, blob[2]);
483 
484     ret = resultSet->GoToNextRow();
485     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
486 
487     ret = resultSet->Close();
488     EXPECT_EQ(ret, E_OK);
489 }
490 
491 /**
492  * @tc.name: RdbStore_Replace_006
493  * @tc.desc: test RdbStore replace
494  * @tc.type: FUNC
495  */
496 HWTEST_F(RdbStoreInsertTest, RdbStore_Replace_006, TestSize.Level1)
497 {
498     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
499 
500     int64_t id;
501     ValuesBucket values;
502 
503     int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
504     EXPECT_EQ(ret, E_OK);
505     EXPECT_EQ(1, id);
506 
507     values.Clear();
508     values.PutInt("id", 1);
509     values.PutString("name", std::string("zhangsan"));
510     values.PutInt("age", 18);
511     values.PutDouble("salary", 200.5);
512     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
513     ret = store->Replace(id, "test", values);
514     EXPECT_EQ(ret, E_OK);
515     EXPECT_EQ(1, id);
516 
517     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
518     EXPECT_NE(resultSet, nullptr);
519 
520     ret = resultSet->GoToNextRow();
521     EXPECT_EQ(ret, E_OK);
522 
523     int columnIndex;
524     double dVal;
525     std::vector<uint8_t> blob;
526 
527     ret = resultSet->GetColumnIndex("salary", columnIndex);
528     EXPECT_EQ(ret, E_OK);
529     ret = resultSet->GetDouble(columnIndex, dVal);
530     EXPECT_EQ(ret, E_OK);
531     EXPECT_EQ(200.5, dVal);
532 
533     ret = resultSet->GetColumnIndex("blobType", columnIndex);
534     EXPECT_EQ(ret, E_OK);
535     ret = resultSet->GetBlob(columnIndex, blob);
536     EXPECT_EQ(ret, E_OK);
537     EXPECT_EQ(3, static_cast<int>(blob.size()));
538     EXPECT_EQ(1, blob[0]);
539     EXPECT_EQ(2, blob[1]);
540     EXPECT_EQ(3, blob[2]);
541 
542     ret = resultSet->GoToNextRow();
543     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
544 
545     ret = resultSet->Close();
546     EXPECT_EQ(ret, E_OK);
547 }
548 
549 /**
550  * @tc.name: RdbStore_InsertWithConflictResolution_001_002
551  * @tc.desc: test RdbStore InsertWithConflictResolution
552  * @tc.type: FUNC
553  */
554 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_001_002, TestSize.Level1)
555 {
556     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
557 
558     int64_t id;
559     ValuesBucket values;
560 
561     values.PutInt("id", 1);
562     values.PutString("name", std::string("zhangsan"));
563     values.PutInt("age", 18);
564     values.PutDouble("salary", 100.5);
565     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
566 
567     // default is ConflictResolution::ON_CONFLICT_NONE
568     int ret = store->InsertWithConflictResolution(id, "test", values);
569     EXPECT_EQ(ret, E_OK);
570     EXPECT_EQ(1, id);
571 
572     values.Clear();
573     values.PutInt("id", 1);
574     values.PutString("name", std::string("zhangsan"));
575     values.PutInt("age", 18);
576     values.PutDouble("salary", 200.5);
577     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
578     ret = store->InsertWithConflictResolution(id, "test", values);
579     EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
580 }
581 
582 /**
583  * @tc.name: RdbStore_InsertWithConflictResolution_003_004
584  * @tc.desc: test RdbStore InsertWithConflictResolution
585  * @tc.type: FUNC
586  */
587 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_003_004, TestSize.Level1)
588 {
589     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
590 
591     int64_t id;
592     ValuesBucket values;
593 
594     values.PutInt("id", 1);
595     values.PutString("name", std::string("zhangsan"));
596     values.PutInt("age", 18);
597     values.PutDouble("salary", 100.5);
598     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
599     int ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_ROLLBACK);
600     EXPECT_EQ(ret, E_OK);
601     EXPECT_EQ(1, id);
602 
603     values.Clear();
604     values.PutInt("id", 1);
605     values.PutString("name", std::string("zhangsan"));
606     values.PutInt("age", 18);
607     values.PutDouble("salary", 200.5);
608     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
609     ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_ROLLBACK);
610     EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
611 }
612 
613 /**
614  * @tc.name: RdbStore_InsertWithConflictResolution_005
615  * @tc.desc: test RdbStore InsertWithConflictResolution
616  * @tc.type: FUNC
617  */
618 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_005, TestSize.Level1)
619 {
620     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
621 
622     int64_t id;
623     ValuesBucket values;
624 
625     values.PutInt("id", 1);
626     values.PutString("name", std::string("zhangsan"));
627     values.PutInt("age", 18);
628     values.PutDouble("salary", 100.5);
629     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
630     int ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_IGNORE);
631     EXPECT_EQ(ret, E_OK);
632     EXPECT_EQ(1, id);
633 
634     values.Clear();
635     values.PutInt("id", 1);
636     values.PutString("name", std::string("zhangsan"));
637     values.PutInt("age", 18);
638     values.PutDouble("salary", 200.5);
639     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
640     ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_IGNORE);
641     EXPECT_EQ(ret, E_OK);
642     EXPECT_EQ(id, -1);
643 }
644 
645 /**
646  * @tc.name: RdbStore_InsertWithConflictResolution_006
647  * @tc.desc: test RdbStore InsertWithConflictResolution
648  * @tc.type: FUNC
649  */
650 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_006, TestSize.Level1)
651 {
652     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
653 
654     int64_t id;
655     ValuesBucket values;
656 
657     int ret = store->InsertWithConflictResolution(
658         id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]), ConflictResolution::ON_CONFLICT_REPLACE);
659     EXPECT_EQ(ret, E_OK);
660     EXPECT_EQ(1, id);
661 
662     values.Clear();
663     values.PutInt("id", 1);
664     values.PutString("name", std::string("zhangsan"));
665     values.PutInt("age", 18);
666     values.PutDouble("salary", 200.5);
667     values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
668     ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_REPLACE);
669     EXPECT_EQ(ret, E_OK);
670     EXPECT_EQ(id, 1);
671 
672     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
673     EXPECT_NE(resultSet, nullptr);
674 
675     ret = resultSet->GoToNextRow();
676     EXPECT_EQ(ret, E_OK);
677 
678     int columnIndex;
679     int intVal;
680     std::string strVal;
681 
682     ret = resultSet->GetColumnIndex("id", columnIndex);
683     EXPECT_EQ(ret, E_OK);
684     ret = resultSet->GetInt(columnIndex, intVal);
685     EXPECT_EQ(ret, E_OK);
686     EXPECT_EQ(1, intVal);
687 
688     ret = resultSet->GetColumnIndex("name", columnIndex);
689     EXPECT_EQ(ret, E_OK);
690     ret = resultSet->GetString(columnIndex, strVal);
691     EXPECT_EQ(ret, E_OK);
692     EXPECT_EQ("zhangsan", strVal);
693 
694     ret = resultSet->GetColumnIndex("age", columnIndex);
695     EXPECT_EQ(ret, E_OK);
696     ret = resultSet->GetInt(columnIndex, intVal);
697     EXPECT_EQ(ret, E_OK);
698     EXPECT_EQ(18, intVal);
699 
700     ret = resultSet->GoToNextRow();
701     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
702 
703     ret = resultSet->Close();
704     EXPECT_EQ(ret, E_OK);
705 }
706 
707 /**
708  * @tc.name: RdbStore_InsertWithConflictResolution_007
709  * @tc.desc: test RdbStore InsertWithConflictResolution
710  * @tc.type: FUNC
711  */
712 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_007, TestSize.Level1)
713 {
714     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
715 
716     int64_t id;
717     ValuesBucket values;
718 
719     int ret = store->InsertWithConflictResolution(
720         id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]), ConflictResolution::ON_CONFLICT_REPLACE);
721     EXPECT_EQ(ret, E_OK);
722     EXPECT_EQ(1, id);
723 
724     values.Clear();
725     values.PutInt("id", 1);
726     values.PutString("name", std::string("zhangsan"));
727     values.PutInt("age", 18);
728     values.PutDouble("salary", 200.5);
729     values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
730     ret = store->InsertWithConflictResolution(id, "test", values, ConflictResolution::ON_CONFLICT_REPLACE);
731     EXPECT_EQ(ret, E_OK);
732     EXPECT_EQ(id, 1);
733 
734     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
735     EXPECT_NE(resultSet, nullptr);
736 
737     ret = resultSet->GoToNextRow();
738     EXPECT_EQ(ret, E_OK);
739 
740     int columnIndex;
741     double dVal;
742     std::vector<uint8_t> blob;
743 
744     ret = resultSet->GetColumnIndex("salary", columnIndex);
745     EXPECT_EQ(ret, E_OK);
746     ret = resultSet->GetDouble(columnIndex, dVal);
747     EXPECT_EQ(ret, E_OK);
748     EXPECT_EQ(200.5, dVal);
749 
750     ret = resultSet->GetColumnIndex("blobType", columnIndex);
751     EXPECT_EQ(ret, E_OK);
752     ret = resultSet->GetBlob(columnIndex, blob);
753     EXPECT_EQ(ret, E_OK);
754     EXPECT_EQ(3, static_cast<int>(blob.size()));
755     EXPECT_EQ(4, blob[0]);
756     EXPECT_EQ(5, blob[1]);
757     EXPECT_EQ(6, blob[2]);
758 
759     ret = resultSet->GoToNextRow();
760     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
761 
762     ret = resultSet->Close();
763     EXPECT_EQ(ret, E_OK);
764 }
765 
766 /**
767  * @tc.name: RdbStore_InsertWithConflictResolution_008
768  * @tc.desc: Abnormal testCase of InsertWithConflictResolution, if conflictResolution is invalid
769  * @tc.type: FUNC
770  */
771 HWTEST_F(RdbStoreInsertTest, RdbStore_InsertWithConflictResolution_008, TestSize.Level1)
772 {
773     std::shared_ptr<RdbStore> &store = RdbStoreInsertTest::store;
774 
775     int64_t id = 0;
776     ValuesBucket values;
777 
778     values.PutInt("id", 1);
779     values.PutInt("age", 18);
780     int ret = store->InsertWithConflictResolution(id, "test", values, static_cast<ConflictResolution>(6));
781     EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
782     EXPECT_EQ(0, id);
783 
784     values.Clear();
785     values.PutInt("id", 1);
786     values.PutInt("age", 18);
787     ret = store->InsertWithConflictResolution(id, "test", values, static_cast<ConflictResolution>(-1));
788     EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
789     EXPECT_EQ(0, id);
790 }