240 lines
6.4 KiB
Go
240 lines
6.4 KiB
Go
// 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
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
)
|
|
|
|
const (
|
|
noError = true
|
|
hasError = false
|
|
)
|
|
|
|
type setParseTest struct {
|
|
name string
|
|
input string
|
|
ok bool
|
|
names []string
|
|
results []string
|
|
}
|
|
|
|
var setParseTests = []setParseTest{
|
|
{"empty", "", noError,
|
|
nil,
|
|
nil},
|
|
{"one", `{{define "foo"}} FOO {{end}}`, noError,
|
|
[]string{"foo"},
|
|
[]string{`[(text: " FOO ")]`}},
|
|
{"two", `{{define "foo"}} FOO {{end}}{{define "bar"}} BAR {{end}}`, noError,
|
|
[]string{"foo", "bar"},
|
|
[]string{`[(text: " FOO ")]`, `[(text: " BAR ")]`}},
|
|
// errors
|
|
{"missing end", `{{define "foo"}} FOO `, hasError,
|
|
nil,
|
|
nil},
|
|
{"malformed name", `{{define "foo}} FOO `, hasError,
|
|
nil,
|
|
nil},
|
|
}
|
|
|
|
func TestSetParse(t *testing.T) {
|
|
for _, test := range setParseTests {
|
|
set, err := new(Set).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 set == nil {
|
|
continue
|
|
}
|
|
if len(set.tmpl) != len(test.names) {
|
|
t.Errorf("%s: wrong number of templates; wanted %d got %d", test.name, len(test.names), len(set.tmpl))
|
|
continue
|
|
}
|
|
for i, name := range test.names {
|
|
tmpl, ok := set.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 setExecTests = []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 setText1 = `
|
|
{{define "x"}}TEXT{{end}}
|
|
{{define "dotV"}}{{.V}}{{end}}
|
|
`
|
|
|
|
const setText2 = `
|
|
{{define "dot"}}{{.}}{{end}}
|
|
{{define "nested"}}{{template "dot" .}}{{end}}
|
|
`
|
|
|
|
func TestSetExecute(t *testing.T) {
|
|
// Declare a set with a couple of templates first.
|
|
set := new(Set)
|
|
_, err := set.Parse(setText1)
|
|
if err != nil {
|
|
t.Fatalf("error parsing set: %s", err)
|
|
}
|
|
_, err = set.Parse(setText2)
|
|
if err != nil {
|
|
t.Fatalf("error parsing set: %s", err)
|
|
}
|
|
testExecute(setExecTests, set, t)
|
|
}
|
|
|
|
func TestSetParseFiles(t *testing.T) {
|
|
set := new(Set)
|
|
_, err := set.ParseFiles("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
_, err = set.ParseFiles("testdata/file1.tmpl", "testdata/file2.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(setExecTests, set, t)
|
|
}
|
|
|
|
func TestParseSetFiles(t *testing.T) {
|
|
set := new(Set)
|
|
_, err := ParseSetFiles("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
set, err = ParseSetFiles("testdata/file1.tmpl", "testdata/file2.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(setExecTests, set, t)
|
|
}
|
|
|
|
func TestSetParseGlob(t *testing.T) {
|
|
_, err := new(Set).ParseGlob("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
_, err = new(Set).ParseGlob("[x")
|
|
if err == nil {
|
|
t.Error("expected error for bad pattern; got none")
|
|
}
|
|
set, err := new(Set).ParseGlob("testdata/file*.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(setExecTests, set, t)
|
|
}
|
|
|
|
func TestParseSetGlob(t *testing.T) {
|
|
_, err := ParseSetGlob("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
_, err = ParseSetGlob("[x")
|
|
if err == nil {
|
|
t.Error("expected error for bad pattern; got none")
|
|
}
|
|
set, err := ParseSetGlob("testdata/file*.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(setExecTests, set, t)
|
|
}
|
|
|
|
var templateFileExecTests = []execTest{
|
|
{"test", `{{template "tmpl1.tmpl"}}{{template "tmpl2.tmpl"}}`, "template1\ntemplate2\n", 0, true},
|
|
}
|
|
|
|
func TestSetParseTemplateFiles(t *testing.T) {
|
|
_, err := ParseTemplateFiles("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
set, err := new(Set).ParseTemplateFiles("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(templateFileExecTests, set, t)
|
|
}
|
|
|
|
func TestParseTemplateFiles(t *testing.T) {
|
|
_, err := ParseTemplateFiles("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
set, err := new(Set).ParseTemplateFiles("testdata/tmpl1.tmpl", "testdata/tmpl2.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(templateFileExecTests, set, t)
|
|
}
|
|
|
|
func TestSetParseTemplateGlob(t *testing.T) {
|
|
_, err := ParseTemplateGlob("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
_, err = new(Set).ParseTemplateGlob("[x")
|
|
if err == nil {
|
|
t.Error("expected error for bad pattern; got none")
|
|
}
|
|
set, err := new(Set).ParseTemplateGlob("testdata/tmpl*.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(templateFileExecTests, set, t)
|
|
}
|
|
|
|
func TestParseTemplateGlob(t *testing.T) {
|
|
_, err := ParseTemplateGlob("DOES NOT EXIST")
|
|
if err == nil {
|
|
t.Error("expected error for non-existent file; got none")
|
|
}
|
|
_, err = ParseTemplateGlob("[x")
|
|
if err == nil {
|
|
t.Error("expected error for bad pattern; got none")
|
|
}
|
|
set, err := ParseTemplateGlob("testdata/tmpl*.tmpl")
|
|
if err != nil {
|
|
t.Fatalf("error parsing files: %v", err)
|
|
}
|
|
testExecute(templateFileExecTests, set, t)
|
|
}
|