public void DataReceived_FullMessage_ReturnsCorrectMessage() { MessageType expectedMessageType = MessageType.Init; byte[] expectedBytes = new byte[] { 1, 2, 3, 4 }; byte[] message = PacketProtocol <MessageType> .WrapMessage(expectedMessageType, expectedBytes); MessageType receivedMessageType = MessageType.Unknown; byte[] receivedBytes = null; PacketProtocol <MessageType> packetProtocol = new PacketProtocol <MessageType>(100); packetProtocol.MessageArrived += (type, bytes) => { receivedMessageType = type; receivedBytes = bytes; }; packetProtocol.DataReceived(message, message.Length); Assert.AreEqual(expectedMessageType, receivedMessageType); Assert.AreEqual(expectedBytes, receivedBytes); }
public void Send_message_SendsMessage() { // Establish the local endpoint for the socket. IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName()); IPAddress ipAddress = ipHostInfo.AddressList[0]; IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 20055); // Create a server Socket server = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); server.Bind(localEndPoint); server.Listen(2); // Create a SocketConnectionController SocketConnection socket = new SocketConnection(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); socket.Connect(localEndPoint); SocketConnectionController <MessageType> socketConnectionController = new SocketConnectionController <MessageType>(socket, 1024); socketConnectionController.Start(); Socket server_receiver = server.Accept(); Thread.Sleep(1000); byte[] message = Encoding.ASCII.GetBytes("ThisIsAMessage"); byte[] expectedData = PacketProtocol <MessageType> .WrapMessage(MessageType.Standard, message); socketConnectionController.Send(MessageType.Standard, message); byte[] receiveBuffer = new byte[expectedData.Length]; server_receiver.Receive(receiveBuffer); Assert.AreEqual(expectedData, receiveBuffer); }
public void Send_Message_CallsBeginSend() { MessageType messageType = MessageType.Init; byte[] message = Encoding.ASCII.GetBytes("test message"); var mock = new Mock <ISocketConnection>(); mock.Setup(x => x.Connected).Returns(true); byte[] expectedMessage = PacketProtocol <MessageType> .WrapMessage(messageType, message); byte[] receivedMessage = null; mock.Setup(x => x.BeginSend( It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <SocketFlags>(), It.IsAny <AsyncCallback>(), It.IsAny <object>())) .Callback <byte[], int, int, SocketFlags, AsyncCallback, object>((data, offset, size, socketFlags, asyncCallback, state) => { receivedMessage = data; }); SocketConnectionController <MessageType> controller = new SocketConnectionController <MessageType>(mock.Object, 1024); controller.Start(); controller.Send(messageType, message); Assert.AreEqual(expectedMessage, receivedMessage); }
public void DataReceived_LengthShorterThanBuffer_OnlyReadsTheLength() { MessageType expectedMessageType = MessageType.Init; byte[] expectedBytes = new byte[] { 1, 2, 3, 4 }; byte[] message = PacketProtocol <MessageType> .WrapMessage(expectedMessageType, expectedBytes); // Add bytes the package protocol should not read. byte[] tooLongMessage = message.Concat(new byte[] { 9, 8, 7 }).ToArray(); MessageType receivedMessageType = MessageType.Unknown; byte[] receivedBytes = null; PacketProtocol <MessageType> packetProtocol = new PacketProtocol <MessageType>(100); packetProtocol.MessageArrived += (type, bytes) => { receivedMessageType = type; receivedBytes = bytes; }; packetProtocol.DataReceived(tooLongMessage, message.Length); Assert.AreEqual(expectedMessageType, receivedMessageType); Assert.AreEqual(expectedBytes, receivedBytes); }
// -------------------- SEND -------------------- \\ public void Send(TMessageType messageType, byte[] message) { if (!IsConnected) { throw new Exception("SocketConnectionController is not connected"); } if (_isDisposed) { throw new ObjectDisposedException("SocketConnectionController has been disposed"); } byte[] data = PacketProtocol <TMessageType> .WrapMessage(messageType, message); // Log the incoming message. Ignoring often occurring types. /*if (messageType != MessageType.Animation_Request) * { * Console.WriteLine($"[OUT] [{messageType}] length:{message.Length}"); * }*/ // Begin sending the data to the remote device. try { _socket.BeginSend(data, 0, data.Length, 0, new AsyncCallback(SendCallback), _socket); } catch (SocketException e) { OnDisconnect(e); } }
public async void SendAsync(object data) { try { var bytes = PacketProtocol.WrapMessage(netSettings.serializer.Invoke(data)); await stream.WriteAsync(bytes, 0, bytes.Length); } catch (Exception ex) { OnDisconnected?.Invoke(null, new DisconnectEventArgs { Exception = ex }); } }
public void DataReceived_PackageTooLong_ThrowsProtocolViolationException() { MessageType expectedMessageType = MessageType.Init; byte[] expectedBytes = new byte[] { 1, 2, 3, 4 }; byte[] message = PacketProtocol <MessageType> .WrapMessage(expectedMessageType, expectedBytes); // Add bytes the package protocol should not read. PacketProtocol <MessageType> packetProtocol = new PacketProtocol <MessageType>(10); Assert.Throws <ProtocolViolationException>(() => packetProtocol.DataReceived(message, message.Length)); }
public void ReceiveCallback_Message_InvokesMessageArrived() { // The receive callback is private. We have to chain the receive via the start function. MessageType messageType = MessageType.Init; byte[] message = Encoding.ASCII.GetBytes("test message"); var mock = new Mock <ISocketConnection>(); mock.Setup(x => x.Connected).Returns(true); byte[] dataToSend = PacketProtocol <MessageType> .WrapMessage(messageType, message); var asyncStateMock = new Mock <IAsyncResult>(); asyncStateMock.Setup(x => x.AsyncState).Returns(dataToSend); bool beginReceiveHasBeenInvoked = false; mock.Setup(x => x.BeginReceive( It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <SocketFlags>(), It.IsAny <AsyncCallback>(), It.IsAny <object>())) .Callback <byte[], int, int, SocketFlags, AsyncCallback, object>((data, offset, size, socketFlags, asyncCallback, state) => { if (!beginReceiveHasBeenInvoked) { beginReceiveHasBeenInvoked = true; // Prevent endless loop asyncCallback.Invoke(asyncStateMock.Object); // calls ReceiveCallBack } }); bool endSendCalled = false; mock.Setup(x => x.EndReceive(It.IsAny <IAsyncResult>())).Returns(dataToSend.Length).Callback(() => endSendCalled = true); SocketConnectionController <MessageType> controller = new SocketConnectionController <MessageType>(mock.Object, 1024); MessageReceivedEventArgs <MessageType> messageReceivedEventArgs = null; controller.MessageReceived += (sender, args) => { messageReceivedEventArgs = args; }; controller.Start(); Assert.IsTrue(endSendCalled); Assert.AreEqual(messageType, messageReceivedEventArgs.MessageType); Assert.AreEqual(message, messageReceivedEventArgs.Message); }
public void DataReceived_MessageSplitInMultiplePackages_ReturnsCorrectMessage() { MessageType expectedMessageType = MessageType.Init; byte[] expectedBytes = new byte[] { 1, 2, 3, 4 }; byte[] message = PacketProtocol <MessageType> .WrapMessage(expectedMessageType, expectedBytes); Assert.AreEqual(12, message.Length, "This test assumes the message length is 12"); byte[] messagePackage1 = { message[0], message[1], message[2] }; byte[] messagePackage2 = { message[3], message[4], message[5] }; byte[] messagePackage3 = { message[6], message[7], message[8] }; byte[] messagePackage4 = { message[9], message[10], message[11], }; MessageType receivedMessageType = MessageType.Unknown; byte[] receivedBytes = null; PacketProtocol <MessageType> packetProtocol = new PacketProtocol <MessageType>(100); packetProtocol.MessageArrived += (type, bytes) => { receivedMessageType = type; receivedBytes = bytes; }; packetProtocol.DataReceived(messagePackage1, messagePackage1.Length); Assert.AreEqual(MessageType.Unknown, receivedMessageType); packetProtocol.DataReceived(messagePackage2, messagePackage2.Length); Assert.AreEqual(MessageType.Unknown, receivedMessageType); packetProtocol.DataReceived(messagePackage3, messagePackage3.Length); Assert.AreEqual(MessageType.Unknown, receivedMessageType); packetProtocol.DataReceived(messagePackage4, messagePackage4.Length); Assert.AreEqual(expectedMessageType, receivedMessageType); Assert.AreEqual(expectedBytes, receivedBytes); }
public void Send(TMessageType messageType, byte[] message) { if (_isDisposed) { throw new ObjectDisposedException("SocketConnectionController has been disposed"); } byte[] data = PacketProtocol <TMessageType> .WrapMessage(messageType, message); // Begin sending the data to the remote device. try { _socket.BeginSendTo(data, 0, data.Length, 0, _targetEndPoint, SendCallback, data); } catch (SocketException e) { } }
/// <summary> /// Sends message to remote client. /// </summary> /// <param name="client">Remote client socket object</param> /// <param name="data">Message to send</param> private static void Send(Socket client, Message data) { try { // convert message into byte array and wrap it for network transport: var serializedMsg = Message.Serialize(data); byte[] byteData = PacketProtocol.WrapMessage(serializedMsg); Debug.Log(String.Format("\t...almost send {0} bytes [{1}]", byteData.Length, data.Code));//----------- // Begin sending the data to the remote device: client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client); } catch (Exception ex) { Debug.Log(ex.ToString()); } }
public void Send_message_SendsMessage() { // Establish the local endpoint for the socket. IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName()); IPAddress ipAddress = ipHostInfo.AddressList[0]; IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 20055); // Create a server Socket server = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); server.Bind(localEndPoint); server.Listen(2); // Create a SocketConnectionController int clientId = 0; StellaServer stellaServer = new StellaServer(); stellaServer.Start(localEndPoint, 20056, clientId); Socket server_receiver = server.Accept(); Thread.Sleep(1000); byte[] message = Encoding.ASCII.GetBytes("ThisIsAMessage"); byte[] expectedInit = PacketProtocol <MessageType> .WrapMessage(MessageType.Init, BitConverter.GetBytes(clientId)); byte[] expectedMessage = PacketProtocol <MessageType> .WrapMessage(MessageType.Standard, message); // Expected init message byte[] receiveBufferInitMessage = new byte[expectedInit.Length]; server_receiver.Receive(receiveBufferInitMessage); Assert.AreEqual(expectedInit, receiveBufferInitMessage); // Expected Standard message stellaServer.Send(MessageType.Standard, message); byte[] receiveBufferMessage = new byte[expectedMessage.Length]; server_receiver.Receive(receiveBufferMessage); Assert.AreEqual(expectedMessage, receiveBufferMessage); }
private void SendInternal(byte[] message) { if (_tcpClient == null) { return; } try { NetworkStream stream = _tcpClient.GetStream(); if (stream.CanWrite) { byte[] clientMessageAsByteArrayWrapped = PacketProtocol.WrapMessage(message); stream.Write(clientMessageAsByteArrayWrapped, 0, clientMessageAsByteArrayWrapped.Length); Debug.Log($"Message sent (size: {clientMessageAsByteArrayWrapped.Length})"); } } catch (SocketException socketException) { Debug.LogError("Socket exception: " + socketException); } }
public void SendCallback_SocketException_InvokesOnDisconnect() { MessageType messageType = MessageType.Init; byte[] message = Encoding.ASCII.GetBytes("test message"); byte[] expectedMessage = PacketProtocol <MessageType> .WrapMessage(messageType, message); var mock = new Mock <ISocketConnection>(); mock.Setup(x => x.Connected).Returns(true); // Chain the BeginSend to the EndSend SendCallBack function mock.Setup(x => x.BeginSend( It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <SocketFlags>(), It.IsAny <AsyncCallback>(), It.IsAny <object>())) .Callback <byte[], int, int, SocketFlags, AsyncCallback, object>((data, offset, size, socketFlags, asyncCallback, state) => { asyncCallback.Invoke(null); }); mock.Setup(x => x.EndSend(It.IsAny <IAsyncResult>())).Throws <SocketException>(); // Listen to the Disconnect event bool disconnectInvoked = false; SocketConnectionController <MessageType> controller = new SocketConnectionController <MessageType>(mock.Object, 1024); controller.Disconnect += (sender, args) => disconnectInvoked = true; // Run controller.Start(); controller.Send(messageType, message); Assert.IsTrue(disconnectInvoked); }
internal void SendMessageToAll(byte[] message) { var clientList = new ReadOnlyCollection <TcpClientInfo>((clientInfoStorage as TcpClientInfoStorage) .ToList()); Parallel.ForEach(clientList, client => WriteToAll(client)); void WriteToAll(TcpClientInfo clientInfo) { try { var bytes = PacketProtocol.WrapMessage(message); clientInfo.Stream.WriteAsync(bytes, 0, bytes.Length); Logger.LogDebug($"{bytes.Length } bytes sent to {clientInfo.ClientId}."); } catch (Exception ex) { Logger.LogError(ex.Message); clientInfoStorage.RemoveInfo(clientInfo); } } }