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 #include "mock_message_parcel.h"
16 #include "iremote_object.h"
17 #include "message_parcel.h"
18 #include "window_manager_hilog.h"
19 namespace OHOS {
20 namespace {
21 bool g_setWriteBoolErrorFlag = false;
22 bool g_setWriteInt32ErrorFlag = false;
23 bool g_setWriteInt64ErrorFlag = false;
24 bool g_setWriteUint32ErrorFlag = false;
25 bool g_setWriteFloatErrorFlag = false;
26 bool g_setWriteString16ErrorFlag = false;
27 bool g_setWriteParcelableErrorFlag = false;
28 bool g_setWriteInterfaceTokenErrorFlag = false;
29 bool g_setReadUint32ErrorFlag = false;
30 bool g_setReadInt32ErrorFlag = false;
31 bool g_setReadInt64ErrorFlag = false;
32 bool g_setReadStringVectorErrorFlag = false;
33 #ifdef ENABLE_MOCK_WRITE_STRING
34 const static std::string ERROR_FLAG = "error";
35 #endif
36 constexpr int32_t ERROR_INT = -1;
37 constexpr float ERROR_FLOAT = -1.0f;
38 #ifdef ENABLE_MOCK_WRITE_STRING_VECTOR
39 constexpr int32_t ERROR_SIZE = 1;
40 #endif
41 
42 } // namespace
43 namespace Rosen {
ClearAllErrorFlag()44 void MockMessageParcel::ClearAllErrorFlag()
45 {
46     g_setWriteBoolErrorFlag = false;
47     g_setWriteInt32ErrorFlag = false;
48     g_setWriteInt64ErrorFlag = false;
49     g_setWriteUint32ErrorFlag = false;
50     g_setWriteFloatErrorFlag = false;
51     g_setWriteString16ErrorFlag = false;
52     g_setWriteParcelableErrorFlag = false;
53     g_setWriteInterfaceTokenErrorFlag = false;
54     g_setReadUint32ErrorFlag = false;
55     g_setReadInt32ErrorFlag = false;
56     g_setReadInt64ErrorFlag = false;
57     g_setReadStringVectorErrorFlag = false;
58 }
59 
SetWriteBoolErrorFlag(bool flag)60 void MockMessageParcel::SetWriteBoolErrorFlag(bool flag)
61 {
62     g_setWriteBoolErrorFlag = flag;
63 }
64 
SetWriteInt32ErrorFlag(bool flag)65 void MockMessageParcel::SetWriteInt32ErrorFlag(bool flag)
66 {
67     g_setWriteInt32ErrorFlag = flag;
68 }
69 
SetWriteInt64ErrorFlag(bool flag)70 void MockMessageParcel::SetWriteInt64ErrorFlag(bool flag)
71 {
72     g_setWriteInt64ErrorFlag = flag;
73 }
74 
SetWriteUint32ErrorFlag(bool flag)75 void MockMessageParcel::SetWriteUint32ErrorFlag(bool flag)
76 {
77     g_setWriteUint32ErrorFlag = flag;
78 }
79 
SetWriteFloatErrorFlag(bool flag)80 void MockMessageParcel::SetWriteFloatErrorFlag(bool flag)
81 {
82     g_setWriteFloatErrorFlag = flag;
83 }
84 
SetWriteString16ErrorFlag(bool flag)85 void MockMessageParcel::SetWriteString16ErrorFlag(bool flag)
86 {
87     g_setWriteString16ErrorFlag = flag;
88 }
89 
SetWriteParcelableErrorFlag(bool flag)90 void MockMessageParcel::SetWriteParcelableErrorFlag(bool flag)
91 {
92     g_setWriteParcelableErrorFlag = flag;
93 }
94 
SetWriteInterfaceTokenErrorFlag(bool flag)95 void MockMessageParcel::SetWriteInterfaceTokenErrorFlag(bool flag)
96 {
97     g_setWriteInterfaceTokenErrorFlag = flag;
98 }
99 
SetReadUint32ErrorFlag(bool flag)100 void MockMessageParcel::SetReadUint32ErrorFlag(bool flag)
101 {
102     g_setReadUint32ErrorFlag = flag;
103 }
104 
SetReadInt32ErrorFlag(bool flag)105 void MockMessageParcel::SetReadInt32ErrorFlag(bool flag)
106 {
107     g_setReadInt32ErrorFlag = flag;
108 }
109 
SetReadInt64ErrorFlag(bool flag)110 void MockMessageParcel::SetReadInt64ErrorFlag(bool flag)
111 {
112     g_setReadInt64ErrorFlag = flag;
113 }
114 
SetReadStringVectorErrorFlag(bool flag)115 void MockMessageParcel::SetReadStringVectorErrorFlag(bool flag)
116 {
117     g_setReadStringVectorErrorFlag = flag;
118 }
119 }
120 
WriteInterfaceToken(std::u16string name)121 bool MessageParcel::WriteInterfaceToken(std::u16string name)
122 {
123     if (g_setWriteInterfaceTokenErrorFlag) {
124         return false;
125     }
126     return true;
127 }
128 
WriteParcelable(const Parcelable * object)129 bool Parcel::WriteParcelable(const Parcelable* object)
130 {
131     (void)object;
132     if (g_setWriteParcelableErrorFlag) {
133         return false;
134     }
135     return true;
136 }
137 
138 #ifdef ENABLE_MOCK_WRITE_STRING
WriteString(const std::string & value)139 bool Parcel::WriteString(const std::string& value)
140 {
141     (void)value;
142     if (value == ERROR_FLAG) {
143         return false;
144     }
145     return true;
146 }
147 #endif
148 
WriteBool(bool value)149 bool Parcel::WriteBool(bool value)
150 {
151     (void)value;
152     return !g_setWriteBoolErrorFlag;
153 }
154 
WriteInt32(int32_t value)155 bool Parcel::WriteInt32(int32_t value)
156 {
157     (void)value;
158     if (g_setWriteInt32ErrorFlag || value == ERROR_INT) {
159         return false;
160     }
161     return true;
162 }
163 
WriteInt64(int64_t value)164 bool Parcel::WriteInt64(int64_t value)
165 {
166     (void)value;
167     if (g_setWriteInt64ErrorFlag || value == ERROR_INT) {
168         return false;
169     }
170     return true;
171 }
172 
WriteUint32(uint32_t value)173 bool Parcel::WriteUint32(uint32_t value)
174 {
175     (void)value;
176     if (g_setWriteUint32ErrorFlag) {
177         return false;
178     }
179     return true;
180 }
181 
WriteFloat(float value)182 bool Parcel::WriteFloat(float value)
183 {
184     (void)value;
185     if (g_setWriteFloatErrorFlag || value == ERROR_FLOAT) {
186         return false;
187     }
188     return true;
189 }
190 
WriteString16(const std::u16string & value)191 bool Parcel::WriteString16(const std::u16string& value)
192 {
193     (void)value;
194     return !g_setWriteString16ErrorFlag;
195 }
196 
197 #ifdef ENABLE_MOCK_READ_UINT32
ReadUint32(uint32_t & value)198 bool Parcel::ReadUint32(uint32_t& value)
199 {
200     if (g_setReadUint32ErrorFlag) {
201         return false;
202     }
203     return true;
204 }
205 #endif
206 
207 #ifdef ENABLE_MOCK_READ_INT32
ReadInt32(int32_t & value)208 bool Parcel::ReadInt32(int32_t& value)
209 {
210     if (g_setReadInt32ErrorFlag) {
211         return false;
212     }
213     return true;
214 }
215 #endif
216 
217 #ifdef ENABLE_MOCK_READ_INT64
ReadInt64(int64_t & value)218 bool Parcel::ReadInt64(int64_t& value)
219 {
220     if (g_setReadInt64ErrorFlag) {
221         return false;
222     }
223     return true;
224 }
225 #endif
226 
227 #ifdef ENABLE_MOCK_WRITE_STRING_VECTOR
WriteStringVector(const std::vector<std::string> & val)228 bool Parcel::WriteStringVector(const std::vector<std::string>& val)
229 {
230     (void)val;
231     if (val.size() == ERROR_SIZE) {
232         return false;
233     }
234     return true;
235 }
236 #endif
237 
ReadStringVector(std::vector<std::string> * val)238 bool Parcel::ReadStringVector(std::vector<std::string>* val)
239 {
240     if (g_setReadStringVectorErrorFlag) {
241         return false;
242     }
243     return true;
244 }
245 } // namespace OHOS
246