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 #include <cstdint>
18 #include <vector>
19 #include "types.h"
20 #include "kv_types_util.h"
21 using namespace testing::ext;
22 using namespace OHOS::DistributedKv;
23 using namespace OHOS;
24
25 class BlobTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31 };
32
SetUpTestCase(void)33 void BlobTest::SetUpTestCase(void)
34 {}
35
TearDownTestCase(void)36 void BlobTest::TearDownTestCase(void)
37 {}
38
SetUp(void)39 void BlobTest::SetUp(void)
40 {}
41
TearDown(void)42 void BlobTest::TearDown(void)
43 {}
44
45 /**
46 * @tc.name: Size001
47 * @tc.desc: construct a Blob and check its size.
48 * @tc.type: FUNC
49 * @tc.require: AR000C6GBG
50 * @tc.author: liqiao
51 */
52 HWTEST_F(BlobTest, Size001, TestSize.Level0)
53 {
54 Blob blob1;
55 EXPECT_EQ(blob1.Size(), (size_t)0);
56 Blob blob2 = "1234567890";
57 EXPECT_EQ(blob2.Size(), (size_t)10);
58 Blob blob3("12345");
59 EXPECT_EQ(blob3.Size(), (size_t)5);
60 std::string strTmp = "123";
61 Blob blob4(strTmp.c_str());
62 EXPECT_EQ(blob4.Size(), (size_t)3);
63 std::vector<uint8_t> vec = {'1', '2', '3', '4'};
64 Blob blob5(vec);
65 EXPECT_EQ(blob5.Size(), (size_t)4);
66 const char *chr1 = strTmp.c_str();
67 Blob blob6(chr1, strlen(chr1));
68 EXPECT_EQ(blob6.Size(), (size_t)3);
69 Blob blob7(nullptr);
70 EXPECT_EQ(blob7.Size(), (size_t)0);
71 Blob blob8(nullptr, strlen(chr1));
72 EXPECT_EQ(blob8.Size(), (size_t)0);
73 }
74
75 /**
76 * @tc.name: Empty001
77 * @tc.desc: construct a Blob and check its empty.
78 * @tc.type: FUNC
79 * @tc.require: AR000C6GBG
80 * @tc.author: liqiao
81 */
82 HWTEST_F(BlobTest, Empty001, TestSize.Level0)
83 {
84 Blob blob1;
85 EXPECT_EQ(blob1.Empty(), true);
86 Blob blob2 = "1234567890";
87 EXPECT_EQ(blob2.Empty(), false);
88 Blob blob3("12345");
89 EXPECT_EQ(blob3.Empty(), false);
90 std::string strTmp = "123";
91 Blob blob4(strTmp.c_str());
92 EXPECT_EQ(blob4.Empty(), false);
93 std::vector<uint8_t> vec = {'1', '2', '3', '4'};
94 Blob blob5(vec);
95 EXPECT_EQ(blob5.Empty(), false);
96 const char *chr1 = strTmp.c_str();
97 Blob blob6(chr1, strlen(chr1));
98 EXPECT_EQ(blob6.Empty(), false);
99 }
100
101 /**
102 * @tc.name: Clear001
103 * @tc.desc: construct a Blob and check it clear function.
104 * @tc.type: FUNC
105 * @tc.require: AR000C6GBG
106 * @tc.author: liqiao
107 */
108 HWTEST_F(BlobTest, Clear001, TestSize.Level0)
109 {
110 Blob blob1 = "1234567890";
111 blob1.Clear();
112 EXPECT_EQ(blob1.Empty(), true);
113 Blob blob2("12345");
114 blob2.Clear();
115 EXPECT_EQ(blob2.Empty(), true);
116 std::string strTmp = "123";
117 const char *chr = strTmp.c_str();
118 Blob blob3(chr);
119 blob3.Clear();
120 EXPECT_EQ(blob3.Empty(), true);
121 std::vector<uint8_t> vec = {'1', '2', '3', '4'};
122 Blob blob4(vec);
123 blob4.Clear();
124 EXPECT_EQ(blob4.Empty(), true);
125 }
126
127 /**
128 * @tc.name: StartsWith001
129 * @tc.desc: construct a Blob and check it StartsWith function.
130 * @tc.type: FUNC
131 * @tc.require: AR000C6GBG
132 * @tc.author: liqiao
133 */
134 HWTEST_F(BlobTest, StartsWith001, TestSize.Level0)
135 {
136 Blob blob1 = "1234567890";
137 Blob blob2("12345");
138 EXPECT_EQ(blob1.StartsWith(blob2), true);
139 EXPECT_EQ(blob2.StartsWith(blob1), false);
140 Blob blob3("234");
141 EXPECT_EQ(blob1.StartsWith(blob3), false);
142 EXPECT_EQ(blob2.StartsWith(blob3), false);
143 }
144
145 /**
146 * @tc.name: Compare001
147 * @tc.desc: construct a Blob and check it compare function.
148 * @tc.type: FUNC
149 * @tc.require: AR000C6GBG
150 * @tc.author: liqiao
151 */
152 HWTEST_F(BlobTest, Compare001, TestSize.Level0)
153 {
154 Blob blob1 = "1234567890";
155 Blob blob2("12345");
156 EXPECT_EQ(blob1.Compare(blob2), 1);
157 EXPECT_EQ(blob2.Compare(blob1), -1);
158 Blob blob3("12345");
159 EXPECT_EQ(blob2.Compare(blob3), 0);
160 }
161
162 /**
163 * @tc.name: Data001
164 * @tc.desc: construct a Blob and check it Data function.
165 * @tc.type: FUNC
166 * @tc.require: AR000C6GBG
167 * @tc.author: liqiao
168 */
169 HWTEST_F(BlobTest, Data001, TestSize.Level0)
170 {
171 std::vector<uint8_t> result = {'1', '2', '3', '4'};
172 Blob blob1("1234");
173 EXPECT_EQ(blob1.Data(), result);
174 std::vector<uint8_t> result2 = {'1', '2', '3', '4', '5'};
175 Blob blob2("12345");
176 EXPECT_EQ(blob2.Data(), result2);
177 }
178
179 /**
180 * @tc.name: ToString001
181 * @tc.desc: construct a Blob and check it ToString function.
182 * @tc.type: FUNC
183 * @tc.require: AR000C6GBG
184 * @tc.author: liqiao
185 */
186 HWTEST_F(BlobTest, ToString001, TestSize.Level0)
187 {
188 Blob blob1("1234");
189 std::string str = "1234";
190 EXPECT_EQ(blob1.ToString(), str);
191 }
192
193 /**
194 * @tc.name: OperatorEqual001
195 * @tc.desc: construct a Blob and check it operator== function.
196 * @tc.type: FUNC
197 * @tc.require: AR000C6GBG
198 * @tc.author: liqiao
199 */
200 HWTEST_F(BlobTest, OperatorEqual001, TestSize.Level0)
201 {
202 Blob blob1("1234");
203 Blob blob2("1234");
204 EXPECT_EQ(blob1 == blob2, true);
205 Blob blob3("12345");
206 EXPECT_EQ(blob1 == blob3, false);
207 }
208
209 /**
210 * @tc.name: Operator001
211 * @tc.desc: construct a Blob and check it operator[] function.
212 * @tc.type: FUNC
213 * @tc.require: AR000C6GBG
214 * @tc.author: liqiao
215 */
216 HWTEST_F(BlobTest, Operator001, TestSize.Level0)
217 {
218 Blob blob1("1234");
219 EXPECT_EQ(blob1[0], '1');
220 EXPECT_EQ(blob1[1], '2');
221 EXPECT_EQ(blob1[2], '3');
222 EXPECT_EQ(blob1[3], '4');
223 EXPECT_EQ(blob1[4], 0);
224 }
225
226 /**
227 * @tc.name: Operator002
228 * @tc.desc: construct a Blob and check it operator= function.
229 * @tc.type: FUNC
230 * @tc.require: AR000C6GBG
231 * @tc.author: liqiao
232 */
233 HWTEST_F(BlobTest, Operator002, TestSize.Level0)
234 {
235 Blob blob1("1234");
236 Blob blob2 = blob1;
237 EXPECT_EQ(blob1 == blob2, true);
238 EXPECT_EQ(blob2.ToString(), "1234");
239 }
240
241 /**
242 * @tc.name: Operator003
243 * @tc.desc: construct a Blob and check it operator= function.
244 * @tc.type: FUNC
245 * @tc.require: AR000C6GBG
246 * @tc.author: liqiao
247 */
248 HWTEST_F(BlobTest, Operator003, TestSize.Level0)
249 {
250 Blob blob1("1234");
251 Blob blob2 = std::move(blob1);
252 EXPECT_EQ(blob1 == blob2, false);
253 EXPECT_EQ(blob1.Empty(), true);
254 EXPECT_EQ(blob2.ToString(), "1234");
255 }
256
257 /**
258 * @tc.name: Operator004
259 * @tc.desc: construct a Blob and check it operator std::vector<uint8_t> && function.
260 * @tc.type: FUNC
261 * @tc.require:
262 * @tc.author: wangkai
263 */
264 HWTEST_F(BlobTest, Operator004, TestSize.Level0)
265 {
266 std::vector<uint8_t> blob = { 1, 2, 3, 4 };
267 Blob blob1(move(blob));
268 EXPECT_EQ(blob1.Size(), 4);
269 std::vector<uint8_t> blob2 = std::move(blob1);
270 EXPECT_EQ(blob2.size(), 4);
271 }
272
273 /**
274 * @tc.name: Operator005
275 * @tc.desc: construct a Blob and check it operator std::vector<uint8_t> & function.
276 * @tc.type: FUNC
277 * @tc.require:
278 * @tc.author: wangkai
279 */
280 HWTEST_F(BlobTest, Operator005, TestSize.Level0)
281 {
282 const std::vector<uint8_t> blob = { 1, 2, 3, 4 };
283 Blob blob1(blob);
284 EXPECT_EQ(blob1.Size(), 4);
285 }
286
287 /**
288 * @tc.name: RawSize001
289 * @tc.desc: construct a Blob and check it RawSize function.
290 * @tc.type: FUNC
291 * @tc.require:
292 * @tc.author: wangkai
293 */
294 HWTEST_F(BlobTest, RawSize001, TestSize.Level0)
295 {
296 Blob blob1("1234");
297 Blob blob2("12345");
298 EXPECT_EQ(blob1.RawSize(), sizeof(int) + 4);
299 EXPECT_EQ(blob2.RawSize(), sizeof(int) + 5);
300 }
301
302 /**
303 * @tc.name: WriteToBuffer001
304 * @tc.desc: construct a Blob and check it WriteToBuffer and ReadFromBuffer function.
305 * @tc.type: FUNC
306 * @tc.require:
307 * @tc.author: wangkai
308 */
309 HWTEST_F(BlobTest, WriteToBuffer001, TestSize.Level1)
310 {
311 Entry insert, update, del;
312 insert.key = "insert";
313 update.key = "update";
314 del.key = "delete";
315 insert.value = "insert_value";
316 update.value = "update_value";
317 del.value = "delete_value";
318 std::vector<Entry> inserts, updates, deletes;
319 inserts.push_back(insert);
320 updates.push_back(update);
321 deletes.push_back(del);
322
323 ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deletes), std::string(), false);
324 OHOS::MessageParcel parcel;
325 int64_t insertSize = ITypesUtil::GetTotalSize(changeIn.GetInsertEntries());
326 int64_t updateSize = ITypesUtil::GetTotalSize(changeIn.GetUpdateEntries());
327 int64_t deleteSize = ITypesUtil::GetTotalSize(changeIn.GetDeleteEntries());
328 ASSERT_TRUE(ITypesUtil::MarshalToBuffer(changeIn.GetInsertEntries(), insertSize, parcel));
329 ASSERT_TRUE(ITypesUtil::MarshalToBuffer(changeIn.GetUpdateEntries(), updateSize, parcel));
330 ASSERT_TRUE(ITypesUtil::MarshalToBuffer(changeIn.GetDeleteEntries(), deleteSize, parcel));
331 std::vector<Entry> outInserts;
332 std::vector<Entry> outUpdates;
333 std::vector<Entry> outDeletes;
334 ASSERT_TRUE(ITypesUtil::UnmarshalFromBuffer(parcel, outInserts));
335 ASSERT_TRUE(ITypesUtil::UnmarshalFromBuffer(parcel, outUpdates));
336 ASSERT_TRUE(ITypesUtil::UnmarshalFromBuffer(parcel, outDeletes));
337 }