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(-1, 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(-1, 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() : -1;
255 EXPECT_EQ(true, predicates->GetLimit() == limit);
256 int offset = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadInt32() : -1;
257 EXPECT_EQ(offset, predicates->GetOffset());
258
259 predicates->Unmarshalling(coutParcel);
260 EXPECT_EQ(true, OHOS::NativeRdb::DataAbilityPredicates::result);
261 OHOS::sptr<DataAbilityPredicates> newPredicates = new DataAbilityPredicates(&outParcel);
262
263 outParcel.FlushBuffer();
264 }
265
266 /* *
267 * @tc.name: DataAbilityPredicates_011
268 * @tc.desc: test DataAbilityPredicates Marshalling
269 * @tc.type: FUNC
270 * @tc.require: AR000FKD4F
271 */
272 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_011, TestSize.Level1)
273 {
274 DataAbilityPredicates *predicates = new DataAbilityPredicates();
275
276 OHOS::Parcel outParcel(0);
277 OHOS::Parcel &coutParcel = outParcel;
278 bool isMarshalling = predicates->Marshalling(coutParcel);
279 EXPECT_EQ(true, isMarshalling);
280
281 EXPECT_EQ(false, outParcel.ReadBool());
282 std::string whereClause = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
283 EXPECT_EQ(whereClause, predicates->GetWhereClause());
284
285 std::vector<std::string> whereArgs;
286 if (outParcel.ReadInt32() != g_invalidObjectFlag) {
287 outParcel.ReadStringVector(&whereArgs);
288 }
289 EXPECT_EQ(whereArgs, predicates->GetWhereArgs());
290 EXPECT_EQ(false, outParcel.ReadBool());
291 std::string indexedBy = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
292 EXPECT_EQ("", indexedBy);
293 std::string groupBy = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
294 EXPECT_EQ(groupBy, predicates->GetGroup());
295 std::string order = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadString() : "";
296 EXPECT_EQ(order, predicates->GetOrder());
297 int limit = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadInt32() : -1;
298 EXPECT_EQ(limit, predicates->GetLimit());
299 int offset = outParcel.ReadInt32() != g_invalidObjectFlag ? outParcel.ReadInt32() : -1;
300 EXPECT_EQ(offset, predicates->GetOffset());
301
302 outParcel.FlushBuffer();
303 }
304
305 /* *
306 * @tc.name: DataAbilityPredicates_012
307 * @tc.desc: test DataAbilityPredicates Marshalling
308 * @tc.type: FUNC
309 * @tc.require: AR000FKD4F
310 */
311 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_012, TestSize.Level1)
312 {
313 OHOS::Parcel parcel(nullptr);
314 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesWriteNull;
315 bool result = parcel.WriteStrongParcelable(dataAbilityPredicatesWriteNull);
316 EXPECT_EQ(true, result);
317
318 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesWrite = new DataAbilityPredicates();
319
320 bool test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::HOLD_OBJECT);
321 EXPECT_EQ(false, test);
322 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::IPC);
323 EXPECT_EQ(false, test);
324 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::RPC);
325 EXPECT_EQ(false, test);
326
327 result = parcel.WriteStrongParcelable(dataAbilityPredicatesWrite);
328 EXPECT_EQ(true, result);
329
330 OHOS::sptr<DataAbilityPredicates> parcelableReadNull = parcel.ReadParcelable<DataAbilityPredicates>();
331 EXPECT_EQ(nullptr, parcelableReadNull);
332
333 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::HOLD_OBJECT);
334 EXPECT_EQ(true, test);
335 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::IPC);
336 EXPECT_EQ(false, test);
337 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::RPC);
338 EXPECT_EQ(false, test);
339
340 dataAbilityPredicatesWrite->ClearBehavior(OHOS::Parcelable::BehaviorFlag::HOLD_OBJECT);
341 test = dataAbilityPredicatesWrite->TestBehavior(OHOS::Parcelable::BehaviorFlag::HOLD_OBJECT);
342 EXPECT_EQ(false, test);
343 }
344
345 /* *
346 * @tc.name: DataAbilityPredicates_013
347 * @tc.desc: test DataAbilityPredicates Unmarshalling
348 * @tc.type: FUNC
349 * @tc.require: AR000FKD4F
350 */
351 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_013, TestSize.Level1)
352 {
353 DataAbilityPredicates *predicates = new DataAbilityPredicates();
354 OHOS::Parcel outParcel(0);
355 OHOS::Parcel &coutParcel = outParcel;
356 predicates->Unmarshalling(coutParcel);
357 EXPECT_EQ(true, OHOS::NativeRdb::DataAbilityPredicates::result);
358
359 outParcel.FlushBuffer();
360 }
361
362 /* *
363 * @tc.name: DataAbilityPredicates_014
364 * @tc.desc: test DataAbilityPredicates Unmarshalling
365 * @tc.type: FUNC
366 * @tc.require: AR000FKD4F
367 */
368 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_014, TestSize.Level1)
369 {
370 OHOS::Parcel parcel(nullptr);
371 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesWrite = new DataAbilityPredicates();
372 bool result = false;
373
374 result = parcel.WriteParcelable(dataAbilityPredicatesWrite);
375 EXPECT_EQ(true, result);
376 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetDataSize());
377
378 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesRead = parcel.ReadParcelable<DataAbilityPredicates>();
379 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetDataSize());
380 }
381
382 /* *
383 * @tc.name: DataAbilityPredicates_015
384 * @tc.desc: test DataAbilityPredicates Unmarshalling
385 * @tc.type: FUNC
386 * @tc.require: AR000FKD4F
387 */
388 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_015, TestSize.Level1)
389 {
390 OHOS::Parcel parcel(nullptr);
391
392 bool result = parcel.WriteParcelable(nullptr);
393 EXPECT_EQ(true, result);
394
395 OHOS::sptr<DataAbilityPredicates> dataAbilityPredicatesRead = parcel.ReadParcelable<DataAbilityPredicates>();
396 EXPECT_EQ(nullptr, dataAbilityPredicatesRead);
397 }