zhaoshichen
5 years ago
parent
a08e0f7715
commit
b9bc3f1b33
@ -0,0 +1,8 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<module type="WEB_MODULE" version="4"> |
||||
<component name="NewModuleRootManager"> |
||||
<content url="file://$MODULE_DIR$" /> |
||||
<orderEntry type="inheritedJdk" /> |
||||
<orderEntry type="sourceFolder" forTests="false" /> |
||||
</component> |
||||
</module> |
||||
@ -0,0 +1,6 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<project version="4"> |
||||
<component name="JavaScriptSettings"> |
||||
<option name="languageLevel" value="ES6" /> |
||||
</component> |
||||
</project> |
||||
@ -0,0 +1,8 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<project version="4"> |
||||
<component name="ProjectModuleManager"> |
||||
<modules> |
||||
<module fileurl="file://$PROJECT_DIR$/.idea/kratos.iml" filepath="$PROJECT_DIR$/.idea/kratos.iml" /> |
||||
</modules> |
||||
</component> |
||||
</project> |
||||
@ -0,0 +1,6 @@ |
||||
<?xml version="1.0" encoding="UTF-8"?> |
||||
<project version="4"> |
||||
<component name="VcsDirectoryMappings"> |
||||
<mapping directory="$PROJECT_DIR$" vcs="Git" /> |
||||
</component> |
||||
</project> |
||||
@ -0,0 +1,627 @@ |
||||
// Copyright 2013 Julien Schmidt. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be found
|
||||
// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE
|
||||
|
||||
package blademaster |
||||
|
||||
import ( |
||||
"net/url" |
||||
"strings" |
||||
"unicode" |
||||
) |
||||
|
||||
// Param is a single URL parameter, consisting of a key and a value.
|
||||
type Param struct { |
||||
Key string |
||||
Value string |
||||
} |
||||
|
||||
// Params is a Param-slice, as returned by the router.
|
||||
// The slice is ordered, the first URL parameter is also the first slice value.
|
||||
// It is therefore safe to read values by the index.
|
||||
type Params []Param |
||||
|
||||
// Get returns the value of the first Param which key matches the given name.
|
||||
// If no matching Param is found, an empty string is returned.
|
||||
func (ps Params) Get(name string) (string, bool) { |
||||
for _, entry := range ps { |
||||
if entry.Key == name { |
||||
return entry.Value, true |
||||
} |
||||
} |
||||
return "", false |
||||
} |
||||
|
||||
// ByName returns the value of the first Param which key matches the given name.
|
||||
// If no matching Param is found, an empty string is returned.
|
||||
func (ps Params) ByName(name string) (va string) { |
||||
va, _ = ps.Get(name) |
||||
return |
||||
} |
||||
|
||||
type methodTree struct { |
||||
method string |
||||
root *node |
||||
} |
||||
|
||||
type methodTrees []methodTree |
||||
|
||||
func (trees methodTrees) get(method string) *node { |
||||
for _, tree := range trees { |
||||
if tree.method == method { |
||||
return tree.root |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func min(a, b int) int { |
||||
if a <= b { |
||||
return a |
||||
} |
||||
return b |
||||
} |
||||
|
||||
func countParams(path string) uint8 { |
||||
var n uint |
||||
for i := 0; i < len(path); i++ { |
||||
if path[i] != ':' && path[i] != '*' { |
||||
continue |
||||
} |
||||
n++ |
||||
} |
||||
if n >= 255 { |
||||
return 255 |
||||
} |
||||
return uint8(n) |
||||
} |
||||
|
||||
type nodeType uint8 |
||||
|
||||
const ( |
||||
static nodeType = iota // default
|
||||
root |
||||
param |
||||
catchAll |
||||
) |
||||
|
||||
type node struct { |
||||
path string |
||||
indices string |
||||
children []*node |
||||
handlers []HandlerFunc |
||||
priority uint32 |
||||
nType nodeType |
||||
maxParams uint8 |
||||
wildChild bool |
||||
} |
||||
|
||||
// increments priority of the given child and reorders if necessary.
|
||||
func (n *node) incrementChildPrio(pos int) int { |
||||
n.children[pos].priority++ |
||||
prio := n.children[pos].priority |
||||
|
||||
// adjust position (move to front)
|
||||
newPos := pos |
||||
for newPos > 0 && n.children[newPos-1].priority < prio { |
||||
// swap node positions
|
||||
n.children[newPos-1], n.children[newPos] = n.children[newPos], n.children[newPos-1] |
||||
|
||||
newPos-- |
||||
} |
||||
|
||||
// build new index char string
|
||||
if newPos != pos { |
||||
n.indices = n.indices[:newPos] + // unchanged prefix, might be empty
|
||||
n.indices[pos:pos+1] + // the index char we move
|
||||
n.indices[newPos:pos] + n.indices[pos+1:] // rest without char at 'pos'
|
||||
} |
||||
|
||||
return newPos |
||||
} |
||||
|
||||
// addRoute adds a node with the given handle to the path.
|
||||
// Not concurrency-safe!
|
||||
func (n *node) addRoute(path string, handlers []HandlerFunc) { |
||||
fullPath := path |
||||
n.priority++ |
||||
numParams := countParams(path) |
||||
|
||||
// non-empty tree
|
||||
if len(n.path) > 0 || len(n.children) > 0 { |
||||
walk: |
||||
for { |
||||
// Update maxParams of the current node
|
||||
if numParams > n.maxParams { |
||||
n.maxParams = numParams |
||||
} |
||||
|
||||
// Find the longest common prefix.
|
||||
// This also implies that the common prefix contains no ':' or '*'
|
||||
// since the existing key can't contain those chars.
|
||||
i := 0 |
||||
max := min(len(path), len(n.path)) |
||||
for i < max && path[i] == n.path[i] { |
||||
i++ |
||||
} |
||||
|
||||
// Split edge
|
||||
if i < len(n.path) { |
||||
child := node{ |
||||
path: n.path[i:], |
||||
wildChild: n.wildChild, |
||||
indices: n.indices, |
||||
children: n.children, |
||||
handlers: n.handlers, |
||||
priority: n.priority - 1, |
||||
} |
||||
|
||||
// Update maxParams (max of all children)
|
||||
for i := range child.children { |
||||
if child.children[i].maxParams > child.maxParams { |
||||
child.maxParams = child.children[i].maxParams |
||||
} |
||||
} |
||||
|
||||
n.children = []*node{&child} |
||||
// []byte for proper unicode char conversion, see #65
|
||||
n.indices = string([]byte{n.path[i]}) |
||||
n.path = path[:i] |
||||
n.handlers = nil |
||||
n.wildChild = false |
||||
} |
||||
|
||||
// Make new node a child of this node
|
||||
if i < len(path) { |
||||
path = path[i:] |
||||
|
||||
if n.wildChild { |
||||
n = n.children[0] |
||||
n.priority++ |
||||
|
||||
// Update maxParams of the child node
|
||||
if numParams > n.maxParams { |
||||
n.maxParams = numParams |
||||
} |
||||
numParams-- |
||||
|
||||
// Check if the wildcard matches
|
||||
if len(path) >= len(n.path) && n.path == path[:len(n.path)] { |
||||
// check for longer wildcard, e.g. :name and :names
|
||||
if len(n.path) >= len(path) || path[len(n.path)] == '/' { |
||||
continue walk |
||||
} |
||||
} |
||||
|
||||
pathSeg := path |
||||
if n.nType != catchAll { |
||||
pathSeg = strings.SplitN(path, "/", 2)[0] |
||||
} |
||||
prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path |
||||
panic("'" + pathSeg + |
||||
"' in new path '" + fullPath + |
||||
"' conflicts with existing wildcard '" + n.path + |
||||
"' in existing prefix '" + prefix + |
||||
"'") |
||||
} |
||||
|
||||
c := path[0] |
||||
|
||||
// slash after param
|
||||
if n.nType == param && c == '/' && len(n.children) == 1 { |
||||
n = n.children[0] |
||||
n.priority++ |
||||
continue walk |
||||
} |
||||
|
||||
// Check if a child with the next path byte exists
|
||||
for i := 0; i < len(n.indices); i++ { |
||||
if c == n.indices[i] { |
||||
i = n.incrementChildPrio(i) |
||||
n = n.children[i] |
||||
continue walk |
||||
} |
||||
} |
||||
|
||||
// Otherwise insert it
|
||||
if c != ':' && c != '*' { |
||||
// []byte for proper unicode char conversion, see #65
|
||||
n.indices += string([]byte{c}) |
||||
child := &node{ |
||||
maxParams: numParams, |
||||
} |
||||
n.children = append(n.children, child) |
||||
n.incrementChildPrio(len(n.indices) - 1) |
||||
n = child |
||||
} |
||||
n.insertChild(numParams, path, fullPath, handlers) |
||||
return |
||||
|
||||
} else if i == len(path) { // Make node a (in-path) leaf
|
||||
if n.handlers != nil { |
||||
panic("handlers are already registered for path '" + fullPath + "'") |
||||
} |
||||
n.handlers = handlers |
||||
} |
||||
return |
||||
} |
||||
} else { // Empty tree
|
||||
n.insertChild(numParams, path, fullPath, handlers) |
||||
n.nType = root |
||||
} |
||||
} |
||||
|
||||
func (n *node) insertChild(numParams uint8, path string, fullPath string, handlers []HandlerFunc) { |
||||
var offset int // already handled bytes of the path
|
||||
|
||||
// find prefix until first wildcard (beginning with ':' or '*')
|
||||
for i, max := 0, len(path); numParams > 0; i++ { |
||||
c := path[i] |
||||
if c != ':' && c != '*' { |
||||
continue |
||||
} |
||||
|
||||
// find wildcard end (either '/' or path end)
|
||||
end := i + 1 |
||||
for end < max && path[end] != '/' { |
||||
switch path[end] { |
||||
// the wildcard name must not contain ':' and '*'
|
||||
case ':', '*': |
||||
panic("only one wildcard per path segment is allowed, has: '" + |
||||
path[i:] + "' in path '" + fullPath + "'") |
||||
default: |
||||
end++ |
||||
} |
||||
} |
||||
|
||||
// check if this Node existing children which would be
|
||||
// unreachable if we insert the wildcard here
|
||||
if len(n.children) > 0 { |
||||
panic("wildcard route '" + path[i:end] + |
||||
"' conflicts with existing children in path '" + fullPath + "'") |
||||
} |
||||
|
||||
// check if the wildcard has a name
|
||||
if end-i < 2 { |
||||
panic("wildcards must be named with a non-empty name in path '" + fullPath + "'") |
||||
} |
||||
|
||||
if c == ':' { // param
|
||||
// split path at the beginning of the wildcard
|
||||
if i > 0 { |
||||
n.path = path[offset:i] |
||||
offset = i |
||||
} |
||||
|
||||
child := &node{ |
||||
nType: param, |
||||
maxParams: numParams, |
||||
} |
||||
n.children = []*node{child} |
||||
n.wildChild = true |
||||
n = child |
||||
n.priority++ |
||||
numParams-- |
||||
|
||||
// if the path doesn't end with the wildcard, then there
|
||||
// will be another non-wildcard subpath starting with '/'
|
||||
if end < max { |
||||
n.path = path[offset:end] |
||||
offset = end |
||||
|
||||
child := &node{ |
||||
maxParams: numParams, |
||||
priority: 1, |
||||
} |
||||
n.children = []*node{child} |
||||
n = child |
||||
} |
||||
|
||||
} else { // catchAll
|
||||
if end != max || numParams > 1 { |
||||
panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'") |
||||
} |
||||
|
||||
if len(n.path) > 0 && n.path[len(n.path)-1] == '/' { |
||||
panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'") |
||||
} |
||||
|
||||
// currently fixed width 1 for '/'
|
||||
i-- |
||||
if path[i] != '/' { |
||||
panic("no / before catch-all in path '" + fullPath + "'") |
||||
} |
||||
|
||||
n.path = path[offset:i] |
||||
|
||||
// first node: catchAll node with empty path
|
||||
child := &node{ |
||||
wildChild: true, |
||||
nType: catchAll, |
||||
maxParams: 1, |
||||
} |
||||
n.children = []*node{child} |
||||
n.indices = string(path[i]) |
||||
n = child |
||||
n.priority++ |
||||
|
||||
// second node: node holding the variable
|
||||
child = &node{ |
||||
path: path[i:], |
||||
nType: catchAll, |
||||
maxParams: 1, |
||||
handlers: handlers, |
||||
priority: 1, |
||||
} |
||||
n.children = []*node{child} |
||||
|
||||
return |
||||
} |
||||
} |
||||
|
||||
// insert remaining path part and handle to the leaf
|
||||
n.path = path[offset:] |
||||
n.handlers = handlers |
||||
} |
||||
|
||||
// getValue returns the handle registered with the given path (key). The values of
|
||||
// wildcards are saved to a map.
|
||||
// If no handle can be found, a TSR (trailing slash redirect) recommendation is
|
||||
// made if a handle exists with an extra (without the) trailing slash for the
|
||||
// given path.
|
||||
func (n *node) getValue(path string, po Params, unescape bool) (handlers []HandlerFunc, p Params, tsr bool) { |
||||
p = po |
||||
walk: // Outer loop for walking the tree
|
||||
for { |
||||
if len(path) > len(n.path) { |
||||
if path[:len(n.path)] == n.path { |
||||
path = path[len(n.path):] |
||||
// If this node does not have a wildcard (param or catchAll)
|
||||
// child, we can just look up the next child node and continue
|
||||
// to walk down the tree
|
||||
if !n.wildChild { |
||||
c := path[0] |
||||
for i := 0; i < len(n.indices); i++ { |
||||
if c == n.indices[i] { |
||||
n = n.children[i] |
||||
continue walk |
||||
} |
||||
} |
||||
|
||||
// Nothing found.
|
||||
// We can recommend to redirect to the same URL without a
|
||||
// trailing slash if a leaf exists for that path.
|
||||
tsr = path == "/" && n.handlers != nil |
||||
return |
||||
} |
||||
|
||||
// handle wildcard child
|
||||
n = n.children[0] |
||||
switch n.nType { |
||||
case param: |
||||
// find param end (either '/' or path end)
|
||||
end := 0 |
||||
for end < len(path) && path[end] != '/' { |
||||
end++ |
||||
} |
||||
|
||||
// save param value
|
||||
if cap(p) < int(n.maxParams) { |
||||
p = make(Params, 0, n.maxParams) |
||||
} |
||||
i := len(p) |
||||
p = p[:i+1] // expand slice within preallocated capacity
|
||||
p[i].Key = n.path[1:] |
||||
val := path[:end] |
||||
if unescape { |
||||
var err error |
||||
if p[i].Value, err = url.QueryUnescape(val); err != nil { |
||||
p[i].Value = val // fallback, in case of error
|
||||
} |
||||
} else { |
||||
p[i].Value = val |
||||
} |
||||
|
||||
// we need to go deeper!
|
||||
if end < len(path) { |
||||
if len(n.children) > 0 { |
||||
path = path[end:] |
||||
n = n.children[0] |
||||
continue walk |
||||
} |
||||
|
||||
// ... but we can't
|
||||
tsr = len(path) == end+1 |
||||
return |
||||
} |
||||
|
||||
if handlers = n.handlers; handlers != nil { |
||||
return |
||||
} |
||||
if len(n.children) == 1 { |
||||
// No handle found. Check if a handle for this path + a
|
||||
// trailing slash exists for TSR recommendation
|
||||
n = n.children[0] |
||||
tsr = n.path == "/" && n.handlers != nil |
||||
} |
||||
|
||||
return |
||||
|
||||
case catchAll: |
||||
// save param value
|
||||
if cap(p) < int(n.maxParams) { |
||||
p = make(Params, 0, n.maxParams) |
||||
} |
||||
i := len(p) |
||||
p = p[:i+1] // expand slice within preallocated capacity
|
||||
p[i].Key = n.path[2:] |
||||
if unescape { |
||||
var err error |
||||
if p[i].Value, err = url.QueryUnescape(path); err != nil { |
||||
p[i].Value = path // fallback, in case of error
|
||||
} |
||||
} else { |
||||
p[i].Value = path |
||||
} |
||||
|
||||
handlers = n.handlers |
||||
return |
||||
|
||||
default: |
||||
panic("invalid node type") |
||||
} |
||||
} |
||||
} else if path == n.path { |
||||
// We should have reached the node containing the handle.
|
||||
// Check if this node has a handle registered.
|
||||
if handlers = n.handlers; handlers != nil { |
||||
return |
||||
} |
||||
|
||||
if path == "/" && n.wildChild && n.nType != root { |
||||
tsr = true |
||||
return |
||||
} |
||||
|
||||
// No handle found. Check if a handle for this path + a
|
||||
// trailing slash exists for trailing slash recommendation
|
||||
for i := 0; i < len(n.indices); i++ { |
||||
if n.indices[i] == '/' { |
||||
n = n.children[i] |
||||
tsr = (len(n.path) == 1 && n.handlers != nil) || |
||||
(n.nType == catchAll && n.children[0].handlers != nil) |
||||
return |
||||
} |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
// Nothing found. We can recommend to redirect to the same URL with an
|
||||
// extra trailing slash if a leaf exists for that path
|
||||
tsr = (path == "/") || |
||||
(len(n.path) == len(path)+1 && n.path[len(path)] == '/' && |
||||
path == n.path[:len(n.path)-1] && n.handlers != nil) |
||||
return |
||||
} |
||||
} |
||||
|
||||
// findCaseInsensitivePath makes a case-insensitive lookup of the given path and tries to find a handler.
|
||||
// It can optionally also fix trailing slashes.
|
||||
// It returns the case-corrected path and a bool indicating whether the lookup
|
||||
// was successful.
|
||||
func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) { |
||||
ciPath = make([]byte, 0, len(path)+1) // preallocate enough memory
|
||||
|
||||
// Outer loop for walking the tree
|
||||
for len(path) >= len(n.path) && strings.ToLower(path[:len(n.path)]) == strings.ToLower(n.path) { |
||||
path = path[len(n.path):] |
||||
ciPath = append(ciPath, n.path...) |
||||
|
||||
if len(path) > 0 { |
||||
// If this node does not have a wildcard (param or catchAll) child,
|
||||
// we can just look up the next child node and continue to walk down
|
||||
// the tree
|
||||
if !n.wildChild { |
||||
r := unicode.ToLower(rune(path[0])) |
||||
for i, index := range n.indices { |
||||
// must use recursive approach since both index and
|
||||
// ToLower(index) could exist. We must check both.
|
||||
if r == unicode.ToLower(index) { |
||||
out, found := n.children[i].findCaseInsensitivePath(path, fixTrailingSlash) |
||||
if found { |
||||
return append(ciPath, out...), true |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Nothing found. We can recommend to redirect to the same URL
|
||||
// without a trailing slash if a leaf exists for that path
|
||||
found = fixTrailingSlash && path == "/" && n.handlers != nil |
||||
return |
||||
} |
||||
|
||||
n = n.children[0] |
||||
switch n.nType { |
||||
case param: |
||||
// find param end (either '/' or path end)
|
||||
k := 0 |
||||
for k < len(path) && path[k] != '/' { |
||||
k++ |
||||
} |
||||
|
||||
// add param value to case insensitive path
|
||||
ciPath = append(ciPath, path[:k]...) |
||||
|
||||
// we need to go deeper!
|
||||
if k < len(path) { |
||||
if len(n.children) > 0 { |
||||
path = path[k:] |
||||
n = n.children[0] |
||||
continue |
||||
} |
||||
|
||||
// ... but we can't
|
||||
if fixTrailingSlash && len(path) == k+1 { |
||||
return ciPath, true |
||||
} |
||||
return |
||||
} |
||||
|
||||
if n.handlers != nil { |
||||
return ciPath, true |
||||
} else if fixTrailingSlash && len(n.children) == 1 { |
||||
// No handle found. Check if a handle for this path + a
|
||||
// trailing slash exists
|
||||
n = n.children[0] |
||||
if n.path == "/" && n.handlers != nil { |
||||
return append(ciPath, '/'), true |
||||
} |
||||
} |
||||
return |
||||
|
||||
case catchAll: |
||||
return append(ciPath, path...), true |
||||
|
||||
default: |
||||
panic("invalid node type") |
||||
} |
||||
} else { |
||||
// We should have reached the node containing the handle.
|
||||
// Check if this node has a handle registered.
|
||||
if n.handlers != nil { |
||||
return ciPath, true |
||||
} |
||||
|
||||
// No handle found.
|
||||
// Try to fix the path by adding a trailing slash
|
||||
if fixTrailingSlash { |
||||
for i := 0; i < len(n.indices); i++ { |
||||
if n.indices[i] == '/' { |
||||
n = n.children[i] |
||||
if (len(n.path) == 1 && n.handlers != nil) || |
||||
(n.nType == catchAll && n.children[0].handlers != nil) { |
||||
return append(ciPath, '/'), true |
||||
} |
||||
return |
||||
} |
||||
} |
||||
} |
||||
return |
||||
} |
||||
} |
||||
|
||||
// Nothing found.
|
||||
// Try to fix the path by adding / removing a trailing slash
|
||||
if fixTrailingSlash { |
||||
if path == "/" { |
||||
return ciPath, true |
||||
} |
||||
if len(path)+1 == len(n.path) && n.path[len(path)] == '/' && |
||||
strings.ToLower(path) == strings.ToLower(n.path[:len(path)]) && |
||||
n.handlers != nil { |
||||
return append(ciPath, n.path...), true |
||||
} |
||||
} |
||||
return |
||||
} |
||||
@ -0,0 +1,698 @@ |
||||
// Copyright 2013 Julien Schmidt. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be found
|
||||
// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE
|
||||
|
||||
package blademaster |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"regexp" |
||||
"strings" |
||||
"testing" |
||||
) |
||||
|
||||
// Used as a workaround since we can't compare functions or their addresses
|
||||
var fakeHandlerValue string |
||||
|
||||
func fakeHandler(val string) []HandlerFunc { |
||||
return []HandlerFunc{func(c *Context) { |
||||
fakeHandlerValue = val |
||||
}} |
||||
} |
||||
|
||||
type testRequests []struct { |
||||
path string |
||||
nilHandler bool |
||||
route string |
||||
ps Params |
||||
} |
||||
|
||||
func checkRequests(t *testing.T, tree *node, requests testRequests, unescapes ...bool) { |
||||
unescape := false |
||||
if len(unescapes) >= 1 { |
||||
unescape = unescapes[0] |
||||
} |
||||
|
||||
for _, request := range requests { |
||||
handler, ps, _ := tree.getValue(request.path, nil, unescape) |
||||
|
||||
if handler == nil { |
||||
if !request.nilHandler { |
||||
t.Errorf("handle mismatch for route '%s': Expected non-nil handle", request.path) |
||||
} |
||||
} else if request.nilHandler { |
||||
t.Errorf("handle mismatch for route '%s': Expected nil handle", request.path) |
||||
} else { |
||||
handler[0](nil) |
||||
if fakeHandlerValue != request.route { |
||||
t.Errorf("handle mismatch for route '%s': Wrong handle (%s != %s)", request.path, fakeHandlerValue, request.route) |
||||
} |
||||
} |
||||
|
||||
if !reflect.DeepEqual(ps, request.ps) { |
||||
t.Errorf("Params mismatch for route '%s'", request.path) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func checkPriorities(t *testing.T, n *node) uint32 { |
||||
var prio uint32 |
||||
for i := range n.children { |
||||
prio += checkPriorities(t, n.children[i]) |
||||
} |
||||
|
||||
if n.handlers != nil { |
||||
prio++ |
||||
} |
||||
|
||||
if n.priority != prio { |
||||
t.Errorf( |
||||
"priority mismatch for node '%s': is %d, should be %d", |
||||
n.path, n.priority, prio, |
||||
) |
||||
} |
||||
|
||||
return prio |
||||
} |
||||
|
||||
func checkMaxParams(t *testing.T, n *node) uint8 { |
||||
var maxParams uint8 |
||||
for i := range n.children { |
||||
params := checkMaxParams(t, n.children[i]) |
||||
if params > maxParams { |
||||
maxParams = params |
||||
} |
||||
} |
||||
if n.nType > root && !n.wildChild { |
||||
maxParams++ |
||||
} |
||||
|
||||
if n.maxParams != maxParams { |
||||
t.Errorf( |
||||
"maxParams mismatch for node '%s': is %d, should be %d", |
||||
n.path, n.maxParams, maxParams, |
||||
) |
||||
} |
||||
|
||||
return maxParams |
||||
} |
||||
|
||||
func TestCountParams(t *testing.T) { |
||||
if countParams("/path/:param1/static/*catch-all") != 2 { |
||||
t.Fail() |
||||
} |
||||
if countParams(strings.Repeat("/:param", 256)) != 255 { |
||||
t.Fail() |
||||
} |
||||
} |
||||
|
||||
func TestTreeAddAndGet(t *testing.T) { |
||||
tree := &node{} |
||||
|
||||
routes := [...]string{ |
||||
"/hi", |
||||
"/contact", |
||||
"/co", |
||||
"/c", |
||||
"/a", |
||||
"/ab", |
||||
"/doc/", |
||||
"/doc/go_faq.html", |
||||
"/doc/go1.html", |
||||
"/α", |
||||
"/β", |
||||
} |
||||
for _, route := range routes { |
||||
tree.addRoute(route, fakeHandler(route)) |
||||
} |
||||
|
||||
checkRequests(t, tree, testRequests{ |
||||
{"/a", false, "/a", nil}, |
||||
{"/", true, "", nil}, |
||||
{"/hi", false, "/hi", nil}, |
||||
{"/contact", false, "/contact", nil}, |
||||
{"/co", false, "/co", nil}, |
||||
{"/con", true, "", nil}, // key mismatch
|
||||
{"/cona", true, "", nil}, // key mismatch
|
||||
{"/no", true, "", nil}, // no matching child
|
||||
{"/ab", false, "/ab", nil}, |
||||
{"/α", false, "/α", nil}, |
||||
{"/β", false, "/β", nil}, |
||||
}) |
||||
|
||||
checkPriorities(t, tree) |
||||
checkMaxParams(t, tree) |
||||
} |
||||
|
||||
func TestTreeWildcard(t *testing.T) { |
||||
tree := &node{} |
||||
|
||||
routes := [...]string{ |
||||
"/", |
||||
"/cmd/:tool/:sub", |
||||
"/cmd/:tool/", |
||||
"/src/*filepath", |
||||
"/search/", |
||||
"/search/:query", |
||||
"/user_:name", |
||||
"/user_:name/about", |
||||
"/files/:dir/*filepath", |
||||
"/doc/", |
||||
"/doc/go_faq.html", |
||||
"/doc/go1.html", |
||||
"/info/:user/public", |
||||
"/info/:user/project/:project", |
||||
} |
||||
for _, route := range routes { |
||||
tree.addRoute(route, fakeHandler(route)) |
||||
} |
||||
|
||||
checkRequests(t, tree, testRequests{ |
||||
{"/", false, "/", nil}, |
||||
{"/cmd/test/", false, "/cmd/:tool/", Params{Param{Key: "tool", Value: "test"}}}, |
||||
{"/cmd/test", true, "", Params{Param{Key: "tool", Value: "test"}}}, |
||||
{"/cmd/test/3", false, "/cmd/:tool/:sub", Params{Param{Key: "tool", Value: "test"}, Param{Key: "sub", Value: "3"}}}, |
||||
{"/src/", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/"}}}, |
||||
{"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}}, |
||||
{"/search/", false, "/search/", nil}, |
||||
{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}}, |
||||
{"/search/someth!ng+in+ünìcodé/", true, "", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}}, |
||||
{"/user_gopher", false, "/user_:name", Params{Param{Key: "name", Value: "gopher"}}}, |
||||
{"/user_gopher/about", false, "/user_:name/about", Params{Param{Key: "name", Value: "gopher"}}}, |
||||
{"/files/js/inc/framework.js", false, "/files/:dir/*filepath", Params{Param{Key: "dir", Value: "js"}, Param{Key: "filepath", Value: "/inc/framework.js"}}}, |
||||
{"/info/gordon/public", false, "/info/:user/public", Params{Param{Key: "user", Value: "gordon"}}}, |
||||
{"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "gordon"}, Param{Key: "project", Value: "go"}}}, |
||||
}) |
||||
|
||||
checkPriorities(t, tree) |
||||
checkMaxParams(t, tree) |
||||
} |
||||
|
||||
func TestUnescapeParameters(t *testing.T) { |
||||
tree := &node{} |
||||
|
||||
routes := [...]string{ |
||||
"/", |
||||
"/cmd/:tool/:sub", |
||||
"/cmd/:tool/", |
||||
"/src/*filepath", |
||||
"/search/:query", |
||||
"/files/:dir/*filepath", |
||||
"/info/:user/project/:project", |
||||
"/info/:user", |
||||
} |
||||
for _, route := range routes { |
||||
tree.addRoute(route, fakeHandler(route)) |
||||
} |
||||
|
||||
unescape := true |
||||
checkRequests(t, tree, testRequests{ |
||||
{"/", false, "/", nil}, |
||||
{"/cmd/test/", false, "/cmd/:tool/", Params{Param{Key: "tool", Value: "test"}}}, |
||||
{"/cmd/test", true, "", Params{Param{Key: "tool", Value: "test"}}}, |
||||
{"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}}, |
||||
{"/src/some/file+test.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file test.png"}}}, |
||||
{"/src/some/file++++%%%%test.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file++++%%%%test.png"}}}, |
||||
{"/src/some/file%2Ftest.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file/test.png"}}}, |
||||
{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng in ünìcodé"}}}, |
||||
{"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "gordon"}, Param{Key: "project", Value: "go"}}}, |
||||
{"/info/slash%2Fgordon", false, "/info/:user", Params{Param{Key: "user", Value: "slash/gordon"}}}, |
||||
{"/info/slash%2Fgordon/project/Project%20%231", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "slash/gordon"}, Param{Key: "project", Value: "Project #1"}}}, |
||||
{"/info/slash%%%%", false, "/info/:user", Params{Param{Key: "user", Value: "slash%%%%"}}}, |
||||
{"/info/slash%%%%2Fgordon/project/Project%%%%20%231", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "slash%%%%2Fgordon"}, Param{Key: "project", Value: "Project%%%%20%231"}}}, |
||||
}, unescape) |
||||
|
||||
checkPriorities(t, tree) |
||||
checkMaxParams(t, tree) |
||||
} |
||||
|
||||
func catchPanic(testFunc func()) (recv interface{}) { |
||||
defer func() { |
||||
recv = recover() |
||||
}() |
||||
|
||||
testFunc() |
||||
return |
||||
} |
||||
|
||||
type testRoute struct { |
||||
path string |
||||
conflict bool |
||||
} |
||||
|
||||
func testRoutes(t *testing.T, routes []testRoute) { |
||||
tree := &node{} |
||||
|
||||
for _, route := range routes { |
||||
recv := catchPanic(func() { |
||||
tree.addRoute(route.path, nil) |
||||
}) |
||||
|
||||
if route.conflict { |
||||
if recv == nil { |
||||
t.Errorf("no panic for conflicting route '%s'", route.path) |
||||
} |
||||
} else if recv != nil { |
||||
t.Errorf("unexpected panic for route '%s': %v", route.path, recv) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestTreeWildcardConflict(t *testing.T) { |
||||
routes := []testRoute{ |
||||
{"/cmd/:tool/:sub", false}, |
||||
{"/cmd/vet", true}, |
||||
{"/src/*filepath", false}, |
||||
{"/src/*filepathx", true}, |
||||
{"/src/", true}, |
||||
{"/src1/", false}, |
||||
{"/src1/*filepath", true}, |
||||
{"/src2*filepath", true}, |
||||
{"/search/:query", false}, |
||||
{"/search/invalid", true}, |
||||
{"/user_:name", false}, |
||||
{"/user_x", true}, |
||||
{"/user_:name", false}, |
||||
{"/id:id", false}, |
||||
{"/id/:id", true}, |
||||
} |
||||
testRoutes(t, routes) |
||||
} |
||||
|
||||
func TestTreeChildConflict(t *testing.T) { |
||||
routes := []testRoute{ |
||||
{"/cmd/vet", false}, |
||||
{"/cmd/:tool/:sub", true}, |
||||
{"/src/AUTHORS", false}, |
||||
{"/src/*filepath", true}, |
||||
{"/user_x", false}, |
||||
{"/user_:name", true}, |
||||
{"/id/:id", false}, |
||||
{"/id:id", true}, |
||||
{"/:id", true}, |
||||
{"/*filepath", true}, |
||||
} |
||||
testRoutes(t, routes) |
||||
} |
||||
|
||||
func TestTreeDupliatePath(t *testing.T) { |
||||
tree := &node{} |
||||
|
||||
routes := [...]string{ |
||||
"/", |
||||
"/doc/", |
||||
"/src/*filepath", |
||||
"/search/:query", |
||||
"/user_:name", |
||||
} |
||||
for _, route := range routes { |
||||
recv := catchPanic(func() { |
||||
tree.addRoute(route, fakeHandler(route)) |
||||
}) |
||||
if recv != nil { |
||||
t.Fatalf("panic inserting route '%s': %v", route, recv) |
||||
} |
||||
|
||||
// Add again
|
||||
recv = catchPanic(func() { |
||||
tree.addRoute(route, nil) |
||||
}) |
||||
if recv == nil { |
||||
t.Fatalf("no panic while inserting duplicate route '%s", route) |
||||
} |
||||
} |
||||
|
||||
checkRequests(t, tree, testRequests{ |
||||
{"/", false, "/", nil}, |
||||
{"/doc/", false, "/doc/", nil}, |
||||
{"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}}, |
||||
{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}}, |
||||
{"/user_gopher", false, "/user_:name", Params{Param{Key: "name", Value: "gopher"}}}, |
||||
}) |
||||
} |
||||
|
||||
func TestEmptyWildcardName(t *testing.T) { |
||||
tree := &node{} |
||||
|
||||
routes := [...]string{ |
||||
"/user:", |
||||
"/user:/", |
||||
"/cmd/:/", |
||||
"/src/*", |
||||
} |
||||
for _, route := range routes { |
||||
recv := catchPanic(func() { |
||||
tree.addRoute(route, nil) |
||||
}) |
||||
if recv == nil { |
||||
t.Fatalf("no panic while inserting route with empty wildcard name '%s", route) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestTreeCatchAllConflict(t *testing.T) { |
||||
routes := []testRoute{ |
||||
{"/src/*filepath/x", true}, |
||||
{"/src2/", false}, |
||||
{"/src2/*filepath/x", true}, |
||||
} |
||||
testRoutes(t, routes) |
||||
} |
||||
|
||||
func TestTreeCatchAllConflictRoot(t *testing.T) { |
||||
routes := []testRoute{ |
||||
{"/", false}, |
||||
{"/*filepath", true}, |
||||
} |
||||
testRoutes(t, routes) |
||||
} |
||||
|
||||
func TestTreeDoubleWildcard(t *testing.T) { |
||||
const panicMsg = "only one wildcard per path segment is allowed" |
||||
|
||||
routes := [...]string{ |
||||
"/:foo:bar", |
||||
"/:foo:bar/", |
||||
"/:foo*bar", |
||||
} |
||||
|
||||
for _, route := range routes { |
||||
tree := &node{} |
||||
recv := catchPanic(func() { |
||||
tree.addRoute(route, nil) |
||||
}) |
||||
|
||||
if rs, ok := recv.(string); !ok || !strings.HasPrefix(rs, panicMsg) { |
||||
t.Fatalf(`"Expected panic "%s" for route '%s', got "%v"`, panicMsg, route, recv) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/*func TestTreeDuplicateWildcard(t *testing.T) { |
||||
tree := &node{} |
||||
routes := [...]string{ |
||||
"/:id/:name/:id", |
||||
} |
||||
for _, route := range routes { |
||||
... |
||||
} |
||||
}*/ |
||||
|
||||
func TestTreeTrailingSlashRedirect(t *testing.T) { |
||||
tree := &node{} |
||||
|
||||
routes := [...]string{ |
||||
"/hi", |
||||
"/b/", |
||||
"/search/:query", |
||||
"/cmd/:tool/", |
||||
"/src/*filepath", |
||||
"/x", |
||||
"/x/y", |
||||
"/y/", |
||||
"/y/z", |
||||
"/0/:id", |
||||
"/0/:id/1", |
||||
"/1/:id/", |
||||
"/1/:id/2", |
||||
"/aa", |
||||
"/a/", |
||||
"/admin", |
||||
"/admin/:category", |
||||
"/admin/:category/:page", |
||||
"/doc", |
||||
"/doc/go_faq.html", |
||||
"/doc/go1.html", |
||||
"/no/a", |
||||
"/no/b", |
||||
"/api/hello/:name", |
||||
} |
||||
for _, route := range routes { |
||||
recv := catchPanic(func() { |
||||
tree.addRoute(route, fakeHandler(route)) |
||||
}) |
||||
if recv != nil { |
||||
t.Fatalf("panic inserting route '%s': %v", route, recv) |
||||
} |
||||
} |
||||
|
||||
tsrRoutes := [...]string{ |
||||
"/hi/", |
||||
"/b", |
||||
"/search/gopher/", |
||||
"/cmd/vet", |
||||
"/src", |
||||
"/x/", |
||||
"/y", |
||||
"/0/go/", |
||||
"/1/go", |
||||
"/a", |
||||
"/admin/", |
||||
"/admin/config/", |
||||
"/admin/config/permissions/", |
||||
"/doc/", |
||||
} |
||||
for _, route := range tsrRoutes { |
||||
handler, _, tsr := tree.getValue(route, nil, false) |
||||
if handler != nil { |
||||
t.Fatalf("non-nil handler for TSR route '%s", route) |
||||
} else if !tsr { |
||||
t.Errorf("expected TSR recommendation for route '%s'", route) |
||||
} |
||||
} |
||||
|
||||
noTsrRoutes := [...]string{ |
||||
"/", |
||||
"/no", |
||||
"/no/", |
||||
"/_", |
||||
"/_/", |
||||
"/api/world/abc", |
||||
} |
||||
for _, route := range noTsrRoutes { |
||||
handler, _, tsr := tree.getValue(route, nil, false) |
||||
if handler != nil { |
||||
t.Fatalf("non-nil handler for No-TSR route '%s", route) |
||||
} else if tsr { |
||||
t.Errorf("expected no TSR recommendation for route '%s'", route) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestTreeRootTrailingSlashRedirect(t *testing.T) { |
||||
tree := &node{} |
||||
|
||||
recv := catchPanic(func() { |
||||
tree.addRoute("/:test", fakeHandler("/:test")) |
||||
}) |
||||
if recv != nil { |
||||
t.Fatalf("panic inserting test route: %v", recv) |
||||
} |
||||
|
||||
handler, _, tsr := tree.getValue("/", nil, false) |
||||
if handler != nil { |
||||
t.Fatalf("non-nil handler") |
||||
} else if tsr { |
||||
t.Errorf("expected no TSR recommendation") |
||||
} |
||||
} |
||||
|
||||
func TestTreeFindCaseInsensitivePath(t *testing.T) { |
||||
tree := &node{} |
||||
|
||||
routes := [...]string{ |
||||
"/hi", |
||||
"/b/", |
||||
"/ABC/", |
||||
"/search/:query", |
||||
"/cmd/:tool/", |
||||
"/src/*filepath", |
||||
"/x", |
||||
"/x/y", |
||||
"/y/", |
||||
"/y/z", |
||||
"/0/:id", |
||||
"/0/:id/1", |
||||
"/1/:id/", |
||||
"/1/:id/2", |
||||
"/aa", |
||||
"/a/", |
||||
"/doc", |
||||
"/doc/go_faq.html", |
||||
"/doc/go1.html", |
||||
"/doc/go/away", |
||||
"/no/a", |
||||
"/no/b", |
||||
} |
||||
|
||||
for _, route := range routes { |
||||
recv := catchPanic(func() { |
||||
tree.addRoute(route, fakeHandler(route)) |
||||
}) |
||||
if recv != nil { |
||||
t.Fatalf("panic inserting route '%s': %v", route, recv) |
||||
} |
||||
} |
||||
|
||||
// Check out == in for all registered routes
|
||||
// With fixTrailingSlash = true
|
||||
for _, route := range routes { |
||||
out, found := tree.findCaseInsensitivePath(route, true) |
||||
if !found { |
||||
t.Errorf("Route '%s' not found!", route) |
||||
} else if string(out) != route { |
||||
t.Errorf("Wrong result for route '%s': %s", route, string(out)) |
||||
} |
||||
} |
||||
// With fixTrailingSlash = false
|
||||
for _, route := range routes { |
||||
out, found := tree.findCaseInsensitivePath(route, false) |
||||
if !found { |
||||
t.Errorf("Route '%s' not found!", route) |
||||
} else if string(out) != route { |
||||
t.Errorf("Wrong result for route '%s': %s", route, string(out)) |
||||
} |
||||
} |
||||
|
||||
tests := []struct { |
||||
in string |
||||
out string |
||||
found bool |
||||
slash bool |
||||
}{ |
||||
{"/HI", "/hi", true, false}, |
||||
{"/HI/", "/hi", true, true}, |
||||
{"/B", "/b/", true, true}, |
||||
{"/B/", "/b/", true, false}, |
||||
{"/abc", "/ABC/", true, true}, |
||||
{"/abc/", "/ABC/", true, false}, |
||||
{"/aBc", "/ABC/", true, true}, |
||||
{"/aBc/", "/ABC/", true, false}, |
||||
{"/abC", "/ABC/", true, true}, |
||||
{"/abC/", "/ABC/", true, false}, |
||||
{"/SEARCH/QUERY", "/search/QUERY", true, false}, |
||||
{"/SEARCH/QUERY/", "/search/QUERY", true, true}, |
||||
{"/CMD/TOOL/", "/cmd/TOOL/", true, false}, |
||||
{"/CMD/TOOL", "/cmd/TOOL/", true, true}, |
||||
{"/SRC/FILE/PATH", "/src/FILE/PATH", true, false}, |
||||
{"/x/Y", "/x/y", true, false}, |
||||
{"/x/Y/", "/x/y", true, true}, |
||||
{"/X/y", "/x/y", true, false}, |
||||
{"/X/y/", "/x/y", true, true}, |
||||
{"/X/Y", "/x/y", true, false}, |
||||
{"/X/Y/", "/x/y", true, true}, |
||||
{"/Y/", "/y/", true, false}, |
||||
{"/Y", "/y/", true, true}, |
||||
{"/Y/z", "/y/z", true, false}, |
||||
{"/Y/z/", "/y/z", true, true}, |
||||
{"/Y/Z", "/y/z", true, false}, |
||||
{"/Y/Z/", "/y/z", true, true}, |
||||
{"/y/Z", "/y/z", true, false}, |
||||
{"/y/Z/", "/y/z", true, true}, |
||||
{"/Aa", "/aa", true, false}, |
||||
{"/Aa/", "/aa", true, true}, |
||||
{"/AA", "/aa", true, false}, |
||||
{"/AA/", "/aa", true, true}, |
||||
{"/aA", "/aa", true, false}, |
||||
{"/aA/", "/aa", true, true}, |
||||
{"/A/", "/a/", true, false}, |
||||
{"/A", "/a/", true, true}, |
||||
{"/DOC", "/doc", true, false}, |
||||
{"/DOC/", "/doc", true, true}, |
||||
{"/NO", "", false, true}, |
||||
{"/DOC/GO", "", false, true}, |
||||
} |
||||
// With fixTrailingSlash = true
|
||||
for _, test := range tests { |
||||
out, found := tree.findCaseInsensitivePath(test.in, true) |
||||
if found != test.found || (found && (string(out) != test.out)) { |
||||
t.Errorf("Wrong result for '%s': got %s, %t; want %s, %t", |
||||
test.in, string(out), found, test.out, test.found) |
||||
return |
||||
} |
||||
} |
||||
// With fixTrailingSlash = false
|
||||
for _, test := range tests { |
||||
out, found := tree.findCaseInsensitivePath(test.in, false) |
||||
if test.slash { |
||||
if found { // test needs a trailingSlash fix. It must not be found!
|
||||
t.Errorf("Found without fixTrailingSlash: %s; got %s", test.in, string(out)) |
||||
} |
||||
} else { |
||||
if found != test.found || (found && (string(out) != test.out)) { |
||||
t.Errorf("Wrong result for '%s': got %s, %t; want %s, %t", |
||||
test.in, string(out), found, test.out, test.found) |
||||
return |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestTreeInvalidNodeType(t *testing.T) { |
||||
const panicMsg = "invalid node type" |
||||
|
||||
tree := &node{} |
||||
tree.addRoute("/", fakeHandler("/")) |
||||
tree.addRoute("/:page", fakeHandler("/:page")) |
||||
|
||||
// set invalid node type
|
||||
tree.children[0].nType = 42 |
||||
|
||||
// normal lookup
|
||||
recv := catchPanic(func() { |
||||
tree.getValue("/test", nil, false) |
||||
}) |
||||
if rs, ok := recv.(string); !ok || rs != panicMsg { |
||||
t.Fatalf("Expected panic '"+panicMsg+"', got '%v'", recv) |
||||
} |
||||
|
||||
// case-insensitive lookup
|
||||
recv = catchPanic(func() { |
||||
tree.findCaseInsensitivePath("/test", true) |
||||
}) |
||||
if rs, ok := recv.(string); !ok || rs != panicMsg { |
||||
t.Fatalf("Expected panic '"+panicMsg+"', got '%v'", recv) |
||||
} |
||||
} |
||||
|
||||
func TestTreeWildcardConflictEx(t *testing.T) { |
||||
conflicts := [...]struct { |
||||
route string |
||||
segPath string |
||||
existPath string |
||||
existSegPath string |
||||
}{ |
||||
{"/who/are/foo", "/foo", `/who/are/\*you`, `/\*you`}, |
||||
{"/who/are/foo/", "/foo/", `/who/are/\*you`, `/\*you`}, |
||||
{"/who/are/foo/bar", "/foo/bar", `/who/are/\*you`, `/\*you`}, |
||||
{"/conxxx", "xxx", `/con:tact`, `:tact`}, |
||||
{"/conooo/xxx", "ooo", `/con:tact`, `:tact`}, |
||||
} |
||||
|
||||
for _, conflict := range conflicts { |
||||
// I have to re-create a 'tree', because the 'tree' will be
|
||||
// in an inconsistent state when the loop recovers from the
|
||||
// panic which threw by 'addRoute' function.
|
||||
tree := &node{} |
||||
routes := [...]string{ |
||||
"/con:tact", |
||||
"/who/are/*you", |
||||
"/who/foo/hello", |
||||
} |
||||
|
||||
for _, route := range routes { |
||||
tree.addRoute(route, fakeHandler(route)) |
||||
} |
||||
|
||||
recv := catchPanic(func() { |
||||
tree.addRoute(conflict.route, fakeHandler(conflict.route)) |
||||
}) |
||||
|
||||
if !regexp.MustCompile(fmt.Sprintf("'%s' in new path .* conflicts with existing wildcard '%s' in existing prefix '%s'", |
||||
conflict.segPath, conflict.existSegPath, conflict.existPath)).MatchString(fmt.Sprint(recv)) { |
||||
t.Fatalf("invalid wildcard conflict error (%v)", recv) |
||||
} |
||||
} |
||||
} |
||||
|
||||
Loading…
Reference in new issue