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_setWriteInt32ErrorFlag = false; 22 bool g_setWriteInt64ErrorFlag = false; 23 bool g_setWriteParcelableErrorFlag = false; 24 bool g_setWriteInterfaceTokenErrorFlag = false; 25 bool g_setReadInt32ErrorFlag = false; 26 bool g_setReadInt64ErrorFlag = false; 27 #ifdef ENABLE_MOCK_WRITE_STRING 28 const static std::string ERROR_FLAG = "error"; 29 #endif 30 constexpr int32_t ERROR_INT = -1; 31 #ifdef ENABLE_MOCK_WRITE_STRING_VECTOR 32 constexpr int32_t ERROR_SIZE = 1; 33 #endif 34 35 } // namespace 36 namespace Rosen { ClearAllErrorFlag()37void MockMessageParcel::ClearAllErrorFlag() 38 { 39 g_setWriteInt32ErrorFlag = false; 40 g_setWriteInt64ErrorFlag = false; 41 g_setWriteParcelableErrorFlag = false; 42 g_setWriteInterfaceTokenErrorFlag = false; 43 g_setReadInt32ErrorFlag = false; 44 g_setReadInt64ErrorFlag = false; 45 } 46 SetWriteInt32ErrorFlag(bool flag)47void MockMessageParcel::SetWriteInt32ErrorFlag(bool flag) 48 { 49 g_setWriteInt32ErrorFlag = flag; 50 } 51 SetWriteInt64ErrorFlag(bool flag)52void MockMessageParcel::SetWriteInt64ErrorFlag(bool flag) 53 { 54 g_setWriteInt64ErrorFlag = flag; 55 } 56 SetWriteParcelableErrorFlag(bool flag)57void MockMessageParcel::SetWriteParcelableErrorFlag(bool flag) 58 { 59 g_setWriteParcelableErrorFlag = flag; 60 } 61 SetWriteInterfaceTokenErrorFlag(bool flag)62void MockMessageParcel::SetWriteInterfaceTokenErrorFlag(bool flag) 63 { 64 g_setWriteInterfaceTokenErrorFlag = flag; 65 } 66 SetReadInt32ErrorFlag(bool flag)67void MockMessageParcel::SetReadInt32ErrorFlag(bool flag) 68 { 69 g_setReadInt32ErrorFlag = flag; 70 } 71 SetReadInt64ErrorFlag(bool flag)72void MockMessageParcel::SetReadInt64ErrorFlag(bool flag) 73 { 74 g_setReadInt64ErrorFlag = flag; 75 } 76 } 77 WriteInterfaceToken(std::u16string name)78bool MessageParcel::WriteInterfaceToken(std::u16string name) 79 { 80 if (g_setWriteInterfaceTokenErrorFlag) { 81 return false; 82 } 83 return true; 84 } 85 WriteParcelable(const Parcelable * object)86bool Parcel::WriteParcelable(const Parcelable* object) 87 { 88 (void)object; 89 if (g_setWriteParcelableErrorFlag) { 90 return false; 91 } 92 return true; 93 } 94 95 #ifdef ENABLE_MOCK_WRITE_STRING WriteString(const std::string & value)96bool Parcel::WriteString(const std::string& value) 97 { 98 (void)value; 99 if (value == ERROR_FLAG) { 100 return false; 101 } 102 return true; 103 } 104 #endif 105 WriteInt32(int32_t value)106bool Parcel::WriteInt32(int32_t value) 107 { 108 (void)value; 109 if (g_setWriteInt32ErrorFlag || value == ERROR_INT) { 110 return false; 111 } 112 return true; 113 } 114 WriteInt64(int64_t value)115bool Parcel::WriteInt64(int64_t value) 116 { 117 (void)value; 118 if (g_setWriteInt64ErrorFlag || value == ERROR_INT) { 119 return false; 120 } 121 return true; 122 } 123 124 #ifdef ENABLE_MOCK_READ_INT32 ReadInt32(int32_t & value)125bool Parcel::ReadInt32(int32_t &value) 126 { 127 if (g_setReadInt32ErrorFlag) { 128 return false; 129 } 130 return true; 131 } 132 #endif 133 134 #ifdef ENABLE_MOCK_READ_INT64 ReadInt64(int64_t & value)135bool Parcel::ReadInt64(int64_t &value) 136 { 137 if (g_setReadInt64ErrorFlag) { 138 return false; 139 } 140 return true; 141 } 142 #endif 143 144 #ifdef ENABLE_MOCK_WRITE_STRING_VECTOR WriteStringVector(const std::vector<std::string> & val)145bool Parcel::WriteStringVector(const std::vector<std::string>& val) 146 { 147 (void)val; 148 if (val.size() == ERROR_SIZE) { 149 return false; 150 } 151 return true; 152 } 153 #endif 154 } // namespace OHOS 155