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
26 using namespace testing::ext;
27 using namespace OHOS;
28 using namespace OHOS::NativeRdb;
29
30 class ValuesBucketTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36 };
37
SetUpTestCase(void)38 void ValuesBucketTest::SetUpTestCase(void)
39 {
40 }
41
TearDownTestCase(void)42 void ValuesBucketTest::TearDownTestCase(void)
43 {
44 }
45
SetUp(void)46 void ValuesBucketTest::SetUp(void)
47 {
48 }
49
TearDown(void)50 void ValuesBucketTest::TearDown(void)
51 {
52 }
53
54 /**
55 * @tc.name: Values_Bucket_001
56 * @tc.desc: test Values Bucket parcel
57 * @tc.type: FUNC
58 * @tc.require: AR000CU2BO
59 * @tc.author: zengmin
60 */
61 HWTEST_F(ValuesBucketTest, Values_Bucket_001, TestSize.Level1)
62 {
63 ValuesBucket values;
64 values.PutInt("id", 1);
65 values.PutString("name", std::string("zhangsan"));
66 values.PutLong("No.", 9223372036854775807L);
67 values.PutDouble("salary", 100.5);
68 values.PutBool("graduated", true);
69 values.PutBlob("codes", std::vector<uint8_t>{ 1, 2, 3 });
70 values.PutNull("mark");
71
72 OHOS::MessageParcel data;
73 data.WriteParcelable(&values);
74
75 ValuesBucket *valuesBucket = data.ReadParcelable<ValuesBucket>();
76 ValueObject valueObject;
77
78 valuesBucket->GetObject("id", valueObject);
79 EXPECT_EQ(ValueObjectType::TYPE_INT, valueObject.GetType());
80 int intVal;
81 valueObject.GetInt(intVal);
82 EXPECT_EQ(1, intVal);
83
84 valuesBucket->GetObject("name", valueObject);
85 EXPECT_EQ(ValueObjectType::TYPE_STRING, valueObject.GetType());
86 std::string strVal;
87 valueObject.GetString(strVal);
88 EXPECT_EQ("zhangsan", strVal);
89
90 valuesBucket->GetObject("No.", valueObject);
91 EXPECT_EQ(ValueObjectType::TYPE_INT64, valueObject.GetType());
92 int64_t int64Val;
93 valueObject.GetLong(int64Val);
94 EXPECT_EQ(9223372036854775807L, int64Val);
95
96 valuesBucket->GetObject("salary", valueObject);
97 EXPECT_EQ(ValueObjectType::TYPE_DOUBLE, valueObject.GetType());
98 double doubleVal;
99 valueObject.GetDouble(doubleVal);
100 EXPECT_EQ(100.5, doubleVal);
101
102 valuesBucket->GetObject("graduated", valueObject);
103 EXPECT_EQ(ValueObjectType::TYPE_BOOL, valueObject.GetType());
104 bool boolVal = false;
105 valueObject.GetBool(boolVal);
106 EXPECT_EQ(true, boolVal);
107
108 valuesBucket->GetObject("codes", valueObject);
109 EXPECT_EQ(ValueObjectType::TYPE_BLOB, valueObject.GetType());
110 std::vector<uint8_t> blobVal;
111 valueObject.GetBlob(blobVal);
112 EXPECT_EQ((uint32_t)3, blobVal.size());
113 EXPECT_EQ(1, blobVal.at(0));
114 EXPECT_EQ(2, blobVal.at(1));
115 EXPECT_EQ(3, blobVal.at(2));
116
117 valuesBucket->GetObject("mark", valueObject);
118 EXPECT_EQ(ValueObjectType::TYPE_NULL, valueObject.GetType());
119 }
120
121 /**
122 * @tc.name: Values_Bucket_002
123 * @tc.desc: test Values Bucket HasColumn
124 * @tc.type: FUNC
125 */
126 HWTEST_F(ValuesBucketTest, Values_Bucket_002, TestSize.Level1)
127 {
128 ValuesBucket values;
129 values.PutInt("id", 1);
130 values.PutString("name", std::string("zhangsan"));
131 values.PutLong("No.", 9223372036854775807L);
132 values.PutDouble("salary", 100.5);
133 values.PutBool("graduated", true);
134 values.PutBlob("codes", std::vector<uint8_t>{ 1, 2, 3 });
135 values.PutNull("mark");
136
137 EXPECT_EQ(true, values.HasColumn("id"));
138 EXPECT_EQ(true, values.HasColumn("name"));
139 EXPECT_EQ(true, values.HasColumn("No."));
140 EXPECT_EQ(true, values.HasColumn("salary"));
141 EXPECT_EQ(true, values.HasColumn("graduated"));
142 EXPECT_EQ(true, values.HasColumn("codes"));
143 EXPECT_EQ(true, values.HasColumn("mark"));
144
145 values.Delete("id");
146 values.Delete("name");
147 values.Delete("No.");
148 values.Delete("salary");
149 values.Delete("graduated");
150 values.Delete("codes");
151 values.Delete("mark");
152
153 EXPECT_EQ(false, values.HasColumn("id"));
154 EXPECT_EQ(false, values.HasColumn("name"));
155 EXPECT_EQ(false, values.HasColumn("No."));
156 EXPECT_EQ(false, values.HasColumn("salary"));
157 EXPECT_EQ(false, values.HasColumn("graduated"));
158 EXPECT_EQ(false, values.HasColumn("codes"));
159 EXPECT_EQ(false, values.HasColumn("mark"));
160 }
161
162 /**
163 * @tc.name: Values_Bucket_003
164 * @tc.desc: test Values Bucket GetAll
165 * @tc.type: FUNC
166 */
167 HWTEST_F(ValuesBucketTest, Values_Bucket_003, TestSize.Level1)
168 {
169 ValuesBucket values;
170 std::map<std::string, ValueObject> getAllValuesMap;
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 values.GetAll(getAllValuesMap);
180 EXPECT_EQ(7, getAllValuesMap.size());
181 getAllValuesMap.clear();
182 EXPECT_EQ(true, getAllValuesMap.empty());
183
184 EXPECT_EQ(7, values.Size());
185 values.Clear();
186 EXPECT_EQ(true, values.IsEmpty());
187 }
188
189 /**
190 * @tc.name: Values_Bucket_004
191 * @tc.desc: test Values Bucket Marshalling
192 * @tc.type: FUNC
193 */
194 HWTEST_F(ValuesBucketTest, Values_Bucket_004, TestSize.Level1)
195 {
196 Parcel parcel;
197 ValuesBucket values;
198 values.PutInt("id", 1);
199 values.PutString("name", std::string("zhangsan"));
200 values.PutLong("No.", 9223372036854775807L);
201 values.PutDouble("salary", 100.5);
202 values.PutBool("graduated", true);
203 values.PutBlob("codes", std::vector<uint8_t>{ 1, 2, 3 });
204 values.PutNull("mark");
205
206 EXPECT_EQ(true, values.Marshalling(parcel));
207 EXPECT_EQ(7, values.Unmarshalling(parcel)->Size());
208 values.Unmarshalling(parcel)->Clear();
209 EXPECT_EQ(true, values.Unmarshalling(parcel)->IsEmpty());
210 }
211
212 /**
213 * @tc.name: Values_Object_001
214 * @tc.desc: test ValuesObject operator
215 * @tc.type: FUNC
216 */
217 HWTEST_F(ValuesBucketTest, Values_Object_001, TestSize.Level1)
218 {
219 int valueInt = 1;
220 int retInt = ValueObject(valueInt);
221 EXPECT_EQ(valueInt, retInt);
222
223 int64_t valueInt64 = 1;
224 int64_t retInt64 = ValueObject(valueInt64);
225 EXPECT_EQ(valueInt64, retInt64);
226
227 double valueDouble = 1.0;
228 double retDouble = ValueObject(valueDouble);
229 EXPECT_EQ(valueDouble, retDouble);
230
231 bool valueBool = true;
232 bool retBool = ValueObject(valueBool);
233 EXPECT_EQ(valueBool, retBool);
234
235 string valueString = "test";
236 string retString = ValueObject(valueString);
237 EXPECT_EQ(valueString, retString);
238
239 std::vector<uint8_t> valueVectorUint8(2, 1);
240 std::vector<uint8_t> retVectorUint8 = ValueObject(valueVectorUint8);
241 EXPECT_EQ(valueVectorUint8, retVectorUint8);
242 }