1 /* 2 * Copyright (c) 2023 Shenzhen Kaihong Digital Industry Development 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 <gtest/gtest.h> 17 #include <iostream> 18 #include <sstream> 19 #include <unistd.h> 20 #include "common/sharing_log.h" 21 #include "network/interfaces/iclient_callback.h" 22 #include "network/interfaces/inetwork_session_callback.h" 23 #include "network/interfaces/iserver_callback.h" 24 #include "network/network_factory.h" 25 26 using namespace std; 27 using namespace OHOS::Sharing; 28 using namespace testing::ext; 29 30 namespace OHOS { 31 namespace Sharing { 32 33 class NetworkTcpUnitTest : public testing::Test { 34 public: SetUpTestCase()35 static void SetUpTestCase() {} TearDownTestCase()36 static void TearDownTestCase() {} SetUp()37 void SetUp() {} TearDown()38 void TearDown() {} 39 }; 40 41 class TcpTestAgent final : public IServerCallback, 42 public IClientCallback, 43 public INetworkSessionCallback, 44 public std::enable_shared_from_this<TcpTestAgent> { 45 public: TcpTestAgent()46 TcpTestAgent() {} 47 ~TcpTestAgent()48 ~TcpTestAgent() 49 { 50 if (serverPtr_) { 51 serverPtr_->Stop(); 52 } 53 } 54 StartTcpServer(uint16_t port)55 bool StartTcpServer(uint16_t port) 56 { 57 bool ret = NetworkFactory::CreateTcpServer(port, shared_from_this(), serverPtr_); 58 if (!ret) { 59 SHARING_LOGE("===[TcpTestAgent] StartTcpServer failed"); 60 } else { 61 SHARING_LOGD("===[TcpTestAgent] server agent started"); 62 } 63 return ret; 64 } 65 StartTcpClient(const std::string & peerIp,uint16_t port)66 bool StartTcpClient(const std::string &peerIp, uint16_t port) 67 { 68 bool ret = NetworkFactory::CreateTcpClient(peerIp, port, shared_from_this(), clientPtr_); 69 if (!ret) { 70 SHARING_LOGE("===[TcpTestAgent] StartTcpClient failed"); 71 } else { 72 SHARING_LOGD("===[TcpTestAgent] client agent started"); 73 } 74 return ret; 75 } 76 OnAccept(std::weak_ptr<INetworkSession> sessionPtr)77 void OnAccept(std::weak_ptr<INetworkSession> sessionPtr) override 78 { 79 SHARING_LOGD("===[TcpTestAgent] OnServerAccept"); 80 auto session = sessionPtr.lock(); 81 if (!session) { 82 return; 83 } 84 session->RegisterCallback(shared_from_this()); 85 session->Start(); 86 static int index = 0; 87 DataBuffer::Ptr buf = std::make_shared<DataBuffer>(); 88 const DataBuffer::Ptr &bufRefs = buf; 89 string msg = "tcp server accept send message=" + std::to_string(index++); 90 buf->PushData(msg.c_str(), msg.size()); 91 session->Send(bufRefs, bufRefs->Size()); 92 sessionPtrVec_.push_back(session); 93 } 94 OnServerReadData(int32_t fd,DataBuffer::Ptr buf,INetworkSession::Ptr session)95 void OnServerReadData(int32_t fd, DataBuffer::Ptr buf, INetworkSession::Ptr session) override 96 { 97 SHARING_LOGD("===[TcpTestAgent] OnServerReadData"); 98 static int index = 0; 99 DataBuffer::Ptr bufSend = std::make_shared<DataBuffer>(); 100 const DataBuffer::Ptr &bufRefs = bufSend; 101 string msg = "tcp server message.index=" + std::to_string(index++); 102 bufSend->PushData(msg.c_str(), msg.size()); 103 size_t nSize = sessionPtrVec_.size(); 104 for (size_t i = 0; i < nSize; i++) { 105 sessionPtrVec_[i]->Send(bufRefs, bufRefs->Size()); 106 sleep(2); 107 } 108 } 109 OnServerWriteable(int32_t fd)110 void OnServerWriteable(int32_t fd) override 111 { 112 SHARING_LOGD("onServerWriteable"); 113 } 114 OnServerClose(int32_t fd)115 void OnServerClose(int32_t fd) override 116 { 117 SHARING_LOGD("===[TcpTestAgent] OnServerClose"); 118 serverPtr_ = nullptr; 119 } 120 OnServerException(int32_t fd)121 void OnServerException(int32_t fd) override 122 { 123 SHARING_LOGD("===[TcpTestAgent] OnServerException"); 124 serverPtr_ = nullptr; 125 } 126 OnSessionReadData(int32_t fd,DataBuffer::Ptr buf)127 void OnSessionReadData(int32_t fd, DataBuffer::Ptr buf) override 128 { 129 SHARING_LOGD("===[TcpTestAgent] OnSessionReadData"); 130 static int index = 0; 131 DataBuffer::Ptr bufSend = std::make_shared<DataBuffer>(); 132 string msg = "tcp session send message=" + std::to_string(index++); 133 bufSend->PushData(msg.c_str(), msg.size()); 134 size_t nSize = sessionPtrVec_.size(); 135 for (size_t i = 0; i < nSize; i++) { 136 if (sessionPtrVec_[i]->GetSocketInfo()->GetPeerFd() == fd) { 137 sessionPtrVec_[i]->Send(bufSend, bufSend->Size()); 138 break; 139 } 140 } 141 sleep(3); 142 } 143 OnSessionWriteable(int32_t fd)144 void OnSessionWriteable(int32_t fd) override 145 { 146 SHARING_LOGD("===[TcpTestAgent] OnSessionWriteable"); 147 } 148 OnSessionClose(int32_t fd)149 void OnSessionClose(int32_t fd) override 150 { 151 SHARING_LOGD("===[TcpTestAgent] OnSessionClose"); 152 } 153 OnSessionException(int32_t fd)154 void OnSessionException(int32_t fd) override 155 { 156 SHARING_LOGD("===[TcpTestAgent] OnSessionException"); 157 } 158 OnClientConnect(bool isSuccess)159 void OnClientConnect(bool isSuccess) override 160 { 161 if (isSuccess) { 162 SHARING_LOGD("===[TcpTestAgent] OnClientConnect success"); 163 static int index = 0; 164 string msg = "tcp client OnClientConnect message.index=" + std::to_string(index++); 165 DataBuffer::Ptr bufSend = std::make_shared<DataBuffer>(); 166 bufSend->PushData(msg.c_str(), msg.size()); 167 if (clientPtr_ != nullptr) { 168 SHARING_LOGD("===[TcpTestAgent] OnClientConnect send"); 169 clientPtr_->Send(bufSend, bufSend->Size()); 170 } else { 171 SHARING_LOGD("===[TcpTestAgent] OnClientConnect nullptr"); 172 } 173 } else { 174 if (clientPtr_ != nullptr) { 175 SHARING_LOGE("===[TcpTestAgent] OnClientConnect failed"); 176 clientPtr_->Disconnect(); 177 } 178 } 179 } 180 OnClientReadData(int32_t fd,DataBuffer::Ptr buf)181 void OnClientReadData(int32_t fd, DataBuffer::Ptr buf) override 182 { 183 SHARING_LOGD("===[TcpTestAgent] OnClientReadData"); 184 static int index = 0; 185 string msg = "tcp client message.index=" + std::to_string(index++); 186 DataBuffer::Ptr bufSend = std::make_shared<DataBuffer>(); 187 bufSend->PushData(msg.c_str(), msg.size()); 188 clientPtr_->Send(bufSend, bufSend->Size()); 189 sleep(3); 190 } 191 OnClientWriteable(int32_t fd)192 void OnClientWriteable(int32_t fd) override 193 { 194 SHARING_LOGD("===[TcpTestAgent] OnClientWriteable"); 195 } 196 OnClientClose(int32_t fd)197 void OnClientClose(int32_t fd) override 198 { 199 SHARING_LOGD("===[TcpTestAgent] OnClientClose"); 200 clientPtr_ = nullptr; 201 } 202 OnClientException(int32_t fd)203 void OnClientException(int32_t fd) override 204 { 205 SHARING_LOGD("===[TcpTestAgent] OnClientException"); 206 clientPtr_ = nullptr; 207 } 208 209 private: 210 NetworkFactory::ServerPtr serverPtr_{nullptr}; 211 NetworkFactory::ClientPtr clientPtr_{nullptr}; 212 std::vector<INetworkSession::Ptr> sessionPtrVec_; 213 }; 214 215 namespace { 216 HWTEST_F(NetworkTcpUnitTest, NetworkTcpUnitTest_001, TestSize.Level0) 217 { 218 auto tcpAgent = std::make_shared<TcpTestAgent>(); 219 ASSERT_TRUE(tcpAgent != nullptr); 220 } 221 222 HWTEST_F(NetworkTcpUnitTest, NetworkTcpUnitTest_002, TestSize.Level0) 223 { 224 auto tcpAgent = std::make_shared<TcpTestAgent>(); 225 ASSERT_TRUE(tcpAgent != nullptr); 226 auto ret = tcpAgent->StartTcpServer(8888); 227 ASSERT_TRUE(ret); 228 } 229 230 } // namespace 231 } // namespace Sharing 232 } // namespace OHOS