1 files changed, 146 insertions, 0 deletions
diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/translation/template_test.go b/vendor/github.com/nicksnyder/go-i18n/i18n/translation/template_test.go
new file mode 100644
index 000000000..73a923404
--- /dev/null
+++ b/vendor/github.com/nicksnyder/go-i18n/i18n/translation/template_test.go
@@ -0,0 +1,146 @@
+package translation
+
+import (
+	"bytes"
+	"fmt"
+	//"launchpad.net/goyaml"
+	"testing"
+	gotemplate "text/template"
+)
+
+func TestNilTemplate(t *testing.T) {
+	expected := "hello"
+	tmpl := &template{
+		tmpl: nil,
+		src:  expected,
+	}
+	if actual := tmpl.Execute(nil); actual != expected {
+		t.Errorf("Execute(nil) returned %s; expected %s", actual, expected)
+	}
+}
+
+func TestMarshalText(t *testing.T) {
+	tmpl := &template{
+		tmpl: gotemplate.Must(gotemplate.New("id").Parse("this is a {{.foo}} template")),
+		src:  "boom",
+	}
+	expectedBuf := []byte(tmpl.src)
+	if buf, err := tmpl.MarshalText(); !bytes.Equal(buf, expectedBuf) || err != nil {
+		t.Errorf("MarshalText() returned %#v, %#v; expected %#v, nil", buf, err, expectedBuf)
+	}
+}
+
+func TestUnmarshalText(t *testing.T) {
+	tmpl := &template{}
+	tmpl.UnmarshalText([]byte("hello {{.World}}"))
+	result := tmpl.Execute(map[string]string{
+		"World": "world!",
+	})
+	expected := "hello world!"
+	if result != expected {
+		t.Errorf("expected %#v; got %#v", expected, result)
+	}
+}
+
+/*
+func TestYAMLMarshal(t *testing.T) {
+	src := "hello {{.World}}"
+	tmpl, err := newTemplate(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	buf, err := goyaml.Marshal(tmpl)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(buf, []byte(src)) {
+		t.Fatalf(`expected "%s"; got "%s"`, src, buf)
+	}
+}
+
+func TestYAMLUnmarshal(t *testing.T) {
+	buf := []byte(`Tmpl: "hello"`)
+
+	var out struct {
+		Tmpl *template
+	}
+	var foo map[string]string
+	if err := goyaml.Unmarshal(buf, &foo); err != nil {
+		t.Fatal(err)
+	}
+	if out.Tmpl == nil {
+		t.Fatalf("out.Tmpl was nil")
+	}
+	if out.Tmpl.tmpl == nil {
+		t.Fatalf("out.Tmpl.tmpl was nil")
+	}
+	if expected := "hello {{.World}}"; out.Tmpl.src != expected {
+		t.Fatalf("expected %s; got %s", expected, out.Tmpl.src)
+	}
+}
+
+func TestGetYAML(t *testing.T) {
+	src := "hello"
+	tmpl := &template{
+		tmpl: nil,
+		src:  src,
+	}
+	if tag, value := tmpl.GetYAML(); tag != "" || value != src {
+		t.Errorf("GetYAML() returned (%#v, %#v); expected (%#v, %#v)", tag, value, "", src)
+	}
+}
+
+func TestSetYAML(t *testing.T) {
+	tmpl := &template{}
+	tmpl.SetYAML("tagDoesntMatter", "hello {{.World}}")
+	result := tmpl.Execute(map[string]string{
+		"World": "world!",
+	})
+	expected := "hello world!"
+	if result != expected {
+		t.Errorf("expected %#v; got %#v", expected, result)
+	}
+}
+*/
+
+func BenchmarkExecuteNilTemplate(b *testing.B) {
+	template := &template{src: "hello world"}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		template.Execute(nil)
+	}
+}
+
+func BenchmarkExecuteHelloWorldTemplate(b *testing.B) {
+	template, err := newTemplate("hello world")
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		template.Execute(nil)
+	}
+}
+
+// Executing a simple template like this is ~6x slower than Sprintf
+// but it is still only a few microseconds which should be sufficiently fast.
+// The benefit is that we have nice semantic tags in the translation.
+func BenchmarkExecuteHelloNameTemplate(b *testing.B) {
+	template, err := newTemplate("hello {{.Name}}")
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		template.Execute(map[string]string{
+			"Name": "Nick",
+		})
+	}
+}
+
+func BenchmarkSprintf(b *testing.B) {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		fmt.Sprintf("hello %s", "nick")
+	}
+}