public void MessageBlockNumbersTest()
{
ClientSocketManager target = new ClientSocketManager(); // TODO: 初始化为适当的值
long actual;
actual = target.MessageBlockNumbers;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void ListenerTest()
{
ClientSocketManager target = new ClientSocketManager(); // TODO: 初始化为适当的值
Listener actual;
actual = target.Listener;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public GameScene() : base(nameof(GameScene))
{
_lock = new object();
Client = new ClientSocketManager();
_worldRenderer = new WorldRenderer();
_playerInput = new PlayerInput();
}
public void FirstTimeTest()
{
ClientSocketManager target = new ClientSocketManager(); // TODO: 初始化为适当的值
long actual;
actual = target.FirstTime;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void IsOnlineTest()
{
ClientSocketManager target = new ClientSocketManager(); // TODO: 初始化为适当的值
bool actual;
actual = target.IsOnline;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void DisposeTest1()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
target.Dispose();
Assert.Inconclusive("无法验证不返回值的方法。");
}
public void WaitSendSizeTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
long actual;
actual = target.WaitSendSize;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void SliceTest()
{
Connecter target = new Connecter(); // TODO: 初始化为适当的值
ClientSocketManager expected = null; // TODO: 初始化为适当的值
ClientSocketManager actual;
actual = target.Slice();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void InitClientHandlerTest()
{
ClientSocketManager target = new ClientSocketManager(); // TODO: 初始化为适当的值
Connecter connecter = null; // TODO: 初始化为适当的值
ConnectHandle connectHandle = ConnectHandle.Zero; // TODO: 初始化为适当的值
ReceiveQueue receiveBuffer = null; // TODO: 初始化为适当的值
target.InitClientHandler(connecter, connectHandle, receiveBuffer);
Assert.Inconclusive("无法验证不返回值的方法。");
}
public void ReceiveBufferTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
ReceiveQueue actual;
actual = target.ReceiveBuffer;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void NetAddressTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
IPEndPoint actual;
actual = target.NetAddress;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void OnHandleComponentMessageTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
ComponentMessage componentMessage = new ComponentMessage(); // TODO: 初始化为适当的值
target.OnHandleComponentMessage(componentMessage);
Assert.Inconclusive("无法验证不返回值的方法。");
}
public void SendTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
Packet packet = null; // TODO: 初始化为适当的值
target.Send(packet);
Assert.Inconclusive("无法验证不返回值的方法。");
}
public void ConnectedForTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
TimeSpan actual;
actual = target.ConnectedFor;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void RunningTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
bool actual;
actual = target.Running;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void GetNewSendMessageBlockTest()
{
ClientSocketManager target = new ClientSocketManager(); // TODO: 初始化为适当的值
MessageBlock expected = MessageBlock.Zero; // TODO: 初始化为适当的值
MessageBlock actual;
actual = target.GetNewSendMessageBlock();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void WorldTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
BaseWorld actual;
actual = target.World;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void InitClientHandlerTest1()
{
ClientSocketManager target = new ClientSocketManager(); // TODO: 初始化为适当的值
Listener listener = null; // TODO: 初始化为适当的值
ServiceHandle serviceHandle = null; // TODO: 初始化为适当的值
ReceiveQueue receiveBuffer = null; // TODO: 初始化为适当的值
target.InitClientHandler(listener, serviceHandle, receiveBuffer);
Assert.Inconclusive("无法验证不返回值的方法。");
}
public void DisposeTest2()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
bool bFlush = false; // TODO: 初始化为适当的值
long iSeconds = 0; // TODO: 初始化为适当的值
target.Dispose(bFlush, iSeconds);
Assert.Inconclusive("无法验证不返回值的方法。");
}
public void NetStateTest()
{
ClientSocketManager target = new ClientSocketManager(); // TODO: 初始化为适当的值
NetState expected = null; // TODO: 初始化为适当的值
NetState actual;
target.NetState = expected;
actual = target.NetState;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
///RegisterComponent 的测试
///</summary>
public void RegisterComponentTestHelper <T>()
where T : class, IComponent
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
ComponentId componentId = new ComponentId(); // TODO: 初始化为适当的值
T component = null; // TODO: 初始化为适当的值
target.RegisterComponent <T>(componentId, component);
Assert.Inconclusive("无法验证不返回值的方法。");
}
public void ToStringTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
string expected = string.Empty; // TODO: 初始化为适当的值
string actual;
actual = target.ToString();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void CheckAliveTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
bool expected = false; // TODO: 初始化为适当的值
bool actual;
actual = target.CheckAlive();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void PacketEncoderTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
IPacketEncoder expected = null; // TODO: 初始化为适当的值
IPacketEncoder actual;
target.PacketEncoder = expected;
actual = target.PacketEncoder;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void VersionTest()
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
VersionInfo expected = null; // TODO: 初始化为适当的值
VersionInfo actual;
target.Version = expected;
actual = target.Version;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
///GetComponent 的测试
///</summary>
public void GetComponentTestHelper <T>()
where T : class, IComponent
{
ClientSocketManager clientSocket = null; // TODO: 初始化为适当的值
MessagePump messagePump = null; // TODO: 初始化为适当的值
NetState target = new NetState(clientSocket, messagePump); // TODO: 初始化为适当的值
ComponentId componentId = new ComponentId(); // TODO: 初始化为适当的值
T expected = null; // TODO: 初始化为适当的值
T actual;
actual = target.GetComponent <T>(componentId);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public static string SendRequest(string command, string requestString, string ipAddress, string userAgent, bool isNeedEncrypt)
{
try
{
Queue <ClientData> queue = new Queue <ClientData>();
int totalLength = 0;
totalLength = DataManager.PushClientDataToQueueAndFeedbackLength(queue, "6");
totalLength += DataManager.PushClientDataToQueueAndFeedbackLength(queue, "sendrequest_2");
totalLength += DataManager.PushClientDataToQueueAndFeedbackLength(queue, command);
totalLength += DataManager.PushClientDataToQueueAndFeedbackLength(queue, ipAddress);
totalLength += DataManager.PushClientDataToQueueAndFeedbackLength(queue, userAgent);
totalLength += DataManager.PushClientDataToQueueAndFeedbackLength(queue, isNeedEncrypt?"true":"false");
totalLength += DataManager.PushClientDataToQueueAndFeedbackLength(queue, requestString);
byte[] sendData = DataManager.GetSendData(queue, totalLength);
ClientSocketManager csmgr = new ClientSocketManager();
string message = string.Empty;
byte[] retData = csmgr.SendRequest(sendData, ref message);
if (message.Equals("socket:ok"))
{
if (retData != null && retData.Length > 8)
{
return(Encoding.UTF8.GetString(retData, 8, retData.Length - 8));
}
else
{
logClient.ErrorFormat("cmd:{0} fail by return null data:{1} \r\nreq:{2}", command, message, requestString);
return("socket:failbynull");
}
}
else
{
logClient.ErrorFormat("cmd:{0} fail in status:{1} request:{2} [from ip:{3},ua:{4},encrypt:{5}]", command, message, requestString, ipAddress, userAgent, isNeedEncrypt);
return(message);
}
}
catch (Exception clientErr)
{
logClient.Error(string.Format("SendRequest_2异常!\r\ncmd:{0}\r\nrequest:{1}\r\nerr:{2}\r\nstackTrace:{3}\r\n", command, requestString, clientErr.Message, clientErr.StackTrace), clientErr);
}
return("fail");
}
public Response Send(string host, int port, Request request, int?timeoutMilliseconds)
{
var uri = string.Format("tcp://{0}:{1}/{2}?scope={3}", host, port, request.Path, request.ServiceScope);
byte[] uriByte = Encoding.UTF8.GetBytes(uri);
byte[] uriLenInfoByte = BitConverter.GetBytes(uriByte.Length);
byte[] sendData = new byte[uriLenInfoByte.Length + uriByte.Length + request.Data.Length];
Buffer.BlockCopy(uriLenInfoByte, 0, sendData, 0, uriLenInfoByte.Length);
Buffer.BlockCopy(uriByte, 0, sendData, uriLenInfoByte.Length, uriByte.Length);
Buffer.BlockCopy(request.Data, 0, sendData, uriLenInfoByte.Length + uriByte.Length, request.Data.Length);
ClientSocketManager socketManager = new ClientSocketManager();
string result = string.Empty;
byte[] returnData = socketManager.SendRequest(sendData, ref result);
if (result.Equals("ok") && returnData != null)
{
int tranId = BitConverter.ToInt32(returnData, 0);
int sid = BitConverter.ToInt32(returnData, 4);
int responseStatusValue = BitConverter.ToInt32(returnData, 8);
ResponseStatus responseStatus = (ResponseStatus)responseStatusValue;
if (returnData.Length > 12)
{
byte[] responseData = new byte[returnData.Length - 12];
Buffer.BlockCopy(returnData, 12, responseData, 0, returnData.Length - 12);
return(new Response(responseStatus, responseData));
}
return(new Response(responseStatus, new byte[0]));
}
else if (result.Equals("timeout"))
{
return(new Response(ResponseStatus.InternalServerError, new byte[0]));
}
else
{
return(new Response(ResponseStatus.BadRequest, new byte[0]));
}
}
public static string GetBizJsonString(string bizName, string requestJson)
{
try {
Queue <ClientData> queue = new Queue <ClientData>();
int totalLength = 0;
totalLength = DataManager.PushClientDataToQueueAndFeedbackLength(queue, "3");
totalLength += DataManager.PushClientDataToQueueAndFeedbackLength(queue, "getbizjsonstring");
totalLength += DataManager.PushClientDataToQueueAndFeedbackLength(queue, bizName);
totalLength += DataManager.PushClientDataToQueueAndFeedbackLength(queue, requestJson);
byte[] sendData = DataManager.GetSendData(queue, totalLength);
ClientSocketManager csmgr = new ClientSocketManager();
string message = string.Empty;
byte[] retData = csmgr.SendRequest(sendData, ref message);
if (message.Equals("socket:ok"))
{
if (retData != null && retData.Length > 8)
{
return(Encoding.UTF8.GetString(retData, 8, retData.Length - 8));
}
else
{
logClient.ErrorFormat("cmd:{0} fail by return null data:{1} \r\nreq:{2}", bizName, message, requestJson);
return("socket:failbynull");
}
}
else
{
logClient.ErrorFormat("bizname:{0} fail in status:{1} requestjson:{2}", bizName, message, requestJson);
return(message.StartsWith("socket:")?message:string.Format("socket:{0}", message));
}
}
catch (Exception bizJsonErr) {
logClient.Error(string.Format("GetBizJsonString异常!\r\nbizName:{0}\r\nrequestJson:{1}\r\nerr:{2}\r\nstackTrace:{3}\r\n", bizName, requestJson, bizJsonErr.Message, bizJsonErr.StackTrace), bizJsonErr);
}
return("socket:exception-fail");
}
public SocketServer(uint packetsize)
{
ActionsConcurrentQueue = new ConcurrentQueue <Action>();
ClientSocketManager = new ClientSocketManager(packetsize);
ClientSocketManager.AsyncOnMessageRecived += ClientSocketManager_AsyncOnMessageRecived;
ClientSocketManager.AsyncOnErrMessageRecived += ClientSocketManager_AsyncOnErrMessageRecived;
ClientSocketManager.AsyncOnClientDataRecived += ClientSocketManager_AsyncOnClientDataRecived;
ClientSocketManager.AsyncOnClientDisConnect += ClientSocketManager_AsyncOnClientDisConnect;
ClientSocketManager.AsyncOnClientDisConnected += ClientSocketManager_AsyncOnClientDisConnected;
ClientSockets = ClientSocketManager.ReadOnlyClientSockets;
SocketListener = new SocketListener();
SocketListener.AsyncOnMessageRecived += SocketListener_AsyncOnMessageRecived;
SocketListener.AsyncOnErrMessageRecived += SocketListener_AsyncOnErrMessageRecived;
SocketListener.AsyncOnClientConnected += SocketListener_AsyncOnClientConnected;
Running = false;
}
