feat: add AddTrailingSlashBytes and AddTrailingSlashString functions with tests for trailing slash handling

Author: ReneWerner87

bytes.go

@@ -63,3 +63,10 @@ func ToUpperBytes(b []byte) []byte {
 
 	return b
 }
+
+// AddTrailingSlashBytes appends a trailing '/' to b if it does not already end with one.
+// If the input already ends with '/', the original slice is returned.
+// A new slice is returned when a '/' is appended. The original slice is never modified.
+func AddTrailingSlashBytes(b []byte) []byte {
+	return UnsafeBytes(AddTrailingSlashString(UnsafeString(b)))
+}

bytes_test.go

@@ -105,3 +105,76 @@ func Test_ToUpperBytes_Edge(t *testing.T) {
 		})
 	}
 }
+
+func Test_AddTrailingSlashBytes(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name string
+		in   []byte
+		want []byte
+	}{
+		{name: "empty", in: []byte(""), want: []byte("/")},
+		{name: "slash-only", in: []byte("/"), want: []byte("/")},
+		{name: "short-no-slash", in: []byte("abc"), want: []byte("abc/")},
+		{name: "short-with-slash", in: []byte("abc/"), want: []byte("abc/")},
+		{name: "path-no-slash", in: []byte("/api/v1/users"), want: []byte("/api/v1/users/")},
+		{name: "path-with-slash", in: []byte("/api/v1/users/"), want: []byte("/api/v1/users/")},
+		{name: "double-slash", in: []byte("abc//"), want: []byte("abc//")},
+		{name: "unicode", in: []byte("/日本語"), want: []byte("/日本語/")},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			result := AddTrailingSlashBytes(tc.in)
+			require.Equal(t, tc.want, result)
+		})
+	}
+}
+
+func Test_AddTrailingSlashBytes_NoMutation(t *testing.T) {
+	t.Parallel()
+
+	original := []byte("test")
+	originalCopy := make([]byte, len(original))
+	copy(originalCopy, original)
+
+	_ = AddTrailingSlashBytes(original)
+
+	require.Equal(t, originalCopy, original, "original slice should not be mutated")
+}
+
+func Test_AddTrailingSlashBytes_ReturnsSame(t *testing.T) {
+	t.Parallel()
+
+	input := []byte("test/")
+	result := AddTrailingSlashBytes(input)
+	require.Equal(t, input, result)
+	require.Same(t, &input[0], &result[0], "should return same slice instance")
+}
+
+func Benchmark_AddTrailingSlashBytes(b *testing.B) {
+	cases := []struct {
+		name  string
+		input []byte
+	}{
+		{name: "empty", input: []byte("")},
+		{name: "slash-only", input: []byte("/")},
+		{name: "short-no-slash", input: []byte("abc")},
+		{name: "short-with-slash", input: []byte("abc/")},
+		{name: "path-no-slash", input: []byte("/api/v1/users")},
+		{name: "path-with-slash", input: []byte("/api/v1/users/")},
+	}
+
+	for _, tc := range cases {
+		b.Run(tc.name, func(b *testing.B) {
+			b.ReportAllocs()
+			var res []byte
+			for n := 0; n < b.N; n++ {
+				res = AddTrailingSlashBytes(tc.input)
+			}
+			_ = res
+		})
+	}
+}

byteseq.go

@@ -1,10 +1,5 @@
 package utils
 
-import (
-	"reflect"
-	"slices"
-)
-
 type byteSeq interface {
 	~string | ~[]byte
 }
@@ -114,43 +109,3 @@ func TrimSpace[S byteSeq](s S) S {
 
 	return s[i : j+1]
 }
-
-// AddTrailingSlash appends a trailing '/' to v if it does not already end with one.
-//
-// For string inputs, a new string is returned only when a '/' needs to be appended.
-// If the input already ends with '/', the original string is returned.
-//
-// For []byte inputs, a new slice is returned when a '/' is appended.
-// If the input already ends with '/', the original slice is returned unchanged.
-// The original slice is never modified.
-func AddTrailingSlash[T byteSeq](v T) T {
-	n := len(v)
-	if n > 0 && v[n-1] == '/' {
-		return v
-	}
-	// Type-specific optimization
-	switch x := any(v).(type) {
-	case string:
-		// For strings: allocate exact size, use UnsafeString to avoid double alloc
-		buf := make([]byte, n+1)
-		copy(buf, x)
-		buf[n] = '/'
-		return any(UnsafeString(buf)).(T) //nolint:forcetypeassert,errcheck // type is guaranteed
-	case []byte:
-		// For bytes: use append which may reuse capacity
-		return any(append(x, '/')).(T) //nolint:forcetypeassert,errcheck // type is guaranteed
-	default:
-		// Fallback for named types (e.g., type MyString string) using reflection
-		val := reflect.ValueOf(v)
-		if val.Kind() == reflect.String {
-			s := val.String() + "/"
-			return reflect.ValueOf(s).Convert(val.Type()).Interface().(T) //nolint:forcetypeassert,errcheck // type is guaranteed
-		}
-		// Assumed to be a slice of bytes
-		b := val.Bytes()
-		res := append(slices.Clone(b), '/')
-		newSlice := reflect.MakeSlice(val.Type(), len(res), len(res))
-		reflect.Copy(newSlice, reflect.ValueOf(res))
-		return newSlice.Interface().(T) //nolint:forcetypeassert,errcheck // type is guaranteed
-	}
-}

byteseq_test.go

@@ -415,158 +415,3 @@ func Benchmark_TrimSpaceBytes(b *testing.B) {
 		})
 	}
 }
-
-// Shared test cases for AddTrailingSlash benchmarks
-var addTrailingSlashBenchmarkCases = []struct {
-	name  string
-	input string
-}{
-	{name: "empty", input: ""},
-	{name: "slash-only", input: "/"},
-	{name: "short-no-slash", input: "abc"},
-	{name: "short-with-slash", input: "abc/"},
-	{name: "path-no-slash", input: "/api/v1/users"},
-	{name: "path-with-slash", input: "/api/v1/users/"},
-	{name: "long-no-slash", input: "/api/v1/users/profile/settings/notifications"},
-	{name: "long-with-slash", input: "/api/v1/users/profile/settings/notifications/"},
-}
-
-func Test_AddTrailingSlash(t *testing.T) {
-	t.Parallel()
-
-	testCases := []struct {
-		name string
-		in   string
-		want string
-	}{
-		{name: "empty", in: "", want: "/"},
-		{name: "slash-only", in: "/", want: "/"},
-		{name: "short-no-slash", in: "abc", want: "abc/"},
-		{name: "short-with-slash", in: "abc/", want: "abc/"},
-		{name: "path-no-slash", in: "/api/v1/users", want: "/api/v1/users/"},
-		{name: "path-with-slash", in: "/api/v1/users/", want: "/api/v1/users/"},
-		{name: "double-slash", in: "abc//", want: "abc//"},
-		{name: "root-path", in: "/", want: "/"},
-		{name: "spaces", in: "  ", want: "  /"},
-		{name: "unicode", in: "/日本語", want: "/日本語/"},
-		{name: "unicode-with-slash", in: "/日本語/", want: "/日本語/"},
-	}
-
-	for _, tc := range testCases {
-		tc := tc
-		t.Run(tc.name+"/string", func(t *testing.T) {
-			t.Parallel()
-			result := AddTrailingSlash(tc.in)
-			require.Equal(t, tc.want, result)
-		})
-		t.Run(tc.name+"/bytes", func(t *testing.T) {
-			t.Parallel()
-			result := AddTrailingSlash([]byte(tc.in))
-			require.Equal(t, []byte(tc.want), result)
-		})
-	}
-}
-
-func Test_AddTrailingSlash_NoMutation(t *testing.T) {
-	t.Parallel()
-
-	// Ensure original byte slice is not mutated
-	original := []byte("test")
-	originalCopy := make([]byte, len(original))
-	copy(originalCopy, original)
-
-	_ = AddTrailingSlash(original)
-
-	require.Equal(t, originalCopy, original, "original slice should not be mutated")
-}
-
-func Test_AddTrailingSlash_AlreadyHasSlash_ReturnsSame(t *testing.T) {
-	t.Parallel()
-
-	// For byte slices with trailing slash, should return the same slice instance
-	input := []byte("test/")
-	result := AddTrailingSlash(input)
-	require.Equal(t, input, result)
-	require.Same(t, &input[0], &result[0], "should return same slice instance")
-
-	// For strings with trailing slash, should return the same string
-	inputStr := "test/"
-	resultStr := AddTrailingSlash(inputStr)
-	require.Equal(t, inputStr, resultStr)
-}
-
-func Test_AddTrailingSlash_NamedTypes(t *testing.T) {
-	t.Parallel()
-
-	type MyString string
-	type MyBytes []byte
-
-	t.Run("named string without slash", func(t *testing.T) {
-		t.Parallel()
-		result := AddTrailingSlash(MyString("abc"))
-		require.Equal(t, MyString("abc/"), result)
-	})
-
-	t.Run("named string with slash", func(t *testing.T) {
-		t.Parallel()
-		result := AddTrailingSlash(MyString("abc/"))
-		require.Equal(t, MyString("abc/"), result)
-	})
-
-	t.Run("named bytes without slash", func(t *testing.T) {
-		t.Parallel()
-		result := AddTrailingSlash(MyBytes("abc"))
-		require.Equal(t, MyBytes("abc/"), result)
-	})
-
-	t.Run("named bytes with slash", func(t *testing.T) {
-		t.Parallel()
-		result := AddTrailingSlash(MyBytes("abc/"))
-		require.Equal(t, MyBytes("abc/"), result)
-	})
-
-	t.Run("empty named string", func(t *testing.T) {
-		t.Parallel()
-		result := AddTrailingSlash(MyString(""))
-		require.Equal(t, MyString("/"), result)
-	})
-
-	t.Run("empty named bytes", func(t *testing.T) {
-		t.Parallel()
-		result := AddTrailingSlash(MyBytes(""))
-		require.Equal(t, MyBytes("/"), result)
-	})
-}
-
-func Benchmark_AddTrailingSlash(b *testing.B) {
-	for _, tc := range addTrailingSlashBenchmarkCases {
-		tc := tc
-		b.Run("string/"+tc.name, func(b *testing.B) {
-			b.ReportAllocs()
-			b.SetBytes(int64(len(tc.input)))
-			b.ResetTimer()
-			var res string
-			for n := 0; n < b.N; n++ {
-				res = AddTrailingSlash(tc.input)
-			}
-			_ = res
-		})
-	}
-}
-
-func Benchmark_AddTrailingSlashBytes(b *testing.B) {
-	for _, tc := range addTrailingSlashBenchmarkCases {
-		tc := tc
-		input := []byte(tc.input)
-		b.Run("bytes/"+tc.name, func(b *testing.B) {
-			b.ReportAllocs()
-			b.SetBytes(int64(len(input)))
-			b.ResetTimer()
-			var res []byte
-			for n := 0; n < b.N; n++ {
-				res = AddTrailingSlash(input)
-			}
-			_ = res
-		})
-	}
-}

strings.go

@@ -48,3 +48,20 @@ func ToUpper(b string) string {
 
 	return b
 }
+
+// AddTrailingSlashString appends a trailing '/' to s if it does not already end with one.
+// If the input already ends with '/', the original string is returned.
+// A new string is returned only when a '/' needs to be appended.
+func AddTrailingSlashString(s string) string {
+	n := len(s)
+	if n == 0 {
+		return "/"
+	}
+	if s[n-1] == '/' {
+		return s
+	}
+	buf := make([]byte, n+1)
+	copy(buf, s)
+	buf[n] = '/'
+	return UnsafeString(buf)
+}

strings_test.go

@@ -193,3 +193,55 @@ func Benchmark_ToLower(b *testing.B) {
 		})
 	}
 }
+
+func Test_AddTrailingSlashString(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{name: "empty", in: "", want: "/"},
+		{name: "slash-only", in: "/", want: "/"},
+		{name: "short-no-slash", in: "abc", want: "abc/"},
+		{name: "short-with-slash", in: "abc/", want: "abc/"},
+		{name: "path-no-slash", in: "/api/v1/users", want: "/api/v1/users/"},
+		{name: "path-with-slash", in: "/api/v1/users/", want: "/api/v1/users/"},
+		{name: "double-slash", in: "abc//", want: "abc//"},
+		{name: "unicode", in: "/日本語", want: "/日本語/"},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			result := AddTrailingSlashString(tc.in)
+			require.Equal(t, tc.want, result)
+		})
+	}
+}
+
+func Benchmark_AddTrailingSlashString(b *testing.B) {
+	cases := []struct {
+		name  string
+		input string
+	}{
+		{name: "empty", input: ""},
+		{name: "slash-only", input: "/"},
+		{name: "short-no-slash", input: "abc"},
+		{name: "short-with-slash", input: "abc/"},
+		{name: "path-no-slash", input: "/api/v1/users"},
+		{name: "path-with-slash", input: "/api/v1/users/"},
+	}
+
+	for _, tc := range cases {
+		b.Run(tc.name, func(b *testing.B) {
+			b.ReportAllocs()
+			var res string
+			for n := 0; n < b.N; n++ {
+				res = AddTrailingSlashString(tc.input)
+			}
+			_ = res
+		})
+	}
+}