...
Run Format

Source file src/text/template/multi_test.go

Documentation: text/template

  // Copyright 2011 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package template
  
  // Tests for multiple-template parsing and execution.
  
  import (
  	"bytes"
  	"fmt"
  	"testing"
  	"text/template/parse"
  )
  
  const (
  	noError  = true
  	hasError = false
  )
  
  type multiParseTest struct {
  	name    string
  	input   string
  	ok      bool
  	names   []string
  	results []string
  }
  
  var multiParseTests = []multiParseTest{
  	{"empty", "", noError,
  		nil,
  		nil},
  	{"one", `{{define "foo"}} FOO {{end}}`, noError,
  		[]string{"foo"},
  		[]string{" FOO "}},
  	{"two", `{{define "foo"}} FOO {{end}}{{define "bar"}} BAR {{end}}`, noError,
  		[]string{"foo", "bar"},
  		[]string{" FOO ", " BAR "}},
  	// errors
  	{"missing end", `{{define "foo"}} FOO `, hasError,
  		nil,
  		nil},
  	{"malformed name", `{{define "foo}} FOO `, hasError,
  		nil,
  		nil},
  }
  
  func TestMultiParse(t *testing.T) {
  	for _, test := range multiParseTests {
  		template, err := New("root").Parse(test.input)
  		switch {
  		case err == nil && !test.ok:
  			t.Errorf("%q: expected error; got none", test.name)
  			continue
  		case err != nil && test.ok:
  			t.Errorf("%q: unexpected error: %v", test.name, err)
  			continue
  		case err != nil && !test.ok:
  			// expected error, got one
  			if *debug {
  				fmt.Printf("%s: %s\n\t%s\n", test.name, test.input, err)
  			}
  			continue
  		}
  		if template == nil {
  			continue
  		}
  		if len(template.tmpl) != len(test.names)+1 { // +1 for root
  			t.Errorf("%s: wrong number of templates; wanted %d got %d", test.name, len(test.names), len(template.tmpl))
  			continue
  		}
  		for i, name := range test.names {
  			tmpl, ok := template.tmpl[name]
  			if !ok {
  				t.Errorf("%s: can't find template %q", test.name, name)
  				continue
  			}
  			result := tmpl.Root.String()
  			if result != test.results[i] {
  				t.Errorf("%s=(%q): got\n\t%v\nexpected\n\t%v", test.name, test.input, result, test.results[i])
  			}
  		}
  	}
  }
  
  var multiExecTests = []execTest{
  	{"empty", "", "", nil, true},
  	{"text", "some text", "some text", nil, true},
  	{"invoke x", `{{template "x" .SI}}`, "TEXT", tVal, true},
  	{"invoke x no args", `{{template "x"}}`, "TEXT", tVal, true},
  	{"invoke dot int", `{{template "dot" .I}}`, "17", tVal, true},
  	{"invoke dot []int", `{{template "dot" .SI}}`, "[3 4 5]", tVal, true},
  	{"invoke dotV", `{{template "dotV" .U}}`, "v", tVal, true},
  	{"invoke nested int", `{{template "nested" .I}}`, "17", tVal, true},
  	{"variable declared by template", `{{template "nested" $x:=.SI}},{{index $x 1}}`, "[3 4 5],4", tVal, true},
  
  	// User-defined function: test argument evaluator.
  	{"testFunc literal", `{{oneArg "joe"}}`, "oneArg=joe", tVal, true},
  	{"testFunc .", `{{oneArg .}}`, "oneArg=joe", "joe", true},
  }
  
  // These strings are also in testdata/*.
  const multiText1 = `
  	{{define "x"}}TEXT{{end}}
  	{{define "dotV"}}{{.V}}{{end}}
  `
  
  const multiText2 = `
  	{{define "dot"}}{{.}}{{end}}
  	{{define "nested"}}{{template "dot" .}}{{end}}
  `
  
  func TestMultiExecute(t *testing.T) {
  	// Declare a couple of templates first.
  	template, err := New("root").Parse(multiText1)
  	if err != nil {
  		t.Fatalf("parse error for 1: %s", err)
  	}
  	_, err = template.Parse(multiText2)
  	if err != nil {
  		t.Fatalf("parse error for 2: %s", err)
  	}
  	testExecute(multiExecTests, template, t)
  }
  
  func TestParseFiles(t *testing.T) {
  	_, err := ParseFiles("DOES NOT EXIST")
  	if err == nil {
  		t.Error("expected error for non-existent file; got none")
  	}
  	template := New("root")
  	_, err = template.ParseFiles("testdata/file1.tmpl", "testdata/file2.tmpl")
  	if err != nil {
  		t.Fatalf("error parsing files: %v", err)
  	}
  	testExecute(multiExecTests, template, t)
  }
  
  func TestParseGlob(t *testing.T) {
  	_, err := ParseGlob("DOES NOT EXIST")
  	if err == nil {
  		t.Error("expected error for non-existent file; got none")
  	}
  	_, err = New("error").ParseGlob("[x")
  	if err == nil {
  		t.Error("expected error for bad pattern; got none")
  	}
  	template := New("root")
  	_, err = template.ParseGlob("testdata/file*.tmpl")
  	if err != nil {
  		t.Fatalf("error parsing files: %v", err)
  	}
  	testExecute(multiExecTests, template, t)
  }
  
  // In these tests, actual content (not just template definitions) comes from the parsed files.
  
  var templateFileExecTests = []execTest{
  	{"test", `{{template "tmpl1.tmpl"}}{{template "tmpl2.tmpl"}}`, "template1\n\ny\ntemplate2\n\nx\n", 0, true},
  }
  
  func TestParseFilesWithData(t *testing.T) {
  	template, err := New("root").ParseFiles("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
  	if err != nil {
  		t.Fatalf("error parsing files: %v", err)
  	}
  	testExecute(templateFileExecTests, template, t)
  }
  
  func TestParseGlobWithData(t *testing.T) {
  	template, err := New("root").ParseGlob("testdata/tmpl*.tmpl")
  	if err != nil {
  		t.Fatalf("error parsing files: %v", err)
  	}
  	testExecute(templateFileExecTests, template, t)
  }
  
  const (
  	cloneText1 = `{{define "a"}}{{template "b"}}{{template "c"}}{{end}}`
  	cloneText2 = `{{define "b"}}b{{end}}`
  	cloneText3 = `{{define "c"}}root{{end}}`
  	cloneText4 = `{{define "c"}}clone{{end}}`
  )
  
  func TestClone(t *testing.T) {
  	// Create some templates and clone the root.
  	root, err := New("root").Parse(cloneText1)
  	if err != nil {
  		t.Fatal(err)
  	}
  	_, err = root.Parse(cloneText2)
  	if err != nil {
  		t.Fatal(err)
  	}
  	clone := Must(root.Clone())
  	// Add variants to both.
  	_, err = root.Parse(cloneText3)
  	if err != nil {
  		t.Fatal(err)
  	}
  	_, err = clone.Parse(cloneText4)
  	if err != nil {
  		t.Fatal(err)
  	}
  	// Verify that the clone is self-consistent.
  	for k, v := range clone.tmpl {
  		if k == clone.name && v.tmpl[k] != clone {
  			t.Error("clone does not contain root")
  		}
  		if v != v.tmpl[v.name] {
  			t.Errorf("clone does not contain self for %q", k)
  		}
  	}
  	// Execute root.
  	var b bytes.Buffer
  	err = root.ExecuteTemplate(&b, "a", 0)
  	if err != nil {
  		t.Fatal(err)
  	}
  	if b.String() != "broot" {
  		t.Errorf("expected %q got %q", "broot", b.String())
  	}
  	// Execute copy.
  	b.Reset()
  	err = clone.ExecuteTemplate(&b, "a", 0)
  	if err != nil {
  		t.Fatal(err)
  	}
  	if b.String() != "bclone" {
  		t.Errorf("expected %q got %q", "bclone", b.String())
  	}
  }
  
  func TestAddParseTree(t *testing.T) {
  	// Create some templates.
  	root, err := New("root").Parse(cloneText1)
  	if err != nil {
  		t.Fatal(err)
  	}
  	_, err = root.Parse(cloneText2)
  	if err != nil {
  		t.Fatal(err)
  	}
  	// Add a new parse tree.
  	tree, err := parse.Parse("cloneText3", cloneText3, "", "", nil, builtins)
  	if err != nil {
  		t.Fatal(err)
  	}
  	added, err := root.AddParseTree("c", tree["c"])
  	// Execute.
  	var b bytes.Buffer
  	err = added.ExecuteTemplate(&b, "a", 0)
  	if err != nil {
  		t.Fatal(err)
  	}
  	if b.String() != "broot" {
  		t.Errorf("expected %q got %q", "broot", b.String())
  	}
  }
  
  // Issue 7032
  func TestAddParseTreeToUnparsedTemplate(t *testing.T) {
  	master := "{{define \"master\"}}{{end}}"
  	tmpl := New("master")
  	tree, err := parse.Parse("master", master, "", "", nil)
  	if err != nil {
  		t.Fatalf("unexpected parse err: %v", err)
  	}
  	masterTree := tree["master"]
  	tmpl.AddParseTree("master", masterTree) // used to panic
  }
  
  func TestRedefinition(t *testing.T) {
  	var tmpl *Template
  	var err error
  	if tmpl, err = New("tmpl1").Parse(`{{define "test"}}foo{{end}}`); err != nil {
  		t.Fatalf("parse 1: %v", err)
  	}
  	if _, err = tmpl.Parse(`{{define "test"}}bar{{end}}`); err != nil {
  		t.Fatalf("got error %v, expected nil", err)
  	}
  	if _, err = tmpl.New("tmpl2").Parse(`{{define "test"}}bar{{end}}`); err != nil {
  		t.Fatalf("got error %v, expected nil", err)
  	}
  }
  
  // Issue 10879
  func TestEmptyTemplateCloneCrash(t *testing.T) {
  	t1 := New("base")
  	t1.Clone() // used to panic
  }
  
  // Issue 10910, 10926
  func TestTemplateLookUp(t *testing.T) {
  	t1 := New("foo")
  	if t1.Lookup("foo") != nil {
  		t.Error("Lookup returned non-nil value for undefined template foo")
  	}
  	t1.New("bar")
  	if t1.Lookup("bar") != nil {
  		t.Error("Lookup returned non-nil value for undefined template bar")
  	}
  	t1.Parse(`{{define "foo"}}test{{end}}`)
  	if t1.Lookup("foo") == nil {
  		t.Error("Lookup returned nil value for defined template")
  	}
  }
  
  func TestNew(t *testing.T) {
  	// template with same name already exists
  	t1, _ := New("test").Parse(`{{define "test"}}foo{{end}}`)
  	t2 := t1.New("test")
  
  	if t1.common != t2.common {
  		t.Errorf("t1 & t2 didn't share common struct; got %v != %v", t1.common, t2.common)
  	}
  	if t1.Tree == nil {
  		t.Error("defined template got nil Tree")
  	}
  	if t2.Tree != nil {
  		t.Error("undefined template got non-nil Tree")
  	}
  
  	containsT1 := false
  	for _, tmpl := range t1.Templates() {
  		if tmpl == t2 {
  			t.Error("Templates included undefined template")
  		}
  		if tmpl == t1 {
  			containsT1 = true
  		}
  	}
  	if !containsT1 {
  		t.Error("Templates didn't include defined template")
  	}
  }
  
  func TestParse(t *testing.T) {
  	// In multiple calls to Parse with the same receiver template, only one call
  	// can contain text other than space, comments, and template definitions
  	t1 := New("test")
  	if _, err := t1.Parse(`{{define "test"}}{{end}}`); err != nil {
  		t.Fatalf("parsing test: %s", err)
  	}
  	if _, err := t1.Parse(`{{define "test"}}{{/* this is a comment */}}{{end}}`); err != nil {
  		t.Fatalf("parsing test: %s", err)
  	}
  	if _, err := t1.Parse(`{{define "test"}}foo{{end}}`); err != nil {
  		t.Fatalf("parsing test: %s", err)
  	}
  }
  
  func TestEmptyTemplate(t *testing.T) {
  	cases := []struct {
  		defn []string
  		in   string
  		want string
  	}{
  		{[]string{""}, "once", ""},
  		{[]string{"", ""}, "twice", ""},
  		{[]string{"{{.}}", "{{.}}"}, "twice", "twice"},
  		{[]string{"{{/* a comment */}}", "{{/* a comment */}}"}, "comment", ""},
  		{[]string{"{{.}}", ""}, "twice", ""},
  	}
  
  	for i, c := range cases {
  		root := New("root")
  
  		var (
  			m   *Template
  			err error
  		)
  		for _, d := range c.defn {
  			m, err = root.New(c.in).Parse(d)
  			if err != nil {
  				t.Fatal(err)
  			}
  		}
  		buf := &bytes.Buffer{}
  		if err := m.Execute(buf, c.in); err != nil {
  			t.Error(i, err)
  			continue
  		}
  		if buf.String() != c.want {
  			t.Errorf("expected string %q: got %q", c.want, buf.String())
  		}
  	}
  }
  
  // Issue 19249 was a regression in 1.8 caused by the handling of empty
  // templates added in that release, which got different answers depending
  // on the order templates appeared in the internal map.
  func TestIssue19294(t *testing.T) {
  	// The empty block in "xhtml" should be replaced during execution
  	// by the contents of "stylesheet", but if the internal map associating
  	// names with templates is built in the wrong order, the empty block
  	// looks non-empty and this doesn't happen.
  	var inlined = map[string]string{
  		"stylesheet": `{{define "stylesheet"}}stylesheet{{end}}`,
  		"xhtml":      `{{block "stylesheet" .}}{{end}}`,
  	}
  	all := []string{"stylesheet", "xhtml"}
  	for i := 0; i < 100; i++ {
  		res, err := New("title.xhtml").Parse(`{{template "xhtml" .}}`)
  		if err != nil {
  			t.Fatal(err)
  		}
  		for _, name := range all {
  			_, err := res.New(name).Parse(inlined[name])
  			if err != nil {
  				t.Fatal(err)
  			}
  		}
  		var buf bytes.Buffer
  		res.Execute(&buf, 0)
  		if buf.String() != "stylesheet" {
  			t.Fatalf("iteration %d: got %q; expected %q", i, buf.String(), "stylesheet")
  		}
  	}
  }
  

View as plain text