// 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 any `xml:"parent1>parent2>a"` B any `xml:"parent1>b"` C any `xml:"parent1>parent2>c"` } type Service struct { XMLName struct{} `xml:"service"` Domain *Domain `xml:"host>domain"` Port *Port `xml:"host>port"` Extra1 any Extra2 any `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 any } 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 PointerAnonFields struct { *MyInt *NamedType } 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 any) any { return &x } func stringptr(x string) *string { return &x } type T1 struct{} type T2 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 any `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 any `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 any `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 any `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 any 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 any `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 any `xml:",any"` T2 T2 } type Generic[T any] struct { X T } 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 any 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: `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`}, {Value: ifaceptr(true), MarshalOnly: true, ExpectXML: `true`}, // 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 []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: &Event{Year: -3114}, ExpectXML: `-3114`}, {Value: &Movie{Length: 13440}, ExpectXML: `13440`}, {Value: &Pi{Approximation: 3.14159265}, ExpectXML: `3.1415927`}, {Value: &Universe{Visible: 9.3e13}, ExpectXML: `9.3e+13`}, {Value: &Particle{HasMass: true}, ExpectXML: `true`}, {Value: &Departure{When: ParseTime("2013-01-09T00:15:00-09:00")}, ExpectXML: `2013-01-09T00:15:00-09:00`}, {Value: atomValue, ExpectXML: atomXML}, {Value: &Generic[int]{1}, ExpectXML: `1`}, { 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, }, { 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: `` + `abc` + `c1` + `d1` + `` + ``, }, { 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: `` + `ab` + `c` + `c1` + `d1` + `` + ``, }, { Value: &struct { XMLName struct{} `xml:"top"` B string `xml:"space x>b"` B1 string `xml:"space1 x>b"` }{ B: "b", B1: "b1", }, ExpectXML: `` + `b` + `b1` + ``, }, // 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: `` + `A.C.B` + `A.C.C` + `` + `A.B.B` + `` + `A.B.C.A1` + `A.B.C.A2` + `` + `A.B.C.C` + `` + `A.A` + `A.D.E` + ``, }, // Anonymous struct pointer field which is nil { Value: &EmbedB{}, ExpectXML: ``, }, // Other kinds of nil anonymous fields { Value: &PointerAnonFields{}, ExpectXML: ``, }, // 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: &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: ``, 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: ``, }, { 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: ``, MarshalOnly: true, }, { Value: &OmitAttrTest{ Int: 8, Named: 9, Float: 23.5, Uint8: 255, Bool: true, Str: "str", Bytes: []byte("byt"), PStr: &empty, }, ExpectXML: ``, }, { Value: &OmitAttrTest{}, ExpectXML: ``, }, // pointer fields { Value: &PointerFieldsTest{Name: &nameAttr, Age: &ageAttr, Contents: &contentsAttr}, ExpectXML: `lorem ipsum`, MarshalOnly: true, }, // empty chardata pointer field { Value: &ChardataEmptyTest{}, ExpectXML: ``, 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: `` + `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", }, }, }, { Value: &AnyTest{Nested: "known", AnyField: AnyHolder{ XML: "", XMLName: Name{Local: "AnyField"}, }, }, ExpectXML: `known`, }, { ExpectXML: `b`, Value: &AnyOmitTest{ Nested: "b", }, }, { ExpectXML: `bei`, Value: &AnySliceTest{ Nested: "b", AnyField: []AnyHolder{ { XMLName: Name{Local: "c"}, XML: "e", }, { XMLName: Name{Space: "f", Local: "g"}, XML: "i", }, }, }, }, { ExpectXML: `b`, Value: &AnySliceTest{ Nested: "b", }, }, // 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, }, // Test escaping. { ExpectXML: `dquote: "; squote: '; ampersand: &; less: <; greater: >;`, Value: &AnyTest{ Nested: `dquote: "; squote: '; ampersand: &; less: <; greater: >;`, AnyField: AnyHolder{XMLName: Name{Local: "empty"}}, }, }, { ExpectXML: `newline: ; cr: ; tab: ;`, Value: &AnyTest{ Nested: "newline: \n; cr: \r; tab: \t;", AnyField: AnyHolder{XMLName: Name{Local: "AnyField"}}, }, }, { ExpectXML: "1\r2\r\n3\n\r4\n5", Value: &AnyTest{ Nested: "1\n2\n3\n\n4\n5", }, UnmarshalOnly: true, }, { ExpectXML: `42`, Value: &EmbedInt{ MyInt: 42, }, }, // Test outputting CDATA-wrapped text. { ExpectXML: ``, Value: &CDataTest{}, }, { ExpectXML: ``, Value: &CDataTest{ Chardata: "http://example.com/tests/1?foo=1&bar=baz", }, }, { ExpectXML: `!]]>`, Value: &CDataTest{ Chardata: "Literal !", }, }, { ExpectXML: ` Literal!]]>`, Value: &CDataTest{ Chardata: " Literal!", }, }, { ExpectXML: ` Literal! Literal!]]>`, Value: &CDataTest{ Chardata: " Literal! Literal!", }, }, { ExpectXML: `]]]]>]]>`, Value: &CDataTest{ Chardata: "]]>", }, }, // Test omitempty with parent chain; see golang.org/issue/4168. { ExpectXML: ``, Value: &Strings{}, }, // Custom marshalers. { ExpectXML: `hello world`, Value: &MyMarshalerTest{}, }, { ExpectXML: ``, Value: &MarshalerStruct{}, }, { ExpectXML: ``, Value: &OuterStruct{IntAttr: 10}, }, { ExpectXML: ``, Value: &OuterNamedStruct{XMLName: Name{Space: "outerns", Local: "test"}, IntAttr: 10}, }, { ExpectXML: ``, Value: &OuterNamedOrderedStruct{XMLName: Name{Space: "outerns", Local: "test"}, IntAttr: 10}, }, { ExpectXML: ``, Value: &OuterOuterStruct{OuterStruct{IntAttr: 10}}, }, { ExpectXML: `test`, Value: &NestedAndChardata{AB: make([]string, 2), Chardata: "test"}, }, { ExpectXML: ``, Value: &NestedAndComment{AB: make([]string, 2), Comment: "test"}, }, { ExpectXML: ``, Value: &NestedAndCData{AB: make([]string, 2), CDATA: "test"}, }, // Test pointer indirection in various kinds of fields. // https://golang.org/issue/19063 { ExpectXML: ``, Value: &IndirComment{Comment: stringptr("hi")}, MarshalOnly: true, }, { ExpectXML: ``, Value: &IndirComment{Comment: stringptr("")}, MarshalOnly: true, }, { ExpectXML: ``, Value: &IndirComment{Comment: nil}, MarshalError: "xml: bad type for comment field of xml.IndirComment", }, { ExpectXML: ``, Value: &IndirComment{Comment: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceComment{Comment: "hi"}, MarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceComment{Comment: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceComment{Comment: nil}, MarshalError: "xml: bad type for comment field of xml.IfaceComment", }, { ExpectXML: ``, Value: &IfaceComment{Comment: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &DirectComment{Comment: string("hi")}, }, { ExpectXML: ``, Value: &DirectComment{Comment: string("")}, }, { ExpectXML: `hi`, Value: &IndirChardata{Chardata: stringptr("hi")}, }, { ExpectXML: ``, Value: &IndirChardata{Chardata: stringptr("hi")}, UnmarshalOnly: true, // marshals without CDATA }, { ExpectXML: ``, Value: &IndirChardata{Chardata: stringptr("")}, }, { ExpectXML: ``, Value: &IndirChardata{Chardata: nil}, MarshalOnly: true, // unmarshal leaves Chardata=stringptr("") }, { ExpectXML: `hi`, Value: &IfaceChardata{Chardata: string("hi")}, UnmarshalError: "cannot unmarshal into interface {}", }, { ExpectXML: ``, Value: &IfaceChardata{Chardata: string("hi")}, UnmarshalOnly: true, // marshals without CDATA UnmarshalError: "cannot unmarshal into interface {}", }, { ExpectXML: ``, Value: &IfaceChardata{Chardata: string("")}, UnmarshalError: "cannot unmarshal into interface {}", }, { ExpectXML: ``, Value: &IfaceChardata{Chardata: nil}, UnmarshalError: "cannot unmarshal into interface {}", }, { ExpectXML: `hi`, Value: &DirectChardata{Chardata: string("hi")}, }, { ExpectXML: ``, Value: &DirectChardata{Chardata: string("hi")}, UnmarshalOnly: true, // marshals without CDATA }, { ExpectXML: ``, Value: &DirectChardata{Chardata: string("")}, }, { ExpectXML: ``, Value: &IndirCDATA{CDATA: stringptr("hi")}, }, { ExpectXML: `hi`, Value: &IndirCDATA{CDATA: stringptr("hi")}, UnmarshalOnly: true, // marshals with CDATA }, { ExpectXML: ``, Value: &IndirCDATA{CDATA: stringptr("")}, }, { ExpectXML: ``, Value: &IndirCDATA{CDATA: nil}, MarshalOnly: true, // unmarshal leaves CDATA=stringptr("") }, { ExpectXML: ``, Value: &IfaceCDATA{CDATA: string("hi")}, UnmarshalError: "cannot unmarshal into interface {}", }, { ExpectXML: `hi`, Value: &IfaceCDATA{CDATA: string("hi")}, UnmarshalOnly: true, // marshals with CDATA UnmarshalError: "cannot unmarshal into interface {}", }, { ExpectXML: ``, Value: &IfaceCDATA{CDATA: string("")}, UnmarshalError: "cannot unmarshal into interface {}", }, { ExpectXML: ``, Value: &IfaceCDATA{CDATA: nil}, UnmarshalError: "cannot unmarshal into interface {}", }, { ExpectXML: ``, Value: &DirectCDATA{CDATA: string("hi")}, }, { ExpectXML: `hi`, Value: &DirectCDATA{CDATA: string("hi")}, UnmarshalOnly: true, // marshals with CDATA }, { ExpectXML: ``, Value: &DirectCDATA{CDATA: string("")}, }, { ExpectXML: ``, Value: &IndirInnerXML{InnerXML: stringptr("")}, MarshalOnly: true, }, { ExpectXML: ``, Value: &IndirInnerXML{InnerXML: stringptr("")}, MarshalOnly: true, }, { ExpectXML: ``, Value: &IndirInnerXML{InnerXML: nil}, }, { ExpectXML: ``, Value: &IndirInnerXML{InnerXML: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceInnerXML{InnerXML: ""}, MarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceInnerXML{InnerXML: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceInnerXML{InnerXML: nil}, }, { ExpectXML: ``, Value: &IfaceInnerXML{InnerXML: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &DirectInnerXML{InnerXML: string("")}, MarshalOnly: true, }, { ExpectXML: ``, Value: &DirectInnerXML{InnerXML: string("")}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &DirectInnerXML{InnerXML: string("")}, MarshalOnly: true, }, { ExpectXML: ``, Value: &DirectInnerXML{InnerXML: string("")}, UnmarshalOnly: true, }, { ExpectXML: `hi`, Value: &IndirElement{Element: stringptr("hi")}, }, { ExpectXML: ``, Value: &IndirElement{Element: stringptr("")}, }, { ExpectXML: ``, Value: &IndirElement{Element: nil}, }, { ExpectXML: `hi`, Value: &IfaceElement{Element: "hi"}, MarshalOnly: true, }, { ExpectXML: `hi`, Value: &IfaceElement{Element: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceElement{Element: nil}, }, { ExpectXML: ``, Value: &IfaceElement{Element: nil}, UnmarshalOnly: true, }, { ExpectXML: `hi`, Value: &DirectElement{Element: string("hi")}, }, { ExpectXML: ``, Value: &DirectElement{Element: string("")}, }, { ExpectXML: `hi`, Value: &IndirOmitEmpty{OmitEmpty: stringptr("hi")}, }, { // Note: Changed in Go 1.8 to include element (because x.OmitEmpty != nil). ExpectXML: ``, Value: &IndirOmitEmpty{OmitEmpty: stringptr("")}, MarshalOnly: true, }, { ExpectXML: ``, Value: &IndirOmitEmpty{OmitEmpty: stringptr("")}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IndirOmitEmpty{OmitEmpty: nil}, }, { ExpectXML: `hi`, Value: &IfaceOmitEmpty{OmitEmpty: "hi"}, MarshalOnly: true, }, { ExpectXML: `hi`, Value: &IfaceOmitEmpty{OmitEmpty: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceOmitEmpty{OmitEmpty: nil}, }, { ExpectXML: ``, Value: &IfaceOmitEmpty{OmitEmpty: nil}, UnmarshalOnly: true, }, { ExpectXML: `hi`, Value: &DirectOmitEmpty{OmitEmpty: string("hi")}, }, { ExpectXML: ``, Value: &DirectOmitEmpty{OmitEmpty: string("")}, }, { ExpectXML: `hi`, Value: &IndirAny{Any: stringptr("hi")}, }, { ExpectXML: ``, Value: &IndirAny{Any: stringptr("")}, }, { ExpectXML: ``, Value: &IndirAny{Any: nil}, }, { ExpectXML: `hi`, Value: &IfaceAny{Any: "hi"}, MarshalOnly: true, }, { ExpectXML: `hi`, Value: &IfaceAny{Any: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceAny{Any: nil}, }, { ExpectXML: ``, Value: &IfaceAny{Any: nil}, UnmarshalOnly: true, }, { ExpectXML: `hi`, Value: &DirectAny{Any: string("hi")}, }, { ExpectXML: ``, Value: &DirectAny{Any: string("")}, }, { ExpectXML: `hi`, Value: &IndirAny{Any: stringptr("hi")}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IndirAny{Any: stringptr("")}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IndirAny{Any: nil}, UnmarshalOnly: true, }, { ExpectXML: `hi`, Value: &IfaceAny{Any: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceAny{Any: nil}, UnmarshalOnly: true, }, { ExpectXML: ``, Value: &IfaceAny{Any: nil}, UnmarshalOnly: true, }, { ExpectXML: `hi`, Value: &DirectAny{Any: string("hi")}, UnmarshalOnly: true, }, { ExpectXML: ``, 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 any 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 any Prefix string Indent string ExpectXML string }{ { Value: &SecretAgent{ Handle: "007", Identity: "James Bond", Obfuscate: "", }, Prefix: "", Indent: "\t", ExpectXML: fmt.Sprintf("\n\tJames Bond\n"), }, } 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 == ``+ `b`+ `b1`+ `` { // 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 strings.Builder 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.String()) } 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 []any } 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 != "x" { 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: ``, }, { 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: ``, }, { 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: ``, }, { 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: ``, }, { desc: "more complex directive", toks: []Token{ Directive("DOCTYPE doc [ '> ]"), }, want: `'> ]>`, }, { 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 without start tag", }, { desc: "mismatching end tag local name", toks: []Token{ StartElement{Name{"", "foo"}, nil}, EndElement{Name{"", "bar"}}, }, err: "xml: end tag does not match start tag ", want: ``, }, { desc: "mismatching end tag namespace", toks: []Token{ StartElement{Name{"space", "foo"}, nil}, EndElement{Name{"another", "foo"}}, }, err: "xml: end tag in namespace another does not match start tag in namespace space", want: ``, }, { desc: "start element with explicit namespace", toks: []Token{ StartElement{Name{"space", "local"}, []Attr{ {Name{"xmlns", "x"}, "space"}, {Name{"space", "foo"}, "value"}, }}, }, want: ``, }, { 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: ``, }, { 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: ``, }, { 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: ``, }, { 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: ``, }, { 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: ``, }, { 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: ``, }, { 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: ``, }, { 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: ``, }, { desc: "redefine xmlns", toks: []Token{ StartElement{Name{"", "foo"}, []Attr{ {Name{"foo", "xmlns"}, "space"}, }}, }, want: ``, }, { desc: "xmlns with explicit name space #1", toks: []Token{ StartElement{Name{"space", "foo"}, []Attr{ {Name{"xml", "xmlns"}, "space"}, }}, }, want: ``, }, { desc: "xmlns with explicit name space #2", toks: []Token{ StartElement{Name{"space", "foo"}, []Attr{ {Name{xmlURL, "xmlns"}, "space"}, }}, }, want: ``, }, { desc: "empty name space declaration is ignored", toks: []Token{ StartElement{Name{"", "foo"}, []Attr{ {Name{"xmlns", "foo"}, ""}, }}, }, want: ``, }, { desc: "attribute with no name is ignored", toks: []Token{ StartElement{Name{"", "foo"}, []Attr{ {Name{"", ""}, "value"}, }}, }, want: ``, }, { desc: "namespace URL with non-valid name", toks: []Token{ StartElement{Name{"/34", "foo"}, []Attr{ {Name{"/34", "x"}, "value"}, }}, }, want: ``, }, { 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: ``, }, { desc: "nested element requires empty default name space", toks: []Token{ StartElement{Name{"space", "foo"}, []Attr{ {Name{"", "xmlns"}, "space"}, }}, StartElement{Name{"", "foo"}, nil}, }, want: ``, }, { 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: ``, }, { 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: ``, }, { 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: ``, }, { desc: "impossible xmlns declaration", toks: []Token{ StartElement{Name{"", "foo"}, []Attr{ {Name{"", "xmlns"}, "space"}, }}, StartElement{Name{"space", "bar"}, []Attr{ {Name{"space", "attr"}, "value"}, }}, }, want: ``, }, { desc: "reserved namespace prefix -- all lower case", toks: []Token{ StartElement{Name{"", "foo"}, []Attr{ {Name{"http://www.w3.org/2001/xmlSchema-instance", "nil"}, "true"}, }}, }, want: ``, }, { desc: "reserved namespace prefix -- all upper case", toks: []Token{ StartElement{Name{"", "foo"}, []Attr{ {Name{"http://www.w3.org/2001/XMLSchema-instance", "nil"}, "true"}, }}, }, want: ``, }, { desc: "reserved namespace prefix -- all mixed case", toks: []Token{ StartElement{Name{"", "foo"}, []Attr{ {Name{"http://www.w3.org/2001/XmLSchema-instance", "nil"}, "true"}, }}, }, want: ``, }} func TestEncodeToken(t *testing.T) { loop: for i, tt := range encodeTokenTests { var buf strings.Builder 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 ...any) { 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(` `) 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{ "<>", "< < > >", "' '>' >", " ]>", " '<' ' doc ANY> ]>", ">>> a < comment --> [ ] >", } testKO := []string{ "<", ">", "", "< > > < < >", " -->", "", "'", "", } 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 strings.Builder 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 := "" 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 = `` 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) } } // Issue 50164. Crash on zero value XML attribute. type LayerOne struct { XMLName Name `xml:"l1"` Value *float64 `xml:"value,omitempty"` *LayerTwo `xml:",omitempty"` } type LayerTwo struct { ValueTwo *int `xml:"value_two,attr,omitempty"` } func TestMarshalZeroValue(t *testing.T) { proofXml := `1.2345` var l1 LayerOne err := Unmarshal([]byte(proofXml), &l1) if err != nil { t.Fatalf("unmarshal XML error: %v", err) } want := float64(1.2345) got := *l1.Value if got != want { t.Fatalf("unexpected unmarshal result, want %f but got %f", want, got) } // Marshal again (or Encode again) // In issue 50164, here `Marshal(l1)` will panic because of the zero value of xml attribute ValueTwo `value_two`. anotherXML, err := Marshal(l1) if err != nil { t.Fatalf("marshal XML error: %v", err) } if string(anotherXML) != proofXml { t.Fatalf("unexpected unmarshal result, want %q but got %q", proofXml, anotherXML) } } var closeTests = []struct { desc string toks []Token want string err string }{{ desc: "unclosed start element", toks: []Token{ StartElement{Name{"", "foo"}, nil}, }, want: ``, err: "unclosed tag ", }, { desc: "closed element", toks: []Token{ StartElement{Name{"", "foo"}, nil}, EndElement{Name{"", "foo"}}, }, want: ``, }, { desc: "directive", toks: []Token{ Directive("foo"), }, want: ``, }} func TestClose(t *testing.T) { for _, tt := range closeTests { tt := tt t.Run(tt.desc, func(t *testing.T) { var out strings.Builder enc := NewEncoder(&out) for j, tok := range tt.toks { if err := enc.EncodeToken(tok); err != nil { t.Fatalf("token #%d: %v", j, err) } } err := enc.Close() switch { case tt.err != "" && err == nil: t.Error(" expected error; got none") case tt.err == "" && err != nil: t.Errorf(" got error: %v", err) case tt.err != "" && err != nil && tt.err != err.Error(): t.Errorf(" error mismatch; got %v, want %v", err, tt.err) } if got := out.String(); got != tt.want { t.Errorf("\ngot %v\nwant %v", got, tt.want) } t.Log(enc.p.closed) if err := enc.EncodeToken(Directive("foo")); err == nil { t.Errorf("unexpected success when encoding after Close") } }) } }