remove foolish code

server/cmd_bit_test.go

@@ -226,157 +226,157 @@ func TestBitErrorParams(t *testing.T) {
 	c := getTestConn()
 	defer c.Close()
 
-	if _, err := c.Do("bget"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bget"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bdelete"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bdelete"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	// bsetbit
-	if _, err := c.Do("bsetbit"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bsetbit"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bsetbit", "test_bsetbit"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bsetbit", "test_bsetbit"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bsetbit", "test_bsetbit", "o", "v"); err == nil || err.Error() != SErrOffset {
+	if _, err := c.Do("bsetbit", "test_bsetbit", "o", "v"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bsetbit", "test_bsetbit", "o", 1); err == nil || err.Error() != SErrOffset {
+	if _, err := c.Do("bsetbit", "test_bsetbit", "o", 1); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	// if _, err := c.Do("bsetbit", "test_bsetbit", -1, 1); err == nil || err.Error() != SErrOffset {
+	// if _, err := c.Do("bsetbit", "test_bsetbit", -1, 1); err == nil  {
 	// 	t.Fatal("invalid err of %v", err)
 	// }
 
-	if _, err := c.Do("bsetbit", "test_bsetbit", 1, "v"); err == nil || err.Error() != SErrBool {
+	if _, err := c.Do("bsetbit", "test_bsetbit", 1, "v"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bsetbit", "test_bsetbit", 1, 2); err == nil || err.Error() != SErrBool {
+	if _, err := c.Do("bsetbit", "test_bsetbit", 1, 2); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//bgetbit
-	if _, err := c.Do("bgetbit", "test_bgetbit"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bgetbit", "test_bgetbit"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bgetbit", "test_bgetbit", "o"); err == nil || err.Error() != SErrOffset {
+	if _, err := c.Do("bgetbit", "test_bgetbit", "o"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	// if _, err := c.Do("bgetbit", "test_bgetbit", -1); err == nil || err.Error() != SErrOffset {
+	// if _, err := c.Do("bgetbit", "test_bgetbit", -1); err == nil  {
 	// 	t.Fatal("invalid err of %v", err)
 	// }
 
 	//bmsetbit
-	if _, err := c.Do("bmsetbit", "test_bmsetbit"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bmsetbit", "test_bmsetbit"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bmsetbit", "test_bmsetbit", 0, 1, 2); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bmsetbit", "test_bmsetbit", 0, 1, 2); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bmsetbit", "test_bmsetbit", "o", "v"); err == nil || err.Error() != SErrOffset {
+	if _, err := c.Do("bmsetbit", "test_bmsetbit", "o", "v"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bmsetbit", "test_bmsetbit", "o", 1); err == nil || err.Error() != SErrOffset {
+	if _, err := c.Do("bmsetbit", "test_bmsetbit", "o", 1); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	// if _, err := c.Do("bmsetbit", "test_bmsetbit", -1, 1); err == nil || err.Error() != SErrOffset {
+	// if _, err := c.Do("bmsetbit", "test_bmsetbit", -1, 1); err == nil  {
 	// 	t.Fatal("invalid err of %v", err)
 	// }
 
-	if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, "v"); err == nil || err.Error() != SErrBool {
+	if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, "v"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, 2); err == nil || err.Error() != SErrBool {
+	if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, 2); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, 0.1); err == nil || err.Error() != SErrBool {
+	if _, err := c.Do("bmsetbit", "test_bmsetbit", 1, 0.1); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//bcount
 
-	if _, err := c.Do("bcount"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bcount"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bcount", "a", "b", "c"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("bcount", "a", "b", "c"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bcount", 1, "a"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("bcount", 1, "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	// if _, err := c.Do("bcount", 1); err == nil || err.Error() != SErrCmdParams {
+	// if _, err := c.Do("bcount", 1); err == nil  {
 	// 	t.Fatal("invalid err of %v", err)
 	// }
 
 	//bopt
-	if _, err := c.Do("bopt"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bopt"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bopt", "and", 1); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bopt", "and", 1); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bopt", "x", 1); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bopt", "x", 1); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bopt", ""); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bopt", ""); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bexpire", "test_bexpire"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bexpire", "test_bexpire"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bexpireat", "test_bexpireat"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bexpireat", "test_bexpireat"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bttl"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bttl"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("bpersist"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bpersist"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//bexpire
-	if _, err := c.Do("bexpire", "test_bexpire"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bexpire", "test_bexpire"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//bexpireat
-	if _, err := c.Do("bexpireat", "test_bexpireat"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bexpireat", "test_bexpireat"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//bttl
-	if _, err := c.Do("bttl"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bttl"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//bpersist
-	if _, err := c.Do("bpersist"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("bpersist"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 

server/cmd_hash_test.go

@@ -221,79 +221,79 @@ func TestHashErrorParams(t *testing.T) {
 	c := getTestConn()
 	defer c.Close()
 
-	if _, err := c.Do("hset", "test_hset"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hset", "test_hset"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hget", "test_hget"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hget", "test_hget"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hexists", "test_hexists"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hexists", "test_hexists"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hdel", "test_hdel"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hdel", "test_hdel"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hlen", "test_hlen", "a"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hlen", "test_hlen", "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hincrby", "test_hincrby"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hincrby", "test_hincrby"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hmset", "test_hmset"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hmset", "test_hmset"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hmset", "test_hmset", "f1", "v1", "f2"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hmset", "test_hmset", "f1", "v1", "f2"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hmget", "test_hget"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hmget", "test_hget"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hgetall"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hgetall"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hkeys"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hkeys"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hvals"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hvals"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hclear"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hclear"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hclear", "test_hclear", "a"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hclear", "test_hclear", "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hmclear"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hmclear"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hexpire", "test_hexpire"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hexpire", "test_hexpire"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hexpireat", "test_hexpireat"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hexpireat", "test_hexpireat"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("httl"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("httl"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("hpersist"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("hpersist"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 

server/cmd_kv_test.go

@@ -142,75 +142,75 @@ func TestKVErrorParams(t *testing.T) {
 	c := getTestConn()
 	defer c.Close()
 
-	if _, err := c.Do("get", "a", "b", "c"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("get", "a", "b", "c"); err == nil {
 		t.Fatalf("invalid err %v", err)
 	}
 
-	if _, err := c.Do("set", "a", "b", "c"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("set", "a", "b", "c"); err == nil {
 		t.Fatalf("invalid err %v", err)
 	}
 
-	if _, err := c.Do("getset", "a", "b", "c"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("getset", "a", "b", "c"); err == nil {
 		t.Fatalf("invalid err %v", err)
 	}
 
-	if _, err := c.Do("setnx", "a", "b", "c"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("setnx", "a", "b", "c"); err == nil {
 		t.Fatalf("invalid err %v", err)
 	}
 
-	if _, err := c.Do("exists", "a", "b"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("exists", "a", "b"); err == nil {
 		t.Fatalf("invalid err %v", err)
 	}
 
-	if _, err := c.Do("incr", "a", "b"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("incr", "a", "b"); err == nil {
 		t.Fatalf("invalid err %v", err)
 	}
 
-	if _, err := c.Do("incrby", "a"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("incrby", "a"); err == nil {
 		t.Fatalf("invalid err %v", err)
 	}
 
-	if _, err := c.Do("decrby", "a"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("decrby", "a"); err == nil {
 		t.Fatalf("invalid err %v", err)
 	}
 
-	if _, err := c.Do("del"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("del"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("mset"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("mset"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("mset", "a", "b", "c"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("mset", "a", "b", "c"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("mget"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("mget"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("expire"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("expire"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("expire", "a", "b"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("expire", "a", "b"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("expireat"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("expireat"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("expireat", "a", "b"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("expireat", "a", "b"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("ttl"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("ttl"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("persist"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("persist"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 

server/cmd_list_test.go

@@ -289,55 +289,55 @@ func TestListErrorParams(t *testing.T) {
 	c := getTestConn()
 	defer c.Close()
 
-	if _, err := c.Do("lpush", "test_lpush"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lpush", "test_lpush"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("rpush", "test_rpush"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("rpush", "test_rpush"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("lpop", "test_lpop", "a"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lpop", "test_lpop", "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("rpop", "test_rpop", "a"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("rpop", "test_rpop", "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("llen", "test_llen", "a"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("llen", "test_llen", "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("lindex", "test_lindex"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lindex", "test_lindex"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("lrange", "test_lrange"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lrange", "test_lrange"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("lclear"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lclear"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("lmclear"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lmclear"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("lexpire"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lexpire"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("lexpireat"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lexpireat"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("lttl"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lttl"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("lpersist"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("lpersist"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 

server/cmd_zset_test.go

@@ -435,166 +435,166 @@ func TestZsetErrorParams(t *testing.T) {
 	defer c.Close()
 
 	//zadd
-	if _, err := c.Do("zadd", "test_zadd"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zadd", "test_zadd"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zadd", "test_zadd", "a", "b", "c"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zadd", "test_zadd", "a", "b", "c"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zadd", "test_zadd", "-a", "a"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zadd", "test_zadd", "-a", "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zadd", "test_zad", "0.1", "a"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zadd", "test_zad", "0.1", "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zcard
-	if _, err := c.Do("zcard"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zcard"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zscore
-	if _, err := c.Do("zscore", "test_zscore"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zscore", "test_zscore"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zrem
-	if _, err := c.Do("zrem", "test_zrem"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrem", "test_zrem"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zincrby
-	if _, err := c.Do("zincrby", "test_zincrby"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zincrby", "test_zincrby"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zincrby", "test_zincrby", 0.1, "a"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zincrby", "test_zincrby", 0.1, "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zcount
-	if _, err := c.Do("zcount", "test_zcount"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zcount", "test_zcount"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zcount", "test_zcount", "-inf", "=inf"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zcount", "test_zcount", "-inf", "=inf"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zcount", "test_zcount", 0.1, 0.1); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zcount", "test_zcount", 0.1, 0.1); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zrank
-	if _, err := c.Do("zrank", "test_zrank"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrank", "test_zrank"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zrevzrank
-	if _, err := c.Do("zrevrank", "test_zrevrank"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrevrank", "test_zrevrank"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zremrangebyrank
-	if _, err := c.Do("zremrangebyrank", "test_zremrangebyrank"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zremrangebyrank", "test_zremrangebyrank"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zremrangebyrank", "test_zremrangebyrank", 0.1, 0.1); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zremrangebyrank", "test_zremrangebyrank", 0.1, 0.1); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zremrangebyscore
-	if _, err := c.Do("zremrangebyscore", "test_zremrangebyscore"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zremrangebyscore", "test_zremrangebyscore"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zremrangebyscore", "test_zremrangebyscore", "-inf", "a"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zremrangebyscore", "test_zremrangebyscore", "-inf", "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zremrangebyscore", "test_zremrangebyscore", 0, "a"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zremrangebyscore", "test_zremrangebyscore", 0, "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zrange
-	if _, err := c.Do("zrange", "test_zrange"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrange", "test_zrange"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zrange", "test_zrange", 0, 1, "withscore"); err == nil || err.Error() != SErrSyntax {
+	if _, err := c.Do("zrange", "test_zrange", 0, 1, "withscore"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zrange", "test_zrange", 0, 1, "withscores", "a"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrange", "test_zrange", 0, 1, "withscores", "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zrevrange, almost same as zrange
-	if _, err := c.Do("zrevrange", "test_zrevrange"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrevrange", "test_zrevrange"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zrangebyscore
-	if _, err := c.Do("zrangebyscore", "test_zrangebyscore"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrangebyscore", "test_zrangebyscore"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscore"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscore"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limit"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limit"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limi", 1, 1); err == nil || err.Error() != SErrSyntax {
+	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limi", 1, 1); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limit", "a", 1); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limit", "a", 1); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
-	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limit", 1, "a"); err == nil || err.Error() != SErrValue {
+	if _, err := c.Do("zrangebyscore", "test_zrangebyscore", 0, 1, "withscores", "limit", 1, "a"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zrevrangebyscore, almost same as zrangebyscore
-	if _, err := c.Do("zrevrangebyscore", "test_zrevrangebyscore"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zrevrangebyscore", "test_zrevrangebyscore"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zclear
-	if _, err := c.Do("zclear"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zclear"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zmclear
-	if _, err := c.Do("zmclear"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zmclear"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zexpire
-	if _, err := c.Do("zexpire", "test_zexpire"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zexpire", "test_zexpire"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zexpireat
-	if _, err := c.Do("zexpireat", "test_zexpireat"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zexpireat", "test_zexpireat"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zttl
-	if _, err := c.Do("zttl"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zttl"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 
 	//zpersist
-	if _, err := c.Do("zpersist"); err == nil || err.Error() != SErrCmdParams {
+	if _, err := c.Do("zpersist"); err == nil {
 		t.Fatal("invalid err of %v", err)
 	}
 

server/const.go

@@ -20,11 +20,6 @@ var (
 	NullBulk  = []byte("-1")
 	NullArray = []byte("-1")
 
-	PONG          = "PONG"
+	PONG = "PONG"
-	OK            = "OK"
+	OK   = "OK"
-	SErrCmdParams = "ERR invalid command param"
-	SErrValue     = "ERR value is not an integer or out of range"
-	SErrSyntax    = "ERR syntax error"
-	SErrOffset    = "ERR offset bit is not an natural number"
-	SErrBool      = "ERR value is not 0 or 1"
 )