Inheritance: IOutgoingSocket
        public void TrySendMultipartBytesWithTimeoutTest()
        {
            var count = 0;

            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                if (count == 0)
                {
                    Assert.Equal(TimeSpan.FromSeconds(1), timeout);
                    Assert.Equal(1, msg.Data.Length);
                    Assert.Equal(1, msg.Data[0]);
                    Assert.True(more);
                    count++;
                }
                else
                {
                    Assert.Equal(SendReceiveConstants.InfiniteTimeout, timeout);
                    Assert.Equal(1, msg.Data.Length);
                    Assert.Equal(2, msg.Data[0]);
                    Assert.False(more);
                    count++;
                }

                return(true);
            });

            Assert.True(socket.TrySendMultipartBytes(TimeSpan.FromSeconds(1), new byte[] { 1 }, new byte[] { 2 }));
            Assert.Equal(2, count);
        }
示例#2
0
        public void SendMultipartBytesTest()
        {
            var count = 0;

            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                if (count == 0)
                {
                    Assert.Equal(SendReceiveConstants.InfiniteTimeout, timeout);
                    Assert.Single(msg.UnsafeData);
                    Assert.Equal(1, msg.UnsafeData[0]);
                    Assert.True(more);
                    count++;
                }
                else
                {
                    Assert.Equal(SendReceiveConstants.InfiniteTimeout, timeout);
                    Assert.Single(msg.UnsafeData);
                    Assert.Equal(2, msg.UnsafeData[0]);
                    Assert.False(more);
                    count++;
                }

                return(true);
            });

            socket.SendMultipartBytes(new byte[] { 1 }, new byte[] { 2 });
            Assert.Equal(2, count);
        }
        public void SendMultipartBytesTest()
        {
            var count = 0;

            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                if (count == 0)
                {
                    Assert.AreEqual(SendReceiveConstants.InfiniteTimeout, timeout);
                    Assert.AreEqual(1, msg.Data.Length);
                    Assert.AreEqual(1, msg.Data[0]);
                    Assert.IsTrue(more);
                    count++;
                }
                else
                {
                    Assert.AreEqual(SendReceiveConstants.InfiniteTimeout, timeout);
                    Assert.AreEqual(1, msg.Data.Length);
                    Assert.AreEqual(2, msg.Data[0]);
                    Assert.IsFalse(more);
                    count++;
                }

                return true;
            });

            socket.SendMultipartBytes(new byte[] { 1 }, new byte[] { 2 });
            Assert.AreEqual(2, count);
        }
示例#4
0
        public void TrySendMultipartMessageTest()
        {
            var count = 0;

            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                if (count == 0)
                {
                    Assert.Equal(TimeSpan.FromSeconds(0), timeout);
                    Assert.Single(msg.UnsafeData);
                    Assert.Equal(1, msg.UnsafeData[0]);
                    Assert.True(more);
                    count++;
                }
                else
                {
                    Assert.Equal(SendReceiveConstants.InfiniteTimeout, timeout);
                    Assert.Single(msg.UnsafeData);
                    Assert.Equal(2, msg.UnsafeData[0]);
                    Assert.False(more);
                    count++;
                }

                return(true);
            });

            var message = new NetMQMessage();

            message.Append(new byte[] { 1 });
            message.Append(new byte[] { 2 });

            Assert.True(socket.TrySendMultipartMessage(message));
            Assert.Equal(2, count);
        }
        public void SendFrameEmpty()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.Equal(SendReceiveConstants.InfiniteTimeout, timeout);
                Assert.Equal(0, msg.Data.Length);
                Assert.False(more);
                return(true);
            });

            socket.SendFrameEmpty();
        }
        public void TrySendFrameEmptyFailed()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.Equal(TimeSpan.Zero, timeout);
                Assert.Equal(0, msg.Data.Length);
                Assert.False(more);
                return(false);
            });

            Assert.False(socket.TrySendFrameEmpty());
        }
示例#7
0
        public void TrySendFrameEmpty()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.Equal(TimeSpan.Zero, timeout);
                Assert.Empty(msg.UnsafeData);
                Assert.False(more);
                return(true);
            });

            Assert.True(socket.TrySendFrameEmpty());
        }
示例#8
0
        public void SendMoreFrameEmpty()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.Equal(SendReceiveConstants.InfiniteTimeout, timeout);
                Assert.Empty(msg.UnsafeData);
                Assert.True(more);
                return(true);
            });

            var returnedSocket = socket.SendMoreFrameEmpty();

            Assert.Equal(returnedSocket, socket);
        }
        public void SignalTest()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.Equal(SendReceiveConstants.InfiniteTimeout, timeout);
                Assert.Equal(8, msg.Data.Length);

                var value = NetworkOrderBitsConverter.ToInt64(msg.Data);

                Assert.Equal(0x7766554433221100L, value);

                Assert.False(more);
                return(true);
            });

            socket.SignalOK();
        }
        public void TrySignalFailedTest()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.Equal(TimeSpan.Zero, timeout);
                Assert.Equal(8, msg.Data.Length);

                var value = NetworkOrderBitsConverter.ToInt64(msg.Data);

                Assert.Equal(0x7766554433221100L, value);

                Assert.False(more);
                return(false);
            });

            Assert.False(socket.TrySignalOK());
        }
        public void TrySendMultipartBytesWithTimeoutTestFailed()
        {
            var count = 0;

            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.Equal(TimeSpan.FromSeconds(1), timeout);
                Assert.Equal(1, msg.Data.Length);
                Assert.Equal(1, msg.Data[0]);
                Assert.True(more);
                count++;

                return(false);
            });

            Assert.False(socket.TrySendMultipartBytes(TimeSpan.FromSeconds(1), new byte[] { 1 }, new byte[] { 2 }));
            Assert.Equal(1, count);
        }
        public void TrySendMultipartMessageFailed()
        {
            var count = 0;

            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.Equal(TimeSpan.FromSeconds(0), timeout);
                Assert.Equal(1, msg.Data.Length);
                Assert.Equal(1, msg.Data[0]);
                Assert.True(more);
                count++;

                return(false);
            });

            var message = new NetMQMessage();

            message.Append(new byte[] { 1 });
            message.Append(new byte[] { 2 });

            Assert.False(socket.TrySendMultipartMessage(message));
            Assert.Equal(1, count);
        }
        public void TrySignalFailedTest()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.AreEqual(TimeSpan.Zero, timeout);
                Assert.AreEqual(8, msg.Data.Length);

                var value = NetworkOrderBitsConverter.ToInt64(msg.Data);

                Assert.AreEqual(0x7766554433221100L, value);

                Assert.IsFalse(more);
                return false;
            });

            Assert.IsFalse(socket.TrySignalOK());
        }
        public void TrySendMultipartMessageTest()
        {
            var count = 0;

            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                if (count == 0)
                {
                    Assert.AreEqual(TimeSpan.FromSeconds(0), timeout);
                    Assert.AreEqual(1, msg.Data.Length);
                    Assert.AreEqual(1, msg.Data[0]);
                    Assert.IsTrue(more);
                    count++;
                }
                else
                {
                    Assert.AreEqual(SendReceiveConstants.InfiniteTimeout, timeout);
                    Assert.AreEqual(1, msg.Data.Length);
                    Assert.AreEqual(2, msg.Data[0]);
                    Assert.IsFalse(more);
                    count++;
                }

                return true;
            });

            var message = new NetMQMessage();
            message.Append(new byte[] {1});
            message.Append(new byte[] {2});

            Assert.IsTrue(socket.TrySendMultipartMessage(message));
            Assert.AreEqual(2, count);
        }
        public void TrySendMultipartMessageFailed()
        {
            var count = 0;

            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.AreEqual(TimeSpan.FromSeconds(0), timeout);
                Assert.AreEqual(1, msg.Data.Length);
                Assert.AreEqual(1, msg.Data[0]);
                Assert.IsTrue(more);
                count++;

                return false;
            });

            var message = new NetMQMessage();
            message.Append(new byte[] { 1 });
            message.Append(new byte[] { 2 });

            Assert.IsFalse(socket.TrySendMultipartMessage(message));
            Assert.AreEqual(1, count);
        }
        public void SendMoreFrameEmpty()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.AreEqual(SendReceiveConstants.InfiniteTimeout, timeout);
                Assert.AreEqual(0, msg.Data.Length);
                Assert.IsTrue(more);
                return true;
            });

            var returnedSocket = socket.SendMoreFrameEmpty();
            Assert.AreEqual(returnedSocket, socket);
        }
        public void TrySendFrameEmptyFailed()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.AreEqual(TimeSpan.Zero, timeout);
                Assert.AreEqual(0, msg.Data.Length);
                Assert.IsFalse(more);
                return false;
            });

            Assert.IsFalse(socket.TrySendFrameEmpty());
        }
        public void SignalTest()
        {
            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {
                Assert.AreEqual(SendReceiveConstants.InfiniteTimeout, timeout);
                Assert.AreEqual(8, msg.Data.Length);

                var value = NetworkOrderBitsConverter.ToInt64(msg.Data);

                Assert.AreEqual(0x7766554433221100L, value);

                Assert.IsFalse(more);
                return true;
            });

            socket.SignalOK();
        }
        public void TrySendMultipartBytesWithTimeoutTestFailed()
        {
            var count = 0;

            var socket = new MockOutgoingSocket((ref Msg msg, TimeSpan timeout, bool more) =>
            {

                Assert.AreEqual(TimeSpan.FromSeconds(1), timeout);
                Assert.AreEqual(1, msg.Data.Length);
                Assert.AreEqual(1, msg.Data[0]);
                Assert.IsTrue(more);
                count++;

                return false;
            });

            Assert.IsFalse(socket.TrySendMultipartBytes(TimeSpan.FromSeconds(1), new byte[] { 1 }, new byte[] { 2 }));
            Assert.AreEqual(1, count);
        }