openharmony/communication_dsoftbus
1
0
Fork 0
mirror of https://gitee.com/openharmony/communication_dsoftbus synced 2025-02-19 18:51:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

add UT for connId callback manager and fix code check

Browse Source 
Signed-off-by: dcette <duanxinyang@huawei.com>
This commit is contained in:
dcette 2025-01-10 14:06:52 +08:00
parent d6384b3d29
commit defdb581ea
5 changed files with 295 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
core/authentication/src/auth_common.c
View File

@ -45,6 +45,11 @@ typedef struct {
void *param;
} EventRemoveInfo;
typedef struct {
AuthLinkType type;
bool (*compareConnInfo)(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash);
} CommpareByType;
static uint64_t g_uniqueId = 0;
static SoftBusMutex g_authLock;
static SoftBusHandler g_authHandler = { NULL, NULL, NULL };
@ -263,54 +268,81 @@ const char *GetAuthSideStr(bool isServer)
return isServer ? "server" : "client";
}
static bool CompareBrConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)
{
if (info2->type == AUTH_LINK_TYPE_BR &&
StrCmpIgnoreCase(info1->info.brInfo.brMac, info2->info.brInfo.brMac) == 0) {
return true;
}
return false;
}
static bool CompareWifiConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)
{
if (info2->type == AUTH_LINK_TYPE_WIFI && strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
return true;
}
return false;
}
static bool CompareBleConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)
{
bool isLinkble = (info2->type == AUTH_LINK_TYPE_BLE &&
(memcmp(info1->info.bleInfo.deviceIdHash, info2->info.bleInfo.deviceIdHash,
(cmpShortHash ? SHORT_HASH_LEN : UDID_HASH_LEN)) == 0 ||
StrCmpIgnoreCase(info1->info.bleInfo.bleMac, info2->info.bleInfo.bleMac) == 0));
return isLinkble;
}
static bool CompareP2pConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)
{
if (info2->type == AUTH_LINK_TYPE_P2P && info1->info.ipInfo.port == info2->info.ipInfo.port &&
strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
return true;
}
return false;
}
static bool CompareEnhancedP2pConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)
{
if (info2->type == AUTH_LINK_TYPE_ENHANCED_P2P && info1->info.ipInfo.port == info2->info.ipInfo.port &&
strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
return true;
}
return false;
}
static bool CompareSessionConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)
{
if (info2->type == AUTH_LINK_TYPE_SESSION &&
info1->info.sessionInfo.connId == info2->info.sessionInfo.connId &&
strcmp(info1->info.sessionInfo.udid, info2->info.sessionInfo.udid) == 0) {
return true;
}
return false;
}
static CommpareByType g_compareByType[] = {
{AUTH_LINK_TYPE_WIFI, CompareWifiConnInfo},
{AUTH_LINK_TYPE_BR, CompareBrConnInfo},
{AUTH_LINK_TYPE_BLE, CompareBleConnInfo},
{AUTH_LINK_TYPE_P2P, CompareP2pConnInfo},
{AUTH_LINK_TYPE_ENHANCED_P2P, CompareEnhancedP2pConnInfo},
{AUTH_LINK_TYPE_SESSION, CompareSessionConnInfo},
};
bool CompareConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)
{
CHECK_NULL_PTR_RETURN_VALUE(info1, false);
CHECK_NULL_PTR_RETURN_VALUE(info2, false);
bool isLinkble = false;
switch (info1->type) {
case AUTH_LINK_TYPE_WIFI:
if (info2->type == AUTH_LINK_TYPE_WIFI && strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
return true;
for (uint32_t i = 0; i < sizeof(g_compareByType) / sizeof(CommpareByType); i++) {
if (info1->type == g_compareByType[i].type) {
if (g_compareByType[i].compareConnInfo != NULL) {
return g_compareByType[i].compareConnInfo(info1, info2, cmpShortHash);
}
break;
case AUTH_LINK_TYPE_BR:
if (info2->type == AUTH_LINK_TYPE_BR &&
StrCmpIgnoreCase(info1->info.brInfo.brMac, info2->info.brInfo.brMac) == 0) {
return true;
}
break;
case AUTH_LINK_TYPE_BLE:
isLinkble = (info2->type == AUTH_LINK_TYPE_BLE &&
(memcmp(info1->info.bleInfo.deviceIdHash, info2->info.bleInfo.deviceIdHash,
(cmpShortHash ? SHORT_HASH_LEN : UDID_HASH_LEN)) == 0 ||
StrCmpIgnoreCase(info1->info.bleInfo.bleMac, info2->info.bleInfo.bleMac) == 0));
if (isLinkble) {
return true;
}
break;
case AUTH_LINK_TYPE_P2P:
if (info2->type == AUTH_LINK_TYPE_P2P && info1->info.ipInfo.port == info2->info.ipInfo.port &&
strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
return true;
}
break;
case AUTH_LINK_TYPE_ENHANCED_P2P:
if (info2->type == AUTH_LINK_TYPE_ENHANCED_P2P && info1->info.ipInfo.port == info2->info.ipInfo.port &&
strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
return true;
}
break;
case AUTH_LINK_TYPE_SESSION:
if (info2->type == AUTH_LINK_TYPE_SESSION &&
info1->info.sessionInfo.connId == info2->info.sessionInfo.connId &&
strcmp(info1->info.sessionInfo.udid, info2->info.sessionInfo.udid) == 0) {
return true;
}
break;
default:
return false;
}
}
AUTH_LOGE(AUTH_CONN, "link type not support, info1-type: %{public}d", info1->type);
return false;
}

4
core/bus_center/lnn/net_builder/src/lnn_connection_fsm.c
View File

@ -966,7 +966,9 @@ static void NotifyJoinExtResultProcess(LnnConnectionFsm *connFsm, int32_t retCod
if (!connFsm->isSession) {
return;
}
LnnNotifyStateForSession(connFsm->connInfo.nodeInfo->deviceInfo.deviceUdid, retCode);
if (connFsm->connInfo.nodeInfo != NULL) {
LnnNotifyStateForSession(connFsm->connInfo.nodeInfo->deviceInfo.deviceUdid, retCode);
}
}
static void CompleteJoinLNN(LnnConnectionFsm *connFsm, const char *networkId, int32_t retCode)

45
tests/core/bus_center/lnn/BUILD.gn
View File

@ -2596,11 +2596,56 @@ ohos_unittest("LNNCtrlLaneMockTest") {
}
}
ohos_unittest("LNNConnIdCbManagerTest") {
module_out_path = module_output_path
sources = [ "net_builder/src/lnn_connId_cb_manager_test.cpp" ]
include_dirs = [
"$dsoftbus_root_path/core/bus_center/lnn/net_builder/include",
"$dsoftbus_root_path/core/common/include",
"$dsoftbus_root_path/interfaces/kits/bus_center",
"$dsoftbus_root_path/interfaces/kits/common",
"$dsoftbus_root_path/core/adapter/bus_center/include",
"unittest/common/",
"$dsoftbus_root_path/interfaces/kits/discovery",
"$dsoftbus_root_path/tests/core/bus_center/lnn/net_builder/include",
]
deps = [
"$dsoftbus_dfx_path:softbus_dfx",
"$dsoftbus_root_path/adapter:softbus_adapter",
"$dsoftbus_root_path/core/common:softbus_utils",
"$dsoftbus_root_path/core/frame:softbus_server",
]
if (is_standard_system) {
external_deps = [
"cJSON:cjson",
"c_utils:utils",
"device_auth:deviceauth_sdk",
"dsoftbus:softbus_client",
"googletest:gmock",
"googletest:gtest_main",
"hilog:libhilog",
]
} else {
external_deps = [
"cJSON:cjson",
"c_utils:utils",
"dsoftbus:softbus_client",
"googletest:gmock",
"googletest:gtest_main",
"hilog:libhilog",
]
}
}
group("unittest") {
testonly = true
deps = [
":LNNBatteryInfoTest",
":LNNBtNetworkImplMockTest",
":LNNConnIdCbManagerTest",
":LNNConnectionFsmMockTest",
":LNNConnectionFsmTest",
":LNNCtrlLaneMockTest",

143
tests/core/bus_center/lnn/net_builder/src/lnn_connId_cb_manager_test.cpp Normal file
View File

@ -0,0 +1,143 @@
/*
* Copyright (c) 2025 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <securec.h>
#include "lnn_connId_callback_manager.h"
#include "softbus_common.h"
#include "softbus_error_code.h"
constexpr int32_t CHANNEL_ID = 2050;
constexpr int32_t CONNID_ID = 99;
constexpr int32_t CONNID_ID_TWO = 100;
constexpr int32_t CONNID_ID_ERROR = 0;
char g_peerUdud[] = "123456ABCDEF";
namespace OHOS {
using namespace testing::ext;
class LnnConnIdCbManagerTest : public testing::Test {
public:
LnnConnIdCbManagerTest()
{}
~LnnConnIdCbManagerTest()
{}
static void SetUpTestCase(void);
static void TearDownTestCase(void);
void SetUp();
void TearDown();
};
void LnnConnIdCbManagerTest::SetUpTestCase(void) { }
void LnnConnIdCbManagerTest::TearDownTestCase(void) { }
void LnnConnIdCbManagerTest::SetUp()
{
LnnInitConnIdCallbackManager();
}
void LnnConnIdCbManagerTest::TearDown()
{
LnnDeinitConnIdCallbackManager();
}
static void OnLnnServerJoinExtCb(const ConnectionAddr *addr, int32_t ret)
{
return;
}
static LnnServerJoinExtCallBack cb = {
.lnnServerJoinExtCallback = OnLnnServerJoinExtCb
};
/**
* @tc.name: LnnConnIdCbManagerTest001
* @tc.desc: AddConnIdCallbackInfoItem test.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LnnConnIdCbManagerTest, LnnConnIdCbManagerTest001, TestSize.Level1)
{
ConnectionAddr addr = { .type = CONNECTION_ADDR_SESSION, .info.session.channelId = CHANNEL_ID };
int32_t ret = AddConnIdCallbackInfoItem(&addr, &cb, CONNID_ID, g_peerUdud);
EXPECT_EQ(ret, SOFTBUS_OK);
ret = AddConnIdCallbackInfoItem(&addr, &cb, CONNID_ID_TWO, g_peerUdud);
EXPECT_EQ(ret, SOFTBUS_ALREADY_EXISTED);
ret = AddConnIdCallbackInfoItem(&addr, &cb, CONNID_ID_TWO, g_peerUdud);
EXPECT_EQ(ret, SOFTBUS_NETWORK_JOIN_LNN_START_ERR);
ret = AddConnIdCallbackInfoItem(nullptr, &cb, CONNID_ID_TWO, g_peerUdud);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
ret = AddConnIdCallbackInfoItem(&addr, &cb, CONNID_ID_TWO, nullptr);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
ret = AddConnIdCallbackInfoItem(&addr, nullptr, CONNID_ID_TWO, g_peerUdud);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
ret = AddConnIdCallbackInfoItem(&addr, &cb, CONNID_ID_ERROR, g_peerUdud);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
}
/**
* @tc.name: LnnConnIdCbManagerTest002
* @tc.desc: DelConnIdCallbackInfoItem test.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LnnConnIdCbManagerTest, LnnConnIdCbManagerTest002, TestSize.Level1)
{
int32_t ret = DelConnIdCallbackInfoItem(CONNID_ID);
EXPECT_EQ(ret, SOFTBUS_OK);
ret = DelConnIdCallbackInfoItem(CONNID_ID_ERROR);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
}
/**
* @tc.name: LnnConnIdCbManagerTest003
* @tc.desc: InvokeCallbackForJoinExt test.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LnnConnIdCbManagerTest, LnnConnIdCbManagerTest003, TestSize.Level1)
{
ConnectionAddr addr = { .type = CONNECTION_ADDR_SESSION, .info.session.channelId = CHANNEL_ID };
int32_t ret = AddConnIdCallbackInfoItem(&addr, &cb, CONNID_ID, g_peerUdud);
EXPECT_EQ(ret, SOFTBUS_OK);
EXPECT_NO_FATAL_FAILURE(InvokeCallbackForJoinExt(g_peerUdud, SOFTBUS_OK));
EXPECT_NO_FATAL_FAILURE(InvokeCallbackForJoinExt(nullptr, SOFTBUS_OK));
}
/**
* @tc.name: LnnConnIdCbManagerTest004
* @tc.desc: GetConnIdCbInfoByAddr test.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LnnConnIdCbManagerTest, LnnConnIdCbManagerTest004, TestSize.Level1)
{
ConnectionAddr addr = { .type = CONNECTION_ADDR_SESSION, .info.session.channelId = CHANNEL_ID };
ConnIdCbInfo connIdCbInfo;
(void)memset_s(&connIdCbInfo, sizeof(ConnIdCbInfo), 0, sizeof(ConnIdCbInfo));
int32_t ret = GetConnIdCbInfoByAddr(nullptr, &connIdCbInfo);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
ret = GetConnIdCbInfoByAddr(&addr, &connIdCbInfo);
EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
ret = AddConnIdCallbackInfoItem(&addr, &cb, CONNID_ID, g_peerUdud);
EXPECT_EQ(ret, SOFTBUS_OK);
ret = GetConnIdCbInfoByAddr(&addr, &connIdCbInfo);
EXPECT_EQ(ret, SOFTBUS_OK);
}
} // namespace OHOS

30
tests/core/bus_center/lnn/net_builder/src/lnn_net_builder_test.cpp
View File

@ -38,6 +38,7 @@ constexpr char PEERUID[MAX_ACCOUNT_HASH_LEN] = "021315ASD";
constexpr uint8_t MSG[] = "123456BNHFCF";
constexpr int64_t AUTH_ID = 10;
constexpr uint32_t REQUEST_ID = 10;
constexpr uint16_t CHANNEL_ID = 2050;
#define SOFTBUS_SUB_SYSTEM 203
#define SOFTBUS_AUTH_MODULE 3
@ -75,6 +76,11 @@ void LNNNetBuilderTest::TearDown()
LnnDeinitBusCenterEvent();
}
static void OnLnnServerJoinExtCb(const ConnectionAddr *addr, int32_t returnRet)
{
return;
}
/*
* @tc.name: LNN_NOTIFY_DISCOVERY_DEVICE_TEST_001
* @tc.desc: test LnnNotifyDiscoveryDevice
@ -283,6 +289,30 @@ HWTEST_F(LNNNetBuilderTest, LNN_SERVER_JOIN_TEST_001, TestSize.Level0)
EXPECT_TRUE(ret == SOFTBUS_MALLOC_ERR);
}
/*
* @tc.name: LNN_SERVER_JOIN_EXT_TEST_001
* @tc.desc: test LnnServerJoinExt
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNNetBuilderTest, LNN_SERVER_JOIN_EXT_TEST_001, TestSize.Level0)
{
ConnectionAddr addr = { .type = CONNECTION_ADDR_SESSION, .info.session.channelId = CHANNEL_ID };
LnnServerJoinExtCallBack cb = {
.lnnServerJoinExtCallback = OnLnnServerJoinExtCb
};
int32_t ret = LnnServerJoinExt(&addr, &cb);
EXPECT_TRUE(ret == SOFTBUS_NO_INIT);
ret = LnnInitNetBuilder();
EXPECT_TRUE(ret == SOFTBUS_OK);
ret = LnnServerJoinExt(&addr, &cb);
EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
ret = LnnServerJoinExt(nullptr, &cb);
EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
ret = LnnServerJoinExt(&addr, nullptr);
EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
}
/*
* @tc.name: FIND_REQUEST_ID_BY_ADDR_TEST_001
* @tc.desc: test FindRequestIdByAddr