1 /*
2 * Copyright (c) 2023-2025 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 "auth_common_mock.h"
17
18 using namespace testing;
19 using namespace testing::ext;
20
21 namespace OHOS {
22 void *g_commonInterface;
23 static const int32_t TEST_DATA_LEN = 200;
AuthCommonInterfaceMock()24 AuthCommonInterfaceMock::AuthCommonInterfaceMock()
25 {
26 g_commonInterface = reinterpret_cast<void *>(this);
27 }
28
~AuthCommonInterfaceMock()29 AuthCommonInterfaceMock::~AuthCommonInterfaceMock()
30 {
31 g_commonInterface = nullptr;
32 }
33
GetCommonInterface()34 static AuthCommonInterface *GetCommonInterface()
35 {
36 return reinterpret_cast<AuthCommonInterfaceMock *>(g_commonInterface);
37 }
38
39 extern "C" {
LnnAsyncCallbackDelayHelper(SoftBusLooper * looper,LnnAsyncCallbackFunc callback,void * para,uint64_t delayMillis)40 int32_t LnnAsyncCallbackDelayHelper(SoftBusLooper *looper, LnnAsyncCallbackFunc callback,
41 void *para, uint64_t delayMillis)
42 {
43 return GetCommonInterface()->LnnAsyncCallbackDelayHelper(looper, callback, para, delayMillis);
44 }
45
LnnGetRemoteNumU64Info(const char * networkId,InfoKey key,uint64_t * info)46 int32_t LnnGetRemoteNumU64Info(const char *networkId, InfoKey key, uint64_t *info)
47 {
48 return GetCommonInterface()->LnnGetRemoteNumU64Info(networkId, key, info);
49 }
50
LnnGetLocalNumU64Info(InfoKey key,uint64_t * info)51 int32_t LnnGetLocalNumU64Info(InfoKey key, uint64_t *info)
52 {
53 return GetCommonInterface()->LnnGetLocalNumU64Info(key, info);
54 }
55
SoftBusGetBtState(void)56 int32_t SoftBusGetBtState(void)
57 {
58 return GetCommonInterface()->SoftBusGetBtState();
59 }
60
SoftBusGetBrState(void)61 int32_t SoftBusGetBrState(void)
62 {
63 return GetCommonInterface()->SoftBusGetBrState();
64 }
65
LnnHbOnTrustedRelationReduced(void)66 void LnnHbOnTrustedRelationReduced(void)
67 {
68 return GetCommonInterface()->LnnHbOnTrustedRelationReduced();
69 }
70
LnnInsertSpecificTrustedDevInfo(const char * udid)71 int32_t LnnInsertSpecificTrustedDevInfo(const char *udid)
72 {
73 return GetCommonInterface()->LnnInsertSpecificTrustedDevInfo(udid);
74 }
75
LnnGetNetworkIdByUuid(const char * uuid,char * buf,uint32_t len)76 int32_t LnnGetNetworkIdByUuid(const char *uuid, char *buf, uint32_t len)
77 {
78 return GetCommonInterface()->LnnGetNetworkIdByUuid(uuid, buf, len);
79 }
80
LnnGetStaFrequency(const NodeInfo * info)81 int32_t LnnGetStaFrequency(const NodeInfo *info)
82 {
83 return GetCommonInterface()->LnnGetStaFrequency(info);
84 }
85
LnnEncryptAesGcm(AesGcmInputParam * in,int32_t keyIndex,uint8_t ** out,uint32_t * outLen)86 int32_t LnnEncryptAesGcm(AesGcmInputParam *in, int32_t keyIndex, uint8_t **out, uint32_t *outLen)
87 {
88 return GetCommonInterface()->LnnEncryptAesGcm(in, keyIndex, out, outLen);
89 }
90
LnnDecryptAesGcm(AesGcmInputParam * in,uint8_t ** out,uint32_t * outLen)91 int32_t LnnDecryptAesGcm(AesGcmInputParam *in, uint8_t **out, uint32_t *outLen)
92 {
93 return GetCommonInterface()->LnnDecryptAesGcm(in, out, outLen);
94 }
95
LnnGetTrustedDevInfoFromDb(char ** udidArray,uint32_t * num)96 int32_t LnnGetTrustedDevInfoFromDb(char **udidArray, uint32_t *num)
97 {
98 return GetCommonInterface()->LnnGetTrustedDevInfoFromDb(udidArray, num);
99 }
100
LnnGetAllOnlineNodeNum(int32_t * nodeNum)101 int32_t LnnGetAllOnlineNodeNum(int32_t *nodeNum)
102 {
103 return GetCommonInterface()->LnnGetAllOnlineNodeNum(nodeNum);
104 }
105
LnnSetLocalStrInfo(InfoKey key,const char * info)106 int32_t LnnSetLocalStrInfo(InfoKey key, const char *info)
107 {
108 return GetCommonInterface()->LnnSetLocalStrInfo(key, info);
109 }
110
LnnNotifyEmptySessionKey(int64_t authId)111 int32_t LnnNotifyEmptySessionKey(int64_t authId)
112 {
113 return GetCommonInterface()->LnnNotifyEmptySessionKey(authId);
114 }
115
LnnNotifyLeaveLnnByAuthHandle(AuthHandle * authHandle)116 int32_t LnnNotifyLeaveLnnByAuthHandle(AuthHandle *authHandle)
117 {
118 return GetCommonInterface()->LnnNotifyLeaveLnnByAuthHandle(authHandle);
119 }
120
LnnRequestLeaveSpecific(const char * networkId,ConnectionAddrType addrType)121 int32_t LnnRequestLeaveSpecific(const char *networkId, ConnectionAddrType addrType)
122 {
123 return GetCommonInterface()->LnnRequestLeaveSpecific(networkId, addrType);
124 }
125
SoftBusGetBtMacAddr(SoftBusBtAddr * mac)126 int32_t SoftBusGetBtMacAddr(SoftBusBtAddr *mac)
127 {
128 return GetCommonInterface()->SoftBusGetBtMacAddr(mac);
129 }
130
GetNodeFromPcRestrictMap(const char * udidHash,uint32_t * count)131 int32_t GetNodeFromPcRestrictMap(const char *udidHash, uint32_t *count)
132 {
133 return GetCommonInterface()->GetNodeFromPcRestrictMap(udidHash, count);
134 }
135
DeleteNodeFromPcRestrictMap(const char * udidHash)136 void DeleteNodeFromPcRestrictMap(const char *udidHash)
137 {
138 return GetCommonInterface()->DeleteNodeFromPcRestrictMap(udidHash);
139 }
140
AuthFailNotifyProofInfo(int32_t errCode,const char * errorReturn,uint32_t errorReturnLen)141 int32_t AuthFailNotifyProofInfo(int32_t errCode, const char *errorReturn, uint32_t errorReturnLen)
142 {
143 return GetCommonInterface()->AuthFailNotifyProofInfo(errCode, errorReturn, errorReturnLen);
144 }
145
LnnDeleteLinkFinderInfo(const char * peerUdid)146 void LnnDeleteLinkFinderInfo(const char *peerUdid)
147 {
148 return GetCommonInterface()->LnnDeleteLinkFinderInfo(peerUdid);
149 }
150
SoftBusGenerateStrHash(const unsigned char * str,uint32_t len,unsigned char * hash)151 int32_t SoftBusGenerateStrHash(const unsigned char *str, uint32_t len, unsigned char *hash)
152 {
153 return GetCommonInterface()->SoftBusGenerateStrHash(str, len, hash);
154 }
155
IdServiceIsPotentialTrustedDevice(const char * udidHash,const char * accountIdHash,bool isSameAccount)156 bool IdServiceIsPotentialTrustedDevice(const char *udidHash, const char *accountIdHash, bool isSameAccount)
157 {
158 return GetCommonInterface()->IdServiceIsPotentialTrustedDevice(udidHash, accountIdHash, isSameAccount);
159 }
160
ConnGetConnectionInfo(uint32_t connectionId,ConnectionInfo * info)161 int32_t ConnGetConnectionInfo(uint32_t connectionId, ConnectionInfo *info)
162 {
163 return GetCommonInterface()->ConnGetConnectionInfo(connectionId, info);
164 }
165
ConnSetConnectCallback(ConnModule moduleId,const ConnectCallback * callback)166 int32_t ConnSetConnectCallback(ConnModule moduleId, const ConnectCallback *callback)
167 {
168 return GetCommonInterface()->ConnSetConnectCallback(moduleId, callback);
169 }
170
ConnUnSetConnectCallback(ConnModule moduleId)171 void ConnUnSetConnectCallback(ConnModule moduleId)
172 {
173 GetCommonInterface()->ConnUnSetConnectCallback(moduleId);
174 }
175
ConnConnectDevice(const ConnectOption * option,uint32_t requestId,const ConnectResult * result)176 int32_t ConnConnectDevice(const ConnectOption *option, uint32_t requestId, const ConnectResult *result)
177 {
178 return GetCommonInterface()->ConnConnectDevice(option, requestId, result);
179 }
180
ConnDisconnectDevice(uint32_t connectionId)181 int32_t ConnDisconnectDevice(uint32_t connectionId)
182 {
183 return GetCommonInterface()->ConnDisconnectDevice(connectionId);
184 }
185
ConnGetHeadSize(void)186 uint32_t ConnGetHeadSize(void)
187 {
188 return GetCommonInterface()->ConnGetHeadSize();
189 }
190
ConnPostBytes(uint32_t connectionId,ConnPostData * data)191 int32_t ConnPostBytes(uint32_t connectionId, ConnPostData *data)
192 {
193 return GetCommonInterface()->ConnPostBytes(connectionId, data);
194 }
195
CheckActiveConnection(const ConnectOption * option,bool needOccupy)196 bool CheckActiveConnection(const ConnectOption *option, bool needOccupy)
197 {
198 return GetCommonInterface()->CheckActiveConnection(option, needOccupy);
199 }
200
ConnStartLocalListening(const LocalListenerInfo * info)201 int32_t ConnStartLocalListening(const LocalListenerInfo *info)
202 {
203 return GetCommonInterface()->ConnStartLocalListening(info);
204 }
205
ConnStopLocalListening(const LocalListenerInfo * info)206 int32_t ConnStopLocalListening(const LocalListenerInfo *info)
207 {
208 return GetCommonInterface()->ConnStopLocalListening(info);
209 }
210
ConnGetNewRequestId(ConnModule moduleId)211 uint32_t ConnGetNewRequestId(ConnModule moduleId)
212 {
213 return GetCommonInterface()->ConnGetNewRequestId(moduleId);
214 }
DiscDeviceInfoChanged(InfoTypeChanged type)215 void DiscDeviceInfoChanged(InfoTypeChanged type)
216 {
217 return GetCommonInterface()->DiscDeviceInfoChanged(type);
218 }
219
ConnUpdateConnection(uint32_t connectionId,UpdateOption * option)220 int32_t ConnUpdateConnection(uint32_t connectionId, UpdateOption *option)
221 {
222 return GetCommonInterface()->ConnUpdateConnection(connectionId, option);
223 }
224 }
225
ActionofConnSetConnectCallback(ConnModule moduleId,const ConnectCallback * callback)226 int32_t AuthCommonInterfaceMock::ActionofConnSetConnectCallback(ConnModule moduleId, const ConnectCallback *callback)
227 {
228 (void)moduleId;
229 if (callback == nullptr) {
230 return SOFTBUS_INVALID_PARAM;
231 }
232 g_conncallback.OnDataReceived = callback->OnDataReceived;
233 g_conncallback.OnConnected = callback->OnConnected;
234 g_conncallback.OnDisconnected = callback->OnDisconnected;
235 return SOFTBUS_OK;
236 }
237
ActionofOnConnectSuccessed(const ConnectOption * option,uint32_t requestId,const ConnectResult * result)238 int32_t AuthCommonInterfaceMock::ActionofOnConnectSuccessed(
239 const ConnectOption *option, uint32_t requestId, const ConnectResult *result)
240 {
241 (void)option;
242 uint32_t connectionId = 196619;
243 const ConnectionInfo info = {
244 .isAvailable = 1,
245 .isServer = 1,
246 .type = CONNECT_BR,
247 .brInfo.brMac = "11:22:33:44:55:66",
248 };
249 result->OnConnectSuccessed(requestId, connectionId, &info);
250 AUTH_LOGI(AUTH_TEST, "ActionofConnConnectDevice");
251 return SOFTBUS_OK;
252 }
253
ActionofOnConnectFailed(const ConnectOption * option,uint32_t requestId,const ConnectResult * result)254 int32_t AuthCommonInterfaceMock::AuthCommonInterfaceMock::ActionofOnConnectFailed(
255 const ConnectOption *option, uint32_t requestId, const ConnectResult *result)
256 {
257 int32_t reason = 0;
258 result->OnConnectFailed(requestId, reason);
259 AUTH_LOGI(AUTH_TEST, "ActionofOnConnectFailed");
260 return SOFTBUS_OK;
261 }
262
ActionofConnGetConnectionInfo(uint32_t connectionId,ConnectionInfo * info)263 int32_t AuthCommonInterfaceMock::ActionofConnGetConnectionInfo(uint32_t connectionId, ConnectionInfo *info)
264 {
265 (void)connectionId;
266 info->type = CONNECT_BLE;
267 info->isServer = SERVER_SIDE_FLAG;
268 info->isAvailable = 1;
269 strcpy_s(info->brInfo.brMac, sizeof(info->brInfo.brMac), "11:22:33:44:55:66");
270 return SOFTBUS_OK;
271 }
272
ActionofConnUnSetConnectCallback(ConnModule moduleId)273 void AuthCommonInterfaceMock::ActionofConnUnSetConnectCallback(ConnModule moduleId)
274 {
275 (void)moduleId;
276 }
277
ActionOfConnPostBytes(uint32_t connectionId,ConnPostData * data)278 int32_t AuthCommonInterfaceMock::ActionOfConnPostBytes(uint32_t connectionId, ConnPostData *data)
279 {
280 AUTH_LOGI(AUTH_TEST, "ActionOfConnPostBytes");
281 g_encryptData = data->buf;
282 if (strcpy_s(g_encryptData, TEST_DATA_LEN, data->buf) != SOFTBUS_OK) {
283 AUTH_LOGE(AUTH_TEST, "strcpy failed in conn post bytes");
284 return SOFTBUS_STRCPY_ERR;
285 }
286 return SOFTBUS_OK;
287 }
288 } // namespace OHOS