openharmony/xts_dcts
1
0
Fork 0
mirror of https://gitee.com/openharmony/xts_dcts synced 2024-10-06 21:33:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

【communication】dsoftbus软总线测试用例提交

Browse Source 
Signed-off-by: greada <kangqiao1@huawei.com>
This commit is contained in:
greada 2022-03-23 14:59:47 +08:00
parent 3a26dbc12e
commit fe385cd69e
8 changed files with 2106 additions and 2217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2886
communication/softbus_standard/common/net_trans_common.c
View File

File diff suppressed because it is too large Load Diff

357
communication/softbus_standard/common/net_trans_common.h
View File

@ -31,8 +31,7 @@
#include <unistd.h>
#ifdef __cplusplus
extern "C"
{
extern "C" {
#endif
#define DEF_GROUP_ID "DEF_GROUP_ID"
@ -115,174 +114,232 @@ extern "C"
#define CASE_9 9
#define CASE_10 10
const char *const def_ssid = "OpenHarmony_Private_Net_01";
const char *const slave_ssid = "OpenHarmony_Private_Net_02";
const char *const def_passwd = "OH2022@xa";
const int GROUP_ID_LEN = 4;
const int ONE_SECOND = 1;
const int TWO_SECOND = 2;
const int THEER_SECOND = 3;
const int FIVE_SECOND = 5;
const int TEN_SECOND = 10;
const char* const def_ssid = "OpenHarmony_Private_Net_01";
const char* const slave_ssid = "OpenHarmony_Private_Net_02";
const char* const def_passwd = "OH2022@xa";
const int GROUP_ID_LEN = 4;
const int ONE_SECOND = 1;
const int TWO_SECOND = 2;
const int THEER_SECOND = 3;
const int FIVE_SECOND = 5;
const int TEN_SECOND = 10;
typedef enum
{
SESSION_4DATA = 1,
SESSION_4CTL,
} WaitSessionType;
typedef enum {
SESSION_4DATA = 1,
SESSION_4CTL,
} WaitSessionType;
typedef enum
{
DATA_TYPE_MSG = 1,
DATA_TYPE_BYTE,
} DataType;
typedef enum {
DATA_TYPE_MSG = 1,
DATA_TYPE_BYTE,
} DataType;
typedef enum
{
STATE_ONLINE = 1,
STATE_OFFLINE,
} WaitNodeStateType;
typedef enum {
STATE_ONLINE = 1,
STATE_OFFLINE,
} WaitNodeStateType;
typedef enum
{
CONC_CLOSE_SESSION = 1,
CONC_LEAVE_NET,
CONC_DIS_NET_RECOVERY,
CONC_DIS_NET_NOT_RECOVERY,
CONC_DOWN_NET,
CONC_SEND_DATA_ONLY,
CONC_CLOSE_SESSION_REMOTE,
} ConcurrentType;
typedef enum {
CONC_CLOSE_SESSION = 1,
CONC_LEAVE_NET,
CONC_DIS_NET_RECOVERY,
CONC_DIS_NET_NOT_RECOVERY,
CONC_DOWN_NET,
CONC_SEND_DATA_ONLY,
CONC_CLOSE_SESSION_REMOTE,
} ConcurrentType;
typedef enum
{
CTRL_CODE_CLOSE_WIFI_TEN_SEC = 1,
CTRL_CODE_CLOSE_WIFI_TEN_MIN,
CTRL_CODE_CLOSE_WIFI_FIVE_MIN,
CTRL_CODE_CLOSE_WIFI_THREE_SEC,
CTRL_CODE_CHANGE_WIFI_TEN_SEC,
CTRL_CODE_CHANGE_WIFI_SIXTY_SEC,
CTRL_CODE_CHANGE_WIFI_LOOP20,
CTRL_CODE_CLOSE_WIFI_LOOP20,
CTRL_CODE_CHANGE_WIFI_LOOP100,
CTRL_CODE_CLOSE_WIFI_LOOP100,
CTRL_CODE_OPEN_SESSION,
CTRL_CODE_OPEN_SESSION_MSG,
CTRL_CODE_OPEN_SESSION_FAIL,
CTRL_CODE_OPEN_SESSION_NOT_EXIST,
CTRL_CODE_CLOSE_SESSION,
CTRL_CODE_CLOSE_BR,
CTRL_CODE_CLOSE_OPEN_BR,
CTRL_CODE_CLOSE_AIR,
CTRL_CODE_CLOSE_OPEN_AIR,
CTRL_CODE_SEND_BIG_DATA,
} CtrlCodeType;
typedef enum {
CTRL_CODE_CLOSE_WIFI_TEN_SEC = 1,
CTRL_CODE_CLOSE_WIFI_TEN_MIN,
CTRL_CODE_CLOSE_WIFI_FIVE_MIN,
CTRL_CODE_CLOSE_WIFI_THREE_SEC,
CTRL_CODE_CHANGE_WIFI_TEN_SEC,
CTRL_CODE_CHANGE_WIFI_SIXTY_SEC,
CTRL_CODE_CHANGE_WIFI_LOOP20,
CTRL_CODE_CLOSE_WIFI_LOOP20,
CTRL_CODE_CHANGE_WIFI_LOOP100,
CTRL_CODE_CLOSE_WIFI_LOOP100,
CTRL_CODE_OPEN_SESSION,
CTRL_CODE_OPEN_SESSION_MSG,
CTRL_CODE_OPEN_SESSION_FAIL,
CTRL_CODE_OPEN_SESSION_NOT_EXIST,
CTRL_CODE_CLOSE_SESSION,
CTRL_CODE_CLOSE_BR,
CTRL_CODE_CLOSE_OPEN_BR,
CTRL_CODE_CLOSE_AIR,
CTRL_CODE_CLOSE_OPEN_AIR,
CTRL_CODE_SEND_BIG_DATA,
} CtrlCodeType;
#define LOG(format, ...) \
do \
{ \
time_t timeSec; \
time(&timeSec); \
struct tm tmRst; \
localtime_r(&timeSec, &tmRst); \
char strTime[10]; \
strftime(strTime, sizeof(strTime), "%H:%M:%S", &tmRst); \
fprintf(stdout, "[Test-softbus] %s " format "\n", strTime, \
##__VA_ARGS__); \
} while (0)
#define LOG(format, ...) \
do { \
time_t timeSec; \
time(&timeSec); \
struct tm tmRst; \
localtime_r(&timeSec, &tmRst); \
char strTime[10]; \
strftime(strTime, sizeof(strTime), "%H:%M:%S", &tmRst); \
fprintf(stdout, "[Test-softbus] %s " format "\n", strTime, ##__VA_ARGS__); \
} while (0)
int Wait(int timeout);
int Wait4Session(int timeout, WaitSessionType type);
int WaitNodeCount(int timeout, WaitNodeStateType state, int expectCount);
int Wait(int timeout);
void TestSetUp(void);
void TestTearDown(void);
int Wait4Session(int timeout, WaitSessionType type);
int StartDiscoveryDevice(void);
int WaitNodeCount(int timeout, WaitNodeStateType state, int expectCount);
int JoinNetwork(void);
int LeaveNetWork(void);
int RegisterDeviceStateDefCallback(void);
int UnRegisterDeviceStateDefCallback(void);
int DiscoverAndJoinNetwork(void);
int CheckRemoteDeviceIsNull(int isSetNetId);
int GetRemoteDeviceNetId(char **netId);
int SetCurrentNetworkId(int index);
int SetRemoteDeviceNetIdToGarray(void);
void TestSetUp(void);
uint64_t GetCurrentTimeOfMs(void);
void TestTearDown(void);
void ResetWaitFlag(void);
void ResetWaitFlag4Data(void);
void ResetWaitFlag4Ctl(void);
void ResetWaitCount4Offline(void);
void ResetWaitCount4Online(void);
int StartDiscoveryDevice(void);
int SendData4Data(DataType type, int size);
int SendCtrlMsgToRemote(CtrlCodeType code);
int JoinNetwork(void);
int CreateSsAndOpenSession4Data(void);
int CreateSsAndOpenSession4Ctl(void);
int OpenSession4Ctl(void);
int OpenSession4Data(void);
int OpenSessionBatch4Data(char groupId[][GROUP_ID_LEN], int *sessionId,
int count);
int OpenSessionBatch4Ctl(char groupId[][GROUP_ID_LEN], int *sessionId,
int count);
int CloseSessionBatch4Data(int *sessionId, int count);
int CloseSessionBatch4Ctl(int *sessionId, int count);
void *OpenSessionTask4Data(void *param);
void *OpenSessionTask4Ctl(void *param);
int LeaveNetWork(void);
int OpenSession4Perf(void);
int OpenSession4PerfWithParam(const char *sessionName, const char *groupId,
char *netId);
int SendData4Perf(int sessionId, char *dataMsg, char *dataByte);
void SetTransStartTime(void);
int RegisterDeviceStateDefCallback(void);
void *SendDataTask1(void *param);
void *SendDataTask2(void *param);
void *SendDataTask3(void *param);
int UnRegisterDeviceStateDefCallback(void);
char *GetSoftbusPid(void);
char *GetNetworkId(void);
int GetCurrentSessionId4Data(void);
int GetCurrentSessionId4Ctl(void);
void SetCurrentSessionId4Data(int sessionId);
void SetCurrentSessionId4Ctl(int sessionId);
ISessionListener *GetSessionListenser4Data(void);
ISessionListener *GetSessionListenser4Ctl(void);
ISessionListener *GetSessionListenser4Pass(void);
ISessionListener *GetSessionListenser4Perf(void);
ISessionListener *GetSessionListenser4Proxy(void);
SessionAttribute *GetSessionAttr4Pass(void);
SessionAttribute *GetSessionAttr4Ctl(void);
SessionAttribute *GetSessionAttr4Data(void);
SessionAttribute *GetSessionAttr4Perf(void);
SessionAttribute *GetSessionAttr4Proxy(void);
IFileReceiveListener *GetRecvFileListener(void);
IFileSendListener *GetSendFileListener(void);
int DiscoverAndJoinNetwork(void);
pthread_barrier_t *GetThreadBarrier(void);
int GetThreadResult4Data(void);
int GetThreadResult4Ctl(void);
int *GetSid4Task2(void);
int *GetSid4Task3(void);
void ResetMsgStat4Control(void);
void ResetByteStat4Control(void);
ConnectionAddr *GetConnectAddr(void);
int CheckRemoteDeviceIsNull(int isSetNetId);
void ResetClosedSessionCount4Data(void);
void ResetClosedSessionCount4Ctrl(void);
int GetClosedSessionCount4Data(void);
int GetClosedSessionCount4Ctrl(void);
void ResetOpenSessionCount4Data(void);
void ResetOpenSessionCount4Ctrl(void);
int GetOpenSessionCount4Data(void);
int GetOpenSessionCount4Ctrl(void);
int GetRemoteDeviceNetId(char** netId);
int CloseSessionAndRemoveSs4Data(void);
int CloseSessionAndRemoveSs4Ctl(void);
int SetCurrentNetworkId(int index);
int SetRemoteDeviceNetIdToGarray(void);
uint64_t GetCurrentTimeOfMs(void);
void ResetWaitFlag(void);
void ResetWaitFlag4Data(void);
void ResetWaitFlag4Ctl(void);
void ResetWaitCount4Offline(void);
void ResetWaitCount4Online(void);
int SendData4Data(DataType type, int size);
int SendCtrlMsgToRemote(CtrlCodeType code);
int CreateSsAndOpenSession4Data(void);
int CreateSsAndOpenSession4Ctl(void);
int OpenSession4Ctl(void);
int OpenSession4Data(void);
int OpenSessionBatch4Data(char groupId[][GROUP_ID_LEN],
int* sessionId,
int count);
int OpenSessionBatch4Ctl(char groupId[][GROUP_ID_LEN],
int* sessionId,
int count);
int CloseSessionBatch4Data(int* sessionId, int count);
int CloseSessionBatch4Ctl(int* sessionId, int count);
void* OpenSessionTask4Data(void* param);
void* OpenSessionTask4Ctl(void* param);
int OpenSession4Perf(void);
int OpenSession4PerfWithParam(const char* sessionName,
const char* groupId,
char* netId);
int SendData4Perf(int sessionId, char* dataMsg, char* dataByte);
void SetTransStartTime(void);
void* SendDataTask1(void* param);
void* SendDataTask2(void* param);
void* SendDataTask3(void* param);
char* GetSoftbusPid(void);
char* GetNetworkId(void);
int GetCurrentSessionId4Data(void);
int GetCurrentSessionId4Ctl(void);
void SetCurrentSessionId4Data(int sessionId);
void SetCurrentSessionId4Ctl(int sessionId);
ISessionListener* GetSessionListenser4Data(void);
ISessionListener* GetSessionListenser4Ctl(void);
ISessionListener* GetSessionListenser4Pass(void);
ISessionListener* GetSessionListenser4Perf(void);
ISessionListener* GetSessionListenser4Proxy(void);
SessionAttribute* GetSessionAttr4Pass(void);
SessionAttribute* GetSessionAttr4Ctl(void);
SessionAttribute* GetSessionAttr4Data(void);
SessionAttribute* GetSessionAttr4Perf(void);
SessionAttribute* GetSessionAttr4Proxy(void);
IFileReceiveListener* GetRecvFileListener(void);
IFileSendListener* GetSendFileListener(void);
pthread_barrier_t* GetThreadBarrier(void);
int GetThreadResult4Data(void);
int GetThreadResult4Ctl(void);
int* GetSid4Task2(void);
int* GetSid4Task3(void);
void ResetMsgStat4Control(void);
void ResetByteStat4Control(void);
ConnectionAddr* GetConnectAddr(void);
void ResetClosedSessionCount4Data(void);
void ResetClosedSessionCount4Ctrl(void);
int GetClosedSessionCount4Data(void);
int GetClosedSessionCount4Ctrl(void);
void ResetOpenSessionCount4Data(void);
void ResetOpenSessionCount4Ctrl(void);
int GetOpenSessionCount4Data(void);
int GetOpenSessionCount4Ctrl(void);
int CloseSessionAndRemoveSs4Data(void);
int CloseSessionAndRemoveSs4Ctl(void);
#ifdef __cplusplus
}

82
communication/softbus_standard/common/softbus_test_permission.cpp
View File

@ -31,49 +31,49 @@ const static std::string TEST_DESCRIPTION = "test description";
const static int TEST_LABEL_ID = 9527;
const static int TEST_DESCRIPTION_ID = 9528;
void SoftBus_Test_Permission::AddPermission(const string &pkgName)
void SoftBus_Test_Permission::AddPermission(const string& pkgName)
{
std::vector<PermissionDef> permDefList;
PermissionDef permissionDefAlpha = {.permissionName = SYSTEM_APP_PERMISSION,
.bundleName = pkgName,
.grantMode = GrantMode::SYSTEM_GRANT,
.availableScope = AVAILABLE_SCOPE_ALL,
.label = TEST_LABEL,
.labelId = TEST_LABEL_ID,
.description = TEST_DESCRIPTION,
.descriptionId = TEST_DESCRIPTION_ID};
PermissionDef permissionDefBeta = {.permissionName = DANGER_APP_PERMISSION,
.bundleName = pkgName,
.grantMode = GrantMode::SYSTEM_GRANT,
.availableScope = AVAILABLE_SCOPE_ALL,
.label = TEST_LABEL,
.labelId = TEST_LABEL_ID,
.description = TEST_DESCRIPTION,
.descriptionId = TEST_DESCRIPTION_ID};
PermissionDef permissionDefGamma = {.permissionName = BIND_DISCOVER_SERVICE,
.bundleName = pkgName,
.grantMode = GrantMode::SYSTEM_GRANT,
.availableScope = AVAILABLE_SCOPE_ALL,
.label = TEST_LABEL,
.labelId = TEST_LABEL_ID,
.description = TEST_DESCRIPTION,
.descriptionId = TEST_DESCRIPTION_ID};
permDefList.emplace_back(permissionDefAlpha);
permDefList.emplace_back(permissionDefBeta);
permDefList.emplace_back(permissionDefGamma);
PermissionKit::AddDefPermissions(permDefList);
std::vector<std::string> permList;
permList.push_back(SYSTEM_APP_PERMISSION);
permList.push_back(DANGER_APP_PERMISSION);
permList.push_back(BIND_DISCOVER_SERVICE);
PermissionKit::AddSystemGrantedReqPermissions(pkgName, permList);
PermissionKit::GrantSystemGrantedPermission(pkgName, SYSTEM_APP_PERMISSION);
PermissionKit::GrantSystemGrantedPermission(pkgName, DANGER_APP_PERMISSION);
PermissionKit::GrantSystemGrantedPermission(pkgName, BIND_DISCOVER_SERVICE);
std::vector<PermissionDef> permDefList;
PermissionDef permissionDefAlpha = {.permissionName = SYSTEM_APP_PERMISSION,
.bundleName = pkgName,
.grantMode = GrantMode::SYSTEM_GRANT,
.availableScope = AVAILABLE_SCOPE_ALL,
.label = TEST_LABEL,
.labelId = TEST_LABEL_ID,
.description = TEST_DESCRIPTION,
.descriptionId = TEST_DESCRIPTION_ID};
PermissionDef permissionDefBeta = {.permissionName = DANGER_APP_PERMISSION,
.bundleName = pkgName,
.grantMode = GrantMode::SYSTEM_GRANT,
.availableScope = AVAILABLE_SCOPE_ALL,
.label = TEST_LABEL,
.labelId = TEST_LABEL_ID,
.description = TEST_DESCRIPTION,
.descriptionId = TEST_DESCRIPTION_ID};
PermissionDef permissionDefGamma = {.permissionName = BIND_DISCOVER_SERVICE,
.bundleName = pkgName,
.grantMode = GrantMode::SYSTEM_GRANT,
.availableScope = AVAILABLE_SCOPE_ALL,
.label = TEST_LABEL,
.labelId = TEST_LABEL_ID,
.description = TEST_DESCRIPTION,
.descriptionId = TEST_DESCRIPTION_ID};
permDefList.emplace_back(permissionDefAlpha);
permDefList.emplace_back(permissionDefBeta);
permDefList.emplace_back(permissionDefGamma);
PermissionKit::AddDefPermissions(permDefList);
std::vector<std::string> permList;
permList.push_back(SYSTEM_APP_PERMISSION);
permList.push_back(DANGER_APP_PERMISSION);
permList.push_back(BIND_DISCOVER_SERVICE);
PermissionKit::AddSystemGrantedReqPermissions(pkgName, permList);
PermissionKit::GrantSystemGrantedPermission(pkgName, SYSTEM_APP_PERMISSION);
PermissionKit::GrantSystemGrantedPermission(pkgName, DANGER_APP_PERMISSION);
PermissionKit::GrantSystemGrantedPermission(pkgName, BIND_DISCOVER_SERVICE);
}
void SoftBus_Test_Permission::RemovePermission(const string &pkgName)
void SoftBus_Test_Permission::RemovePermission(const string& pkgName)
{
PermissionKit::RemoveDefPermissions(pkgName);
PermissionKit::RemoveSystemGrantedReqPermissions(pkgName);
PermissionKit::RemoveDefPermissions(pkgName);
PermissionKit::RemoveSystemGrantedReqPermissions(pkgName);
}

9
communication/softbus_standard/common/softbus_test_permission.h
View File

@ -18,11 +18,10 @@
#include <string>
class SoftBus_Test_Permission
{
public:
static void AddPermission(const std::string &pkgName);
static void RemovePermission(const std::string &pkgName);
class SoftBus_Test_Permission {
public:
static void AddPermission(const std::string& pkgName);
static void RemovePermission(const std::string& pkgName);
};
#endif

537
communication/softbus_standard/common/wifi_utils.cpp
View File

@ -22,327 +22,270 @@ using namespace OHOS::Wifi;
const static int WIFI_SA_ID = 1125;
unique_ptr<WifiDevice> wifiDevicePtr = WifiDevice::GetInstance(WIFI_SA_ID);
int WiFiUtils::EnableWifi()
int WiFiUtils::EnableWifi()
{
bool isActive = false;
int ret = wifiDevicePtr->IsWifiActive(isActive);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call IsWifiActive fail, ret:%d", ret);
}
if (!isActive)
{
LOG("[wifi]not active, call enable...");
ret = wifiDevicePtr->EnableWifi();
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call EnableWifi fail, ret:%d", ret);
return SOFTBUS_ERR;
}
LOG("[wifi]call EnableWifi success, wait state active");
int timeout = 10;
do
{
ret = wifiDevicePtr->IsWifiActive(isActive);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call IsWifiActive fail, ret:%d", ret);
}
if (isActive)
{
LOG("[wifi]is active, timeout:%d", timeout);
break;
}
sleep(FIVE_SECOND);
timeout--;
} while (timeout > 0);
if (timeout <= 0)
{
LOG("[wifi]wait wifi state fail[timeout]");
return SOFTBUS_ERR;
}
else
{
LOG("[wifi]wait wifi state success");
return SOFTBUS_OK;
}
}
else
{
LOG("[wifi]is active, do nothing");
return SOFTBUS_OK;
}
}
int WiFiUtils::DisableWifi()
{
bool isActive = false;
int ret = wifiDevicePtr->IsWifiActive(isActive);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call IsWifiActive fail, ret:%d", ret);
}
if (isActive)
{
LOG("[wifi]is active, call disable...");
ret = wifiDevicePtr->DisableWifi();
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call DisableWifi fail, ret:%d", ret);
return SOFTBUS_ERR;
}
LOG("[wifi]call DisableWifi success, wait state active");
int timeout = 10;
do
{
ret = wifiDevicePtr->IsWifiActive(isActive);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call IsWifiActive fail, ret:%d", ret);
}
if (!isActive)
{
LOG("[wifi]not active, timeout:%d", timeout);
break;
}
sleep(ONE_SECOND);
timeout--;
} while (timeout > 0);
if (timeout <= 0)
{
LOG("[wifi]wait wifi state fail[timeout]");
return SOFTBUS_ERR;
}
else
{
LOG("[wifi]wait wifi state success");
return SOFTBUS_OK;
}
}
else
{
LOG("[wifi]not active, do nothing");
return SOFTBUS_OK;
}
}
int WiFiUtils::DisableThenEnable(int delaySeconds)
{
int ret = DisableWifi();
if (ret != SOFTBUS_OK)
{
LOG("[wifi]DisableWifi fail");
return ret;
}
sleep(delaySeconds);
ret = EnableWifi();
if (ret != SOFTBUS_OK)
{
LOG("[wifi]EnableWifi fail");
}
return ret;
}
int WiFiUtils::CheckIsConnectToDefault(void)
{
WifiLinkedInfo linkInfo;
int ret = wifiDevicePtr->GetLinkedInfo(linkInfo);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call GetLinkedInfo fail, ret:%d", ret);
}
else
{
char rstBuff[16];
struct in_addr inputAddr = {0};
inputAddr.s_addr = htonl(linkInfo.ipAddress);
inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
LOG("[wifi]link info,netid:%d, ssid:%s, state:%d, ip:%u,%s",
linkInfo.networkId, linkInfo.ssid.c_str(), linkInfo.connState,
linkInfo.ipAddress, rstBuff);
if (strncmp(linkInfo.ssid.c_str(), def_ssid, strlen(def_ssid)) == 0)
{
LOG("[wifi]check success");
return SOFTBUS_OK;
}
else
{
LOG("[wifi]check fail");
}
}
return SOFTBUS_ERR;
}
int WiFiUtils::ConnectTo(const std::string &ssid, const std::string &passwd)
{
WifiDeviceConfig deviceConfig;
deviceConfig.ssid = ssid;
deviceConfig.preSharedKey = passwd;
deviceConfig.keyMgmt = "WPA-PSK";
int netId;
int ret = wifiDevicePtr->AddDeviceConfig(deviceConfig, netId);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call AddDeviceConfig fail, ret:%d", ret);
}
else
{
LOG("[wifi]call AddDeviceConfig success, netId:%d", netId);
bool isActive = false;
int ret = wifiDevicePtr->IsWifiActive(isActive);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call IsWifiActive fail, ret:%d", ret);
}
if (!isActive) {
LOG("[wifi]not active, call enable...");
ret = wifiDevicePtr->EnableWifi();
if (ret != SOFTBUS_OK) {
LOG("[wifi]call EnableWifi fail, ret:%d", ret);
return SOFTBUS_ERR;
}
ret = wifiDevicePtr->ConnectToNetwork(netId);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call ConnectTo fail, ret:%d", ret);
return SOFTBUS_ERR;
}
else
{
LOG("[wifi]call ConnectTo success, netId:%d", netId);
}
LOG("[wifi]call EnableWifi success, wait state active");
int timeout = 10;
do {
ret = wifiDevicePtr->IsWifiActive(isActive);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call IsWifiActive fail, ret:%d", ret);
}
if (isActive) {
LOG("[wifi]is active, timeout:%d", timeout);
break;
}
sleep(FIVE_SECOND);
timeout--;
} while (timeout > 0);
if (timeout <= 0) {
LOG("[wifi]wait wifi state fail[timeout]");
return SOFTBUS_ERR;
} else {
LOG("[wifi]wait wifi state success");
return SOFTBUS_OK;
}
} else {
LOG("[wifi]is active, do nothing");
return SOFTBUS_OK;
}
}
int WiFiUtils::DisableWifi()
{
bool isActive = false;
int ret = wifiDevicePtr->IsWifiActive(isActive);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call IsWifiActive fail, ret:%d", ret);
}
if (isActive) {
LOG("[wifi]is active, call disable...");
ret = wifiDevicePtr->DisableWifi();
if (ret != SOFTBUS_OK) {
LOG("[wifi]call DisableWifi fail, ret:%d", ret);
return SOFTBUS_ERR;
}
LOG("[wifi]call DisableWifi success, wait state active");
int timeout = 10;
do {
ret = wifiDevicePtr->IsWifiActive(isActive);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call IsWifiActive fail, ret:%d", ret);
}
if (!isActive) {
LOG("[wifi]not active, timeout:%d", timeout);
break;
}
sleep(ONE_SECOND);
timeout--;
} while (timeout > 0);
if (timeout <= 0) {
LOG("[wifi]wait wifi state fail[timeout]");
return SOFTBUS_ERR;
} else {
LOG("[wifi]wait wifi state success");
return SOFTBUS_OK;
}
} else {
LOG("[wifi]not active, do nothing");
return SOFTBUS_OK;
}
}
int WiFiUtils::DisableThenEnable(int delaySeconds)
{
int ret = DisableWifi();
if (ret != SOFTBUS_OK) {
LOG("[wifi]DisableWifi fail");
return ret;
}
sleep(delaySeconds);
ret = EnableWifi();
if (ret != SOFTBUS_OK) {
LOG("[wifi]EnableWifi fail");
}
return ret;
}
int WiFiUtils::CheckIsConnectToDefault(void)
{
WifiLinkedInfo linkInfo;
int ret = wifiDevicePtr->GetLinkedInfo(linkInfo);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call GetLinkedInfo fail, ret:%d", ret);
} else {
char rstBuff[16];
WifiLinkedInfo linkInfo;
struct in_addr inputAddr = {0};
while (timeout > 0)
{
sleep(TWO_SECOND);
ret = wifiDevicePtr->GetLinkedInfo(linkInfo);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call GetLinkedInfo fail, ret:%d", ret);
}
else
{
LOG("[wifi]call GetLinkedInfo success, now state:%d",
linkInfo.connState);
if (linkInfo.connState == ConnState::CONNECTED &&
linkInfo.ipAddress != 0)
{
inputAddr.s_addr = htonl(linkInfo.ipAddress);
inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
LOG("[wifi]state OK,netid:%d, ssid:%s, state:%d, ip:%u,%s",
linkInfo.networkId, linkInfo.ssid.c_str(),
linkInfo.connState, linkInfo.ipAddress, rstBuff);
break;
}
}
timeout -= TWO_SECOND;
inputAddr.s_addr = htonl(linkInfo.ipAddress);
inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
LOG("[wifi]link info,netid:%d, ssid:%s, state:%d, ip:%u,%s",
linkInfo.networkId, linkInfo.ssid.c_str(), linkInfo.connState,
linkInfo.ipAddress, rstBuff);
if (strncmp(linkInfo.ssid.c_str(), def_ssid, strlen(def_ssid)) == 0) {
LOG("[wifi]check success");
return SOFTBUS_OK;
} else {
LOG("[wifi]check fail");
}
if (timeout == 0)
{
inputAddr.s_addr = htonl(linkInfo.ipAddress);
inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
LOG("[wifi]state(timeout=0),netid:%d, ssid:%s, state:%d, ip:%u,%s",
linkInfo.networkId, linkInfo.ssid.c_str(), linkInfo.connState,
linkInfo.ipAddress, rstBuff);
}
return SOFTBUS_OK;
}
return SOFTBUS_ERR;
}
int WiFiUtils::ConnectToNew(const std::string &ssid,
const std::string &passwd)
int WiFiUtils::ConnectTo(const std::string& ssid, const std::string& passwd)
{
int ret = wifiDevicePtr->Disconnect();
LOG("[wifi]call Disconnect ret:%d", ret);
ret = ConnectTo(ssid, passwd);
return ret;
}
WifiDeviceConfig deviceConfig;
deviceConfig.ssid = ssid;
deviceConfig.preSharedKey = passwd;
deviceConfig.keyMgmt = "WPA-PSK";
int netId;
int ret = wifiDevicePtr->AddDeviceConfig(deviceConfig, netId);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call AddDeviceConfig fail, ret:%d", ret);
} else {
LOG("[wifi]call AddDeviceConfig success, netId:%d", netId);
}
int WiFiUtils::ConnectToOpenAP(const std::string &ssid)
{
WifiDeviceConfig deviceConfig;
deviceConfig.ssid = ssid;
deviceConfig.keyMgmt = "NONE";
int netId;
int ret = wifiDevicePtr->AddDeviceConfig(deviceConfig, netId);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call AddDeviceConfig fail, ret:%d", ret);
}
else
{
LOG("[wifi]call AddDeviceConfig success, netId:%d", netId);
}
ret = wifiDevicePtr->ConnectToNetwork(netId);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call ConnectTo fail, ret:%d", ret);
return SOFTBUS_ERR;
}
else
{
LOG("[wifi]call ConnectTo success, netId:%d", netId);
}
sleep(FIVE_SECOND);
int state;
ret = wifiDevicePtr->GetWifiState(state);
LOG("[wifi]call GetWifiState ret:%d,state:%d", ret, state);
WifiLinkedInfo linkInfo;
ret = wifiDevicePtr->ConnectToNetwork(netId);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call ConnectTo fail, ret:%d", ret);
return SOFTBUS_ERR;
} else {
LOG("[wifi]call ConnectTo success, netId:%d", netId);
}
int timeout = 10;
char rstBuff[16];
WifiLinkedInfo linkInfo;
struct in_addr inputAddr = {0};
while (timeout > 0) {
sleep(TWO_SECOND);
ret = wifiDevicePtr->GetLinkedInfo(linkInfo);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]call GetLinkedInfo fail, ret:%d", ret);
}
else
{
LOG("[wifi]call GetLinkedInfo success");
char rstBuff[16];
struct in_addr inputAddr = {0};
if (ret != SOFTBUS_OK) {
LOG("[wifi]call GetLinkedInfo fail, ret:%d", ret);
} else {
LOG("[wifi]call GetLinkedInfo success, now state:%d", linkInfo.connState);
if (linkInfo.connState == ConnState::CONNECTED &&
linkInfo.ipAddress != 0) {
inputAddr.s_addr = htonl(linkInfo.ipAddress);
inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
LOG("[wifi]link info,netid:%d, ssid:%s, state:%d, ip:%u,%s",
LOG("[wifi]state OK,netid:%d, ssid:%s, state:%d, ip:%u,%s",
linkInfo.networkId, linkInfo.ssid.c_str(), linkInfo.connState,
linkInfo.ipAddress, rstBuff);
break;
}
}
return SOFTBUS_OK;
timeout -= TWO_SECOND;
}
if (timeout == 0) {
inputAddr.s_addr = htonl(linkInfo.ipAddress);
inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
LOG("[wifi]state(timeout=0),netid:%d, ssid:%s, state:%d, ip:%u,%s",
linkInfo.networkId, linkInfo.ssid.c_str(), linkInfo.connState,
linkInfo.ipAddress, rstBuff);
}
return SOFTBUS_OK;
}
int WiFiUtils::EnableThenConnect(const std::string &ssid,
const std::string &passwd)
int WiFiUtils::ConnectToNew(const std::string& ssid,
const std::string& passwd)
{
int ret = EnableWifi();
if (ret != SOFTBUS_OK)
{
LOG("[wifi]EnableWifi fail");
return ret;
}
ret = ConnectTo(ssid, passwd);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]ConnectTo fail");
}
int ret = wifiDevicePtr->Disconnect();
LOG("[wifi]call Disconnect ret:%d", ret);
ret = ConnectTo(ssid, passwd);
return ret;
}
int WiFiUtils::ConnectToOpenAP(const std::string& ssid)
{
WifiDeviceConfig deviceConfig;
deviceConfig.ssid = ssid;
deviceConfig.keyMgmt = "NONE";
int netId;
int ret = wifiDevicePtr->AddDeviceConfig(deviceConfig, netId);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call AddDeviceConfig fail, ret:%d", ret);
} else {
LOG("[wifi]call AddDeviceConfig success, netId:%d", netId);
}
ret = wifiDevicePtr->ConnectToNetwork(netId);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call ConnectTo fail, ret:%d", ret);
return SOFTBUS_ERR;
} else {
LOG("[wifi]call ConnectTo success, netId:%d", netId);
}
sleep(FIVE_SECOND);
int state;
ret = wifiDevicePtr->GetWifiState(state);
LOG("[wifi]call GetWifiState ret:%d,state:%d", ret, state);
WifiLinkedInfo linkInfo;
ret = wifiDevicePtr->GetLinkedInfo(linkInfo);
if (ret != SOFTBUS_OK) {
LOG("[wifi]call GetLinkedInfo fail, ret:%d", ret);
} else {
LOG("[wifi]call GetLinkedInfo success");
char rstBuff[16];
struct in_addr inputAddr = {0};
inputAddr.s_addr = htonl(linkInfo.ipAddress);
inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
LOG("[wifi]link info,netid:%d, ssid:%s, state:%d, ip:%u,%s",
linkInfo.networkId, linkInfo.ssid.c_str(), linkInfo.connState,
linkInfo.ipAddress, rstBuff);
}
return SOFTBUS_OK;
}
int WiFiUtils::EnableThenConnect(const std::string& ssid,
const std::string& passwd)
{
int ret = EnableWifi();
if (ret != SOFTBUS_OK) {
LOG("[wifi]EnableWifi fail");
return ret;
}
ret = ConnectTo(ssid, passwd);
if (ret != SOFTBUS_OK) {
LOG("[wifi]ConnectTo fail");
}
return ret;
}
int WiFiUtils::DisableThenEnableAndConnect(int delaySeconds,
const std::string &ssid,
const std::string &passwd)
const std::string& ssid,
const std::string& passwd)
{
int ret = DisableWifi();
if (ret != SOFTBUS_OK)
{
LOG("[wifi]DisableWifi fail");
return ret;
}
sleep(delaySeconds);
ret = EnableWifi();
if (ret != SOFTBUS_OK)
{
LOG("[wifi]EnableWifi fail");
return ret;
}
ret = ConnectTo(ssid, passwd);
if (ret != SOFTBUS_OK)
{
LOG("[wifi]ConnectTo fail");
}
int ret = DisableWifi();
if (ret != SOFTBUS_OK) {
LOG("[wifi]DisableWifi fail");
return ret;
}
sleep(delaySeconds);
ret = EnableWifi();
if (ret != SOFTBUS_OK) {
LOG("[wifi]EnableWifi fail");
return ret;
}
ret = ConnectTo(ssid, passwd);
if (ret != SOFTBUS_OK) {
LOG("[wifi]ConnectTo fail");
}
return ret;
}

29
communication/softbus_standard/common/wifi_utils.h
View File

@ -19,21 +19,20 @@
#include "net_trans_common.h"
#include "wifi_device.h"
class WiFiUtils
{
public:
static int EnableWifi();
static int DisableWifi();
static int DisableThenEnable(int delaySeconds);
static int ConnectTo(const std::string &ssid, const std::string &passwd);
static int ConnectToNew(const std::string &ssid, const std::string &passwd);
static int ConnectToOpenAP(const std::string &ssid);
static int EnableThenConnect(const std::string &ssid,
const std::string &passwd);
static int DisableThenEnableAndConnect(int delaySeconds,
const std::string &ssid,
const std::string &passwd);
static int CheckIsConnectToDefault(void);
class WiFiUtils {
public:
static int EnableWifi();
static int DisableWifi();
static int DisableThenEnable(int delaySeconds);
static int ConnectTo(const std::string& ssid, const std::string& passwd);
static int ConnectToNew(const std::string& ssid, const std::string& passwd);
static int ConnectToOpenAP(const std::string& ssid);
static int EnableThenConnect(const std::string& ssid,
const std::string& passwd);
static int DisableThenEnableAndConnect(int delaySeconds,
const std::string& ssid,
const std::string& passwd);
static int CheckIsConnectToDefault(void);
};
#endif

208
communication/softbus_standard/network/src/Net_Bindself_Func_Test.cpp Normal file
View File

@ -0,0 +1,208 @@
/*
* Copyright (c) 2021 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 "net_trans_common.h"
#include "softbus_test_permission.h"
#include "wifi_utils.h"
using namespace testing::ext;
class Net_Bindself_Func_Test : public testing::Test {
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
};
void Net_Bindself_Func_Test::SetUp() {}
void Net_Bindself_Func_Test::TearDown() {}
void Net_Bindself_Func_Test::SetUpTestCase()
{
LOG("[SetUp] begin");
TestSetUp();
SoftBus_Test_Permission::AddPermission(DEF_PKG_NAME);
int ret = RegisterDeviceStateDefCallback();
EXPECT_EQ(SOFTBUS_OK, ret) << "call reg node state callback fail";
LOG("[SetUp] end");
}
void Net_Bindself_Func_Test::TearDownTestCase()
{
int ret = UnRegisterDeviceStateDefCallback();
EXPECT_EQ(SOFTBUS_OK, ret) << "call unReg node state callback fail";
TestTearDown();
SoftBus_Test_Permission::RemovePermission(DEF_PKG_NAME);
}
static void WaitOnly(int seconds)
{
if (seconds < TEN_SECOND) {
sleep(seconds);
} else {
while (seconds > 0) {
sleep(TEN_SECOND);
seconds -= TEN_SECOND;
LOG("###wait:%d", seconds);
}
}
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0100
* @tc.name : get net id
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0100,
TestSize.Level3)
{
char* netId = NULL;
int count = GetRemoteDeviceNetId(&netId);
LOG("GetRemoteDeviceNetId count:%d", count);
if (count > 0) {
for (int i = 0; i < count; i++) {
LOG("GetRemoteDeviceNetId id:%s", *(&netId + i));
}
free(netId);
}
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0200
* @tc.name : discovery device
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0200,
TestSize.Level3)
{
int ret = StartDiscoveryDevice();
EXPECT_EQ(SOFTBUS_OK, ret) << "Discover fail";
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0300
* @tc.name : check node
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0300,
TestSize.Level3)
{
int ret = CheckRemoteDeviceIsNull(BOOL_FALSE);
EXPECT_EQ(SOFTBUS_OK, ret) << "check node fail";
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0400
* @tc.name : check node multi
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0400,
TestSize.Level3)
{
int nodeCount = SetRemoteDeviceNetIdToGarray();
LOG("######node count:%d", nodeCount);
EXPECT_TRUE(nodeCount >= DEF_REMOTE_DEV_COUNT)
<< "check node fail, count:" << nodeCount;
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0500
* @tc.name : check node and senddata
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0500,
TestSize.Level3)
{
int ret = CheckRemoteDeviceIsNull(BOOL_TRUE);
EXPECT_EQ(SOFTBUS_OK, ret) << "check node fail";
ret = CreateSsAndOpenSession4Ctl();
EXPECT_EQ(SOFTBUS_OK, ret) << "create Ss and openS[ctrl] fail";
ret = CreateSsAndOpenSession4Data();
EXPECT_EQ(SOFTBUS_OK, ret) << "create Ss and openS[data] fail";
int dataLen = 888;
int sessionId = GetCurrentSessionId4Ctl();
char* sendData = (char*)malloc(dataLen);
ASSERT_TRUE(sendData != NULL);
(void)memset_s(sendData, dataLen, 'C', dataLen);
ret = SendBytes(sessionId, sendData, dataLen);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendBytes[ctrl] fail";
ret = SendMessage(sessionId, sendData, dataLen);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendMessage[ctrl] fail";
ret = SendData4Data(DATA_TYPE_BYTE, dataLen);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendData4Data(byte) fail";
ret = SendData4Data(DATA_TYPE_MSG, dataLen);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendData4Data(msg) fail";
ret = CloseSessionAndRemoveSs4Data();
EXPECT_EQ(SOFTBUS_OK, ret) << "close and remove[data] fail";
ret = CloseSessionAndRemoveSs4Ctl();
EXPECT_EQ(SOFTBUS_OK, ret) << "close and remove[ctrl] fail";
free(sendData);
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0600
* @tc.name : jion network and leve network
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0600,
TestSize.Level2)
{
int ret;
int size = 1024;
ret = LeaveNetWork();
EXPECT_EQ(SOFTBUS_OK, ret) << "LeaveNetWork fail";
WaitOnly(10);
ret = JoinNetwork();
EXPECT_EQ(SOFTBUS_OK, ret) << "JoinNetwork fail";
ret = CreateSsAndOpenSession4Data();
ASSERT_EQ(SOFTBUS_OK, ret) << "create Ss and openS[data] fail";
ret = SendData4Data(DATA_TYPE_BYTE, size);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendData4Data(byte,1K) fail";
ret = CloseSessionAndRemoveSs4Data();
EXPECT_EQ(SOFTBUS_OK, ret) << "close session and remove Ss fail";
ret = LeaveNetWork();
EXPECT_EQ(SOFTBUS_OK, ret) << "LeaveNetWork fail";
WaitOnly(20);
ret = JoinNetwork();
EXPECT_EQ(SOFTBUS_OK, ret) << "JoinNetwork fail";
}

215
communication/softbus_standard/network/src/net_bindself_func_test.cpp
View File

@ -1,215 +0,0 @@
/*
* Copyright (c) 2021 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 "net_trans_common.h"
#include "softbus_test_permission.h"
#include "wifi_utils.h"
using namespace testing::ext;
class Net_Bindself_Func_Test : public testing::Test
{
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
};
void Net_Bindself_Func_Test::SetUp() {}
void Net_Bindself_Func_Test::TearDown() {}
void Net_Bindself_Func_Test::SetUpTestCase()
{
LOG("[SetUp] begin");
TestSetUp();
SoftBus_Test_Permission::AddPermission(DEF_PKG_NAME);
int ret = RegisterDeviceStateDefCallback();
EXPECT_EQ(SOFTBUS_OK, ret) << "call reg node state callback fail";
LOG("[SetUp] end");
}
void Net_Bindself_Func_Test::TearDownTestCase()
{
int ret = UnRegisterDeviceStateDefCallback();
EXPECT_EQ(SOFTBUS_OK, ret) << "call unReg node state callback fail";
TestTearDown();
SoftBus_Test_Permission::RemovePermission(DEF_PKG_NAME);
}
static void WaitOnly(int seconds)
{
if (seconds < TEN_SECOND)
{
sleep(seconds);
}
else
{
while (seconds > 0)
{
sleep(TEN_SECOND);
seconds -= TEN_SECOND;
LOG("###wait:%d", seconds);
}
}
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0100
* @tc.name : get net id
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0100,
TestSize.Level3)
{
char *netId = NULL;
int count = GetRemoteDeviceNetId(&netId);
LOG("GetRemoteDeviceNetId count:%d", count);
if (count > 0)
{
for (int i = 0; i < count; i++)
{
LOG("GetRemoteDeviceNetId id:%s", *(&netId + i));
}
free(netId);
}
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0200
* @tc.name : discovery device
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0200,
TestSize.Level3)
{
int ret = StartDiscoveryDevice();
EXPECT_EQ(SOFTBUS_OK, ret) << "Discover fail";
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0300
* @tc.name : check node
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0300,
TestSize.Level3)
{
int ret = CheckRemoteDeviceIsNull(BOOL_FALSE);
EXPECT_EQ(SOFTBUS_OK, ret) << "check node fail";
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0400
* @tc.name : check node multi
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0400,
TestSize.Level3)
{
int nodeCount = SetRemoteDeviceNetIdToGarray();
LOG("######node count:%d", nodeCount);
EXPECT_TRUE(nodeCount >= DEF_REMOTE_DEV_COUNT)
<< "check node fail, count:" << nodeCount;
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0500
* @tc.name : check node and senddata
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0500,
TestSize.Level3)
{
int ret = CheckRemoteDeviceIsNull(BOOL_TRUE);
EXPECT_EQ(SOFTBUS_OK, ret) << "check node fail";
ret = CreateSsAndOpenSession4Ctl();
EXPECT_EQ(SOFTBUS_OK, ret) << "create Ss and openS[ctrl] fail";
ret = CreateSsAndOpenSession4Data();
EXPECT_EQ(SOFTBUS_OK, ret) << "create Ss and openS[data] fail";
int dataLen = 888;
int sessionId = GetCurrentSessionId4Ctl();
char *sendData = (char *)malloc(dataLen);
ASSERT_TRUE(sendData != NULL);
(void)memset_s(sendData, dataLen, 'C', dataLen);
ret = SendBytes(sessionId, sendData, dataLen);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendBytes[ctrl] fail";
ret = SendMessage(sessionId, sendData, dataLen);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendMessage[ctrl] fail";
ret = SendData4Data(DATA_TYPE_BYTE, dataLen);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendData4Data(byte) fail";
ret = SendData4Data(DATA_TYPE_MSG, dataLen);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendData4Data(msg) fail";
ret = CloseSessionAndRemoveSs4Data();
EXPECT_EQ(SOFTBUS_OK, ret) << "close and remove[data] fail";
ret = CloseSessionAndRemoveSs4Ctl();
EXPECT_EQ(SOFTBUS_OK, ret) << "close and remove[ctrl] fail";
free(sendData);
}
/**
* @tc.number : SUB_Softbus_Net_Bind_Func_0600
* @tc.name : jion network and leve network
* @tc.desc : Test networking function
* @tc.type : FUNC
* @tc.size : MediumTest
*/
HWTEST_F(Net_Bindself_Func_Test,
SUB_Softbus_Net_Bind_Func_0600,
TestSize.Level2)
{
int ret;
int size = 1024;
ret = LeaveNetWork();
EXPECT_EQ(SOFTBUS_OK, ret) << "LeaveNetWork fail";
WaitOnly(10);
ret = JoinNetwork();
EXPECT_EQ(SOFTBUS_OK, ret) << "JoinNetwork fail";
ret = CreateSsAndOpenSession4Data();
ASSERT_EQ(SOFTBUS_OK, ret) << "create Ss and openS[data] fail";
ret = SendData4Data(DATA_TYPE_BYTE, size);
EXPECT_EQ(SOFTBUS_OK, ret) << "SendData4Data(byte,1K) fail";
ret = CloseSessionAndRemoveSs4Data();
EXPECT_EQ(SOFTBUS_OK, ret) << "close session and remove Ss fail";
ret = LeaveNetWork();
EXPECT_EQ(SOFTBUS_OK, ret) << "LeaveNetWork fail";
WaitOnly(20);
ret = JoinNetwork();
EXPECT_EQ(SOFTBUS_OK, ret) << "JoinNetwork fail";
}