zoukankan      html  css  js  c++  java
  • ServiceStack.Redis

    官方源码:

    https://github.com/ServiceStack/ServiceStack.Redis

    首先项目NuGet程序包安装ServiceStack.Redis

    仅供自己参考。


    string

    public class RedisClientTestsBase
        {
            protected string CleanMask = null;
            protected RedisClient Redis;
    
            protected void Log(string fmt, params object[] args)
            {
                Debug.WriteLine("{0}", string.Format(fmt, args).Trim());
            }
    
            [OneTimeSetUp]
            public virtual void OnBeforeTestFixture()
            {
                RedisClient.NewFactoryFn = () => new RedisClient(TestConfig.SingleHost);
                using (var redis = RedisClient.New())
                {
                    redis.FlushAll();
                }
            }
    
            [OneTimeTearDown]
            public virtual void OnAfterTestFixture()
            {
            }
    
            [SetUp]
            public virtual void OnBeforeEachTest()
            {
                Redis = RedisClient.New();
            }
    
            [TearDown]
            public virtual void OnAfterEachTest()
            {
                try
                {
                    if (Redis.NamespacePrefix != null && CleanMask == null) CleanMask = Redis.NamespacePrefix + "*";
                    if (CleanMask != null) Redis.SearchKeys(CleanMask).ForEach(t => Redis.Del(t));
                    Redis.Dispose();
                }
                catch (RedisResponseException e)
                {
                    // if exception has that message then it still proves that BgSave works as expected.
                    if (e.Message.StartsWith("Can't BGSAVE while AOF log rewriting is in progress"))
                        return;
    
                    throw;
                }
            }
    
            protected string PrefixedKey(string key)
            {
                return string.Concat(Redis.NamespacePrefix, key);
            }
    
            public RedisClient GetRedisClient()
            {
                var client = new RedisClient(TestConfig.SingleHost);
                return client;
            }
    
            public RedisClient CreateRedisClient()
            {
                var client = new RedisClient(TestConfig.SingleHost);
                return client;
            }
    
            public string GetString(byte[] stringBytes)
            {
                return Encoding.UTF8.GetString(stringBytes);
            }
    
            public byte[] GetBytes(string stringValue)
            {
                return Encoding.UTF8.GetBytes(stringValue);
            }
        }
     public class RedisClientTests
            : RedisClientTestsBase
        {
            const string Value = "Value";
    
            public override void OnBeforeEachTest()
            {
                base.OnBeforeEachTest();
                Redis.NamespacePrefix = "RedisClientTests";
            }
    
            [Test]
            public void Can_Set_and_Get_string()
            {
                Redis.SetValue("key", Value);
                var valueBytes = Redis.Get("key");
                var valueString = GetString(valueBytes);
                Redis.Remove("key");
    
                Assert.That(valueString, Is.EqualTo(Value));
            }
    
            [Test]
            public void Can_Set_and_Get_key_with_space()
            {
                Redis.SetValue("key with space", Value);
                var valueBytes = Redis.Get("key with space");
                var valueString = GetString(valueBytes);
                Redis.Remove("key with space");
    
                Assert.That(valueString, Is.EqualTo(Value));
            }
    
            [Test]
            public void Can_Set_and_Get_key_with_spaces()
            {
                const string key = "key with spaces";
    
                Redis.SetValue(key, Value);
                var valueBytes = Redis.Get(key);
                var valueString = GetString(valueBytes);
    
                Assert.That(valueString, Is.EqualTo(Value));
            }
    
            [Test]
            public void Can_Set_and_Get_key_with_all_byte_values()
            {
                const string key = "bytesKey";
    
                var value = new byte[256];
                for (var i = 0; i < value.Length; i++)
                {
                    value[i] = (byte)i;
                }
    
                Redis.Set(key, value);
                var resultValue = Redis.Get(key);
    
                Assert.That(resultValue, Is.EquivalentTo(value));
            }
    
            [Test]
            public void GetKeys_returns_matching_collection()
            {
                Redis.Set("ss-tests:a1", "One");
                Redis.Set("ss-tests:a2", "One");
                Redis.Set("ss-tests:b3", "One");
    
                var matchingKeys = Redis.SearchKeys("ss-tests:a*");
    
                Assert.That(matchingKeys.Count, Is.EqualTo(2));
            }
    
            [Test]
            public void GetKeys_on_non_existent_keys_returns_empty_collection()
            {
                var matchingKeys = Redis.SearchKeys("ss-tests:NOTEXISTS");
    
                Assert.That(matchingKeys.Count, Is.EqualTo(0));
            }
    
            [Test]
            public void Can_get_Types()
            {
                Redis.SetValue("string", "string");
                Redis.AddItemToList("list", "list");
                Redis.AddItemToSet("set", "set");
                Redis.AddItemToSortedSet("sortedset", "sortedset");
                Redis.SetEntryInHash("hash", "key", "val");
    
                Assert.That(Redis.GetEntryType("nokey"), Is.EqualTo(RedisKeyType.None));
                Assert.That(Redis.GetEntryType("string"), Is.EqualTo(RedisKeyType.String));
                Assert.That(Redis.GetEntryType("list"), Is.EqualTo(RedisKeyType.List));
                Assert.That(Redis.GetEntryType("set"), Is.EqualTo(RedisKeyType.Set));
                Assert.That(Redis.GetEntryType("sortedset"), Is.EqualTo(RedisKeyType.SortedSet));
                Assert.That(Redis.GetEntryType("hash"), Is.EqualTo(RedisKeyType.Hash));
            }
    
            [Test]
            public void Can_delete_keys()
            {
                Redis.SetValue("key", "val");
    
                Assert.That(Redis.ContainsKey("key"), Is.True);
    
                Redis.Del("key");
    
                Assert.That(Redis.ContainsKey("key"), Is.False);
    
                var keysMap = new Dictionary<string, string>();
    
                10.Times(i => keysMap.Add("key" + i, "val" + i));
    
                Redis.SetAll(keysMap);
    
                10.Times(i => Assert.That(Redis.ContainsKey("key" + i), Is.True));
    
                Redis.Del(keysMap.Keys.ToArray());
    
                10.Times(i => Assert.That(Redis.ContainsKey("key" + i), Is.False));
            }
    
            [Test]
            public void Can_get_RandomKey()
            {
                Redis.Db = 15;
                var keysMap = new Dictionary<string, string>();
    
                10.Times(i => keysMap.Add(Redis.NamespacePrefix + "key" + i, "val" + i));
    
                Redis.SetAll(keysMap);
    
                var randKey = Redis.RandomKey();
    
                Assert.That(keysMap.ContainsKey(randKey), Is.True);
            }
    
            [Test]
            public void Can_RenameKey()
            {
                Redis.SetValue("oldkey", "val");
                Redis.Rename("oldkey", "newkey");
    
                Assert.That(Redis.ContainsKey("oldkey"), Is.False);
                Assert.That(Redis.ContainsKey("newkey"), Is.True);
            }
    
            [Test]
            public void Can_Expire()
            {
                Redis.SetValue("key", "val");
                Redis.Expire("key", 1);
                Assert.That(Redis.ContainsKey("key"), Is.True);
                Thread.Sleep(2000);
                Assert.That(Redis.ContainsKey("key"), Is.False);
            }
    
            [Test]
            public void Can_Expire_Ms()
            {
                Redis.SetValue("key", "val");
                Redis.ExpireEntryIn("key", TimeSpan.FromMilliseconds(100));
                Assert.That(Redis.ContainsKey("key"), Is.True);
                Thread.Sleep(500);
                Assert.That(Redis.ContainsKey("key"), Is.False);
            }
    
            [Ignore("Changes in system clock can break test")]
            [Test]
            public void Can_ExpireAt()
            {
                Redis.SetValue("key", "val");
    
                var unixNow = DateTime.Now.ToUnixTime();
                var in2Secs = unixNow + 2;
    
                Redis.ExpireAt("key", in2Secs);
    
                Assert.That(Redis.ContainsKey("key"), Is.True);
                Thread.Sleep(3000);
                Assert.That(Redis.ContainsKey("key"), Is.False);
            }
    
            [Test]
            public void Can_GetTimeToLive()
            {
                Redis.SetValue("key", "val");
                Redis.Expire("key", 10);
    
                var ttl = Redis.GetTimeToLive("key");
                Assert.That(ttl.Value.TotalSeconds, Is.GreaterThanOrEqualTo(9));
                Thread.Sleep(1700);
    
                ttl = Redis.GetTimeToLive("key");
                Assert.That(ttl.Value.TotalSeconds, Is.LessThanOrEqualTo(9));
            }
    
            [Test]
            public void Can_GetServerTime()
            {
                var now = Redis.GetServerTime();
    
                now.Kind.PrintDump();
                now.ToString("D").Print();
                now.ToString("T").Print();
    
                "UtcNow".Print();
                DateTime.UtcNow.ToString("D").Print();
                DateTime.UtcNow.ToString("T").Print();
    
                Assert.That(now.Date, Is.EqualTo(DateTime.UtcNow.Date));
            }
    
            [Test]
            public void Can_Ping()
            {
                Assert.That(Redis.Ping(), Is.True);
            }
    
            [Test]
            public void Can_Echo()
            {
                Assert.That(Redis.Echo("Hello"), Is.EqualTo("Hello"));
            }
    
            [Test]
            public void Can_SlaveOfNoOne()
            {
                Redis.SlaveOfNoOne();
            }
    
            [Test]
            public void Can_Save()
            {
                try
                {
                    Redis.Save();
                }
                catch (RedisResponseException e)
                {
                    // if exception has that message then it still proves that BgSave works as expected.
                    if (e.Message.StartsWith("Can't BGSAVE while AOF log rewriting is in progress")
                        || e.Message.StartsWith("An AOF log rewriting in progress: can't BGSAVE right now")
                        || e.Message.StartsWith("Background save already in progress"))
                        return;
    
                    throw;
                }
            }
    
            [Test]
            public void Can_BgSave()
            {
                try
                {
                    Redis.BgSave();
                }
                catch (RedisResponseException e)
                {
                    // if exception has that message then it still proves that BgSave works as expected.
                    if (e.Message.StartsWith("Can't BGSAVE while AOF log rewriting is in progress")
                        || e.Message.StartsWith("An AOF log rewriting in progress: can't BGSAVE right now")
                        || e.Message.StartsWith("Background save already in progress"))
                        return;
    
                    throw;
                }
            }
    
            [Test]
            public void Can_Quit()
            {
                Redis.Quit();
                Redis.NamespacePrefix = null;
                CleanMask = null;
            }
    
            [Test]
            public void Can_BgRewriteAof()
            {
                Redis.BgRewriteAof();
            }
    
            [Test]
            [Ignore("Works too well and shutdown the server")]
            public void Can_Shutdown()
            {
                Redis.Shutdown();
            }
    
            [Test]
            public void Can_get_Keys_with_pattern()
            {
                5.Times(i => Redis.SetValue("k1:" + i, "val"));
                5.Times(i => Redis.SetValue("k2:" + i, "val"));
    
                var keys = Redis.Keys("k1:*");
                Assert.That(keys.Length, Is.EqualTo(5));
            }
    
            [Test]
            public void Can_GetAll()
            {
                var keysMap = new Dictionary<string, string>();
    
                10.Times(i => keysMap.Add("key" + i, "val" + i));
    
                Redis.SetAll(keysMap);
    
                var map = Redis.GetAll<string>(keysMap.Keys);
                var mapKeys = Redis.GetValues(keysMap.Keys.ToList<string>());
    
                foreach (var entry in keysMap)
                {
                    Assert.That(map.ContainsKey(entry.Key), Is.True);
                    Assert.That(mapKeys.Contains(entry.Value), Is.True);
                }
            }
    
            [Test]
            public void Can_GetValues_JSON_strings()
            {
                var val = "{"AuthorId":0,"Created":"\/Date(1345961754013)\/","Name":"test","Base64":"BQELAAEBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAViA/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP8BWAFYgP8BWAFYAViA/wFYAVgBWID/AVgBWAFYgP8BWAFYAViA/4D/gP+A/4D/AVgBWID/gP8BWID/gP8BWID/gP+A/wFYgP+A/4D/gP8BWID/gP+A/4D/gP+A/wFYAViA/4D/AViA/4D/AVgBWAFYgP8BWAFYAViA/4D/AViA/4D/gP+A/4D/gP8BWAFYgP+A/wFYgP+A/wFYgP+A/4D/gP+A/wFYgP+A/wFYgP+A/4D/gP+A/4D/AVgBWID/gP8BWID/gP8BWAFYAViA/wFYAVgBWID/gP8BWID/gP+A/4D/gP+A/wFYAViA/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP8BWAFYgP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/AVgBWID/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/wFYAViA/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP8BWAFYgP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/AVgBWID/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/4D/gP+A/wFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAFYAVgBWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"}";
    
                Redis.SetValue("UserLevel/1", val);
    
                var vals = Redis.GetValues(new List<string>(new[] { "UserLevel/1" }));
    
                Assert.That(vals.Count, Is.EqualTo(1));
                Assert.That(vals[0], Is.EqualTo(val));
            }
    
            [Test]
            public void Can_AcquireLock()
            {
                var key = PrefixedKey("AcquireLockKey");
                var lockKey = PrefixedKey("Can_AcquireLock");
                Redis.IncrementValue(key); //1
    
                var asyncResults = 5.TimesAsync(i =>
                    IncrementKeyInsideLock(key, lockKey, i, new RedisClient(TestConfig.SingleHost) { NamespacePrefix = Redis.NamespacePrefix }));
    
                asyncResults.WaitAll(TimeSpan.FromSeconds(5));
    
                var val = Redis.Get<int>(key);
    
                Assert.That(val, Is.EqualTo(1 + 5));
            }
    
            private void IncrementKeyInsideLock(String key, String lockKey, int clientNo, IRedisClient client)
            {
                using (client.AcquireLock(lockKey))
                {
                    Debug.WriteLine(String.Format("client {0} acquired lock", clientNo));
                    var val = client.Get<int>(key);
    
                    Thread.Sleep(200);
    
                    client.Set(key, val + 1);
                    Debug.WriteLine(String.Format("client {0} released lock", clientNo));
                }
            }
    
            [Test]
            public void Can_AcquireLock_TimeOut()
            {
                var key = PrefixedKey("AcquireLockKeyTimeOut");
                var lockKey = PrefixedKey("Can_AcquireLock_TimeOut");
                Redis.IncrementValue(key); //1
                var acquiredLock = Redis.AcquireLock(lockKey);
                var waitFor = TimeSpan.FromMilliseconds(1000);
                var now = DateTime.Now;
    
                try
                {
                    using (var client = new RedisClient(TestConfig.SingleHost))
                    {
                        using (client.AcquireLock(lockKey, waitFor))
                        {
                            Redis.IncrementValue(key); //2
                        }
                    }
                }
                catch (TimeoutException)
                {
                    var val = Redis.Get<int>(key);
                    Assert.That(val, Is.EqualTo(1));
    
                    var timeTaken = DateTime.Now - now;
                    Assert.That(timeTaken.TotalMilliseconds > waitFor.TotalMilliseconds, Is.True);
                    Assert.That(timeTaken.TotalMilliseconds < waitFor.TotalMilliseconds + 1000, Is.True);
                    return;
                }
                Assert.Fail("should have Timed out");
            }
    
            [Test]
            public void Can_Append()
            {
                const string expectedString = "Hello, " + "World!";
                Redis.SetValue("key", "Hello, ");
                var currentLength = Redis.AppendToValue("key", "World!");
    
                Assert.That(currentLength, Is.EqualTo(expectedString.Length));
    
                var val = Redis.GetValue("key");
                Assert.That(val, Is.EqualTo(expectedString));
            }
    
            [Test]
            public void Can_GetRange()
            {
                const string helloWorld = "Hello, World!";
                Redis.SetValue("key", helloWorld);
    
                var fromIndex = "Hello, ".Length;
                var toIndex = "Hello, World".Length - 1;
    
                var expectedString = helloWorld.Substring(fromIndex, toIndex - fromIndex + 1);
                var world = Redis.GetRange("key", fromIndex, toIndex);
    
                Assert.That(world.Length, Is.EqualTo(expectedString.Length));
            }
    
            [Test]
            public void Can_create_distributed_lock()
            {
                var key = "lockkey";
                int lockTimeout = 2;
    
                var distributedLock = new DistributedLock();
                long lockExpire;
                Assert.AreEqual(distributedLock.Lock(key, lockTimeout, lockTimeout, out lockExpire, Redis), DistributedLock.LOCK_ACQUIRED);
    
                //can't re-lock
                distributedLock = new DistributedLock();
                Assert.AreEqual(distributedLock.Lock(key, lockTimeout, lockTimeout, out lockExpire, Redis), DistributedLock.LOCK_NOT_ACQUIRED);
    
                // re-acquire lock after timeout
                Thread.Sleep(lockTimeout * 1000 + 1000);
                distributedLock = new DistributedLock();
                Assert.AreEqual(distributedLock.Lock(key, lockTimeout, lockTimeout, out lockExpire, Redis), DistributedLock.LOCK_RECOVERED);
    
    
                Assert.IsTrue(distributedLock.Unlock(key, lockExpire, Redis));
    
                //can now lock
                distributedLock = new DistributedLock();
                Assert.AreEqual(distributedLock.Lock(key, lockTimeout, lockTimeout, out lockExpire, Redis), DistributedLock.LOCK_ACQUIRED);
    
    
                //cleanup
                Assert.IsTrue(distributedLock.Unlock(key, lockExpire, Redis));
            }
    
            public class MyPoco
            {
                public int Id { get; set; }
                public string Name { get; set; }
            }
    
            [Test]
            public void Can_StoreObject()
            {
                object poco = new MyPoco { Id = 1, Name = "Test" };
    
                Redis.StoreObject(poco);
    
                Assert.That(Redis.GetValue(Redis.NamespacePrefix + "urn:mypoco:1"), Is.EqualTo("{"Id":1,"Name":"Test"}"));
    
                Assert.That(Redis.PopItemFromSet(Redis.NamespacePrefix + "ids:MyPoco"), Is.EqualTo("1"));
            }
    
            [Test]
            public void Can_store_multiple_keys()
            {
                var keys = 5.Times(x => "key" + x);
                var vals = 5.Times(x => "val" + x);
    
                using (var redis = RedisClient.New())
                {
                    redis.SetAll(keys, vals);
    
                    var all = redis.GetValues(keys);
                    Assert.AreEqual(vals, all);
                }
            }
    
            [Test]
            public void Can_store_Dictionary()
            {
                var keys = 5.Times(x => "key" + x);
                var vals = 5.Times(x => "val" + x);
                var map = new Dictionary<string, string>();
                keys.ForEach(x => map[x] = "val" + x);
    
                using (var redis = RedisClient.New())
                {
                    redis.SetAll(map);
    
                    var all = redis.GetValuesMap(keys);
                    Assert.AreEqual(map, all);
                }
            }
    
            [Test]
            public void Can_store_Dictionary_as_objects()
            {
                var map = new Dictionary<string, object>();
                map["key_a"] = "123";
                map["key_b"] = null;
    
                using (var redis = RedisClient.New())
                {
                    redis.SetAll(map);
    
                    Assert.That(redis.Get<string>("key_a"), Is.EqualTo("123"));
                    Assert.That(redis.Get("key_b"), Is.EqualTo(""));
                }
            }
    
    
            [Test]
            public void Can_store_Dictionary_as_bytes()
            {
                var map = new Dictionary<string, byte[]>();
                map["key_a"] = "123".ToUtf8Bytes();
                map["key_b"] = null;
    
                using (var redis = RedisClient.New())
                {
                    redis.SetAll(map);
    
                    Assert.That(redis.Get<string>("key_a"), Is.EqualTo("123"));
                    Assert.That(redis.Get("key_b"), Is.EqualTo(""));
                }
            }
    
            [Test]
            public void Should_reset_slowlog()
            {
                using (var redis = RedisClient.New())
                {
                    redis.SlowlogReset();
                }
            }
    
            [Test]
            public void Can_get_showlog()
            {
                using (var redis = RedisClient.New())
                {
                    var log = redis.GetSlowlog(10);
    
                    foreach (var t in log)
                    {
                        Console.WriteLine(t.Id);
                        Console.WriteLine(t.Duration);
                        Console.WriteLine(t.Timestamp);
                        Console.WriteLine(string.Join(":", t.Arguments));
                    }
                }
            }
    
    
            [Test]
            public void Can_change_db_at_runtime()
            {
                using (var redis = new RedisClient(TestConfig.SingleHost, TestConfig.RedisPort, db: 1))
                {
                    var val = Environment.TickCount;
                    var key = "test" + val;
                    try
                    {
                        redis.Set(key, val);
                        redis.ChangeDb(2);
                        Assert.That(redis.Get<int>(key), Is.EqualTo(0));
                        redis.ChangeDb(1);
                        Assert.That(redis.Get<int>(key), Is.EqualTo(val));
                        redis.Dispose();
                    }
                    finally
                    {
                        redis.ChangeDb(1);
                        redis.Del(key);
                    }
                }
            }
    
            [Test]
            public void Can_Set_Expire_Seconds()
            {
                Redis.SetValue("key", "val", expireIn: TimeSpan.FromSeconds(1));
                Assert.That(Redis.ContainsKey("key"), Is.True);
                Thread.Sleep(2000);
                Assert.That(Redis.ContainsKey("key"), Is.False);
            }
    
            [Test]
            public void Can_Set_Expire_MilliSeconds()
            {
                Redis.SetValue("key", "val", expireIn: TimeSpan.FromMilliseconds(1000));
                Assert.That(Redis.ContainsKey("key"), Is.True);
                Thread.Sleep(2000);
                Assert.That(Redis.ContainsKey("key"), Is.False);
            }
    
            [Test]
            public void Can_Set_Expire_Seconds_if_exists()
            {
                Assert.That(Redis.SetValueIfExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1500)),
                    Is.False);
                Assert.That(Redis.ContainsKey("key"), Is.False);
    
                Redis.SetValue("key", "val");
                Assert.That(Redis.SetValueIfExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1000)),
                    Is.True);
                Assert.That(Redis.ContainsKey("key"), Is.True);
    
                Thread.Sleep(2000);
                Assert.That(Redis.ContainsKey("key"), Is.False);
            }
    
            [Test]
            public void Can_Set_Expire_Seconds_if_not_exists()
            {
                Assert.That(Redis.SetValueIfNotExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1000)),
                    Is.True);
                Assert.That(Redis.ContainsKey("key"), Is.True);
    
                Assert.That(Redis.SetValueIfNotExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1000)),
                    Is.False);
    
                Thread.Sleep(2000);
                Assert.That(Redis.ContainsKey("key"), Is.False);
    
                Redis.Remove("key");
                Redis.SetValueIfNotExists("key", "val", expireIn: TimeSpan.FromMilliseconds(1000));
                Assert.That(Redis.ContainsKey("key"), Is.True);
            }
        }

    list

     public class RedisClientTestsBase
        {
            protected string CleanMask = null;
            protected RedisClient Redis;
    
            protected void Log(string fmt, params object[] args)
            {
                Debug.WriteLine("{0}", string.Format(fmt, args).Trim());
            }
    
            [OneTimeSetUp]
            public virtual void OnBeforeTestFixture()
            {
                RedisClient.NewFactoryFn = () => new RedisClient(TestConfig.SingleHost);
                using (var redis = RedisClient.New())
                {
                    redis.FlushAll();
                }
            }
    
            [OneTimeTearDown]
            public virtual void OnAfterTestFixture()
            {
            }
    
            [SetUp]
            public virtual void OnBeforeEachTest()
            {
                Redis = RedisClient.New();
            }
    
            [TearDown]
            public virtual void OnAfterEachTest()
            {
                try
                {
                    if (Redis.NamespacePrefix != null && CleanMask == null) CleanMask = Redis.NamespacePrefix + "*";
                    if (CleanMask != null) Redis.SearchKeys(CleanMask).ForEach(t => Redis.Del(t));
                    Redis.Dispose();
                }
                catch (RedisResponseException e)
                {
                    // if exception has that message then it still proves that BgSave works as expected.
                    if (e.Message.StartsWith("Can't BGSAVE while AOF log rewriting is in progress"))
                        return;
    
                    throw;
                }
            }
    
            protected string PrefixedKey(string key)
            {
                return string.Concat(Redis.NamespacePrefix, key);
            }
    
            public RedisClient GetRedisClient()
            {
                var client = new RedisClient(TestConfig.SingleHost);
                return client;
            }
    
            public RedisClient CreateRedisClient()
            {
                var client = new RedisClient(TestConfig.SingleHost);
                return client;
            }
    
            public string GetString(byte[] stringBytes)
            {
                return Encoding.UTF8.GetString(stringBytes);
            }
    
            public byte[] GetBytes(string stringValue)
            {
                return Encoding.UTF8.GetBytes(stringValue);
            }
        }
    public class RedisClientListTests
            : RedisClientTestsBase
        {
            const string ListId = "rcl_testlist";
            const string ListId2 = "rcl_testlist2";
            private List<string> storeMembers;
    
            public RedisClientListTests()
            {
                CleanMask = "rcl_testlist*";
            }
    
            public override void OnBeforeEachTest()
            {
                base.OnBeforeEachTest();
                storeMembers = new List<string> { "one", "two", "three", "four" };
            }
    
            private static void AssertAreEqual(List<string> actualList, List<string> expectedList)
            {
                Assert.That(actualList, Has.Count.EqualTo(expectedList.Count));
                var i = 0;
                actualList.ForEach(x => Assert.That(x, Is.EqualTo(expectedList[i++])));
            }
    
            private static void AssertAreEqual(List<string> actualList, Queue<string> expectedList)
            {
                Assert.That(actualList, Has.Count.EqualTo(expectedList.Count));
                actualList.ForEach(x => Assert.That(x, Is.EqualTo(expectedList.Dequeue())));
            }
    
            [Test]
            public void Can_PopAndPushItemBetweenLists()
            {
                Redis.AddItemToList(ListId, "1");
                Redis.PopAndPushItemBetweenLists(ListId, ListId2);
            }
    
            [Test]
            public void Can_BlockingPopAndPushItemBetweenLists()
            {
                Redis.AddItemToList(ListId, "A");
                Redis.AddItemToList(ListId, "B");
                var r = Redis.BlockingPopAndPushItemBetweenLists(ListId, ListId2, new TimeSpan(0, 0, 1));
    
                Assert.That(r, Is.EqualTo("B"));
            }
    
            [Test]
            public void Can_Timeout_BlockingPopAndPushItemBetweenLists()
            {
                var r = Redis.BlockingPopAndPushItemBetweenLists(ListId, ListId2, new TimeSpan(0, 0, 1));
                Assert.That(r, Is.Null);
            }
    
            [Test]
            public void Can_AddToList_and_GetAllFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));//添加
    
                var members = Redis.GetAllItemsFromList(ListId);//获取
    
                AssertAreEqual(members, storeMembers);//测试
            }
    
            [Test]
            public void Can_AddRangeToList_and_GetAllFromList()
            {
                Redis.AddRangeToList(ListId, storeMembers);
    
                var members = Redis.GetAllItemsFromList(ListId);
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_PrependRangeToList_and_GetAllFromList()
            {
                Redis.PrependRangeToList(ListId, storeMembers);
    
                var members = Redis.GetAllItemsFromList(ListId);
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_GetListCount()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var listCount = Redis.GetListCount(ListId);
    
                Assert.That(listCount, Is.EqualTo(storeMembers.Count));
            }
    
            [Test]
            public void Can_GetItemFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var storeMember3 = storeMembers[2];
                var item3 = Redis.GetItemFromList(ListId, 2);
    
                Assert.That(item3, Is.EqualTo(storeMember3));
            }
    
            [Test]
            public void Can_SetItemInList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                storeMembers[2] = "five";
                Redis.SetItemInList(ListId, 2, "five");
    
                var members = Redis.GetAllItemsFromList(ListId);
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_PopFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var item4 = Redis.PopItemFromList(ListId);
    
                Assert.That(item4, Is.EqualTo("four"));
            }
    
            [Test]
            public void Can_EnqueueOnList()
            {
                var queue = new Queue<string>();
                storeMembers.ForEach(queue.Enqueue);
                storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x));
    
                while (queue.Count > 0)
                {
                    var actual = Redis.DequeueItemFromList(ListId);
                    Assert.That(actual, Is.EqualTo(queue.Dequeue()));
                }
            }
    
            [Test]
            public void Can_DequeueFromList()
            {
                var queue = new Queue<string>();
                storeMembers.ForEach(queue.Enqueue);
                storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x));
    
                var item1 = Redis.DequeueItemFromList(ListId);
    
                Assert.That(item1, Is.EqualTo(queue.Dequeue()));
            }
    
            [Test]
            public void PopAndPushSameAsDequeue()
            {
                var queue = new Queue<string>();
                storeMembers.ForEach(queue.Enqueue);
                storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x));
    
                var item1 = Redis.PopAndPushItemBetweenLists(ListId, ListId2);
                Assert.That(item1, Is.EqualTo(queue.Dequeue()));
            }
    
            [Test]
            public void Can_BlockingDequeueFromList()
            {
                var queue = new Queue<string>();
                storeMembers.ForEach(queue.Enqueue);
                storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x));
    
                var item1 = Redis.BlockingDequeueItemFromList(ListId, null);
    
                Assert.That(item1, Is.EqualTo(queue.Dequeue()));
            }
    
            [Test]
            public void BlockingDequeueFromList_Can_TimeOut()
            {
                var item1 = Redis.BlockingDequeueItemFromList(ListId, TimeSpan.FromSeconds(1));
                Assert.That(item1, Is.Null);
            }
    
            [Test]
            public void Can_PushToList()
            {
                var stack = new Stack<string>();
                storeMembers.ForEach(stack.Push);
                storeMembers.ForEach(x => Redis.PushItemToList(ListId, x));
    
                while (stack.Count > 0)
                {
                    var actual = Redis.PopItemFromList(ListId);
                    Assert.That(actual, Is.EqualTo(stack.Pop()));
                }
            }
    
            [Test]
            public void Can_BlockingPopFromList()
            {
                var stack = new Stack<string>();
                storeMembers.ForEach(stack.Push);
                storeMembers.ForEach(x => Redis.PushItemToList(ListId, x));
    
                var item1 = Redis.BlockingPopItemFromList(ListId, null);
    
                Assert.That(item1, Is.EqualTo(stack.Pop()));
            }
    
            [Test]
            public void BlockingPopFromList_Can_TimeOut()
            {
                var item1 = Redis.BlockingPopItemFromList(ListId, TimeSpan.FromSeconds(1));
                Assert.That(item1, Is.Null);
            }
    
            [Test]
            public void Can_RemoveStartFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var item1 = Redis.RemoveStartFromList(ListId);
    
                Assert.That(item1, Is.EqualTo(storeMembers.First()));
            }
    
            [Test]
            public void Can_RemoveEndFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var item1 = Redis.RemoveEndFromList(ListId);
    
                Assert.That(item1, Is.EqualTo(storeMembers.Last()));
            }
    
            [Test]
            public void Can_BlockingRemoveStartFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var item1 = Redis.BlockingRemoveStartFromList(ListId, null);
    
                Assert.That(item1, Is.EqualTo(storeMembers.First()));
            }
    
            [Test]
            public void Can_MoveBetweenLists()
            {
                var list1Members = new List<string> { "one", "two", "three", "four" };
                var list2Members = new List<string> { "five", "six", "seven" };
                const string item4 = "four";
    
                list1Members.ForEach(x => Redis.AddItemToList(ListId, x));
                list2Members.ForEach(x => Redis.AddItemToList(ListId2, x));
    
                list1Members.Remove(item4);
                list2Members.Insert(0, item4);
                Redis.PopAndPushItemBetweenLists(ListId, ListId2);
    
                var readList1 = Redis.GetAllItemsFromList(ListId);
                var readList2 = Redis.GetAllItemsFromList(ListId2);
    
                AssertAreEqual(readList1, list1Members);
                AssertAreEqual(readList2, list2Members);
            }
    
    
            [Test]
            public void Can_enumerate_small_list()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var readMembers = new List<string>();
                foreach (var item in Redis.Lists[ListId])
                {
                    readMembers.Add(item);
                }
                AssertAreEqual(readMembers, storeMembers);
            }
    
            [Test]
            public void Can_enumerate_large_list()
            {
                if (TestConfig.IgnoreLongTests) return;
    
                const int listSize = 2500;
    
                storeMembers = new List<string>();
                listSize.Times(x =>
                {
                    Redis.AddItemToList(ListId, x.ToString());
                    storeMembers.Add(x.ToString());
                });
    
                var members = new List<string>();
                foreach (var item in Redis.Lists[ListId])
                {
                    members.Add(item);
                }
                members.Sort((x, y) => int.Parse(x).CompareTo(int.Parse(y)));
                Assert.That(members.Count, Is.EqualTo(storeMembers.Count));
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_Add_to_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                var members = list.ToList<string>();
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_Clear_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                Assert.That(list.Count, Is.EqualTo(storeMembers.Count));
    
                list.Clear();
    
                Assert.That(list.Count, Is.EqualTo(0));
            }
    
            [Test]
            public void Can_Test_Contains_in_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                Assert.That(list.Contains("two"), Is.True);
                Assert.That(list.Contains("five"), Is.False);
            }
    
            [Test]
            public void Can_Remove_value_from_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                storeMembers.Remove("two");
                list.Remove("two");
    
                var members = list.ToList<string>();
    
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_RemoveAt_value_from_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                storeMembers.RemoveAt(2);
                list.RemoveAt(2);
    
                var members = list.ToList<string>();
    
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_get_default_index_from_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                for (var i = 0; i < storeMembers.Count; i++)
                {
                    Assert.That(list[i], Is.EqualTo(storeMembers[i]));
                }
            }
    
            [Test]
            public void Can_test_for_IndexOf_in_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                foreach (var item in storeMembers)
                {
                    Assert.That(list.IndexOf(item), Is.EqualTo(storeMembers.IndexOf(item)));
                }
            }
    
            [Test]
            public void Can_AddRangeToList_and_GetSortedItems()
            {
                Redis.PrependRangeToList(ListId, storeMembers);
    
                var members = Redis.GetSortedItemsFromList(ListId, new SortOptions { SortAlpha = true, SortDesc = true, Skip = 1, Take = 2 });
                AssertAreEqual(members, storeMembers.OrderByDescending(s => s).Skip(1).Take(2).ToList());
            }
    
            public class Test
            {
                public string A { get; set; }
            }
    
            [Test]
            public void RemoveAll_removes_all_items_from_Named_List()
            {
                var redis = Redis.As<Test>();
    
                var clientesRepo = redis.Lists["repo:Client:Test"];
    
                Assert.IsTrue(clientesRepo.Count == 0, "Count 1 = " + clientesRepo.Count);
                clientesRepo.Add(new Test() { A = "Test" });
                Assert.IsTrue(clientesRepo.Count == 1, "Count 2 = " + clientesRepo.Count);
                clientesRepo.RemoveAll();
                Assert.IsTrue(clientesRepo.Count == 0, "Count 3 = " + clientesRepo.Count);
            }
    
        }

    hash

    public class RedisClientListTests
            : RedisClientTestsBase
        {
            const string ListId = "rcl_testlist";
            const string ListId2 = "rcl_testlist2";
            private List<string> storeMembers;
    
            public RedisClientListTests()
            {
                CleanMask = "rcl_testlist*";
            }
    
            public override void OnBeforeEachTest()
            {
                base.OnBeforeEachTest();
                storeMembers = new List<string> { "one", "two", "three", "four" };
            }
    
            private static void AssertAreEqual(List<string> actualList, List<string> expectedList)
            {
                Assert.That(actualList, Has.Count.EqualTo(expectedList.Count));
                var i = 0;
                actualList.ForEach(x => Assert.That(x, Is.EqualTo(expectedList[i++])));
            }
    
            private static void AssertAreEqual(List<string> actualList, Queue<string> expectedList)
            {
                Assert.That(actualList, Has.Count.EqualTo(expectedList.Count));
                actualList.ForEach(x => Assert.That(x, Is.EqualTo(expectedList.Dequeue())));
            }
    
            [Test]
            public void Can_PopAndPushItemBetweenLists()
            {
                Redis.AddItemToList(ListId, "1");
                Redis.PopAndPushItemBetweenLists(ListId, ListId2);
            }
    
            [Test]
            public void Can_BlockingPopAndPushItemBetweenLists()
            {
                Redis.AddItemToList(ListId, "A");
                Redis.AddItemToList(ListId, "B");
                var r = Redis.BlockingPopAndPushItemBetweenLists(ListId, ListId2, new TimeSpan(0, 0, 1));
    
                Assert.That(r, Is.EqualTo("B"));
            }
    
            [Test]
            public void Can_Timeout_BlockingPopAndPushItemBetweenLists()
            {
                var r = Redis.BlockingPopAndPushItemBetweenLists(ListId, ListId2, new TimeSpan(0, 0, 1));
                Assert.That(r, Is.Null);
            }
    
            [Test]
            public void Can_AddToList_and_GetAllFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var members = Redis.GetAllItemsFromList(ListId);
    
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_AddRangeToList_and_GetAllFromList()
            {
                Redis.AddRangeToList(ListId, storeMembers);
    
                var members = Redis.GetAllItemsFromList(ListId);
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_PrependRangeToList_and_GetAllFromList()
            {
                Redis.PrependRangeToList(ListId, storeMembers);
    
                var members = Redis.GetAllItemsFromList(ListId);
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_GetListCount()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var listCount = Redis.GetListCount(ListId);
    
                Assert.That(listCount, Is.EqualTo(storeMembers.Count));
            }
    
            [Test]
            public void Can_GetItemFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var storeMember3 = storeMembers[2];
                var item3 = Redis.GetItemFromList(ListId, 2);
    
                Assert.That(item3, Is.EqualTo(storeMember3));
            }
    
            [Test]
            public void Can_SetItemInList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                storeMembers[2] = "five";
                Redis.SetItemInList(ListId, 2, "five");
    
                var members = Redis.GetAllItemsFromList(ListId);
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_PopFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var item4 = Redis.PopItemFromList(ListId);
    
                Assert.That(item4, Is.EqualTo("four"));
            }
    
            [Test]
            public void Can_EnqueueOnList()
            {
                var queue = new Queue<string>();
                storeMembers.ForEach(queue.Enqueue);
                storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x));
    
                while (queue.Count > 0)
                {
                    var actual = Redis.DequeueItemFromList(ListId);
                    Assert.That(actual, Is.EqualTo(queue.Dequeue()));
                }
            }
    
            [Test]
            public void Can_DequeueFromList()
            {
                var queue = new Queue<string>();
                storeMembers.ForEach(queue.Enqueue);
                storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x));
    
                var item1 = Redis.DequeueItemFromList(ListId);
    
                Assert.That(item1, Is.EqualTo(queue.Dequeue()));
            }
    
            [Test]
            public void PopAndPushSameAsDequeue()
            {
                var queue = new Queue<string>();
                storeMembers.ForEach(queue.Enqueue);
                storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x));
    
                var item1 = Redis.PopAndPushItemBetweenLists(ListId, ListId2);
                Assert.That(item1, Is.EqualTo(queue.Dequeue()));
            }
    
            [Test]
            public void Can_BlockingDequeueFromList()
            {
                var queue = new Queue<string>();
                storeMembers.ForEach(queue.Enqueue);
                storeMembers.ForEach(x => Redis.EnqueueItemOnList(ListId, x));
    
                var item1 = Redis.BlockingDequeueItemFromList(ListId, null);
    
                Assert.That(item1, Is.EqualTo(queue.Dequeue()));
            }
    
            [Test]
            public void BlockingDequeueFromList_Can_TimeOut()
            {
                var item1 = Redis.BlockingDequeueItemFromList(ListId, TimeSpan.FromSeconds(1));
                Assert.That(item1, Is.Null);
            }
    
            [Test]
            public void Can_PushToList()
            {
                var stack = new Stack<string>();
                storeMembers.ForEach(stack.Push);
                storeMembers.ForEach(x => Redis.PushItemToList(ListId, x));
    
                while (stack.Count > 0)
                {
                    var actual = Redis.PopItemFromList(ListId);
                    Assert.That(actual, Is.EqualTo(stack.Pop()));
                }
            }
    
            [Test]
            public void Can_BlockingPopFromList()
            {
                var stack = new Stack<string>();
                storeMembers.ForEach(stack.Push);
                storeMembers.ForEach(x => Redis.PushItemToList(ListId, x));
    
                var item1 = Redis.BlockingPopItemFromList(ListId, null);
    
                Assert.That(item1, Is.EqualTo(stack.Pop()));
            }
    
            [Test]
            public void BlockingPopFromList_Can_TimeOut()
            {
                var item1 = Redis.BlockingPopItemFromList(ListId, TimeSpan.FromSeconds(1));
                Assert.That(item1, Is.Null);
            }
    
            [Test]
            public void Can_RemoveStartFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var item1 = Redis.RemoveStartFromList(ListId);
    
                Assert.That(item1, Is.EqualTo(storeMembers.First()));
            }
    
            [Test]
            public void Can_RemoveEndFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var item1 = Redis.RemoveEndFromList(ListId);
    
                Assert.That(item1, Is.EqualTo(storeMembers.Last()));
            }
    
            [Test]
            public void Can_BlockingRemoveStartFromList()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var item1 = Redis.BlockingRemoveStartFromList(ListId, null);
    
                Assert.That(item1, Is.EqualTo(storeMembers.First()));
            }
    
            [Test]
            public void Can_MoveBetweenLists()
            {
                var list1Members = new List<string> { "one", "two", "three", "four" };
                var list2Members = new List<string> { "five", "six", "seven" };
                const string item4 = "four";
    
                list1Members.ForEach(x => Redis.AddItemToList(ListId, x));
                list2Members.ForEach(x => Redis.AddItemToList(ListId2, x));
    
                list1Members.Remove(item4);
                list2Members.Insert(0, item4);
                Redis.PopAndPushItemBetweenLists(ListId, ListId2);
    
                var readList1 = Redis.GetAllItemsFromList(ListId);
                var readList2 = Redis.GetAllItemsFromList(ListId2);
    
                AssertAreEqual(readList1, list1Members);
                AssertAreEqual(readList2, list2Members);
            }
    
    
            [Test]
            public void Can_enumerate_small_list()
            {
                storeMembers.ForEach(x => Redis.AddItemToList(ListId, x));
    
                var readMembers = new List<string>();
                foreach (var item in Redis.Lists[ListId])
                {
                    readMembers.Add(item);
                }
                AssertAreEqual(readMembers, storeMembers);
            }
    
            [Test]
            public void Can_enumerate_large_list()
            {
                if (TestConfig.IgnoreLongTests) return;
    
                const int listSize = 2500;
    
                storeMembers = new List<string>();
                listSize.Times(x =>
                {
                    Redis.AddItemToList(ListId, x.ToString());
                    storeMembers.Add(x.ToString());
                });
    
                var members = new List<string>();
                foreach (var item in Redis.Lists[ListId])
                {
                    members.Add(item);
                }
                members.Sort((x, y) => int.Parse(x).CompareTo(int.Parse(y)));
                Assert.That(members.Count, Is.EqualTo(storeMembers.Count));
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_Add_to_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                var members = list.ToList<string>();
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_Clear_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                Assert.That(list.Count, Is.EqualTo(storeMembers.Count));
    
                list.Clear();
    
                Assert.That(list.Count, Is.EqualTo(0));
            }
    
            [Test]
            public void Can_Test_Contains_in_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                Assert.That(list.Contains("two"), Is.True);
                Assert.That(list.Contains("five"), Is.False);
            }
    
            [Test]
            public void Can_Remove_value_from_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                storeMembers.Remove("two");
                list.Remove("two");
    
                var members = list.ToList<string>();
    
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_RemoveAt_value_from_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                storeMembers.RemoveAt(2);
                list.RemoveAt(2);
    
                var members = list.ToList<string>();
    
                AssertAreEqual(members, storeMembers);
            }
    
            [Test]
            public void Can_get_default_index_from_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                for (var i = 0; i < storeMembers.Count; i++)
                {
                    Assert.That(list[i], Is.EqualTo(storeMembers[i]));
                }
            }
    
            [Test]
            public void Can_test_for_IndexOf_in_IList()
            {
                var list = Redis.Lists[ListId];
                storeMembers.ForEach(list.Add);
    
                foreach (var item in storeMembers)
                {
                    Assert.That(list.IndexOf(item), Is.EqualTo(storeMembers.IndexOf(item)));
                }
            }
    
            [Test]
            public void Can_AddRangeToList_and_GetSortedItems()
            {
                Redis.PrependRangeToList(ListId, storeMembers);
    
                var members = Redis.GetSortedItemsFromList(ListId, new SortOptions { SortAlpha = true, SortDesc = true, Skip = 1, Take = 2 });
                AssertAreEqual(members, storeMembers.OrderByDescending(s => s).Skip(1).Take(2).ToList());
            }
    
            public class Test
            {
                public string A { get; set; }
            }
    
            [Test]
            public void RemoveAll_removes_all_items_from_Named_List()
            {
                var redis = Redis.As<Test>();
    
                var clientesRepo = redis.Lists["repo:Client:Test"];
    
                Assert.IsTrue(clientesRepo.Count == 0, "Count 1 = " + clientesRepo.Count);
                clientesRepo.Add(new Test() { A = "Test" });
                Assert.IsTrue(clientesRepo.Count == 1, "Count 2 = " + clientesRepo.Count);
                clientesRepo.RemoveAll();
                Assert.IsTrue(clientesRepo.Count == 0, "Count 3 = " + clientesRepo.Count);
            }
    
        }

     set

     public class RedisClientSetTests
            : RedisClientTestsBase
        {
            private const string SetIdSuffix = "testset";
            private List<string> storeMembers;
    
            private string SetId
            {
                get
                {
                    return this.PrefixedKey(SetIdSuffix);
                }
            }
    
            [SetUp]
            public override void OnBeforeEachTest()
            {
                base.OnBeforeEachTest();
                Redis.NamespacePrefix = "RedisClientSetTests";
                storeMembers = new List<string> { "one", "two", "three", "four" };
            }
    
            [Test]
            public void Can_AddToSet_and_GetAllFromSet()
            {
                storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x));
    
                var members = Redis.GetAllItemsFromSet(SetId);
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_AddRangeToSet_and_GetAllFromSet()
            {
                Redis.AddRangeToSet(SetId, storeMembers);
    
                var members = Redis.GetAllItemsFromSet(SetId);
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_RemoveFromSet()
            {
                const string removeMember = "two";
    
                storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x));
    
                Redis.RemoveItemFromSet(SetId, removeMember);
    
                storeMembers.Remove(removeMember);
    
                var members = Redis.GetAllItemsFromSet(SetId);
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_PopFromSet()
            {
                storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x));
    
                var member = Redis.PopItemFromSet(SetId);
    
                Assert.That(storeMembers.Contains(member), Is.True);
            }
    
            [Test]
            public void Can_MoveBetweenSets()
            {
                string fromSetId = PrefixedKey("testmovefromset");
                string toSetId = PrefixedKey("testmovetoset");
                const string moveMember = "four";
                var fromSetIdMembers = new List<string> { "one", "two", "three", "four" };
                var toSetIdMembers = new List<string> { "five", "six", "seven" };
    
                fromSetIdMembers.ForEach(x => Redis.AddItemToSet(fromSetId, x));
                toSetIdMembers.ForEach(x => Redis.AddItemToSet(toSetId, x));
    
                Redis.MoveBetweenSets(fromSetId, toSetId, moveMember);
    
                fromSetIdMembers.Remove(moveMember);
                toSetIdMembers.Add(moveMember);
    
                var readFromSetId = Redis.GetAllItemsFromSet(fromSetId);
                var readToSetId = Redis.GetAllItemsFromSet(toSetId);
    
                Assert.That(readFromSetId, Is.EquivalentTo(fromSetIdMembers));
                Assert.That(readToSetId, Is.EquivalentTo(toSetIdMembers));
            }
    
            [Test]
            public void Can_GetSetCount()
            {
                storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x));
    
                var setCount = Redis.GetSetCount(SetId);
    
                Assert.That(setCount, Is.EqualTo(storeMembers.Count));
            }
    
            [Test]
            public void Does_SetContainsValue()
            {
                const string existingMember = "two";
                const string nonExistingMember = "five";
    
                storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x));
    
                Assert.That(Redis.SetContainsItem(SetId, existingMember), Is.True);
                Assert.That(Redis.SetContainsItem(SetId, nonExistingMember), Is.False);
            }
    
            [Test]
            public void Can_IntersectBetweenSets()
            {
                string set1Name = PrefixedKey("testintersectset1");
                string set2Name = PrefixedKey("testintersectset2");
                var set1Members = new List<string> { "one", "two", "three", "four", "five" };
                var set2Members = new List<string> { "four", "five", "six", "seven" };
    
                set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x));
                set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x));
    
                var intersectingMembers = Redis.GetIntersectFromSets(set1Name, set2Name);
    
                Assert.That(intersectingMembers, Is.EquivalentTo(new List<string> { "four", "five" }));
            }
    
            [Test]
            public void Can_Store_IntersectBetweenSets()
            {
                string set1Name = PrefixedKey("testintersectset1");
                string set2Name = PrefixedKey("testintersectset2");
                string storeSetName = PrefixedKey("testintersectsetstore");
                var set1Members = new List<string> { "one", "two", "three", "four", "five" };
                var set2Members = new List<string> { "four", "five", "six", "seven" };
    
                set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x));
                set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x));
    
                Redis.StoreIntersectFromSets(storeSetName, set1Name, set2Name);
    
                var intersectingMembers = Redis.GetAllItemsFromSet(storeSetName);
    
                Assert.That(intersectingMembers, Is.EquivalentTo(new List<string> { "four", "five" }));
            }
    
            [Test]
            public void Can_UnionBetweenSets()
            {
                string set1Name = PrefixedKey("testunionset1");
                string set2Name = PrefixedKey("testunionset2");
                var set1Members = new List<string> { "one", "two", "three", "four", "five" };
                var set2Members = new List<string> { "four", "five", "six", "seven" };
    
                set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x));
                set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x));
    
                var unionMembers = Redis.GetUnionFromSets(set1Name, set2Name);
    
                Assert.That(unionMembers, Is.EquivalentTo(
                    new List<string> { "one", "two", "three", "four", "five", "six", "seven" }));
            }
    
            [Test]
            public void Can_Store_UnionBetweenSets()
            {
                string set1Name = PrefixedKey("testunionset1");
                string set2Name = PrefixedKey("testunionset2");
                string storeSetName = PrefixedKey("testunionsetstore");
                var set1Members = new List<string> { "one", "two", "three", "four", "five" };
                var set2Members = new List<string> { "four", "five", "six", "seven" };
    
                set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x));
                set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x));
    
                Redis.StoreUnionFromSets(storeSetName, set1Name, set2Name);
    
                var unionMembers = Redis.GetAllItemsFromSet(storeSetName);
    
                Assert.That(unionMembers, Is.EquivalentTo(
                    new List<string> { "one", "two", "three", "four", "five", "six", "seven" }));
            }
    
            [Test]
            public void Can_DiffBetweenSets()
            {
                string set1Name = PrefixedKey("testdiffset1");
                string set2Name = PrefixedKey("testdiffset2");
                string set3Name = PrefixedKey("testdiffset3");
                var set1Members = new List<string> { "one", "two", "three", "four", "five" };
                var set2Members = new List<string> { "four", "five", "six", "seven" };
                var set3Members = new List<string> { "one", "five", "seven", "eleven" };
    
                set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x));
                set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x));
                set3Members.ForEach(x => Redis.AddItemToSet(set3Name, x));
    
                var diffMembers = Redis.GetDifferencesFromSet(set1Name, set2Name, set3Name);
    
                Assert.That(diffMembers, Is.EquivalentTo(
                    new List<string> { "two", "three" }));
            }
    
            [Test]
            public void Can_Store_DiffBetweenSets()
            {
                string set1Name = PrefixedKey("testdiffset1");
                string set2Name = PrefixedKey("testdiffset2");
                string set3Name = PrefixedKey("testdiffset3");
                string storeSetName = PrefixedKey("testdiffsetstore");
                var set1Members = new List<string> { "one", "two", "three", "four", "five" };
                var set2Members = new List<string> { "four", "five", "six", "seven" };
                var set3Members = new List<string> { "one", "five", "seven", "eleven" };
    
                set1Members.ForEach(x => Redis.AddItemToSet(set1Name, x));
                set2Members.ForEach(x => Redis.AddItemToSet(set2Name, x));
                set3Members.ForEach(x => Redis.AddItemToSet(set3Name, x));
    
                Redis.StoreDifferencesFromSet(storeSetName, set1Name, set2Name, set3Name);
    
                var diffMembers = Redis.GetAllItemsFromSet(storeSetName);
    
                Assert.That(diffMembers, Is.EquivalentTo(
                    new List<string> { "two", "three" }));
            }
    
            [Test]
            public void Can_GetRandomEntryFromSet()
            {
                storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x));
    
                var randomEntry = Redis.GetRandomItemFromSet(SetId);
    
                Assert.That(storeMembers.Contains(randomEntry), Is.True);
            }
    
    
            [Test]
            public void Can_enumerate_small_ICollection_Set()
            {
                storeMembers.ForEach(x => Redis.AddItemToSet(SetId, x));
    
                var members = new List<string>();
                foreach (var item in Redis.Sets[SetId])
                {
                    members.Add(item);
                }
                members.Sort();
                Assert.That(members.Count, Is.EqualTo(storeMembers.Count));
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_enumerate_large_ICollection_Set()
            {
                if (TestConfig.IgnoreLongTests) return;
    
                const int setSize = 2500;
    
                storeMembers = new List<string>();
                setSize.Times(x =>
                {
                    Redis.AddItemToSet(SetId, x.ToString());
                    storeMembers.Add(x.ToString());
                });
    
                var members = new List<string>();
                foreach (var item in Redis.Sets[SetId])
                {
                    members.Add(item);
                }
                members.Sort((x, y) => int.Parse(x).CompareTo(int.Parse(y)));
                Assert.That(members.Count, Is.EqualTo(storeMembers.Count));
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_Add_to_ICollection_Set()
            {
                var list = Redis.Sets[SetId];
                storeMembers.ForEach(list.Add);
    
                var members = list.ToList();
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_Clear_ICollection_Set()
            {
                var list = Redis.Sets[SetId];
                storeMembers.ForEach(list.Add);
    
                Assert.That(list.Count, Is.EqualTo(storeMembers.Count));
    
                list.Clear();
    
                Assert.That(list.Count, Is.EqualTo(0));
            }
    
            [Test]
            public void Can_Test_Contains_in_ICollection_Set()
            {
                var list = Redis.Sets[SetId];
                storeMembers.ForEach(list.Add);
    
                Assert.That(list.Contains("two"), Is.True);
                Assert.That(list.Contains("five"), Is.False);
            }
    
            [Test]
            public void Can_Remove_value_from_ICollection_Set()
            {
                var list = Redis.Sets[SetId];
                storeMembers.ForEach(list.Add);
    
                storeMembers.Remove("two");
                list.Remove("two");
    
                var members = list.ToList();
    
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
        }

     Zset

    public class RedisClientSortedSetTests
            : RedisClientTestsBase
        {
            private const string SetIdSuffix = "testzset";
            private List<string> storeMembers;
    
            private string SetId
            {
                get
                {
                    return PrefixedKey(SetIdSuffix);
                }
            }
    
            Dictionary<string, double> stringDoubleMap;
    
            public override void OnBeforeEachTest()
            {
                base.OnBeforeEachTest();
                Redis.NamespacePrefix = "RedisClientSortedSetTests";
                storeMembers = new List<string> { "one", "two", "three", "four" };
    
                stringDoubleMap = new Dictionary<string, double> {
                     {"one",1}, {"two",2}, {"three",3}, {"four",4}
                 };
            }
    
            [Test]
            public void Can_AddItemToSortedSet_and_GetAllFromSet()
            {
                var i = 0;
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, i++));
    
                var members = Redis.GetAllItemsFromSortedSet(SetId);
                Assert.That(members.EquivalentTo(storeMembers), Is.True);
            }
    
            [Test]
            public void Can_AddRangeToSortedSet_and_GetAllFromSet()
            {
                var success = Redis.AddRangeToSortedSet(SetId, storeMembers, 1);
                Assert.That(success, Is.True);
    
                var members = Redis.GetAllItemsFromSortedSet(SetId);
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void AddToSet_without_score_adds_an_implicit_lexical_order_score()
            {
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x));
    
                var members = Redis.GetAllItemsFromSortedSet(SetId);
    
                storeMembers.Sort((x, y) => x.CompareTo(y));
                Assert.That(members.EquivalentTo(storeMembers), Is.True);
            }
    
            [Test]
            public void AddToSet_with_same_score_is_still_returned_in_lexical_order_score()
            {
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, 1));
    
                var members = Redis.GetAllItemsFromSortedSet(SetId);
    
                storeMembers.Sort((x, y) => x.CompareTo(y));
                Assert.That(members.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_RemoveFromSet()
            {
                const string removeMember = "two";
    
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x));
    
                Redis.RemoveItemFromSortedSet(SetId, removeMember);
    
                storeMembers.Remove(removeMember);
    
                var members = Redis.GetAllItemsFromSortedSet(SetId);
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_RemoveItemsFromSortedSet()
            {
                var removeMembers = new[] { "two" , "four", "six" };
    
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x));
    
                var removeCount = Redis.RemoveItemsFromSortedSet(SetId, removeMembers.ToList());
                Assert.That(removeCount, Is.EqualTo(2));
    
                removeMembers.Each(x => storeMembers.Remove(x));
    
                var members = Redis.GetAllItemsFromSortedSet(SetId);
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_PopFromSet()
            {
                var i = 0;
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, i++));
    
                var member = Redis.PopItemWithHighestScoreFromSortedSet(SetId);
    
                Assert.That(member, Is.EqualTo("four"));
            }
    
            [Test]
            public void Can_GetSetCount()
            {
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x));
    
                var setCount = Redis.GetSortedSetCount(SetId);
    
                Assert.That(setCount, Is.EqualTo(storeMembers.Count));
            }
    
            [Test]
            public void Can_GetSetCountByScores()
            {
                var scores = new List<double>();
    
                storeMembers.ForEach(x =>
                {
                    Redis.AddItemToSortedSet(SetId, x);
                    scores.Add(RedisClient.GetLexicalScore(x));
                });
    
                Assert.That(Redis.GetSortedSetCount(SetId, scores.Min(), scores.Max()), Is.EqualTo(storeMembers.Count()));
                Assert.That(Redis.GetSortedSetCount(SetId, scores.Min(), scores.Min()), Is.EqualTo(1));
            }
    
            [Test]
            public void Does_SortedSetContainsValue()
            {
                const string existingMember = "two";
                const string nonExistingMember = "five";
    
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x));
    
                Assert.That(Redis.SortedSetContainsItem(SetId, existingMember), Is.True);
                Assert.That(Redis.SortedSetContainsItem(SetId, nonExistingMember), Is.False);
            }
    
            [Test]
            public void Can_GetItemIndexInSortedSet_in_Asc_and_Desc()
            {
                var i = 10;
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, i++));
    
                Assert.That(Redis.GetItemIndexInSortedSet(SetId, "one"), Is.EqualTo(0));
                Assert.That(Redis.GetItemIndexInSortedSet(SetId, "two"), Is.EqualTo(1));
                Assert.That(Redis.GetItemIndexInSortedSet(SetId, "three"), Is.EqualTo(2));
                Assert.That(Redis.GetItemIndexInSortedSet(SetId, "four"), Is.EqualTo(3));
    
                Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "one"), Is.EqualTo(3));
                Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "two"), Is.EqualTo(2));
                Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "three"), Is.EqualTo(1));
                Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "four"), Is.EqualTo(0));
            }
    
            [Test]
            public void Can_Store_IntersectBetweenSets()
            {
                string set1Name = PrefixedKey("testintersectset1");
                string set2Name = PrefixedKey("testintersectset2");
                string storeSetName = PrefixedKey("testintersectsetstore");
                var set1Members = new List<string> { "one", "two", "three", "four", "five" };
                var set2Members = new List<string> { "four", "five", "six", "seven" };
    
                set1Members.ForEach(x => Redis.AddItemToSortedSet(set1Name, x));
                set2Members.ForEach(x => Redis.AddItemToSortedSet(set2Name, x));
    
                Redis.StoreIntersectFromSortedSets(storeSetName, set1Name, set2Name);
    
                var intersectingMembers = Redis.GetAllItemsFromSortedSet(storeSetName);
    
                Assert.That(intersectingMembers, Is.EquivalentTo(new List<string> { "four", "five" }));
            }
    
            [Test]
            public void Can_Store_UnionBetweenSets()
            {
                string set1Name = PrefixedKey("testunionset1");
                string set2Name = PrefixedKey("testunionset2");
                string storeSetName = PrefixedKey("testunionsetstore");
                var set1Members = new List<string> { "one", "two", "three", "four", "five" };
                var set2Members = new List<string> { "four", "five", "six", "seven" };
    
                set1Members.ForEach(x => Redis.AddItemToSortedSet(set1Name, x));
                set2Members.ForEach(x => Redis.AddItemToSortedSet(set2Name, x));
    
                Redis.StoreUnionFromSortedSets(storeSetName, set1Name, set2Name);
    
                var unionMembers = Redis.GetAllItemsFromSortedSet(storeSetName);
    
                Assert.That(unionMembers, Is.EquivalentTo(
                    new List<string> { "one", "two", "three", "four", "five", "six", "seven" }));
            }
    
            [Test]
            public void Can_pop_items_with_lowest_and_highest_scores_from_sorted_set()
            {
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x));
    
                storeMembers.Sort((x, y) => x.CompareTo(y));
    
                var lowestScore = Redis.PopItemWithLowestScoreFromSortedSet(SetId);
                Assert.That(lowestScore, Is.EqualTo(storeMembers.First()));
    
                var highestScore = Redis.PopItemWithHighestScoreFromSortedSet(SetId);
                Assert.That(highestScore, Is.EqualTo(storeMembers[storeMembers.Count - 1]));
            }
    
            [Test]
            public void Can_GetRangeFromSortedSetByLowestScore_from_sorted_set()
            {
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x));
    
                storeMembers.Sort((x, y) => x.CompareTo(y));
                var memberRage = storeMembers.Where(x =>
                    x.CompareTo("four") >= 0 && x.CompareTo("three") <= 0).ToList();
    
                var range = Redis.GetRangeFromSortedSetByLowestScore(SetId, "four", "three");
                Assert.That(range.EquivalentTo(memberRage));
            }
    
            [Test]
            public void Can_IncrementItemInSortedSet()
            {
                stringDoubleMap.Each(x => Redis.AddItemToSortedSet(SetId, x.Key, x.Value));
    
                var currentScore = Redis.IncrementItemInSortedSet(SetId, "one", 3);
                stringDoubleMap["one"] = stringDoubleMap["one"] + 3;
                Assert.That(currentScore, Is.EqualTo(stringDoubleMap["one"]));
    
                currentScore = Redis.IncrementItemInSortedSet(SetId, "four", -3);
                stringDoubleMap["four"] = stringDoubleMap["four"] - 3;
                Assert.That(currentScore, Is.EqualTo(stringDoubleMap["four"]));
    
                var map = Redis.GetAllWithScoresFromSortedSet(SetId);
    
                Assert.That(stringDoubleMap.UnorderedEquivalentTo(map));
            }
    
            [Test]
            public void Can_WorkInSortedSetUnderDifferentCulture()
            {
    #if NETCORE
                var prevCulture = CultureInfo.CurrentCulture;
                CultureInfo.CurrentCulture = new CultureInfo("ru-RU");
    #else
                var prevCulture = Thread.CurrentThread.CurrentCulture;
                Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("ru-RU");
    #endif
                Redis.AddItemToSortedSet(SetId, "key", 123.22);
    
                var map = Redis.GetAllWithScoresFromSortedSet(SetId);
    
                Assert.AreEqual(123.22, map["key"]);
    
    #if NETCORE
                CultureInfo.CurrentCulture = prevCulture;
    #else
                Thread.CurrentThread.CurrentCulture = prevCulture;
    #endif
            }
    
    
            [Ignore("Not implemented yet")]
            [Test]
            public void Can_GetRangeFromSortedSetByHighestScore_from_sorted_set()
            {
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x));
    
                storeMembers.Sort((x, y) => y.CompareTo(x));
                var memberRage = storeMembers.Where(x =>
                    x.CompareTo("four") >= 0 && x.CompareTo("three") <= 0).ToList();
    
                var range = Redis.GetRangeFromSortedSetByHighestScore(SetId, "four", "three");
                Assert.That(range.EquivalentTo(memberRage));
            }
    
            [Test]
            public void Can_get_index_and_score_from_SortedSet()
            {
                storeMembers = new List<string> { "a", "b", "c", "d" };
                const double initialScore = 10d;
                var i = initialScore;
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x, i++));
    
                Assert.That(Redis.GetItemIndexInSortedSet(SetId, "a"), Is.EqualTo(0));
                Assert.That(Redis.GetItemIndexInSortedSetDesc(SetId, "a"), Is.EqualTo(storeMembers.Count - 1));
    
                Assert.That(Redis.GetItemScoreInSortedSet(SetId, "a"), Is.EqualTo(initialScore));
                Assert.That(Redis.GetItemScoreInSortedSet(SetId, "d"), Is.EqualTo(initialScore + storeMembers.Count - 1));
            }
    
            [Test]
            public void Can_enumerate_small_ICollection_Set()
            {
                storeMembers.ForEach(x => Redis.AddItemToSortedSet(SetId, x));
    
                var members = new List<string>();
                foreach (var item in Redis.SortedSets[SetId])
                {
                    members.Add(item);
                }
                members.Sort();
                Assert.That(members.Count, Is.EqualTo(storeMembers.Count));
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_enumerate_large_ICollection_Set()
            {
                if (TestConfig.IgnoreLongTests) return;
    
                const int setSize = 2500;
    
                storeMembers = new List<string>();
                setSize.Times(x =>
                {
                    Redis.AddItemToSortedSet(SetId, x.ToString());
                    storeMembers.Add(x.ToString());
                });
    
                var members = new List<string>();
                foreach (var item in Redis.SortedSets[SetId])
                {
                    members.Add(item);
                }
                members.Sort((x, y) => int.Parse(x).CompareTo(int.Parse(y)));
                Assert.That(members.Count, Is.EqualTo(storeMembers.Count));
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_Add_to_ICollection_Set()
            {
                var list = Redis.SortedSets[SetId];
                storeMembers.ForEach(list.Add);
    
                var members = list.ToList<string>();
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Can_Clear_ICollection_Set()
            {
                var list = Redis.SortedSets[SetId];
                storeMembers.ForEach(list.Add);
    
                Assert.That(list.Count, Is.EqualTo(storeMembers.Count));
    
                list.Clear();
    
                Assert.That(list.Count, Is.EqualTo(0));
            }
    
            [Test]
            public void Can_Test_Contains_in_ICollection_Set()
            {
                var list = Redis.SortedSets[SetId];
                storeMembers.ForEach(list.Add);
    
                Assert.That(list.Contains("two"), Is.True);
                Assert.That(list.Contains("five"), Is.False);
            }
    
            [Test]
            public void Can_Remove_value_from_ICollection_Set()
            {
                var list = Redis.SortedSets[SetId];
                storeMembers.ForEach(list.Add);
    
                storeMembers.Remove("two");
                list.Remove("two");
    
                var members = list.ToList();
    
                Assert.That(members, Is.EquivalentTo(storeMembers));
            }
    
            [Test]
            public void Score_from_non_existent_item_returns_NaN()
            {
                var score = Redis.GetItemScoreInSortedSet("nonexistentset", "value");
    
                Assert.That(score, Is.EqualTo(Double.NaN));
            }
    
            [Test]
            public void Can_add_large_score_to_sortedset()
            {
                Redis.AddItemToSortedSet(SetId, "value", 12345678901234567890d);
                var score = Redis.GetItemScoreInSortedSet(SetId, "value");
    
                Assert.That(score, Is.EqualTo(12345678901234567890d));
            }
    
            public class Article
            {
                public int Id { get; set; }
                public string Title { get; set; }
                public DateTime ModifiedDate { get; set; }
            }
    
            [Test]
            public void Can_use_SortedIndex_to_store_articles_by_Date()
            {
                var redisArticles = Redis.As<Article>();
    
                var articles = new[]
                {
                    new Article { Id = 1, Title = "Article 1", ModifiedDate = new DateTime(2015, 01, 02) },
                    new Article { Id = 2, Title = "Article 2", ModifiedDate = new DateTime(2015, 01, 01) },
                    new Article { Id = 3, Title = "Article 3", ModifiedDate = new DateTime(2015, 01, 03) },
                };
    
                redisArticles.StoreAll(articles);
    
                const string LatestArticlesSet = "urn:Article:modified";
    
                foreach (var article in articles)
                {
                    Redis.AddItemToSortedSet(LatestArticlesSet, article.Id.ToString(), article.ModifiedDate.Ticks);
                }
    
                var articleIds = Redis.GetAllItemsFromSortedSetDesc(LatestArticlesSet);
                articleIds.PrintDump();
    
                var latestArticles = redisArticles.GetByIds(articleIds);
                latestArticles.PrintDump();
            }
        }

    ConfigTests

    public class ConfigTests
        {
            [OneTimeSetUp]
            public void OneTimeSetUp()
            {
                RedisConfig.VerifyMasterConnections = false;
            }
    
            [OneTimeTearDown]
            public void OneTimeTearDown()
            {
                RedisConfig.VerifyMasterConnections = true;
            }
    
            [Test]
            [TestCase("host", "{Host:host,Port:6379}")]
            [TestCase("redis://host", "{Host:host,Port:6379}")]
            [TestCase("host:1", "{Host:host,Port:1}")]
            [TestCase("pass@host:1", "{Host:host,Port:1,Password:pass}")]
            [TestCase("nunit:pass@host:1", "{Host:host,Port:1,Client:nunit,Password:pass}")]
            [TestCase("host:1?password=pass&client=nunit", "{Host:host,Port:1,Client:nunit,Password:pass}")]
            [TestCase("host:1?db=2", "{Host:host,Port:1,Db:2}")]
            [TestCase("host?ssl=true", "{Host:host,Port:6380,Ssl:True}")]
            [TestCase("host:6380?ssl=true&password=pass&sslprotocols=Tls12", "{Host:host,Port:6380,Ssl:True,Password:pass,SslProtocols:Tls12}")]
            [TestCase("host:1?ssl=true", "{Host:host,Port:1,Ssl:True}")]
            [TestCase("host:1?connectTimeout=1&sendtimeout=2&receiveTimeout=3&idletimeoutsecs=4",
                "{Host:host,Port:1,ConnectTimeout:1,SendTimeout:2,ReceiveTimeout:3,IdleTimeOutSecs:4}")]
            [TestCase("redis://nunit:pass@host:1?ssl=true&db=1&connectTimeout=2&sendtimeout=3&receiveTimeout=4&retryTimeout=5&idletimeoutsecs=5&NamespacePrefix=prefix.",
                "{Host:host,Port:1,Ssl:True,Client:nunit,Password:pass,Db:1,ConnectTimeout:2,SendTimeout:3,ReceiveTimeout:4,RetryTimeout:5,IdleTimeOutSecs:5,NamespacePrefix:prefix.}")]
            [TestCase("redis://nunit:pass@host:1?ssl=true&sslprotocols=Tls12&db=1&connectTimeout=2&sendtimeout=3&receiveTimeout=4&retryTimeout=5&idletimeoutsecs=5&NamespacePrefix=prefix.",
                "{Host:host,Port:1,Ssl:True,Client:nunit,Password:pass,SslProtocols:Tls12,Db:1,ConnectTimeout:2,SendTimeout:3,ReceiveTimeout:4,RetryTimeout:5,IdleTimeOutSecs:5,NamespacePrefix:prefix.}")]
            public void Does_handle_different_connection_strings_settings(string connString, string expectedJsv)
            {
                var actual = connString.ToRedisEndpoint();
                var expected = expectedJsv.FromJsv<RedisEndpoint>();
    
                Assert.That(actual, Is.EqualTo(expected),
                    "{0} != {1}".Fmt(actual.ToJsv(), expected.ToJsv()));
            }
    
            [Test]
            [TestCase("host", "host:6379")]
            [TestCase("redis://host", "host:6379")]
            [TestCase("host:1", "host:1")]
            [TestCase("pass@host:1", "host:1?Password=pass")]
            [TestCase("nunit:pass@host:1", "host:1?Client=nunit&Password=pass")]
            [TestCase("host:1?password=pass&client=nunit", "host:1?Client=nunit&Password=pass")]
            [TestCase("host:1?db=2", "host:1?Db=2")]
            [TestCase("host?ssl=true", "host:6380?Ssl=true")]
            [TestCase("host:1?ssl=true", "host:1?Ssl=true")]
            [TestCase("host:1?connectTimeout=1&sendtimeout=2&receiveTimeout=3&idletimeoutsecs=4",
                "host:1?ConnectTimeout=1&SendTimeout=2&ReceiveTimeout=3&IdleTimeOutSecs=4")]
            [TestCase("redis://nunit:pass@host:1?ssl=true&db=1&connectTimeout=2&sendtimeout=3&receiveTimeout=4&idletimeoutsecs=5&NamespacePrefix=prefix.",
                "host:1?Client=nunit&Password=pass&Db=1&Ssl=true&ConnectTimeout=2&SendTimeout=3&ReceiveTimeout=4&IdleTimeOutSecs=5&NamespacePrefix=prefix.")]
            [TestCase("password@host:6380?ssl=true&sslprotocols=Tls12", "host:6380?Password=password&Ssl=true&SslProtocols=Tls12")]
            public void Does_Serialize_RedisEndpoint(string connString, string expectedString)
            {
                var actual = connString.ToRedisEndpoint();
                Assert.That(actual.ToString(), Is.EqualTo(expectedString));
            }
    
            [Test]
            public void Does_set_all_properties_on_Client_using_ClientsManagers()
            {
                var connStr = "redis://nunit:pass@host:1?ssl=true&sslprotocols=Tls12&db=0&connectTimeout=2&sendtimeout=3&receiveTimeout=4&idletimeoutsecs=5&NamespacePrefix=prefix.";
                var expected = "{Host:host,Port:1,Ssl:True,SslProtocols:Tls12,Client:nunit,Password:pass,Db:0,ConnectTimeout:2,SendTimeout:3,ReceiveTimeout:4,IdleTimeOutSecs:5,NamespacePrefix:prefix.}"
                    .FromJsv<RedisEndpoint>();
    
                using (var pooledManager = new RedisManagerPool(connStr))
                {
                    AssertClientManager(pooledManager, expected);
                }
                using (var pooledManager = new PooledRedisClientManager(connStr))
                {
                    AssertClientManager(pooledManager, expected);
                }
                using (var basicManager = new BasicRedisClientManager(connStr))
                {
                    AssertClientManager(basicManager, expected);
                }
            }
    
            [Test]
            public void Does_encode_values_when_serializing_to_ConnectionString()
            {
                var config = new RedisEndpoint
                {
                    Host = "host",
                    Port = 1,
                    Password = "p@55W0rd="
                };
    
                var connString = config.ToString();
                Assert.That(connString, Is.EqualTo("host:1?Password=p%4055W0rd%3d"));
    
                var fromConfig = connString.ToRedisEndpoint();
                Assert.That(fromConfig.Host, Is.EqualTo(config.Host));
                Assert.That(fromConfig.Port, Is.EqualTo(config.Port));
                Assert.That(fromConfig.Password, Is.EqualTo(config.Password));
            }
    
            private static void AssertClientManager(IRedisClientsManager redisManager, RedisEndpoint expected)
            {
                using (var readWrite = (RedisClient)redisManager.GetClient())
                using (var readOnly = (RedisClient)redisManager.GetReadOnlyClient())
                using (var cacheClientWrapper = (RedisClientManagerCacheClient)redisManager.GetCacheClient())
                {
                    AssertClient(readWrite, expected);
                    AssertClient(readOnly, expected);
    
                    using (var cacheClient = (RedisClient)cacheClientWrapper.GetClient())
                    {
                        AssertClient(cacheClient, expected);
                    }
                }
            }
    
            private static void AssertClient(RedisClient redis, RedisEndpoint expected)
            {
                Assert.That(redis.Host, Is.EqualTo(expected.Host));
                Assert.That(redis.Port, Is.EqualTo(expected.Port));
                Assert.That(redis.Ssl, Is.EqualTo(expected.Ssl));
                Assert.That(redis.SslProtocols, Is.EqualTo(expected.SslProtocols));
                Assert.That(redis.Client, Is.EqualTo(expected.Client));
                Assert.That(redis.Password, Is.EqualTo(expected.Password));
                Assert.That(redis.Db, Is.EqualTo(expected.Db));
                Assert.That(redis.ConnectTimeout, Is.EqualTo(expected.ConnectTimeout));
                Assert.That(redis.SendTimeout, Is.EqualTo(expected.SendTimeout));
                Assert.That(redis.ReceiveTimeout, Is.EqualTo(expected.ReceiveTimeout));
                Assert.That(redis.RetryTimeout, Is.EqualTo(expected.RetryTimeout));
                Assert.That(redis.IdleTimeOutSecs, Is.EqualTo(expected.IdleTimeOutSecs));
                Assert.That(redis.NamespacePrefix, Is.EqualTo(expected.NamespacePrefix));
            }
    
            [Test]
            public void Does_set_Client_name_on_Connection()
            {
                using (var redis = new RedisClient(TestConfig.SingleHost + "?Client=nunit"))
                {
                    var clientName = redis.GetClient();
    
                    Assert.That(clientName, Is.EqualTo("nunit"));
                }
            }
    
            [Test]
            public void Does_set_Client_on_Pooled_Connection()
            {
                using (var redisManager = new PooledRedisClientManager(TestConfig.SingleHost + "?Client=nunit"))
                using (var redis = redisManager.GetClient())
                {
                    var clientName = redis.GetClient();
    
                    Assert.That(clientName, Is.EqualTo("nunit"));
                }
            }
        }
  • 相关阅读:
    循环语句(2019年10月10号)
    (面试题)引用数据类型(2019年10月9日)
    引用数据类型(2019年10月9日)
    学车的录像,需要的拿走,比驾校实用。
    Laravel5.1 学习笔记1, 目录结构和命名空间(待修)
    PHP中的魔术方法和魔术常量
    php获取当地时间 time zone
    Windows7环境下Composer 安装包的Cache目录位置
    PHP 框架Laravel Eloquent 实现身份验证
    《CSS Mastery》读书笔记(4)
  • 原文地址:https://www.cnblogs.com/xyyhcn/p/11612724.html
Copyright © 2011-2022 走看看