Test/Benchmark, old code with safety harness preventing panic

Author: manisharma

export_test.go

@@ -106,3 +106,7 @@ func (c *ModuleLoadexConfig) ToArgs() []interface{} {
 func ShouldRetry(err error, retryTimeout bool) bool {
 	return shouldRetry(err, retryTimeout)
 }
+
+func JoinErrors(errs []error) string {
+	return joinErrors(errs)
+}

sentinel.go

@@ -16,6 +16,7 @@ import (
 	"github.com/redis/go-redis/v9/internal"
 	"github.com/redis/go-redis/v9/internal/pool"
 	"github.com/redis/go-redis/v9/internal/rand"
+	"github.com/redis/go-redis/v9/internal/util"
 	"github.com/redis/go-redis/v9/push"
 )
 
@@ -900,14 +901,12 @@ func joinErrors(errs []error) string {
 	if len(errs) == 1 {
 		return errs[0].Error()
 	}
-
-	var b strings.Builder
-	b.WriteString(errs[0].Error())
+	b := []byte(errs[0].Error())
 	for _, err := range errs[1:] {
-		b.WriteByte('\n')
-		b.WriteString(err.Error())
+		b = append(b, '\n')
+		b = append(b, err.Error()...)
 	}
-	return b.String()
+	return util.BytesToString(b)
 }
 
 func (c *sentinelFailover) replicaAddrs(ctx context.Context, useDisconnected bool) ([]string, error) {

sentinel_test.go

@@ -682,3 +682,99 @@ func compareSlices(t *testing.T, a, b []string, name string) {
 		}
 	}
 }
+
+type joinErrorsTest struct {
+	name     string
+	errs     []error
+	expected string
+}
+
+func TestJoinErrors(t *testing.T) {
+	tests := []joinErrorsTest{
+		{
+			name:     "empty slice",
+			errs:     []error{},
+			expected: "",
+		},
+		{
+			name:     "single error",
+			errs:     []error{errors.New("first error")},
+			expected: "first error",
+		},
+		{
+			name:     "two errors",
+			errs:     []error{errors.New("first error"), errors.New("second error")},
+			expected: "first error\nsecond error",
+		},
+		{
+			name: "multiple errors",
+			errs: []error{
+				errors.New("first error"),
+				errors.New("second error"),
+				errors.New("third error"),
+			},
+			expected: "first error\nsecond error\nthird error",
+		},
+		{
+			name:     "nil slice",
+			errs:     nil,
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := redis.JoinErrors(tt.errs)
+			if result != tt.expected {
+				t.Errorf("joinErrors() = %q, want %q", result, tt.expected)
+			}
+		})
+	}
+}
+
+func BenchmarkJoinErrors(b *testing.B) {
+	benchmarks := []joinErrorsTest{
+		{
+			name:     "empty slice",
+			errs:     []error{},
+			expected: "",
+		},
+		{
+			name:     "single error",
+			errs:     []error{errors.New("first error")},
+			expected: "first error",
+		},
+		{
+			name:     "two errors",
+			errs:     []error{errors.New("first error"), errors.New("second error")},
+			expected: "first error\nsecond error",
+		},
+		{
+			name: "multiple errors",
+			errs: []error{
+				errors.New("first error"),
+				errors.New("second error"),
+				errors.New("third error"),
+			},
+			expected: "first error\nsecond error\nthird error",
+		},
+		{
+			name:     "nil slice",
+			errs:     nil,
+			expected: "",
+		},
+	}
+	for _, bm := range benchmarks {
+		b.Run(bm.name, func(b *testing.B) {
+			b.ResetTimer()
+			b.RunParallel(func(pb *testing.PB) {
+				for pb.Next() {
+					result := redis.JoinErrors(bm.errs)
+					if result != bm.expected {
+						b.Errorf("joinErrors() = %q, want %q", result, bm.expected)
+					}
+				}
+			})
+		})
+	}
+}