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(12);
92     messageSixth.WriteString(helloWord);
93     messageSixth.WriteBool(true);
94     messageSixth.WriteBool(true);
95     messageSixth.WriteBool(true);
96     bool retSixth = faultData->ReadFromParcel(messageSixth);
97     EXPECT_EQ(true, retSixth);
98 }
99 
100 /**
101  * @tc.name: Unmarshalling_001
102  * @tc.desc: Verify that the Unmarshalling interface calls normally
103  * @tc.type: FUNC
104  */
105 HWTEST_F(FaultDataTest, Unmarshalling_001, TestSize.Level1)
106 {
107     auto faultData = std::make_shared<FaultData>();
108     MessageParcel message;
109     auto retFirst = faultData->Unmarshalling(message);
110     EXPECT_EQ(nullptr, retFirst);
111 
112     std::string helloWord = "HelloWord";
113     message.WriteString(helloWord);
114     message.WriteString(helloWord);
115     message.WriteString(helloWord);
116     message.WriteInt32(12);
117     message.WriteString(helloWord);
118     message.WriteBool(true);
119     message.WriteBool(true);
120     message.WriteBool(true);
121     auto retSecond = faultData->Unmarshalling(message);
122     EXPECT_NE(nullptr, retSecond);
123 }
124 
125 /**
126  * @tc.name: Marshalling_001
127  * @tc.desc: Verify that the Marshalling interface calls normally
128  * @tc.type: FUNC
129  */
130 HWTEST_F(FaultDataTest, Marshalling_001, TestSize.Level1)
131 {
132     auto faultData = std::make_shared<FaultData>();
133     faultData->errorObject.name = "1234";
134     faultData->errorObject.message = "5678";
135     faultData->errorObject.stack = "90";
136 
137     MessageParcel message;
138     bool ret = faultData->Marshalling(message);
139     EXPECT_EQ(true, ret);
140 }
141 
142 /**
143  * @tc.name: ReadFromParcel_002
144  * @tc.desc: Verify that the ReadFromParcel interface calls normally
145  * @tc.type: FUNC
146  */
147 HWTEST_F(FaultDataTest, ReadFromParcel_002, TestSize.Level1)
148 {
149     auto appFaultDataBySA = std::make_shared<AppFaultDataBySA>();
150     MessageParcel messageFirst;
151     bool retFirst = appFaultDataBySA->ReadFromParcel(messageFirst);
152     EXPECT_EQ(false, retFirst);
153 
154     MessageParcel messageSecond;
155     std::string helloWord = "HelloWord";
156     messageSecond.WriteString(helloWord);
157     bool retSecond = appFaultDataBySA->ReadFromParcel(messageSecond);
158     EXPECT_EQ(false, retSecond);
159 
160     MessageParcel messageThird;
161     messageThird.WriteString(helloWord);
162     messageThird.WriteString(helloWord);
163     bool retThird = appFaultDataBySA->ReadFromParcel(messageThird);
164     EXPECT_EQ(false, retThird);
165 
166     MessageParcel messageFourth;
167     messageFourth.WriteString(helloWord);
168     messageFourth.WriteString(helloWord);
169     messageFourth.WriteString(helloWord);
170     bool retFourth = appFaultDataBySA->ReadFromParcel(messageFourth);
171     EXPECT_EQ(false, retFourth);
172 
173     MessageParcel messageFifth;
174     messageFifth.WriteString(helloWord);
175     messageFifth.WriteString(helloWord);
176     messageFifth.WriteString(helloWord);
177     messageFifth.WriteInt32(12);
178     bool retFifth = appFaultDataBySA->ReadFromParcel(messageFifth);
179     EXPECT_EQ(false, retFifth);
180 
181     MessageParcel messageSixth;
182     messageSixth.WriteString(helloWord);
183     messageSixth.WriteString(helloWord);
184     messageSixth.WriteString(helloWord);
185     messageSixth.WriteInt32(12);
186     messageSixth.WriteInt32(34);
187     messageSixth.WriteString(helloWord);
188     messageSixth.WriteBool(true);
189     messageSixth.WriteBool(true);
190     messageSixth.WriteBool(true);
191     bool retSixth = appFaultDataBySA->ReadFromParcel(messageSixth);
192     EXPECT_EQ(true, retSixth);
193 }
194 
195 /**
196  * @tc.name: Unmarshalling_002
197  * @tc.desc: Verify that the Unmarshalling interface calls normally
198  * @tc.type: FUNC
199  */
200 HWTEST_F(FaultDataTest, Unmarshalling_002, TestSize.Level1)
201 {
202     auto appFaultDataBySA = std::make_shared<AppFaultDataBySA>();
203     MessageParcel message;
204     auto retFirst = appFaultDataBySA->Unmarshalling(message);
205     EXPECT_EQ(nullptr, retFirst);
206 
207     std::string helloWord = "HelloWord";
208     message.WriteString(helloWord);
209     message.WriteString(helloWord);
210     message.WriteString(helloWord);
211     message.WriteInt32(12);
212     message.WriteInt32(34);
213     message.WriteString(helloWord);
214     message.WriteBool(true);
215     message.WriteBool(true);
216     message.WriteBool(true);
217     auto retSecond = appFaultDataBySA->Unmarshalling(message);
218     EXPECT_NE(nullptr, retSecond);
219 }
220 
221 /**
222  * @tc.name: Marshalling_002
223  * @tc.desc: Verify that the Marshalling interface calls normally
224  * @tc.type: FUNC
225  */
226 HWTEST_F(FaultDataTest, Marshalling_002, TestSize.Level1)
227 {
228     auto appFaultDataBySA = std::make_shared<AppFaultDataBySA>();
229     appFaultDataBySA->errorObject.name = "1234";
230     appFaultDataBySA->errorObject.message = "5678";
231     appFaultDataBySA->errorObject.stack = "90";
232 
233     MessageParcel message;
234     bool ret = appFaultDataBySA->Marshalling(message);
235     EXPECT_EQ(true, ret);
236 }
237 } // namespace AppExecFwk
238 } // namespace OHOS
239