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