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