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 "logger.h"
21 #include "parcel.h"
22 #include "value_object.h"
23 #include "values_bucket.h"
24 #include "message_parcel.h"
25 #include "sqlite_global_config.h"
26
27 using namespace testing::ext;
28 using namespace OHOS;
29 using namespace OHOS::NativeRdb;
30
31 class ValuesBucketTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void ValuesBucketTest::SetUpTestCase(void)
40 {
41 }
42
TearDownTestCase(void)43 void ValuesBucketTest::TearDownTestCase(void)
44 {
45 }
46
SetUp(void)47 void ValuesBucketTest::SetUp(void)
48 {
49 }
50
TearDown(void)51 void ValuesBucketTest::TearDown(void)
52 {
53 }
54
55 /**
56 * @tc.name: Values_Bucket_001
57 * @tc.desc: test Values Bucket parcel
58 * @tc.type: FUNC
59 * @tc.require: AR000CU2BO
60 * @tc.author: zengmin
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 data.WriteParcelable(&values);
75
76 ValuesBucket *valuesBucket = data.ReadParcelable<ValuesBucket>();
77 ValueObject valueObject;
78
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_INT64, 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 std::map<std::string, ValueObject> getAllValuesMap;
172 values.PutInt("id", 1);
173 values.PutString("name", std::string("zhangsan"));
174 values.PutLong("No.", 9223372036854775807L);
175 values.PutDouble("salary", 100.5);
176 values.PutBool("graduated", true);
177 values.PutBlob("codes", std::vector<uint8_t>{ 1, 2, 3 });
178 values.PutNull("mark");
179
180 values.GetAll(getAllValuesMap);
181 EXPECT_EQ(7, getAllValuesMap.size());
182 getAllValuesMap.clear();
183 EXPECT_EQ(true, getAllValuesMap.empty());
184
185 EXPECT_EQ(7, values.Size());
186 values.Clear();
187 EXPECT_EQ(true, values.IsEmpty());
188 }
189
190 /**
191 * @tc.name: Values_Bucket_004
192 * @tc.desc: test Values Bucket Marshalling
193 * @tc.type: FUNC
194 */
195 HWTEST_F(ValuesBucketTest, Values_Bucket_004, TestSize.Level1)
196 {
197 Parcel parcel;
198 ValuesBucket values;
199 values.PutInt("id", 1);
200 values.PutString("name", std::string("zhangsan"));
201 values.PutLong("No.", 9223372036854775807L);
202 values.PutDouble("salary", 100.5);
203 values.PutBool("graduated", true);
204 values.PutBlob("codes", std::vector<uint8_t>{ 1, 2, 3 });
205 values.PutNull("mark");
206
207 EXPECT_EQ(true, values.Marshalling(parcel));
208 EXPECT_EQ(7, values.Unmarshalling(parcel)->Size());
209 values.Unmarshalling(parcel)->Clear();
210 EXPECT_EQ(true, values.Unmarshalling(parcel)->IsEmpty());
211 }
212
213 /**
214 * @tc.name: Values_Bucket_005
215 * @tc.desc: test Values Bucket Unmarshalling
216 * @tc.type: FUNC
217 */
218 HWTEST_F(ValuesBucketTest, Values_Bucket_005, TestSize.Level1)
219 {
220 Parcel parcel;
221 ValuesBucket values;
222 for (int i = 0; i < GlobalExpr::SQLITE_MAX_COLUMN + 1; i++) {
223 values.PutInt("id" + std::to_string(i), i);
224 }
225
226 EXPECT_EQ(true, values.Marshalling(parcel));
227 auto valuesBucket = std::shared_ptr<ValuesBucket>(ValuesBucket::Unmarshalling(parcel));
228 EXPECT_EQ(true, valuesBucket->IsEmpty());
229 }
230
231 /**
232 * @tc.name: Values_Object_001
233 * @tc.desc: test ValuesObject operator
234 * @tc.type: FUNC
235 */
236 HWTEST_F(ValuesBucketTest, Values_Object_001, TestSize.Level1)
237 {
238 int valueInt = 1;
239 int retInt = ValueObject(valueInt);
240 EXPECT_EQ(valueInt, retInt);
241
242 int64_t valueInt64 = 1;
243 int64_t retInt64 = ValueObject(valueInt64);
244 EXPECT_EQ(valueInt64, retInt64);
245
246 double valueDouble = 1.0;
247 double retDouble = ValueObject(valueDouble);
248 EXPECT_EQ(valueDouble, retDouble);
249
250 bool valueBool = true;
251 bool retBool = ValueObject(valueBool);
252 EXPECT_EQ(valueBool, retBool);
253
254 string valueString = "test";
255 string retString = ValueObject(valueString);
256 EXPECT_EQ(valueString, retString);
257
258 std::vector<uint8_t> valueVectorUint8(2, 1);
259 std::vector<uint8_t> retVectorUint8 = ValueObject(valueVectorUint8);
260 EXPECT_EQ(valueVectorUint8, retVectorUint8);
261 }