1 /*
2 * Copyright (c) 2025 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 "sequenceable_test.h"
17
18 #include "ipc_skeleton.h"
19 #include "message_parcel.h"
20
21 #include "devicestatus_define.h"
22 #include "devicestatus_common.h"
23 #include "i_context.h"
24
25
26 namespace OHOS {
27 namespace Msdp {
28 namespace DeviceStatus {
29 using namespace testing::ext;
30 namespace {
31 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
32 } // namespace
33
SetUpTestCase()34 void SequencableTest::SetUpTestCase() {}
35
SetUp()36 void SequencableTest::SetUp() {}
TearDown()37 void SequencableTest::TearDown()
38 {
39 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
40 }
41
42 /**
43 * @tc.name: SequencableTest1
44 * @tc.desc: SequencableTest
45 * @tc.type: FUNC
46 * @tc.require:
47 */
48 HWTEST_F(SequencableTest, SequencableTest1, TestSize.Level1)
49 {
50 CALL_TEST_DEBUG;
51 PreviewStyle previewStyle;
52 PreviewAnimation previewAnimation;
53 Parcel parcel;
54 SequenceablePreviewAnimation sequenceablePreviewAnimation(previewStyle, previewAnimation);
55 bool ret = sequenceablePreviewAnimation.Marshalling(parcel);
56 EXPECT_TRUE(ret);
57 ASSERT_NO_FATAL_FAILURE(sequenceablePreviewAnimation.Unmarshalling(parcel));
58 }
59
60 /**
61 * @tc.name: SequencableTest2
62 * @tc.desc: SequencableTest
63 * @tc.type: FUNC
64 * @tc.require:
65 */
66 HWTEST_F(SequencableTest, SequencableTest2, TestSize.Level1)
67 {
68 CALL_TEST_DEBUG;
69 PreviewStyle previewStyle;
70 Parcel parcel;
71 SequenceablePreviewStyle sequenceablePreviewStyle(previewStyle);
72 bool ret = sequenceablePreviewStyle.Marshalling(parcel);
73 EXPECT_TRUE(ret);
74 ASSERT_NO_FATAL_FAILURE(sequenceablePreviewStyle.Unmarshalling(parcel));
75 }
76
77 /**
78 * @tc.name: SequencableTest3
79 * @tc.desc: SequencableTest
80 * @tc.type: FUNC
81 * @tc.require:
82 */
83 HWTEST_F(SequencableTest, SequencableTest3, TestSize.Level1)
84 {
85 CALL_TEST_DEBUG;
86 DragDropResult dropResult;
87 Parcel parcel;
88 SequenceableDragResult sequenceableDragResult(dropResult);
89 bool ret = sequenceableDragResult.Marshalling(parcel);
90 EXPECT_TRUE(ret);
91 ASSERT_NO_FATAL_FAILURE(sequenceableDragResult.Unmarshalling(parcel));
92 }
93
94 /**
95 * @tc.name: SequencableTest4
96 * @tc.desc: SequencableTest
97 * @tc.type: FUNC
98 * @tc.require:
99 */
100 HWTEST_F(SequencableTest, SequencableTest4, TestSize.Level1)
101 {
102 CALL_TEST_DEBUG;
103 bool visible = true;
104 bool isForce = true;
105 std::shared_ptr<Rosen::RSTransaction> rsTransaction = nullptr;
106 DragVisibleParam dragVisibleParam;
107 dragVisibleParam.visible = visible;
108 dragVisibleParam.isForce = isForce;
109 dragVisibleParam.rsTransaction = rsTransaction;
110 SequenceableDragVisible sequenceableDragVisible(dragVisibleParam);
111 Parcel parcel;
112 bool ret = sequenceableDragVisible.Marshalling(parcel);
113 EXPECT_TRUE(ret);
114 ASSERT_NO_FATAL_FAILURE(sequenceableDragVisible.Unmarshalling(parcel));
115 }
116
117 /**
118 * @tc.name: SequencableTest5
119 * @tc.desc: SequencableTest
120 * @tc.type: FUNC
121 * @tc.require:
122 */
123 HWTEST_F(SequencableTest, SequencableTest5, TestSize.Level1)
124 {
125 CALL_TEST_DEBUG;
126 std::shared_ptr<Rosen::RSTransaction> rsTransaction = nullptr;
127 Parcel parcel;
128 SequenceableRotateWindow sequenceableRotateWindow(rsTransaction);
129 bool ret = sequenceableRotateWindow.Marshalling(parcel);
130 EXPECT_FALSE(ret);
131 ASSERT_NO_FATAL_FAILURE(sequenceableRotateWindow.Unmarshalling(parcel));
132 }
133
134 /**
135 * @tc.name: SequencableTest6
136 * @tc.desc: SequencableTest
137 * @tc.type: FUNC
138 * @tc.require:
139 */
140 HWTEST_F(SequencableTest, SequencableTest6, TestSize.Level1)
141 {
142 CALL_TEST_DEBUG;
143 PreviewStyle previewStyle;
144 PreviewAnimation animation;
145 Parcel parcel;
146 SequenceablePreviewAnimation sequenceablePreviewAnimation(previewStyle, animation);
147 bool ret = sequenceablePreviewAnimation.Marshalling(parcel);
148 EXPECT_TRUE(ret);
149 ASSERT_NO_FATAL_FAILURE(sequenceablePreviewAnimation.Unmarshalling(parcel));
150 }
151
152 /**
153 * @tc.name: SequencableTest7
154 * @tc.desc: SequencableTest
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(SequencableTest, SequencableTest7, TestSize.Level1)
159 {
160 CALL_TEST_DEBUG;
161 Parcel parcel;
162 SequenceablePostureData postureData;
163 bool ret = postureData.Marshalling(parcel);
164 EXPECT_TRUE(ret);
165 ASSERT_NO_FATAL_FAILURE(postureData.Unmarshalling(parcel));
166 }
167
168 /**
169 * @tc.name: SequencableTest8
170 * @tc.desc: SequencableTest
171 * @tc.type: FUNC
172 * @tc.require:
173 */
174 HWTEST_F(SequencableTest, SequencableTest8, TestSize.Level1)
175 {
176 CALL_TEST_DEBUG;
177 Parcel parcel;
178 OnScreen::SequenceableContentOption option;
179 bool ret = option.Marshalling(parcel);
180 EXPECT_TRUE(ret);
181 ASSERT_NO_FATAL_FAILURE(option.Unmarshalling(parcel));
182 }
183
184 /**
185 * @tc.name: SequencableTest9
186 * @tc.desc: SequencableTest
187 * @tc.type: FUNC
188 * @tc.require:
189 */
190 HWTEST_F(SequencableTest, SequencableTest9, TestSize.Level1)
191 {
192 CALL_TEST_DEBUG;
193 Parcel parcel;
194 OnScreen::SequenceablePageContent pageContent;
195 OnScreen::Paragraph para;
196 pageContent.pageContent_.paragraphs.push_back(para);
197 bool ret = pageContent.Marshalling(parcel);
198 EXPECT_TRUE(ret);
199 ASSERT_NO_FATAL_FAILURE(pageContent.Unmarshalling(parcel));
200 }
201
202 /**
203 * @tc.name: SequencableTest10
204 * @tc.desc: SequencableTest
205 * @tc.type: FUNC
206 * @tc.require:
207 */
208 HWTEST_F(SequencableTest, SequencableTest10, TestSize.Level1)
209 {
210 CALL_TEST_DEBUG;
211 Parcel parcel;
212 OnScreen::SequenceableControlEvent event;
213 event.controlEvent_.eventType = OnScreen::EventType::SCROLL_TO_HOOK;
214 bool ret = event.Marshalling(parcel);
215 EXPECT_TRUE(ret);
216 ASSERT_NO_FATAL_FAILURE(event.Unmarshalling(parcel));
217 }
218
219 /**
220 * @tc.name: SequencableTest11
221 * @tc.desc: SequencableTest
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(SequencableTest, SequencableTest11, TestSize.Level1)
226 {
227 CALL_TEST_DEBUG;
228 Parcel parcel;
229 OnScreen::SequenceableControlEvent event;
230 event.controlEvent_.eventType = OnScreen::EventType::END;
231 bool ret = event.Marshalling(parcel);
232 EXPECT_FALSE(ret);
233 event.controlEvent_.eventType = OnScreen::EventType::UNKNOWN;
234 ret = event.Marshalling(parcel);
235 EXPECT_FALSE(ret);
236 }
237
238 /**
239 * @tc.name: SequencableTest12
240 * @tc.desc: SequencableTest
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(SequencableTest, SequencableTest12, TestSize.Level1)
245 {
246 CALL_TEST_DEBUG;
247 Parcel parcel;
248 OnScreen::SequenceablePageContent content;
249 content.pageContent_.scenario = OnScreen::Scenario::END;
250 bool ret = content.Marshalling(parcel);
251 EXPECT_FALSE(ret);
252 }
253
254 /**
255 * @tc.name: SequencableTest13
256 * @tc.desc: SequencableTest
257 * @tc.type: FUNC
258 * @tc.require:
259 */
260 HWTEST_F(SequencableTest, SequencableTest13, TestSize.Level1)
261 {
262 CALL_TEST_DEBUG;
263 Parcel parcel;
264 parcel.WriteInt32(0);
265 parcel.WriteInt64(0);
266 parcel.WriteInt32(static_cast<int32_t>(OnScreen::EventType::END) + 1);
267 parcel.WriteInt64(0);
268 OnScreen::SequenceableControlEvent event;
269 OnScreen::SequenceableControlEvent *eventPtr = event.Unmarshalling(parcel);
270 EXPECT_EQ(eventPtr, nullptr);
271 Parcel parcel1;
272 parcel1.WriteInt32(0);
273 parcel1.WriteInt64(0);
274 parcel1.WriteInt32(-1);
275 parcel1.WriteInt64(0);
276 eventPtr = event.Unmarshalling(parcel1);
277 EXPECT_EQ(eventPtr, nullptr);
278 }
279
280 /**
281 * @tc.name: SequencableTest14
282 * @tc.desc: SequencableTest
283 * @tc.type: FUNC
284 * @tc.require:
285 */
286 HWTEST_F(SequencableTest, SequencableTest14, TestSize.Level1)
287 {
288 CALL_TEST_DEBUG;
289 Parcel parcel;
290 OnScreen::SequenceablePageContent content;
291 std::string str;
292 parcel.WriteInt32(0);
293 parcel.WriteInt64(0);
294 parcel.WriteString(str);
295 parcel.WriteInt32(static_cast<int32_t>(OnScreen::Scenario::END) + 1);
296 parcel.WriteString(str);
297 parcel.WriteString(str);
298 parcel.WriteString(str);
299 parcel.WriteInt32(0);
300 OnScreen::SequenceablePageContent *contentPtr = content.Unmarshalling(parcel);
301 EXPECT_EQ(contentPtr, nullptr);
302 Parcel parcel1;
303 parcel1.WriteInt32(0);
304 parcel1.WriteInt64(0);
305 parcel1.WriteString(str);
306 parcel1.WriteInt32(-1);
307 parcel1.WriteString(str);
308 parcel1.WriteString(str);
309 parcel1.WriteString(str);
310 parcel1.WriteInt32(0);
311 contentPtr = content.Unmarshalling(parcel);
312 EXPECT_EQ(contentPtr, nullptr);
313 }
314 } // namespace DeviceStatus
315 } // namespace Msdp
316 } // namespace OHOS
317