Example #1
0
        private void OnReceiveMessage()
        {
            _receive_iterations++;
            _log.WriteLine(this.GetHashCode() + " OnReceiveMessage() _receive_iterations={0}", _receive_iterations);

            _recvBufferIndex = 0;

            // Expect echo server.
            if (!SocketTestMemcmp.Compare(_sendBuffer, _recvBuffer))
            {
                _log.WriteLine("Received different data from echo server");
            }

            if (_receive_iterations >= _iterations)
            {
                _timeSendRecv.Stop();
                _timeClose.Start();
                Close(OnClose);
            }
            else
            {
                Array.Clear(_recvBuffer, 0, _recvBuffer.Length);
                Receive(OnReceive);
            }
        }
Example #2
0
        private async Task DoReceive()
        {
            int total_bytes_received = 0;

            while (total_bytes_received < _current_bytes)
            {
                int receivedBytes = await ReceiveHelper();

                if (receivedBytes == 0)
                {
                    _log.WriteLine("Socket unexpectedly closed.");
                    throw new Exception("Socket unexpectedly closed");
                }

                total_bytes_received += receivedBytes;
                Assert.True(total_bytes_received <= _current_bytes);

                _recvBufferIndex += receivedBytes;
                Assert.True(_recvBufferIndex <= _bufferLen);
                if (_recvBufferIndex == _bufferLen)
                {
                    _recvBufferIndex = 0;

                    // Compare the bytes we sent to the bytes we received;
                    // They should be the same since the server is an echo server.
                    if (!SocketTestMemcmp.Compare(_sendBuffer, _recvBuffer))
                    {
                        _log.WriteLine("Received different data from echo server");
                        throw new Exception("Received different data from echo server");
                    }

                    Array.Clear(_recvBuffer, 0, _bufferLen);
                }
            }
        }
Example #3
0
        // Called when the entire _recvBuffer has been received.
        private void OnReceive(int receivedBytes, SocketError error)
        {
            bool pending;

            do
            {
                _log.WriteLine(this.GetHashCode() + " OnSend({0}, {1})", receivedBytes, error);
                _recvBufferIndex += receivedBytes;

                // TODO: an error should fail the test.
                if (error != SocketError.Success)
                {
                    _timeClose.Start();
                    Close(OnClose);
                    return;
                }

                if (_recvBufferIndex == _recvBuffer.Length)
                {
                    _receive_iterations++;
                    _log.WriteLine(this.GetHashCode() + " OnReceiveMessage() _receive_iterations={0}", _receive_iterations);

                    _recvBufferIndex = 0;

                    // Expect echo server.
                    if (!SocketTestMemcmp.Compare(_sendBuffer, _recvBuffer))
                    {
                        _log.WriteLine("Received different data from echo server");
                    }

                    if (_receive_iterations >= _iterations)
                    {
                        _timeSendRecv.Stop();
                        _timeClose.Start();
                        Close(OnClose);
                        return;
                    }
                    else
                    {
                        Array.Clear(_recvBuffer, 0, _recvBuffer.Length);
                        pending = Receive(out receivedBytes, out error, OnReceive);
                    }
                }
                else if (receivedBytes == 0)
                {
                    _log.WriteLine("Socket unexpectedly closed.");
                    return;
                }
                else
                {
                    pending = Receive(out receivedBytes, out error, OnReceive);
                }
            } while (!pending);
        }