// panics with http.TimeoutHandler (timeoutWriter is not http.Hijacker)
return w.ResponseWriter.(http.Hijacker).Hijack()

// panics with http.TimeoutHandler (timeoutWriter is not http.CloseNotifier)
return w.ResponseWriter.(http.CloseNotifier).CloseNotify()

  package main                                                                                                                                                                                
                                                                   
  import (                                                                                                                                                                                    
      "net/http"                                                                   
      "net/http/httptest"                                                                                                                                                                     
      "time"
      "testing"                                                                                                                                                                               
                                                                                   
      "github.com/gin-gonic/gin"         
  )                                                         
                                                          
  func TestTimeoutHandlerHijackPanic(t *testing.T) {               
      r := gin.New()                  
      r.GET("/ws", func(c *gin.Context) {
          // Any handler that attempts to hijack the connection (e.g. WebSocket upgrade)                                                                                                      
          _, _, err := c.Writer.Hijack()                    
          if err != nil {                                                                                                                                                                     
              c.String(http.StatusInternalServerError, err.Error())                
          }                                                        
      })                                                    
                                                                                                                                                                                              
      // Wrapping with http.TimeoutHandler is common for adding global request timeouts.                                                                                                      
      // timeoutWriter (internal to net/http) does NOT implement http.Hijacker.                                                                                                               
      handler := http.TimeoutHandler(r, 5*time.Second, "timeout")                                                                                                                             
                                                                                                                                                                                              
      req := httptest.NewRequest(http.MethodGet, "/ws", nil)
      w := httptest.NewRecorder()                                                                                                                                                             
                                                                                                                                                                                              
      // Panics: interface conversion: *http.timeoutWriter is not http.Hijacker
      handler.ServeHTTP(w, req)                                                                                                                                                               
  }