Merge a9b0085e40f6b9149ebe79868f68ce5c86fe6456 into ecb3f7b5e2f3915bf1db240ed5eee572f8dbea36

.github/workflows/codeql.yml

@@ -33,7 +33,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL

.github/workflows/gin.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
       - name: Set up Go
@@ -54,17 +54,17 @@ jobs:
       TESTTAGS: ${{ matrix.test-tags }}
       GOPROXY: https://proxy.golang.org
     steps:
+      - name: Checkout Code
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ github.ref }}
+
       - name: Set up Go ${{ matrix.go }}
         uses: actions/setup-go@v6
         with:
           go-version: ${{ matrix.go }}
           cache: false
 
-      - name: Checkout Code
-        uses: actions/checkout@v6
-        with:
-          ref: ${{ github.ref }}
-
       - uses: actions/cache@v4
         with:
           path: |

.github/workflows/goreleaser.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
       - name: Set up Go

.github/workflows/trivy-scan.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 

gin.go

@@ -11,6 +11,7 @@ import (
 	"net/http"
 	"os"
 	"path"
+	"regexp"
 	"strings"
 	"sync"
 
@@ -47,6 +48,11 @@ var defaultTrustedCIDRs = []*net.IPNet{
 	},
 }
 
+var (
+	regSafePrefix         = regexp.MustCompile("[^a-zA-Z0-9/-]+")
+	regRemoveRepeatedChar = regexp.MustCompile("/{2,}")
+)
+
 // HandlerFunc defines the handler used by gin middleware as return value.
 type HandlerFunc func(*Context)
 
@@ -135,16 +141,10 @@ type Engine struct {
 	AppEngine bool
 
 	// UseRawPath if enabled, the url.RawPath will be used to find parameters.
-	// The RawPath is only a hint, EscapedPath() should be use instead. (https://pkg.go.dev/net/url@master#URL)
-	// Only use RawPath if you know what you are doing.
 	UseRawPath bool
 
-	// UseEscapedPath if enable, the url.EscapedPath() will be used to find parameters
-	// It overrides UseRawPath
-	UseEscapedPath bool
-
 	// UnescapePathValues if true, the path value will be unescaped.
-	// If UseRawPath and UseEscapedPath are false (by default), the UnescapePathValues effectively is true,
+	// If UseRawPath is false (by default), the UnescapePathValues effectively is true,
 	// as url.Path gonna be used, which is already unescaped.
 	UnescapePathValues bool
 
@@ -197,7 +197,6 @@ var _ IRouter = (*Engine)(nil)
 // - HandleMethodNotAllowed: false
 // - ForwardedByClientIP:    true
 // - UseRawPath:             false
-// - UseEscapedPath: 		 false
 // - UnescapePathValues:     true
 func New(opts ...OptionFunc) *Engine {
 	debugPrintWARNINGNew()
@@ -215,7 +214,6 @@ func New(opts ...OptionFunc) *Engine {
 		RemoteIPHeaders:        []string{"X-Forwarded-For", "X-Real-IP"},
 		TrustedPlatform:        defaultPlatform,
 		UseRawPath:             false,
-		UseEscapedPath:         false,
 		RemoveExtraSlash:       false,
 		UnescapePathValues:     true,
 		MaxMultipartMemory:     defaultMultipartMemory,
@@ -691,11 +689,7 @@ func (engine *Engine) handleHTTPRequest(c *Context) {
 	httpMethod := c.Request.Method
 	rPath := c.Request.URL.Path
 	unescape := false
-
-	if engine.UseEscapedPath {
-		rPath = c.Request.URL.EscapedPath()
-		unescape = engine.UnescapePathValues
-	} else if engine.UseRawPath && len(c.Request.URL.RawPath) > 0 {
+	if engine.UseRawPath && len(c.Request.URL.RawPath) > 0 {
 		rPath = c.Request.URL.RawPath
 		unescape = engine.UnescapePathValues
 	}
@@ -782,8 +776,8 @@ func redirectTrailingSlash(c *Context) {
 	req := c.Request
 	p := req.URL.Path
 	if prefix := path.Clean(c.Request.Header.Get("X-Forwarded-Prefix")); prefix != "." {
-		prefix = sanitizePathChars(prefix)
-		prefix = removeRepeatedChar(prefix, '/')
+		prefix = regSafePrefix.ReplaceAllString(prefix, "")
+		prefix = regRemoveRepeatedChar.ReplaceAllString(prefix, "/")
 
 		p = prefix + "/" + req.URL.Path
 	}
@@ -794,17 +788,6 @@ func redirectTrailingSlash(c *Context) {
 	redirectRequest(c)
 }
 
-// sanitizePathChars removes unsafe characters from path strings,
-// keeping only ASCII letters, ASCII numbers, forward slashes, and hyphens.
-func sanitizePathChars(s string) string {
-	return strings.Map(func(r rune) rune {
-		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '/' || r == '-' {
-			return r
-		}
-		return -1
-	}, s)
-}
-
 func redirectFixedPath(c *Context, root *node, trailingSlash bool) bool {
 	req := c.Request
 	rPath := req.URL.Path

ginS/gins_test.go

@@ -1,246 +0,0 @@
-// Copyright 2025 Gin Core Team. All rights reserved.
-// Use of this source code is governed by a MIT style
-// license that can be found in the LICENSE file.
-
-package ginS
-
-import (
-	"html/template"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/gin-gonic/gin"
-	"github.com/stretchr/testify/assert"
-)
-
-func init() {
-	gin.SetMode(gin.TestMode)
-}
-
-func TestGET(t *testing.T) {
-	GET("/test", func(c *gin.Context) {
-		c.String(http.StatusOK, "test")
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/test", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "test", w.Body.String())
-}
-
-func TestPOST(t *testing.T) {
-	POST("/post", func(c *gin.Context) {
-		c.String(http.StatusCreated, "created")
-	})
-
-	req := httptest.NewRequest(http.MethodPost, "/post", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusCreated, w.Code)
-	assert.Equal(t, "created", w.Body.String())
-}
-
-func TestPUT(t *testing.T) {
-	PUT("/put", func(c *gin.Context) {
-		c.String(http.StatusOK, "updated")
-	})
-
-	req := httptest.NewRequest(http.MethodPut, "/put", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "updated", w.Body.String())
-}
-
-func TestDELETE(t *testing.T) {
-	DELETE("/delete", func(c *gin.Context) {
-		c.String(http.StatusOK, "deleted")
-	})
-
-	req := httptest.NewRequest(http.MethodDelete, "/delete", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "deleted", w.Body.String())
-}
-
-func TestPATCH(t *testing.T) {
-	PATCH("/patch", func(c *gin.Context) {
-		c.String(http.StatusOK, "patched")
-	})
-
-	req := httptest.NewRequest(http.MethodPatch, "/patch", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "patched", w.Body.String())
-}
-
-func TestOPTIONS(t *testing.T) {
-	OPTIONS("/options", func(c *gin.Context) {
-		c.String(http.StatusOK, "options")
-	})
-
-	req := httptest.NewRequest(http.MethodOptions, "/options", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "options", w.Body.String())
-}
-
-func TestHEAD(t *testing.T) {
-	HEAD("/head", func(c *gin.Context) {
-		c.String(http.StatusOK, "head")
-	})
-
-	req := httptest.NewRequest(http.MethodHead, "/head", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-}
-
-func TestAny(t *testing.T) {
-	Any("/any", func(c *gin.Context) {
-		c.String(http.StatusOK, "any")
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/any", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "any", w.Body.String())
-}
-
-func TestHandle(t *testing.T) {
-	Handle(http.MethodGet, "/handle", func(c *gin.Context) {
-		c.String(http.StatusOK, "handle")
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/handle", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "handle", w.Body.String())
-}
-
-func TestGroup(t *testing.T) {
-	group := Group("/group")
-	group.GET("/test", func(c *gin.Context) {
-		c.String(http.StatusOK, "group test")
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/group/test", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "group test", w.Body.String())
-}
-
-func TestUse(t *testing.T) {
-	var middlewareExecuted bool
-	Use(func(c *gin.Context) {
-		middlewareExecuted = true
-		c.Next()
-	})
-
-	GET("/middleware-test", func(c *gin.Context) {
-		c.String(http.StatusOK, "ok")
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/middleware-test", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.True(t, middlewareExecuted)
-	assert.Equal(t, http.StatusOK, w.Code)
-}
-
-func TestNoRoute(t *testing.T) {
-	NoRoute(func(c *gin.Context) {
-		c.String(http.StatusNotFound, "custom 404")
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/nonexistent", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusNotFound, w.Code)
-	assert.Equal(t, "custom 404", w.Body.String())
-}
-
-func TestNoMethod(t *testing.T) {
-	NoMethod(func(c *gin.Context) {
-		c.String(http.StatusMethodNotAllowed, "method not allowed")
-	})
-
-	// This just verifies that NoMethod is callable
-	// Testing the actual behavior would require a separate engine instance
-	assert.NotNil(t, engine())
-}
-
-func TestRoutes(t *testing.T) {
-	GET("/routes-test", func(c *gin.Context) {})
-
-	routes := Routes()
-	assert.NotEmpty(t, routes)
-
-	found := false
-	for _, route := range routes {
-		if route.Path == "/routes-test" && route.Method == http.MethodGet {
-			found = true
-			break
-		}
-	}
-	assert.True(t, found)
-}
-
-func TestSetHTMLTemplate(t *testing.T) {
-	tmpl := template.Must(template.New("test").Parse("Hello {{.}}"))
-	SetHTMLTemplate(tmpl)
-
-	// Verify engine has template set
-	assert.NotNil(t, engine())
-}
-
-func TestStaticFile(t *testing.T) {
-	StaticFile("/static-file", "../testdata/test_file.txt")
-
-	req := httptest.NewRequest(http.MethodGet, "/static-file", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-}
-
-func TestStatic(t *testing.T) {
-	Static("/static-dir", "../testdata")
-
-	req := httptest.NewRequest(http.MethodGet, "/static-dir/test_file.txt", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-}
-
-func TestStaticFS(t *testing.T) {
-	fs := http.Dir("../testdata")
-	StaticFS("/static-fs", fs)
-
-	req := httptest.NewRequest(http.MethodGet, "/static-fs/test_file.txt", nil)
-	w := httptest.NewRecorder()
-	engine().ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-}

gin_integration_test.go

@@ -70,10 +70,9 @@ func TestRunEmpty(t *testing.T) {
 		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
 		assert.NoError(t, router.Run())
 	}()
-
-	// Wait for server to be ready with exponential backoff
-	err := waitForServerReady("http://localhost:8080/example", 10)
-	require.NoError(t, err, "server should start successfully")
+	// have to wait for the goroutine to start and run the server
+	// otherwise the main thread will complete
+	time.Sleep(5 * time.Millisecond)
 
 	require.Error(t, router.Run(":8080"))
 	testRequest(t, "http://localhost:8080/example")
@@ -214,10 +213,9 @@ func TestRunEmptyWithEnv(t *testing.T) {
 		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
 		assert.NoError(t, router.Run())
 	}()
-
-	// Wait for server to be ready with exponential backoff
-	err := waitForServerReady("http://localhost:3123/example", 10)
-	require.NoError(t, err, "server should start successfully")
+	// have to wait for the goroutine to start and run the server
+	// otherwise the main thread will complete
+	time.Sleep(5 * time.Millisecond)
 
 	require.Error(t, router.Run(":3123"))
 	testRequest(t, "http://localhost:3123/example")
@@ -236,10 +234,9 @@ func TestRunWithPort(t *testing.T) {
 		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
 		assert.NoError(t, router.Run(":5150"))
 	}()
-
-	// Wait for server to be ready with exponential backoff
-	err := waitForServerReady("http://localhost:5150/example", 10)
-	require.NoError(t, err, "server should start successfully")
+	// have to wait for the goroutine to start and run the server
+	// otherwise the main thread will complete
+	time.Sleep(5 * time.Millisecond)
 
 	require.Error(t, router.Run(":5150"))
 	testRequest(t, "http://localhost:5150/example")

gin_test.go

@@ -545,29 +545,6 @@ func TestNoMethodWithoutGlobalHandlers(t *testing.T) {
 }
 
 func TestRebuild404Handlers(t *testing.T) {
-	var middleware0 HandlerFunc = func(c *Context) {}
-	var middleware1 HandlerFunc = func(c *Context) {}
-
-	router := New()
-
-	// Initially, allNoRoute should be nil
-	assert.Nil(t, router.allNoRoute)
-
-	// Set NoRoute handlers
-	router.NoRoute(middleware0)
-	assert.Len(t, router.allNoRoute, 1)
-	assert.Len(t, router.noRoute, 1)
-	compareFunc(t, router.allNoRoute[0], middleware0)
-
-	// Add Use middleware should trigger rebuild404Handlers
-	router.Use(middleware1)
-	assert.Len(t, router.allNoRoute, 2)
-	assert.Len(t, router.Handlers, 1)
-	assert.Len(t, router.noRoute, 1)
-
-	// Global middleware should come first
-	compareFunc(t, router.allNoRoute[0], middleware1)
-	compareFunc(t, router.allNoRoute[1], middleware0)
 }
 
 func TestNoMethodWithGlobalHandlers(t *testing.T) {
@@ -743,55 +720,6 @@ func TestEngineHandleContextPreventsMiddlewareReEntry(t *testing.T) {
 	assert.Equal(t, int64(1), handlerCounterV2)
 }
 
-func TestEngineHandleContextUseEscapedPathPercentEncoded(t *testing.T) {
-	r := New()
-	r.UseEscapedPath = true
-	r.UnescapePathValues = false
-
-	r.GET("/v1/:path", func(c *Context) {
-		// Path is Escaped, the %25 is not interpreted as %
-		assert.Equal(t, "foo%252Fbar", c.Param("path"))
-		c.Status(http.StatusOK)
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/v1/foo%252Fbar", nil)
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-}
-
-func TestEngineHandleContextUseRawPathPercentEncoded(t *testing.T) {
-	r := New()
-	r.UseRawPath = true
-	r.UnescapePathValues = false
-
-	r.GET("/v1/:path", func(c *Context) {
-		// Path is used, the %25 is interpreted as %
-		assert.Equal(t, "foo%2Fbar", c.Param("path"))
-		c.Status(http.StatusOK)
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/v1/foo%252Fbar", nil)
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-}
-
-func TestEngineHandleContextUseEscapedPathOverride(t *testing.T) {
-	r := New()
-	r.UseEscapedPath = true
-	r.UseRawPath = true
-	r.UnescapePathValues = false
-
-	r.GET("/v1/:path", func(c *Context) {
-		assert.Equal(t, "foo%25bar", c.Param("path"))
-		c.Status(http.StatusOK)
-	})
-
-	assert.NotPanics(t, func() {
-		w := PerformRequest(r, http.MethodGet, "/v1/foo%25bar")
-		assert.Equal(t, 200, w.Code)
-	})
-}
-
 func TestPrepareTrustedCIRDsWith(t *testing.T) {
 	r := New()
 

go.mod

@@ -12,7 +12,7 @@ require (
 	github.com/mattn/go-isatty v0.0.20
 	github.com/modern-go/reflect2 v1.0.2
 	github.com/pelletier/go-toml/v2 v2.2.4
-	github.com/quic-go/quic-go v0.57.1
+	github.com/quic-go/quic-go v0.56.0
 	github.com/stretchr/testify v1.11.1
 	github.com/ugorji/go/codec v1.3.1
 	golang.org/x/net v0.47.0
@@ -32,7 +32,7 @@ require (
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/quic-go/qpack v0.6.0 // indirect
+	github.com/quic-go/qpack v0.5.1 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	golang.org/x/arch v0.20.0 // indirect
 	golang.org/x/crypto v0.45.0 // indirect

go.sum

@@ -49,10 +49,10 @@ github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0
 github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
-github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
-github.com/quic-go/quic-go v0.57.1 h1:25KAAR9QR8KZrCZRThWMKVAwGoiHIrNbT72ULHTuI10=
-github.com/quic-go/quic-go v0.57.1/go.mod h1:ly4QBAjHA2VhdnxhojRsCUOeJwKYg+taDlos92xb1+s=
+github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
+github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
+github.com/quic-go/quic-go v0.56.0 h1:q/TW+OLismmXAehgFLczhCDTYB3bFmua4D9lsNBWxvY=
+github.com/quic-go/quic-go v0.56.0/go.mod h1:9gx5KsFQtw2oZ6GZTyh+7YEvOxWCL9WZAepnHxgAo6c=
 github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

internal/bytesconv/bytesconv_test.go

@@ -41,15 +41,6 @@ func TestBytesToString(t *testing.T) {
 	}
 }
 
-func TestBytesToStringEmpty(t *testing.T) {
-	if got := BytesToString([]byte{}); got != "" {
-		t.Fatalf("BytesToString([]byte{}) = %q; want empty string", got)
-	}
-	if got := BytesToString(nil); got != "" {
-		t.Fatalf("BytesToString(nil) = %q; want empty string", got)
-	}
-}
-
 const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 const (
 	letterIdxBits = 6                    // 6 bits to represent a letter index
@@ -87,16 +78,6 @@ func TestStringToBytes(t *testing.T) {
 	}
 }
 
-func TestStringToBytesEmpty(t *testing.T) {
-	b := StringToBytes("")
-	if len(b) != 0 {
-		t.Fatalf(`StringToBytes("") length = %d; want 0`, len(b))
-	}
-	if !bytes.Equal(b, []byte("")) {
-		t.Fatalf(`StringToBytes("") = %v; want []byte("")`, b)
-	}
-}
-
 // go test -v -run=none -bench=^BenchmarkBytesConv -benchmem=true
 
 func BenchmarkBytesConvBytesToStrRaw(b *testing.B) {

path.go

@@ -5,8 +5,6 @@
 
 package gin
 
-const stackBufSize = 128
-
 // cleanPath is the URL version of path.Clean, it returns a canonical URL path
 // for p, eliminating . and .. elements.
 //
@@ -21,6 +19,7 @@ const stackBufSize = 128
 //
 // If the result of this process is an empty string, "/" is returned.
 func cleanPath(p string) string {
+	const stackBufSize = 128
 	// Turn empty string into "/"
 	if p == "" {
 		return "/"
@@ -149,55 +148,3 @@ func bufApp(buf *[]byte, s string, w int, c byte) {
 	}
 	b[w] = c
 }
-
-// removeRepeatedChar removes multiple consecutive 'char's from a string.
-// if s == "/a//b///c////" && char == '/', it returns "/a/b/c/"
-func removeRepeatedChar(s string, char byte) string {
-	// Check if there are any consecutive chars
-	hasRepeatedChar := false
-	for i := 1; i < len(s); i++ {
-		if s[i] == char && s[i-1] == char {
-			hasRepeatedChar = true
-			break
-		}
-	}
-	if !hasRepeatedChar {
-		return s
-	}
-
-	// Reasonably sized buffer on stack to avoid allocations in the common case.
-	buf := make([]byte, 0, stackBufSize)
-
-	// Invariants:
-	//      reading from s; r is index of next byte to process.
-	//      writing to buf; w is index of next byte to write.
-	r := 0
-	w := 0
-
-	for n := len(s); r < n; {
-		if s[r] == char {
-			// Write the first char
-			bufApp(&buf, s, w, char)
-			w++
-			r++
-
-			// Skip all consecutive chars
-			for r < n && s[r] == char {
-				r++
-			}
-		} else {
-			// Copy non-char character
-			bufApp(&buf, s, w, s[r])
-			w++
-			r++
-		}
-	}
-
-	// If the original string was not modified (or only shortened at the end),
-	// return the respective substring of the original string.
-	// Otherwise, return a new string from the buffer.
-	if len(buf) == 0 {
-		return s[:w]
-	}
-	return string(buf[:w])
-}

path_test.go

@@ -143,50 +143,3 @@ func BenchmarkPathCleanLong(b *testing.B) {
 		}
 	}
 }
-
-func TestRemoveRepeatedChar(t *testing.T) {
-	testCases := []struct {
-		name string
-		str  string
-		char byte
-		want string
-	}{
-		{
-			name: "empty",
-			str:  "",
-			char: 'a',
-			want: "",
-		},
-		{
-			name: "noSlash",
-			str:  "abc",
-			char: ',',
-			want: "abc",
-		},
-		{
-			name: "withSlash",
-			str:  "/a/b/c/",
-			char: '/',
-			want: "/a/b/c/",
-		},
-		{
-			name: "withRepeatedSlashes",
-			str:  "/a//b///c////",
-			char: '/',
-			want: "/a/b/c/",
-		},
-		{
-			name: "threeSlashes",
-			str:  "///",
-			char: '/',
-			want: "/",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			res := removeRepeatedChar(tc.str, tc.char)
-			assert.Equal(t, tc.want, res)
-		})
-	}
-}

recovery.go

@@ -68,9 +68,6 @@ func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc {
 						}
 					}
 				}
-				if e, ok := err.(error); ok && errors.Is(e, http.ErrAbortHandler) {
-					brokenPipe = true
-				}
 				if logger != nil {
 					const stackSkip = 3
 					if brokenPipe {

recovery_test.go

@@ -142,30 +142,6 @@ func TestPanicWithBrokenPipe(t *testing.T) {
 	}
 }
 
-// TestPanicWithAbortHandler asserts that recovery handles http.ErrAbortHandler as broken pipe
-func TestPanicWithAbortHandler(t *testing.T) {
-	const expectCode = 204
-
-	var buf strings.Builder
-	router := New()
-	router.Use(RecoveryWithWriter(&buf))
-	router.GET("/recovery", func(c *Context) {
-		// Start writing response
-		c.Header("X-Test", "Value")
-		c.Status(expectCode)
-
-		// Panic with ErrAbortHandler which should be treated as broken pipe
-		panic(http.ErrAbortHandler)
-	})
-	// RUN
-	w := PerformRequest(router, http.MethodGet, "/recovery")
-	// TEST
-	assert.Equal(t, expectCode, w.Code)
-	out := buf.String()
-	assert.Contains(t, out, "net/http: abort Handler")
-	assert.NotContains(t, out, "panic recovered")
-}
-
 func TestCustomRecoveryWithWriter(t *testing.T) {
 	errBuffer := new(strings.Builder)
 	buffer := new(strings.Builder)

test_helpers.go

@@ -4,11 +4,7 @@
 
 package gin
 
-import (
-	"fmt"
-	"net/http"
-	"time"
-)
+import "net/http"
 
 // CreateTestContext returns a fresh Engine and a Context associated with it.
 // This is useful for tests that need to set up a new Gin engine instance
@@ -33,28 +29,3 @@ func CreateTestContextOnly(w http.ResponseWriter, r *Engine) (c *Context) {
 	c.writermem.reset(w)
 	return
 }
-
-// waitForServerReady waits for a server to be ready by making HTTP requests
-// with exponential backoff. This is more reliable than time.Sleep() for testing.
-func waitForServerReady(url string, maxAttempts int) error {
-	client := &http.Client{
-		Timeout: 100 * time.Millisecond,
-	}
-
-	for i := 0; i < maxAttempts; i++ {
-		resp, err := client.Get(url)
-		if err == nil {
-			resp.Body.Close()
-			return nil
-		}
-
-		// Exponential backoff: 10ms, 20ms, 40ms, 80ms, 160ms...
-		backoff := time.Duration(10*(1<<uint(i))) * time.Millisecond
-		if backoff > 500*time.Millisecond {
-			backoff = 500 * time.Millisecond
-		}
-		time.Sleep(backoff)
-	}
-
-	return fmt.Errorf("server at %s did not become ready after %d attempts", url, maxAttempts)
-}