// 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 xml
import (
"reflect"
"strconv"
"strings"
"testing"
"time"
)
type DriveType int
const (
HyperDrive DriveType = iota
ImprobabilityDrive
)
type Passenger struct {
Name []string `xml:"name"`
Weight float32 `xml:"weight"`
}
type Ship struct {
XMLName struct{} `xml:"spaceship"`
Name string `xml:"name,attr"`
Pilot string `xml:"pilot,attr"`
Drive DriveType `xml:"drive"`
Age uint `xml:"age"`
Passenger []*Passenger `xml:"passenger"`
secret string
}
type NamedType string
type Port struct {
XMLName struct{} `xml:"port"`
Type string `xml:"type,attr,omitempty"`
Comment string `xml:",comment"`
Number string `xml:",chardata"`
}
type Domain struct {
XMLName struct{} `xml:"domain"`
Country string `xml:",attr,omitempty"`
Name []byte `xml:",chardata"`
Comment []byte `xml:",comment"`
}
type Book struct {
XMLName struct{} `xml:"book"`
Title string `xml:",chardata"`
}
type SecretAgent struct {
XMLName struct{} `xml:"agent"`
Handle string `xml:"handle,attr"`
Identity string
Obfuscate string `xml:",innerxml"`
}
type NestedItems struct {
XMLName struct{} `xml:"result"`
Items []string `xml:">item"`
Item1 []string `xml:"Items>item1"`
}
type NestedOrder struct {
XMLName struct{} `xml:"result"`
Field1 string `xml:"parent>c"`
Field2 string `xml:"parent>b"`
Field3 string `xml:"parent>a"`
}
type MixedNested struct {
XMLName struct{} `xml:"result"`
A string `xml:"parent1>a"`
B string `xml:"b"`
C string `xml:"parent1>parent2>c"`
D string `xml:"parent1>d"`
}
type NilTest struct {
A interface{} `xml:"parent1>parent2>a"`
B interface{} `xml:"parent1>b"`
C interface{} `xml:"parent1>parent2>c"`
}
type Service struct {
XMLName struct{} `xml:"service"`
Domain *Domain `xml:"host>domain"`
Port *Port `xml:"host>port"`
Extra1 interface{}
Extra2 interface{} `xml:"host>extra2"`
}
var nilStruct *Ship
type EmbedA struct {
EmbedC
EmbedB EmbedB
FieldA string
}
type EmbedB struct {
FieldB string
EmbedC
}
type EmbedC struct {
FieldA1 string `xml:"FieldA>A1"`
FieldA2 string `xml:"FieldA>A2"`
FieldB string
FieldC string
}
type NameCasing struct {
XMLName struct{} `xml:"casing"`
Xy string
XY string
XyA string `xml:"Xy,attr"`
XYA string `xml:"XY,attr"`
}
type NamePrecedence struct {
XMLName Name `xml:"Parent"`
FromTag XMLNameWithoutTag `xml:"InTag"`
FromNameVal XMLNameWithoutTag
FromNameTag XMLNameWithTag
InFieldName string
}
type XMLNameWithTag struct {
XMLName Name `xml:"InXMLNameTag"`
Value string `xml:",chardata"`
}
type XMLNameWithoutTag struct {
XMLName Name
Value string `xml:",chardata"`
}
type NameInField struct {
Foo Name `xml:"ns foo"`
}
type AttrTest struct {
Int int `xml:",attr"`
Named int `xml:"int,attr"`
Float float64 `xml:",attr"`
Uint8 uint8 `xml:",attr"`
Bool bool `xml:",attr"`
Str string `xml:",attr"`
Bytes []byte `xml:",attr"`
}
type OmitAttrTest struct {
Int int `xml:",attr,omitempty"`
Named int `xml:"int,attr,omitempty"`
Float float64 `xml:",attr,omitempty"`
Uint8 uint8 `xml:",attr,omitempty"`
Bool bool `xml:",attr,omitempty"`
Str string `xml:",attr,omitempty"`
Bytes []byte `xml:",attr,omitempty"`
}
type OmitFieldTest struct {
Int int `xml:",omitempty"`
Named int `xml:"int,omitempty"`
Float float64 `xml:",omitempty"`
Uint8 uint8 `xml:",omitempty"`
Bool bool `xml:",omitempty"`
Str string `xml:",omitempty"`
Bytes []byte `xml:",omitempty"`
Ptr *PresenceTest `xml:",omitempty"`
}
type AnyTest struct {
XMLName struct{} `xml:"a"`
Nested string `xml:"nested>value"`
AnyField AnyHolder `xml:",any"`
}
type AnyHolder struct {
XMLName Name
XML string `xml:",innerxml"`
}
type RecurseA struct {
A string
B *RecurseB
}
type RecurseB struct {
A *RecurseA
B string
}
type PresenceTest struct {
Exists *struct{}
}
type IgnoreTest struct {
PublicSecret string `xml:"-"`
}
type MyBytes []byte
type Data struct {
Bytes []byte
Attr []byte `xml:",attr"`
Custom MyBytes
}
type Plain struct {
V interface{}
}
// Unless explicitly stated as such (or *Plain), all of the
// tests below are two-way tests. When introducing new tests,
// please try to make them two-way as well to ensure that
// marshalling and unmarshalling are as symmetrical as feasible.
var marshalTests = []struct {
Value interface{}
ExpectXML string
MarshalOnly bool
UnmarshalOnly bool
}{
// Test nil marshals to nothing
{Value: nil, ExpectXML: ``, MarshalOnly: true},
{Value: nilStruct, ExpectXML: ``, MarshalOnly: true},
// Test value types
{Value: &Plain{true}, ExpectXML: `true`},
{Value: &Plain{false}, ExpectXML: `false`},
{Value: &Plain{int(42)}, ExpectXML: `42`},
{Value: &Plain{int8(42)}, ExpectXML: `42`},
{Value: &Plain{int16(42)}, ExpectXML: `42`},
{Value: &Plain{int32(42)}, ExpectXML: `42`},
{Value: &Plain{uint(42)}, ExpectXML: `42`},
{Value: &Plain{uint8(42)}, ExpectXML: `42`},
{Value: &Plain{uint16(42)}, ExpectXML: `42`},
{Value: &Plain{uint32(42)}, ExpectXML: `42`},
{Value: &Plain{float32(1.25)}, ExpectXML: `1.25`},
{Value: &Plain{float64(1.25)}, ExpectXML: `1.25`},
{Value: &Plain{uintptr(0xFFDD)}, ExpectXML: `65501`},
{Value: &Plain{"gopher"}, ExpectXML: `gopher`},
{Value: &Plain{[]byte("gopher")}, ExpectXML: `gopher`},
{Value: &Plain{">"}, ExpectXML: `</>`},
{Value: &Plain{[]byte(">")}, ExpectXML: `</>`},
{Value: &Plain{[3]byte{'<', '/', '>'}}, ExpectXML: `</>`},
{Value: &Plain{NamedType("potato")}, ExpectXML: `potato`},
{Value: &Plain{[]int{1, 2, 3}}, ExpectXML: `123`},
{Value: &Plain{[3]int{1, 2, 3}}, ExpectXML: `123`},
// Test time.
{
Value: &Plain{time.Unix(1e9, 123456789).UTC()},
ExpectXML: `2001-09-09T01:46:40.123456789Z`,
},
// A pointer to struct{} may be used to test for an element's presence.
{
Value: &PresenceTest{new(struct{})},
ExpectXML: ``,
},
{
Value: &PresenceTest{},
ExpectXML: ``,
},
// A pointer to struct{} may be used to test for an element's presence.
{
Value: &PresenceTest{new(struct{})},
ExpectXML: ``,
},
{
Value: &PresenceTest{},
ExpectXML: ``,
},
// A []byte field is only nil if the element was not found.
{
Value: &Data{},
ExpectXML: ``,
UnmarshalOnly: true,
},
{
Value: &Data{Bytes: []byte{}, Custom: MyBytes{}, Attr: []byte{}},
ExpectXML: ``,
UnmarshalOnly: true,
},
// Check that []byte works, including named []byte types.
{
Value: &Data{Bytes: []byte("ab"), Custom: MyBytes("cd"), Attr: []byte{'v'}},
ExpectXML: `abcd`,
},
// Test innerxml
{
Value: &SecretAgent{
Handle: "007",
Identity: "James Bond",
Obfuscate: "",
},
ExpectXML: `James Bond`,
MarshalOnly: true,
},
{
Value: &SecretAgent{
Handle: "007",
Identity: "James Bond",
Obfuscate: "James Bond",
},
ExpectXML: `James Bond`,
UnmarshalOnly: true,
},
// Test structs
{Value: &Port{Type: "ssl", Number: "443"}, ExpectXML: `443`},
{Value: &Port{Number: "443"}, ExpectXML: `443`},
{Value: &Port{Type: ""}, ExpectXML: ``},
{Value: &Port{Number: "443", Comment: "https"}, ExpectXML: `443`},
{Value: &Port{Number: "443", Comment: "add space-"}, ExpectXML: `443`, MarshalOnly: true},
{Value: &Domain{Name: []byte("google.com&friends")}, ExpectXML: `google.com&friends`},
{Value: &Domain{Name: []byte("google.com"), Comment: []byte(" &friends ")}, ExpectXML: `google.com`},
{Value: &Book{Title: "Pride & Prejudice"}, ExpectXML: `Pride & Prejudice`},
{Value: atomValue, ExpectXML: atomXml},
{
Value: &Ship{
Name: "Heart of Gold",
Pilot: "Computer",
Age: 1,
Drive: ImprobabilityDrive,
Passenger: []*Passenger{
{
Name: []string{"Zaphod", "Beeblebrox"},
Weight: 7.25,
},
{
Name: []string{"Trisha", "McMillen"},
Weight: 5.5,
},
{
Name: []string{"Ford", "Prefect"},
Weight: 7,
},
{
Name: []string{"Arthur", "Dent"},
Weight: 6.75,
},
},
},
ExpectXML: `` +
`` + strconv.Itoa(int(ImprobabilityDrive)) + `` +
`1` +
`` +
`Zaphod` +
`Beeblebrox` +
`7.25` +
`` +
`` +
`Trisha` +
`McMillen` +
`5.5` +
`` +
`` +
`Ford` +
`Prefect` +
`7` +
`` +
`` +
`Arthur` +
`Dent` +
`6.75` +
`` +
``,
},
// Test a>b
{
Value: &NestedItems{Items: nil, Item1: nil},
ExpectXML: `` +
`` +
`` +
``,
},
{
Value: &NestedItems{Items: []string{}, Item1: []string{}},
ExpectXML: `` +
`` +
`` +
``,
MarshalOnly: true,
},
{
Value: &NestedItems{Items: nil, Item1: []string{"A"}},
ExpectXML: `` +
`` +
`A` +
`` +
``,
},
{
Value: &NestedItems{Items: []string{"A", "B"}, Item1: nil},
ExpectXML: `` +
`` +
`- A
` +
`- B
` +
`` +
``,
},
{
Value: &NestedItems{Items: []string{"A", "B"}, Item1: []string{"C"}},
ExpectXML: `` +
`` +
`- A
` +
`- B
` +
`C` +
`` +
``,
},
{
Value: &NestedOrder{Field1: "C", Field2: "B", Field3: "A"},
ExpectXML: `` +
`` +
`C` +
`B` +
`A` +
`` +
``,
},
{
Value: &NilTest{A: "A", B: nil, C: "C"},
ExpectXML: `` +
`` +
`A` +
`C` +
`` +
``,
MarshalOnly: true, // Uses interface{}
},
{
Value: &MixedNested{A: "A", B: "B", C: "C", D: "D"},
ExpectXML: `` +
`A` +
`B` +
`` +
`C` +
`D` +
`` +
``,
},
{
Value: &Service{Port: &Port{Number: "80"}},
ExpectXML: `80`,
},
{
Value: &Service{},
ExpectXML: ``,
},
{
Value: &Service{Port: &Port{Number: "80"}, Extra1: "A", Extra2: "B"},
ExpectXML: `` +
`80` +
`A` +
`B` +
``,
MarshalOnly: true,
},
{
Value: &Service{Port: &Port{Number: "80"}, Extra2: "example"},
ExpectXML: `` +
`80` +
`example` +
``,
MarshalOnly: true,
},
// Test struct embedding
{
Value: &EmbedA{
EmbedC: EmbedC{
FieldA1: "", // Shadowed by A.A
FieldA2: "", // Shadowed by A.A
FieldB: "A.C.B",
FieldC: "A.C.C",
},
EmbedB: EmbedB{
FieldB: "A.B.B",
EmbedC: EmbedC{
FieldA1: "A.B.C.A1",
FieldA2: "A.B.C.A2",
FieldB: "", // Shadowed by A.B.B
FieldC: "A.B.C.C",
},
},
FieldA: "A.A",
},
ExpectXML: `` +
`A.C.B` +
`A.C.C` +
`` +
`A.B.B` +
`` +
`A.B.C.A1` +
`A.B.C.A2` +
`` +
`A.B.C.C` +
`` +
`A.A` +
``,
},
// Test that name casing matters
{
Value: &NameCasing{Xy: "mixed", XY: "upper", XyA: "mixedA", XYA: "upperA"},
ExpectXML: `mixedupper`,
},
// Test the order in which the XML element name is chosen
{
Value: &NamePrecedence{
FromTag: XMLNameWithoutTag{Value: "A"},
FromNameVal: XMLNameWithoutTag{XMLName: Name{Local: "InXMLName"}, Value: "B"},
FromNameTag: XMLNameWithTag{Value: "C"},
InFieldName: "D",
},
ExpectXML: `` +
`A` +
`B` +
`C` +
`D` +
``,
MarshalOnly: true,
},
{
Value: &NamePrecedence{
XMLName: Name{Local: "Parent"},
FromTag: XMLNameWithoutTag{XMLName: Name{Local: "InTag"}, Value: "A"},
FromNameVal: XMLNameWithoutTag{XMLName: Name{Local: "FromNameVal"}, Value: "B"},
FromNameTag: XMLNameWithTag{XMLName: Name{Local: "InXMLNameTag"}, Value: "C"},
InFieldName: "D",
},
ExpectXML: `` +
`A` +
`B` +
`C` +
`D` +
``,
UnmarshalOnly: true,
},
// xml.Name works in a plain field as well.
{
Value: &NameInField{Name{Space: "ns", Local: "foo"}},
ExpectXML: ``,
},
{
Value: &NameInField{Name{Space: "ns", Local: "foo"}},
ExpectXML: ``,
UnmarshalOnly: true,
},
// Marshaling zero xml.Name uses the tag or field name.
{
Value: &NameInField{},
ExpectXML: ``,
MarshalOnly: true,
},
// Test attributes
{
Value: &AttrTest{
Int: 8,
Named: 9,
Float: 23.5,
Uint8: 255,
Bool: true,
Str: "str",
Bytes: []byte("byt"),
},
ExpectXML: ``,
},
{
Value: &AttrTest{Bytes: []byte{}},
ExpectXML: ``,
},
{
Value: &OmitAttrTest{
Int: 8,
Named: 9,
Float: 23.5,
Uint8: 255,
Bool: true,
Str: "str",
Bytes: []byte("byt"),
},
ExpectXML: ``,
},
{
Value: &OmitAttrTest{},
ExpectXML: ``,
},
// omitempty on fields
{
Value: &OmitFieldTest{
Int: 8,
Named: 9,
Float: 23.5,
Uint8: 255,
Bool: true,
Str: "str",
Bytes: []byte("byt"),
Ptr: &PresenceTest{},
},
ExpectXML: `` +
`8` +
`9` +
`23.5` +
`255` +
`true` +
`str` +
`byt` +
`` +
``,
},
{
Value: &OmitFieldTest{},
ExpectXML: ``,
},
// Test ",any"
{
ExpectXML: `knownunknown`,
Value: &AnyTest{
Nested: "known",
AnyField: AnyHolder{
XMLName: Name{Local: "other"},
XML: "unknown",
},
},
UnmarshalOnly: true,
},
{
Value: &AnyTest{Nested: "known", AnyField: AnyHolder{XML: ""}},
ExpectXML: `known`,
MarshalOnly: true,
},
// Test recursive types.
{
Value: &RecurseA{
A: "a1",
B: &RecurseB{
A: &RecurseA{"a2", nil},
B: "b1",
},
},
ExpectXML: `a1a2b1`,
},
// Test ignoring fields via "-" tag
{
ExpectXML: ``,
Value: &IgnoreTest{},
},
{
ExpectXML: ``,
Value: &IgnoreTest{PublicSecret: "can't tell"},
MarshalOnly: true,
},
{
ExpectXML: `ignore me`,
Value: &IgnoreTest{},
UnmarshalOnly: true,
},
}
func TestMarshal(t *testing.T) {
for idx, test := range marshalTests {
if test.UnmarshalOnly {
continue
}
data, err := Marshal(test.Value)
if err != nil {
t.Errorf("#%d: Error: %s", idx, err)
continue
}
if got, want := string(data), test.ExpectXML; got != want {
if strings.Contains(want, "\n") {
t.Errorf("#%d: marshal(%#v):\nHAVE:\n%s\nWANT:\n%s", idx, test.Value, got, want)
} else {
t.Errorf("#%d: marshal(%#v):\nhave %#q\nwant %#q", idx, test.Value, got, want)
}
}
}
}
var marshalErrorTests = []struct {
Value interface{}
Err string
Kind reflect.Kind
}{
{
Value: make(chan bool),
Err: "xml: unsupported type: chan bool",
Kind: reflect.Chan,
},
{
Value: map[string]string{
"question": "What do you get when you multiply six by nine?",
"answer": "42",
},
Err: "xml: unsupported type: map[string]string",
Kind: reflect.Map,
},
{
Value: map[*Ship]bool{nil: false},
Err: "xml: unsupported type: map[*xml.Ship]bool",
Kind: reflect.Map,
},
{
Value: &Domain{Comment: []byte("f--bar")},
Err: `xml: comments must not contain "--"`,
},
}
func TestMarshalErrors(t *testing.T) {
for idx, test := range marshalErrorTests {
_, err := Marshal(test.Value)
if err == nil || err.Error() != test.Err {
t.Errorf("#%d: marshal(%#v) = [error] %v, want %v", idx, test.Value, err, test.Err)
}
if test.Kind != reflect.Invalid {
if kind := err.(*UnsupportedTypeError).Type.Kind(); kind != test.Kind {
t.Errorf("#%d: marshal(%#v) = [error kind] %s, want %s", idx, test.Value, kind, test.Kind)
}
}
}
}
// Do invertibility testing on the various structures that we test
func TestUnmarshal(t *testing.T) {
for i, test := range marshalTests {
if test.MarshalOnly {
continue
}
if _, ok := test.Value.(*Plain); ok {
continue
}
vt := reflect.TypeOf(test.Value)
dest := reflect.New(vt.Elem()).Interface()
err := Unmarshal([]byte(test.ExpectXML), dest)
switch fix := dest.(type) {
case *Feed:
fix.Author.InnerXML = ""
for i := range fix.Entry {
fix.Entry[i].Author.InnerXML = ""
}
}
if err != nil {
t.Errorf("#%d: unexpected error: %#v", i, err)
} else if got, want := dest, test.Value; !reflect.DeepEqual(got, want) {
t.Errorf("#%d: unmarshal(%q):\nhave %#v\nwant %#v", i, test.ExpectXML, got, want)
}
}
}
func BenchmarkMarshal(b *testing.B) {
for i := 0; i < b.N; i++ {
Marshal(atomValue)
}
}
func BenchmarkUnmarshal(b *testing.B) {
xml := []byte(atomXml)
for i := 0; i < b.N; i++ {
Unmarshal(xml, &Feed{})
}
}