mirror of git://gcc.gnu.org/git/gcc.git
2453 lines
63 KiB
Go
2453 lines
63 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 xml
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"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 Event struct {
|
|
XMLName struct{} `xml:"event"`
|
|
Year int `xml:",chardata"`
|
|
}
|
|
|
|
type Movie struct {
|
|
XMLName struct{} `xml:"movie"`
|
|
Length uint `xml:",chardata"`
|
|
}
|
|
|
|
type Pi struct {
|
|
XMLName struct{} `xml:"pi"`
|
|
Approximation float32 `xml:",chardata"`
|
|
}
|
|
|
|
type Universe struct {
|
|
XMLName struct{} `xml:"universe"`
|
|
Visible float64 `xml:",chardata"`
|
|
}
|
|
|
|
type Particle struct {
|
|
XMLName struct{} `xml:"particle"`
|
|
HasMass bool `xml:",chardata"`
|
|
}
|
|
|
|
type Departure struct {
|
|
XMLName struct{} `xml:"departure"`
|
|
When time.Time `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
|
|
embedD
|
|
}
|
|
|
|
type EmbedB struct {
|
|
FieldB string
|
|
*EmbedC
|
|
}
|
|
|
|
type EmbedC struct {
|
|
FieldA1 string `xml:"FieldA>A1"`
|
|
FieldA2 string `xml:"FieldA>A2"`
|
|
FieldB string
|
|
FieldC string
|
|
}
|
|
|
|
type embedD struct {
|
|
fieldD string
|
|
FieldE string // Promoted and visible when embedD is embedded.
|
|
}
|
|
|
|
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 AttrsTest struct {
|
|
Attrs []Attr `xml:",any,attr"`
|
|
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"`
|
|
PStr *string `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"`
|
|
PStr *string `xml:",omitempty"`
|
|
Ptr *PresenceTest `xml:",omitempty"`
|
|
}
|
|
|
|
type AnyTest struct {
|
|
XMLName struct{} `xml:"a"`
|
|
Nested string `xml:"nested>value"`
|
|
AnyField AnyHolder `xml:",any"`
|
|
}
|
|
|
|
type AnyOmitTest struct {
|
|
XMLName struct{} `xml:"a"`
|
|
Nested string `xml:"nested>value"`
|
|
AnyField *AnyHolder `xml:",any,omitempty"`
|
|
}
|
|
|
|
type AnySliceTest 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{}
|
|
}
|
|
|
|
type MyInt int
|
|
|
|
type EmbedInt struct {
|
|
MyInt
|
|
}
|
|
|
|
type Strings struct {
|
|
X []string `xml:"A>B,omitempty"`
|
|
}
|
|
|
|
type PointerFieldsTest struct {
|
|
XMLName Name `xml:"dummy"`
|
|
Name *string `xml:"name,attr"`
|
|
Age *uint `xml:"age,attr"`
|
|
Empty *string `xml:"empty,attr"`
|
|
Contents *string `xml:",chardata"`
|
|
}
|
|
|
|
type ChardataEmptyTest struct {
|
|
XMLName Name `xml:"test"`
|
|
Contents *string `xml:",chardata"`
|
|
}
|
|
|
|
type MyMarshalerTest struct {
|
|
}
|
|
|
|
var _ Marshaler = (*MyMarshalerTest)(nil)
|
|
|
|
func (m *MyMarshalerTest) MarshalXML(e *Encoder, start StartElement) error {
|
|
e.EncodeToken(start)
|
|
e.EncodeToken(CharData([]byte("hello world")))
|
|
e.EncodeToken(EndElement{start.Name})
|
|
return nil
|
|
}
|
|
|
|
type MyMarshalerAttrTest struct {
|
|
}
|
|
|
|
var _ MarshalerAttr = (*MyMarshalerAttrTest)(nil)
|
|
|
|
func (m *MyMarshalerAttrTest) MarshalXMLAttr(name Name) (Attr, error) {
|
|
return Attr{name, "hello world"}, nil
|
|
}
|
|
|
|
func (m *MyMarshalerAttrTest) UnmarshalXMLAttr(attr Attr) error {
|
|
return nil
|
|
}
|
|
|
|
type MarshalerStruct struct {
|
|
Foo MyMarshalerAttrTest `xml:",attr"`
|
|
}
|
|
|
|
type InnerStruct struct {
|
|
XMLName Name `xml:"testns outer"`
|
|
}
|
|
|
|
type OuterStruct struct {
|
|
InnerStruct
|
|
IntAttr int `xml:"int,attr"`
|
|
}
|
|
|
|
type OuterNamedStruct struct {
|
|
InnerStruct
|
|
XMLName Name `xml:"outerns test"`
|
|
IntAttr int `xml:"int,attr"`
|
|
}
|
|
|
|
type OuterNamedOrderedStruct struct {
|
|
XMLName Name `xml:"outerns test"`
|
|
InnerStruct
|
|
IntAttr int `xml:"int,attr"`
|
|
}
|
|
|
|
type OuterOuterStruct struct {
|
|
OuterStruct
|
|
}
|
|
|
|
type NestedAndChardata struct {
|
|
AB []string `xml:"A>B"`
|
|
Chardata string `xml:",chardata"`
|
|
}
|
|
|
|
type NestedAndComment struct {
|
|
AB []string `xml:"A>B"`
|
|
Comment string `xml:",comment"`
|
|
}
|
|
|
|
type CDataTest struct {
|
|
Chardata string `xml:",cdata"`
|
|
}
|
|
|
|
type NestedAndCData struct {
|
|
AB []string `xml:"A>B"`
|
|
CDATA string `xml:",cdata"`
|
|
}
|
|
|
|
func ifaceptr(x interface{}) interface{} {
|
|
return &x
|
|
}
|
|
|
|
func stringptr(x string) *string {
|
|
return &x
|
|
}
|
|
|
|
type T1 struct{}
|
|
type T2 struct{}
|
|
type T3 struct{}
|
|
|
|
type IndirComment struct {
|
|
T1 T1
|
|
Comment *string `xml:",comment"`
|
|
T2 T2
|
|
}
|
|
|
|
type DirectComment struct {
|
|
T1 T1
|
|
Comment string `xml:",comment"`
|
|
T2 T2
|
|
}
|
|
|
|
type IfaceComment struct {
|
|
T1 T1
|
|
Comment interface{} `xml:",comment"`
|
|
T2 T2
|
|
}
|
|
|
|
type IndirChardata struct {
|
|
T1 T1
|
|
Chardata *string `xml:",chardata"`
|
|
T2 T2
|
|
}
|
|
|
|
type DirectChardata struct {
|
|
T1 T1
|
|
Chardata string `xml:",chardata"`
|
|
T2 T2
|
|
}
|
|
|
|
type IfaceChardata struct {
|
|
T1 T1
|
|
Chardata interface{} `xml:",chardata"`
|
|
T2 T2
|
|
}
|
|
|
|
type IndirCDATA struct {
|
|
T1 T1
|
|
CDATA *string `xml:",cdata"`
|
|
T2 T2
|
|
}
|
|
|
|
type DirectCDATA struct {
|
|
T1 T1
|
|
CDATA string `xml:",cdata"`
|
|
T2 T2
|
|
}
|
|
|
|
type IfaceCDATA struct {
|
|
T1 T1
|
|
CDATA interface{} `xml:",cdata"`
|
|
T2 T2
|
|
}
|
|
|
|
type IndirInnerXML struct {
|
|
T1 T1
|
|
InnerXML *string `xml:",innerxml"`
|
|
T2 T2
|
|
}
|
|
|
|
type DirectInnerXML struct {
|
|
T1 T1
|
|
InnerXML string `xml:",innerxml"`
|
|
T2 T2
|
|
}
|
|
|
|
type IfaceInnerXML struct {
|
|
T1 T1
|
|
InnerXML interface{} `xml:",innerxml"`
|
|
T2 T2
|
|
}
|
|
|
|
type IndirElement struct {
|
|
T1 T1
|
|
Element *string
|
|
T2 T2
|
|
}
|
|
|
|
type DirectElement struct {
|
|
T1 T1
|
|
Element string
|
|
T2 T2
|
|
}
|
|
|
|
type IfaceElement struct {
|
|
T1 T1
|
|
Element interface{}
|
|
T2 T2
|
|
}
|
|
|
|
type IndirOmitEmpty struct {
|
|
T1 T1
|
|
OmitEmpty *string `xml:",omitempty"`
|
|
T2 T2
|
|
}
|
|
|
|
type DirectOmitEmpty struct {
|
|
T1 T1
|
|
OmitEmpty string `xml:",omitempty"`
|
|
T2 T2
|
|
}
|
|
|
|
type IfaceOmitEmpty struct {
|
|
T1 T1
|
|
OmitEmpty interface{} `xml:",omitempty"`
|
|
T2 T2
|
|
}
|
|
|
|
type IndirAny struct {
|
|
T1 T1
|
|
Any *string `xml:",any"`
|
|
T2 T2
|
|
}
|
|
|
|
type DirectAny struct {
|
|
T1 T1
|
|
Any string `xml:",any"`
|
|
T2 T2
|
|
}
|
|
|
|
type IfaceAny struct {
|
|
T1 T1
|
|
Any interface{} `xml:",any"`
|
|
T2 T2
|
|
}
|
|
|
|
var (
|
|
nameAttr = "Sarah"
|
|
ageAttr = uint(12)
|
|
contentsAttr = "lorem ipsum"
|
|
empty = ""
|
|
)
|
|
|
|
// 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
|
|
// marshaling and unmarshaling are as symmetrical as feasible.
|
|
var marshalTests = []struct {
|
|
Value interface{}
|
|
ExpectXML string
|
|
MarshalOnly bool
|
|
MarshalError string
|
|
UnmarshalOnly bool
|
|
UnmarshalError string
|
|
}{
|
|
// Test nil marshals to nothing
|
|
{Value: nil, ExpectXML: ``, MarshalOnly: true},
|
|
{Value: nilStruct, ExpectXML: ``, MarshalOnly: true},
|
|
|
|
// Test value types
|
|
{Value: &Plain{true}, ExpectXML: `<Plain><V>true</V></Plain>`},
|
|
{Value: &Plain{false}, ExpectXML: `<Plain><V>false</V></Plain>`},
|
|
{Value: &Plain{int(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
|
|
{Value: &Plain{int8(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
|
|
{Value: &Plain{int16(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
|
|
{Value: &Plain{int32(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
|
|
{Value: &Plain{uint(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
|
|
{Value: &Plain{uint8(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
|
|
{Value: &Plain{uint16(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
|
|
{Value: &Plain{uint32(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
|
|
{Value: &Plain{float32(1.25)}, ExpectXML: `<Plain><V>1.25</V></Plain>`},
|
|
{Value: &Plain{float64(1.25)}, ExpectXML: `<Plain><V>1.25</V></Plain>`},
|
|
{Value: &Plain{uintptr(0xFFDD)}, ExpectXML: `<Plain><V>65501</V></Plain>`},
|
|
{Value: &Plain{"gopher"}, ExpectXML: `<Plain><V>gopher</V></Plain>`},
|
|
{Value: &Plain{[]byte("gopher")}, ExpectXML: `<Plain><V>gopher</V></Plain>`},
|
|
{Value: &Plain{"</>"}, ExpectXML: `<Plain><V></></V></Plain>`},
|
|
{Value: &Plain{[]byte("</>")}, ExpectXML: `<Plain><V></></V></Plain>`},
|
|
{Value: &Plain{[3]byte{'<', '/', '>'}}, ExpectXML: `<Plain><V></></V></Plain>`},
|
|
{Value: &Plain{NamedType("potato")}, ExpectXML: `<Plain><V>potato</V></Plain>`},
|
|
{Value: &Plain{[]int{1, 2, 3}}, ExpectXML: `<Plain><V>1</V><V>2</V><V>3</V></Plain>`},
|
|
{Value: &Plain{[3]int{1, 2, 3}}, ExpectXML: `<Plain><V>1</V><V>2</V><V>3</V></Plain>`},
|
|
{Value: ifaceptr(true), MarshalOnly: true, ExpectXML: `<bool>true</bool>`},
|
|
|
|
// Test time.
|
|
{
|
|
Value: &Plain{time.Unix(1e9, 123456789).UTC()},
|
|
ExpectXML: `<Plain><V>2001-09-09T01:46:40.123456789Z</V></Plain>`,
|
|
},
|
|
|
|
// A pointer to struct{} may be used to test for an element's presence.
|
|
{
|
|
Value: &PresenceTest{new(struct{})},
|
|
ExpectXML: `<PresenceTest><Exists></Exists></PresenceTest>`,
|
|
},
|
|
{
|
|
Value: &PresenceTest{},
|
|
ExpectXML: `<PresenceTest></PresenceTest>`,
|
|
},
|
|
|
|
// A []byte field is only nil if the element was not found.
|
|
{
|
|
Value: &Data{},
|
|
ExpectXML: `<Data></Data>`,
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
Value: &Data{Bytes: []byte{}, Custom: MyBytes{}, Attr: []byte{}},
|
|
ExpectXML: `<Data Attr=""><Bytes></Bytes><Custom></Custom></Data>`,
|
|
UnmarshalOnly: true,
|
|
},
|
|
|
|
// Check that []byte works, including named []byte types.
|
|
{
|
|
Value: &Data{Bytes: []byte("ab"), Custom: MyBytes("cd"), Attr: []byte{'v'}},
|
|
ExpectXML: `<Data Attr="v"><Bytes>ab</Bytes><Custom>cd</Custom></Data>`,
|
|
},
|
|
|
|
// Test innerxml
|
|
{
|
|
Value: &SecretAgent{
|
|
Handle: "007",
|
|
Identity: "James Bond",
|
|
Obfuscate: "<redacted/>",
|
|
},
|
|
ExpectXML: `<agent handle="007"><Identity>James Bond</Identity><redacted/></agent>`,
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
Value: &SecretAgent{
|
|
Handle: "007",
|
|
Identity: "James Bond",
|
|
Obfuscate: "<Identity>James Bond</Identity><redacted/>",
|
|
},
|
|
ExpectXML: `<agent handle="007"><Identity>James Bond</Identity><redacted/></agent>`,
|
|
UnmarshalOnly: true,
|
|
},
|
|
|
|
// Test structs
|
|
{Value: &Port{Type: "ssl", Number: "443"}, ExpectXML: `<port type="ssl">443</port>`},
|
|
{Value: &Port{Number: "443"}, ExpectXML: `<port>443</port>`},
|
|
{Value: &Port{Type: "<unix>"}, ExpectXML: `<port type="<unix>"></port>`},
|
|
{Value: &Port{Number: "443", Comment: "https"}, ExpectXML: `<port><!--https-->443</port>`},
|
|
{Value: &Port{Number: "443", Comment: "add space-"}, ExpectXML: `<port><!--add space- -->443</port>`, MarshalOnly: true},
|
|
{Value: &Domain{Name: []byte("google.com&friends")}, ExpectXML: `<domain>google.com&friends</domain>`},
|
|
{Value: &Domain{Name: []byte("google.com"), Comment: []byte(" &friends ")}, ExpectXML: `<domain>google.com<!-- &friends --></domain>`},
|
|
{Value: &Book{Title: "Pride & Prejudice"}, ExpectXML: `<book>Pride & Prejudice</book>`},
|
|
{Value: &Event{Year: -3114}, ExpectXML: `<event>-3114</event>`},
|
|
{Value: &Movie{Length: 13440}, ExpectXML: `<movie>13440</movie>`},
|
|
{Value: &Pi{Approximation: 3.14159265}, ExpectXML: `<pi>3.1415927</pi>`},
|
|
{Value: &Universe{Visible: 9.3e13}, ExpectXML: `<universe>9.3e+13</universe>`},
|
|
{Value: &Particle{HasMass: true}, ExpectXML: `<particle>true</particle>`},
|
|
{Value: &Departure{When: ParseTime("2013-01-09T00:15:00-09:00")}, ExpectXML: `<departure>2013-01-09T00:15:00-09:00</departure>`},
|
|
{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: `<spaceship name="Heart of Gold" pilot="Computer">` +
|
|
`<drive>` + strconv.Itoa(int(ImprobabilityDrive)) + `</drive>` +
|
|
`<age>1</age>` +
|
|
`<passenger>` +
|
|
`<name>Zaphod</name>` +
|
|
`<name>Beeblebrox</name>` +
|
|
`<weight>7.25</weight>` +
|
|
`</passenger>` +
|
|
`<passenger>` +
|
|
`<name>Trisha</name>` +
|
|
`<name>McMillen</name>` +
|
|
`<weight>5.5</weight>` +
|
|
`</passenger>` +
|
|
`<passenger>` +
|
|
`<name>Ford</name>` +
|
|
`<name>Prefect</name>` +
|
|
`<weight>7</weight>` +
|
|
`</passenger>` +
|
|
`<passenger>` +
|
|
`<name>Arthur</name>` +
|
|
`<name>Dent</name>` +
|
|
`<weight>6.75</weight>` +
|
|
`</passenger>` +
|
|
`</spaceship>`,
|
|
},
|
|
|
|
// Test a>b
|
|
{
|
|
Value: &NestedItems{Items: nil, Item1: nil},
|
|
ExpectXML: `<result>` +
|
|
`<Items>` +
|
|
`</Items>` +
|
|
`</result>`,
|
|
},
|
|
{
|
|
Value: &NestedItems{Items: []string{}, Item1: []string{}},
|
|
ExpectXML: `<result>` +
|
|
`<Items>` +
|
|
`</Items>` +
|
|
`</result>`,
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
Value: &NestedItems{Items: nil, Item1: []string{"A"}},
|
|
ExpectXML: `<result>` +
|
|
`<Items>` +
|
|
`<item1>A</item1>` +
|
|
`</Items>` +
|
|
`</result>`,
|
|
},
|
|
{
|
|
Value: &NestedItems{Items: []string{"A", "B"}, Item1: nil},
|
|
ExpectXML: `<result>` +
|
|
`<Items>` +
|
|
`<item>A</item>` +
|
|
`<item>B</item>` +
|
|
`</Items>` +
|
|
`</result>`,
|
|
},
|
|
{
|
|
Value: &NestedItems{Items: []string{"A", "B"}, Item1: []string{"C"}},
|
|
ExpectXML: `<result>` +
|
|
`<Items>` +
|
|
`<item>A</item>` +
|
|
`<item>B</item>` +
|
|
`<item1>C</item1>` +
|
|
`</Items>` +
|
|
`</result>`,
|
|
},
|
|
{
|
|
Value: &NestedOrder{Field1: "C", Field2: "B", Field3: "A"},
|
|
ExpectXML: `<result>` +
|
|
`<parent>` +
|
|
`<c>C</c>` +
|
|
`<b>B</b>` +
|
|
`<a>A</a>` +
|
|
`</parent>` +
|
|
`</result>`,
|
|
},
|
|
{
|
|
Value: &NilTest{A: "A", B: nil, C: "C"},
|
|
ExpectXML: `<NilTest>` +
|
|
`<parent1>` +
|
|
`<parent2><a>A</a></parent2>` +
|
|
`<parent2><c>C</c></parent2>` +
|
|
`</parent1>` +
|
|
`</NilTest>`,
|
|
MarshalOnly: true, // Uses interface{}
|
|
},
|
|
{
|
|
Value: &MixedNested{A: "A", B: "B", C: "C", D: "D"},
|
|
ExpectXML: `<result>` +
|
|
`<parent1><a>A</a></parent1>` +
|
|
`<b>B</b>` +
|
|
`<parent1>` +
|
|
`<parent2><c>C</c></parent2>` +
|
|
`<d>D</d>` +
|
|
`</parent1>` +
|
|
`</result>`,
|
|
},
|
|
{
|
|
Value: &Service{Port: &Port{Number: "80"}},
|
|
ExpectXML: `<service><host><port>80</port></host></service>`,
|
|
},
|
|
{
|
|
Value: &Service{},
|
|
ExpectXML: `<service></service>`,
|
|
},
|
|
{
|
|
Value: &Service{Port: &Port{Number: "80"}, Extra1: "A", Extra2: "B"},
|
|
ExpectXML: `<service>` +
|
|
`<host><port>80</port></host>` +
|
|
`<Extra1>A</Extra1>` +
|
|
`<host><extra2>B</extra2></host>` +
|
|
`</service>`,
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
Value: &Service{Port: &Port{Number: "80"}, Extra2: "example"},
|
|
ExpectXML: `<service>` +
|
|
`<host><port>80</port></host>` +
|
|
`<host><extra2>example</extra2></host>` +
|
|
`</service>`,
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
Value: &struct {
|
|
XMLName struct{} `xml:"space top"`
|
|
A string `xml:"x>a"`
|
|
B string `xml:"x>b"`
|
|
C string `xml:"space x>c"`
|
|
C1 string `xml:"space1 x>c"`
|
|
D1 string `xml:"space1 x>d"`
|
|
}{
|
|
A: "a",
|
|
B: "b",
|
|
C: "c",
|
|
C1: "c1",
|
|
D1: "d1",
|
|
},
|
|
ExpectXML: `<top xmlns="space">` +
|
|
`<x><a>a</a><b>b</b><c xmlns="space">c</c>` +
|
|
`<c xmlns="space1">c1</c>` +
|
|
`<d xmlns="space1">d1</d>` +
|
|
`</x>` +
|
|
`</top>`,
|
|
},
|
|
{
|
|
Value: &struct {
|
|
XMLName Name
|
|
A string `xml:"x>a"`
|
|
B string `xml:"x>b"`
|
|
C string `xml:"space x>c"`
|
|
C1 string `xml:"space1 x>c"`
|
|
D1 string `xml:"space1 x>d"`
|
|
}{
|
|
XMLName: Name{
|
|
Space: "space0",
|
|
Local: "top",
|
|
},
|
|
A: "a",
|
|
B: "b",
|
|
C: "c",
|
|
C1: "c1",
|
|
D1: "d1",
|
|
},
|
|
ExpectXML: `<top xmlns="space0">` +
|
|
`<x><a>a</a><b>b</b>` +
|
|
`<c xmlns="space">c</c>` +
|
|
`<c xmlns="space1">c1</c>` +
|
|
`<d xmlns="space1">d1</d>` +
|
|
`</x>` +
|
|
`</top>`,
|
|
},
|
|
{
|
|
Value: &struct {
|
|
XMLName struct{} `xml:"top"`
|
|
B string `xml:"space x>b"`
|
|
B1 string `xml:"space1 x>b"`
|
|
}{
|
|
B: "b",
|
|
B1: "b1",
|
|
},
|
|
ExpectXML: `<top>` +
|
|
`<x><b xmlns="space">b</b>` +
|
|
`<b xmlns="space1">b1</b></x>` +
|
|
`</top>`,
|
|
},
|
|
|
|
// 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",
|
|
embedD: embedD{
|
|
FieldE: "A.D.E",
|
|
},
|
|
},
|
|
ExpectXML: `<EmbedA>` +
|
|
`<FieldB>A.C.B</FieldB>` +
|
|
`<FieldC>A.C.C</FieldC>` +
|
|
`<EmbedB>` +
|
|
`<FieldB>A.B.B</FieldB>` +
|
|
`<FieldA>` +
|
|
`<A1>A.B.C.A1</A1>` +
|
|
`<A2>A.B.C.A2</A2>` +
|
|
`</FieldA>` +
|
|
`<FieldC>A.B.C.C</FieldC>` +
|
|
`</EmbedB>` +
|
|
`<FieldA>A.A</FieldA>` +
|
|
`<FieldE>A.D.E</FieldE>` +
|
|
`</EmbedA>`,
|
|
},
|
|
|
|
// Test that name casing matters
|
|
{
|
|
Value: &NameCasing{Xy: "mixed", XY: "upper", XyA: "mixedA", XYA: "upperA"},
|
|
ExpectXML: `<casing Xy="mixedA" XY="upperA"><Xy>mixed</Xy><XY>upper</XY></casing>`,
|
|
},
|
|
|
|
// 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: `<Parent>` +
|
|
`<InTag>A</InTag>` +
|
|
`<InXMLName>B</InXMLName>` +
|
|
`<InXMLNameTag>C</InXMLNameTag>` +
|
|
`<InFieldName>D</InFieldName>` +
|
|
`</Parent>`,
|
|
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: `<Parent>` +
|
|
`<InTag>A</InTag>` +
|
|
`<FromNameVal>B</FromNameVal>` +
|
|
`<InXMLNameTag>C</InXMLNameTag>` +
|
|
`<InFieldName>D</InFieldName>` +
|
|
`</Parent>`,
|
|
UnmarshalOnly: true,
|
|
},
|
|
|
|
// xml.Name works in a plain field as well.
|
|
{
|
|
Value: &NameInField{Name{Space: "ns", Local: "foo"}},
|
|
ExpectXML: `<NameInField><foo xmlns="ns"></foo></NameInField>`,
|
|
},
|
|
{
|
|
Value: &NameInField{Name{Space: "ns", Local: "foo"}},
|
|
ExpectXML: `<NameInField><foo xmlns="ns"><ignore></ignore></foo></NameInField>`,
|
|
UnmarshalOnly: true,
|
|
},
|
|
|
|
// Marshaling zero xml.Name uses the tag or field name.
|
|
{
|
|
Value: &NameInField{},
|
|
ExpectXML: `<NameInField><foo xmlns="ns"></foo></NameInField>`,
|
|
MarshalOnly: true,
|
|
},
|
|
|
|
// Test attributes
|
|
{
|
|
Value: &AttrTest{
|
|
Int: 8,
|
|
Named: 9,
|
|
Float: 23.5,
|
|
Uint8: 255,
|
|
Bool: true,
|
|
Str: "str",
|
|
Bytes: []byte("byt"),
|
|
},
|
|
ExpectXML: `<AttrTest Int="8" int="9" Float="23.5" Uint8="255"` +
|
|
` Bool="true" Str="str" Bytes="byt"></AttrTest>`,
|
|
},
|
|
{
|
|
Value: &AttrTest{Bytes: []byte{}},
|
|
ExpectXML: `<AttrTest Int="0" int="0" Float="0" Uint8="0"` +
|
|
` Bool="false" Str="" Bytes=""></AttrTest>`,
|
|
},
|
|
{
|
|
Value: &AttrsTest{
|
|
Attrs: []Attr{
|
|
{Name: Name{Local: "Answer"}, Value: "42"},
|
|
{Name: Name{Local: "Int"}, Value: "8"},
|
|
{Name: Name{Local: "int"}, Value: "9"},
|
|
{Name: Name{Local: "Float"}, Value: "23.5"},
|
|
{Name: Name{Local: "Uint8"}, Value: "255"},
|
|
{Name: Name{Local: "Bool"}, Value: "true"},
|
|
{Name: Name{Local: "Str"}, Value: "str"},
|
|
{Name: Name{Local: "Bytes"}, Value: "byt"},
|
|
},
|
|
},
|
|
ExpectXML: `<AttrsTest Answer="42" Int="8" int="9" Float="23.5" Uint8="255" Bool="true" Str="str" Bytes="byt" Int="0" int="0" Float="0" Uint8="0" Bool="false" Str="" Bytes=""></AttrsTest>`,
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
Value: &AttrsTest{
|
|
Attrs: []Attr{
|
|
{Name: Name{Local: "Answer"}, Value: "42"},
|
|
},
|
|
Int: 8,
|
|
Named: 9,
|
|
Float: 23.5,
|
|
Uint8: 255,
|
|
Bool: true,
|
|
Str: "str",
|
|
Bytes: []byte("byt"),
|
|
},
|
|
ExpectXML: `<AttrsTest Answer="42" Int="8" int="9" Float="23.5" Uint8="255" Bool="true" Str="str" Bytes="byt"></AttrsTest>`,
|
|
},
|
|
{
|
|
Value: &AttrsTest{
|
|
Attrs: []Attr{
|
|
{Name: Name{Local: "Int"}, Value: "0"},
|
|
{Name: Name{Local: "int"}, Value: "0"},
|
|
{Name: Name{Local: "Float"}, Value: "0"},
|
|
{Name: Name{Local: "Uint8"}, Value: "0"},
|
|
{Name: Name{Local: "Bool"}, Value: "false"},
|
|
{Name: Name{Local: "Str"}},
|
|
{Name: Name{Local: "Bytes"}},
|
|
},
|
|
Bytes: []byte{},
|
|
},
|
|
ExpectXML: `<AttrsTest Int="0" int="0" Float="0" Uint8="0" Bool="false" Str="" Bytes="" Int="0" int="0" Float="0" Uint8="0" Bool="false" Str="" Bytes=""></AttrsTest>`,
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
Value: &OmitAttrTest{
|
|
Int: 8,
|
|
Named: 9,
|
|
Float: 23.5,
|
|
Uint8: 255,
|
|
Bool: true,
|
|
Str: "str",
|
|
Bytes: []byte("byt"),
|
|
PStr: &empty,
|
|
},
|
|
ExpectXML: `<OmitAttrTest Int="8" int="9" Float="23.5" Uint8="255"` +
|
|
` Bool="true" Str="str" Bytes="byt" PStr=""></OmitAttrTest>`,
|
|
},
|
|
{
|
|
Value: &OmitAttrTest{},
|
|
ExpectXML: `<OmitAttrTest></OmitAttrTest>`,
|
|
},
|
|
|
|
// pointer fields
|
|
{
|
|
Value: &PointerFieldsTest{Name: &nameAttr, Age: &ageAttr, Contents: &contentsAttr},
|
|
ExpectXML: `<dummy name="Sarah" age="12">lorem ipsum</dummy>`,
|
|
MarshalOnly: true,
|
|
},
|
|
|
|
// empty chardata pointer field
|
|
{
|
|
Value: &ChardataEmptyTest{},
|
|
ExpectXML: `<test></test>`,
|
|
MarshalOnly: true,
|
|
},
|
|
|
|
// omitempty on fields
|
|
{
|
|
Value: &OmitFieldTest{
|
|
Int: 8,
|
|
Named: 9,
|
|
Float: 23.5,
|
|
Uint8: 255,
|
|
Bool: true,
|
|
Str: "str",
|
|
Bytes: []byte("byt"),
|
|
PStr: &empty,
|
|
Ptr: &PresenceTest{},
|
|
},
|
|
ExpectXML: `<OmitFieldTest>` +
|
|
`<Int>8</Int>` +
|
|
`<int>9</int>` +
|
|
`<Float>23.5</Float>` +
|
|
`<Uint8>255</Uint8>` +
|
|
`<Bool>true</Bool>` +
|
|
`<Str>str</Str>` +
|
|
`<Bytes>byt</Bytes>` +
|
|
`<PStr></PStr>` +
|
|
`<Ptr></Ptr>` +
|
|
`</OmitFieldTest>`,
|
|
},
|
|
{
|
|
Value: &OmitFieldTest{},
|
|
ExpectXML: `<OmitFieldTest></OmitFieldTest>`,
|
|
},
|
|
|
|
// Test ",any"
|
|
{
|
|
ExpectXML: `<a><nested><value>known</value></nested><other><sub>unknown</sub></other></a>`,
|
|
Value: &AnyTest{
|
|
Nested: "known",
|
|
AnyField: AnyHolder{
|
|
XMLName: Name{Local: "other"},
|
|
XML: "<sub>unknown</sub>",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Value: &AnyTest{Nested: "known",
|
|
AnyField: AnyHolder{
|
|
XML: "<unknown/>",
|
|
XMLName: Name{Local: "AnyField"},
|
|
},
|
|
},
|
|
ExpectXML: `<a><nested><value>known</value></nested><AnyField><unknown/></AnyField></a>`,
|
|
},
|
|
{
|
|
ExpectXML: `<a><nested><value>b</value></nested></a>`,
|
|
Value: &AnyOmitTest{
|
|
Nested: "b",
|
|
},
|
|
},
|
|
{
|
|
ExpectXML: `<a><nested><value>b</value></nested><c><d>e</d></c><g xmlns="f"><h>i</h></g></a>`,
|
|
Value: &AnySliceTest{
|
|
Nested: "b",
|
|
AnyField: []AnyHolder{
|
|
{
|
|
XMLName: Name{Local: "c"},
|
|
XML: "<d>e</d>",
|
|
},
|
|
{
|
|
XMLName: Name{Space: "f", Local: "g"},
|
|
XML: "<h>i</h>",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
ExpectXML: `<a><nested><value>b</value></nested></a>`,
|
|
Value: &AnySliceTest{
|
|
Nested: "b",
|
|
},
|
|
},
|
|
|
|
// Test recursive types.
|
|
{
|
|
Value: &RecurseA{
|
|
A: "a1",
|
|
B: &RecurseB{
|
|
A: &RecurseA{"a2", nil},
|
|
B: "b1",
|
|
},
|
|
},
|
|
ExpectXML: `<RecurseA><A>a1</A><B><A><A>a2</A></A><B>b1</B></B></RecurseA>`,
|
|
},
|
|
|
|
// Test ignoring fields via "-" tag
|
|
{
|
|
ExpectXML: `<IgnoreTest></IgnoreTest>`,
|
|
Value: &IgnoreTest{},
|
|
},
|
|
{
|
|
ExpectXML: `<IgnoreTest></IgnoreTest>`,
|
|
Value: &IgnoreTest{PublicSecret: "can't tell"},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IgnoreTest><PublicSecret>ignore me</PublicSecret></IgnoreTest>`,
|
|
Value: &IgnoreTest{},
|
|
UnmarshalOnly: true,
|
|
},
|
|
|
|
// Test escaping.
|
|
{
|
|
ExpectXML: `<a><nested><value>dquote: "; squote: '; ampersand: &; less: <; greater: >;</value></nested><empty></empty></a>`,
|
|
Value: &AnyTest{
|
|
Nested: `dquote: "; squote: '; ampersand: &; less: <; greater: >;`,
|
|
AnyField: AnyHolder{XMLName: Name{Local: "empty"}},
|
|
},
|
|
},
|
|
{
|
|
ExpectXML: `<a><nested><value>newline: 
; cr: 
; tab: 	;</value></nested><AnyField></AnyField></a>`,
|
|
Value: &AnyTest{
|
|
Nested: "newline: \n; cr: \r; tab: \t;",
|
|
AnyField: AnyHolder{XMLName: Name{Local: "AnyField"}},
|
|
},
|
|
},
|
|
{
|
|
ExpectXML: "<a><nested><value>1\r2\r\n3\n\r4\n5</value></nested></a>",
|
|
Value: &AnyTest{
|
|
Nested: "1\n2\n3\n\n4\n5",
|
|
},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<EmbedInt><MyInt>42</MyInt></EmbedInt>`,
|
|
Value: &EmbedInt{
|
|
MyInt: 42,
|
|
},
|
|
},
|
|
// Test outputting CDATA-wrapped text.
|
|
{
|
|
ExpectXML: `<CDataTest></CDataTest>`,
|
|
Value: &CDataTest{},
|
|
},
|
|
{
|
|
ExpectXML: `<CDataTest><![CDATA[http://example.com/tests/1?foo=1&bar=baz]]></CDataTest>`,
|
|
Value: &CDataTest{
|
|
Chardata: "http://example.com/tests/1?foo=1&bar=baz",
|
|
},
|
|
},
|
|
{
|
|
ExpectXML: `<CDataTest><![CDATA[Literal <![CDATA[Nested]]]]><![CDATA[>!]]></CDataTest>`,
|
|
Value: &CDataTest{
|
|
Chardata: "Literal <![CDATA[Nested]]>!",
|
|
},
|
|
},
|
|
{
|
|
ExpectXML: `<CDataTest><![CDATA[<![CDATA[Nested]]]]><![CDATA[> Literal!]]></CDataTest>`,
|
|
Value: &CDataTest{
|
|
Chardata: "<![CDATA[Nested]]> Literal!",
|
|
},
|
|
},
|
|
{
|
|
ExpectXML: `<CDataTest><![CDATA[<![CDATA[Nested]]]]><![CDATA[> Literal! <![CDATA[Nested]]]]><![CDATA[> Literal!]]></CDataTest>`,
|
|
Value: &CDataTest{
|
|
Chardata: "<![CDATA[Nested]]> Literal! <![CDATA[Nested]]> Literal!",
|
|
},
|
|
},
|
|
{
|
|
ExpectXML: `<CDataTest><![CDATA[<![CDATA[<![CDATA[Nested]]]]><![CDATA[>]]]]><![CDATA[>]]></CDataTest>`,
|
|
Value: &CDataTest{
|
|
Chardata: "<![CDATA[<![CDATA[Nested]]>]]>",
|
|
},
|
|
},
|
|
|
|
// Test omitempty with parent chain; see golang.org/issue/4168.
|
|
{
|
|
ExpectXML: `<Strings><A></A></Strings>`,
|
|
Value: &Strings{},
|
|
},
|
|
// Custom marshalers.
|
|
{
|
|
ExpectXML: `<MyMarshalerTest>hello world</MyMarshalerTest>`,
|
|
Value: &MyMarshalerTest{},
|
|
},
|
|
{
|
|
ExpectXML: `<MarshalerStruct Foo="hello world"></MarshalerStruct>`,
|
|
Value: &MarshalerStruct{},
|
|
},
|
|
{
|
|
ExpectXML: `<outer xmlns="testns" int="10"></outer>`,
|
|
Value: &OuterStruct{IntAttr: 10},
|
|
},
|
|
{
|
|
ExpectXML: `<test xmlns="outerns" int="10"></test>`,
|
|
Value: &OuterNamedStruct{XMLName: Name{Space: "outerns", Local: "test"}, IntAttr: 10},
|
|
},
|
|
{
|
|
ExpectXML: `<test xmlns="outerns" int="10"></test>`,
|
|
Value: &OuterNamedOrderedStruct{XMLName: Name{Space: "outerns", Local: "test"}, IntAttr: 10},
|
|
},
|
|
{
|
|
ExpectXML: `<outer xmlns="testns" int="10"></outer>`,
|
|
Value: &OuterOuterStruct{OuterStruct{IntAttr: 10}},
|
|
},
|
|
{
|
|
ExpectXML: `<NestedAndChardata><A><B></B><B></B></A>test</NestedAndChardata>`,
|
|
Value: &NestedAndChardata{AB: make([]string, 2), Chardata: "test"},
|
|
},
|
|
{
|
|
ExpectXML: `<NestedAndComment><A><B></B><B></B></A><!--test--></NestedAndComment>`,
|
|
Value: &NestedAndComment{AB: make([]string, 2), Comment: "test"},
|
|
},
|
|
{
|
|
ExpectXML: `<NestedAndCData><A><B></B><B></B></A><![CDATA[test]]></NestedAndCData>`,
|
|
Value: &NestedAndCData{AB: make([]string, 2), CDATA: "test"},
|
|
},
|
|
// Test pointer indirection in various kinds of fields.
|
|
// https://golang.org/issue/19063
|
|
{
|
|
ExpectXML: `<IndirComment><T1></T1><!--hi--><T2></T2></IndirComment>`,
|
|
Value: &IndirComment{Comment: stringptr("hi")},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IndirComment><T1></T1><T2></T2></IndirComment>`,
|
|
Value: &IndirComment{Comment: stringptr("")},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IndirComment><T1></T1><T2></T2></IndirComment>`,
|
|
Value: &IndirComment{Comment: nil},
|
|
MarshalError: "xml: bad type for comment field of xml.IndirComment",
|
|
},
|
|
{
|
|
ExpectXML: `<IndirComment><T1></T1><!--hi--><T2></T2></IndirComment>`,
|
|
Value: &IndirComment{Comment: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceComment><T1></T1><!--hi--><T2></T2></IfaceComment>`,
|
|
Value: &IfaceComment{Comment: "hi"},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceComment><T1></T1><!--hi--><T2></T2></IfaceComment>`,
|
|
Value: &IfaceComment{Comment: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceComment><T1></T1><T2></T2></IfaceComment>`,
|
|
Value: &IfaceComment{Comment: nil},
|
|
MarshalError: "xml: bad type for comment field of xml.IfaceComment",
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceComment><T1></T1><T2></T2></IfaceComment>`,
|
|
Value: &IfaceComment{Comment: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectComment><T1></T1><!--hi--><T2></T2></DirectComment>`,
|
|
Value: &DirectComment{Comment: string("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<DirectComment><T1></T1><T2></T2></DirectComment>`,
|
|
Value: &DirectComment{Comment: string("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirChardata><T1></T1>hi<T2></T2></IndirChardata>`,
|
|
Value: &IndirChardata{Chardata: stringptr("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirChardata><T1></T1><![CDATA[hi]]><T2></T2></IndirChardata>`,
|
|
Value: &IndirChardata{Chardata: stringptr("hi")},
|
|
UnmarshalOnly: true, // marshals without CDATA
|
|
},
|
|
{
|
|
ExpectXML: `<IndirChardata><T1></T1><T2></T2></IndirChardata>`,
|
|
Value: &IndirChardata{Chardata: stringptr("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirChardata><T1></T1><T2></T2></IndirChardata>`,
|
|
Value: &IndirChardata{Chardata: nil},
|
|
MarshalOnly: true, // unmarshal leaves Chardata=stringptr("")
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceChardata><T1></T1>hi<T2></T2></IfaceChardata>`,
|
|
Value: &IfaceChardata{Chardata: string("hi")},
|
|
UnmarshalError: "cannot unmarshal into interface {}",
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceChardata><T1></T1><![CDATA[hi]]><T2></T2></IfaceChardata>`,
|
|
Value: &IfaceChardata{Chardata: string("hi")},
|
|
UnmarshalOnly: true, // marshals without CDATA
|
|
UnmarshalError: "cannot unmarshal into interface {}",
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceChardata><T1></T1><T2></T2></IfaceChardata>`,
|
|
Value: &IfaceChardata{Chardata: string("")},
|
|
UnmarshalError: "cannot unmarshal into interface {}",
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceChardata><T1></T1><T2></T2></IfaceChardata>`,
|
|
Value: &IfaceChardata{Chardata: nil},
|
|
UnmarshalError: "cannot unmarshal into interface {}",
|
|
},
|
|
{
|
|
ExpectXML: `<DirectChardata><T1></T1>hi<T2></T2></DirectChardata>`,
|
|
Value: &DirectChardata{Chardata: string("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<DirectChardata><T1></T1><![CDATA[hi]]><T2></T2></DirectChardata>`,
|
|
Value: &DirectChardata{Chardata: string("hi")},
|
|
UnmarshalOnly: true, // marshals without CDATA
|
|
},
|
|
{
|
|
ExpectXML: `<DirectChardata><T1></T1><T2></T2></DirectChardata>`,
|
|
Value: &DirectChardata{Chardata: string("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirCDATA><T1></T1><![CDATA[hi]]><T2></T2></IndirCDATA>`,
|
|
Value: &IndirCDATA{CDATA: stringptr("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirCDATA><T1></T1>hi<T2></T2></IndirCDATA>`,
|
|
Value: &IndirCDATA{CDATA: stringptr("hi")},
|
|
UnmarshalOnly: true, // marshals with CDATA
|
|
},
|
|
{
|
|
ExpectXML: `<IndirCDATA><T1></T1><T2></T2></IndirCDATA>`,
|
|
Value: &IndirCDATA{CDATA: stringptr("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirCDATA><T1></T1><T2></T2></IndirCDATA>`,
|
|
Value: &IndirCDATA{CDATA: nil},
|
|
MarshalOnly: true, // unmarshal leaves CDATA=stringptr("")
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceCDATA><T1></T1><![CDATA[hi]]><T2></T2></IfaceCDATA>`,
|
|
Value: &IfaceCDATA{CDATA: string("hi")},
|
|
UnmarshalError: "cannot unmarshal into interface {}",
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceCDATA><T1></T1>hi<T2></T2></IfaceCDATA>`,
|
|
Value: &IfaceCDATA{CDATA: string("hi")},
|
|
UnmarshalOnly: true, // marshals with CDATA
|
|
UnmarshalError: "cannot unmarshal into interface {}",
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceCDATA><T1></T1><T2></T2></IfaceCDATA>`,
|
|
Value: &IfaceCDATA{CDATA: string("")},
|
|
UnmarshalError: "cannot unmarshal into interface {}",
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceCDATA><T1></T1><T2></T2></IfaceCDATA>`,
|
|
Value: &IfaceCDATA{CDATA: nil},
|
|
UnmarshalError: "cannot unmarshal into interface {}",
|
|
},
|
|
{
|
|
ExpectXML: `<DirectCDATA><T1></T1><![CDATA[hi]]><T2></T2></DirectCDATA>`,
|
|
Value: &DirectCDATA{CDATA: string("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<DirectCDATA><T1></T1>hi<T2></T2></DirectCDATA>`,
|
|
Value: &DirectCDATA{CDATA: string("hi")},
|
|
UnmarshalOnly: true, // marshals with CDATA
|
|
},
|
|
{
|
|
ExpectXML: `<DirectCDATA><T1></T1><T2></T2></DirectCDATA>`,
|
|
Value: &DirectCDATA{CDATA: string("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirInnerXML><T1></T1><hi/><T2></T2></IndirInnerXML>`,
|
|
Value: &IndirInnerXML{InnerXML: stringptr("<hi/>")},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IndirInnerXML><T1></T1><T2></T2></IndirInnerXML>`,
|
|
Value: &IndirInnerXML{InnerXML: stringptr("")},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IndirInnerXML><T1></T1><T2></T2></IndirInnerXML>`,
|
|
Value: &IndirInnerXML{InnerXML: nil},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirInnerXML><T1></T1><hi/><T2></T2></IndirInnerXML>`,
|
|
Value: &IndirInnerXML{InnerXML: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceInnerXML><T1></T1><hi/><T2></T2></IfaceInnerXML>`,
|
|
Value: &IfaceInnerXML{InnerXML: "<hi/>"},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceInnerXML><T1></T1><hi/><T2></T2></IfaceInnerXML>`,
|
|
Value: &IfaceInnerXML{InnerXML: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceInnerXML><T1></T1><T2></T2></IfaceInnerXML>`,
|
|
Value: &IfaceInnerXML{InnerXML: nil},
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceInnerXML><T1></T1><T2></T2></IfaceInnerXML>`,
|
|
Value: &IfaceInnerXML{InnerXML: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectInnerXML><T1></T1><hi/><T2></T2></DirectInnerXML>`,
|
|
Value: &DirectInnerXML{InnerXML: string("<hi/>")},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectInnerXML><T1></T1><hi/><T2></T2></DirectInnerXML>`,
|
|
Value: &DirectInnerXML{InnerXML: string("<T1></T1><hi/><T2></T2>")},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectInnerXML><T1></T1><T2></T2></DirectInnerXML>`,
|
|
Value: &DirectInnerXML{InnerXML: string("")},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectInnerXML><T1></T1><T2></T2></DirectInnerXML>`,
|
|
Value: &DirectInnerXML{InnerXML: string("<T1></T1><T2></T2>")},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IndirElement><T1></T1><Element>hi</Element><T2></T2></IndirElement>`,
|
|
Value: &IndirElement{Element: stringptr("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirElement><T1></T1><Element></Element><T2></T2></IndirElement>`,
|
|
Value: &IndirElement{Element: stringptr("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirElement><T1></T1><T2></T2></IndirElement>`,
|
|
Value: &IndirElement{Element: nil},
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceElement><T1></T1><Element>hi</Element><T2></T2></IfaceElement>`,
|
|
Value: &IfaceElement{Element: "hi"},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceElement><T1></T1><Element>hi</Element><T2></T2></IfaceElement>`,
|
|
Value: &IfaceElement{Element: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceElement><T1></T1><T2></T2></IfaceElement>`,
|
|
Value: &IfaceElement{Element: nil},
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceElement><T1></T1><T2></T2></IfaceElement>`,
|
|
Value: &IfaceElement{Element: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectElement><T1></T1><Element>hi</Element><T2></T2></DirectElement>`,
|
|
Value: &DirectElement{Element: string("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<DirectElement><T1></T1><Element></Element><T2></T2></DirectElement>`,
|
|
Value: &DirectElement{Element: string("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirOmitEmpty><T1></T1><OmitEmpty>hi</OmitEmpty><T2></T2></IndirOmitEmpty>`,
|
|
Value: &IndirOmitEmpty{OmitEmpty: stringptr("hi")},
|
|
},
|
|
{
|
|
// Note: Changed in Go 1.8 to include <OmitEmpty> element (because x.OmitEmpty != nil).
|
|
ExpectXML: `<IndirOmitEmpty><T1></T1><OmitEmpty></OmitEmpty><T2></T2></IndirOmitEmpty>`,
|
|
Value: &IndirOmitEmpty{OmitEmpty: stringptr("")},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IndirOmitEmpty><T1></T1><OmitEmpty></OmitEmpty><T2></T2></IndirOmitEmpty>`,
|
|
Value: &IndirOmitEmpty{OmitEmpty: stringptr("")},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IndirOmitEmpty><T1></T1><T2></T2></IndirOmitEmpty>`,
|
|
Value: &IndirOmitEmpty{OmitEmpty: nil},
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceOmitEmpty><T1></T1><OmitEmpty>hi</OmitEmpty><T2></T2></IfaceOmitEmpty>`,
|
|
Value: &IfaceOmitEmpty{OmitEmpty: "hi"},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceOmitEmpty><T1></T1><OmitEmpty>hi</OmitEmpty><T2></T2></IfaceOmitEmpty>`,
|
|
Value: &IfaceOmitEmpty{OmitEmpty: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceOmitEmpty><T1></T1><T2></T2></IfaceOmitEmpty>`,
|
|
Value: &IfaceOmitEmpty{OmitEmpty: nil},
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceOmitEmpty><T1></T1><T2></T2></IfaceOmitEmpty>`,
|
|
Value: &IfaceOmitEmpty{OmitEmpty: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectOmitEmpty><T1></T1><OmitEmpty>hi</OmitEmpty><T2></T2></DirectOmitEmpty>`,
|
|
Value: &DirectOmitEmpty{OmitEmpty: string("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<DirectOmitEmpty><T1></T1><T2></T2></DirectOmitEmpty>`,
|
|
Value: &DirectOmitEmpty{OmitEmpty: string("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirAny><T1></T1><Any>hi</Any><T2></T2></IndirAny>`,
|
|
Value: &IndirAny{Any: stringptr("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirAny><T1></T1><Any></Any><T2></T2></IndirAny>`,
|
|
Value: &IndirAny{Any: stringptr("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirAny><T1></T1><T2></T2></IndirAny>`,
|
|
Value: &IndirAny{Any: nil},
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceAny><T1></T1><Any>hi</Any><T2></T2></IfaceAny>`,
|
|
Value: &IfaceAny{Any: "hi"},
|
|
MarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceAny><T1></T1><Any>hi</Any><T2></T2></IfaceAny>`,
|
|
Value: &IfaceAny{Any: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceAny><T1></T1><T2></T2></IfaceAny>`,
|
|
Value: &IfaceAny{Any: nil},
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceAny><T1></T1><T2></T2></IfaceAny>`,
|
|
Value: &IfaceAny{Any: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectAny><T1></T1><Any>hi</Any><T2></T2></DirectAny>`,
|
|
Value: &DirectAny{Any: string("hi")},
|
|
},
|
|
{
|
|
ExpectXML: `<DirectAny><T1></T1><Any></Any><T2></T2></DirectAny>`,
|
|
Value: &DirectAny{Any: string("")},
|
|
},
|
|
{
|
|
ExpectXML: `<IndirFoo><T1></T1><Foo>hi</Foo><T2></T2></IndirFoo>`,
|
|
Value: &IndirAny{Any: stringptr("hi")},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IndirFoo><T1></T1><Foo></Foo><T2></T2></IndirFoo>`,
|
|
Value: &IndirAny{Any: stringptr("")},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IndirFoo><T1></T1><T2></T2></IndirFoo>`,
|
|
Value: &IndirAny{Any: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceFoo><T1></T1><Foo>hi</Foo><T2></T2></IfaceFoo>`,
|
|
Value: &IfaceAny{Any: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceFoo><T1></T1><T2></T2></IfaceFoo>`,
|
|
Value: &IfaceAny{Any: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<IfaceFoo><T1></T1><T2></T2></IfaceFoo>`,
|
|
Value: &IfaceAny{Any: nil},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectFoo><T1></T1><Foo>hi</Foo><T2></T2></DirectFoo>`,
|
|
Value: &DirectAny{Any: string("hi")},
|
|
UnmarshalOnly: true,
|
|
},
|
|
{
|
|
ExpectXML: `<DirectFoo><T1></T1><Foo></Foo><T2></T2></DirectFoo>`,
|
|
Value: &DirectAny{Any: string("")},
|
|
UnmarshalOnly: true,
|
|
},
|
|
}
|
|
|
|
func TestMarshal(t *testing.T) {
|
|
for idx, test := range marshalTests {
|
|
if test.UnmarshalOnly {
|
|
continue
|
|
}
|
|
|
|
t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
|
|
data, err := Marshal(test.Value)
|
|
if err != nil {
|
|
if test.MarshalError == "" {
|
|
t.Errorf("marshal(%#v): %s", test.Value, err)
|
|
return
|
|
}
|
|
if !strings.Contains(err.Error(), test.MarshalError) {
|
|
t.Errorf("marshal(%#v): %s, want %q", test.Value, err, test.MarshalError)
|
|
}
|
|
return
|
|
}
|
|
if test.MarshalError != "" {
|
|
t.Errorf("Marshal succeeded, want error %q", test.MarshalError)
|
|
return
|
|
}
|
|
if got, want := string(data), test.ExpectXML; got != want {
|
|
if strings.Contains(want, "\n") {
|
|
t.Errorf("marshal(%#v):\nHAVE:\n%s\nWANT:\n%s", test.Value, got, want)
|
|
} else {
|
|
t.Errorf("marshal(%#v):\nhave %#q\nwant %#q", test.Value, got, want)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type AttrParent struct {
|
|
X string `xml:"X>Y,attr"`
|
|
}
|
|
|
|
type BadAttr struct {
|
|
Name map[string]string `xml:"name,attr"`
|
|
}
|
|
|
|
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 "--"`,
|
|
},
|
|
// Reject parent chain with attr, never worked; see golang.org/issue/5033.
|
|
{
|
|
Value: &AttrParent{},
|
|
Err: `xml: X>Y chain not valid with attr flag`,
|
|
},
|
|
{
|
|
Value: BadAttr{map[string]string{"X": "Y"}},
|
|
Err: `xml: unsupported type: map[string]string`,
|
|
},
|
|
}
|
|
|
|
var marshalIndentTests = []struct {
|
|
Value interface{}
|
|
Prefix string
|
|
Indent string
|
|
ExpectXML string
|
|
}{
|
|
{
|
|
Value: &SecretAgent{
|
|
Handle: "007",
|
|
Identity: "James Bond",
|
|
Obfuscate: "<redacted/>",
|
|
},
|
|
Prefix: "",
|
|
Indent: "\t",
|
|
ExpectXML: fmt.Sprintf("<agent handle=\"007\">\n\t<Identity>James Bond</Identity><redacted/>\n</agent>"),
|
|
},
|
|
}
|
|
|
|
func TestMarshalErrors(t *testing.T) {
|
|
for idx, test := range marshalErrorTests {
|
|
data, err := Marshal(test.Value)
|
|
if err == nil {
|
|
t.Errorf("#%d: marshal(%#v) = [success] %q, want error %v", idx, test.Value, data, test.Err)
|
|
continue
|
|
}
|
|
if 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
|
|
}
|
|
if test.ExpectXML == `<top>`+
|
|
`<x><b xmlns="space">b</b>`+
|
|
`<b xmlns="space1">b1</b></x>`+
|
|
`</top>` {
|
|
// TODO(rogpeppe): re-enable this test in
|
|
// https://go-review.googlesource.com/#/c/5910/
|
|
continue
|
|
}
|
|
|
|
vt := reflect.TypeOf(test.Value)
|
|
dest := reflect.New(vt.Elem()).Interface()
|
|
err := Unmarshal([]byte(test.ExpectXML), dest)
|
|
|
|
t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
|
|
switch fix := dest.(type) {
|
|
case *Feed:
|
|
fix.Author.InnerXML = ""
|
|
for i := range fix.Entry {
|
|
fix.Entry[i].Author.InnerXML = ""
|
|
}
|
|
}
|
|
|
|
if err != nil {
|
|
if test.UnmarshalError == "" {
|
|
t.Errorf("unmarshal(%#v): %s", test.ExpectXML, err)
|
|
return
|
|
}
|
|
if !strings.Contains(err.Error(), test.UnmarshalError) {
|
|
t.Errorf("unmarshal(%#v): %s, want %q", test.ExpectXML, err, test.UnmarshalError)
|
|
}
|
|
return
|
|
}
|
|
if got, want := dest, test.Value; !reflect.DeepEqual(got, want) {
|
|
t.Errorf("unmarshal(%q):\nhave %#v\nwant %#v", test.ExpectXML, got, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMarshalIndent(t *testing.T) {
|
|
for i, test := range marshalIndentTests {
|
|
data, err := MarshalIndent(test.Value, test.Prefix, test.Indent)
|
|
if err != nil {
|
|
t.Errorf("#%d: Error: %s", i, err)
|
|
continue
|
|
}
|
|
if got, want := string(data), test.ExpectXML; got != want {
|
|
t.Errorf("#%d: MarshalIndent:\nGot:%s\nWant:\n%s", i, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
type limitedBytesWriter struct {
|
|
w io.Writer
|
|
remain int // until writes fail
|
|
}
|
|
|
|
func (lw *limitedBytesWriter) Write(p []byte) (n int, err error) {
|
|
if lw.remain <= 0 {
|
|
println("error")
|
|
return 0, errors.New("write limit hit")
|
|
}
|
|
if len(p) > lw.remain {
|
|
p = p[:lw.remain]
|
|
n, _ = lw.w.Write(p)
|
|
lw.remain = 0
|
|
return n, errors.New("write limit hit")
|
|
}
|
|
n, err = lw.w.Write(p)
|
|
lw.remain -= n
|
|
return n, err
|
|
}
|
|
|
|
func TestMarshalWriteErrors(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
const writeCap = 1024
|
|
w := &limitedBytesWriter{&buf, writeCap}
|
|
enc := NewEncoder(w)
|
|
var err error
|
|
var i int
|
|
const n = 4000
|
|
for i = 1; i <= n; i++ {
|
|
err = enc.Encode(&Passenger{
|
|
Name: []string{"Alice", "Bob"},
|
|
Weight: 5,
|
|
})
|
|
if err != nil {
|
|
break
|
|
}
|
|
}
|
|
if err == nil {
|
|
t.Error("expected an error")
|
|
}
|
|
if i == n {
|
|
t.Errorf("expected to fail before the end")
|
|
}
|
|
if buf.Len() != writeCap {
|
|
t.Errorf("buf.Len() = %d; want %d", buf.Len(), writeCap)
|
|
}
|
|
}
|
|
|
|
func TestMarshalWriteIOErrors(t *testing.T) {
|
|
enc := NewEncoder(errWriter{})
|
|
|
|
expectErr := "unwritable"
|
|
err := enc.Encode(&Passenger{})
|
|
if err == nil || err.Error() != expectErr {
|
|
t.Errorf("EscapeTest = [error] %v, want %v", err, expectErr)
|
|
}
|
|
}
|
|
|
|
func TestMarshalFlush(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
enc := NewEncoder(&buf)
|
|
if err := enc.EncodeToken(CharData("hello world")); err != nil {
|
|
t.Fatalf("enc.EncodeToken: %v", err)
|
|
}
|
|
if buf.Len() > 0 {
|
|
t.Fatalf("enc.EncodeToken caused actual write: %q", buf.Bytes())
|
|
}
|
|
if err := enc.Flush(); err != nil {
|
|
t.Fatalf("enc.Flush: %v", err)
|
|
}
|
|
if buf.String() != "hello world" {
|
|
t.Fatalf("after enc.Flush, buf.String() = %q, want %q", buf.String(), "hello world")
|
|
}
|
|
}
|
|
|
|
func BenchmarkMarshal(b *testing.B) {
|
|
b.ReportAllocs()
|
|
b.RunParallel(func(pb *testing.PB) {
|
|
for pb.Next() {
|
|
Marshal(atomValue)
|
|
}
|
|
})
|
|
}
|
|
|
|
func BenchmarkUnmarshal(b *testing.B) {
|
|
b.ReportAllocs()
|
|
xml := []byte(atomXML)
|
|
b.RunParallel(func(pb *testing.PB) {
|
|
for pb.Next() {
|
|
Unmarshal(xml, &Feed{})
|
|
}
|
|
})
|
|
}
|
|
|
|
// golang.org/issue/6556
|
|
func TestStructPointerMarshal(t *testing.T) {
|
|
type A struct {
|
|
XMLName string `xml:"a"`
|
|
B []interface{}
|
|
}
|
|
type C struct {
|
|
XMLName Name
|
|
Value string `xml:"value"`
|
|
}
|
|
|
|
a := new(A)
|
|
a.B = append(a.B, &C{
|
|
XMLName: Name{Local: "c"},
|
|
Value: "x",
|
|
})
|
|
|
|
b, err := Marshal(a)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if x := string(b); x != "<a><c><value>x</value></c></a>" {
|
|
t.Fatal(x)
|
|
}
|
|
var v A
|
|
err = Unmarshal(b, &v)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
var encodeTokenTests = []struct {
|
|
desc string
|
|
toks []Token
|
|
want string
|
|
err string
|
|
}{{
|
|
desc: "start element with name space",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "local"}, nil},
|
|
},
|
|
want: `<local xmlns="space">`,
|
|
}, {
|
|
desc: "start element with no name",
|
|
toks: []Token{
|
|
StartElement{Name{"space", ""}, nil},
|
|
},
|
|
err: "xml: start tag with no name",
|
|
}, {
|
|
desc: "end element with no name",
|
|
toks: []Token{
|
|
EndElement{Name{"space", ""}},
|
|
},
|
|
err: "xml: end tag with no name",
|
|
}, {
|
|
desc: "char data",
|
|
toks: []Token{
|
|
CharData("foo"),
|
|
},
|
|
want: `foo`,
|
|
}, {
|
|
desc: "char data with escaped chars",
|
|
toks: []Token{
|
|
CharData(" \t\n"),
|
|
},
|
|
want: " 	\n",
|
|
}, {
|
|
desc: "comment",
|
|
toks: []Token{
|
|
Comment("foo"),
|
|
},
|
|
want: `<!--foo-->`,
|
|
}, {
|
|
desc: "comment with invalid content",
|
|
toks: []Token{
|
|
Comment("foo-->"),
|
|
},
|
|
err: "xml: EncodeToken of Comment containing --> marker",
|
|
}, {
|
|
desc: "proc instruction",
|
|
toks: []Token{
|
|
ProcInst{"Target", []byte("Instruction")},
|
|
},
|
|
want: `<?Target Instruction?>`,
|
|
}, {
|
|
desc: "proc instruction with empty target",
|
|
toks: []Token{
|
|
ProcInst{"", []byte("Instruction")},
|
|
},
|
|
err: "xml: EncodeToken of ProcInst with invalid Target",
|
|
}, {
|
|
desc: "proc instruction with bad content",
|
|
toks: []Token{
|
|
ProcInst{"", []byte("Instruction?>")},
|
|
},
|
|
err: "xml: EncodeToken of ProcInst with invalid Target",
|
|
}, {
|
|
desc: "directive",
|
|
toks: []Token{
|
|
Directive("foo"),
|
|
},
|
|
want: `<!foo>`,
|
|
}, {
|
|
desc: "more complex directive",
|
|
toks: []Token{
|
|
Directive("DOCTYPE doc [ <!ELEMENT doc '>'> <!-- com>ment --> ]"),
|
|
},
|
|
want: `<!DOCTYPE doc [ <!ELEMENT doc '>'> <!-- com>ment --> ]>`,
|
|
}, {
|
|
desc: "directive instruction with bad name",
|
|
toks: []Token{
|
|
Directive("foo>"),
|
|
},
|
|
err: "xml: EncodeToken of Directive containing wrong < or > markers",
|
|
}, {
|
|
desc: "end tag without start tag",
|
|
toks: []Token{
|
|
EndElement{Name{"foo", "bar"}},
|
|
},
|
|
err: "xml: end tag </bar> without start tag",
|
|
}, {
|
|
desc: "mismatching end tag local name",
|
|
toks: []Token{
|
|
StartElement{Name{"", "foo"}, nil},
|
|
EndElement{Name{"", "bar"}},
|
|
},
|
|
err: "xml: end tag </bar> does not match start tag <foo>",
|
|
want: `<foo>`,
|
|
}, {
|
|
desc: "mismatching end tag namespace",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, nil},
|
|
EndElement{Name{"another", "foo"}},
|
|
},
|
|
err: "xml: end tag </foo> in namespace another does not match start tag <foo> in namespace space",
|
|
want: `<foo xmlns="space">`,
|
|
}, {
|
|
desc: "start element with explicit namespace",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "local"}, []Attr{
|
|
{Name{"xmlns", "x"}, "space"},
|
|
{Name{"space", "foo"}, "value"},
|
|
}},
|
|
},
|
|
want: `<local xmlns="space" xmlns:_xmlns="xmlns" _xmlns:x="space" xmlns:space="space" space:foo="value">`,
|
|
}, {
|
|
desc: "start element with explicit namespace and colliding prefix",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "local"}, []Attr{
|
|
{Name{"xmlns", "x"}, "space"},
|
|
{Name{"space", "foo"}, "value"},
|
|
{Name{"x", "bar"}, "other"},
|
|
}},
|
|
},
|
|
want: `<local xmlns="space" xmlns:_xmlns="xmlns" _xmlns:x="space" xmlns:space="space" space:foo="value" xmlns:x="x" x:bar="other">`,
|
|
}, {
|
|
desc: "start element using previously defined namespace",
|
|
toks: []Token{
|
|
StartElement{Name{"", "local"}, []Attr{
|
|
{Name{"xmlns", "x"}, "space"},
|
|
}},
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"space", "x"}, "y"},
|
|
}},
|
|
},
|
|
want: `<local xmlns:_xmlns="xmlns" _xmlns:x="space"><foo xmlns="space" xmlns:space="space" space:x="y">`,
|
|
}, {
|
|
desc: "nested name space with same prefix",
|
|
toks: []Token{
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"xmlns", "x"}, "space1"},
|
|
}},
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"xmlns", "x"}, "space2"},
|
|
}},
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"space1", "a"}, "space1 value"},
|
|
{Name{"space2", "b"}, "space2 value"},
|
|
}},
|
|
EndElement{Name{"", "foo"}},
|
|
EndElement{Name{"", "foo"}},
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"space1", "a"}, "space1 value"},
|
|
{Name{"space2", "b"}, "space2 value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns:_xmlns="xmlns" _xmlns:x="space1"><foo _xmlns:x="space2"><foo xmlns:space1="space1" space1:a="space1 value" xmlns:space2="space2" space2:b="space2 value"></foo></foo><foo xmlns:space1="space1" space1:a="space1 value" xmlns:space2="space2" space2:b="space2 value">`,
|
|
}, {
|
|
desc: "start element defining several prefixes for the same name space",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"xmlns", "a"}, "space"},
|
|
{Name{"xmlns", "b"}, "space"},
|
|
{Name{"space", "x"}, "value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns="space" xmlns:_xmlns="xmlns" _xmlns:a="space" _xmlns:b="space" xmlns:space="space" space:x="value">`,
|
|
}, {
|
|
desc: "nested element redefines name space",
|
|
toks: []Token{
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"xmlns", "x"}, "space"},
|
|
}},
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"xmlns", "y"}, "space"},
|
|
{Name{"space", "a"}, "value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns:_xmlns="xmlns" _xmlns:x="space"><foo xmlns="space" _xmlns:y="space" xmlns:space="space" space:a="value">`,
|
|
}, {
|
|
desc: "nested element creates alias for default name space",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"", "xmlns"}, "space"},
|
|
}},
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"xmlns", "y"}, "space"},
|
|
{Name{"space", "a"}, "value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns="space" xmlns="space"><foo xmlns="space" xmlns:_xmlns="xmlns" _xmlns:y="space" xmlns:space="space" space:a="value">`,
|
|
}, {
|
|
desc: "nested element defines default name space with existing prefix",
|
|
toks: []Token{
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"xmlns", "x"}, "space"},
|
|
}},
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"", "xmlns"}, "space"},
|
|
{Name{"space", "a"}, "value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns:_xmlns="xmlns" _xmlns:x="space"><foo xmlns="space" xmlns="space" xmlns:space="space" space:a="value">`,
|
|
}, {
|
|
desc: "nested element uses empty attribute name space when default ns defined",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"", "xmlns"}, "space"},
|
|
}},
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"", "attr"}, "value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns="space" xmlns="space"><foo xmlns="space" attr="value">`,
|
|
}, {
|
|
desc: "redefine xmlns",
|
|
toks: []Token{
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"foo", "xmlns"}, "space"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns:foo="foo" foo:xmlns="space">`,
|
|
}, {
|
|
desc: "xmlns with explicit name space #1",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"xml", "xmlns"}, "space"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns="space" xmlns:_xml="xml" _xml:xmlns="space">`,
|
|
}, {
|
|
desc: "xmlns with explicit name space #2",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{xmlURL, "xmlns"}, "space"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns="space" xml:xmlns="space">`,
|
|
}, {
|
|
desc: "empty name space declaration is ignored",
|
|
toks: []Token{
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"xmlns", "foo"}, ""},
|
|
}},
|
|
},
|
|
want: `<foo xmlns:_xmlns="xmlns" _xmlns:foo="">`,
|
|
}, {
|
|
desc: "attribute with no name is ignored",
|
|
toks: []Token{
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"", ""}, "value"},
|
|
}},
|
|
},
|
|
want: `<foo>`,
|
|
}, {
|
|
desc: "namespace URL with non-valid name",
|
|
toks: []Token{
|
|
StartElement{Name{"/34", "foo"}, []Attr{
|
|
{Name{"/34", "x"}, "value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns="/34" xmlns:_="/34" _:x="value">`,
|
|
}, {
|
|
desc: "nested element resets default namespace to empty",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"", "xmlns"}, "space"},
|
|
}},
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"", "xmlns"}, ""},
|
|
{Name{"", "x"}, "value"},
|
|
{Name{"space", "x"}, "value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns="space" xmlns="space"><foo xmlns="" x="value" xmlns:space="space" space:x="value">`,
|
|
}, {
|
|
desc: "nested element requires empty default name space",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"", "xmlns"}, "space"},
|
|
}},
|
|
StartElement{Name{"", "foo"}, nil},
|
|
},
|
|
want: `<foo xmlns="space" xmlns="space"><foo>`,
|
|
}, {
|
|
desc: "attribute uses name space from xmlns",
|
|
toks: []Token{
|
|
StartElement{Name{"some/space", "foo"}, []Attr{
|
|
{Name{"", "attr"}, "value"},
|
|
{Name{"some/space", "other"}, "other value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns="some/space" attr="value" xmlns:space="some/space" space:other="other value">`,
|
|
}, {
|
|
desc: "default name space should not be used by attributes",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"", "xmlns"}, "space"},
|
|
{Name{"xmlns", "bar"}, "space"},
|
|
{Name{"space", "baz"}, "foo"},
|
|
}},
|
|
StartElement{Name{"space", "baz"}, nil},
|
|
EndElement{Name{"space", "baz"}},
|
|
EndElement{Name{"space", "foo"}},
|
|
},
|
|
want: `<foo xmlns="space" xmlns="space" xmlns:_xmlns="xmlns" _xmlns:bar="space" xmlns:space="space" space:baz="foo"><baz xmlns="space"></baz></foo>`,
|
|
}, {
|
|
desc: "default name space not used by attributes, not explicitly defined",
|
|
toks: []Token{
|
|
StartElement{Name{"space", "foo"}, []Attr{
|
|
{Name{"", "xmlns"}, "space"},
|
|
{Name{"space", "baz"}, "foo"},
|
|
}},
|
|
StartElement{Name{"space", "baz"}, nil},
|
|
EndElement{Name{"space", "baz"}},
|
|
EndElement{Name{"space", "foo"}},
|
|
},
|
|
want: `<foo xmlns="space" xmlns="space" xmlns:space="space" space:baz="foo"><baz xmlns="space"></baz></foo>`,
|
|
}, {
|
|
desc: "impossible xmlns declaration",
|
|
toks: []Token{
|
|
StartElement{Name{"", "foo"}, []Attr{
|
|
{Name{"", "xmlns"}, "space"},
|
|
}},
|
|
StartElement{Name{"space", "bar"}, []Attr{
|
|
{Name{"space", "attr"}, "value"},
|
|
}},
|
|
},
|
|
want: `<foo xmlns="space"><bar xmlns="space" xmlns:space="space" space:attr="value">`,
|
|
}}
|
|
|
|
func TestEncodeToken(t *testing.T) {
|
|
loop:
|
|
for i, tt := range encodeTokenTests {
|
|
var buf bytes.Buffer
|
|
enc := NewEncoder(&buf)
|
|
var err error
|
|
for j, tok := range tt.toks {
|
|
err = enc.EncodeToken(tok)
|
|
if err != nil && j < len(tt.toks)-1 {
|
|
t.Errorf("#%d %s token #%d: %v", i, tt.desc, j, err)
|
|
continue loop
|
|
}
|
|
}
|
|
errorf := func(f string, a ...interface{}) {
|
|
t.Errorf("#%d %s token #%d:%s", i, tt.desc, len(tt.toks)-1, fmt.Sprintf(f, a...))
|
|
}
|
|
switch {
|
|
case tt.err != "" && err == nil:
|
|
errorf(" expected error; got none")
|
|
continue
|
|
case tt.err == "" && err != nil:
|
|
errorf(" got error: %v", err)
|
|
continue
|
|
case tt.err != "" && err != nil && tt.err != err.Error():
|
|
errorf(" error mismatch; got %v, want %v", err, tt.err)
|
|
continue
|
|
}
|
|
if err := enc.Flush(); err != nil {
|
|
errorf(" %v", err)
|
|
continue
|
|
}
|
|
if got := buf.String(); got != tt.want {
|
|
errorf("\ngot %v\nwant %v", got, tt.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestProcInstEncodeToken(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
enc := NewEncoder(&buf)
|
|
|
|
if err := enc.EncodeToken(ProcInst{"xml", []byte("Instruction")}); err != nil {
|
|
t.Fatalf("enc.EncodeToken: expected to be able to encode xml target ProcInst as first token, %s", err)
|
|
}
|
|
|
|
if err := enc.EncodeToken(ProcInst{"Target", []byte("Instruction")}); err != nil {
|
|
t.Fatalf("enc.EncodeToken: expected to be able to add non-xml target ProcInst")
|
|
}
|
|
|
|
if err := enc.EncodeToken(ProcInst{"xml", []byte("Instruction")}); err == nil {
|
|
t.Fatalf("enc.EncodeToken: expected to not be allowed to encode xml target ProcInst when not first token")
|
|
}
|
|
}
|
|
|
|
func TestDecodeEncode(t *testing.T) {
|
|
var in, out bytes.Buffer
|
|
in.WriteString(`<?xml version="1.0" encoding="UTF-8"?>
|
|
<?Target Instruction?>
|
|
<root>
|
|
</root>
|
|
`)
|
|
dec := NewDecoder(&in)
|
|
enc := NewEncoder(&out)
|
|
for tok, err := dec.Token(); err == nil; tok, err = dec.Token() {
|
|
err = enc.EncodeToken(tok)
|
|
if err != nil {
|
|
t.Fatalf("enc.EncodeToken: Unable to encode token (%#v), %v", tok, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Issue 9796. Used to fail with GORACE="halt_on_error=1" -race.
|
|
func TestRace9796(t *testing.T) {
|
|
type A struct{}
|
|
type B struct {
|
|
C []A `xml:"X>Y"`
|
|
}
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < 2; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
Marshal(B{[]A{{}}})
|
|
wg.Done()
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func TestIsValidDirective(t *testing.T) {
|
|
testOK := []string{
|
|
"<>",
|
|
"< < > >",
|
|
"<!DOCTYPE '<' '>' '>' <!--nothing-->>",
|
|
"<!DOCTYPE doc [ <!ELEMENT doc ANY> <!ELEMENT doc ANY> ]>",
|
|
"<!DOCTYPE doc [ <!ELEMENT doc \"ANY> '<' <!E\" LEMENT '>' doc ANY> ]>",
|
|
"<!DOCTYPE doc <!-- just>>>> a < comment --> [ <!ITEM anything> ] >",
|
|
}
|
|
testKO := []string{
|
|
"<",
|
|
">",
|
|
"<!--",
|
|
"-->",
|
|
"< > > < < >",
|
|
"<!dummy <!-- > -->",
|
|
"<!DOCTYPE doc '>",
|
|
"<!DOCTYPE doc '>'",
|
|
"<!DOCTYPE doc <!--comment>",
|
|
}
|
|
for _, s := range testOK {
|
|
if !isValidDirective(Directive(s)) {
|
|
t.Errorf("Directive %q is expected to be valid", s)
|
|
}
|
|
}
|
|
for _, s := range testKO {
|
|
if isValidDirective(Directive(s)) {
|
|
t.Errorf("Directive %q is expected to be invalid", s)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Issue 11719. EncodeToken used to silently eat tokens with an invalid type.
|
|
func TestSimpleUseOfEncodeToken(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
enc := NewEncoder(&buf)
|
|
if err := enc.EncodeToken(&StartElement{Name: Name{"", "object1"}}); err == nil {
|
|
t.Errorf("enc.EncodeToken: pointer type should be rejected")
|
|
}
|
|
if err := enc.EncodeToken(&EndElement{Name: Name{"", "object1"}}); err == nil {
|
|
t.Errorf("enc.EncodeToken: pointer type should be rejected")
|
|
}
|
|
if err := enc.EncodeToken(StartElement{Name: Name{"", "object2"}}); err != nil {
|
|
t.Errorf("enc.EncodeToken: StartElement %s", err)
|
|
}
|
|
if err := enc.EncodeToken(EndElement{Name: Name{"", "object2"}}); err != nil {
|
|
t.Errorf("enc.EncodeToken: EndElement %s", err)
|
|
}
|
|
if err := enc.EncodeToken(Universe{}); err == nil {
|
|
t.Errorf("enc.EncodeToken: invalid type not caught")
|
|
}
|
|
if err := enc.Flush(); err != nil {
|
|
t.Errorf("enc.Flush: %s", err)
|
|
}
|
|
if buf.Len() == 0 {
|
|
t.Errorf("enc.EncodeToken: empty buffer")
|
|
}
|
|
want := "<object2></object2>"
|
|
if buf.String() != want {
|
|
t.Errorf("enc.EncodeToken: expected %q; got %q", want, buf.String())
|
|
}
|
|
}
|
|
|
|
// Issue 16158. Decoder.unmarshalAttr ignores the return value of copyValue.
|
|
func TestIssue16158(t *testing.T) {
|
|
const data = `<foo b="HELLOWORLD"></foo>`
|
|
err := Unmarshal([]byte(data), &struct {
|
|
B byte `xml:"b,attr,omitempty"`
|
|
}{})
|
|
if err == nil {
|
|
t.Errorf("Unmarshal: expected error, got nil")
|
|
}
|
|
}
|
|
|
|
// Issue 20953. Crash on invalid XMLName attribute.
|
|
|
|
type InvalidXMLName struct {
|
|
XMLName Name `xml:"error"`
|
|
Type struct {
|
|
XMLName Name `xml:"type,attr"`
|
|
}
|
|
}
|
|
|
|
func TestInvalidXMLName(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
enc := NewEncoder(&buf)
|
|
if err := enc.Encode(InvalidXMLName{}); err == nil {
|
|
t.Error("unexpected success")
|
|
} else if want := "invalid tag"; !strings.Contains(err.Error(), want) {
|
|
t.Errorf("error %q does not contain %q", err, want)
|
|
}
|
|
}
|