Tests host:port cleanup

There were several mismatches here...this should help avoid future ones.

StackExchange.Redis.Tests/AsyncTests.cs

@@ -8,7 +8,7 @@ public class AsyncTests : TestBase
     {
         public AsyncTests(ITestOutputHelper output) : base (output) { }
 
-        protected override string GetConfiguration() => TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort;
+        protected override string GetConfiguration() => TestConfig.Current.MasterServerAndPort;
 
 #if DEBUG // IRedisServerDebug and AllowConnect are only available if DEBUG is defined
         [Fact]

StackExchange.Redis.Tests/ConnectionShutdown.cs

@@ -7,7 +7,7 @@ namespace StackExchange.Redis.Tests
 {
     public class ConnectionShutdown : TestBase
     {
-        protected override string GetConfiguration() => TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort;
+        protected override string GetConfiguration() => TestConfig.Current.MasterServerAndPort;
         public ConnectionShutdown(ITestOutputHelper output) : base (output) { }
 
         [Fact(Skip="Unfriendly")]
@@ -53,4 +53,4 @@ public void ShutdownRaisesConnectionFailedAndRestore()
             }
         }
     }
-}
\ No newline at end of file
+}

StackExchange.Redis.Tests/Helpers/TestConfig.cs

@@ -42,13 +42,16 @@ public class Config
 
             public string MasterServer { get; set; } = "127.0.0.1";
             public int MasterPort { get; set; } = 6379;
+            public string MasterServerAndPort => MasterServer + ":" + MasterPort.ToString();
 
             public string SlaveServer { get; set; } = "127.0.0.1";
             public int SlavePort { get; set; } = 6380;
+            public string SlaveServerAndPort => SlaveServer + ":" + SlavePort.ToString();
 
             public string SecureServer { get; set; } = "127.0.0.1";
             public int SecurePort { get; set; } = 6381;
             public string SecurePassword { get; set; } = "changeme";
+            public string SecureServerAndPort => SecureServer + ":" + SecurePort.ToString();
 
             public string IPv4Server { get; set; } = "127.0.0.1";
             public int IPv4Port { get; set; } = 6379;

StackExchange.Redis.Tests/Issues/DefaultDatabase.cs

@@ -28,7 +28,7 @@ public void ConfigurationOptions_UnspecifiedDefaultDb()
             var log = new StringWriter();
             try
             {
-                using (var conn = ConnectionMultiplexer.Connect($"{TestConfig.Current.MasterServer}:{TestConfig.Current.MasterPort}", log)) {
+                using (var conn = ConnectionMultiplexer.Connect(TestConfig.Current.MasterServerAndPort, log)) {
                     var db = conn.GetDatabase();
                     Assert.Equal(0, db.Database);
                 }
@@ -45,7 +45,7 @@ public void ConfigurationOptions_SpecifiedDefaultDb()
             var log = new StringWriter();
             try
             {
-                using (var conn = ConnectionMultiplexer.Connect($"{TestConfig.Current.MasterServer}:{TestConfig.Current.MasterPort},defaultDatabase=3", log)) {
+                using (var conn = ConnectionMultiplexer.Connect($"{TestConfig.Current.MasterServerAndPort},defaultDatabase=3", log)) {
                     var db = conn.GetDatabase();
                     Assert.Equal(3, db.Database);
                 }

StackExchange.Redis.Tests/Issues/Issue182.cs

-using System;
-using System.Linq;
-using Xunit;
-using Xunit.Abstractions;
-
-namespace StackExchange.Redis.Tests.Issues
-{
-    public class Issue182 : TestBase
-    {
-        protected override string GetConfiguration() => $"{TestConfig.Current.MasterServer}:{TestConfig.Current.MasterPort},responseTimeout=10000";
-
-        public Issue182(ITestOutputHelper output) : base (output) { }
-
-        [FactLongRunning]
-        public void SetMembers()
-        {
-            using (var conn = Create())
-            {
-                conn.ConnectionFailed += (s, a) =>
-                {
-                    Output.WriteLine(a.FailureType.ToString());
-                    Output.WriteLine(a.Exception.Message);
-                    Output.WriteLine(a.Exception.StackTrace);
-                };
-                var db = conn.GetDatabase();
-
-                var key = Me();
-                const int count = (int)5e6;
-
-                db.KeyDeleteAsync(key).Wait();
-                foreach (var _ in Enumerable.Range(0, count))
-                    db.SetAdd(key, Guid.NewGuid().ToByteArray(), CommandFlags.FireAndForget);
-
-                Assert.Equal(count, db.SetLengthAsync(key).Result); // SCARD for set
-
-                var task = db.SetMembersAsync(key);
-                task.Wait();
-                Assert.Equal(count, task.Result.Length); // SMEMBERS result length
-            }
-        }
-
-        [FactLongRunning]
-        public void SetUnion()
-        {
-            using (var conn = Create())
-            {
-                var db = conn.GetDatabase();
-
-                var key1 = Me() + ":1";
-                var key2 = Me() + ":2";
-                var dstkey = Me() + ":dst";
-
-                db.KeyDeleteAsync(key1).Wait();
-                db.KeyDeleteAsync(key2).Wait();
-                db.KeyDeleteAsync(dstkey).Wait();
-
-                const int count = (int)5e6;
-                foreach (var _ in Enumerable.Range(0, count))
-                {
-                    db.SetAdd(key1, Guid.NewGuid().ToByteArray(), CommandFlags.FireAndForget);
-                    db.SetAdd(key2, Guid.NewGuid().ToByteArray(), CommandFlags.FireAndForget);
-                }
-                Assert.Equal(count, db.SetLengthAsync(key1).Result); // SCARD for set 1
-                Assert.Equal(count, db.SetLengthAsync(key2).Result); // SCARD for set 2
-
-                db.SetCombineAndStoreAsync(SetOperation.Union, dstkey, key1, key2).Wait();
-                var dstLen = db.SetLength(dstkey);
-                Assert.Equal(count * 2, dstLen); // SCARD for destination set
-            }
-        }
-    }
-}
\ No newline at end of file
+using System;
+using System.Linq;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace StackExchange.Redis.Tests.Issues
+{
+    public class Issue182 : TestBase
+    {
+        protected override string GetConfiguration() => $"{TestConfig.Current.MasterServerAndPort},responseTimeout=10000";
+
+        public Issue182(ITestOutputHelper output) : base (output) { }
+
+        [FactLongRunning]
+        public void SetMembers()
+        {
+            using (var conn = Create())
+            {
+                conn.ConnectionFailed += (s, a) =>
+                {
+                    Output.WriteLine(a.FailureType.ToString());
+                    Output.WriteLine(a.Exception.Message);
+                    Output.WriteLine(a.Exception.StackTrace);
+                };
+                var db = conn.GetDatabase();
+
+                var key = Me();
+                const int count = (int)5e6;
+
+                db.KeyDeleteAsync(key).Wait();
+                foreach (var _ in Enumerable.Range(0, count))
+                    db.SetAdd(key, Guid.NewGuid().ToByteArray(), CommandFlags.FireAndForget);
+
+                Assert.Equal(count, db.SetLengthAsync(key).Result); // SCARD for set
+
+                var task = db.SetMembersAsync(key);
+                task.Wait();
+                Assert.Equal(count, task.Result.Length); // SMEMBERS result length
+            }
+        }
+
+        [FactLongRunning]
+        public void SetUnion()
+        {
+            using (var conn = Create())
+            {
+                var db = conn.GetDatabase();
+
+                var key1 = Me() + ":1";
+                var key2 = Me() + ":2";
+                var dstkey = Me() + ":dst";
+
+                db.KeyDeleteAsync(key1).Wait();
+                db.KeyDeleteAsync(key2).Wait();
+                db.KeyDeleteAsync(dstkey).Wait();
+
+                const int count = (int)5e6;
+                foreach (var _ in Enumerable.Range(0, count))
+                {
+                    db.SetAdd(key1, Guid.NewGuid().ToByteArray(), CommandFlags.FireAndForget);
+                    db.SetAdd(key2, Guid.NewGuid().ToByteArray(), CommandFlags.FireAndForget);
+                }
+                Assert.Equal(count, db.SetLengthAsync(key1).Result); // SCARD for set 1
+                Assert.Equal(count, db.SetLengthAsync(key2).Result); // SCARD for set 2
+
+                db.SetCombineAndStoreAsync(SetOperation.Union, dstkey, key1, key2).Wait();
+                var dstLen = db.SetLength(dstkey);
+                Assert.Equal(count * 2, dstLen); // SCARD for destination set
+            }
+        }
+    }
+}

StackExchange.Redis.Tests/Issues/Issue791.cs

@@ -29,7 +29,7 @@ public void DefaultValue_IsTrue()
         [Fact]
         public void PreserveAsyncOrder_SetConnectionMultiplexerProperty()
         {
-            var multiplexer = ConnectionMultiplexer.Connect(TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort + ",preserveAsyncOrder=false");
+            var multiplexer = ConnectionMultiplexer.Connect(TestConfig.Current.MasterServerAndPort + ",preserveAsyncOrder=false");
             Assert.False(multiplexer.PreserveAsyncOrder);
         }
     }

StackExchange.Redis.Tests/Issues/SO25567566.cs

@@ -7,7 +7,7 @@ namespace StackExchange.Redis.Tests.Issues
 {
     public class SO25567566 : TestBase
     {
-        protected override string GetConfiguration() => $"{TestConfig.Current.MasterServer}:{TestConfig.Current.MasterPort}";
+        protected override string GetConfiguration() => TestConfig.Current.MasterServerAndPort;
         public SO25567566(ITestOutputHelper output) : base(output) { }
 
         [FactLongRunning]
@@ -70,4 +70,4 @@ private async Task<string> DoStuff(ConnectionMultiplexer conn)
             }
         }
     }
-}
\ No newline at end of file
+}

StackExchange.Redis.Tests/Keys.cs

@@ -34,7 +34,7 @@ public void RandomKey()
             using (var conn = Create(allowAdmin: true))
             {
                 var db = conn.GetDatabase();
-                conn.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.MasterPort).FlushDatabase();
+                conn.GetServer(TestConfig.Current.MasterServerAndPort).FlushDatabase();
                 string anyKey = db.KeyRandom();
 
                 Assert.Null(anyKey);

StackExchange.Redis.Tests/Locking.cs

@@ -9,7 +9,7 @@ namespace StackExchange.Redis.Tests
 {
     public class Locking : TestBase
     {
-        protected override string GetConfiguration() => TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort;
+        protected override string GetConfiguration() => TestConfig.Current.MasterServerAndPort;
         public Locking(ITestOutputHelper output) : base (output) { }
 
         public enum TestMode

StackExchange.Redis.Tests/MultiMaster.cs

@@ -12,7 +12,7 @@ namespace StackExchange.Redis.Tests
     public class MultiMaster : TestBase
     {
         protected override string GetConfiguration() =>
-            TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort + "," + TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort + ",password=" + TestConfig.Current.SecurePassword;
+            TestConfig.Current.MasterServerAndPort + "," + TestConfig.Current.SecureServerAndPort + ",password=" + TestConfig.Current.SecurePassword;
 
         public MultiMaster(ITestOutputHelper output) : base (output) { }
 
@@ -39,8 +39,8 @@ public async Task DeslaveGoesToPrimary()
             ConfigurationOptions config = GetMasterSlaveConfig();
             using (var conn = ConnectionMultiplexer.Connect(config))
             {
-                var primary = conn.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.MasterPort);
-                var secondary = conn.GetServer(TestConfig.Current.SlaveServer, TestConfig.Current.SlavePort);
+                var primary = conn.GetServer(TestConfig.Current.MasterServerAndPort);
+                var secondary = conn.GetServer(TestConfig.Current.SlaveServerAndPort);
 
                 primary.Ping();
                 secondary.Ping();
@@ -58,7 +58,7 @@ public async Task DeslaveGoesToPrimary()
                     conn.Configure(writer);
                     string log = writer.ToString();
 
-                    Assert.True(log.Contains("tie-break is unanimous at " + TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort), "unanimous");
+                    Assert.True(log.Contains("tie-break is unanimous at " + TestConfig.Current.MasterServerAndPort), "unanimous");
                 }
                 // k, so we know everyone loves 6379; is that what we get?
 
@@ -89,8 +89,8 @@ public async Task DeslaveGoesToPrimary()
                 // server topology changes from failures to recognize those changes
                 using (var conn2 = ConnectionMultiplexer.Connect(config))
                 {
-                    var primary2 = conn.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.MasterPort);
-                    var secondary2 = conn.GetServer(TestConfig.Current.SlaveServer, TestConfig.Current.SlavePort);
+                    var primary2 = conn.GetServer(TestConfig.Current.MasterServerAndPort);
+                    var secondary2 = conn.GetServer(TestConfig.Current.SlaveServerAndPort);
 
                     Writer.WriteLine($"Check: {primary2.EndPoint}: {primary2.ServerType}, Mode: {(primary2.IsSlave ? "Slave" : "Master")}");
                     Writer.WriteLine($"Check: {secondary2.EndPoint}: {secondary2.ServerType}, Mode: {(secondary2.IsSlave ? "Slave" : "Master")}");
@@ -143,15 +143,15 @@ public void TestMultiNoTieBreak()
 
         public static IEnumerable<object[]> GetConnections()
         {
-            yield return new object[] { TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort, TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort, TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort };
-            yield return new object[] { TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort, TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort, TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort };
-            yield return new object[] { TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort, TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort, null };
-            yield return new object[] { TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort, TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort, null };
-
-            yield return new object[] { null, TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort, TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort };
-            yield return new object[] { TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort, null, TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort };
-            yield return new object[] { null, TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort, TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort };
-            yield return new object[] { TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort, null, TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort };
+            yield return new object[] { TestConfig.Current.MasterServerAndPort, TestConfig.Current.MasterServerAndPort, TestConfig.Current.MasterServerAndPort };
+            yield return new object[] { TestConfig.Current.SecureServerAndPort, TestConfig.Current.SecureServerAndPort, TestConfig.Current.SecureServerAndPort };
+            yield return new object[] { TestConfig.Current.SecureServerAndPort, TestConfig.Current.MasterServerAndPort, null };
+            yield return new object[] { TestConfig.Current.MasterServerAndPort, TestConfig.Current.SecureServerAndPort, null };
+
+            yield return new object[] { null, TestConfig.Current.MasterServerAndPort, TestConfig.Current.MasterServerAndPort };
+            yield return new object[] { TestConfig.Current.MasterServerAndPort, null, TestConfig.Current.MasterServerAndPort };
+            yield return new object[] { null, TestConfig.Current.SecureServerAndPort, TestConfig.Current.SecureServerAndPort };
+            yield return new object[] { TestConfig.Current.SecureServerAndPort, null, TestConfig.Current.SecureServerAndPort };
             yield return new object[] { null, null, null };
         }
 
@@ -160,11 +160,11 @@ public void TestMultiWithTiebreak(string a, string b, string elected)
         {
             const string TieBreak = "__tie__";
             // set the tie-breakers to the expected state
-            using (var aConn = ConnectionMultiplexer.Connect(TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort))
+            using (var aConn = ConnectionMultiplexer.Connect(TestConfig.Current.MasterServerAndPort))
             {
                 aConn.GetDatabase().StringSet(TieBreak, a);
             }
-            using (var aConn = ConnectionMultiplexer.Connect(TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort + ",password=" + TestConfig.Current.SecurePassword))
+            using (var aConn = ConnectionMultiplexer.Connect(TestConfig.Current.SecureServerAndPort + ",password=" + TestConfig.Current.SecurePassword))
             {
                 aConn.GetDatabase().StringSet(TieBreak, b);
             }

StackExchange.Redis.Tests/PubSubNonParallel.cs

 using System.IO;
 using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -13,7 +14,7 @@ public class PubSubNonParallel : TestBase
         [Theory]
         [InlineData(false)]
         [InlineData(true)]
-        public void SubscriptionsSurviveMasterSwitch(bool useSharedSocketManager)
+        public async Task SubscriptionsSurviveMasterSwitchAsync(bool useSharedSocketManager)
         {
             using (var a = Create(allowAdmin: true, useSharedSocketManager: useSharedSocketManager))
             using (var b = Create(allowAdmin: true, useSharedSocketManager: useSharedSocketManager))
@@ -42,10 +43,10 @@ public void SubscriptionsSurviveMasterSwitch(bool useSharedSocketManager)
                     Interlocked.Increment(ref bCount);
                 });
 
-                Assert.False(a.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.MasterPort).IsSlave, TestConfig.Current.MasterPort + " is master via a");
-                Assert.True(a.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.SlavePort).IsSlave, TestConfig.Current.SlavePort + " is slave via a");
-                Assert.False(b.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.MasterPort).IsSlave, TestConfig.Current.MasterPort + " is master via b");
-                Assert.True(b.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.SlavePort).IsSlave, TestConfig.Current.SlavePort + " is slave via b");
+                Assert.False(a.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave, $"{TestConfig.Current.MasterServerAndPort} should be master via a");
+                Assert.True(a.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave, $"{TestConfig.Current.SlaveServerAndPort} should be slave via a");
+                Assert.False(b.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave, $"{TestConfig.Current.MasterServerAndPort} should be master via b");
+                Assert.True(b.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave, $"{TestConfig.Current.SlaveServerAndPort} should be slave via b");
 
                 var epA = subA.SubscribedEndpoint(channel);
                 var epB = subB.SubscribedEndpoint(channel);
@@ -68,18 +69,18 @@ public void SubscriptionsSurviveMasterSwitch(bool useSharedSocketManager)
                     Output.WriteLine("Changing master...");
                     using (var sw = new StringWriter())
                     {
-                        a.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.SlavePort).MakeMaster(ReplicationChangeOptions.All, sw);
+                        a.GetServer(TestConfig.Current.SlaveServerAndPort).MakeMaster(ReplicationChangeOptions.All, sw);
                         Output.WriteLine(sw.ToString());
                     }
                     subA.Ping();
                     subB.Ping();
                     Output.WriteLine("Pausing...");
-                    Thread.Sleep(2000);
+                    await Task.Delay(4000).ForAwait();
 
-                    Assert.True(a.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.MasterPort).IsSlave, TestConfig.Current.MasterPort + " is slave via a");
-                    Assert.False(a.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.SlavePort).IsSlave, TestConfig.Current.SlavePort + " is master via a");
-                    Assert.True(b.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.MasterPort).IsSlave, TestConfig.Current.MasterPort + " is slave via b");
-                    Assert.False(b.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.SlavePort).IsSlave, TestConfig.Current.SlavePort + " is master via b");
+                    Assert.True(a.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave, $"{TestConfig.Current.MasterServerAndPort} should be a slave via a");
+                    Assert.False(a.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave, $"{TestConfig.Current.SlaveServerAndPort} should be a master via a");
+                    Assert.True(b.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave, $"{TestConfig.Current.MasterServerAndPort} should be a slave via b");
+                    Assert.False(b.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave, $"{TestConfig.Current.SlaveServerAndPort} should be a master via b");
 
                     Output.WriteLine("Pause complete");
                     var counters = a.GetCounters();
@@ -88,6 +89,7 @@ public void SubscriptionsSurviveMasterSwitch(bool useSharedSocketManager)
                     Output.WriteLine("b outstanding: " + counters.TotalOutstanding);
                     subA.Ping();
                     subB.Ping();
+                    await Task.Delay(2000).ForAwait();
                     epA = subA.SubscribedEndpoint(channel);
                     epB = subB.SubscribedEndpoint(channel);
                     Output.WriteLine("a: " + EndPointCollection.ToString(epA));
@@ -108,7 +110,7 @@ public void SubscriptionsSurviveMasterSwitch(bool useSharedSocketManager)
                     Output.WriteLine("Restoring configuration...");
                     try
                     {
-                        a.GetServer(TestConfig.Current.MasterServer, TestConfig.Current.MasterPort).MakeMaster(ReplicationChangeOptions.All);
+                        a.GetServer(TestConfig.Current.MasterServerAndPort).MakeMaster(ReplicationChangeOptions.All);
                     }
                     catch
                     { }

StackExchange.Redis.Tests/Secure.cs

-using System;
-using System.Diagnostics;
-using System.Threading.Tasks;
-using Xunit;
-using Xunit.Abstractions;
-
-namespace StackExchange.Redis.Tests
-{
-    [Collection(NonParallelCollection.Name)]
-    public class Secure : TestBase
-    {
-        protected override string GetConfiguration() =>
-            TestConfig.Current.MasterServer + ":" + TestConfig.Current.SecurePort + ",password=" + TestConfig.Current.SecurePassword + ",name=MyClient";
-
-        public Secure(ITestOutputHelper output) : base (output) { }
-
-        [Theory]
-        [InlineData(true)]
-        [InlineData(false)]
-        public void MassiveBulkOpsFireAndForgetSecure(bool preserveOrder)
-        {
-            using (var muxer = Create())
-            {
-                muxer.PreserveAsyncOrder = preserveOrder;
-#if DEBUG
-                long oldAlloc = ConnectionMultiplexer.GetResultBoxAllocationCount();
-#endif
-                RedisKey key = "MBOF";
-                var conn = muxer.GetDatabase();
-                conn.Ping();
-
-                var watch = Stopwatch.StartNew();
-
-                for (int i = 0; i <= AsyncOpsQty; i++)
-                {
-                    conn.StringSet(key, i, flags: CommandFlags.FireAndForget);
-                }
-                int val = (int)conn.StringGet(key);
-                Assert.Equal(AsyncOpsQty, val);
-                watch.Stop();
-                Output.WriteLine("{2}: Time for {0} ops: {1}ms ({3}); ops/s: {4}", AsyncOpsQty, watch.ElapsedMilliseconds, Me(),
-                    preserveOrder ? "preserve order" : "any order",
-                    AsyncOpsQty / watch.Elapsed.TotalSeconds);
-#if DEBUG
-                long newAlloc = ConnectionMultiplexer.GetResultBoxAllocationCount();
-                Output.WriteLine("ResultBox allocations: {0}", newAlloc - oldAlloc);
-                Assert.True(newAlloc - oldAlloc <= 2, $"NewAllocs: {newAlloc}, OldAllocs: {oldAlloc}");
-#endif
-            }
-        }
-
-        [Fact]
-        public void CheckConfig()
-        {
-            var config = ConfigurationOptions.Parse(GetConfiguration());
-            foreach (var ep in config.EndPoints)
-            {
-                Output.WriteLine(ep.ToString());
-            }
-            Assert.Single(config.EndPoints);
-            Assert.Equal("changeme", config.Password);
-        }
-
-        [Fact]
-        public void Connect()
-        {
-            using (var server = Create())
-            {
-                server.GetDatabase().Ping();
-            }
-        }
-
-        [Theory]
-        [InlineData("wrong")]
-        [InlineData("")]
-        public async Task ConnectWithWrongPassword(string password)
-        {
-            var config = ConfigurationOptions.Parse(GetConfiguration());
-            config.Password = password;
-            config.ConnectRetry = 0; // we don't want to retry on closed sockets in this case.
-
-            var ex = await Assert.ThrowsAsync<RedisConnectionException>(async () =>
-            {
-                SetExpectedAmbientFailureCount(-1);
-                using (var conn = await ConnectionMultiplexer.ConnectAsync(config, Writer).ConfigureAwait(false))
-                {
-                    conn.GetDatabase().Ping();
-                }
-            }).ConfigureAwait(false);
-            Output.WriteLine("Exception: " + ex.Message);
-            Assert.Equal("It was not possible to connect to the redis server(s); to create a disconnected multiplexer, disable AbortOnConnectFail. AuthenticationFailure on PING", ex.Message);
-        }
-    }
-}
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace StackExchange.Redis.Tests
+{
+    [Collection(NonParallelCollection.Name)]
+    public class Secure : TestBase
+    {
+        protected override string GetConfiguration() =>
+            TestConfig.Current.SecureServerAndPort + ",password=" + TestConfig.Current.SecurePassword + ",name=MyClient";
+
+        public Secure(ITestOutputHelper output) : base (output) { }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void MassiveBulkOpsFireAndForgetSecure(bool preserveOrder)
+        {
+            using (var muxer = Create())
+            {
+                muxer.PreserveAsyncOrder = preserveOrder;
+#if DEBUG
+                long oldAlloc = ConnectionMultiplexer.GetResultBoxAllocationCount();
+#endif
+                RedisKey key = "MBOF";
+                var conn = muxer.GetDatabase();
+                conn.Ping();
+
+                var watch = Stopwatch.StartNew();
+
+                for (int i = 0; i <= AsyncOpsQty; i++)
+                {
+                    conn.StringSet(key, i, flags: CommandFlags.FireAndForget);
+                }
+                int val = (int)conn.StringGet(key);
+                Assert.Equal(AsyncOpsQty, val);
+                watch.Stop();
+                Output.WriteLine("{2}: Time for {0} ops: {1}ms ({3}); ops/s: {4}", AsyncOpsQty, watch.ElapsedMilliseconds, Me(),
+                    preserveOrder ? "preserve order" : "any order",
+                    AsyncOpsQty / watch.Elapsed.TotalSeconds);
+#if DEBUG
+                long newAlloc = ConnectionMultiplexer.GetResultBoxAllocationCount();
+                Output.WriteLine("ResultBox allocations: {0}", newAlloc - oldAlloc);
+                Assert.True(newAlloc - oldAlloc <= 2, $"NewAllocs: {newAlloc}, OldAllocs: {oldAlloc}");
+#endif
+            }
+        }
+
+        [Fact]
+        public void CheckConfig()
+        {
+            var config = ConfigurationOptions.Parse(GetConfiguration());
+            foreach (var ep in config.EndPoints)
+            {
+                Output.WriteLine(ep.ToString());
+            }
+            Assert.Single(config.EndPoints);
+            Assert.Equal("changeme", config.Password);
+        }
+
+        [Fact]
+        public void Connect()
+        {
+            using (var server = Create())
+            {
+                server.GetDatabase().Ping();
+            }
+        }
+
+        [Theory]
+        [InlineData("wrong")]
+        [InlineData("")]
+        public async Task ConnectWithWrongPassword(string password)
+        {
+            var config = ConfigurationOptions.Parse(GetConfiguration());
+            config.Password = password;
+            config.ConnectRetry = 0; // we don't want to retry on closed sockets in this case.
+
+            var ex = await Assert.ThrowsAsync<RedisConnectionException>(async () =>
+            {
+                SetExpectedAmbientFailureCount(-1);
+                using (var conn = await ConnectionMultiplexer.ConnectAsync(config, Writer).ConfigureAwait(false))
+                {
+                    conn.GetDatabase().Ping();
+                }
+            }).ConfigureAwait(false);
+            Output.WriteLine("Exception: " + ex.Message);
+            Assert.Equal("It was not possible to connect to the redis server(s); to create a disconnected multiplexer, disable AbortOnConnectFail. AuthenticationFailure on PING", ex.Message);
+        }
+    }
+}

StackExchange.Redis.Tests/TestBase.cs

@@ -18,7 +18,7 @@ public abstract class TestBase : IDisposable
     {
         protected ITestOutputHelper Output { get; }
         protected TextWriterOutputHelper Writer { get; }
-        protected virtual string GetConfiguration() => TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort + "," + TestConfig.Current.SlaveServer + ":" + TestConfig.Current.SlavePort;
+        protected virtual string GetConfiguration() => TestConfig.Current.MasterServerAndPort + "," + TestConfig.Current.SlaveServerAndPort;
 
         protected TestBase(ITestOutputHelper output)
         {
@@ -331,4 +331,4 @@ protected static TimeSpan RunConcurrent(Action work, int threads, int timeout =
             return watch.Elapsed;
         }
     }
-}
\ No newline at end of file
+}