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