`
func TestEscapeRace(t *testing.T) {
+ t.Skip("this test currently fails with -race; see issue #39807")
+
tmpl := New("")
_, err := tmpl.New("templ.html").Parse(raceText)
if err != nil {
}
}
+// recursiveInvoker is for TestRecursiveExecuteViaMethod.
+type recursiveInvoker struct {
+ t *testing.T
+ tmpl *Template
+}
+
+func (r *recursiveInvoker) Recur() (string, error) {
+ var sb strings.Builder
+ if err := r.tmpl.ExecuteTemplate(&sb, "subroutine", nil); err != nil {
+ r.t.Fatal(err)
+ }
+ return sb.String(), nil
+}
+
+func TestRecursiveExecuteViaMethod(t *testing.T) {
+ tmpl := New("")
+ top, err := tmpl.New("x.html").Parse(`{{.Recur}}`)
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, err = tmpl.New("subroutine").Parse(`<a href="/x?p={{"'a<b'"}}">`)
+ if err != nil {
+ t.Fatal(err)
+ }
+ r := &recursiveInvoker{
+ t: t,
+ tmpl: tmpl,
+ }
+ if err := top.Execute(io.Discard, r); err != nil {
+ t.Fatal(err)
+ }
+}
+
// Issue 43295.
func TestTemplateFuncsAfterClone(t *testing.T) {
s := `{{ f . }}`
"os"
"path"
"path/filepath"
- "reflect"
"sync"
"text/template"
"text/template/parse"
// nameSpace is the data structure shared by all templates in an association.
type nameSpace struct {
- mu sync.RWMutex
+ mu sync.Mutex
set map[string]*Template
escaped bool
esc escaper
- // The original functions, before wrapping.
- funcMap FuncMap
}
// Templates returns a slice of the templates associated with t, including t
// itself.
func (t *Template) Templates() []*Template {
ns := t.nameSpace
- ns.mu.RLock()
- defer ns.mu.RUnlock()
+ ns.mu.Lock()
+ defer ns.mu.Unlock()
// Return a slice so we don't expose the map.
m := make([]*Template, 0, len(ns.set))
for _, v := range ns.set {
if t == nil {
return nil
}
- t.nameSpace.mu.RLock()
- defer t.nameSpace.mu.RUnlock()
+ t.nameSpace.mu.Lock()
+ defer t.nameSpace.mu.Unlock()
if t.nameSpace.escaped {
return fmt.Errorf("html/template: cannot Parse after Execute")
}
// escape escapes all associated templates.
func (t *Template) escape() error {
- t.nameSpace.mu.RLock()
- escapeErr := t.escapeErr
- t.nameSpace.mu.RUnlock()
- if escapeErr != nil {
- if escapeErr == escapeOK {
- return nil
- }
- return escapeErr
- }
-
t.nameSpace.mu.Lock()
defer t.nameSpace.mu.Unlock()
t.nameSpace.escaped = true
if err := t.escape(); err != nil {
return err
}
- t.nameSpace.mu.RLock()
- defer t.nameSpace.mu.RUnlock()
return t.text.Execute(wr, data)
}
if err != nil {
return err
}
- t.nameSpace.mu.RLock()
- defer t.nameSpace.mu.RUnlock()
return tmpl.text.Execute(wr, data)
}
// is escaped, or returns an error if it cannot be. It returns the named
// template.
func (t *Template) lookupAndEscapeTemplate(name string) (tmpl *Template, err error) {
- t.nameSpace.mu.RLock()
+ t.nameSpace.mu.Lock()
+ defer t.nameSpace.mu.Unlock()
+ t.nameSpace.escaped = true
tmpl = t.set[name]
- var escapeErr error
- if tmpl != nil {
- escapeErr = tmpl.escapeErr
- }
- t.nameSpace.mu.RUnlock()
-
if tmpl == nil {
return nil, fmt.Errorf("html/template: %q is undefined", name)
}
- if escapeErr != nil {
- if escapeErr != escapeOK {
- return nil, escapeErr
- }
- return tmpl, nil
- }
-
- t.nameSpace.mu.Lock()
- defer t.nameSpace.mu.Unlock()
- t.nameSpace.escaped = true
if tmpl.escapeErr != nil && tmpl.escapeErr != escapeOK {
return nil, tmpl.escapeErr
}
}
ns := &nameSpace{set: make(map[string]*Template)}
ns.esc = makeEscaper(ns)
- if t.nameSpace.funcMap != nil {
- ns.funcMap = make(FuncMap, len(t.nameSpace.funcMap))
- for name, fn := range t.nameSpace.funcMap {
- ns.funcMap[name] = fn
- }
- }
- wrapFuncs(ns, textClone, ns.funcMap)
ret := &Template{
nil,
textClone,
return nil, fmt.Errorf("html/template: cannot Clone %q after it has executed", t.Name())
}
x.Tree = x.Tree.Copy()
- tc := &Template{
+ ret.set[name] = &Template{
nil,
x,
x.Tree,
ret.nameSpace,
}
- ret.set[name] = tc
}
// Return the template associated with the name of this template.
return ret.set[ret.Name()], nil
// type. However, it is legal to overwrite elements of the map. The return
// value is the template, so calls can be chained.
func (t *Template) Funcs(funcMap FuncMap) *Template {
- t.nameSpace.mu.Lock()
- if t.nameSpace.funcMap == nil {
- t.nameSpace.funcMap = make(FuncMap, len(funcMap))
- }
- for name, fn := range funcMap {
- t.nameSpace.funcMap[name] = fn
- }
- t.nameSpace.mu.Unlock()
-
- wrapFuncs(t.nameSpace, t.text, funcMap)
+ t.text.Funcs(template.FuncMap(funcMap))
return t
}
-// wrapFuncs records the functions with text/template. We wrap them to
-// unlock the nameSpace. See TestRecursiveExecute for a test case.
-func wrapFuncs(ns *nameSpace, textTemplate *template.Template, funcMap FuncMap) {
- if len(funcMap) == 0 {
- return
- }
- tfuncs := make(template.FuncMap, len(funcMap))
- for name, fn := range funcMap {
- fnv := reflect.ValueOf(fn)
- wrapper := func(args []reflect.Value) []reflect.Value {
- ns.mu.RUnlock()
- defer ns.mu.RLock()
- if fnv.Type().IsVariadic() {
- return fnv.CallSlice(args)
- } else {
- return fnv.Call(args)
- }
- }
- wrapped := reflect.MakeFunc(fnv.Type(), wrapper)
- tfuncs[name] = wrapped.Interface()
- }
- textTemplate.Funcs(tfuncs)
-}
-
// Delims sets the action delimiters to the specified strings, to be used in
// subsequent calls to Parse, ParseFiles, or ParseGlob. Nested template
// definitions will inherit the settings. An empty delimiter stands for the
// Lookup returns the template with the given name that is associated with t,
// or nil if there is no such template.
func (t *Template) Lookup(name string) *Template {
- t.nameSpace.mu.RLock()
- defer t.nameSpace.mu.RUnlock()
+ t.nameSpace.mu.Lock()
+ defer t.nameSpace.mu.Unlock()
return t.set[name]
}