ConfigureAwait love for tests

MigratedBookSleeveTestSuite/Constraints.cs

@@ -35,7 +35,7 @@ public void TestManualIncr()
 
         public async Task<long?> ManualIncr(IDatabase connection, string key)
         {
-            var oldVal = (long?)await connection.StringGetAsync(key);
+            var oldVal = (long?)await connection.StringGetAsync(key).ConfigureAwait(false);
             var newVal = (oldVal ?? 0) + 1;
             var tran = connection.CreateTransaction();
             { // check hasn't changed
@@ -44,7 +44,7 @@ public void TestManualIncr()
                 tran.AddCondition(Condition.StringEqual(key, oldVal));
                 tran.StringSetAsync(key, newVal);
 #pragma warning restore 4014
-                if (!await tran.ExecuteAsync()) return null; // aborted
+                if (!await tran.ExecuteAsync().ConfigureAwait(false)) return null; // aborted
                 return newVal;
             }
         }

MigratedBookSleeveTestSuite/Program.cs

@@ -170,8 +170,7 @@ where Attribute.IsDefined(method, typeof(TestAttribute))
 [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
 public sealed class ActiveTestAttribute : Attribute
 {
-    private readonly int count;
-    public int Count { get { return count; } }
+    public int Count { get; }
     public ActiveTestAttribute() : this(1) { }
-    public ActiveTestAttribute(int count) { this.count = count; }
+    public ActiveTestAttribute(int count) { this.Count = count; }
 }
\ No newline at end of file

StackExchange.Redis.Tests/Config.cs

@@ -170,7 +170,7 @@ public async System.Threading.Tasks.Task TestConfigureAsync()
             {
                 Thread.Sleep(1000);
                 Debug.WriteLine("About to reconfigure.....");
-                await muxer.ConfigureAsync();
+                await muxer.ConfigureAsync().ConfigureAwait(false);
                 Debug.WriteLine("Reconfigured");
             }
         }

StackExchange.Redis.Tests/FloatingPoint.cs

@@ -70,15 +70,15 @@ public async void IncrDecrFloatingPointAsync()
                 double sum = 0;
                 foreach (var value in incr)
                 {
-                    await db.StringIncrementAsync(key, value);
+                    await db.StringIncrementAsync(key, value).ConfigureAwait(false);
                     sum += value;
                 }
                 foreach (var value in decr)
                 {
-                    await db.StringDecrementAsync(key, value);
+                    await db.StringDecrementAsync(key, value).ConfigureAwait(false);
                     sum -= value;
                 }
-                var val = (double)await db.StringGetAsync(key);
+                var val = (double)await db.StringGetAsync(key).ConfigureAwait(false);
 
                 Assert.IsTrue(Within(sum, val, 0.0001));
             }
@@ -146,15 +146,15 @@ public async void HashIncrDecrFloatingPointAsync()
                 double sum = 0;
                 foreach (var value in incr)
                 {
-                    await db.HashIncrementAsync(key, field, value);
+                    await db.HashIncrementAsync(key, field, value).ConfigureAwait(false);
                     sum += value;
                 }
                 foreach (var value in decr)
                 {
-                    await db.HashDecrementAsync(key, field, value);
+                    await db.HashDecrementAsync(key, field, value).ConfigureAwait(false);
                     sum -= value;
                 }
-                var val = (double)await db.HashGetAsync(key, field);
+                var val = (double)await db.HashGetAsync(key, field).ConfigureAwait(false);
 
                 Assert.IsTrue(Within(sum, val, 0.0001));
             }

StackExchange.Redis.Tests/Issues/SO25567566.cs

@@ -18,7 +18,7 @@ public async void Execute()
             {
                 for(int i = 0; i < 100; i++)
                 {
-                    Assert.AreEqual("ok", await DoStuff(conn));
+                    Assert.AreEqual("ok", await DoStuff(conn).ConfigureAwait(false));
 
                 }
             }
@@ -30,13 +30,13 @@ private async Task<string> DoStuff(ConnectionMultiplexer conn)
             var timeout = Task.Delay(5000);
             var len = db.ListLengthAsync("list");
 
-            if (await Task.WhenAny(timeout, len) != len)
+            if (await Task.WhenAny(timeout, len).ConfigureAwait(false) != len)
             {
                 return "Timeout getting length";
             }
 
             
-            if ((await len) == 0)
+            if ((await len.ConfigureAwait(false)) == 0)
             {
                 db.ListRightPush("list", "foo", flags: CommandFlags.FireAndForget);
             }
@@ -48,14 +48,14 @@ private async Task<string> DoStuff(ConnectionMultiplexer conn)
 
             var exec = tran.ExecuteAsync();
             // SWAP THESE TWO
-            bool ok = await Task.WhenAny(exec, timeout) == exec;
+            bool ok = await Task.WhenAny(exec, timeout).ConfigureAwait(false) == exec;
             //bool ok = true;
 
             if (ok)
             {
-                if (await exec)
+                if (await exec.ConfigureAwait(false))
                 {
-                    await Task.WhenAll(x, y, z);
+                    await Task.WhenAll(x, y, z).ConfigureAwait(false);
 
                     var db2 = conn.GetDatabase();
                     db2.HashGet("hash", "whatever");

StackExchange.Redis.Tests/Profiling.cs

@@ -447,7 +447,7 @@ public void LowAllocationEnumerable()
                           .ContinueWith(
                             async _ =>
                             {
-                                return (string)(await db.StringGetAsync("foo" + i));
+                                return (string)(await db.StringGetAsync("foo" + i).ConfigureAwait(false));
                             }
                           );
 

StackExchange.Redis.Tests/TaskTests.cs

@@ -109,7 +109,7 @@ private void Continue(Task task)
             }
             private async void DoAwait(Task task)
             {
-                await task;
+                await task.ConfigureAwait(false);
                 continuationThread = Environment.CurrentManagedThreadId;
                 evt.Set();
             }

StackExchange.Redis.Tests/Transactions.cs

@@ -333,12 +333,12 @@ public async void BasicTran()
                 var g = db.KeyExists(key);
                 
 
-                Assert.AreEqual(10, await a);
-                Assert.AreEqual(15, await b);
-                Assert.AreEqual(15, (long)await c);
-                Assert.IsTrue(await d);
-                Assert.IsTrue(await e);
-                Assert.IsFalse(await f);
+                Assert.AreEqual(10, await a.ConfigureAwait(false));
+                Assert.AreEqual(15, await b.ConfigureAwait(false));
+                Assert.AreEqual(15, (long)await c.ConfigureAwait(false));
+                Assert.IsTrue(await d.ConfigureAwait(false));
+                Assert.IsTrue(await e.ConfigureAwait(false));
+                Assert.IsFalse(await f.ConfigureAwait(false));
                 Assert.IsFalse(g);
             }
         }