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 "data_ability_predicates.h"
17
18 #include <gtest/gtest.h>
19
20 #include <vector>
21
22 #include "predicates_utils.h"
23 #include "refbase.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::NativeRdb;
27 const int MAX_PARCEL_SIZE = 1000;
28 char g_data[MAX_PARCEL_SIZE];
29 int g_invalidObjectFlag = 0;
30 const std::string MAX = "2 147 483 647";
31 class DataAbilityPredicatesTest : public testing::Test {
32 public:
33 static void TearDownTestCase(void);
34 };
35
TearDownTestCase(void)36 void DataAbilityPredicatesTest::TearDownTestCase(void)
37 {
38 for (int i = 0; i < MAX_PARCEL_SIZE; i++) {
39 g_data[i] = 0;
40 }
41 }
42
43 /* *
44 * @tc.name: DataAbilityPredicates_001
45 * @tc.desc: test DataAbilityPredicates()
46 * @tc.type: FUNC
47 */
48 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_001, TestSize.Level1)
49 {
50 OHOS::sptr<DataAbilityPredicates> predicates = new DataAbilityPredicates();
51 EXPECT_EQ(false, predicates->IsRawSelection());
52 }
53
54 /* *
55 * @tc.name: DataAbilityPredicates_002
56 * @tc.desc: test DataAbilityPredicates()
57 * @tc.type: FUNC
58 */
59 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_002, TestSize.Level1)
60 {
61 DataAbilityPredicates *predicates1 = new DataAbilityPredicates();
62
63 predicates1->EqualTo("stringValue", "ABCDEFGHIJKLMN")
64 ->BeginWrap()
65 ->EqualTo("integerValue", "1")
66 ->Or()
67 ->EqualTo("integerValue", MAX)
68 ->EndWrap()
69 ->OrderByDesc("integerValue")
70 ->Limit(2);
71
72 EXPECT_EQ(true, predicates1->GetLimit() == 2);
73
74 predicates1->SetOrder("ohos");
75 predicates1->Distinct();
76
77 EXPECT_EQ("ohos", predicates1->GetOrder());
78 EXPECT_EQ(true, predicates1->IsDistinct());
79
80 EXPECT_EQ(false, predicates1->IsRawSelection());
81 predicates1->Clear();
82
83 EXPECT_EQ(AbsPredicates::INIT_LIMIT_VALUE, predicates1->GetLimit());
84 EXPECT_EQ(true, predicates1->GetWhereClause().empty());
85 EXPECT_EQ(true, predicates1->GetWhereArgs().empty());
86 EXPECT_EQ(true, predicates1->GetOrder().empty());
87 EXPECT_EQ(false, predicates1->IsDistinct());
88
89 EXPECT_EQ(false, predicates1->IsRawSelection());
90 }
91 /* *
92 * @tc.name: DataAbilityPredicates_003
93 * @tc.desc: test DataAbilityPredicates
94 * @tc.type: FUNC
95 */
96 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_003, TestSize.Level1)
97 {
98 DataAbilityPredicates *predicates = new DataAbilityPredicates();
99 predicates->SetWhereClause("`name` = ? ");
100 std::vector<std::string> whereArgsArray = { "zhangsan", "lisi" };
101 predicates->SetWhereArgs(whereArgsArray);
102 predicates->SetOrder("ASC");
103 OHOS::Parcel outParcel(0);
104 OHOS::Parcel &coutParcel = outParcel;
105 bool isMarshalling = predicates->Marshalling(coutParcel);
106 EXPECT_EQ(true, isMarshalling);
107
108 EXPECT_EQ(false, outParcel.ReadBool());
109 std::string whereClause = (outParcel.ReadInt32() != g_invalidObjectFlag) ? outParcel.ReadString() : "";
110 EXPECT_EQ(whereClause, predicates->GetWhereClause());
111 std::vector<std::string> whereArgs;
112 if (outParcel.ReadInt32() != g_invalidObjectFlag) {
113 outParcel.ReadStringVector(&whereArgs);
114 }
115 EXPECT_EQ(whereArgs, predicates->GetWhereArgs());
116 EXPECT_EQ(false, outParcel.ReadBool());
117 std::string indexedBy = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
118 EXPECT_EQ("", indexedBy);
119
120 outParcel.FlushBuffer();
121 }
122
123 /* *
124 * @tc.name: DataAbilityPredicates_004
125 * @tc.desc: test DataAbilityPredicates(std::string rawSelection);
126 * @tc.type: FUNC
127 */
128 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_004, TestSize.Level1)
129 {
130 std::string rawSelection = "select * from table";
131 OHOS::sptr<DataAbilityPredicates> predicates = new DataAbilityPredicates(rawSelection);
132 EXPECT_EQ(true, predicates->IsRawSelection());
133 EXPECT_EQ(rawSelection, predicates->GetWhereClause());
134 }
135
136 /* *
137 * @tc.name: DataAbilityPredicates_005
138 * @tc.desc: test DataAbilityPredicates(std::string rawSelection);
139 * @tc.type: FUNC
140 */
141 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_005, TestSize.Level1)
142 {
143 std::string rawSelection = "";
144 OHOS::sptr<DataAbilityPredicates> predicates = new DataAbilityPredicates(rawSelection);
145 EXPECT_EQ(true, predicates->IsRawSelection());
146 EXPECT_EQ(rawSelection, predicates->GetWhereClause());
147 }
148
149 /* *
150 * @tc.name: DataAbilityPredicates_006
151 * @tc.desc: test DataAbilityPredicates(std::string rawSelection);
152 * @tc.type: FUNC
153 */
154 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_006, TestSize.Level1)
155 {
156 std::string rawSelection = "select * from user order by @(*.{}`。 age";
157 OHOS::sptr<DataAbilityPredicates> predicates = new DataAbilityPredicates(rawSelection);
158 EXPECT_EQ(true, predicates->IsRawSelection());
159 EXPECT_EQ(rawSelection, predicates->GetWhereClause());
160 }
161
162 /* *
163 * @tc.name: DataAbilityPredicates_007
164 * @tc.desc: test DataAbilityPredicates(OHOS::Parcel *source)
165 * @tc.type: FUNC
166 */
167 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_007, TestSize.Level1)
168 {
169 OHOS::sptr<DataAbilityPredicates> predicates = new DataAbilityPredicates(nullptr);
170 EXPECT_EQ(false, predicates->GetJudgeSource());
171 }
172
173 /* *
174 * @tc.name: DataAbilityPredicates_008
175 * @tc.desc: test DataAbilityPredicates(OHOS::Parcel *source)
176 * @tc.type: FUNC
177 */
178 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_008, TestSize.Level1)
179 {
180 DataAbilityPredicates *predicates = new DataAbilityPredicates();
181 predicates->SetWhereClause("`name` = ? ");
182 OHOS::Parcel outParcel(0);
183 OHOS::Parcel &coutParcel = outParcel;
184 bool isMarshalling = predicates->Marshalling(coutParcel);
185 OHOS::sptr<DataAbilityPredicates> createdPredicates = new DataAbilityPredicates(&outParcel);
186 EXPECT_EQ(true, isMarshalling);
187 EXPECT_EQ("`name` = ? ", createdPredicates->GetWhereClause());
188
189 outParcel.FlushBuffer();
190 }
191 /* *
192 * @tc.name: DataAbilityPredicates_009
193 * @tc.desc: test DataAbilityPredicates(OHOS::Parcel *source)
194 * @tc.type: FUNC
195 */
196 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_009, TestSize.Level1)
197 {
198 DataAbilityPredicates *predicates = new DataAbilityPredicates();
199 predicates->SetWhereClause("`name` = ? ");
200 std::vector<std::string> whereArgsArray = { "zhangsan", "lisi" };
201 predicates->SetWhereArgs(whereArgsArray);
202 predicates->SetOrder("ASC");
203 OHOS::Parcel outParcel(0);
204 OHOS::Parcel &coutParcel = outParcel;
205 bool isMarshalling = predicates->Marshalling(coutParcel);
206 EXPECT_EQ(true, isMarshalling);
207
208 OHOS::sptr<DataAbilityPredicates> newPredicates = new DataAbilityPredicates(&outParcel);
209 EXPECT_EQ(newPredicates->GetWhereClause(), predicates->GetWhereClause());
210 EXPECT_EQ(newPredicates->GetWhereArgs(), predicates->GetWhereArgs());
211 EXPECT_EQ(newPredicates->GetOrder(), predicates->GetOrder());
212 EXPECT_EQ(AbsPredicates::INIT_LIMIT_VALUE, newPredicates->GetLimit());
213
214 outParcel.FlushBuffer();
215 }
216
217 /* *
218 * @tc.name: DataAbilityPredicates_010
219 * @tc.desc: test DataAbilityPredicates Marshalling
220 * @tc.type: FUNC
221 */
222 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_010, TestSize.Level1)
223 {
224 DataAbilityPredicates *predicates = new DataAbilityPredicates();
225 std::vector<std::string> group = { "salary" };
226 predicates->GreaterThan("age", "20")->OrderByAsc("age")->GroupBy(group)->Limit(3)->Offset(1);
227
228 OHOS::Parcel outParcel(0);
229 OHOS::Parcel &coutParcel = outParcel;
230 bool isMarshalling = predicates->Marshalling(coutParcel);
231 EXPECT_EQ(true, isMarshalling);
232
233 EXPECT_EQ(false, outParcel.ReadBool());
234 std::string whereClause = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
235 EXPECT_EQ(whereClause, predicates->GetWhereClause());
236 std::vector<std::string> whereArgs;
237 if (outParcel.ReadInt32() != g_invalidObjectFlag) {
238 outParcel.ReadStringVector(&whereArgs);
239 }
240 EXPECT_EQ(whereArgs, predicates->GetWhereArgs());
241 bool isDistinct = outParcel.ReadBool();
242 EXPECT_EQ(false, isDistinct);
243 std::string indexedBy = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
244 EXPECT_EQ("", indexedBy);
245 std::string groupBy = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
246 EXPECT_EQ(groupBy, predicates->GetGroup());
247 std::string order = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
248 EXPECT_EQ(order, predicates->GetOrder());
249 int limit = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadInt32() : AbsPredicates::INIT_LIMIT_VALUE;
250 EXPECT_EQ(true, predicates->GetLimit() == limit);
251 int offset = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadInt32()
252 : AbsPredicates::INIT_OFFSET_VALUE;
253 EXPECT_EQ(offset, predicates->GetOffset());
254
255 predicates->Unmarshalling(coutParcel);
256 EXPECT_EQ(true, OHOS::NativeRdb::DataAbilityPredicates::result);
257 OHOS::sptr<DataAbilityPredicates> newPredicates = new DataAbilityPredicates(&outParcel);
258
259 outParcel.FlushBuffer();
260 }
261
262 /* *
263 * @tc.name: DataAbilityPredicates_011
264 * @tc.desc: test DataAbilityPredicates Marshalling
265 * @tc.type: FUNC
266 */
267 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_011, TestSize.Level1)
268 {
269 DataAbilityPredicates *predicates = new DataAbilityPredicates();
270
271 OHOS::Parcel outParcel(0);
272 OHOS::Parcel &coutParcel = outParcel;
273 bool isMarshalling = predicates->Marshalling(coutParcel);
274 EXPECT_EQ(true, isMarshalling);
275
276 EXPECT_EQ(false, outParcel.ReadBool());
277 std::string whereClause = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
278 EXPECT_EQ(whereClause, predicates->GetWhereClause());
279
280 std::vector<std::string> whereArgs;
281 if (outParcel.ReadInt32() != g_invalidObjectFlag) {
282 outParcel.ReadStringVector(&whereArgs);
283 }
284 EXPECT_EQ(whereArgs, predicates->GetWhereArgs());
285 EXPECT_EQ(false, outParcel.ReadBool());
286 std::string indexedBy = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
287 EXPECT_EQ("", indexedBy);
288 std::string groupBy = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
289 EXPECT_EQ(groupBy, predicates->GetGroup());
290 std::string order = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
291 EXPECT_EQ(order, predicates->GetOrder());
292 int limit = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadInt32() : AbsPredicates::INIT_LIMIT_VALUE;
293 EXPECT_EQ(limit, predicates->GetLimit());
294 int offset = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadInt32()
295 : AbsPredicates::INIT_OFFSET_VALUE;
296 EXPECT_EQ(offset, predicates->GetOffset());
297
298 outParcel.FlushBuffer();
299 }
300
301 /* *
302 * @tc.name: DataAbilityPredicates_012
303 * @tc.desc: test DataAbilityPredicates Marshalling
304 * @tc.type: FUNC
305 */
306 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_012, TestSize.Level1)
307 {
308 OHOS::Parcel parcel(nullptr);
309 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesWriteNull;
310 bool result = parcel.WriteStrongParcelable(dataAbilityPredicatesWriteNull);
311 EXPECT_EQ(true, result);
312
313 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesWrite = new DataAbilityPredicates();
314
315 bool test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::HOLD_OBJECT);
316 EXPECT_EQ(false, test);
317 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::IPC);
318 EXPECT_EQ(false, test);
319 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::RPC);
320 EXPECT_EQ(false, test);
321
322 result = parcel.WriteStrongParcelable(dataAbilityPredicatesWrite);
323 EXPECT_EQ(true, result);
324
325 OHOS::sptr<DataAbilityPredicates> parcelableReadNull = parcel.ReadParcelable<DataAbilityPredicates>();
326 EXPECT_EQ(nullptr, parcelableReadNull);
327
328 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::HOLD_OBJECT);
329 EXPECT_EQ(true, test);
330 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::IPC);
331 EXPECT_EQ(false, test);
332 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::RPC);
333 EXPECT_EQ(false, test);
334
335 dataAbilityPredicatesWrite->ClearBehavior(OHOS::Parcelable::BehaviorFlag::HOLD_OBJECT);
336 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::HOLD_OBJECT);
337 EXPECT_EQ(false, test);
338 }
339
340 /* *
341 * @tc.name: DataAbilityPredicates_013
342 * @tc.desc: test DataAbilityPredicates Unmarshalling
343 * @tc.type: FUNC
344 */
345 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_013, TestSize.Level1)
346 {
347 DataAbilityPredicates *predicates = new DataAbilityPredicates();
348 OHOS::Parcel outParcel(0);
349 OHOS::Parcel &coutParcel = outParcel;
350 predicates->Unmarshalling(coutParcel);
351 EXPECT_EQ(true, OHOS::NativeRdb::DataAbilityPredicates::result);
352
353 outParcel.FlushBuffer();
354 }
355
356 /* *
357 * @tc.name: DataAbilityPredicates_014
358 * @tc.desc: test DataAbilityPredicates Unmarshalling
359 * @tc.type: FUNC
360 */
361 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_014, TestSize.Level1)
362 {
363 OHOS::Parcel parcel(nullptr);
364 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesWrite = new DataAbilityPredicates();
365 bool result = false;
366
367 result = parcel.WriteParcelable(dataAbilityPredicatesWrite);
368 EXPECT_EQ(true, result);
369 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetDataSize());
370
371 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesRead = parcel.ReadParcelable<DataAbilityPredicates>();
372 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetDataSize());
373 }
374
375 /* *
376 * @tc.name: DataAbilityPredicates_015
377 * @tc.desc: test DataAbilityPredicates Unmarshalling
378 * @tc.type: FUNC
379 */
380 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_015, TestSize.Level1)
381 {
382 OHOS::Parcel parcel(nullptr);
383
384 bool result = parcel.WriteParcelable(nullptr);
385 EXPECT_EQ(true, result);
386
387 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesRead = parcel.ReadParcelable<DataAbilityPredicates>();
388 EXPECT_EQ(nullptr, dataAbilityPredicatesRead);
389 }
390
391 /* *
392 * @tc.name: DataAbilityPredicates_016
393 * @tc.desc: test SetAttributes
394 * @tc.type: FUNC
395 */
396 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_016, TestSize.Level1)
397 {
398 OHOS::NativeRdb::AbsPredicates predicates;
399 bool isDistinct = true;
400 std::string index = "test";
401 std::string group = "test";
402 std::string order = "";
403 int limit = 1;
404 int offset = 0;
405 PredicatesUtils::SetAttributes(&predicates, isDistinct, index, group, order, limit, offset);
406 EXPECT_EQ(isDistinct, predicates.IsDistinct());
407 EXPECT_EQ(index, predicates.GetIndex());
408 EXPECT_EQ(group, predicates.GetGroup());
409 EXPECT_EQ(order, predicates.GetOrder());
410 EXPECT_EQ(limit, predicates.GetLimit());
411 EXPECT_EQ(offset, predicates.GetOffset());
412 }