#!/usr/bin/env python
# -*- coding: utf-8 -*-

import redis

host = "127.0.0.1"
port = 6379
c = redis.Redis(host=host, port=port)

print "check begin"
#append
c.execute_command("del", "mykey")
ret = c.execute_command("append", "mykey", "Hello")
if ret != 5:
    print "append"+" ret not compatible " + "redis: 5" + " checker: " + str(ret)
ret = c.execute_command("append", "mykey", " World")
ret = c.execute_command("get", "mykey")
if ret != "Hello World":
    print "append"+" result wrong " + "redis: \"Hello World\"" + " checker: " + str(ret)

#bitcount
c.execute_command("del", "mykey")
ret = c.execute_command("set", "mykey", "foobar")
ret = c.execute_command("bitcount", "mykey")
if ret != 26:
    print "bitcount"+" result wrong " + "redis: 26" + " checker: " + str(ret)
ret = c.execute_command("bitcount", "mykey", 0, 0)
if ret != 4:
    print "bitcount"+" result wrong " + "redis: 4" + " checker: " + str(ret)
ret = c.execute_command("bitcount", "mykey", 1, 1)
if ret != 6:
    print "bitcount"+" result wrong " + "redis: 6" + " checker: " + str(ret)

#bitop
c.execute_command("del", "key1")
c.execute_command("del", "key2")
c.execute_command("del", "dest")
c.execute_command("set", "key1", "foobar")
c.execute_command("set", "key2", "abcdef")
ret = c.bitop("and","dest", "key1", "key2")
if ret != 6:
    print "bitop"+" ret not compatible " + "redis: 6" + " checker: " + str(ret)
ret = c.get("dest")
if ret != "`bc`ab":
    print "bitop"+" result wrong " + "redis: \"`bc`ab\"" + " checker: " + ret

#bitpos
try:
    c.delete("mykey")
    c.set("mykey","\xff\xf0\x00")
    ret = c.bitpos("mykey",0)
    if ret != 12:
        print "bitpos" + " result wrong " + "redis: 12" + " checker: " + str(ret)
except Exception as e:
    print "bitop Exception: " + str(e)

#decr
c.delete("mykey")
c.set("mykey",10)
ret = c.execute_command("decr","mykey")
if ret != 9:
    print "decr" + " ret not compatible " + "redis: 9" + " checker: " + str(ret)


#decrby
c.delete("mykey")
c.set("mykey",10)
ret = c.execute_command("decrby","mykey",3)
if ret != 7:
    print "decr" + " ret not compatible " + "redis: 7" + " checker: " + str(ret)

#getbit
c.delete("mykey")
c.execute_command("setbit","mykey",7,1)
ret = c.execute_command("getbit", "mykey", 0)
if ret != 0:
    print "getbit"+" result wrong " + "redis: 0" + " checker: " + str(ret)
ret = c.execute_command("getbit", "mykey", 7)
if ret != 1:
    print "getbit"+" result wrong " + "redis: 1" + " checker: " + str(ret)

#getrange
c.delete("mykey")
c.set("mykey", "This is a string")
ret = c.execute_command("getrange", "mykey", 0, 3)
if ret != "This":
    print "getrange"+" result wrong "+"redis: \"This\""+" checker: "+str(ret)
ret = c.execute_command("getrange", "mykey", -3, -1)
if ret != "ing":
    print "getrange"+" result wrong "+"redis: \"ing\""+" checker: "+str(ret)
ret = c.execute_command("getrange", "mykey", 0, -1)
if ret != "This is a string":
    print "getrange"+" result wrong "+"redis: \"This is a string\""+" checker: "+str(ret)
ret = c.execute_command("getrange", "mykey", 10, 100)
if ret != "string":
    print "getrange"+" result wrong "+"redis: \"string\""+" checker: "+str(ret)


#getset
c.delete("mycounter")
c.execute_command("incr", "mycounter")
ret = c.execute_command("getset", "mycounter", 0)
if str(ret) != "1":
    print "getset" + " result wrong " + "redis: 1" + " checker: "+str(ret)

#incr
c.set("mykey", 10)
ret = c.execute_command("incr", "mykey")
if str(ret) != "11":
    print "incr" + " ret not compatible " + "redis: 11" + " checker: "+str(ret)
ret = c.get("mykey")
if str(ret) != "11":
    print "incr" + " result wrong " + "redis: 11" + " checker: " + ret

#incrby
c.set("mykey", 10)
ret = c.execute_command("incrby", "mykey", 5)
if str(ret) != "15":
    print "incrby" + " ret not compatible " + "redis: 15" + " checker: "+str(ret)
ret = c.get("mykey")
if str(ret) != "15":
    print "incrby" + " result wrong " + "redis: 15" + " checker: " + str(ret)


#incrbyfloat
c.set("mykey", 10.50)
ret = c.execute_command("incrbyfloat", "mykey", 0.1)
if ret != "10.6":
    print "incrbyfloat" + " ret not compatible " + "redis: 10.6" + " checker: "+str(ret)
ret = c.get("mykey")
if ret != "10.6":
    print "incrbyfloat" + " result wrong " + "redis: 10.6" + " checker: " + ret

#mget
c.set("key1", "Hello")
c.set("key2", "World")
r1,r2,r3 = c.execute_command("mget", "key1", "key2", "nonexisting")
if r1 != "Hello" or r2 != "World" or r3 != None:
    print "mget" + " result wrong " + "redis: Hello World None" + " checker: " + r1+ r2 + r3

#mset
c.execute_command("mset", "key1", "Hello", "key2", "World")
r1 = c.get("key1")
if r1 != "Hello":
    print "mset" + " result wrong " + "redis: Hello" + " checker: "+ str(ret)
r2 = c.get("key2")
if r2 != "World":
    print "mset" + " result wrong " + "redis: World" + " checker: "+ str(ret)

#msetnx
c.delete("key1")
c.delete("key2")
ret = c.execute_command("msetnx", "key1", "Hello", "key2", "there")
if str(ret) != "1":
    print "msetnx" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("msetnx", "key2", "there", "key3", "world")
if str(ret) != "0":
    print "msetnx" + " ret not compatible " + "redis: 0" + " checker: " + str(ret)
r1,r2,r3 = c.execute_command("mget", "key1", "key2", "key3")
if r1 != "Hello" or r2 !="there" or r3 != None:
    print "msetnx" + " result wrong " + "redis: Hello there None"+ " Checker: " + str(r1) + " " + " " + str(r2) + " " + str(r3)

#setbit
c.delete("mykey")
ret = c.execute_command("setbit", "mykey", 7, 1)
if ret != 0:
    print "setbit" + " ret not compatible " + "redis: 0" + " checker: " + str(ret)
ret = c.execute_command("setbit", "mykey", 7, 0)
if ret != 1:
    print "setbit" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.get("mykey").encode('hex')
if str(ret) != "00":
    print "setbit" + " result wrong " + "redis: 00" + " checker: " + str(ret)

#setex
c.delete("mykey")
ret = c.execute_command("setex", "mykey", 10, "hello")
if ret != "OK":
    print "setex" + " ret not compatible " + "redis: OK" + " checker: "+str(ret)
ret = c.ttl("mykey")
if ret != 10:
    print "setex" + " result wrong " + "redis: 10" + " checker: "+str(ret)

#setnx
c.delete("mykey")
ret = c.execute_command("setnx", "mykey", "Hello")
if ret != 1:
    print "setnx" + " ret not compatible " + "redis: 1" + " checker: "+str(ret)

ret = c.execute_command("setnx", "mykey", "Hello")
if ret != 0:
    print "setnx" + " ret not compatible " + "redis: 0" + " checker: "+str(ret)

ret = c.get("mykey")
if ret != "Hello":
    print "setnx" + " result wrong " + "redis: Hello" + " checker:  " + str(ret)

#setrange
c.set("key1", "Hello World")
ret = c.execute_command("setrange", "key1", 6, "Redis")
if ret != 11:
    print "setrange" + " ret not compatile " + "redis: 11" + " checker: " + str(ret)

ret = c.get("key1")
if ret != "Hello Redis":
    print "setrange" + " wrong result " + "redis: Hello Redis" + " checker: " + str(ret)

#strlen
try:
    c.delete("mykey")
    c.set("mykey", "Hello world")
    ret = c.execute_command("strlen", "mykey")
    if ret != 11:
        print "strlen" + " wrong result " + "redis: 11" + " checker: " + str(ret)
    ret = c.execute_command("strlen", "nonexisting")
    if ret != 0:
        print "strlen" + " wrong result " + "redis: 0" + " checker: " + str(ret)
except Exception as e:
    print "strlen Exception: " + str(e)


#hset
c.delete("myhash")
ret = c.execute_command("hset", "myhash", "field1", "Hello")
if str(ret) != "1":
    print "hset" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.hget("myhash", "field1")
if str(ret) != "Hello":
    print "hset" + " wrong result " + "redis: Hello" + " checker: " + str(ret)

#hget
c.hset("myhash", "field1", "foo")
ret = c.execute_command("hget", "myhash", "field1")
if str(ret) != "foo":
    print "hget" + " result wrong " + "redis: foo" + " checker: " + str(ret)
ret = c.execute_command("hget", "myhash", "field2")
if ret != None:
    print "hget" + " result wrong " + "redis: None" + " checker: " + str(ret)

#hdel
c.hset("myhash", "field1", "foo")
ret = c.execute_command("hdel", "myhash", "field1")
if str(ret) != "1":
    print "hdel" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("hdel", "myhash", "field2")
if str(ret) != "0":
    print "hdel" + " ret not compatible " + "redis: 0" + " checker: " + str(ret)
ret = c.execute_command("hdel", "myhash", "field1")
if str(ret) != "0":
    print "hdel" + " ret not compatible " + "redis: 0" + " checker: " + str(ret)

#hexists
c.delete("myhash")
c.hset("myhash", "field1", "foo")
ret = c.execute_command("hexists", "myhash", "field1")
if str(ret) != "1":
    print "hexists" + " wrong result " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("hexists", "myhash", "field2")
if str(ret) != "0":
    print "hexists" + " wrong result " + "redis: 0" + " checker: " + str(ret)

#hgetall
c.delete("myhash")
c.hset("myhash", "field1", "Hello")
c.hset("myhash", "field2", "World")
ret = c.execute_command("hgetall", "myhash")
if ret != ['field1', 'Hello', 'field2', 'World']:
    print "hgetall" + " wrong result " + "redis: ['field1', 'Hello', 'field2', 'World']" + " checker: " + str(ret)

#hincrby
c.delete("myhash")
c.hset("myhash", "field", 5)
ret = c.execute_command("hincrby", "myhash", "field", 1)
if str(ret) != "6":
    print "hincrby" + " ret not compatible " + "redis: 6 " + " checker: " + str(ret)
ret = c.hget("myhash", "field")
if str(ret)!="6":
    print "hincrby" + " result wrong " + "redis: 6" + " checker: " + str(ret)

#hincrbyfloat
c.delete("mykey")
c.hset("mykey", "field", 10.50)
ret = c.execute_command("hincrbyfloat", "mykey", "field", 0.1)
if str(ret)!="10.6":
    print "hincrbyfloat" + " ret not compatible " + "redis: 10.6" + " checker: " + str(ret)
ret = c.execute_command("hincrbyfloat", "mykey", "field", -5)
if str(ret)!="5.6":
    print "hincrbyfloat" + " ret not compatible " + "redis: 5.6" + " checker: " + str(ret)

#hkeys
c.delete("myhash")
c.hset("myhash", "field1", "Hello")
c.hset("myhash", "field2", "World")
ret = c.execute_command("hkeys", "myhash")
if ret != ['field1', 'field2']:
    print "hkeys" + " result wrong " + "redis: ['field1', 'field2']" + " checker: " + str(ret)

#hlen
c.delete("myhash")
c.hset("myhash", "field1", "Hello")
c.hset("myhash", "field2", "World")
ret = c.execute_command("hlen", "myhash")
if str(ret) != "2":
    print "hlen" + " result wrong " + "redis: 2" + " checker: " + str(ret)

#hmget
c.delete("myhash")
c.hset("myhash", "field1", "Hello")
c.hset("myhash", "field2", "World")
ret = c.execute_command("hmget", "myhash", "field1", "field2", "nofield")
if ret != ['Hello', 'World', None]:
    print "hmget" + " result wrong " + "redis: ['Hello', 'World', None]" + str(ret)

#hmset
c.delete("myhash")
ret = c.execute_command("hmset", "myhash", "field1", "Hello", "field2", "World")
if str(ret) != "OK":
    print "hmset" + " ret not compatible " + "redis: OK" + "checker: " + str(ret)
ret = c.hget("myhash", "field1")
if str(ret) != "Hello":
        print "hmset" + " result wrong " + "redis: Hello" + " checker: " + str(ret)
ret = c.hget("myhash", "field2")
if str(ret) != "World":
        print "hmset" + " result wrong " + "redis: Hello" + " checker: " + str(ret)

#hsetnx
c.delete("myhash")
ret = c.execute_command("hsetnx", "myhash", "field", "Hello")
if str(ret) != "1":
    print "hsetnx" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("hsetnx", "myhash", "field", "Hello")
if str(ret) != "0":
    print "hsetnx" + " ret not compatible " + "redis: 0" + " checker: " + str(ret)
ret = c.hget("myhash", "field")
if str(ret) != "Hello":
    print "hsetnx" + " result wrong " + "redis: Hello" + " checker: " + str(ret)

#hstrlen
c.delete("myhash")
c.execute_command("hmset", "myhash", "f1", "HelloWorld", "f2", 99, "f3", -256)
try:
    ret = c.execute_command("hstrlen", "myhash", "f1")
    if str(ret) != "10":
        print "hstrlen" + " result wrong " + "redis: 10" + " checker: " + str(ret)
    ret = c.execute_command("hstrlen", "myhash", "f2")
    if str(ret) != "2":
        print "hstrlen" + " result wrong " + "redis: 2" + " checker: " + str(ret)
    ret = c.execute_command("hstrlen", "myhash", "f3")
    if str(ret) != "4":
        print "hstrlen" + " result wrong " + "redis: 4" + " checker: " + str(ret)
except Exception as e:
    print "hstrlen Exception " + str(e)

#hvals
c.delete("myhash")
c.hset("myhash", "field1", "Hello")
c.hset("myhash", "field2", "World")
ret = c.execute_command("hvals", "myhash")
if ret != ['Hello', 'World']:
    print "hvals" + " result wrong " + "redis: ['Hello', 'World']" + " checker: " + str(ret)

#hscan
c.delete("myhash")
c.hset("myhash", "field1", "Hello")
c.hset("myhash", "field2", "World")
for v in c.hscan_iter("myhash"):
    print v

#lpush
c.delete("mylist")
ret = c.execute_command("lpush", "mylist", "world")
if str(ret) != "1":
    print "lpush" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("lpush", "mylist", "hello")
if str(ret) != "2":
    print "lpush" + " ret not compatible " + "redis: 2" + " checker: " + str(ret)
ret = c.lrange("mylist", 0, -1)
if ret != ['hello', 'world']:
    print "lpush" + " result wrong " + "redis: ['hello', 'world']" + " checker: " + str(ret)

#lindex
c.delete("mylist")
c.lpush("mylist", "World")
c.lpush("mylist", "Hello")
ret = c.execute_command("lindex", "mylist", 0)
if str(ret) != "Hello":
    print "lindex" + " result wrong " + "redis: Hello" + " checker: " + str(ret)
ret = c.execute_command("lindex", "mylist", -1)
if str(ret) != "World":
    print "lindex" + " result wrong " + "redis: World" + " checker: " + str(ret)
ret = c.execute_command("lindex", "mylist", 3)
if ret != None:
    print "lindex" + " result wrong " + "redis: None" + " checker: " + str(ret)

#rpush
c.delete("mylist")
ret = c.execute_command("rpush", "mylist", "hello")
if str(ret) != "1":
    print "rpush" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("rpush", "mylist", "world")
if str(ret) != "2":
    print "rpush" + " ret not compatible " + "redis: 2" + " checker: " + str(ret)
ret = c.lrange("mylist", 0, -1)
if ret != ['hello', 'world']:
    print "rpush" + " result wrong " + "redis: ['hello', 'world']" + " checker: " + str(ret)


#linsert
c.delete("mylist")
c.rpush("mylist", "Hello")
c.rpush("mylist", "World")
ret = c.execute_command("linsert", "mylist", "before", "World", "There")
if str(ret) != "3":
    print "linsert"  + " ret not compatible " + "redis: 3" + " checker: " + str(ret)
ret = c.lrange("mylist", 0, -1)
if ret != ['Hello', 'There', 'World']:
    print "linsert" + " result wrong " + "redis: ['Hello', 'There', 'World']" + " checker: " + str(ret)

#llen
c.delete("mylist")
c.lpush("mylist", "World")
c.lpush("mylist", "Hello")
ret = c.execute_command("llen","mylist")
if str(ret) != "2":
    print "llen" + " result wrong " + "redis: 2" + " checker: " + str(ret)

#lpop
c.delete("mylist")
c.rpush("mylist", "one")
c.rpush("mylist", "two")
c.rpush("mylist", "three")
ret = c.lpop("mylist")
if str(ret) != "one":
    print "lpop" + " result wrong " + "redis: one" + " checker: " + str(ret)
ret = c.lrange("mylist", 0, -1)
if ret != ['two', 'three']:
    print "lpop" + " result wrong " + "redis: ['two', 'three']" + " checker: " + str(ret)

#lpushx
c.delete("mylist")
c.delete("myotherlist")
c.lpush("mylist", "World")
c.lpush("mylist", "Hello")
c.lpushx("myotherlist", "Hello")
ret = c.lrange("mylist", 0, -1)
ret = c.lrange("myotherlist", 0, -1)
if ret != []:
    print "lpushx" + " result wrong " + "redis: []" + " checker: " + str(ret)

#lrem
c.delete("mylist")
c.rpush("mylist", "hello")
c.rpush("mylist", "hello")
c.rpush("mylist", "foo")
c.rpush("mylist", "hello")
ret = c.execute_command("lrem", "mylist", -2, "hello")
if str(ret) != "2":
    print "lrem" + " ret not compabile " + "redis: 2" + " checker: " + str(ret)
ret = c.lrange("mylist", 0, -1)
if ret != ['hello', 'foo']:
    print "lrem" + " result wrong " + "redis: ['hello', 'foo']" + " checker: " + str(ret)

#lset
c.delete("mylist")
c.rpush("mylist", "one")
c.rpush("mylist", "two")
c.rpush("mylist", "three")
ret = c.execute_command("lset", "mylist", 0, "four")
if str(ret) != "OK":
    print "lset" + " ret not compatible " + "redis: OK" + " checker: " + str(ret)
ret = c.execute_command("lset", "mylist", -2, "five")
if str(ret) != "OK":
    print "lset" + " ret not compatible " + "redis: OK" + " checker: " + str(ret)
ret = c.lrange("mylist", 0, -1)
if ret != ['four', 'five', 'three']:
    print "lset" + " result wrong " + "redis: ['four', 'five', 'three']" + " checker: " + str(ret)

#ltrim
c.delete("mylist")
c.rpush("mylist", "one")
c.rpush("mylist", "two")
c.rpush("mylist", "three")
ret = c.execute_command("ltrim", "mylist", 1, -1)
if str(ret) != "OK":
    print "ltrim" + " ret not compabile " + "redis: OK" + " checker: "  + str(ret)
ret = c.lrange("mylist", 0, -1)
if ret != ['two', 'three']:
    print "ltrim" + " result wrong " + "redis: ['two', 'three']" + " checker: " + str(ret)

#rpop
c.delete("mylist")
c.rpush("mylist", "one")
c.rpush("mylist", "two")
c.rpush("mylist", "three")
ret = c.execute_command("rpop", "mylist")
if str(ret) != "three":
    print "rpop" + " result wrong " + "redis: three" + " checker: " + str(ret)

#rpoplpush
c.delete("mylist")
c.delete("myotherlist")
c.rpush("mylist", "one")
c.rpush("mylist", "two")
c.rpush("mylist", "three")
ret = c.execute_command("rpoplpush", "mylist", "myotherlist")
if str(ret) != "three":
    print "rpoplpush" + " ret not compatible " + "redis: three" + " checker: " + str(ret)
ret = c.lrange("mylist", 0, -1)
if ret != ['one', 'two']:
    print "rpoplpush" + " result wrong " + "redis: ['one', 'two']" + " checker: " + str(ret)
ret = c.lrange("myotherlist", 0, -1)
if ret != ['three']:
    print "rpoplpush" + " result wrong " + "redis: ['three']" + " checker: " + str(ret)

#rpushx
c.delete("mylist")
c.delete("myotherlist")
c.rpush("mylist", "Hello")
ret = c.execute_command("rpushx", "mylist", "World")
if str(ret) != "2":
    print "rpushx" + " ret not compatible " + "redis: 2" + " checker: " + str(ret)
ret = c.execute_command("rpushx", "myotherlist", "World")
if str(ret) != "0":
    print "rpushx" + " ret not compatible " + "redis: 0" + " checker: " + str(ret)
ret = c.lrange("mylist", 0, -1)
if ret != ['Hello', 'World']:
    print "rpushx" + " result wrong " + "redis: ['Hello', 'World']" + str(ret)
ret = c.lrange("myotherlist", 0, -1)
if ret != []:
    print "rpushx" + " result wrong " + "redis: []" + str(ret)

#sadd
c.delete("myset")
ret = c.execute_command("sadd", "myset", "Hello")
if str(ret) != "1":
    print "sadd" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("sadd", "myset", "World")
if str(ret) != "1":
    print "sadd" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("sadd", "myset", "World")
if str(ret) != "0":
    print "sadd" + " ret not compatible " + "redis: 0" + " checker: " + str(ret)
ret = c.smembers("myset")
if ret != set(['World', 'Hello']):
    print "sadd" + " result wrong " + "redis: set(['World', 'Hello'])" + str(ret)

#scard
c.delete("myset")
c.sadd("myset", "Hello")
c.sadd("myset", "World")
ret = c.scard("myset")
if str(ret) != "2":
    print "scard" + " result wrong " + "redis: 2" + " checker: " + str(ret)

#sdiff
c.delete("key1")
c.delete("key2")
c.sadd("key1", "a")
c.sadd("key1", "b")
c.sadd("key1", "c")
c.sadd("key2", "c")
c.sadd("key2", "d")
c.sadd("key2", "e")
ret = c.execute_command("sdiff", "key1", "key2")
if ret != ['a', 'b']:
    print "sdiff" + " result wrong " + "redis: ['a', 'b']" + " checker: " + str(ret)

#sdiffstore
c.delete("key1")
c.delete("key2")
c.delete("key")
c.sadd("key1", "a")
c.sadd("key1", "b")
c.sadd("key1", "c")
c.sadd("key2", "c")
c.sadd("key2", "d")
c.sadd("key2", "e")
ret = c.execute_command("sdiffstore", "key", "key1", "key2")
if str(ret) != "2":
    print "sdiffstore" + " ret not compatible " + "redis: 2" + " checker: " + str(ret)
ret = c.smembers("key")
if ret != set(['a', 'b']):
    print "sdiffstore" + " result wrong " + "redis: set(['a', 'b'])" + " checker: " + str(ret)

#sinter
c.delete("key1")
c.delete("key2")
c.sadd("key1", "a")
c.sadd("key1", "b")
c.sadd("key1", "c")
c.sadd("key2", "c")
c.sadd("key2", "d")
c.sadd("key2", "e")
ret = c.execute_command("sinter", "key1", "key2")
if ret != ['c']:
    print "sinter" + " result wrong " + "redis: ['c']" + " checker: " + str(ret)

#sinterstore
c.delete("key1")
c.delete("key2")
c.delete("key")
c.sadd("key1", "a")
c.sadd("key1", "b")
c.sadd("key1", "c")
c.sadd("key2", "c")
c.sadd("key2", "d")
c.sadd("key2", "e")
ret = c.execute_command("sinterstore", "key", "key1", "key2")
if str(ret) != "1":
    print "sinterstore" + " ret not compatible " + " checker: " + str(ret)
ret = c.smembers("key")
if ret != set(['c']):
    print "sinterstore" + " result wrong " + "redis: set(['c'])" + " checker: " + str(ret)

#sismember
c.delete("myset")
c.sadd("myset", "one")
ret = c.execute_command("sismember", "myset", "one")
if str(ret) != "1":
    print "sismember" + " result wrong " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("sismember", "myset", "two")
if str(ret) != "0":
    print "sismember" + " result wrong " + "redis: 0" + " checker: " + str(ret)

#smove
c.delete("myset")
c.delete("myotherset")
c.sadd("myset", "one")
c.sadd("myset", "two")
c.sadd("myotherset", "three")
ret = c.execute_command("smove", "myset", "myotherset", "two")
if str(ret) != "1":
    print "smove" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.smembers("myset")
if ret != set(['one']):
    print "smove" + " result wrong " + "redis: set(['one'])" + " checker: " + str(ret)
ret = c.smembers("myotherset")
if ret != set(['three', 'two']):
    print "smove" + " result wrong " + "redis: set(['three', 'two'])" + " checker: " + str(ret)

#srem
c.delete("myset")
c.sadd("myset", "one")
c.sadd("myset", "two")
c.sadd("myset", "three")
ret = c.execute_command("srem", "myset", "one")
ret = c.execute_command("srem", "myset", "four")
ret = c.smembers("myset")
if ret != set(['three', 'two']):
    print "srem" + " result wrong " + "redis: set(['three', 'two'])" + " checker: " + str(ret)

#sunion
c.delete("key1")
c.delete("key2")
c.sadd("key1", "a")
c.sadd("key1", "b")
c.sadd("key1", "c")
c.sadd("key2", "c")
c.sadd("key2", "d")
c.sadd("key2", "e")
ret = c.execute_command("sunion", "key1", "key2")
if ret != ['a', 'b', 'c', 'd', 'e']:
    print "sunion" + " result wrong " + "redis: ['a', 'b', 'c', 'd', 'e']" + " checker: " + str(ret)

#sunionstore
c.delete("key1")
c.delete("key2")
c.delete("key")
c.sadd("key1", "a")
c.sadd("key1", "b")
c.sadd("key1", "c")
c.sadd("key2", "c")
c.sadd("key2", "d")
c.sadd("key2", "e")
ret = c.execute_command("sunionstore", "key", "key1", "key2")
if str(ret) != "5":
    print "sunionstore" + " ret not compatible " + "redis: 5" + " checker: " + str(ret)

ret = c.smembers("key")
if ret != set(['a', 'c', 'b', 'e', 'd']):
    print "sunionstore" + " result wrong " + "redis: set(['a', 'c', 'b', 'e', 'd'])" + " checker: " + str(ret)

#zadd
c.delete("myzset")
ret = c.execute_command("zadd", "myzset", 1, "one")
if str(ret) != "1":
    print "zadd" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("zadd", "myzset", 1, "uno")
if str(ret) != "1":
    print "zadd" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.execute_command("zadd", "myzset", 2, "two", 3, "three")
if str(ret) != "2":
    print "zadd" + " ret not compatible " + "redis: 2" + " checker: " + str(ret)
ret = c.zrange("myzset", 0, -1, withscores=True)
if ret != [('one', 1.0), ('uno', 1.0), ('two', 2.0), ('three', 3.0)]:
    print "zadd" + " result wrong " + "redis: [('one', 1.0), ('uno', 1.0), ('two', 2.0), ('three', 3.0)]" + " checker: " + str(ret)

#zcard
c.delete("myzset")
c.zadd("myzset", "one", 1)
c.zadd("myzset", "two", 2)
ret = c.execute_command("zcard", "myzset")
if str(ret) != "2":
    print "zcard" + " result wrong " + "redis: 2" + " checker: " + str(ret)

#zcount
c.delete("myzset")
c.zadd("myzset", "one", 1)
c.zadd("myzset", "two", 2)
c.zadd("myzset", "three", 3)
ret = c.execute_command("zcount", "myzset", "-inf", "+inf")
if str(ret) != "3":
    print "zcount" + " result wrong " + "redis: 3" + " checker: " + str(ret)
ret = c.execute_command("zcount", "myzset", "(1", "3")
if str(ret) != "2":
    print "zcount" + " result wrong " + "redis: 2" + " checker: " + str(ret)

#zincrby
c.delete("myzset")
c.zadd("myzset", "one", 1)
c.zadd("myzset", "two", 2)
ret = c.execute_command("zincrby", "myzset", 2, "one")
if str(ret) != "3":
    print "zincrby" + " ret not compatible " + "redis: 3" + " checker: " + str(ret)
ret = c.zrange("myzset", 0, -1, withscores=True)
if ret != [('two', 2.0), ('one', 3.0)]:
    print "zincrby" + " result wrong " + "redis: [('two', 2.0), ('one', 3.0)]" + " checker: " + str(ret)

#zinterstore
c.delete("zset1")
c.delete("zset2")
c.delete("out")
c.zadd("zset1", "one", 1)
c.zadd("zset1", "two", 2)
c.zadd("zset2", "one", 1)
c.zadd("zset2", "two", 2)
c.zadd("zset2", "three", 3)
ret = c.execute_command("zinterstore", "out", 2, "zset1", "zset2", "weights", 2, 3)
if str(ret) != "2":
    print "zinterstore" + " ret not compatible " + "redis: 2" + " checker: " + str(ret)
ret = c.zrange("out", 0, -1, withscores=True)
if ret != [('one', 5.0), ('two', 10.0)]:
    print "zinterstore" + " result wrong " + "redis: [('one', 5.0), ('two', 10.0)]" + " checker: " + str(ret)

#zlexcount
c.delete("myzset")
c.zadd("myzset", "a", 0, "b", 0, "c", 0, "d", 0, "e", 0)
c.zadd("myzset", "f", 0, "g", 0)
ret = c.execute_command("zlexcount", "myzset", "-", "+")
if str(ret) != "7":
    print "zlexcount" + " ret not compatible " + "redis: 7" + " checker: " + str(ret)
ret = c.execute_command("zlexcount", "myzset", "[b", "[f")
if str(ret) != "5":
    print "zlexcount" + " ret not compatible " + "redis: 5" + " checker: " + str(ret)

#zrangebylex
c.delete("myzset")
c.zadd("myzset", "a", 0, "aa", 0, "abc", 0, "apple", 0, "b", 0, "c", 0, "d", 0, "d1", 0, "dd", 0, "dobble", 0, "z", 0, "z1", 0)
ret = c.execute_command("zrangebylex", "myzset", "-", "+")
if ret != ['a', 'aa', 'abc', 'apple', 'b', 'c', 'd', 'd1', 'dd', 'dobble', 'z', 'z1']:
    print "zrangebylex" + " result wrong " + "redis: ['a', 'aa', 'abc', 'apple', 'b', 'c', 'd', 'd1', 'dd', 'dobble', 'z', 'z1']" + " checker: " + str(ret)
ret = c.execute_command("zrangebylex", "myzset", "-", "+", "limit", 0, 3)
if ret != ['a', 'aa', 'abc']:
    print "zrangebylex" + " result wrong " + "redis: ['a', 'aa', 'abc']" + " checker: " + str(ret)

#zrevrangebylex
c.delete("myzset")
c.zadd("myzset", "a", 0, "aa", 0, "abc", 0, "apple", 0, "b", 0, "c", 0, "d", 0, "d1", 0, "dd", 0, "dobble", 0, "z", 0, "z1", 0)
ret = c.execute_command("zrevrangebylex", "myzset", "+", "-")
if ret != ['z1', 'z', 'dobble', 'dd', 'd1', 'd', 'c', 'b', 'apple', 'abc', 'aa', 'a']:
    print "zrevrangebylex" + " result wrong " + "redis: ['z1', 'z', 'dobble', 'dd', 'd1', 'd', 'c', 'b', 'apple', 'abc', 'aa', 'a']" + " checker: " + str(ret)
ret = c.execute_command("zrevrangebylex", "myzset", "+", "-", "limit", 3, 3)
if ret != ['dd', 'd1', 'd']:
    print "zrangebylex" + " result wrong " + "redis: ['dd', 'd1', 'd']" + " checker: " + str(ret)


#zrangebyscore
c.delete("myzset")
c.zadd("myzset", "one", 1)
c.zadd("myzset", "two", 2)
c.zadd("myzset", "three", 3)
ret = c.execute_command("zrangebyscore","myzset", "-inf", "+inf")
if ret != ['one', 'two', 'three']:
    print "zrangebyscore" + " result wrong " + "redis: ['one', 'two', 'three']" + " checker: " + str(ret)

#zrank
c.delete("myzset")
c.zadd("myzset", "one", 1)
c.zadd("myzset", "two", 2)
c.zadd("myzset", "three", 3)
ret = c.execute_command("zrank", "myzset", "three")
if str(ret) != "2":
    print "zrank" + " result wrong " + "redis: 2" + " checker: " + str(ret)
ret = c.execute_command("zrank", "myzset", "four")
if ret != None:
    print "zrank" + " result wrong " + "redis: None" + " checker: " + str(ret)

#zrem
c.delete("myzset")
c.zadd("myzset", "one", 1)
c.zadd("myzset", "two", 2)
c.zadd("myzset", "three", 3)
ret = c.execute_command("zrem", "myzset", "two")
if str(ret) != "1":
    print "zrem" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.zrange("myzset", 0, -1, withscores=True)
if ret != [('one', 1.0), ('three', 3.0)]:
    print "zrem" + " result wrong " + "redis: [('one', 1.0), ('three', 3.0)]" + " checker: " + str(ret)

#zremrangebylex
c.delete("myzset")
c.zadd("myzset", "a", 0, "aa", 0, "abc", 0, "apple", 0, "b", 0, "c", 0, "d", 0, "d1", 0, "dd", 0, "dobble", 0, "z", 0, "z1", 0)
ret = c.execute_command("zremrangebylex", "myzset", "-", "+")
if str(ret) != "12":
    print "zremrangebylex" + " ret not compatible " + "redis: 7" + " checker: " + str(ret)
ret = c.zrangebylex("myzset", "-", "+")
if ret != []:
    print "zremrangebylex" + " result wrong " + "redis: []" + " checker: " + str(ret)

#zremrangebyrank
c.delete("myzset")
c.zadd("myzset", "one", 1, "two", 2, "three", 3)
ret = c.execute_command("zremrangebyrank", "myzset", 0, 1)
if str(ret) != "2":
    print "zremrangebyrank" + " ret not compatible " + "redis: 2" + " checker: " + str(ret)
ret = c.zrange("myzset", 0, -1, withscores=True)
if ret != [('three', 3.0)]:
    print "zremrangebyrank" + " result wrong " + "redis: [('three', 3.0)]" + " checker: " + str(ret)

#zremrangebyscore
c.delete("myzset")
c.zadd("myzset", "one", 1, "two", 2, "three", 3)
ret = c.execute_command("zremrangebyscore", "myzset", "-inf", "(2")
if str(ret) != "1":
    print "zremrangebyscore" + " ret not compatible " + "redis: 1" + " checker: " + str(ret)
ret = c.zrange("myzset", 0, -1, withscores=True)
if ret != [('two', 2.0), ('three', 3.0)]:
    print "zremrangebyscore" + " result wrong " + "redis: [('two', 2.0), ('three', 3.0)]" + " checker: " + str(ret)

#zrevrange
c.delete("myzset")
c.zadd("myzset", "one", 1, "two", 2, "three", 3)
ret = c.execute_command("zrevrange", "myzset", 0, -1)
if ret != ['three', 'two', 'one']:
    print "zrevrange" + " result wrong " + "redis: ['three', 'two', 'one']" + " checker: " + str(ret)

#zrevrangebyscore
c.delete("myzset")
c.zadd("myzset", "one", 1, "two", 2, "three", 3)
ret = c.execute_command("zrevrangebyscore", "myzset", "+inf", "-inf")
if ret != ['three', 'two', 'one']:
    print "zrevrangebyscore" + " result wrong " + "redis: ['three', 'two', 'one']" + " checker: " + str(ret)
ret = c.execute_command("zrevrangebyscore", "myzset", 2, 1)
if ret != ['two', 'one']:
    print "zrevrangebyscore" + " result wrong " + "redis: ['two', 'one']" + " checker: " + str(ret)
ret = c.execute_command("zrevrangebyscore", "myzset", "(2", "(1")
if ret != []:
    print "zrevrangebyscore" + " result wrong " + "redis: []" + " checker: " + str(ret)

#zrevrank
c.delete("myzset")
c.zadd("myzset", "one", 1, "two", 2, "three", 3)
ret = c.execute_command("zrevrank", "myzset", "one")
if str(ret) != "2":
    print "zrevrank" + " result wrong " + "redis: 2" + " checker: " + str(ret)
ret = c.execute_command("zrevrank", "myzset", "four")
if ret != None:
    print "zrevrank" + " result wrong " + "redis: None" + " checker: " + str(ret)

#zscore
c.delete("myzset")
c.zadd("myzset", "one", 1, "two", 2, "three", 3)
ret = c.execute_command("zscore", "myzset", "one")
if str(ret) != "1":
    print "zscore" + " result wrong " + "redis: 1" + " checker: " + str(ret)

#zunionstore
c.delete("zset1")
c.delete("zset2")
c.delete("out")
c.zadd("zset1", "one", 1)
c.zadd("zset1", "two", 2)
c.zadd("zset2", "one", 1)
c.zadd("zset2", "two", 2)
c.zadd("zset2", "three", 3)
ret = c.execute_command("zunionstore", "out", 2, "zset1", "zset2", "weights", 2, 3)
if str(ret) != "3":
    print "zunionstore" + " ret not compatible " + "redis: 3" + " checker: " + str(ret)
ret = c.zrange("out", 0, -1, withscores=True)
if ret != [('one', 5.0), ('three', 9.0), ('two', 10.0)]:
    print "zunionstore" + " result wrong " + "redis: [('one', 5.0), ('three', 9.0), ('two', 10.0)]" + " checker: " + str(ret)

print "check done"
