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_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 RdbStoreInterfaceTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 };
35
36 class MyOpenCallback : public RdbOpenCallback {
37 public:
38 int OnCreate(RdbStore &store) override;
39 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
40 static const std::string CREATE_TABLE_TEST;
41 };
42
43 const std::string MyOpenCallback::CREATE_TABLE_TEST =
44 std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, name "
45 "TEXT, "
46 "age INTEGER, salary REAL, blobType BLOB)");
47
OnCreate(RdbStore & store)48 int MyOpenCallback::OnCreate(RdbStore &store)
49 {
50 return store.ExecuteSql(CREATE_TABLE_TEST);
51 }
52
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)53 int MyOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
54 {
55 return E_OK;
56 }
57
SetUpTestCase(void)58 void RdbStoreInterfaceTest::SetUpTestCase(void)
59 {
60 }
61
TearDownTestCase(void)62 void RdbStoreInterfaceTest::TearDownTestCase(void)
63 {
64 }
65
SetUp(void)66 void RdbStoreInterfaceTest::SetUp(void)
67 {
68 }
69
TearDown(void)70 void RdbStoreInterfaceTest::TearDown(void)
71 {
72 }
73
74 /**
75 * @tc.name: ValueObject_TEST_001
76 * @tc.desc: test ValueObject
77 * @tc.type: FUNC
78 */
79 HWTEST_F(RdbStoreInterfaceTest, ValueObject_TEST_001, TestSize.Level1)
80 {
81 ValueObject obj = ValueObject();
82 ValueObjectType type = obj.GetType();
83 EXPECT_EQ(type, ValueObjectType::TYPE_NULL);
84 }
85
86 /**
87 * @tc.name: ValueObject_TEST_002
88 * @tc.desc: test ValueObject
89 * @tc.type: FUNC
90 */
91 HWTEST_F(RdbStoreInterfaceTest, ValueObject_TEST_002, TestSize.Level1)
92 {
93 int inputVal = 5;
94 int outputVal = 0;
95 ValueObject obj = ValueObject(inputVal);
96 ValueObjectType type = obj.GetType();
97 EXPECT_EQ(type, ValueObjectType::TYPE_INT);
98 int ret = obj.GetInt(outputVal);
99 EXPECT_EQ(ret, E_OK);
100 EXPECT_EQ(outputVal, 5);
101 }
102
103 /**
104 * @tc.name: ValueObject_TEST_003
105 * @tc.desc: test ValueObject
106 * @tc.type: FUNC
107 */
108 HWTEST_F(RdbStoreInterfaceTest, ValueObject_TEST_003, TestSize.Level1)
109 {
110 bool inputVal = true;
111 bool outputVal = false;
112 ValueObject obj = ValueObject(inputVal);
113 ValueObjectType type = obj.GetType();
114 EXPECT_EQ(type, ValueObjectType::TYPE_BOOL);
115 int ret = obj.GetBool(outputVal);
116 EXPECT_EQ(ret, E_OK);
117 EXPECT_EQ(outputVal, true);
118 }
119
120 /**
121 * @tc.name: ValueObject_TEST_004
122 * @tc.desc: test ValueObject
123 * @tc.type: FUNC
124 */
125 HWTEST_F(RdbStoreInterfaceTest, ValueObject_TEST_004, TestSize.Level1)
126 {
127 std::string inputVal = "hello";
128 std::string outputVal = "";
129 ValueObject obj = ValueObject(inputVal);
130 ValueObjectType type = obj.GetType();
131 EXPECT_EQ(type, ValueObjectType::TYPE_STRING);
132 int ret = obj.GetString(outputVal);
133 EXPECT_EQ(ret, E_OK);
134 EXPECT_EQ(outputVal, "hello");
135 }
136
137 /**
138 * @tc.name: ValueObject_TEST_005
139 * @tc.desc: test ValueObject
140 * @tc.type: FUNC
141 */
142 HWTEST_F(RdbStoreInterfaceTest, ValueObject_TEST_005, TestSize.Level1)
143 {
144 std::vector<uint8_t> inputVal = { 'h', 'e', 'l', 'l', 'o' };
145 std::vector<uint8_t> outputVal;
146 ValueObject obj = ValueObject(inputVal);
147 ValueObjectType type = obj.GetType();
148 EXPECT_EQ(type, ValueObjectType::TYPE_BLOB);
149 int ret = obj.GetBlob(outputVal);
150 EXPECT_EQ(ret, E_OK);
151 EXPECT_EQ(static_cast<int>(outputVal.size()), 5);
152 EXPECT_EQ(outputVal[0], 'h');
153 EXPECT_EQ(outputVal[1], 'e');
154 EXPECT_EQ(outputVal[2], 'l');
155 EXPECT_EQ(outputVal[3], 'l');
156 EXPECT_EQ(outputVal[4], 'o');
157 }
158
159 /**
160 * @tc.name: ValueObject_TEST_006
161 * @tc.desc: test ValueObject
162 * @tc.type: FUNC
163 */
164 HWTEST_F(RdbStoreInterfaceTest, ValueObject_TEST_006, TestSize.Level1)
165 {
166 int inputVal = 5;
167 ValueObject obj = ValueObject(inputVal);
168 ValueObject obj1 = ValueObject();
169 obj1 = obj;
170 ValueObjectType type = obj1.GetType();
171 EXPECT_EQ(type, ValueObjectType::TYPE_INT);
172 }
173
174 /**
175 * @tc.name: ValuesBucket_001
176 * @tc.desc: test ValuesBucket
177 * @tc.type: FUNC
178 */
179 HWTEST_F(RdbStoreInterfaceTest, ValuesBucket_001, TestSize.Level1)
180 {
181 ValuesBucket values;
182 values.PutInt("id", 1);
183 values.PutNull("name");
184 values.PutInt("age", 18);
185 values.PutDouble("salary", 100.5);
186 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
187
188 int size = values.Size();
189 EXPECT_EQ(size, 5);
190 bool contains = values.HasColumn("name");
191 EXPECT_EQ(contains, true);
192 ValueObject obj;
193 contains = values.GetObject("salary", obj);
194 double val = 0.0;
195 ValueObjectType type = obj.GetType();
196 EXPECT_EQ(type, ValueObjectType::TYPE_DOUBLE);
197 int ret = obj.GetDouble(val);
198 EXPECT_EQ(ret, E_OK);
199 EXPECT_EQ(val, 100.5);
200
201 values.Delete("name");
202 size = values.Size();
203 EXPECT_EQ(size, 4);
204 contains = values.HasColumn("name");
205 EXPECT_EQ(contains, false);
206
207 values.Clear();
208 size = values.Size();
209 EXPECT_EQ(size, 0);
210 contains = values.HasColumn("salary");
211 EXPECT_EQ(contains, false);
212 }
213
214 /**
215 * @tc.name: ValuesBucket_002
216 * @tc.desc: test ValuesBucket
217 * @tc.type: FUNC
218 */
219 HWTEST_F(RdbStoreInterfaceTest, ValuesBucket_002, TestSize.Level1)
220 {
221 int errCode = E_OK;
222 const std::string dbPath = RDB_TEST_PATH + "InterfaceTest.db";
223 RdbStoreConfig config(dbPath);
224 MyOpenCallback helper;
225 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
226 EXPECT_NE(store, nullptr);
227 EXPECT_EQ(errCode, E_OK);
228
229 int64_t id;
230 ValuesBucket values;
231 values.PutInt("id", 1);
232 values.PutNull("name");
233 values.PutInt("age", 18);
234 values.PutDouble("salary", 100.5);
235 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
236 int ret = store->Insert(id, "test", values);
237 EXPECT_EQ(ret, E_OK);
238 EXPECT_EQ(1, id);
239
240 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
241 EXPECT_NE(resultSet, nullptr);
242
243 int columnIndex;
244 std::string strVal;
245
246 ret = resultSet->GoToFirstRow();
247 EXPECT_EQ(ret, E_OK);
248
249 ret = resultSet->GetColumnIndex("name", columnIndex);
250 EXPECT_EQ(ret, E_OK);
251 ret = resultSet->GetString(columnIndex, strVal);
252 EXPECT_EQ(ret, E_OK);
253
254 resultSet->Close();
255 resultSet = nullptr;
256 store = nullptr;
257 ret = RdbHelper::DeleteRdbStore(dbPath);
258 EXPECT_EQ(ret, E_OK);
259 }
260
261 /**
262 * @tc.name: ValuesBucket_003
263 * @tc.desc: test ValuesBucket
264 * @tc.type: FUNC
265 */
266 HWTEST_F(RdbStoreInterfaceTest, ValuesBucket_003, TestSize.Level1)
267 {
268 ValuesBucket values;
269 values.PutBool("boolType", true);
270 values.PutLong("longType", 1);
271
272 int size = values.Size();
273 EXPECT_EQ(size, 2);
274 bool contains = values.HasColumn("boolType");
275 EXPECT_EQ(contains, true);
276 ValueObject obj;
277 contains = values.GetObject("boolType", obj);
278 ValueObjectType type = obj.GetType();
279 EXPECT_EQ(type, ValueObjectType::TYPE_BOOL);
280 bool val1 = false;
281 int ret = obj.GetBool(val1);
282 EXPECT_EQ(ret, E_OK);
283 EXPECT_EQ(val1, true);
284
285 contains = values.HasColumn("longType");
286 EXPECT_EQ(contains, true);
287 contains = values.GetObject("longType", obj);
288 type = obj.GetType();
289 EXPECT_EQ(type, ValueObjectType::TYPE_INT);
290 int64_t val2 = 0;
291 ret = obj.GetLong(val2);
292 EXPECT_EQ(ret, E_OK);
293 EXPECT_EQ(val2, 1);
294 }
295