Subversion Repositories openrisc

// Copyright 2009 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 (
        "bytes"
        "encoding/json"
        "fmt"
        "io"
        "io/ioutil"
        "os"
        "strings"
        "testing"
)

type Test struct {
        in, out, err string
}

type T struct {
        Item  string
        Value string
}

type U struct {
        Mp map[string]int
}

type S struct {
        Header        string
        HeaderPtr     *string
        Integer       int
        IntegerPtr    *int
        NilPtr        *int
        InnerT        T
        InnerPointerT *T
        Data          []T
        Pdata         []*T
        Empty         []*T
        Emptystring   string
        Null          []*T
        Vec           []interface{}
        True          bool
        False         bool
        Mp            map[string]string
        JSON          interface{}
        Innermap      U
        Stringmap     map[string]string
        Ptrmap        map[string]*string
        Iface         interface{}
        Ifaceptr      interface{}
}

func (s *S) PointerMethod() string { return "ptrmethod!" }

func (s S) ValueMethod() string { return "valmethod!" }

var t1 = T{"ItemNumber1", "ValueNumber1"}
var t2 = T{"ItemNumber2", "ValueNumber2"}

func uppercase(v interface{}) string {
        s := v.(string)
        t := ""
        for i := 0; i < len(s); i++ {
                c := s[i]
                if 'a' <= c && c <= 'z' {
                        c = c + 'A' - 'a'
                }
                t += string(c)
        }
        return t
}

func plus1(v interface{}) string {
        i := v.(int)
        return fmt.Sprint(i + 1)
}

func writer(f func(interface{}) string) func(io.Writer, string, ...interface{}) {
        return func(w io.Writer, format string, v ...interface{}) {
                if len(v) != 1 {
                        panic("test writer expected one arg")
                }
                io.WriteString(w, f(v[0]))
        }
}

func multiword(w io.Writer, format string, value ...interface{}) {
        for _, v := range value {
                fmt.Fprintf(w, "<%v>", v)
        }
}

func printf(w io.Writer, format string, v ...interface{}) {
        io.WriteString(w, fmt.Sprintf(v[0].(string), v[1:]...))
}

var formatters = FormatterMap{
        "uppercase": writer(uppercase),
        "+1":        writer(plus1),
        "multiword": multiword,
        "printf":    printf,
}

var tests = []*Test{
        // Simple
        {"", "", ""},
        {"abc", "abc", ""},
        {"abc\ndef\n", "abc\ndef\n", ""},
        {" {.meta-left}   \n", "{", ""},
        {" {.meta-right}   \n", "}", ""},
        {" {.space}   \n", " ", ""},
        {" {.tab}   \n", "\t", ""},
        {"     {#comment}   \n", "", ""},
        {"\tSome Text\t\n", "\tSome Text\t\n", ""},
        {" {.meta-right} {.meta-right} {.meta-right} \n", " } } } \n", ""},

        // Variables at top level
        {
                in: "{Header}={Integer}\n",

                out: "Header=77\n",
        },

        {
                in: "Pointers: {*HeaderPtr}={*IntegerPtr}\n",

                out: "Pointers: Header=77\n",
        },

        {
                in: "Stars but not pointers: {*Header}={*Integer}\n",

                out: "Stars but not pointers: Header=77\n",
        },

        {
                in: "nil pointer: {*NilPtr}={*Integer}\n",

                out: "nil pointer: <nil>=77\n",
        },

        {
                in: `{"Strings" ":"} {""} {"|"} {"\t\u0123 \x23\\"} {"\"}{\\"}`,

                out: "Strings:  | \t\u0123 \x23\\ \"}{\\",
        },

        {
                in: "{`Raw strings` `:`} {``} {`|`} {`\\t\\u0123 \\x23\\`} {`}{\\`}",

                out: "Raw strings:  | \\t\\u0123 \\x23\\ }{\\",
        },

        {
                in: "Characters: {'a'} {'\\u0123'} {' '} {'{'} {'|'} {'}'}",

                out: "Characters: 97 291 32 123 124 125",
        },

        {
                in: "Integers: {1} {-2} {+42} {0777} {0x0a}",

                out: "Integers: 1 -2 42 511 10",
        },

        {
                in: "Floats: {.5} {-.5} {1.1} {-2.2} {+42.1} {1e10} {1.2e-3} {1.2e3} {-1.2e3}",

                out: "Floats: 0.5 -0.5 1.1 -2.2 42.1 1e+10 0.0012 1200 -1200",
        },

        // Method at top level
        {
                in: "ptrmethod={PointerMethod}\n",

                out: "ptrmethod=ptrmethod!\n",
        },

        {
                in: "valmethod={ValueMethod}\n",

                out: "valmethod=valmethod!\n",
        },

        // Section
        {
                in: "{.section Data }\n" +
                        "some text for the section\n" +
                        "{.end}\n",

                out: "some text for the section\n",
        },
        {
                in: "{.section Data }\n" +
                        "{Header}={Integer}\n" +
                        "{.end}\n",

                out: "Header=77\n",
        },
        {
                in: "{.section Pdata }\n" +
                        "{Header}={Integer}\n" +
                        "{.end}\n",

                out: "Header=77\n",
        },
        {
                in: "{.section Pdata }\n" +
                        "data present\n" +
                        "{.or}\n" +
                        "data not present\n" +
                        "{.end}\n",

                out: "data present\n",
        },
        {
                in: "{.section Empty }\n" +
                        "data present\n" +
                        "{.or}\n" +
                        "data not present\n" +
                        "{.end}\n",

                out: "data not present\n",
        },
        {
                in: "{.section Null }\n" +
                        "data present\n" +
                        "{.or}\n" +
                        "data not present\n" +
                        "{.end}\n",

                out: "data not present\n",
        },
        {
                in: "{.section Pdata }\n" +
                        "{Header}={Integer}\n" +
                        "{.section @ }\n" +
                        "{Header}={Integer}\n" +
                        "{.end}\n" +
                        "{.end}\n",

                out: "Header=77\n" +
                        "Header=77\n",
        },

        {
                in: "{.section Data}{.end} {Header}\n",

                out: " Header\n",
        },

        {
                in: "{.section Integer}{@}{.end}",

                out: "77",
        },

        // Repeated
        {
                in: "{.section Pdata }\n" +
                        "{.repeated section @ }\n" +
                        "{Item}={Value}\n" +
                        "{.end}\n" +
                        "{.end}\n",

                out: "ItemNumber1=ValueNumber1\n" +
                        "ItemNumber2=ValueNumber2\n",
        },
        {
                in: "{.section Pdata }\n" +
                        "{.repeated section @ }\n" +
                        "{Item}={Value}\n" +
                        "{.or}\n" +
                        "this should not appear\n" +
                        "{.end}\n" +
                        "{.end}\n",

                out: "ItemNumber1=ValueNumber1\n" +
                        "ItemNumber2=ValueNumber2\n",
        },
        {
                in: "{.section @ }\n" +
                        "{.repeated section Empty }\n" +
                        "{Item}={Value}\n" +
                        "{.or}\n" +
                        "this should appear: empty field\n" +
                        "{.end}\n" +
                        "{.end}\n",

                out: "this should appear: empty field\n",
        },
        {
                in: "{.repeated section Pdata }\n" +
                        "{Item}\n" +
                        "{.alternates with}\n" +
                        "is\nover\nmultiple\nlines\n" +
                        "{.end}\n",

                out: "ItemNumber1\n" +
                        "is\nover\nmultiple\nlines\n" +
                        "ItemNumber2\n",
        },
        {
                in: "{.repeated section Pdata }\n" +
                        "{Item}\n" +
                        "{.alternates with}\n" +
                        "is\nover\nmultiple\nlines\n" +
                        " {.end}\n",

                out: "ItemNumber1\n" +
                        "is\nover\nmultiple\nlines\n" +
                        "ItemNumber2\n",
        },
        {
                in: "{.section Pdata }\n" +
                        "{.repeated section @ }\n" +
                        "{Item}={Value}\n" +
                        "{.alternates with}DIVIDER\n" +
                        "{.or}\n" +
                        "this should not appear\n" +
                        "{.end}\n" +
                        "{.end}\n",

                out: "ItemNumber1=ValueNumber1\n" +
                        "DIVIDER\n" +
                        "ItemNumber2=ValueNumber2\n",
        },
        {
                in: "{.repeated section Vec }\n" +
                        "{@}\n" +
                        "{.end}\n",

                out: "elt1\n" +
                        "elt2\n",
        },
        // Same but with a space before {.end}: was a bug.
        {
                in: "{.repeated section Vec }\n" +
                        "{@} {.end}\n",

                out: "elt1 elt2 \n",
        },
        {
                in: "{.repeated section Integer}{.end}",

                err: "line 1: .repeated: cannot repeat Integer (type int)",
        },

        // Nested names
        {
                in: "{.section @ }\n" +
                        "{InnerT.Item}={InnerT.Value}\n" +
                        "{.end}",

                out: "ItemNumber1=ValueNumber1\n",
        },
        {
                in: "{.section @ }\n" +
                        "{InnerT.Item}={.section InnerT}{.section Value}{@}{.end}{.end}\n" +
                        "{.end}",

                out: "ItemNumber1=ValueNumber1\n",
        },

        {
                in: "{.section Emptystring}emptystring{.end}\n" +
                        "{.section Header}header{.end}\n",

                out: "\nheader\n",
        },

        {
                in: "{.section True}1{.or}2{.end}\n" +
                        "{.section False}3{.or}4{.end}\n",

                out: "1\n4\n",
        },

        // Maps

        {
                in: "{Mp.mapkey}\n",

                out: "Ahoy!\n",
        },
        {
                in: "{Innermap.Mp.innerkey}\n",

                out: "55\n",
        },
        {
                in: "{.section Innermap}{.section Mp}{innerkey}{.end}{.end}\n",

                out: "55\n",
        },
        {
                in: "{.section JSON}{.repeated section maps}{a}{b}{.end}{.end}\n",

                out: "1234\n",
        },
        {
                in: "{Stringmap.stringkey1}\n",

                out: "stringresult\n",
        },
        {
                in: "{.repeated section Stringmap}\n" +
                        "{@}\n" +
                        "{.end}",

                out: "stringresult\n" +
                        "stringresult\n",
        },
        {
                in: "{.repeated section Stringmap}\n" +
                        "\t{@}\n" +
                        "{.end}",

                out: "\tstringresult\n" +
                        "\tstringresult\n",
        },
        {
                in: "{*Ptrmap.stringkey1}\n",

                out: "pointedToString\n",
        },
        {
                in: "{.repeated section Ptrmap}\n" +
                        "{*@}\n" +
                        "{.end}",

                out: "pointedToString\n" +
                        "pointedToString\n",
        },

        // Interface values

        {
                in: "{Iface}",

                out: "[1 2 3]",
        },
        {
                in: "{.repeated section Iface}{@}{.alternates with} {.end}",

                out: "1 2 3",
        },
        {
                in: "{.section Iface}{@}{.end}",

                out: "[1 2 3]",
        },
        {
                in: "{.section Ifaceptr}{Item} {Value}{.end}",

                out: "Item Value",
        },
}

func TestAll(t *testing.T) {
        // Parse
        testAll(t, func(test *Test) (*Template, error) { return Parse(test.in, formatters) })
        // ParseFile
        f, err := ioutil.TempFile("", "template-test")
        if err != nil {
                t.Fatal(err)
        }
        defer func() {
                name := f.Name()
                f.Close()
                os.Remove(name)
        }()
        testAll(t, func(test *Test) (*Template, error) {
                err := ioutil.WriteFile(f.Name(), []byte(test.in), 0600)
                if err != nil {
                        t.Error("unexpected write error:", err)
                        return nil, err
                }
                return ParseFile(f.Name(), formatters)
        })
        // tmpl.ParseFile
        testAll(t, func(test *Test) (*Template, error) {
                err := ioutil.WriteFile(f.Name(), []byte(test.in), 0600)
                if err != nil {
                        t.Error("unexpected write error:", err)
                        return nil, err
                }
                tmpl := New(formatters)
                return tmpl, tmpl.ParseFile(f.Name())
        })
}

func testAll(t *testing.T, parseFunc func(*Test) (*Template, error)) {
        s := new(S)
        // initialized by hand for clarity.
        s.Header = "Header"
        s.HeaderPtr = &s.Header
        s.Integer = 77
        s.IntegerPtr = &s.Integer
        s.InnerT = t1
        s.Data = []T{t1, t2}
        s.Pdata = []*T{&t1, &t2}
        s.Empty = []*T{}
        s.Null = nil
        s.Vec = []interface{}{"elt1", "elt2"}
        s.True = true
        s.False = false
        s.Mp = make(map[string]string)
        s.Mp["mapkey"] = "Ahoy!"
        json.Unmarshal([]byte(`{"maps":[{"a":1,"b":2},{"a":3,"b":4}]}`), &s.JSON)
        s.Innermap.Mp = make(map[string]int)
        s.Innermap.Mp["innerkey"] = 55
        s.Stringmap = make(map[string]string)
        s.Stringmap["stringkey1"] = "stringresult" // the same value so repeated section is order-independent
        s.Stringmap["stringkey2"] = "stringresult"
        s.Ptrmap = make(map[string]*string)
        x := "pointedToString"
        s.Ptrmap["stringkey1"] = &x // the same value so repeated section is order-independent
        s.Ptrmap["stringkey2"] = &x
        s.Iface = []int{1, 2, 3}
        s.Ifaceptr = &T{"Item", "Value"}

        var buf bytes.Buffer
        for _, test := range tests {
                buf.Reset()
                tmpl, err := parseFunc(test)
                if err != nil {
                        t.Error("unexpected parse error: ", err)
                        continue
                }
                err = tmpl.Execute(&buf, s)
                if test.err == "" {
                        if err != nil {
                                t.Error("unexpected execute error:", err)
                        }
                } else {
                        if err == nil {
                                t.Errorf("expected execute error %q, got nil", test.err)
                        } else if err.Error() != test.err {
                                t.Errorf("expected execute error %q, got %q", test.err, err.Error())
                        }
                }
                if buf.String() != test.out {
                        t.Errorf("for %q: expected %q got %q", test.in, test.out, buf.String())
                }
        }
}

func TestMapDriverType(t *testing.T) {
        mp := map[string]string{"footer": "Ahoy!"}
        tmpl, err := Parse("template: {footer}", nil)
        if err != nil {
                t.Error("unexpected parse error:", err)
        }
        var b bytes.Buffer
        err = tmpl.Execute(&b, mp)
        if err != nil {
                t.Error("unexpected execute error:", err)
        }
        s := b.String()
        expect := "template: Ahoy!"
        if s != expect {
                t.Errorf("failed passing string as data: expected %q got %q", expect, s)
        }
}

func TestMapNoEntry(t *testing.T) {
        mp := make(map[string]int)
        tmpl, err := Parse("template: {notthere}!", nil)
        if err != nil {
                t.Error("unexpected parse error:", err)
        }
        var b bytes.Buffer
        err = tmpl.Execute(&b, mp)
        if err != nil {
                t.Error("unexpected execute error:", err)
        }
        s := b.String()
        expect := "template: 0!"
        if s != expect {
                t.Errorf("failed passing string as data: expected %q got %q", expect, s)
        }
}

func TestStringDriverType(t *testing.T) {
        tmpl, err := Parse("template: {@}", nil)
        if err != nil {
                t.Error("unexpected parse error:", err)
        }
        var b bytes.Buffer
        err = tmpl.Execute(&b, "hello")
        if err != nil {
                t.Error("unexpected execute error:", err)
        }
        s := b.String()
        expect := "template: hello"
        if s != expect {
                t.Errorf("failed passing string as data: expected %q got %q", expect, s)
        }
}

func TestTwice(t *testing.T) {
        tmpl, err := Parse("template: {@}", nil)
        if err != nil {
                t.Error("unexpected parse error:", err)
        }
        var b bytes.Buffer
        err = tmpl.Execute(&b, "hello")
        if err != nil {
                t.Error("unexpected parse error:", err)
        }
        s := b.String()
        expect := "template: hello"
        if s != expect {
                t.Errorf("failed passing string as data: expected %q got %q", expect, s)
        }
        err = tmpl.Execute(&b, "hello")
        if err != nil {
                t.Error("unexpected parse error:", err)
        }
        s = b.String()
        expect += expect
        if s != expect {
                t.Errorf("failed passing string as data: expected %q got %q", expect, s)
        }
}

func TestCustomDelims(t *testing.T) {
        // try various lengths.  zero should catch error.
        for i := 0; i < 7; i++ {
                for j := 0; j < 7; j++ {
                        tmpl := New(nil)
                        // first two chars deliberately the same to test equal left and right delims
                        ldelim := "$!#$%^&"[0:i]
                        rdelim := "$*&^%$!"[0:j]
                        tmpl.SetDelims(ldelim, rdelim)
                        // if braces, this would be template: {@}{.meta-left}{.meta-right}
                        text := "template: " +
                                ldelim + "@" + rdelim +
                                ldelim + ".meta-left" + rdelim +
                                ldelim + ".meta-right" + rdelim
                        err := tmpl.Parse(text)
                        if err != nil {
                                if i == 0 || j == 0 { // expected
                                        continue
                                }
                                t.Error("unexpected parse error:", err)
                        } else if i == 0 || j == 0 {
                                t.Errorf("expected parse error for empty delimiter: %d %d %q %q", i, j, ldelim, rdelim)
                                continue
                        }
                        var b bytes.Buffer
                        err = tmpl.Execute(&b, "hello")
                        s := b.String()
                        if s != "template: hello"+ldelim+rdelim {
                                t.Errorf("failed delim check(%q %q) %q got %q", ldelim, rdelim, text, s)
                        }
                }
        }
}

// Test that a variable evaluates to the field itself and does not further indirection
func TestVarIndirection(t *testing.T) {
        s := new(S)
        // initialized by hand for clarity.
        s.InnerPointerT = &t1

        var buf bytes.Buffer
        input := "{.section @}{InnerPointerT}{.end}"
        tmpl, err := Parse(input, nil)
        if err != nil {
                t.Fatal("unexpected parse error:", err)
        }
        err = tmpl.Execute(&buf, s)
        if err != nil {
                t.Fatal("unexpected execute error:", err)
        }
        expect := fmt.Sprintf("%v", &t1) // output should be hex address of t1
        if buf.String() != expect {
                t.Errorf("for %q: expected %q got %q", input, expect, buf.String())
        }
}

func TestHTMLFormatterWithByte(t *testing.T) {
        s := "Test string."
        b := []byte(s)
        var buf bytes.Buffer
        HTMLFormatter(&buf, "", b)
        bs := buf.String()
        if bs != s {
                t.Errorf("munged []byte, expected: %s got: %s", s, bs)
        }
}

type UF struct {
        I int
        s string
}

func TestReferenceToUnexported(t *testing.T) {
        u := &UF{3, "hello"}
        var buf bytes.Buffer
        input := "{.section @}{I}{s}{.end}"
        tmpl, err := Parse(input, nil)
        if err != nil {
                t.Fatal("unexpected parse error:", err)
        }
        err = tmpl.Execute(&buf, u)
        if err == nil {
                t.Fatal("expected execute error, got none")
        }
        if strings.Index(err.Error(), "not exported") < 0 {
                t.Fatal("expected unexported error; got", err)
        }
}

var formatterTests = []Test{
        {
                in: "{Header|uppercase}={Integer|+1}\n" +
                        "{Header|html}={Integer|str}\n",

                out: "HEADER=78\n" +
                        "Header=77\n",
        },

        {
                in: "{Header|uppercase}={Integer Header|multiword}\n" +
                        "{Header|html}={Header Integer|multiword}\n" +
                        "{Header|html}={Header Integer}\n",

                out: "HEADER=<77><Header>\n" +
                        "Header=<Header><77>\n" +
                        "Header=Header77\n",
        },
        {
                in: "{Raw}\n" +
                        "{Raw|html}\n",

                out: "a <&> b\n" +
                        "a &lt;&amp;&gt; b\n",
        },
        {
                in:  "{Bytes}",
                out: "hello",
        },
        {
                in:  "{Raw|uppercase|html|html}",
                out: "A &amp;lt;&amp;amp;&amp;gt; B",
        },
        {
                in:  "{Header Integer|multiword|html}",
                out: "&lt;Header&gt;&lt;77&gt;",
        },
        {
                in:  "{Integer|no_formatter|html}",
                err: `unknown formatter: "no_formatter"`,
        },
        {
                in:  "{Integer|||||}", // empty string is a valid formatter
                out: "77",
        },
        {
                in:  `{"%.02f 0x%02X" 1.1 10|printf}`,
                out: "1.10 0x0A",
        },
        {
                in:  `{""|}{""||}{""|printf}`, // Issue #1896.
                out: "",
        },
}

func TestFormatters(t *testing.T) {
        data := map[string]interface{}{
                "Header":  "Header",
                "Integer": 77,
                "Raw":     "a <&> b",
                "Bytes":   []byte("hello"),
        }
        for _, c := range formatterTests {
                tmpl, err := Parse(c.in, formatters)
                if err != nil {
                        if c.err == "" {
                                t.Error("unexpected parse error:", err)
                                continue
                        }
                        if strings.Index(err.Error(), c.err) < 0 {
                                t.Errorf("unexpected error: expected %q, got %q", c.err, err.Error())
                                continue
                        }
                } else {
                        if c.err != "" {
                                t.Errorf("For %q, expected error, got none.", c.in)
                                continue
                        }
                        var buf bytes.Buffer
                        err = tmpl.Execute(&buf, data)
                        if err != nil {
                                t.Error("unexpected Execute error: ", err)
                                continue
                        }
                        actual := buf.String()
                        if actual != c.out {
                                t.Errorf("for %q: expected %q but got %q.", c.in, c.out, actual)
                        }
                }
        }
}