openharmony/communication_dsoftbus
1
0
Fork 0
mirror of https://gitee.com/openharmony/communication_dsoftbus synced 2025-02-17 01:30:02 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

【传输】新增UT传输用例

Browse Source 
Signed-off-by: wangqilong2 <wangqilong2@huawei.com>
This commit is contained in:
wangqilong2 2022-12-02 19:49:52 +08:00
parent 48b5e1b3b5
commit a56f6f9fa1
4 changed files with 443 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
sdk/transmission/session/src/client_trans_message_service.c
View File

@ -24,6 +24,7 @@
#include "softbus_errcode.h"
#include "softbus_feature_config.h"
#include "softbus_log.h"
#include "softbus_adapter_mem.h"
int CheckSendLen(int32_t channelType, int32_t businessType, unsigned int len)
{
@ -173,10 +174,15 @@ int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], ui
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "SendFile no permission, ret = %d", ret);
return ret;
}
FileSchemaListener fileSchemaListener = {0};
if (CheckFileSchema(sessionId, &fileSchemaListener) == SOFTBUS_OK) {
if (SetSchemaCallback(fileSchemaListener.schema, sFileList, fileCnt) != SOFTBUS_OK) {
FileSchemaListener *fileSchemaListener = (FileSchemaListener*)SoftBusCalloc(sizeof(FileSchemaListener));
if (fileSchemaListener == NULL) {
return SOFTBUS_MALLOC_ERR;
}
if (CheckFileSchema(sessionId, fileSchemaListener) == SOFTBUS_OK) {
if (SetSchemaCallback(fileSchemaListener->schema, sFileList, fileCnt) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "set schema callback failed");
SoftBusFree(fileSchemaListener);
return SOFTBUS_ERR;
}
}
@ -185,21 +191,26 @@ int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], ui
int32_t type = CHANNEL_TYPE_BUTT;
bool isEnable = false;
if (ClientGetChannelBySessionId(sessionId, &channelId, &type, &isEnable) != SOFTBUS_OK) {
SoftBusFree(fileSchemaListener);
return SOFTBUS_TRANS_INVALID_SESSION_ID;
}
int32_t businessType = BUSINESS_TYPE_BUTT;
if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
SoftBusFree(fileSchemaListener);
return SOFTBUS_TRANS_INVALID_SESSION_ID;
}
if ((businessType != BUSINESS_TYPE_FILE) && (businessType != BUSINESS_TYPE_NOT_CARE)) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "BusinessType no match, exp: %d", businessType);
SoftBusFree(fileSchemaListener);
return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
}
if (isEnable != true) {
SoftBusFree(fileSchemaListener);
return SOFTBUS_TRANS_SESSION_NO_ENABLE;
}
SoftBusFree(fileSchemaListener);
return ClientTransChannelSendFile(channelId, type, sFileList, dFileList, fileCnt);
}

40
tests/sdk/transmission/session/BUILD.gn
View File

@ -114,6 +114,45 @@ ohos_unittest("TransClientSessionCallbackTest") {
}
}
ohos_unittest("TransClientMsgServiceTest") {
module_out_path = module_output_path
sources = [ "client_trans_message_service_test.cpp" ]
include_dirs = [
"$dsoftbus_root_path/core/common/include",
"$dsoftbus_root_path/core/frame/common/include",
"$dsoftbus_root_path/core/transmission/common/include",
"$dsoftbus_root_path/sdk/transmission/session/include",
"$dsoftbus_root_path/sdk/transmission/session/src",
"$dsoftbus_root_path/interfaces/inner_kits/transport",
"$dsoftbus_root_path/sdk/transmission/trans_channel/udp/file/include",
"$dsoftbus_root_path/sdk/transmission/trans_channel/manager/include",
"$dsoftbus_root_path/sdk/frame/common/include",
"$dsoftbus_root_path/tests/sdk/common/include",
"$dsoftbus_root_path/sdk/transmission/trans_channel/udp/common/include",
]
deps = [
"$dsoftbus_root_path/core/common:softbus_utils",
"$dsoftbus_root_path/core/frame:softbus_server",
"$dsoftbus_root_path/sdk:softbus_client",
"$dsoftbus_root_path/tests/sdk/common:softbus_access_token_test",
"//third_party/googletest:gtest_main",
]
if (is_standard_system) {
external_deps = [
"c_utils:utils",
"hiviewdfx_hilog_native:libhilog",
]
} else {
external_deps = [
"c_utils:utils",
"hilog:libhilog",
]
}
}
ohos_unittest("TransClientSessionTest") {
module_out_path = module_output_path
sources = [ "client_trans_session_test.cpp" ]
@ -158,6 +197,7 @@ ohos_unittest("TransClientSessionTest") {
group("unittest") {
testonly = true
deps = [
":TransClientMsgServiceTest",
":TransClientSessionCallbackTest",
":TransClientSessionManagerTest",
":TransClientSessionServiceTest",

343
tests/sdk/transmission/session/client_trans_message_service_test.cpp Normal file
View File

@ -0,0 +1,343 @@
/*
* Copyright (c) 2022 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 <securec.h>
#include <gtest/gtest.h>
#include "softbus_def.h"
#include "softbus_errcode.h"
#include "softbus_log.h"
#include "softbus_trans_def.h"
#include "softbus_json_utils.h"
#include "softbus_app_info.h"
#include "softbus_config_type.h"
#include "softbus_server_frame.h"
#include "softbus_adapter_mem.h"
#include "client_trans_message_service.h"
#include "client_trans_message_service.c"
#include "client_trans_session_manager.h"
#include "softbus_common.h"
#define TRANS_TEST_SESSION_ID 10
#define TRANS_TEST_CHANNEL_ID 1000
#define TRANS_TEST_FILE_ENCRYPT 10
#define TRANS_TEST_ALGORITHM 1
#define TRANS_TEST_CRC 1
#define TRANS_TEST_AUTH_DATA "test auth message data"
#define TRANS_TEST_MAX_MSG_LEN (1 * 1024)
#define TRANS_TEST_MAX_BYTES_LEN (2 * 1024)
#define TRANS_TEST_SEND_LEN 123
#define TRANS_TEST_FILE_COUNT 2
#define TRANS_TEST_INVALID_SEND_LEN (1024 * 1024)
using namespace testing::ext;
namespace OHOS {
const char *g_pkgName = "dms";
const char *g_sessionName = "ohos.distributedschedule.dms.test";
const char *g_sessionKey = "www.huaweitest.com";
const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
const char *g_groupId = "TEST_GROUP_ID";
static SessionAttribute g_sessionAttr = {
.dataType = TYPE_BYTES,
};
class TransClientMsgServiceTest : public testing::Test {
public:
TransClientMsgServiceTest()
{}
~TransClientMsgServiceTest()
{}
static void SetUpTestCase(void);
static void TearDownTestCase(void);
void SetUp() override
{}
void TearDown() override
{}
};
void TransClientMsgServiceTest::SetUpTestCase(void)
{
InitSoftBusServer();
int32_t ret = TransClientInit();
ASSERT_EQ(ret, SOFTBUS_OK);
}
void TransClientMsgServiceTest::TearDownTestCase(void)
{
}
static int OnSessionOpened(int sessionId, int result)
{
LOG_INFO("session opened,sesison id = %d\r\n", sessionId);
return SOFTBUS_OK;
}
static void OnSessionClosed(int sessionId)
{
LOG_INFO("session closed, session id = %d\r\n", sessionId);
}
static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
{
LOG_INFO("session bytes received, session id = %d\r\n", sessionId);
}
static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
{
LOG_INFO("session msg received, session id = %d\r\n", sessionId);
}
static void OnStreamReceived(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
{
LOG_INFO("session stream received, session id = %d\r\n", sessionId);
}
static void OnQosEvent(int sessionId, int eventId, int tvCount, const QosTv *tvList)
{
LOG_INFO("session Qos event emit, session id = %d\r\n", sessionId);
}
static ISessionListener g_sessionlistener = {
.OnSessionOpened = OnSessionOpened,
.OnSessionClosed = OnSessionClosed,
.OnBytesReceived = OnBytesReceived,
.OnMessageReceived = OnMessageReceived,
.OnStreamReceived = OnStreamReceived,
.OnQosEvent = OnQosEvent,
};
static void TestGenerateCommParam(SessionParam *sessionParam)
{
sessionParam->sessionName = g_sessionName;
sessionParam->peerSessionName = g_sessionName;
sessionParam->peerDeviceId = g_deviceId;
sessionParam->groupId = g_groupId;
sessionParam->attr = &g_sessionAttr;
}
static SessionInfo *TestGenerateSession(const SessionParam *param)
{
SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
if (session == NULL) {
return NULL;
}
if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK) {
SoftBusFree(session);
return NULL;
}
session->sessionId = TRANS_TEST_SESSION_ID;
session->channelId = TRANS_TEST_CHANNEL_ID;
session->channelType = CHANNEL_TYPE_BUTT;
session->isServer = false;
session->isEnable = false;
session->routeType = ROUTE_TYPE_ALL;
session->info.flag = TYPE_BYTES;
session->isEncrypt = true;
session->algorithm = TRANS_TEST_ALGORITHM;
session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
session->crc = TRANS_TEST_CRC;
return session;
}
static int32_t AddSessionServerAndSession(const char *sessionName, int32_t channelType, int32_t businessType,
bool isServer, bool isEnable)
{
SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
if (sessionParam == NULL) {
return SOFTBUS_ERR;
}
TestGenerateCommParam(sessionParam);
sessionParam->sessionName = sessionName;
int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, sessionName, &g_sessionlistener);
if (ret != SOFTBUS_OK) {
return SOFTBUS_ERR;
}
SessionInfo *session = TestGenerateSession(sessionParam);
if (session == NULL) {
return SOFTBUS_ERR;
}
session->channelType = (ChannelType)channelType;
session->businessType = (BusinessType)businessType;
session->isServer = isServer;
session->isEnable = isEnable;
ret = ClientAddNewSession(sessionName, session);
if (ret != SOFTBUS_OK) {
return SOFTBUS_ERR;
}
int32_t sessionId = 0;
ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, channelType, &sessionId);
if (ret != SOFTBUS_OK) {
return SOFTBUS_ERR;
}
SoftBusFree(sessionParam);
return sessionId;
}
static void DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)
{
int32_t ret = ClientDeleteSession(sessionId);
EXPECT_EQ(ret, SOFTBUS_OK);
ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
EXPECT_EQ(ret, SOFTBUS_OK);
}
/**
* @tc.name: TransClientMsgServiceTest01
* @tc.desc: Transmission sdk message service check send length with different parameters.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest01, TestSize.Level1)
{
int ret = CheckSendLen(CHANNEL_TYPE_BUTT, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_INVALID_SEND_LEN);
EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN);
EXPECT_EQ(ret, SOFTBUS_OK);
}
/**
* @tc.name: TransClientMsgServiceTest02
* @tc.desc: Transmission sdk message service send bytes with different parameters.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest02, TestSize.Level1)
{
int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, true);
ASSERT_GT(sessionId, 0);
int ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
DeleteSessionServerAndSession(g_sessionName, sessionId);
sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, true);
ASSERT_GT(sessionId, 0);
ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
EXPECT_EQ(ret, SOFTBUS_ERR);
DeleteSessionServerAndSession(g_sessionName, sessionId);
}
/**
* @tc.name: TransClientMsgServiceTest03
* @tc.desc: Transmission sdk message service send message with different parameters.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest03, TestSize.Level1)
{
int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, true);
ASSERT_GT(sessionId, 0);
int ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
DeleteSessionServerAndSession(g_sessionName, sessionId);
sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, true);
ASSERT_GT(sessionId, 0);
ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
DeleteSessionServerAndSession(g_sessionName, sessionId);
sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, true);
ASSERT_GT(sessionId, 0);
ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
EXPECT_EQ(ret, SOFTBUS_ERR);
DeleteSessionServerAndSession(g_sessionName, sessionId);
}
/**
* @tc.name: TransClientMsgServiceTest04
* @tc.desc: Transmission sdk message service send stream with different parameters.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest04, TestSize.Level1)
{
char dataBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
StreamData data = {
.buf = dataBuf,
.bufLen = TRANS_TEST_MAX_MSG_LEN
};
char extBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
StreamData ext = {
.buf = extBuf,
.bufLen = TRANS_TEST_MAX_MSG_LEN
};
StreamFrameInfo streamFrameInfo = {0};
int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, true);
ASSERT_GT(sessionId, 0);
int ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
EXPECT_EQ(ret, SOFTBUS_TRANS_STREAM_ONLY_UDP_CHANNEL);
DeleteSessionServerAndSession(g_sessionName, sessionId);
sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, false);
ASSERT_GT(sessionId, 0);
ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
DeleteSessionServerAndSession(g_sessionName, sessionId);
sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, true);
ASSERT_GT(sessionId, 0);
ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
DeleteSessionServerAndSession(g_sessionName, sessionId);
sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_STREAM, false, true);
ASSERT_GT(sessionId, 0);
ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
EXPECT_NE(ret, SOFTBUS_OK);
DeleteSessionServerAndSession(g_sessionName, sessionId);
}
/**
* @tc.name: TransClientMsgServiceTest05
* @tc.desc: Transmission sdk message service send file with different parameters.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest05, TestSize.Level1)
{
const char *sFileList[TRANS_TEST_FILE_COUNT] = {
"/DATA/LOCAL/X",
"/DATA/LOCAL/Y"
};
const char *dFileList[TRANS_TEST_FILE_COUNT] = {
"/DATA/LOCAL/X",
"/DATA/LOCAL/Y"
};
int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, true);
ASSERT_GT(sessionId, 0);
int ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
DeleteSessionServerAndSession(g_sessionName, sessionId);
sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, false);
ASSERT_GT(sessionId, 0);
ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
DeleteSessionServerAndSession(g_sessionName, sessionId);
sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, true);
ASSERT_GT(sessionId, 0);
ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
EXPECT_EQ(ret, SOFTBUS_TRANS_CHANNEL_TYPE_INVALID);
DeleteSessionServerAndSession(g_sessionName, sessionId);
}
}

47
tests/sdk/transmission/session/client_trans_session_manager_test.cpp
View File

@ -30,7 +30,7 @@
#define TRANS_TEST_UID 0
#define TRANS_TEST_INVALID_PID (-1)
#define TRANS_TEST_INVALID_UID (-1)
#define TRANS_TEST_CHANNEL_ID 12345
#define TRANS_TEST_CHANNEL_ID 1000
#define TRANS_TEST_INVALID_CHANNEL_ID (-1)
#define TRANS_TEST_INVALID_SESSION_ID (-1)
#define TRANS_TEST_FILE_ENCRYPT 10
@ -906,6 +906,51 @@ HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest28, TestSiz
EXPECT_EQ(ret, SOFTBUS_OK);
}
/**
* @tc.name: TransClientSessionDestoryTest01
* @tc.desc: Transmission sdk session manager destory session by network id.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientSessionManagerTest, TransClientSessionDestoryTest01, TestSize.Level1)
{
int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
ASSERT_EQ(ret, SOFTBUS_OK);
SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
ASSERT_TRUE(sessionParam != NULL);
memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
GenerateCommParam(sessionParam);
SessionInfo *session = GenerateSession(sessionParam);
ASSERT_TRUE(session != NULL);
session->channelId = TRANS_TEST_CHANNEL_ID;
session->channelType = CHANNEL_TYPE_UDP;
session->routeType = WIFI_STA;
ret = ClientAddNewSession(g_sessionName, session);
ASSERT_EQ(ret, SOFTBUS_OK);
sessionParam->peerDeviceId = g_networkId;
SessionInfo *newSession = GenerateSession(sessionParam);
ASSERT_TRUE(newSession != NULL);
newSession->channelId = TRANS_TEST_CHANNEL_ID + 1;
newSession->channelType = CHANNEL_TYPE_UDP;
newSession->routeType = WIFI_P2P;
ret = ClientAddNewSession(g_sessionName, newSession);
ASSERT_EQ(ret, SOFTBUS_OK);
ClientTransOnLinkDown(g_networkId, WIFI_STA);
int32_t sessionId = 0;
ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId);
EXPECT_EQ(ret, SOFTBUS_OK);
EXPECT_GT(sessionId, 0);
ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId);
EXPECT_EQ(ret, SOFTBUS_ERR);
ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
EXPECT_EQ(ret, SOFTBUS_ERR);
ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
EXPECT_EQ(ret, SOFTBUS_OK);
SoftBusFree(sessionParam);
}
/**
* @tc.name: TransClientSessionManagerTest29
* @tc.desc: Transmission sdk session manager add and delete server with invalid parameters no initialize.