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