fix: Uint64s and Uint64Map tests (gomodule#469)

Fix bad tests introduced by Uint64s and Uint64Map work.

Also:
* Fix some doc typos.

Author: stevenh

redis/reply.go

@@ -56,7 +56,7 @@ func Int(reply interface{}, err error) (int, error) {
 }
 
 // Int64 is a helper that converts a command reply to 64 bit integer. If err is
-// not equal to nil, then Int returns 0, err. Otherwise, Int64 converts the
+// not equal to nil, then Int64 returns 0, err. Otherwise, Int64 converts the
 // reply to an int64 as follows:
 //
 //  Reply type    Result
@@ -82,14 +82,16 @@ func Int64(reply interface{}, err error) (int64, error) {
 	return 0, fmt.Errorf("redigo: unexpected type for Int64, got type %T", reply)
 }
 
-var errNegativeInt = errors.New("redigo: unexpected value for Uint64")
+func errNegativeInt(v int64) error {
+	return fmt.Errorf("redigo: unexpected negative value %v for Uint64", v)
+}
 
-// Uint64 is a helper that converts a command reply to 64 bit integer. If err is
-// not equal to nil, then Int returns 0, err. Otherwise, Int64 converts the
-// reply to an int64 as follows:
+// Uint64 is a helper that converts a command reply to 64 bit unsigned integer.
+// If err is not equal to nil, then Uint64 returns 0, err. Otherwise, Uint64 converts the
+// reply to an uint64 as follows:
 //
 //  Reply type    Result
-//  integer       reply, nil
+//  +integer      reply, nil
 //  bulk string   parsed reply, nil
 //  nil           0, ErrNil
 //  other         0, error
@@ -100,7 +102,7 @@ func Uint64(reply interface{}, err error) (uint64, error) {
 	switch reply := reply.(type) {
 	case int64:
 		if reply < 0 {
-			return 0, errNegativeInt
+			return 0, errNegativeInt(reply)
 		}
 		return uint64(reply), nil
 	case []byte:
@@ -501,7 +503,6 @@ func Uint64s(reply interface{}, err error) ([]uint64, error) {
 	return result, err
 }
 
-
 // Uint64Map is a helper that converts an array of strings (alternating key, value)
 // into a map[string]uint64. The HGETALL commands return replies in this format.
 // Requires an even number of values in result.

redis/reply_test.go

@@ -25,6 +25,10 @@ import (
 	"github.com/gomodule/redigo/redis"
 )
 
+var (
+	maxUint64Str = strconv.FormatUint(math.MaxUint64, 10)
+)
+
 type valueError struct {
 	v   interface{}
 	err error
@@ -69,38 +73,18 @@ var replyTests = []struct {
 		ve(redis.Int64s([]interface{}{int64(4), int64(5)}, nil)),
 		ve([]int64{4, 5}, nil),
 	},
-	{
-		"uint64s([uint64, uint64])",
-		ve(redis.Uint64s([]interface{}{uint64(4), uint64(5)}, nil)),
-		ve([]uint64{4, 5}, nil),
-	},
-	{
-		"uint64s([uint64, uint64])",
-		ve(redis.Uint64s([]interface{}{math.MaxUint64, math.MaxUint64}, nil)),
-		ve([]uint64{math.MaxUint64, math.MaxUint64}, nil),
-	},
 	{
 		"uint64s([[]byte, []byte])",
-		ve(redis.Uint64s([]interface{}{[]byte("4"), []byte("5")}, nil)),
-		ve([]uint64{4, 5}, nil),
+		ve(redis.Uint64s([]interface{}{[]byte(maxUint64Str), []byte("5")}, nil)),
+		ve([]uint64{math.MaxUint64, 5}, nil),
 	},
 	{
 		"Uint64Map([[]byte, []byte])",
-		ve(redis.Uint64Map([]interface{}{[]byte("4"), []byte("5")}, nil)),
-		ve(map[string]uint64{"1": 4, "2": 5}, nil),
-	},
-	{
-		"Uint64Map([uint64, uint64])",
-		ve(redis.Uint64Map([]interface{}{uint64(4), uint64(5)}, nil)),
-		ve(map[string]uint64{"1": 4, "2": 5}, nil),
-	},
-	{
-		"Uint64Map([uint64, uint64])",
-		ve(redis.Uint64Map([]interface{}{math.MaxUint64, math.MaxUint64}, nil)),
-		ve(map[string]uint64{"1": math.MaxUint64, "2": math.MaxUint64}, nil),
+		ve(redis.Uint64Map([]interface{}{[]byte("key1"), []byte(maxUint64Str), []byte("key2"), []byte("5")}, nil)),
+		ve(map[string]uint64{"key1": math.MaxUint64, "key2": 5}, nil),
 	},
 	{
-		"strings([[]byte, []bytev2])",
+		"strings([[]byte, []byte])",
 		ve(redis.Strings([]interface{}{[]byte("v1"), []byte("v2")}, nil)),
 		ve([]string{"v1", "v2"}, nil),
 	},
@@ -147,7 +131,7 @@ var replyTests = []struct {
 	{
 		"uint64(-1)",
 		ve(redis.Uint64(int64(-1), nil)),
-		ve(uint64(0), redis.ErrNegativeInt),
+		ve(uint64(0), redis.ErrNegativeInt(-1)),
 	},
 	{
 		"positions([[1, 2], nil, [3, 4]])",
@@ -171,7 +155,7 @@ func getSlowLog() (redis.SlowLog, error) {
 
 func TestReply(t *testing.T) {
 	for _, rt := range replyTests {
-		if rt.actual.err != rt.expected.err {
+		if rt.actual.err != rt.expected.err && rt.actual.err.Error() != rt.expected.err.Error() {
 			t.Errorf("%s returned err %v, want %v", rt.name, rt.actual.err, rt.expected.err)
 			continue
 		}