RedisSortedSetStudyTest

RedisStudyTest/RedisLockStudyTest.cs

@@ -29,13 +29,12 @@ namespace RedisStudyTest
         public void RedisLockTest()
         {
             //启动50个线程
-            for (int i = 0; i < 50; i++)
+            for (int i = 0; i < 10; i++)
             {
                 var cc = new Thread(new ThreadStart(MyRedisLock));
                 //调用Start方法执行线程
                 cc.Start();
             }
-            //MyRedisLock();
         }
 
         private void MyRedisLock()

RedisStudyTest/RedisSortedSetStudyTest.cs

@@ -51,7 +51,7 @@ namespace RedisStudyTest
             var exits = redisDatabase.KeyExists(defaultRedisKey);
             Assert.False(exits);
 
-            var result = redisSortedSetStudy.SortedSetAdd(defaultRedisKey,"first",1,CommandFlags.None);
+            var result = redisSortedSetStudy.SortedSetAdd(defaultRedisKey, "first", 1, CommandFlags.None);
             Assert.True(result);
 
             var number = redisSortedSetStudy.SortedSetLength(defaultRedisKey);
@@ -61,13 +61,108 @@ namespace RedisStudyTest
         [Fact]
         public void SetAdd_SortedSetEntrys_Empty_Test()
         {
-            SortedSetEntry sortedSetEntry = new SortedSetEntry("first", 1);
-
             var addNumber = redisSortedSetStudy.SortedSetAdd(defaultRedisKey, new SortedSetEntry[] { }, CommandFlags.None);
             Assert.Equal(0, addNumber);
+        }
 
-            var result = redisSortedSetStudy.SortedSetAdd(defaultRedisKey, "first",1,CommandFlags.None);
-            Assert.True(result);
+        [Fact]
+        public void SetAddByOneTest()
+        {
+            //重载方法1
+            var addResult = redisSortedSetStudy.SortedSetAdd(defaultRedisKey,"first",1);
+            Assert.True(addResult);
+
+            //重载方法2
+            var addResult2 = redisSortedSetStudy.SortedSetAdd(defaultRedisKey, "second", 2, CommandFlags.None);
+            Assert.True(addResult2);
+
+            //反向验证
+            var members = redisSortedSetStudy.SortedSetLength(defaultRedisKey);
+            Assert.Equal(2, members);
+        }
+
+        [Fact]
+        public void SetAddByGroupTest()
+        {
+            SortedSetEntry[] sortedSetEntrys = new SortedSetEntry[] 
+            {
+                new SortedSetEntry("first", 1),
+                new SortedSetEntry("second", 2),
+                new SortedSetEntry("third", 3),
+                new SortedSetEntry("four", 4),
+                new SortedSetEntry("five", 5),
+            };
+
+            SortedSetEntry[] sortedSetEntrys2 = new SortedSetEntry[]
+            {
+                new SortedSetEntry("six", 6),
+                new SortedSetEntry("seven", 7),
+            };
+
+            //重载方法1
+            var memberNumber = redisSortedSetStudy.SortedSetAdd(defaultRedisKey, sortedSetEntrys, CommandFlags.None);
+            Assert.Equal(5, memberNumber);
+
+            //重载方法2
+            var memberNumber2 = redisSortedSetStudy.SortedSetAdd(defaultRedisKey, sortedSetEntrys2, When.Always, CommandFlags.None);
+            Assert.Equal(2, memberNumber2);
+
+            //验证数据
+            var totalNumber = redisSortedSetStudy.SortedSetLength(defaultRedisKey);
+
+            Assert.Equal(7, totalNumber);
+        }
+        #endregion
+
+        #region SortedSetIncrement
+
+        [Fact]
+        public void SortedSetIncrement_NotKey_Test()
+        {
+            var incResult = redisSortedSetStudy.SortedSetIncrement(defaultRedisKey, "first", 1.0);
+            Assert.Equal(1.0, incResult);
+        }
+
+        [Fact]
+        public void SortedSetIncrementTest()
+        {
+            var incResult = redisSortedSetStudy.SortedSetIncrement(defaultRedisKey, "first", 1.0);
+            Assert.Equal(1.0, incResult);
+
+            incResult = redisSortedSetStudy.SortedSetIncrement(defaultRedisKey, "first", 1.5);
+            double differenceValue = incResult - 2.5;
+            Assert.True(differenceValue < 0.01);
+
+            //增加负值等于减少
+            incResult = redisSortedSetStudy.SortedSetIncrement(defaultRedisKey, "first", -2.1);
+            differenceValue =0.4 - incResult;
+            Assert.True(differenceValue < 0.01);
+        }
+        #endregion
+
+        #region SortedSetDecrement
+
+        [Fact]
+        public void SortedSetDecrement_NotKey_Test()
+        {
+            var incResult = redisSortedSetStudy.SortedSetDecrement(defaultRedisKey, "first", 1.0);
+            Assert.Equal(-1.0, incResult);
+        }
+
+        [Fact]
+        public void SortedSetDecrementTest()
+        {
+            var decResult = redisSortedSetStudy.SortedSetIncrement(defaultRedisKey, "first", -1.0);
+            Assert.Equal(-1.0, decResult);
+
+            decResult = redisSortedSetStudy.SortedSetIncrement(defaultRedisKey, "first", -1.5);
+            double differenceValue =Math.Abs( -2.5 - decResult);
+            Assert.True(differenceValue < 0.01);
+
+            //减少负值等于增加
+            decResult = redisSortedSetStudy.SortedSetIncrement(defaultRedisKey, "first", 2.1);
+            differenceValue =Math.Abs(-0.4 - decResult);
+            Assert.True(differenceValue < 0.01);
         }
         #endregion
 

RedisStudyTest/RedisStringStudyTest.cs

@@ -138,7 +138,6 @@ namespace RedisStudyTest
             var redisValue = redisStringStudy.StringGet(defaultRedisKey);
             var anonymousType = JsonConvert.DeserializeAnonymousType(redisValue, stuent);
             Assert.True(anonymousType.Id == stuent.Id && anonymousType.Name == stuent.Name && anonymousType.Age == stuent.Age && anonymousType.Number == stuent.Number);
-
         }
 
         /// <summary>

RedisStuy/RedisSortedSetStudy.cs

@@ -23,7 +23,7 @@ namespace RedisStuy
         /// 如果这个 member 已经是有序集的成员，那么更新这个 member 的 score 值，
         /// 并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
         /// </summary>
-        public bool SortedSetAdd(RedisKey key, RedisValue member, double score,CommandFlags flags=CommandFlags.None)
+        public bool SortedSetAdd(RedisKey key, RedisValue member, double score, CommandFlags flags)
         {
             return redisDatabase.SortedSetAdd(key, member, score, flags);
         }
@@ -44,6 +44,7 @@ namespace RedisStuy
         /// 如果某个 SortedSetEntry 已经是有序集的成员，那么更新这个 member 的 score 值，
         /// 并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
         /// </summary>
+        /// <returns>添加到排序集合中的元素的数量，不包括已被更新的元素。</returns>
         public long SortedSetAdd(RedisKey key, SortedSetEntry[] values, CommandFlags flags)
         {
             return redisDatabase.SortedSetAdd(key, values,flags);
@@ -54,6 +55,7 @@ namespace RedisStuy
         /// 如果某个 SortedSetEntry 已经是有序集的成员，那么更新这个 member 的 score 值，
         /// 并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
         /// </summary>
+        /// <returns>添加到排序集合中的元素的数量，不包括已被更新的元素。</returns>
         public long SortedSetAdd(RedisKey key, SortedSetEntry[] values, When when = When.Always, CommandFlags flags = CommandFlags.None)
         {
             return redisDatabase.SortedSetAdd(key, values,when, flags);