Merge pull request #72 from cnblogs/improve-tests

cnblogs-dudu · web-flow · commit 244e953b305d · 2018-09-20T17:55:32.000+08:00
Improve tests
diff --git a/Enyim.Caching/IMemcachedClient.cs b/Enyim.Caching/IMemcachedClient.cs
@@ -28,6 +28,7 @@ public interface IMemcachedClient : IDisposable
         CasResult<object> GetWithCas(string key);
         CasResult<T> GetWithCas<T>(string key);
         IDictionary<string, CasResult<object>> GetWithCas(IEnumerable<string> keys);
+        Task<IDictionary<string, CasResult<object>>> GetWithCasAsync(IEnumerable<string> keys);
 
         bool Append(string key, ArraySegment<byte> data);
         CasResult<bool> Append(string key, ulong cas, ArraySegment<byte> data);
diff --git a/Enyim.Caching/Memcached/MemcachedNode.cs b/Enyim.Caching/Memcached/MemcachedNode.cs
@@ -96,7 +96,7 @@ public bool Ping()
                     if (this.isDisposed) return false;
 
                     // try to connect to the server
-                    using (var socket = this.CreateSocket()) ;
+                    using (var socket = this.CreateSocket());
 
                     if (this.internalPoolImpl.IsAlive)
                         return true;
diff --git a/Enyim.Caching/Memcached/Protocol/Binary/MultiGetOperation.cs b/Enyim.Caching/Memcached/Protocol/Binary/MultiGetOperation.cs
@@ -75,9 +75,9 @@ protected internal override IList<ArraySegment<byte>> GetBuffer()
         private bool? asyncLoopState;
         private Action<bool> afterAsyncRead;
 
-        protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
+        protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
         {
-            return ReadResponse(socket);
+            return new ValueTask<IOperationResult>(ReadResponse(socket));
         }
 
         protected internal override bool ReadResponseAsync(PooledSocket socket, Action<bool> next)
diff --git a/Enyim.Caching/Memcached/Protocol/Text/DeleteOperation.cs b/Enyim.Caching/Memcached/Protocol/Text/DeleteOperation.cs
@@ -24,12 +24,13 @@ protected internal override IOperationResult ReadResponse(PooledSocket socket)
             };
         }
 
-        protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
+        protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
         {
-            return new TextOperationResult
-            {
-                Success = String.Compare(TextSocketHelper.ReadResponse(socket), "DELETED", StringComparison.Ordinal) == 0
-            };
+            return new ValueTask<IOperationResult>(
+                new TextOperationResult
+                {
+                    Success = String.Compare(TextSocketHelper.ReadResponse(socket), "DELETED", StringComparison.Ordinal) == 0
+                });
         }
 
         protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)
diff --git a/Enyim.Caching/Memcached/Protocol/Text/FlushOperation.cs b/Enyim.Caching/Memcached/Protocol/Text/FlushOperation.cs
@@ -20,10 +20,10 @@ protected internal override IOperationResult ReadResponse(PooledSocket socket)
             return new TextOperationResult().Pass();
         }
 
-        protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
+        protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
         {
             TextSocketHelper.ReadResponse(socket);
-            return new TextOperationResult().Pass();
+            return new ValueTask<IOperationResult>(new TextOperationResult().Pass());
         }
 
         protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)
diff --git a/Enyim.Caching/Memcached/Protocol/Text/GetOperation.cs b/Enyim.Caching/Memcached/Protocol/Text/GetOperation.cs
@@ -37,19 +37,19 @@ CacheItem IGetOperation.Result
             get { return this.result; }
         }
 
-        protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
+        protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
         {
             GetResponse r = GetHelper.ReadItem(socket);
             var result = new TextOperationResult();
 
-            if (r == null) return result.Fail("Failed to read response");
+            if (r == null) return new ValueTask<IOperationResult>(result.Fail("Failed to read response"));
 
             this.result = r.Item;
             this.Cas = r.CasValue;
 
             GetHelper.FinishCurrent(socket);
 
-            return result.Pass();
+            return new ValueTask<IOperationResult>(result.Pass());
         }
 
         protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)
diff --git a/Enyim.Caching/Memcached/Protocol/Text/MultiGetOperation.cs b/Enyim.Caching/Memcached/Protocol/Text/MultiGetOperation.cs
@@ -62,7 +62,7 @@ Dictionary<string, CacheItem> IMultiGetOperation.Result
             get { return this.result; }
         }
 
-        protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
+        protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
         {
             var retval = new Dictionary<string, CacheItem>();
             var cas = new Dictionary<string, ulong>();
@@ -91,7 +91,7 @@ protected internal override async ValueTask<IOperationResult> ReadResponseAsync(
             this.result = retval;
             this.Cas = cas;
 
-            return new TextOperationResult().Pass();
+            return new ValueTask<IOperationResult>(new TextOperationResult().Pass());
         }
 
         protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)
diff --git a/Enyim.Caching/Memcached/Protocol/Text/MutatorOperation.cs b/Enyim.Caching/Memcached/Protocol/Text/MutatorOperation.cs
@@ -61,18 +61,18 @@ ulong IMutatorOperation.Result
             get { return this.result; }
         }
 
-        protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
-        {
+        protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
+        { 
             string response = TextSocketHelper.ReadResponse(socket);
             var result = new TextOperationResult();
 
             //maybe we should throw an exception when the item is not found?
             if (String.Compare(response, "NOT_FOUND", StringComparison.Ordinal) == 0)
-                return result.Fail("Failed to read response.  Item not found");
+                return new ValueTask<IOperationResult>(result.Fail("Failed to read response.  Item not found"));
 
             result.Success =
                 UInt64.TryParse(response, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, CultureInfo.InvariantCulture, out this.result);
-            return result;
+            return new ValueTask<IOperationResult>(result);
         }
 
         protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)
diff --git a/Enyim.Caching/Memcached/Protocol/Text/StatsOperation.cs b/Enyim.Caching/Memcached/Protocol/Text/StatsOperation.cs
@@ -73,7 +73,7 @@ Dictionary<string, string> IStatsOperation.Result
             get { return result; }
         }
 
-        protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
+        protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
         {
             var serverData = new Dictionary<string, string>();
 
@@ -110,7 +110,7 @@ protected internal override async ValueTask<IOperationResult> ReadResponseAsync(
 
             this.result = serverData;
 
-            return new TextOperationResult().Pass();
+            return new ValueTask<IOperationResult>(new TextOperationResult().Pass());
         }
 
         protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)
diff --git a/Enyim.Caching/Memcached/Protocol/Text/StoreOperationBase.cs b/Enyim.Caching/Memcached/Protocol/Text/StoreOperationBase.cs
@@ -74,12 +74,12 @@ protected internal override IOperationResult ReadResponse(PooledSocket socket)
             };
         }
 
-        protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
+        protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)
         {
-            return new TextOperationResult
+            return new ValueTask<IOperationResult>(new TextOperationResult
             {
                 Success = String.Compare(TextSocketHelper.ReadResponse(socket), "STORED", StringComparison.Ordinal) == 0
-            };
+            });
         }
 
         protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)
diff --git a/Enyim.Caching/MemcachedClient.cs b/Enyim.Caching/MemcachedClient.cs
@@ -125,7 +125,6 @@ public object Get(string key)
         /// </summary>
         /// <param name="key">The identifier for the item to retrieve.</param>
         /// <returns>The retrieved item, or <value>default(T)</value> if the key was not found.</returns>
-        [Obsolete]
         public T Get<T>(string key)
         {
             var result = PerformGet<T>(key);
@@ -975,7 +974,16 @@ public async Task<IDictionary<string, T>> GetAsync<T>(IEnumerable<string> keys)
 
         public IDictionary<string, CasResult<object>> GetWithCas(IEnumerable<string> keys)
         {
-            return PerformMultiGet<CasResult<object>>(keys, (mget, kvp) => new CasResult<object>
+            return PerformMultiGet(keys, (mget, kvp) => new CasResult<object>
+            {
+                Result = this.transcoder.Deserialize(kvp.Value),
+                Cas = mget.Cas[kvp.Key]
+            });
+        }
+
+        public async Task<IDictionary<string, CasResult<object>>> GetWithCasAsync(IEnumerable<string> keys)
+        {
+            return await PerformMultiGetAsync(keys, (mget, kvp) => new CasResult<object>
             {
                 Result = this.transcoder.Deserialize(kvp.Value),
                 Cas = mget.Cas[kvp.Key]
diff --git a/Enyim.Caching/NullMemcachedClient.cs b/Enyim.Caching/NullMemcachedClient.cs
@@ -109,19 +109,24 @@ public async Task<IGetOperationResult<T>> GetAsync<T>(string key)
             var result = new DefaultGetOperationResultFactory<T>().Create();
             result.Success = false;
             result.Value = default(T);
-            return result;
+            return await Task.FromResult(result);
         }
 
         public async Task<T> GetValueAsync<T>(string key)
         {
-            return default(T);
+            return await Task.FromResult(default(T));
         }
 
         public IDictionary<string, CasResult<object>> GetWithCas(IEnumerable<string> keys)
         {
             return new Dictionary<string, CasResult<object>>();
         }
 
+        public async Task<IDictionary<string, CasResult<object>>> GetWithCasAsync(IEnumerable<string> keys)
+        {
+            return await Task.FromResult(new Dictionary<string, CasResult<object>>());
+        }
+
         public CasResult<object> GetWithCas(string key)
         {
             return new CasResult<object>();
@@ -204,12 +209,12 @@ public bool Store(StoreMode mode, string key, object value, TimeSpan validFor)
 
         public async Task<bool> StoreAsync(StoreMode mode, string key, object value, TimeSpan validFor)
         {
-            return false;
+            return await Task.FromResult(false);
         }
 
         public async Task<bool> StoreAsync(StoreMode mode, string key, object value, DateTime expiresAt)
         {
-            return false;
+            return await Task.FromResult(false);
         }
 
         public bool Store(StoreMode mode, string key, object value, DateTime expiresAt)
diff --git a/MemcachedTest/BinaryMemcachedClientTest.cs b/MemcachedTest/BinaryMemcachedClientTest.cs
@@ -60,7 +60,7 @@ public virtual void CASTest()
                 // get back the item and check the cas value (it should match the cas from the set)
                 var r2 = client.GetWithCas<string>("CasItem1");
 
-                Assert.Equal(r2.Result, "foo");
+                Assert.Equal("foo", r2.Result);
                 Assert.Equal(r1.Cas, r2.Cas);
 
                 var r3 = client.Cas(StoreMode.Set, "CasItem1", "bar", r1.Cas - 1);
@@ -72,7 +72,7 @@ public virtual void CASTest()
                 Assert.True(r4.Result, "Overwriting with 'baz' should have succeeded.");
 
                 var r5 = client.GetWithCas<string>("CasItem1");
-                Assert.Equal(r5.Result, "baz");
+                Assert.Equal("baz", r5.Result);
             }
         }
 
@@ -94,7 +94,7 @@ public void AppendCASTest()
                 // get back the item and check the cas value (it should match the cas from the set)
                 var r3 = client.GetWithCas<string>("CasAppend");
 
-                Assert.Equal(r3.Result, "fool");
+                Assert.Equal("fool", r3.Result);
                 Assert.Equal(r2.Cas, r3.Cas);
 
                 var r4 = client.Append("CasAppend", r1.Cas, new System.ArraySegment<byte>(new byte[] { (byte)'l' }));
@@ -120,7 +120,7 @@ public void PrependCASTest()
                 // get back the item and check the cas value (it should match the cas from the set)
                 var r3 = client.GetWithCas<string>("CasPrepend");
 
-                Assert.Equal(r3.Result, "fool");
+                Assert.Equal("fool", r3.Result);
                 Assert.Equal(r2.Cas, r3.Cas);
 
                 var r4 = client.Prepend("CasPrepend", r1.Cas, new System.ArraySegment<byte>(new byte[] { (byte)'l' }));
diff --git a/MemcachedTest/MemcachedClientTest.cs b/MemcachedTest/MemcachedClientTest.cs
@@ -34,7 +34,7 @@ protected virtual MemcachedClient GetClient(MemcachedProtocol protocol = Memcach
                 services.AddSingleton<ITranscoder,BinaryFormatterTranscoder>();
             }
 
-            services.AddLogging(builder => builder.SetMinimumLevel(LogLevel.Error).AddConsole());
+            services.AddLogging(builder => builder.SetMinimumLevel(LogLevel.Debug).AddConsole());
 
             IServiceProvider serviceProvider = services.BuildServiceProvider();
             var client = serviceProvider.GetService<IMemcachedClient>() as MemcachedClient;
@@ -92,9 +92,9 @@ public void GetObjectTest()
                 TestData td2 = client.Get<TestData>(TestObjectKey);
 
                 Assert.NotNull(td2);
-                Assert.Equal(td2.FieldA, "Hello");
-                Assert.Equal(td2.FieldB, "World");
-                Assert.Equal(td2.FieldC, 19810619);
+                Assert.Equal("Hello", td2.FieldA);
+                Assert.Equal("World", td2.FieldB);
+                Assert.Equal(19810619, td2.FieldC);
                 Assert.True(td2.FieldD, "Object was corrupted.");
             }
 
@@ -104,9 +104,9 @@ public void GetObjectTest()
                 TestData td2 = client.Get<TestData>(TestObjectKey);
 
                 Assert.NotNull(td2);
-                Assert.Equal(td2.FieldA, "Hello");
-                Assert.Equal(td2.FieldB, "World");
-                Assert.Equal(td2.FieldC, 19810619);
+                Assert.Equal("Hello", td2.FieldA);
+                Assert.Equal("World", td2.FieldB);
+                Assert.Equal(19810619, td2.FieldC);
                 Assert.True(td2.FieldD, "Object was corrupted.");
             }
         }
@@ -218,38 +218,40 @@ public void AddSetReplaceTest()
             {
                 log.Debug("Cache should be empty.");
 
-                Assert.True(client.Store(StoreMode.Set, "VALUE", "1"), "Initialization failed");
+                var cacheKey = $"{nameof(AddSetReplaceTest)}-{Guid.NewGuid()}";
+
+                Assert.True(client.Store(StoreMode.Set, cacheKey, "1"), "Initialization failed");
 
                 log.Debug("Setting VALUE to 1.");
 
-                Assert.Equal("1", client.Get("VALUE"));
+                Assert.Equal("1", client.Get(cacheKey));
 
                 log.Debug("Adding VALUE; this should return false.");
-                Assert.False(client.Store(StoreMode.Add, "VALUE", "2"), "Add should have failed");
+                Assert.False(client.Store(StoreMode.Add, cacheKey, "2"), "Add should have failed");
 
                 log.Debug("Checking if VALUE is still '1'.");
-                Assert.Equal("1", client.Get("VALUE"));
+                Assert.Equal("1", client.Get(cacheKey));
 
                 log.Debug("Replacing VALUE; this should return true.");
-                Assert.True(client.Store(StoreMode.Replace, "VALUE", "4"), "Replace failed");
+                Assert.True(client.Store(StoreMode.Replace, cacheKey, "4"), "Replace failed");
 
                 log.Debug("Checking if VALUE is '4' so it got replaced.");
-                Assert.Equal("4", client.Get("VALUE"));
+                Assert.Equal("4", client.Get(cacheKey));
 
                 log.Debug("Removing VALUE.");
-                Assert.True(client.Remove("VALUE"), "Remove failed");
+                Assert.True(client.Remove(cacheKey), "Remove failed");
 
                 log.Debug("Replacing VALUE; this should return false.");
-                Assert.False(client.Store(StoreMode.Replace, "VALUE", "8"), "Replace should not have succeeded");
+                Assert.False(client.Store(StoreMode.Replace, cacheKey, "8"), "Replace should not have succeeded");
 
                 log.Debug("Checking if VALUE is 'null' so it was not replaced.");
-                Assert.Null(client.Get("VALUE"));
+                Assert.Null(client.Get(cacheKey));
 
                 log.Debug("Adding VALUE; this should return true.");
-                Assert.True(client.Store(StoreMode.Add, "VALUE", "16"), "Item should have been Added");
+                Assert.True(client.Store(StoreMode.Add, cacheKey, "16"), "Item should have been Added");
 
                 log.Debug("Checking if VALUE is '16' so it was added.");
-                Assert.Equal("16", client.Get("VALUE"));
+                Assert.Equal("16", client.Get(cacheKey));
 
                 log.Debug("Passed AddSetReplaceTest.");
             }
@@ -321,29 +323,40 @@ public virtual async Task MultiGetWithCasTest()
             using (var client = GetClient())
             {
                 var keys = new List<string>();
+                var tasks = new List<Task<bool>>();
 
-                for (int i = 0; i < 100; i++)
+                for (int i = 0; i < 10; i++)
                 {
-                    string k = $"Hello_Multi_Get_{Guid.NewGuid()}_" + i;
+                    string k = $"Hello_Multi_Get_{Guid.NewGuid()}_{new Random().Next()}" + i;
                     keys.Add(k);
 
-                    Assert.True(await client.StoreAsync(StoreMode.Set, k, i, DateTime.Now.AddSeconds(300)), "Store of " + k + " failed");
+                    tasks.Add(client.StoreAsync(StoreMode.Set, k, i, DateTime.Now.AddSeconds(300)));
                 }
 
-                var retvals = client.GetWithCas(keys);
+                await Task.WhenAll(tasks);
+
+                foreach (var task in tasks)
+                { 
+                    Assert.True(await task, "Store failed");
+                }
 
-                CasResult<object> value;
+                var retvals = await client.GetWithCasAsync(keys);
 
                 Assert.Equal(keys.Count, retvals.Count);
 
+                tasks.Clear();
                 for (int i = 0; i < keys.Count; i++)
                 {
                     string key = keys[i];
 
-                    Assert.True(retvals.TryGetValue(key, out value), "missing key: " + key);
+                    Assert.True(retvals.TryGetValue(key, out var value), "missing key: " + key);
                     Assert.Equal(value.Result, i);
                     Assert.NotEqual(value.Cas, (ulong)0);
+
+                    tasks.Add(client.RemoveAsync(key));
                 }
+
+                await Task.WhenAll(tasks);                
             }
         }
 
diff --git a/MemcachedTest/TextMemcachedClientTest.cs b/MemcachedTest/TextMemcachedClientTest.cs

Original file line number	Diff line number	Diff line change
`@@ -75,9 +75,9 @@ protected internal override IList<ArraySegment<byte>> GetBuffer()`
`75`	`75`	`private bool? asyncLoopState;`
`76`	`76`	`private Action<bool> afterAsyncRead;`
`77`	`77`
`78`		`- protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
	`78`	`+ protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
`79`	`79`	`{`
`80`		`- return ReadResponse(socket);`
	`80`	`+ return new ValueTask<IOperationResult>(ReadResponse(socket));`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`protected internal override bool ReadResponseAsync(PooledSocket socket, Action<bool> next)`
Original file line number	Diff line number	Diff line change
`@@ -24,12 +24,13 @@ protected internal override IOperationResult ReadResponse(PooledSocket socket)`
`24`	`24`	`};`
`25`	`25`	`}`
`26`	`26`
`27`		`- protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
	`27`	`+ protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
`28`	`28`	`{`
`29`		`- return new TextOperationResult`
`30`		`- {`
`31`		`- Success = String.Compare(TextSocketHelper.ReadResponse(socket), "DELETED", StringComparison.Ordinal) == 0`
`32`		`- };`
	`29`	`+ return new ValueTask<IOperationResult>(`
	`30`	`+ new TextOperationResult`
	`31`	`+ {`
	`32`	`+ Success = String.Compare(TextSocketHelper.ReadResponse(socket), "DELETED", StringComparison.Ordinal) == 0`
	`33`	`+ });`
`33`	`34`	`}`
`34`	`35`
`35`	`36`	`protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)`
Original file line number	Diff line number	Diff line change
`@@ -20,10 +20,10 @@ protected internal override IOperationResult ReadResponse(PooledSocket socket)`
`20`	`20`	`return new TextOperationResult().Pass();`
`21`	`21`	`}`
`22`	`22`
`23`		`- protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
	`23`	`+ protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
`24`	`24`	`{`
`25`	`25`	`TextSocketHelper.ReadResponse(socket);`
`26`		`- return new TextOperationResult().Pass();`
	`26`	`+ return new ValueTask<IOperationResult>(new TextOperationResult().Pass());`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)`
Original file line number	Diff line number	Diff line change
`@@ -37,19 +37,19 @@ CacheItem IGetOperation.Result`
`37`	`37`	`get { return this.result; }`
`38`	`38`	`}`
`39`	`39`
`40`		`- protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
	`40`	`+ protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
`41`	`41`	`{`
`42`	`42`	`GetResponse r = GetHelper.ReadItem(socket);`
`43`	`43`	`var result = new TextOperationResult();`
`44`	`44`
`45`		`- if (r == null) return result.Fail("Failed to read response");`
	`45`	`+ if (r == null) return new ValueTask<IOperationResult>(result.Fail("Failed to read response"));`
`46`	`46`
`47`	`47`	`this.result = r.Item;`
`48`	`48`	`this.Cas = r.CasValue;`
`49`	`49`
`50`	`50`	`GetHelper.FinishCurrent(socket);`
`51`	`51`
`52`		`- return result.Pass();`
	`52`	`+ return new ValueTask<IOperationResult>(result.Pass());`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ Dictionary<string, CacheItem> IMultiGetOperation.Result`
`62`	`62`	`get { return this.result; }`
`63`	`63`	`}`
`64`	`64`
`65`		`- protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
	`65`	`+ protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
`66`	`66`	`{`
`67`	`67`	`var retval = new Dictionary<string, CacheItem>();`
`68`	`68`	`var cas = new Dictionary<string, ulong>();`
`@@ -91,7 +91,7 @@ protected internal override async ValueTask<IOperationResult> ReadResponseAsync(`
`91`	`91`	`this.result = retval;`
`92`	`92`	`this.Cas = cas;`
`93`	`93`
`94`		`- return new TextOperationResult().Pass();`
	`94`	`+ return new ValueTask<IOperationResult>(new TextOperationResult().Pass());`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ Dictionary<string, string> IStatsOperation.Result`
`73`	`73`	`get { return result; }`
`74`	`74`	`}`
`75`	`75`
`76`		`- protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
	`76`	`+ protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
`77`	`77`	`{`
`78`	`78`	`var serverData = new Dictionary<string, string>();`
`79`	`79`
`@@ -110,7 +110,7 @@ protected internal override async ValueTask<IOperationResult> ReadResponseAsync(`
`110`	`110`
`111`	`111`	`this.result = serverData;`
`112`	`112`
`113`		`- return new TextOperationResult().Pass();`
	`113`	`+ return new ValueTask<IOperationResult>(new TextOperationResult().Pass());`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)`
Original file line number	Diff line number	Diff line change
`@@ -74,12 +74,12 @@ protected internal override IOperationResult ReadResponse(PooledSocket socket)`
`74`	`74`	`};`
`75`	`75`	`}`
`76`	`76`
`77`		`- protected internal override async ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
	`77`	`+ protected internal override ValueTask<IOperationResult> ReadResponseAsync(PooledSocket socket)`
`78`	`78`	`{`
`79`		`- return new TextOperationResult`
	`79`	`+ return new ValueTask<IOperationResult>(new TextOperationResult`
`80`	`80`	`{`
`81`	`81`	`Success = String.Compare(TextSocketHelper.ReadResponse(socket), "STORED", StringComparison.Ordinal) == 0`
`82`		`- };`
	`82`	`+ });`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`protected internal override bool ReadResponseAsync(PooledSocket socket, System.Action<bool> next)`