1 /*
2 * Copyright (c) 2022 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 "itypes_util.h"
21 #include "message_parcel.h"
22 #include "parcel.h"
23 #include "raw_data_parser.h"
24 #include "rdb_errno.h"
25 #include "sqlite_global_config.h"
26 #include "value_object.h"
27 #include "values_bucket.h"
28
29 using namespace testing::ext;
30 using namespace OHOS;
31 using namespace OHOS::NativeRdb;
32
33 class ValuesBucketTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase(void)41 void ValuesBucketTest::SetUpTestCase(void)
42 {
43 }
44
TearDownTestCase(void)45 void ValuesBucketTest::TearDownTestCase(void)
46 {
47 }
48
SetUp(void)49 void ValuesBucketTest::SetUp(void)
50 {
51 }
52
TearDown(void)53 void ValuesBucketTest::TearDown(void)
54 {
55 }
56
57 /**
58 * @tc.name: Values_Bucket_001
59 * @tc.desc: test Values Bucket parcel
60 * @tc.type: FUNC
61 */
62 HWTEST_F(ValuesBucketTest, Values_Bucket_001, TestSize.Level1)
63 {
64 ValuesBucket values;
65 values.PutInt("id", 1);
66 values.PutString("name", std::string("zhangsan"));
67 values.PutLong("No.", 9223372036854775807L);
68 values.PutDouble("salary", 100.5);
69 values.PutBool("graduated", true);
70 values.PutBlob("codes", std::vector<uint8_t>{ 1, 2, 3 });
71 values.PutNull("mark");
72
73 OHOS::MessageParcel data;
74 ITypesUtil::Marshal(data, values);
75 ValuesBucket valuesBucket;
76
77 ITypesUtil::Unmarshal(data, valuesBucket);
78 ValueObject valueObject;
79 valuesBucket.GetObject("id", valueObject);
80 EXPECT_EQ(ValueObjectType::TYPE_INT, valueObject.GetType());
81 int intVal;
82 valueObject.GetInt(intVal);
83 EXPECT_EQ(1, intVal);
84
85 valuesBucket.GetObject("name", valueObject);
86 EXPECT_EQ(ValueObjectType::TYPE_STRING, valueObject.GetType());
87 std::string strVal;
88 valueObject.GetString(strVal);
89 EXPECT_EQ("zhangsan", strVal);
90
91 valuesBucket.GetObject("No.", valueObject);
92 EXPECT_EQ(ValueObjectType::TYPE_INT, valueObject.GetType());
93 int64_t int64Val;
94 valueObject.GetLong(int64Val);
95 EXPECT_EQ(9223372036854775807L, int64Val);
96
97 valuesBucket.GetObject("salary", valueObject);
98 EXPECT_EQ(ValueObjectType::TYPE_DOUBLE, valueObject.GetType());
99 double doubleVal;
100 valueObject.GetDouble(doubleVal);
101 EXPECT_EQ(100.5, doubleVal);
102
103 valuesBucket.GetObject("graduated", valueObject);
104 EXPECT_EQ(ValueObjectType::TYPE_BOOL, valueObject.GetType());
105 bool boolVal = false;
106 valueObject.GetBool(boolVal);
107 EXPECT_EQ(true, boolVal);
108
109 valuesBucket.GetObject("codes", valueObject);
110 EXPECT_EQ(ValueObjectType::TYPE_BLOB, valueObject.GetType());
111 std::vector<uint8_t> blobVal;
112 valueObject.GetBlob(blobVal);
113 EXPECT_EQ((uint32_t)3, blobVal.size());
114 EXPECT_EQ(1, blobVal.at(0));
115 EXPECT_EQ(2, blobVal.at(1));
116 EXPECT_EQ(3, blobVal.at(2));
117
118 valuesBucket.GetObject("mark", valueObject);
119 EXPECT_EQ(ValueObjectType::TYPE_NULL, valueObject.GetType());
120 }
121
122 /**
123 * @tc.name: Values_Bucket_002
124 * @tc.desc: test Values Bucket HasColumn
125 * @tc.type: FUNC
126 */
127 HWTEST_F(ValuesBucketTest, Values_Bucket_002, TestSize.Level1)
128 {
129 ValuesBucket values;
130 values.PutInt("id", 1);
131 values.PutString("name", std::string("zhangsan"));
132 values.PutLong("No.", 9223372036854775807L);
133 values.PutDouble("salary", 100.5);
134 values.PutBool("graduated", true);
135 values.PutBlob("codes", std::vector<uint8_t>{ 1, 2, 3 });
136 values.PutNull("mark");
137
138 EXPECT_EQ(true, values.HasColumn("id"));
139 EXPECT_EQ(true, values.HasColumn("name"));
140 EXPECT_EQ(true, values.HasColumn("No."));
141 EXPECT_EQ(true, values.HasColumn("salary"));
142 EXPECT_EQ(true, values.HasColumn("graduated"));
143 EXPECT_EQ(true, values.HasColumn("codes"));
144 EXPECT_EQ(true, values.HasColumn("mark"));
145
146 values.Delete("id");
147 values.Delete("name");
148 values.Delete("No.");
149 values.Delete("salary");
150 values.Delete("graduated");
151 values.Delete("codes");
152 values.Delete("mark");
153
154 EXPECT_EQ(false, values.HasColumn("id"));
155 EXPECT_EQ(false, values.HasColumn("name"));
156 EXPECT_EQ(false, values.HasColumn("No."));
157 EXPECT_EQ(false, values.HasColumn("salary"));
158 EXPECT_EQ(false, values.HasColumn("graduated"));
159 EXPECT_EQ(false, values.HasColumn("codes"));
160 EXPECT_EQ(false, values.HasColumn("mark"));
161 }
162
163 /**
164 * @tc.name: Values_Bucket_003
165 * @tc.desc: test Values Bucket GetAll
166 * @tc.type: FUNC
167 */
168 HWTEST_F(ValuesBucketTest, Values_Bucket_003, TestSize.Level1)
169 {
170 ValuesBucket values;
171 values.PutInt("id", 1);
172 values.PutString("name", std::string("zhangsan"));
173 values.PutLong("No.", 9223372036854775807L);
174 values.PutDouble("salary", 100.5);
175 values.PutBool("graduated", true);
176 values.PutBlob("codes", std::vector<uint8_t>{ 1, 2, 3 });
177 values.PutNull("mark");
178
179 EXPECT_EQ(7, values.Size());
180 values.Clear();
181 EXPECT_EQ(true, values.IsEmpty());
182 }
183
184 /**
185 * @tc.name: Values_Bucket_004
186 * @tc.desc: test Values Bucket Marshalling
187 * @tc.type: FUNC
188 */
189 HWTEST_F(ValuesBucketTest, Values_Bucket_004, TestSize.Level1)
190 {
191 MessageParcel parcel;
192 ValuesBucket values;
193 values.PutInt("id", 1);
194 values.PutString("name", std::string("zhangsan"));
195 values.PutLong("No.", 9223372036854775807L);
196 values.PutDouble("salary", 100.5);
197 values.PutBool("graduated", true);
198 values.PutBlob("codes", std::vector<uint8_t>{ 1, 2, 3 });
199 values.PutNull("mark");
200
201 EXPECT_EQ(true, ITypesUtil::Marshal(parcel, values));
202 ValuesBucket valuesBucket;
203 ITypesUtil::Unmarshal(parcel, valuesBucket);
204 EXPECT_EQ(7, valuesBucket.Size());
205 valuesBucket.Clear();
206 ITypesUtil::Unmarshal(parcel, valuesBucket);
207 EXPECT_EQ(true, valuesBucket.IsEmpty());
208 }
209
210 /**
211 * @tc.name: Values_Bucket_005
212 * @tc.desc: test Values Bucket Unmarshalling
213 * @tc.type: FUNC
214 */
215 HWTEST_F(ValuesBucketTest, Values_Bucket_005, TestSize.Level1)
216 {
217 MessageParcel parcel;
218 ValuesBucket values;
219 for (int i = 0; i < GlobalExpr::SQLITE_MAX_COLUMN + 1; i++) {
220 values.PutInt("id" + std::to_string(i), i);
221 }
222
223 EXPECT_EQ(true, values.Marshalling(parcel));
224 auto valuesBucket = ValuesBucket::Unmarshalling(parcel);
225 EXPECT_FALSE(valuesBucket.IsEmpty());
226 }
227
228 /**
229 * @tc.name: Values_Object_001
230 * @tc.desc: test ValuesObject operator
231 * @tc.type: FUNC
232 */
233 HWTEST_F(ValuesBucketTest, Values_Object_001, TestSize.Level1)
234 {
235 int valueInt = 1;
236 int retInt = ValueObject(valueInt);
237 EXPECT_EQ(valueInt, retInt);
238
239 int64_t valueInt64 = 1;
240 int64_t retInt64 = ValueObject(valueInt64);
241 EXPECT_EQ(valueInt64, retInt64);
242
243 double valueDouble = 1.0;
244 double retDouble = ValueObject(valueDouble);
245 EXPECT_EQ(valueDouble, retDouble);
246
247 bool valueBool = true;
248 bool retBool = ValueObject(valueBool);
249 EXPECT_EQ(valueBool, retBool);
250
251 string valueString = "test";
252 string retString = ValueObject(valueString);
253 EXPECT_EQ(valueString, retString);
254
255 std::vector<uint8_t> valueVectorUint8(2, 1);
256 std::vector<uint8_t> retVectorUint8 = ValueObject(valueVectorUint8);
257 EXPECT_EQ(valueVectorUint8, retVectorUint8);
258 }
259
260 /**
261 * @tc.name: Values_Object_002
262 * @tc.desc: test ValuesObject for Get
263 * @tc.type: FUNC
264 */
265 HWTEST_F(ValuesBucketTest, Values_Object_002, TestSize.Level1)
266 {
267 ValueObject val;
268 int valueInt;
269 int errCode = val.GetInt(valueInt);
270 EXPECT_EQ(E_INVALID_OBJECT_TYPE, errCode);
271
272 int64_t valueInt64;
273 errCode = val.GetLong(valueInt64);
274 EXPECT_EQ(E_INVALID_OBJECT_TYPE, errCode);
275
276 double valueDouble;
277 errCode = val.GetDouble(valueDouble);
278 EXPECT_EQ(E_INVALID_OBJECT_TYPE, errCode);
279
280 bool valueBool = false;
281 errCode = val.GetBool(valueBool);
282 EXPECT_EQ(E_INVALID_OBJECT_TYPE, errCode);
283
284 std::string valueString;
285 errCode = val.GetString(valueString);
286 EXPECT_EQ(E_INVALID_OBJECT_TYPE, errCode);
287
288 std::vector<uint8_t> valueVectorUint8;
289 errCode = val.GetBlob(valueVectorUint8);
290 EXPECT_EQ(E_INVALID_OBJECT_TYPE, errCode);
291
292 AssetValue asset;
293 errCode = val.GetAsset(asset);
294 EXPECT_EQ(E_INVALID_OBJECT_TYPE, errCode);
295
296 auto assets = ValueObject::Assets({ asset });
297 errCode = val.GetAssets(assets);
298 EXPECT_EQ(E_INVALID_OBJECT_TYPE, errCode);
299 }
300
301 /**
302 * @tc.name: Convert from subset
303 * @tc.desc: test ValuesObject operator
304 * @tc.type: FUNC
305 */
306 HWTEST_F(ValuesBucketTest, Convert_From_Subset, TestSize.Level1)
307 {
308 ValueObject::Type output = AssetValue();
309 using Type = std::variant<std::monostate, int64_t, double, std::string, bool, std::vector<uint8_t>>;
310 Type input;
311 RawDataParser::Convert(input, output);
312 auto *nil = std::get_if<std::monostate>(&output);
313 EXPECT_TRUE(nil != nullptr);
314 input = int64_t(54);
315 RawDataParser::Convert(input, output);
316 auto *number = std::get_if<int64_t>(&output);
317 EXPECT_TRUE(number != nullptr);
318 EXPECT_TRUE(*number == 54);
319 input = double(1.1);
320 RawDataParser::Convert(input, output);
321 auto *real = std::get_if<double>(&output);
322 EXPECT_TRUE(real != nullptr);
323 input = std::string("my test");
324 RawDataParser::Convert(input, output);
325 auto *text = std::get_if<std::string>(&output);
326 EXPECT_TRUE(text != nullptr);
327 EXPECT_TRUE(*text == "my test");
328 input = std::vector<uint8_t>(10, 'm');
329 RawDataParser::Convert(input, output);
330 auto *blob = std::get_if<std::vector<uint8_t>>(&output);
331 EXPECT_TRUE(blob != nullptr);
332 EXPECT_TRUE(*blob == std::vector<uint8_t>(10, 'm'));
333 }
334
335 /**
336 * @tc.name: Convert to subset
337 * @tc.desc: test ValuesObject operator
338 * @tc.type: FUNC
339 */
340 HWTEST_F(ValuesBucketTest, Convert_To_Subset, TestSize.Level1)
341 {
342 using Type = std::variant<std::monostate, int64_t, double, std::string, bool, std::vector<uint8_t>>;
343 Type output;
344 ValueObject::Type input;
345 RawDataParser::Convert(input, output);
346 auto *nil = std::get_if<std::monostate>(&output);
347 EXPECT_TRUE(nil != nullptr);
348 input = int64_t(54);
349 RawDataParser::Convert(input, output);
350 auto *number = std::get_if<int64_t>(&output);
351 EXPECT_TRUE(number != nullptr);
352 EXPECT_TRUE(*number == 54);
353 input = double(1.1);
354 RawDataParser::Convert(input, output);
355 auto *real = std::get_if<double>(&output);
356 EXPECT_TRUE(real != nullptr);
357 input = std::string("my test");
358 RawDataParser::Convert(input, output);
359 auto *text = std::get_if<std::string>(&output);
360 EXPECT_TRUE(text != nullptr);
361 EXPECT_TRUE(*text == "my test");
362 input = std::vector<uint8_t>(10, 'm');
363 RawDataParser::Convert(input, output);
364 auto *blob = std::get_if<std::vector<uint8_t>>(&output);
365 EXPECT_TRUE(blob != nullptr);
366 EXPECT_TRUE(*blob == std::vector<uint8_t>(10, 'm'));
367 AssetValue value{ .version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12" };
368 input = value;
369 output = {};
370 RawDataParser::Convert(input, output);
371 nil = std::get_if<std::monostate>(&output);
372 EXPECT_TRUE(nil != nullptr);
373 input = std::vector<AssetValue>(10, value);
374 output = {};
375 RawDataParser::Convert(input, output);
376 nil = std::get_if<std::monostate>(&output);
377 EXPECT_TRUE(nil != nullptr);
378 }
379
380 /**
381 * @tc.name: Explicit conversion
382 * @tc.desc: test ValuesObject operator
383 * @tc.type: FUNC
384 */
385 HWTEST_F(ValuesBucketTest, Explicit_Conversion, TestSize.Level1)
386 {
387 ValueObject valueObject;
388 auto blob = std::vector<uint8_t>(10, 'm');
389 valueObject = ValueObject(blob);
390 auto transformedBlob = ValueObject::Blob(valueObject);
391 ASSERT_EQ(transformedBlob.size(), 10);
392
393 AssetValue asset{ .version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12" };
394 valueObject = ValueObject(asset);
395 auto transformedAsset = ValueObject::Asset(valueObject);
396 ASSERT_EQ(transformedAsset.version, asset.version);
397 ASSERT_EQ(transformedAsset.name, asset.name);
398 ASSERT_EQ(transformedAsset.uri, asset.uri);
399 ASSERT_EQ(transformedAsset.createTime, asset.createTime);
400
401 auto assets = ValueObject::Assets({ asset });
402 valueObject = ValueObject(assets);
403 auto transformedAssets = ValueObject::Assets(valueObject);
404 ASSERT_EQ(transformedAssets.size(), 1);
405 auto first = transformedAssets.begin();
406 ASSERT_EQ(first->version, asset.version);
407 ASSERT_EQ(first->name, asset.name);
408 ASSERT_EQ(first->uri, asset.uri);
409 ASSERT_EQ(first->createTime, asset.createTime);
410
411 using Type = ValueObject::Type;
412 Type input = asset;
413 valueObject = ValueObject(input);
414 auto transformedType = ValueObject::Type(valueObject);
415 ASSERT_EQ(transformedType.index(), ValueObject::TYPE_ASSET);
416 }