public void TestListenerForProxyingMinimally()
        {
            var fakeLogger = new FakeLogging();

            using var fakeDiscoverer = new FakeDiscoverer();
            var source             = new CancellationTokenSource();
            var fakeExternalSocket = new TestSocket(holdYourHorses: true, _tag, 1, 240, 128);
            var fakeInternalSocket = new TestSocket(holdYourHorses: true, _tag, 1, 241, 1);
            var fakeSink           = new TestSink(_tag, 1, 242);
            var fakeNodeSink       = new FakeNodeSink(_tag, 2000, 10, 40);

            using var referenceListener = new ListenerForPeer(fakeNodeSink, fakeDiscoverer, source, fakeLogger);
            var internalConnection = new ConnectionInitiatedByPeer("TLFPM", fakeNodeSink, fakeInternalSocket, fakeSink, source, fakeLogger);

            internalConnection.SetDefaultSink(fakeNodeSink);
            using var lfp = new TestListenerForProxying(fakeExternalSocket, referenceListener.ExternalAddress, referenceListener.ExternalAddress, 333, internalConnection, new SocketFactory(fakeLogger, 3), source, fakeLogger);
            lfp.Start();
            WaitForOthers(100);
            fakeExternalSocket.ReleaseYourHorses();
            var max = 5;

            while (AllBytes(fakeInternalSocket).Length < 4 && max-- > 0)
            {
                WaitForOthers(100);
            }
            var allInternalBytes = AllBytes(fakeInternalSocket);

            Assert.IsNotNull(fakeLogger.LastLog);
            AssertHasSameItems <byte>(nameof(fakeInternalSocket.BytesSent), allInternalBytes.ToArray(), _tag, 1, 240, 1);
            WaitForOthers(100);
            fakeInternalSocket.ReleaseYourHorses();
            max = 7;
            while (AllBytes(fakeExternalSocket).Length < 4 && max-- > 0)
            {
                WaitForOthers(100);
            }
            AssertHasSameItems <byte>(nameof(fakeExternalSocket.BytesSent), AllBytes(fakeExternalSocket).ToArray(), _tag, 1, 241, 128);
            fakeSink.Reset();
            long lastIndex = allInternalBytes.Length - 1;

            fakeSink.SinkAsync(allInternalBytes.Slice(0, lastIndex), new TestChannel(allInternalBytes.Slice(lastIndex).First.Span[0])).Wait();
            max = 12;
            while (fakeSink.ChannelProcessed == 0ul && max-- > 0)
            {
                WaitForOthers(100);
            }
            WaitForOthers(300);
            AssertHasSameItems <byte>(nameof(fakeSink.BytesProcessed), fakeSink.BytesProcessed.ToArray(), _tag, 1, 240);
            Assert.AreEqual((ulong)1, fakeSink.ChannelProcessed);
            AssertHasLogLine(fakeLogger, "Debug: Sinked Message '8A' from Channel ProxyingClient#1@128 using new pair to Proxied Channel 1. Sent: True");
            AssertHasLogLine(fakeLogger, "Debug: Responded with Message '8Q' from Channel TLFPM@1 to External Channel 128. Sent: True");
        }
 public TestListenerForProxying(TestSocket overridingSocket, string externalAddress, string hostedAddress, ushort firstPort, ConnectionInitiatedByPeer connection, SocketFactory socketFactory, CancellationTokenSource source, ILogger logger) :
     base(externalAddress, hostedAddress, firstPort, connection, socketFactory, source, logger)
     => _testSocket = new SingleUseSocket(overridingSocket, _source);