test(router): fix test to exercise parent-walk code path

The previous test registered RouteNotFound("/*") which creates an
anyKind wildcard node at the root. The router's normal backtracking
algorithm already finds that node without the parent-walk fix, so the
tests passed on unpatched v5.0.4.

The real scenario that requires the fix is when RouteNotFound is
registered on an exact prefix (no wildcard suffix) — e.g.,
e.RouteNotFound("/api", ...) or g.RouteNotFound("", ...). In that
case there is no anyKind child to backtrack into, and the router must
walk the parent chain of the matched node to discover the handler.

Updated test cases:
- Use e.RouteNotFound("/api") and g.RouteNotFound("") instead of "/*"
- Removed unused 'expectCode' field from test struct
- Improved comments to explain why the wildcard variant is insufficient
- All four scenarios (root handler, group handler, param route, fallback)
  are retained

Signed-off-by: lyydsheep <2230561977@qq.com>

Author: lyydsheep

router_test.go

@@ -3624,42 +3624,56 @@ func TestPathValues_GetOr(t *testing.T) {
 // TestRouterRouteNotFoundHandlerInGroup verifies that a RouteNotFound handler registered
 // at a parent (root or group) level is properly invoked for sub-paths when the route exists
 // but the HTTP method is not registered. This is the scenario described in issue #2485.
+//
+// The critical test cases use exact-prefix RouteNotFound registrations (not wildcard "/*")
+// to exercise the parent-node walking fix. A RouteNotFound("/*") would create an anyKind
+// node that the router already finds via normal backtracking even without the fix; the bug
+// only manifests when the RouteNotFound is registered on an exact path or group prefix
+// (no anyKind child), so the router must walk the parent chain to find it.
 func TestRouterRouteNotFoundHandlerInGroup(t *testing.T) {
 	var testCases = []struct {
-		name              string
-		whenMethod        string
-		whenURL           string
-		expectHandlerID   string
-		expectCode        int
-		registerRootNotFound bool
+		name                  string
+		whenMethod            string
+		whenURL               string
+		expectHandlerID       string
+		registerRootNotFound  bool
 		registerGroupNotFound bool
 	}{
 		{
-			name:                 "root RouteNotFound handler fires for group sub-path with wrong method",
-			whenMethod:           http.MethodPost,
-			whenURL:              "/api/users",
-			expectHandlerID:      "root-not-found",
+			// Root registers RouteNotFound on "/api" (exact prefix, no wildcard).
+			// Without the parent-walk fix the router falls back to methodNotAllowedHandler
+			// because the anyKind /* node does not exist and no backtracking reaches the
+			// root RouteNotFound. With the fix, the parent chain is walked from /api/users
+			// up to /api and the handler is found.
+			name:                "root RouteNotFound on exact prefix fires for group sub-path with wrong method",
+			whenMethod:          http.MethodPost,
+			whenURL:             "/api/users",
+			expectHandlerID:     "root-not-found",
 			registerRootNotFound: true,
 		},
 		{
-			name:                  "group RouteNotFound handler fires for group sub-path with wrong method",
+			// Group registers its own RouteNotFound on "/api" (exact prefix, no wildcard).
+			// Same reasoning: parent-walk is required to find the handler.
+			name:                  "group RouteNotFound on exact prefix fires for group sub-path with wrong method",
 			whenMethod:            http.MethodPost,
 			whenURL:               "/api/users",
 			expectHandlerID:       "group-not-found",
 			registerGroupNotFound: true,
 		},
 		{
-			name:                 "root RouteNotFound fires when no group-level handler defined",
-			whenMethod:           http.MethodDelete,
-			whenURL:              "/api/items/123",
-			expectHandlerID:      "root-not-found",
+			// Root registers RouteNotFound on "/api" (exact prefix).
+			// Wrong method on a param route inside the group still triggers the handler.
+			name:                "root RouteNotFound fires for param sub-route with wrong method",
+			whenMethod:          http.MethodDelete,
+			whenURL:             "/api/items/123",
+			expectHandlerID:     "root-not-found",
 			registerRootNotFound: true,
 		},
 		{
-			name:       "fallback to methodNotAllowed when no RouteNotFound handler defined",
-			whenMethod: http.MethodPost,
-			whenURL:    "/api/users",
-			// no RouteNotFound registered → method not allowed
+			// No RouteNotFound registered anywhere → standard 405 methodNotAllowedHandler.
+			name:            "fallback to methodNotAllowed when no RouteNotFound handler defined",
+			whenMethod:      http.MethodPost,
+			whenURL:         "/api/users",
 			expectHandlerID: "method-not-allowed",
 		},
 	}
@@ -3669,7 +3683,7 @@ func TestRouterRouteNotFoundHandlerInGroup(t *testing.T) {
 			e := New()
 			handlerID := ""
 
-			// Register a GET route inside a group
+			// Register GET routes inside the /api group.
 			g := e.Group("/api")
 			g.GET("/users", func(c *Context) error {
 				handlerID = "users-get"
@@ -3680,17 +3694,19 @@ func TestRouterRouteNotFoundHandlerInGroup(t *testing.T) {
 				return nil
 			})
 
-			// Optionally register RouteNotFound at root level
+			// Register RouteNotFound on the exact group prefix "/api" (no trailing wildcard).
+			// This means the only way the router can find this handler when a sub-path is
+			// requested is by walking up the parent node tree — the scenario this fix covers.
 			if tc.registerRootNotFound {
-				e.RouteNotFound("/*", func(c *Context) error {
+				// Root-level handler registered on the group prefix path, not on "/*".
+				e.RouteNotFound("/api", func(c *Context) error {
 					handlerID = "root-not-found"
 					return nil
 				})
 			}
-
-			// Optionally register RouteNotFound at group level
 			if tc.registerGroupNotFound {
-				g.RouteNotFound("/*", func(c *Context) error {
+				// Group-level handler using the group's own prefix (no wildcard suffix).
+				g.RouteNotFound("", func(c *Context) error {
 					handlerID = "group-not-found"
 					return nil
 				})