1 /*
2 * Copyright (c) 2023 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
18 #define private public
19 #include "fault_data.h"
20 #include "message_parcel.h"
21 #undef private
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace AppExecFwk {
28 class FaultDataTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34 };
35
SetUpTestCase(void)36 void FaultDataTest::SetUpTestCase(void)
37 {}
38
TearDownTestCase(void)39 void FaultDataTest::TearDownTestCase(void)
40 {}
41
SetUp()42 void FaultDataTest::SetUp()
43 {}
44
TearDown()45 void FaultDataTest::TearDown()
46 {}
47
48 /**
49 * @tc.name: ReadFromParcel_001
50 * @tc.desc: Verify that the ReadFromParcel interface calls normally
51 * @tc.type: FUNC
52 */
53 HWTEST_F(FaultDataTest, ReadFromParcel_001, TestSize.Level1)
54 {
55 auto faultData = std::make_shared<FaultData>();
56 MessageParcel messageFirst;
57 bool retFirst = faultData->ReadFromParcel(messageFirst);
58 EXPECT_EQ(false, retFirst);
59
60 MessageParcel messageSecond;
61 std::string helloWord = "HelloWord";
62 messageSecond.WriteString(helloWord);
63 bool retSecond = faultData->ReadFromParcel(messageSecond);
64 EXPECT_EQ(false, retSecond);
65
66 MessageParcel messageThird;
67 messageThird.WriteString(helloWord);
68 messageThird.WriteString(helloWord);
69 bool retThird = faultData->ReadFromParcel(messageThird);
70 EXPECT_EQ(false, retThird);
71
72 MessageParcel messageFourth;
73 messageFourth.WriteString(helloWord);
74 messageFourth.WriteString(helloWord);
75 messageFourth.WriteString(helloWord);
76 bool retFourth = faultData->ReadFromParcel(messageFourth);
77 EXPECT_EQ(false, retFourth);
78
79 MessageParcel messageFifth;
80 messageFifth.WriteString(helloWord);
81 messageFifth.WriteString(helloWord);
82 messageFifth.WriteString(helloWord);
83 messageFifth.WriteInt32(12);
84 bool retFifth = faultData->ReadFromParcel(messageFifth);
85 EXPECT_EQ(false, retFifth);
86
87 MessageParcel messageSixth;
88 messageSixth.WriteString(helloWord);
89 messageSixth.WriteString(helloWord);
90 messageSixth.WriteString(helloWord);
91 messageSixth.WriteInt32(1);
92 messageSixth.WriteString(helloWord);
93 messageSixth.WriteBool(true);
94 messageSixth.WriteBool(true);
95 messageSixth.WriteBool(true);
96 messageSixth.WriteBool(true);
97 messageSixth.WriteUint32(12);
98 messageSixth.WriteInt32(12);
99 messageSixth.WriteInt32(12);
100 messageSixth.WriteUint32(12);
101 messageSixth.WriteBool(true);
102 messageSixth.WriteString(helloWord);
103 messageSixth.WriteString(helloWord);
104 messageSixth.WriteString(helloWord);
105 bool retSixth = faultData->ReadFromParcel(messageSixth);
106 EXPECT_EQ(true, retSixth);
107 }
108
109 /**
110 * @tc.name: Unmarshalling_001
111 * @tc.desc: Verify that the Unmarshalling interface calls normally
112 * @tc.type: FUNC
113 */
114 HWTEST_F(FaultDataTest, Unmarshalling_001, TestSize.Level1)
115 {
116 auto faultData = std::make_shared<FaultData>();
117 MessageParcel message;
118 auto retFirst = faultData->Unmarshalling(message);
119 EXPECT_EQ(nullptr, retFirst);
120
121 std::string helloWord = "HelloWord";
122 message.WriteString(helloWord);
123 message.WriteString(helloWord);
124 message.WriteString(helloWord);
125 message.WriteInt32(1);
126 message.WriteString(helloWord);
127 message.WriteBool(true);
128 message.WriteBool(true);
129 message.WriteBool(true);
130 message.WriteBool(true);
131 message.WriteUint32(12);
132 message.WriteInt32(12);
133 message.WriteInt32(12);
134 message.WriteUint32(12);
135 message.WriteBool(true);
136 message.WriteString(helloWord);
137 message.WriteString(helloWord);
138 message.WriteString(helloWord);
139 auto retSecond = faultData->Unmarshalling(message);
140 EXPECT_NE(nullptr, retSecond);
141 }
142
143 /**
144 * @tc.name: Marshalling_001
145 * @tc.desc: Verify that the Marshalling interface calls normally
146 * @tc.type: FUNC
147 */
148 HWTEST_F(FaultDataTest, Marshalling_001, TestSize.Level1)
149 {
150 auto faultData = std::make_shared<FaultData>();
151 faultData->errorObject.name = "1234";
152 faultData->errorObject.message = "5678";
153 faultData->errorObject.stack = "90";
154
155 MessageParcel message;
156 bool ret = faultData->Marshalling(message);
157 EXPECT_EQ(true, ret);
158 }
159
160 /**
161 * @tc.name: ReadFromParcel_002
162 * @tc.desc: Verify that the ReadFromParcel interface calls normally
163 * @tc.type: FUNC
164 */
165 HWTEST_F(FaultDataTest, ReadFromParcel_002, TestSize.Level1)
166 {
167 auto appFaultDataBySA = std::make_shared<AppFaultDataBySA>();
168 MessageParcel messageFirst;
169 bool retFirst = appFaultDataBySA->ReadFromParcel(messageFirst);
170 EXPECT_EQ(false, retFirst);
171
172 MessageParcel messageSecond;
173 std::string helloWord = "HelloWord";
174 messageSecond.WriteString(helloWord);
175 bool retSecond = appFaultDataBySA->ReadFromParcel(messageSecond);
176 EXPECT_EQ(false, retSecond);
177
178 MessageParcel messageThird;
179 messageThird.WriteString(helloWord);
180 messageThird.WriteString(helloWord);
181 bool retThird = appFaultDataBySA->ReadFromParcel(messageThird);
182 EXPECT_EQ(false, retThird);
183
184 MessageParcel messageFourth;
185 messageFourth.WriteString(helloWord);
186 messageFourth.WriteString(helloWord);
187 messageFourth.WriteString(helloWord);
188 bool retFourth = appFaultDataBySA->ReadFromParcel(messageFourth);
189 EXPECT_EQ(false, retFourth);
190
191 MessageParcel messageFifth;
192 messageFifth.WriteString(helloWord);
193 messageFifth.WriteString(helloWord);
194 messageFifth.WriteString(helloWord);
195 messageFifth.WriteInt32(12);
196 bool retFifth = appFaultDataBySA->ReadFromParcel(messageFifth);
197 EXPECT_EQ(false, retFifth);
198
199 MessageParcel messageSixth;
200 messageSixth.WriteString(helloWord);
201 messageSixth.WriteString(helloWord);
202 messageSixth.WriteString(helloWord);
203 messageSixth.WriteInt32(1);
204 messageSixth.WriteInt32(1234);
205 messageSixth.WriteString(helloWord);
206 messageSixth.WriteBool(true);
207 messageSixth.WriteBool(true);
208 messageSixth.WriteBool(true);
209 messageSixth.WriteBool(true);
210 messageSixth.WriteUint32(12);
211 messageSixth.WriteInt32(12);
212 messageSixth.WriteBool(true);
213 messageSixth.WriteString(helloWord);
214 messageSixth.WriteString(helloWord);
215 messageSixth.WriteString(helloWord);
216 bool retSixth = appFaultDataBySA->ReadFromParcel(messageSixth);
217 EXPECT_EQ(true, retSixth);
218 }
219
220 /**
221 * @tc.name: Unmarshalling_002
222 * @tc.desc: Verify that the Unmarshalling interface calls normally
223 * @tc.type: FUNC
224 */
225 HWTEST_F(FaultDataTest, Unmarshalling_002, TestSize.Level1)
226 {
227 auto appFaultDataBySA = std::make_shared<AppFaultDataBySA>();
228 MessageParcel message;
229 auto retFirst = appFaultDataBySA->Unmarshalling(message);
230 EXPECT_EQ(nullptr, retFirst);
231
232 std::string helloWord = "HelloWord";
233 message.WriteString(helloWord);
234 message.WriteString(helloWord);
235 message.WriteString(helloWord);
236 message.WriteInt32(1);
237 message.WriteInt32(1234);
238 message.WriteString(helloWord);
239 message.WriteBool(true);
240 message.WriteBool(true);
241 message.WriteBool(true);
242 message.WriteBool(true);
243 message.WriteUint32(12);
244 message.WriteInt32(12);
245 message.WriteBool(true);
246 message.WriteString(helloWord);
247 message.WriteString(helloWord);
248 message.WriteString(helloWord);
249 auto retSecond = appFaultDataBySA->Unmarshalling(message);
250 EXPECT_NE(nullptr, retSecond);
251 }
252
253 /**
254 * @tc.name: Marshalling_002
255 * @tc.desc: Verify that the Marshalling interface calls normally
256 * @tc.type: FUNC
257 */
258 HWTEST_F(FaultDataTest, Marshalling_002, TestSize.Level1)
259 {
260 auto appFaultDataBySA = std::make_shared<AppFaultDataBySA>();
261 appFaultDataBySA->errorObject.name = "1234";
262 appFaultDataBySA->errorObject.message = "5678";
263 appFaultDataBySA->errorObject.stack = "90";
264
265 MessageParcel message;
266 bool ret = appFaultDataBySA->Marshalling(message);
267 EXPECT_EQ(true, ret);
268 }
269 } // namespace AppExecFwk
270 } // namespace OHOS
271