discourse-redis 3.2.2

data/test/lint/sets.rb

@@ -0,0 +1,125 @@
+module Lint
+
+  module Sets
+
+    def test_sadd
+      assert_equal true, r.sadd("foo", "s1")
+      assert_equal true, r.sadd("foo", "s2")
+      assert_equal false, r.sadd("foo", "s1")
+
+      assert_equal ["s1", "s2"], r.smembers("foo").sort
+    end
+
+    def test_variadic_sadd
+      target_version "2.3.9" do # 2.4-rc6
+        assert_equal 2, r.sadd("foo", ["s1", "s2"])
+        assert_equal 1, r.sadd("foo", ["s1", "s2", "s3"])
+
+        assert_equal ["s1", "s2", "s3"], r.smembers("foo").sort
+      end
+    end
+
+    def test_srem
+      r.sadd("foo", "s1")
+      r.sadd("foo", "s2")
+
+      assert_equal true, r.srem("foo", "s1")
+      assert_equal false, r.srem("foo", "s3")
+
+      assert_equal ["s2"], r.smembers("foo")
+    end
+
+    def test_variadic_srem
+      target_version "2.3.9" do # 2.4-rc6
+        r.sadd("foo", "s1")
+        r.sadd("foo", "s2")
+        r.sadd("foo", "s3")
+
+        assert_equal 1, r.srem("foo", ["s1", "aaa"])
+        assert_equal 0, r.srem("foo", ["bbb", "ccc" "ddd"])
+        assert_equal 1, r.srem("foo", ["eee", "s3"])
+
+        assert_equal ["s2"], r.smembers("foo")
+      end
+    end
+
+    def test_spop
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+
+      assert ["s1", "s2"].include?(r.spop("foo"))
+      assert ["s1", "s2"].include?(r.spop("foo"))
+      assert_equal nil, r.spop("foo")
+    end
+
+    def test_scard
+      assert_equal 0, r.scard("foo")
+
+      r.sadd "foo", "s1"
+
+      assert_equal 1, r.scard("foo")
+
+      r.sadd "foo", "s2"
+
+      assert_equal 2, r.scard("foo")
+    end
+
+    def test_sismember
+      assert_equal false, r.sismember("foo", "s1")
+
+      r.sadd "foo", "s1"
+
+      assert_equal true,  r.sismember("foo", "s1")
+      assert_equal false, r.sismember("foo", "s2")
+    end
+
+    def test_smembers
+      assert_equal [], r.smembers("foo")
+
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+
+      assert_equal ["s1", "s2"], r.smembers("foo").sort
+    end
+
+    def test_srandmember
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+
+      4.times do
+        assert ["s1", "s2"].include?(r.srandmember("foo"))
+      end
+
+      assert_equal 2, r.scard("foo")
+    end
+
+    def test_srandmember_with_positive_count
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "foo", "s3"
+      r.sadd "foo", "s4"
+
+      4.times do
+        assert !(["s1", "s2", "s3", "s4"] & r.srandmember("foo", 3)).empty?
+
+        assert_equal 3, r.srandmember("foo", 3).size
+      end
+
+      assert_equal 4, r.scard("foo")
+    end
+
+    def test_srandmember_with_negative_count
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "foo", "s3"
+      r.sadd "foo", "s4"
+
+      4.times do
+        assert !(["s1", "s2", "s3", "s4"] & r.srandmember("foo", -6)).empty?
+        assert_equal 6, r.srandmember("foo", -6).size
+      end
+
+      assert_equal 4, r.scard("foo")
+    end
+  end
+end

data/test/lint/sorted_sets.rb

@@ -0,0 +1,316 @@
+module Lint
+
+  module SortedSets
+
+    Infinity = 1.0/0.0
+
+    def test_zadd
+      assert_equal 0, r.zcard("foo")
+      assert_equal true, r.zadd("foo", 1, "s1")
+      assert_equal false, r.zadd("foo", 1, "s1")
+      assert_equal 1, r.zcard("foo")
+      r.del "foo"
+
+      target_version "3.0.2" do
+        # XX option
+        assert_equal 0, r.zcard("foo")
+        assert_equal false, r.zadd("foo", 1, "s1", :xx => true)
+        r.zadd("foo", 1, "s1")
+        assert_equal false, r.zadd("foo", 2, "s1", :xx => true)
+        assert_equal 2, r.zscore("foo", "s1")
+        r.del "foo"
+
+        # NX option
+        assert_equal 0, r.zcard("foo")
+        assert_equal true, r.zadd("foo", 1, "s1", :nx => true)
+        assert_equal false, r.zadd("foo", 2, "s1", :nx => true)
+        assert_equal 1, r.zscore("foo", "s1")
+        assert_equal 1, r.zcard("foo")
+        r.del "foo"
+
+        # CH option
+        assert_equal 0, r.zcard("foo")
+        assert_equal true, r.zadd("foo", 1, "s1", :ch => true)
+        assert_equal false, r.zadd("foo", 1, "s1", :ch => true)
+        assert_equal true, r.zadd("foo", 2, "s1", :ch => true)
+        assert_equal 1, r.zcard("foo")
+        r.del "foo"
+
+        # INCR option
+        assert_equal 1.0, r.zadd("foo", 1, "s1", :incr => true)
+        assert_equal 11.0, r.zadd("foo", 10, "s1", :incr => true)
+        assert_equal -Infinity, r.zadd("bar", "-inf", "s1", :incr => true)
+        assert_equal +Infinity, r.zadd("bar", "+inf", "s2", :incr => true)
+        r.del "foo", "bar"
+
+        # Incompatible options combination
+        assert_raise(Redis::CommandError) { r.zadd("foo", 1, "s1", :xx => true, :nx => true) }
+      end
+    end
+
+    def test_variadic_zadd
+      target_version "2.3.9" do # 2.4-rc6
+        # Non-nested array with pairs
+        assert_equal 0, r.zcard("foo")
+        assert_equal 2, r.zadd("foo", [1, "s1", 2, "s2"])
+        assert_equal 1, r.zadd("foo", [4, "s1", 5, "s2", 6, "s3"])
+        assert_equal 3, r.zcard("foo")
+        r.del "foo"
+
+        # Nested array with pairs
+        assert_equal 0, r.zcard("foo")
+        assert_equal 2, r.zadd("foo", [[1, "s1"], [2, "s2"]])
+        assert_equal 1, r.zadd("foo", [[4, "s1"], [5, "s2"], [6, "s3"]])
+        assert_equal 3, r.zcard("foo")
+        r.del "foo"
+
+        # Wrong number of arguments
+        assert_raise(Redis::CommandError) { r.zadd("foo", ["bar"]) }
+        assert_raise(Redis::CommandError) { r.zadd("foo", ["bar", "qux", "zap"]) }
+      end
+
+      target_version "3.0.2" do
+        # XX option
+        assert_equal 0, r.zcard("foo")
+        assert_equal 0, r.zadd("foo", [1, "s1", 2, "s2"], :xx => true)
+        r.zadd("foo", [1, "s1", 2, "s2"])
+        assert_equal 0, r.zadd("foo", [2, "s1", 3, "s2", 4, "s3"], :xx => true)
+        assert_equal 2, r.zscore("foo", "s1")
+        assert_equal 3, r.zscore("foo", "s2")
+        assert_equal nil, r.zscore("foo", "s3")
+        assert_equal 2, r.zcard("foo")
+        r.del "foo"
+
+        # NX option
+        assert_equal 0, r.zcard("foo")
+        assert_equal 2, r.zadd("foo", [1, "s1", 2, "s2"], :nx => true)
+        assert_equal 1, r.zadd("foo", [2, "s1", 3, "s2", 4, "s3"], :nx => true)
+        assert_equal 1, r.zscore("foo", "s1")
+        assert_equal 2, r.zscore("foo", "s2")
+        assert_equal 4, r.zscore("foo", "s3")
+        assert_equal 3, r.zcard("foo")
+        r.del "foo"
+
+        # CH option
+        assert_equal 0, r.zcard("foo")
+        assert_equal 2, r.zadd("foo", [1, "s1", 2, "s2"], :ch => true)
+        assert_equal 2, r.zadd("foo", [1, "s1", 3, "s2", 4, "s3"], :ch => true)
+        assert_equal 3, r.zcard("foo")
+        r.del "foo"
+
+        # INCR option
+        assert_equal 1.0, r.zadd("foo", [1, "s1"], :incr => true)
+        assert_equal 11.0, r.zadd("foo", [10, "s1"], :incr => true)
+        assert_equal -Infinity, r.zadd("bar", ["-inf", "s1"], :incr => true)
+        assert_equal +Infinity, r.zadd("bar", ["+inf", "s2"], :incr => true)
+        assert_raise(Redis::CommandError) { r.zadd("foo", [1, "s1", 2, "s2"], :incr => true) }
+        r.del "foo", "bar"
+
+        # Incompatible options combination
+        assert_raise(Redis::CommandError) { r.zadd("foo", [1, "s1"], :xx => true, :nx => true) }
+      end
+    end
+
+    def test_zrem
+      r.zadd("foo", 1, "s1")
+      r.zadd("foo", 2, "s2")
+
+      assert_equal 2, r.zcard("foo")
+      assert_equal true, r.zrem("foo", "s1")
+      assert_equal false, r.zrem("foo", "s1")
+      assert_equal 1, r.zcard("foo")
+    end
+
+    def test_variadic_zrem
+      target_version "2.3.9" do # 2.4-rc6
+        r.zadd("foo", 1, "s1")
+        r.zadd("foo", 2, "s2")
+        r.zadd("foo", 3, "s3")
+
+        assert_equal 3, r.zcard("foo")
+        assert_equal 1, r.zrem("foo", ["s1", "aaa"])
+        assert_equal 0, r.zrem("foo", ["bbb", "ccc" "ddd"])
+        assert_equal 1, r.zrem("foo", ["eee", "s3"])
+        assert_equal 1, r.zcard("foo")
+      end
+    end
+
+    def test_zincrby
+      rv = r.zincrby "foo", 1, "s1"
+      assert_equal 1.0, rv
+
+      rv = r.zincrby "foo", 10, "s1"
+      assert_equal 11.0, rv
+
+      rv = r.zincrby "bar", "-inf", "s1"
+      assert_equal(-Infinity, rv)
+
+      rv = r.zincrby "bar", "+inf", "s2"
+      assert_equal(+Infinity, rv)
+    end
+
+    def test_zrank
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal 2, r.zrank("foo", "s3")
+    end
+
+    def test_zrevrank
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal 0, r.zrevrank("foo", "s3")
+    end
+
+    def test_zrange
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal ["s1", "s2"], r.zrange("foo", 0, 1)
+      assert_equal [["s1", 1.0], ["s2", 2.0]], r.zrange("foo", 0, 1, :with_scores => true)
+      assert_equal [["s1", 1.0], ["s2", 2.0]], r.zrange("foo", 0, 1, :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s1", -Infinity], ["s2", +Infinity]], r.zrange("bar", 0, 1, :with_scores => true)
+      assert_equal [["s1", -Infinity], ["s2", +Infinity]], r.zrange("bar", 0, 1, :withscores => true)
+    end
+
+    def test_zrevrange
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal ["s3", "s2"], r.zrevrange("foo", 0, 1)
+      assert_equal [["s3", 3.0], ["s2", 2.0]], r.zrevrange("foo", 0, 1, :with_scores => true)
+      assert_equal [["s3", 3.0], ["s2", 2.0]], r.zrevrange("foo", 0, 1, :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s2", +Infinity], ["s1", -Infinity]], r.zrevrange("bar", 0, 1, :with_scores => true)
+      assert_equal [["s2", +Infinity], ["s1", -Infinity]], r.zrevrange("bar", 0, 1, :withscores => true)
+    end
+
+    def test_zrangebyscore
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal ["s2", "s3"], r.zrangebyscore("foo", 2, 3)
+    end
+
+    def test_zrevrangebyscore
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal ["s3", "s2"], r.zrevrangebyscore("foo", 3, 2)
+    end
+
+    def test_zrangebyscore_with_limit
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal ["s2"], r.zrangebyscore("foo", 2, 4, :limit => [0, 1])
+      assert_equal ["s3"], r.zrangebyscore("foo", 2, 4, :limit => [1, 1])
+      assert_equal ["s3", "s4"], r.zrangebyscore("foo", 2, 4, :limit => [1, 2])
+    end
+
+    def test_zrevrangebyscore_with_limit
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal ["s4"], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1])
+      assert_equal ["s3"], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1])
+      assert_equal ["s3", "s2"], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 2])
+    end
+
+    def test_zrangebyscore_with_withscores
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal [["s2", 2.0]], r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s3", 3.0]], r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s2", 2.0]], r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :withscores => true)
+      assert_equal [["s3", 3.0]], r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s1", -Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s2", +Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s1", -Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [0, 1], :withscores => true)
+      assert_equal [["s2", +Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [1, 1], :withscores => true)
+    end
+
+    def test_zrevrangebyscore_with_withscores
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal [["s4", 4.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s3", 3.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s4", 4.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :withscores => true)
+      assert_equal [["s3", 3.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s2", +Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s1", -Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s2", +Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [0, 1], :withscores => true)
+      assert_equal [["s1", -Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [1, 1], :withscores => true)
+    end
+
+    def test_zcard
+      assert_equal 0, r.zcard("foo")
+
+      r.zadd "foo", 1, "s1"
+
+      assert_equal 1, r.zcard("foo")
+    end
+
+    def test_zscore
+      r.zadd "foo", 1, "s1"
+
+      assert_equal 1.0, r.zscore("foo", "s1")
+
+      assert_equal nil, r.zscore("foo", "s2")
+      assert_equal nil, r.zscore("bar", "s1")
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal(-Infinity, r.zscore("bar", "s1"))
+      assert_equal(+Infinity, r.zscore("bar", "s2"))
+    end
+
+    def test_zremrangebyrank
+      r.zadd "foo", 10, "s1"
+      r.zadd "foo", 20, "s2"
+      r.zadd "foo", 30, "s3"
+      r.zadd "foo", 40, "s4"
+
+      assert_equal 3, r.zremrangebyrank("foo", 1, 3)
+      assert_equal ["s1"], r.zrange("foo", 0, -1)
+    end
+
+    def test_zremrangebyscore
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal 3, r.zremrangebyscore("foo", 2, 4)
+      assert_equal ["s1"], r.zrange("foo", 0, -1)
+    end
+  end
+end

data/test/lint/strings.rb

@@ -0,0 +1,260 @@
+module Lint
+
+  module Strings
+
+    def test_set_and_get
+      r.set("foo", "s1")
+
+      assert_equal "s1", r.get("foo")
+    end
+
+    def test_set_and_get_with_brackets
+      r["foo"] = "s1"
+
+      assert_equal "s1", r["foo"]
+    end
+
+    def test_set_and_get_with_brackets_and_symbol
+      r[:foo] = "s1"
+
+      assert_equal "s1", r[:foo]
+    end
+
+    def test_set_and_get_with_newline_characters
+      r.set("foo", "1\n")
+
+      assert_equal "1\n", r.get("foo")
+    end
+
+    def test_set_and_get_with_non_string_value
+      value = ["a", "b"]
+
+      r.set("foo", value)
+
+      assert_equal value.to_s, r.get("foo")
+    end
+
+    def test_set_and_get_with_ascii_characters
+      if defined?(Encoding)
+        with_external_encoding("ASCII-8BIT") do
+          (0..255).each do |i|
+            str = "#{i.chr}---#{i.chr}"
+            r.set("foo", str)
+
+            assert_equal str, r.get("foo")
+          end
+        end
+      end
+    end
+
+    def test_set_with_ex
+      target_version "2.6.12" do
+        r.set("foo", "bar", :ex => 2)
+        assert_in_range 0..2, r.ttl("foo")
+      end
+    end
+
+    def test_set_with_px
+      target_version "2.6.12" do
+        r.set("foo", "bar", :px => 2000)
+        assert_in_range 0..2, r.ttl("foo")
+      end
+    end
+
+    def test_set_with_nx
+      target_version "2.6.12" do
+        r.set("foo", "qux", :nx => true)
+        assert !r.set("foo", "bar", :nx => true)
+        assert_equal "qux", r.get("foo")
+
+        r.del("foo")
+        assert r.set("foo", "bar", :nx => true)
+        assert_equal "bar", r.get("foo")
+      end
+    end
+
+    def test_set_with_xx
+      target_version "2.6.12" do
+        r.set("foo", "qux")
+        assert r.set("foo", "bar", :xx => true)
+        assert_equal "bar", r.get("foo")
+
+        r.del("foo")
+        assert !r.set("foo", "bar", :xx => true)
+      end
+    end
+
+    def test_setex
+      assert r.setex("foo", 1, "bar")
+      assert_equal "bar", r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+    end
+
+    def test_setex_with_non_string_value
+      value = ["b", "a", "r"]
+
+      assert r.setex("foo", 1, value)
+      assert_equal value.to_s, r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+    end
+
+    def test_psetex
+      target_version "2.5.4" do
+        assert r.psetex("foo", 1000, "bar")
+        assert_equal "bar", r.get("foo")
+        assert [0, 1].include? r.ttl("foo")
+      end
+    end
+
+    def test_psetex_with_non_string_value
+      target_version "2.5.4" do
+        value = ["b", "a", "r"]
+
+        assert r.psetex("foo", 1000, value)
+        assert_equal value.to_s, r.get("foo")
+        assert [0, 1].include? r.ttl("foo")
+      end
+    end
+
+    def test_getset
+      r.set("foo", "bar")
+
+      assert_equal "bar", r.getset("foo", "baz")
+      assert_equal "baz", r.get("foo")
+    end
+
+    def test_getset_with_non_string_value
+      r.set("foo", "zap")
+
+      value = ["b", "a", "r"]
+
+      assert_equal "zap", r.getset("foo", value)
+      assert_equal value.to_s, r.get("foo")
+    end
+
+    def test_setnx
+      r.set("foo", "qux")
+      assert !r.setnx("foo", "bar")
+      assert_equal "qux", r.get("foo")
+
+      r.del("foo")
+      assert r.setnx("foo", "bar")
+      assert_equal "bar", r.get("foo")
+    end
+
+    def test_setnx_with_non_string_value
+      value = ["b", "a", "r"]
+
+      r.set("foo", "qux")
+      assert !r.setnx("foo", value)
+      assert_equal "qux", r.get("foo")
+
+      r.del("foo")
+      assert r.setnx("foo", value)
+      assert_equal value.to_s, r.get("foo")
+    end
+
+    def test_incr
+      assert_equal 1, r.incr("foo")
+      assert_equal 2, r.incr("foo")
+      assert_equal 3, r.incr("foo")
+    end
+
+    def test_incrby
+      assert_equal 1, r.incrby("foo", 1)
+      assert_equal 3, r.incrby("foo", 2)
+      assert_equal 6, r.incrby("foo", 3)
+    end
+
+    def test_incrbyfloat
+      target_version "2.5.4" do
+        assert_equal 1.23, r.incrbyfloat("foo", 1.23)
+        assert_equal 2   , r.incrbyfloat("foo", 0.77)
+        assert_equal 1.9 , r.incrbyfloat("foo", -0.1)
+      end
+    end
+
+    def test_decr
+      r.set("foo", 3)
+
+      assert_equal 2, r.decr("foo")
+      assert_equal 1, r.decr("foo")
+      assert_equal 0, r.decr("foo")
+    end
+
+    def test_decrby
+      r.set("foo", 6)
+
+      assert_equal 3, r.decrby("foo", 3)
+      assert_equal 1, r.decrby("foo", 2)
+      assert_equal 0, r.decrby("foo", 1)
+    end
+
+    def test_append
+      r.set "foo", "s"
+      r.append "foo", "1"
+
+      assert_equal "s1", r.get("foo")
+    end
+
+    def test_getbit
+      r.set("foo", "a")
+
+      assert_equal 1, r.getbit("foo", 1)
+      assert_equal 1, r.getbit("foo", 2)
+      assert_equal 0, r.getbit("foo", 3)
+      assert_equal 0, r.getbit("foo", 4)
+      assert_equal 0, r.getbit("foo", 5)
+      assert_equal 0, r.getbit("foo", 6)
+      assert_equal 1, r.getbit("foo", 7)
+    end
+
+    def test_setbit
+      r.set("foo", "a")
+
+      r.setbit("foo", 6, 1)
+
+      assert_equal "c", r.get("foo")
+    end
+
+    def test_bitcount
+      target_version "2.5.10" do
+        r.set("foo", "abcde")
+
+        assert_equal 10, r.bitcount("foo", 1, 3)
+        assert_equal 17, r.bitcount("foo", 0, -1)
+      end
+    end
+
+    def test_getrange
+      r.set("foo", "abcde")
+
+      assert_equal "bcd", r.getrange("foo", 1, 3)
+      assert_equal "abcde", r.getrange("foo", 0, -1)
+    end
+
+    def test_setrange
+      r.set("foo", "abcde")
+
+      r.setrange("foo", 1, "bar")
+
+      assert_equal "abare", r.get("foo")
+    end
+
+    def test_setrange_with_non_string_value
+      r.set("foo", "abcde")
+
+      value = ["b", "a", "r"]
+
+      r.setrange("foo", 2, value)
+
+      assert_equal "ab#{value.to_s}", r.get("foo")
+    end
+
+    def test_strlen
+      r.set "foo", "lorem"
+
+      assert_equal 5, r.strlen("foo")
+    end
+  end
+end