Source file src/golang.org/x/net/webdav/internal/xml/marshal_test.go

Documentation: golang.org/x/net/webdav/internal/xml

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package xml
     6  
     7  import (
     8  	"bytes"
     9  	"errors"
    10  	"fmt"
    11  	"io"
    12  	"reflect"
    13  	"strconv"
    14  	"strings"
    15  	"sync"
    16  	"testing"
    17  	"time"
    18  )
    19  
    20  type DriveType int
    21  
    22  const (
    23  	HyperDrive DriveType = iota
    24  	ImprobabilityDrive
    25  )
    26  
    27  type Passenger struct {
    28  	Name   []string `xml:"name"`
    29  	Weight float32  `xml:"weight"`
    30  }
    31  
    32  type Ship struct {
    33  	XMLName struct{} `xml:"spaceship"`
    34  
    35  	Name      string       `xml:"name,attr"`
    36  	Pilot     string       `xml:"pilot,attr"`
    37  	Drive     DriveType    `xml:"drive"`
    38  	Age       uint         `xml:"age"`
    39  	Passenger []*Passenger `xml:"passenger"`
    40  	secret    string
    41  }
    42  
    43  type NamedType string
    44  
    45  type Port struct {
    46  	XMLName struct{} `xml:"port"`
    47  	Type    string   `xml:"type,attr,omitempty"`
    48  	Comment string   `xml:",comment"`
    49  	Number  string   `xml:",chardata"`
    50  }
    51  
    52  type Domain struct {
    53  	XMLName struct{} `xml:"domain"`
    54  	Country string   `xml:",attr,omitempty"`
    55  	Name    []byte   `xml:",chardata"`
    56  	Comment []byte   `xml:",comment"`
    57  }
    58  
    59  type Book struct {
    60  	XMLName struct{} `xml:"book"`
    61  	Title   string   `xml:",chardata"`
    62  }
    63  
    64  type Event struct {
    65  	XMLName struct{} `xml:"event"`
    66  	Year    int      `xml:",chardata"`
    67  }
    68  
    69  type Movie struct {
    70  	XMLName struct{} `xml:"movie"`
    71  	Length  uint     `xml:",chardata"`
    72  }
    73  
    74  type Pi struct {
    75  	XMLName       struct{} `xml:"pi"`
    76  	Approximation float32  `xml:",chardata"`
    77  }
    78  
    79  type Universe struct {
    80  	XMLName struct{} `xml:"universe"`
    81  	Visible float64  `xml:",chardata"`
    82  }
    83  
    84  type Particle struct {
    85  	XMLName struct{} `xml:"particle"`
    86  	HasMass bool     `xml:",chardata"`
    87  }
    88  
    89  type Departure struct {
    90  	XMLName struct{}  `xml:"departure"`
    91  	When    time.Time `xml:",chardata"`
    92  }
    93  
    94  type SecretAgent struct {
    95  	XMLName   struct{} `xml:"agent"`
    96  	Handle    string   `xml:"handle,attr"`
    97  	Identity  string
    98  	Obfuscate string `xml:",innerxml"`
    99  }
   100  
   101  type NestedItems struct {
   102  	XMLName struct{} `xml:"result"`
   103  	Items   []string `xml:">item"`
   104  	Item1   []string `xml:"Items>item1"`
   105  }
   106  
   107  type NestedOrder struct {
   108  	XMLName struct{} `xml:"result"`
   109  	Field1  string   `xml:"parent>c"`
   110  	Field2  string   `xml:"parent>b"`
   111  	Field3  string   `xml:"parent>a"`
   112  }
   113  
   114  type MixedNested struct {
   115  	XMLName struct{} `xml:"result"`
   116  	A       string   `xml:"parent1>a"`
   117  	B       string   `xml:"b"`
   118  	C       string   `xml:"parent1>parent2>c"`
   119  	D       string   `xml:"parent1>d"`
   120  }
   121  
   122  type NilTest struct {
   123  	A interface{} `xml:"parent1>parent2>a"`
   124  	B interface{} `xml:"parent1>b"`
   125  	C interface{} `xml:"parent1>parent2>c"`
   126  }
   127  
   128  type Service struct {
   129  	XMLName struct{} `xml:"service"`
   130  	Domain  *Domain  `xml:"host>domain"`
   131  	Port    *Port    `xml:"host>port"`
   132  	Extra1  interface{}
   133  	Extra2  interface{} `xml:"host>extra2"`
   134  }
   135  
   136  var nilStruct *Ship
   137  
   138  type EmbedA struct {
   139  	EmbedC
   140  	EmbedB EmbedB
   141  	FieldA string
   142  }
   143  
   144  type EmbedB struct {
   145  	FieldB string
   146  	*EmbedC
   147  }
   148  
   149  type EmbedC struct {
   150  	FieldA1 string `xml:"FieldA>A1"`
   151  	FieldA2 string `xml:"FieldA>A2"`
   152  	FieldB  string
   153  	FieldC  string
   154  }
   155  
   156  type NameCasing struct {
   157  	XMLName struct{} `xml:"casing"`
   158  	Xy      string
   159  	XY      string
   160  	XyA     string `xml:"Xy,attr"`
   161  	XYA     string `xml:"XY,attr"`
   162  }
   163  
   164  type NamePrecedence struct {
   165  	XMLName     Name              `xml:"Parent"`
   166  	FromTag     XMLNameWithoutTag `xml:"InTag"`
   167  	FromNameVal XMLNameWithoutTag
   168  	FromNameTag XMLNameWithTag
   169  	InFieldName string
   170  }
   171  
   172  type XMLNameWithTag struct {
   173  	XMLName Name   `xml:"InXMLNameTag"`
   174  	Value   string `xml:",chardata"`
   175  }
   176  
   177  type XMLNameWithNSTag struct {
   178  	XMLName Name   `xml:"ns InXMLNameWithNSTag"`
   179  	Value   string `xml:",chardata"`
   180  }
   181  
   182  type XMLNameWithoutTag struct {
   183  	XMLName Name
   184  	Value   string `xml:",chardata"`
   185  }
   186  
   187  type NameInField struct {
   188  	Foo Name `xml:"ns foo"`
   189  }
   190  
   191  type AttrTest struct {
   192  	Int   int     `xml:",attr"`
   193  	Named int     `xml:"int,attr"`
   194  	Float float64 `xml:",attr"`
   195  	Uint8 uint8   `xml:",attr"`
   196  	Bool  bool    `xml:",attr"`
   197  	Str   string  `xml:",attr"`
   198  	Bytes []byte  `xml:",attr"`
   199  }
   200  
   201  type OmitAttrTest struct {
   202  	Int   int     `xml:",attr,omitempty"`
   203  	Named int     `xml:"int,attr,omitempty"`
   204  	Float float64 `xml:",attr,omitempty"`
   205  	Uint8 uint8   `xml:",attr,omitempty"`
   206  	Bool  bool    `xml:",attr,omitempty"`
   207  	Str   string  `xml:",attr,omitempty"`
   208  	Bytes []byte  `xml:",attr,omitempty"`
   209  }
   210  
   211  type OmitFieldTest struct {
   212  	Int   int           `xml:",omitempty"`
   213  	Named int           `xml:"int,omitempty"`
   214  	Float float64       `xml:",omitempty"`
   215  	Uint8 uint8         `xml:",omitempty"`
   216  	Bool  bool          `xml:",omitempty"`
   217  	Str   string        `xml:",omitempty"`
   218  	Bytes []byte        `xml:",omitempty"`
   219  	Ptr   *PresenceTest `xml:",omitempty"`
   220  }
   221  
   222  type AnyTest struct {
   223  	XMLName  struct{}  `xml:"a"`
   224  	Nested   string    `xml:"nested>value"`
   225  	AnyField AnyHolder `xml:",any"`
   226  }
   227  
   228  type AnyOmitTest struct {
   229  	XMLName  struct{}   `xml:"a"`
   230  	Nested   string     `xml:"nested>value"`
   231  	AnyField *AnyHolder `xml:",any,omitempty"`
   232  }
   233  
   234  type AnySliceTest struct {
   235  	XMLName  struct{}    `xml:"a"`
   236  	Nested   string      `xml:"nested>value"`
   237  	AnyField []AnyHolder `xml:",any"`
   238  }
   239  
   240  type AnyHolder struct {
   241  	XMLName Name
   242  	XML     string `xml:",innerxml"`
   243  }
   244  
   245  type RecurseA struct {
   246  	A string
   247  	B *RecurseB
   248  }
   249  
   250  type RecurseB struct {
   251  	A *RecurseA
   252  	B string
   253  }
   254  
   255  type PresenceTest struct {
   256  	Exists *struct{}
   257  }
   258  
   259  type IgnoreTest struct {
   260  	PublicSecret string `xml:"-"`
   261  }
   262  
   263  type MyBytes []byte
   264  
   265  type Data struct {
   266  	Bytes  []byte
   267  	Attr   []byte `xml:",attr"`
   268  	Custom MyBytes
   269  }
   270  
   271  type Plain struct {
   272  	V interface{}
   273  }
   274  
   275  type MyInt int
   276  
   277  type EmbedInt struct {
   278  	MyInt
   279  }
   280  
   281  type Strings struct {
   282  	X []string `xml:"A>B,omitempty"`
   283  }
   284  
   285  type PointerFieldsTest struct {
   286  	XMLName  Name    `xml:"dummy"`
   287  	Name     *string `xml:"name,attr"`
   288  	Age      *uint   `xml:"age,attr"`
   289  	Empty    *string `xml:"empty,attr"`
   290  	Contents *string `xml:",chardata"`
   291  }
   292  
   293  type ChardataEmptyTest struct {
   294  	XMLName  Name    `xml:"test"`
   295  	Contents *string `xml:",chardata"`
   296  }
   297  
   298  type MyMarshalerTest struct {
   299  }
   300  
   301  var _ Marshaler = (*MyMarshalerTest)(nil)
   302  
   303  func (m *MyMarshalerTest) MarshalXML(e *Encoder, start StartElement) error {
   304  	e.EncodeToken(start)
   305  	e.EncodeToken(CharData([]byte("hello world")))
   306  	e.EncodeToken(EndElement{start.Name})
   307  	return nil
   308  }
   309  
   310  type MyMarshalerAttrTest struct{}
   311  
   312  var _ MarshalerAttr = (*MyMarshalerAttrTest)(nil)
   313  
   314  func (m *MyMarshalerAttrTest) MarshalXMLAttr(name Name) (Attr, error) {
   315  	return Attr{name, "hello world"}, nil
   316  }
   317  
   318  type MyMarshalerValueAttrTest struct{}
   319  
   320  var _ MarshalerAttr = MyMarshalerValueAttrTest{}
   321  
   322  func (m MyMarshalerValueAttrTest) MarshalXMLAttr(name Name) (Attr, error) {
   323  	return Attr{name, "hello world"}, nil
   324  }
   325  
   326  type MarshalerStruct struct {
   327  	Foo MyMarshalerAttrTest `xml:",attr"`
   328  }
   329  
   330  type MarshalerValueStruct struct {
   331  	Foo MyMarshalerValueAttrTest `xml:",attr"`
   332  }
   333  
   334  type InnerStruct struct {
   335  	XMLName Name `xml:"testns outer"`
   336  }
   337  
   338  type OuterStruct struct {
   339  	InnerStruct
   340  	IntAttr int `xml:"int,attr"`
   341  }
   342  
   343  type OuterNamedStruct struct {
   344  	InnerStruct
   345  	XMLName Name `xml:"outerns test"`
   346  	IntAttr int  `xml:"int,attr"`
   347  }
   348  
   349  type OuterNamedOrderedStruct struct {
   350  	XMLName Name `xml:"outerns test"`
   351  	InnerStruct
   352  	IntAttr int `xml:"int,attr"`
   353  }
   354  
   355  type OuterOuterStruct struct {
   356  	OuterStruct
   357  }
   358  
   359  type NestedAndChardata struct {
   360  	AB       []string `xml:"A>B"`
   361  	Chardata string   `xml:",chardata"`
   362  }
   363  
   364  type NestedAndComment struct {
   365  	AB      []string `xml:"A>B"`
   366  	Comment string   `xml:",comment"`
   367  }
   368  
   369  type XMLNSFieldStruct struct {
   370  	Ns   string `xml:"xmlns,attr"`
   371  	Body string
   372  }
   373  
   374  type NamedXMLNSFieldStruct struct {
   375  	XMLName struct{} `xml:"testns test"`
   376  	Ns      string   `xml:"xmlns,attr"`
   377  	Body    string
   378  }
   379  
   380  type XMLNSFieldStructWithOmitEmpty struct {
   381  	Ns   string `xml:"xmlns,attr,omitempty"`
   382  	Body string
   383  }
   384  
   385  type NamedXMLNSFieldStructWithEmptyNamespace struct {
   386  	XMLName struct{} `xml:"test"`
   387  	Ns      string   `xml:"xmlns,attr"`
   388  	Body    string
   389  }
   390  
   391  type RecursiveXMLNSFieldStruct struct {
   392  	Ns   string                     `xml:"xmlns,attr"`
   393  	Body *RecursiveXMLNSFieldStruct `xml:",omitempty"`
   394  	Text string                     `xml:",omitempty"`
   395  }
   396  
   397  func ifaceptr(x interface{}) interface{} {
   398  	return &x
   399  }
   400  
   401  var (
   402  	nameAttr     = "Sarah"
   403  	ageAttr      = uint(12)
   404  	contentsAttr = "lorem ipsum"
   405  )
   406  
   407  // Unless explicitly stated as such (or *Plain), all of the
   408  // tests below are two-way tests. When introducing new tests,
   409  // please try to make them two-way as well to ensure that
   410  // marshalling and unmarshalling are as symmetrical as feasible.
   411  var marshalTests = []struct {
   412  	Value         interface{}
   413  	ExpectXML     string
   414  	MarshalOnly   bool
   415  	UnmarshalOnly bool
   416  }{
   417  	// Test nil marshals to nothing
   418  	{Value: nil, ExpectXML: ``, MarshalOnly: true},
   419  	{Value: nilStruct, ExpectXML: ``, MarshalOnly: true},
   420  
   421  	// Test value types
   422  	{Value: &Plain{true}, ExpectXML: `<Plain><V>true</V></Plain>`},
   423  	{Value: &Plain{false}, ExpectXML: `<Plain><V>false</V></Plain>`},
   424  	{Value: &Plain{int(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
   425  	{Value: &Plain{int8(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
   426  	{Value: &Plain{int16(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
   427  	{Value: &Plain{int32(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
   428  	{Value: &Plain{uint(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
   429  	{Value: &Plain{uint8(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
   430  	{Value: &Plain{uint16(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
   431  	{Value: &Plain{uint32(42)}, ExpectXML: `<Plain><V>42</V></Plain>`},
   432  	{Value: &Plain{float32(1.25)}, ExpectXML: `<Plain><V>1.25</V></Plain>`},
   433  	{Value: &Plain{float64(1.25)}, ExpectXML: `<Plain><V>1.25</V></Plain>`},
   434  	{Value: &Plain{uintptr(0xFFDD)}, ExpectXML: `<Plain><V>65501</V></Plain>`},
   435  	{Value: &Plain{"gopher"}, ExpectXML: `<Plain><V>gopher</V></Plain>`},
   436  	{Value: &Plain{[]byte("gopher")}, ExpectXML: `<Plain><V>gopher</V></Plain>`},
   437  	{Value: &Plain{"</>"}, ExpectXML: `<Plain><V>&lt;/&gt;</V></Plain>`},
   438  	{Value: &Plain{[]byte("</>")}, ExpectXML: `<Plain><V>&lt;/&gt;</V></Plain>`},
   439  	{Value: &Plain{[3]byte{'<', '/', '>'}}, ExpectXML: `<Plain><V>&lt;/&gt;</V></Plain>`},
   440  	{Value: &Plain{NamedType("potato")}, ExpectXML: `<Plain><V>potato</V></Plain>`},
   441  	{Value: &Plain{[]int{1, 2, 3}}, ExpectXML: `<Plain><V>1</V><V>2</V><V>3</V></Plain>`},
   442  	{Value: &Plain{[3]int{1, 2, 3}}, ExpectXML: `<Plain><V>1</V><V>2</V><V>3</V></Plain>`},
   443  	{Value: ifaceptr(true), MarshalOnly: true, ExpectXML: `<bool>true</bool>`},
   444  
   445  	// Test time.
   446  	{
   447  		Value:     &Plain{time.Unix(1e9, 123456789).UTC()},
   448  		ExpectXML: `<Plain><V>2001-09-09T01:46:40.123456789Z</V></Plain>`,
   449  	},
   450  
   451  	// A pointer to struct{} may be used to test for an element's presence.
   452  	{
   453  		Value:     &PresenceTest{new(struct{})},
   454  		ExpectXML: `<PresenceTest><Exists></Exists></PresenceTest>`,
   455  	},
   456  	{
   457  		Value:     &PresenceTest{},
   458  		ExpectXML: `<PresenceTest></PresenceTest>`,
   459  	},
   460  
   461  	// A pointer to struct{} may be used to test for an element's presence.
   462  	{
   463  		Value:     &PresenceTest{new(struct{})},
   464  		ExpectXML: `<PresenceTest><Exists></Exists></PresenceTest>`,
   465  	},
   466  	{
   467  		Value:     &PresenceTest{},
   468  		ExpectXML: `<PresenceTest></PresenceTest>`,
   469  	},
   470  
   471  	// A []byte field is only nil if the element was not found.
   472  	{
   473  		Value:         &Data{},
   474  		ExpectXML:     `<Data></Data>`,
   475  		UnmarshalOnly: true,
   476  	},
   477  	{
   478  		Value:         &Data{Bytes: []byte{}, Custom: MyBytes{}, Attr: []byte{}},
   479  		ExpectXML:     `<Data Attr=""><Bytes></Bytes><Custom></Custom></Data>`,
   480  		UnmarshalOnly: true,
   481  	},
   482  
   483  	// Check that []byte works, including named []byte types.
   484  	{
   485  		Value:     &Data{Bytes: []byte("ab"), Custom: MyBytes("cd"), Attr: []byte{'v'}},
   486  		ExpectXML: `<Data Attr="v"><Bytes>ab</Bytes><Custom>cd</Custom></Data>`,
   487  	},
   488  
   489  	// Test innerxml
   490  	{
   491  		Value: &SecretAgent{
   492  			Handle:    "007",
   493  			Identity:  "James Bond",
   494  			Obfuscate: "<redacted/>",
   495  		},
   496  		ExpectXML:   `<agent handle="007"><Identity>James Bond</Identity><redacted/></agent>`,
   497  		MarshalOnly: true,
   498  	},
   499  	{
   500  		Value: &SecretAgent{
   501  			Handle:    "007",
   502  			Identity:  "James Bond",
   503  			Obfuscate: "<Identity>James Bond</Identity><redacted/>",
   504  		},
   505  		ExpectXML:     `<agent handle="007"><Identity>James Bond</Identity><redacted/></agent>`,
   506  		UnmarshalOnly: true,
   507  	},
   508  
   509  	// Test structs
   510  	{Value: &Port{Type: "ssl", Number: "443"}, ExpectXML: `<port type="ssl">443</port>`},
   511  	{Value: &Port{Number: "443"}, ExpectXML: `<port>443</port>`},
   512  	{Value: &Port{Type: "<unix>"}, ExpectXML: `<port type="&lt;unix&gt;"></port>`},
   513  	{Value: &Port{Number: "443", Comment: "https"}, ExpectXML: `<port><!--https-->443</port>`},
   514  	{Value: &Port{Number: "443", Comment: "add space-"}, ExpectXML: `<port><!--add space- -->443</port>`, MarshalOnly: true},
   515  	{Value: &Domain{Name: []byte("google.com&friends")}, ExpectXML: `<domain>google.com&amp;friends</domain>`},
   516  	{Value: &Domain{Name: []byte("google.com"), Comment: []byte(" &friends ")}, ExpectXML: `<domain>google.com<!-- &friends --></domain>`},
   517  	{Value: &Book{Title: "Pride & Prejudice"}, ExpectXML: `<book>Pride &amp; Prejudice</book>`},
   518  	{Value: &Event{Year: -3114}, ExpectXML: `<event>-3114</event>`},
   519  	{Value: &Movie{Length: 13440}, ExpectXML: `<movie>13440</movie>`},
   520  	{Value: &Pi{Approximation: 3.14159265}, ExpectXML: `<pi>3.1415927</pi>`},
   521  	{Value: &Universe{Visible: 9.3e13}, ExpectXML: `<universe>9.3e+13</universe>`},
   522  	{Value: &Particle{HasMass: true}, ExpectXML: `<particle>true</particle>`},
   523  	{Value: &Departure{When: ParseTime("2013-01-09T00:15:00-09:00")}, ExpectXML: `<departure>2013-01-09T00:15:00-09:00</departure>`},
   524  	{Value: atomValue, ExpectXML: atomXml},
   525  	{
   526  		Value: &Ship{
   527  			Name:  "Heart of Gold",
   528  			Pilot: "Computer",
   529  			Age:   1,
   530  			Drive: ImprobabilityDrive,
   531  			Passenger: []*Passenger{
   532  				{
   533  					Name:   []string{"Zaphod", "Beeblebrox"},
   534  					Weight: 7.25,
   535  				},
   536  				{
   537  					Name:   []string{"Trisha", "McMillen"},
   538  					Weight: 5.5,
   539  				},
   540  				{
   541  					Name:   []string{"Ford", "Prefect"},
   542  					Weight: 7,
   543  				},
   544  				{
   545  					Name:   []string{"Arthur", "Dent"},
   546  					Weight: 6.75,
   547  				},
   548  			},
   549  		},
   550  		ExpectXML: `<spaceship name="Heart of Gold" pilot="Computer">` +
   551  			`<drive>` + strconv.Itoa(int(ImprobabilityDrive)) + `</drive>` +
   552  			`<age>1</age>` +
   553  			`<passenger>` +
   554  			`<name>Zaphod</name>` +
   555  			`<name>Beeblebrox</name>` +
   556  			`<weight>7.25</weight>` +
   557  			`</passenger>` +
   558  			`<passenger>` +
   559  			`<name>Trisha</name>` +
   560  			`<name>McMillen</name>` +
   561  			`<weight>5.5</weight>` +
   562  			`</passenger>` +
   563  			`<passenger>` +
   564  			`<name>Ford</name>` +
   565  			`<name>Prefect</name>` +
   566  			`<weight>7</weight>` +
   567  			`</passenger>` +
   568  			`<passenger>` +
   569  			`<name>Arthur</name>` +
   570  			`<name>Dent</name>` +
   571  			`<weight>6.75</weight>` +
   572  			`</passenger>` +
   573  			`</spaceship>`,
   574  	},
   575  
   576  	// Test a>b
   577  	{
   578  		Value: &NestedItems{Items: nil, Item1: nil},
   579  		ExpectXML: `<result>` +
   580  			`<Items>` +
   581  			`</Items>` +
   582  			`</result>`,
   583  	},
   584  	{
   585  		Value: &NestedItems{Items: []string{}, Item1: []string{}},
   586  		ExpectXML: `<result>` +
   587  			`<Items>` +
   588  			`</Items>` +
   589  			`</result>`,
   590  		MarshalOnly: true,
   591  	},
   592  	{
   593  		Value: &NestedItems{Items: nil, Item1: []string{"A"}},
   594  		ExpectXML: `<result>` +
   595  			`<Items>` +
   596  			`<item1>A</item1>` +
   597  			`</Items>` +
   598  			`</result>`,
   599  	},
   600  	{
   601  		Value: &NestedItems{Items: []string{"A", "B"}, Item1: nil},
   602  		ExpectXML: `<result>` +
   603  			`<Items>` +
   604  			`<item>A</item>` +
   605  			`<item>B</item>` +
   606  			`</Items>` +
   607  			`</result>`,
   608  	},
   609  	{
   610  		Value: &NestedItems{Items: []string{"A", "B"}, Item1: []string{"C"}},
   611  		ExpectXML: `<result>` +
   612  			`<Items>` +
   613  			`<item>A</item>` +
   614  			`<item>B</item>` +
   615  			`<item1>C</item1>` +
   616  			`</Items>` +
   617  			`</result>`,
   618  	},
   619  	{
   620  		Value: &NestedOrder{Field1: "C", Field2: "B", Field3: "A"},
   621  		ExpectXML: `<result>` +
   622  			`<parent>` +
   623  			`<c>C</c>` +
   624  			`<b>B</b>` +
   625  			`<a>A</a>` +
   626  			`</parent>` +
   627  			`</result>`,
   628  	},
   629  	{
   630  		Value: &NilTest{A: "A", B: nil, C: "C"},
   631  		ExpectXML: `<NilTest>` +
   632  			`<parent1>` +
   633  			`<parent2><a>A</a></parent2>` +
   634  			`<parent2><c>C</c></parent2>` +
   635  			`</parent1>` +
   636  			`</NilTest>`,
   637  		MarshalOnly: true, // Uses interface{}
   638  	},
   639  	{
   640  		Value: &MixedNested{A: "A", B: "B", C: "C", D: "D"},
   641  		ExpectXML: `<result>` +
   642  			`<parent1><a>A</a></parent1>` +
   643  			`<b>B</b>` +
   644  			`<parent1>` +
   645  			`<parent2><c>C</c></parent2>` +
   646  			`<d>D</d>` +
   647  			`</parent1>` +
   648  			`</result>`,
   649  	},
   650  	{
   651  		Value:     &Service{Port: &Port{Number: "80"}},
   652  		ExpectXML: `<service><host><port>80</port></host></service>`,
   653  	},
   654  	{
   655  		Value:     &Service{},
   656  		ExpectXML: `<service></service>`,
   657  	},
   658  	{
   659  		Value: &Service{Port: &Port{Number: "80"}, Extra1: "A", Extra2: "B"},
   660  		ExpectXML: `<service>` +
   661  			`<host><port>80</port></host>` +
   662  			`<Extra1>A</Extra1>` +
   663  			`<host><extra2>B</extra2></host>` +
   664  			`</service>`,
   665  		MarshalOnly: true,
   666  	},
   667  	{
   668  		Value: &Service{Port: &Port{Number: "80"}, Extra2: "example"},
   669  		ExpectXML: `<service>` +
   670  			`<host><port>80</port></host>` +
   671  			`<host><extra2>example</extra2></host>` +
   672  			`</service>`,
   673  		MarshalOnly: true,
   674  	},
   675  	{
   676  		Value: &struct {
   677  			XMLName struct{} `xml:"space top"`
   678  			A       string   `xml:"x>a"`
   679  			B       string   `xml:"x>b"`
   680  			C       string   `xml:"space x>c"`
   681  			C1      string   `xml:"space1 x>c"`
   682  			D1      string   `xml:"space1 x>d"`
   683  			E1      string   `xml:"x>e"`
   684  		}{
   685  			A:  "a",
   686  			B:  "b",
   687  			C:  "c",
   688  			C1: "c1",
   689  			D1: "d1",
   690  			E1: "e1",
   691  		},
   692  		ExpectXML: `<top xmlns="space">` +
   693  			`<x><a>a</a><b>b</b><c>c</c></x>` +
   694  			`<x xmlns="space1">` +
   695  			`<c>c1</c>` +
   696  			`<d>d1</d>` +
   697  			`</x>` +
   698  			`<x>` +
   699  			`<e>e1</e>` +
   700  			`</x>` +
   701  			`</top>`,
   702  	},
   703  	{
   704  		Value: &struct {
   705  			XMLName Name
   706  			A       string `xml:"x>a"`
   707  			B       string `xml:"x>b"`
   708  			C       string `xml:"space x>c"`
   709  			C1      string `xml:"space1 x>c"`
   710  			D1      string `xml:"space1 x>d"`
   711  		}{
   712  			XMLName: Name{
   713  				Space: "space0",
   714  				Local: "top",
   715  			},
   716  			A:  "a",
   717  			B:  "b",
   718  			C:  "c",
   719  			C1: "c1",
   720  			D1: "d1",
   721  		},
   722  		ExpectXML: `<top xmlns="space0">` +
   723  			`<x><a>a</a><b>b</b></x>` +
   724  			`<x xmlns="space"><c>c</c></x>` +
   725  			`<x xmlns="space1">` +
   726  			`<c>c1</c>` +
   727  			`<d>d1</d>` +
   728  			`</x>` +
   729  			`</top>`,
   730  	},
   731  	{
   732  		Value: &struct {
   733  			XMLName struct{} `xml:"top"`
   734  			B       string   `xml:"space x>b"`
   735  			B1      string   `xml:"space1 x>b"`
   736  		}{
   737  			B:  "b",
   738  			B1: "b1",
   739  		},
   740  		ExpectXML: `<top>` +
   741  			`<x xmlns="space"><b>b</b></x>` +
   742  			`<x xmlns="space1"><b>b1</b></x>` +
   743  			`</top>`,
   744  	},
   745  
   746  	// Test struct embedding
   747  	{
   748  		Value: &EmbedA{
   749  			EmbedC: EmbedC{
   750  				FieldA1: "", // Shadowed by A.A
   751  				FieldA2: "", // Shadowed by A.A
   752  				FieldB:  "A.C.B",
   753  				FieldC:  "A.C.C",
   754  			},
   755  			EmbedB: EmbedB{
   756  				FieldB: "A.B.B",
   757  				EmbedC: &EmbedC{
   758  					FieldA1: "A.B.C.A1",
   759  					FieldA2: "A.B.C.A2",
   760  					FieldB:  "", // Shadowed by A.B.B
   761  					FieldC:  "A.B.C.C",
   762  				},
   763  			},
   764  			FieldA: "A.A",
   765  		},
   766  		ExpectXML: `<EmbedA>` +
   767  			`<FieldB>A.C.B</FieldB>` +
   768  			`<FieldC>A.C.C</FieldC>` +
   769  			`<EmbedB>` +
   770  			`<FieldB>A.B.B</FieldB>` +
   771  			`<FieldA>` +
   772  			`<A1>A.B.C.A1</A1>` +
   773  			`<A2>A.B.C.A2</A2>` +
   774  			`</FieldA>` +
   775  			`<FieldC>A.B.C.C</FieldC>` +
   776  			`</EmbedB>` +
   777  			`<FieldA>A.A</FieldA>` +
   778  			`</EmbedA>`,
   779  	},
   780  
   781  	// Test that name casing matters
   782  	{
   783  		Value:     &NameCasing{Xy: "mixed", XY: "upper", XyA: "mixedA", XYA: "upperA"},
   784  		ExpectXML: `<casing Xy="mixedA" XY="upperA"><Xy>mixed</Xy><XY>upper</XY></casing>`,
   785  	},
   786  
   787  	// Test the order in which the XML element name is chosen
   788  	{
   789  		Value: &NamePrecedence{
   790  			FromTag:     XMLNameWithoutTag{Value: "A"},
   791  			FromNameVal: XMLNameWithoutTag{XMLName: Name{Local: "InXMLName"}, Value: "B"},
   792  			FromNameTag: XMLNameWithTag{Value: "C"},
   793  			InFieldName: "D",
   794  		},
   795  		ExpectXML: `<Parent>` +
   796  			`<InTag>A</InTag>` +
   797  			`<InXMLName>B</InXMLName>` +
   798  			`<InXMLNameTag>C</InXMLNameTag>` +
   799  			`<InFieldName>D</InFieldName>` +
   800  			`</Parent>`,
   801  		MarshalOnly: true,
   802  	},
   803  	{
   804  		Value: &NamePrecedence{
   805  			XMLName:     Name{Local: "Parent"},
   806  			FromTag:     XMLNameWithoutTag{XMLName: Name{Local: "InTag"}, Value: "A"},
   807  			FromNameVal: XMLNameWithoutTag{XMLName: Name{Local: "FromNameVal"}, Value: "B"},
   808  			FromNameTag: XMLNameWithTag{XMLName: Name{Local: "InXMLNameTag"}, Value: "C"},
   809  			InFieldName: "D",
   810  		},
   811  		ExpectXML: `<Parent>` +
   812  			`<InTag>A</InTag>` +
   813  			`<FromNameVal>B</FromNameVal>` +
   814  			`<InXMLNameTag>C</InXMLNameTag>` +
   815  			`<InFieldName>D</InFieldName>` +
   816  			`</Parent>`,
   817  		UnmarshalOnly: true,
   818  	},
   819  
   820  	// xml.Name works in a plain field as well.
   821  	{
   822  		Value:     &NameInField{Name{Space: "ns", Local: "foo"}},
   823  		ExpectXML: `<NameInField><foo xmlns="ns"></foo></NameInField>`,
   824  	},
   825  	{
   826  		Value:         &NameInField{Name{Space: "ns", Local: "foo"}},
   827  		ExpectXML:     `<NameInField><foo xmlns="ns"><ignore></ignore></foo></NameInField>`,
   828  		UnmarshalOnly: true,
   829  	},
   830  
   831  	// Marshaling zero xml.Name uses the tag or field name.
   832  	{
   833  		Value:       &NameInField{},
   834  		ExpectXML:   `<NameInField><foo xmlns="ns"></foo></NameInField>`,
   835  		MarshalOnly: true,
   836  	},
   837  
   838  	// Test attributes
   839  	{
   840  		Value: &AttrTest{
   841  			Int:   8,
   842  			Named: 9,
   843  			Float: 23.5,
   844  			Uint8: 255,
   845  			Bool:  true,
   846  			Str:   "str",
   847  			Bytes: []byte("byt"),
   848  		},
   849  		ExpectXML: `<AttrTest Int="8" int="9" Float="23.5" Uint8="255"` +
   850  			` Bool="true" Str="str" Bytes="byt"></AttrTest>`,
   851  	},
   852  	{
   853  		Value: &AttrTest{Bytes: []byte{}},
   854  		ExpectXML: `<AttrTest Int="0" int="0" Float="0" Uint8="0"` +
   855  			` Bool="false" Str="" Bytes=""></AttrTest>`,
   856  	},
   857  	{
   858  		Value: &OmitAttrTest{
   859  			Int:   8,
   860  			Named: 9,
   861  			Float: 23.5,
   862  			Uint8: 255,
   863  			Bool:  true,
   864  			Str:   "str",
   865  			Bytes: []byte("byt"),
   866  		},
   867  		ExpectXML: `<OmitAttrTest Int="8" int="9" Float="23.5" Uint8="255"` +
   868  			` Bool="true" Str="str" Bytes="byt"></OmitAttrTest>`,
   869  	},
   870  	{
   871  		Value:     &OmitAttrTest{},
   872  		ExpectXML: `<OmitAttrTest></OmitAttrTest>`,
   873  	},
   874  
   875  	// pointer fields
   876  	{
   877  		Value:       &PointerFieldsTest{Name: &nameAttr, Age: &ageAttr, Contents: &contentsAttr},
   878  		ExpectXML:   `<dummy name="Sarah" age="12">lorem ipsum</dummy>`,
   879  		MarshalOnly: true,
   880  	},
   881  
   882  	// empty chardata pointer field
   883  	{
   884  		Value:       &ChardataEmptyTest{},
   885  		ExpectXML:   `<test></test>`,
   886  		MarshalOnly: true,
   887  	},
   888  
   889  	// omitempty on fields
   890  	{
   891  		Value: &OmitFieldTest{
   892  			Int:   8,
   893  			Named: 9,
   894  			Float: 23.5,
   895  			Uint8: 255,
   896  			Bool:  true,
   897  			Str:   "str",
   898  			Bytes: []byte("byt"),
   899  			Ptr:   &PresenceTest{},
   900  		},
   901  		ExpectXML: `<OmitFieldTest>` +
   902  			`<Int>8</Int>` +
   903  			`<int>9</int>` +
   904  			`<Float>23.5</Float>` +
   905  			`<Uint8>255</Uint8>` +
   906  			`<Bool>true</Bool>` +
   907  			`<Str>str</Str>` +
   908  			`<Bytes>byt</Bytes>` +
   909  			`<Ptr></Ptr>` +
   910  			`</OmitFieldTest>`,
   911  	},
   912  	{
   913  		Value:     &OmitFieldTest{},
   914  		ExpectXML: `<OmitFieldTest></OmitFieldTest>`,
   915  	},
   916  
   917  	// Test ",any"
   918  	{
   919  		ExpectXML: `<a><nested><value>known</value></nested><other><sub>unknown</sub></other></a>`,
   920  		Value: &AnyTest{
   921  			Nested: "known",
   922  			AnyField: AnyHolder{
   923  				XMLName: Name{Local: "other"},
   924  				XML:     "<sub>unknown</sub>",
   925  			},
   926  		},
   927  	},
   928  	{
   929  		Value: &AnyTest{Nested: "known",
   930  			AnyField: AnyHolder{
   931  				XML:     "<unknown/>",
   932  				XMLName: Name{Local: "AnyField"},
   933  			},
   934  		},
   935  		ExpectXML: `<a><nested><value>known</value></nested><AnyField><unknown/></AnyField></a>`,
   936  	},
   937  	{
   938  		ExpectXML: `<a><nested><value>b</value></nested></a>`,
   939  		Value: &AnyOmitTest{
   940  			Nested: "b",
   941  		},
   942  	},
   943  	{
   944  		ExpectXML: `<a><nested><value>b</value></nested><c><d>e</d></c><g xmlns="f"><h>i</h></g></a>`,
   945  		Value: &AnySliceTest{
   946  			Nested: "b",
   947  			AnyField: []AnyHolder{
   948  				{
   949  					XMLName: Name{Local: "c"},
   950  					XML:     "<d>e</d>",
   951  				},
   952  				{
   953  					XMLName: Name{Space: "f", Local: "g"},
   954  					XML:     "<h>i</h>",
   955  				},
   956  			},
   957  		},
   958  	},
   959  	{
   960  		ExpectXML: `<a><nested><value>b</value></nested></a>`,
   961  		Value: &AnySliceTest{
   962  			Nested: "b",
   963  		},
   964  	},
   965  
   966  	// Test recursive types.
   967  	{
   968  		Value: &RecurseA{
   969  			A: "a1",
   970  			B: &RecurseB{
   971  				A: &RecurseA{"a2", nil},
   972  				B: "b1",
   973  			},
   974  		},
   975  		ExpectXML: `<RecurseA><A>a1</A><B><A><A>a2</A></A><B>b1</B></B></RecurseA>`,
   976  	},
   977  
   978  	// Test ignoring fields via "-" tag
   979  	{
   980  		ExpectXML: `<IgnoreTest></IgnoreTest>`,
   981  		Value:     &IgnoreTest{},
   982  	},
   983  	{
   984  		ExpectXML:   `<IgnoreTest></IgnoreTest>`,
   985  		Value:       &IgnoreTest{PublicSecret: "can't tell"},
   986  		MarshalOnly: true,
   987  	},
   988  	{
   989  		ExpectXML:     `<IgnoreTest><PublicSecret>ignore me</PublicSecret></IgnoreTest>`,
   990  		Value:         &IgnoreTest{},
   991  		UnmarshalOnly: true,
   992  	},
   993  
   994  	// Test escaping.
   995  	{
   996  		ExpectXML: `<a><nested><value>dquote: &#34;; squote: &#39;; ampersand: &amp;; less: &lt;; greater: &gt;;</value></nested><empty></empty></a>`,
   997  		Value: &AnyTest{
   998  			Nested:   `dquote: "; squote: '; ampersand: &; less: <; greater: >;`,
   999  			AnyField: AnyHolder{XMLName: Name{Local: "empty"}},
  1000  		},
  1001  	},
  1002  	{
  1003  		ExpectXML: `<a><nested><value>newline: &#xA;; cr: &#xD;; tab: &#x9;;</value></nested><AnyField></AnyField></a>`,
  1004  		Value: &AnyTest{
  1005  			Nested:   "newline: \n; cr: \r; tab: \t;",
  1006  			AnyField: AnyHolder{XMLName: Name{Local: "AnyField"}},
  1007  		},
  1008  	},
  1009  	{
  1010  		ExpectXML: "<a><nested><value>1\r2\r\n3\n\r4\n5</value></nested></a>",
  1011  		Value: &AnyTest{
  1012  			Nested: "1\n2\n3\n\n4\n5",
  1013  		},
  1014  		UnmarshalOnly: true,
  1015  	},
  1016  	{
  1017  		ExpectXML: `<EmbedInt><MyInt>42</MyInt></EmbedInt>`,
  1018  		Value: &EmbedInt{
  1019  			MyInt: 42,
  1020  		},
  1021  	},
  1022  	// Test omitempty with parent chain; see golang.org/issue/4168.
  1023  	{
  1024  		ExpectXML: `<Strings><A></A></Strings>`,
  1025  		Value:     &Strings{},
  1026  	},
  1027  	// Custom marshalers.
  1028  	{
  1029  		ExpectXML: `<MyMarshalerTest>hello world</MyMarshalerTest>`,
  1030  		Value:     &MyMarshalerTest{},
  1031  	},
  1032  	{
  1033  		ExpectXML: `<MarshalerStruct Foo="hello world"></MarshalerStruct>`,
  1034  		Value:     &MarshalerStruct{},
  1035  	},
  1036  	{
  1037  		ExpectXML: `<MarshalerValueStruct Foo="hello world"></MarshalerValueStruct>`,
  1038  		Value:     &MarshalerValueStruct{},
  1039  	},
  1040  	{
  1041  		ExpectXML: `<outer xmlns="testns" int="10"></outer>`,
  1042  		Value:     &OuterStruct{IntAttr: 10},
  1043  	},
  1044  	{
  1045  		ExpectXML: `<test xmlns="outerns" int="10"></test>`,
  1046  		Value:     &OuterNamedStruct{XMLName: Name{Space: "outerns", Local: "test"}, IntAttr: 10},
  1047  	},
  1048  	{
  1049  		ExpectXML: `<test xmlns="outerns" int="10"></test>`,
  1050  		Value:     &OuterNamedOrderedStruct{XMLName: Name{Space: "outerns", Local: "test"}, IntAttr: 10},
  1051  	},
  1052  	{
  1053  		ExpectXML: `<outer xmlns="testns" int="10"></outer>`,
  1054  		Value:     &OuterOuterStruct{OuterStruct{IntAttr: 10}},
  1055  	},
  1056  	{
  1057  		ExpectXML: `<NestedAndChardata><A><B></B><B></B></A>test</NestedAndChardata>`,
  1058  		Value:     &NestedAndChardata{AB: make([]string, 2), Chardata: "test"},
  1059  	},
  1060  	{
  1061  		ExpectXML: `<NestedAndComment><A><B></B><B></B></A><!--test--></NestedAndComment>`,
  1062  		Value:     &NestedAndComment{AB: make([]string, 2), Comment: "test"},
  1063  	},
  1064  	{
  1065  		ExpectXML: `<XMLNSFieldStruct xmlns="http://example.com/ns"><Body>hello world</Body></XMLNSFieldStruct>`,
  1066  		Value:     &XMLNSFieldStruct{Ns: "http://example.com/ns", Body: "hello world"},
  1067  	},
  1068  	{
  1069  		ExpectXML: `<testns:test xmlns:testns="testns" xmlns="http://example.com/ns"><Body>hello world</Body></testns:test>`,
  1070  		Value:     &NamedXMLNSFieldStruct{Ns: "http://example.com/ns", Body: "hello world"},
  1071  	},
  1072  	{
  1073  		ExpectXML: `<testns:test xmlns:testns="testns"><Body>hello world</Body></testns:test>`,
  1074  		Value:     &NamedXMLNSFieldStruct{Ns: "", Body: "hello world"},
  1075  	},
  1076  	{
  1077  		ExpectXML: `<XMLNSFieldStructWithOmitEmpty><Body>hello world</Body></XMLNSFieldStructWithOmitEmpty>`,
  1078  		Value:     &XMLNSFieldStructWithOmitEmpty{Body: "hello world"},
  1079  	},
  1080  	{
  1081  		// The xmlns attribute must be ignored because the <test>
  1082  		// element is in the empty namespace, so it's not possible
  1083  		// to set the default namespace to something non-empty.
  1084  		ExpectXML:   `<test><Body>hello world</Body></test>`,
  1085  		Value:       &NamedXMLNSFieldStructWithEmptyNamespace{Ns: "foo", Body: "hello world"},
  1086  		MarshalOnly: true,
  1087  	},
  1088  	{
  1089  		ExpectXML: `<RecursiveXMLNSFieldStruct xmlns="foo"><Body xmlns=""><Text>hello world</Text></Body></RecursiveXMLNSFieldStruct>`,
  1090  		Value: &RecursiveXMLNSFieldStruct{
  1091  			Ns: "foo",
  1092  			Body: &RecursiveXMLNSFieldStruct{
  1093  				Text: "hello world",
  1094  			},
  1095  		},
  1096  	},
  1097  }
  1098  
  1099  func TestMarshal(t *testing.T) {
  1100  	for idx, test := range marshalTests {
  1101  		if test.UnmarshalOnly {
  1102  			continue
  1103  		}
  1104  		data, err := Marshal(test.Value)
  1105  		if err != nil {
  1106  			t.Errorf("#%d: marshal(%#v): %s", idx, test.Value, err)
  1107  			continue
  1108  		}
  1109  		if got, want := string(data), test.ExpectXML; got != want {
  1110  			if strings.Contains(want, "\n") {
  1111  				t.Errorf("#%d: marshal(%#v):\nHAVE:\n%s\nWANT:\n%s", idx, test.Value, got, want)
  1112  			} else {
  1113  				t.Errorf("#%d: marshal(%#v):\nhave %#q\nwant %#q", idx, test.Value, got, want)
  1114  			}
  1115  		}
  1116  	}
  1117  }
  1118  
  1119  type AttrParent struct {
  1120  	X string `xml:"X>Y,attr"`
  1121  }
  1122  
  1123  type BadAttr struct {
  1124  	Name []string `xml:"name,attr"`
  1125  }
  1126  
  1127  var marshalErrorTests = []struct {
  1128  	Value interface{}
  1129  	Err   string
  1130  	Kind  reflect.Kind
  1131  }{
  1132  	{
  1133  		Value: make(chan bool),
  1134  		Err:   "xml: unsupported type: chan bool",
  1135  		Kind:  reflect.Chan,
  1136  	},
  1137  	{
  1138  		Value: map[string]string{
  1139  			"question": "What do you get when you multiply six by nine?",
  1140  			"answer":   "42",
  1141  		},
  1142  		Err:  "xml: unsupported type: map[string]string",
  1143  		Kind: reflect.Map,
  1144  	},
  1145  	{
  1146  		Value: map[*Ship]bool{nil: false},
  1147  		Err:   "xml: unsupported type: map[*xml.Ship]bool",
  1148  		Kind:  reflect.Map,
  1149  	},
  1150  	{
  1151  		Value: &Domain{Comment: []byte("f--bar")},
  1152  		Err:   `xml: comments must not contain "--"`,
  1153  	},
  1154  	// Reject parent chain with attr, never worked; see golang.org/issue/5033.
  1155  	{
  1156  		Value: &AttrParent{},
  1157  		Err:   `xml: X>Y chain not valid with attr flag`,
  1158  	},
  1159  	{
  1160  		Value: BadAttr{[]string{"X", "Y"}},
  1161  		Err:   `xml: unsupported type: []string`,
  1162  	},
  1163  }
  1164  
  1165  var marshalIndentTests = []struct {
  1166  	Value     interface{}
  1167  	Prefix    string
  1168  	Indent    string
  1169  	ExpectXML string
  1170  }{
  1171  	{
  1172  		Value: &SecretAgent{
  1173  			Handle:    "007",
  1174  			Identity:  "James Bond",
  1175  			Obfuscate: "<redacted/>",
  1176  		},
  1177  		Prefix:    "",
  1178  		Indent:    "\t",
  1179  		ExpectXML: fmt.Sprintf("<agent handle=\"007\">\n\t<Identity>James Bond</Identity><redacted/>\n</agent>"),
  1180  	},
  1181  }
  1182  
  1183  func TestMarshalErrors(t *testing.T) {
  1184  	for idx, test := range marshalErrorTests {
  1185  		data, err := Marshal(test.Value)
  1186  		if err == nil {
  1187  			t.Errorf("#%d: marshal(%#v) = [success] %q, want error %v", idx, test.Value, data, test.Err)
  1188  			continue
  1189  		}
  1190  		if err.Error() != test.Err {
  1191  			t.Errorf("#%d: marshal(%#v) = [error] %v, want %v", idx, test.Value, err, test.Err)
  1192  		}
  1193  		if test.Kind != reflect.Invalid {
  1194  			if kind := err.(*UnsupportedTypeError).Type.Kind(); kind != test.Kind {
  1195  				t.Errorf("#%d: marshal(%#v) = [error kind] %s, want %s", idx, test.Value, kind, test.Kind)
  1196  			}
  1197  		}
  1198  	}
  1199  }
  1200  
  1201  // Do invertibility testing on the various structures that we test
  1202  func TestUnmarshal(t *testing.T) {
  1203  	for i, test := range marshalTests {
  1204  		if test.MarshalOnly {
  1205  			continue
  1206  		}
  1207  		if _, ok := test.Value.(*Plain); ok {
  1208  			continue
  1209  		}
  1210  		vt := reflect.TypeOf(test.Value)
  1211  		dest := reflect.New(vt.Elem()).Interface()
  1212  		err := Unmarshal([]byte(test.ExpectXML), dest)
  1213  
  1214  		switch fix := dest.(type) {
  1215  		case *Feed:
  1216  			fix.Author.InnerXML = ""
  1217  			for i := range fix.Entry {
  1218  				fix.Entry[i].Author.InnerXML = ""
  1219  			}
  1220  		}
  1221  
  1222  		if err != nil {
  1223  			t.Errorf("#%d: unexpected error: %#v", i, err)
  1224  		} else if got, want := dest, test.Value; !reflect.DeepEqual(got, want) {
  1225  			t.Errorf("#%d: unmarshal(%q):\nhave %#v\nwant %#v", i, test.ExpectXML, got, want)
  1226  		}
  1227  	}
  1228  }
  1229  
  1230  func TestMarshalIndent(t *testing.T) {
  1231  	for i, test := range marshalIndentTests {
  1232  		data, err := MarshalIndent(test.Value, test.Prefix, test.Indent)
  1233  		if err != nil {
  1234  			t.Errorf("#%d: Error: %s", i, err)
  1235  			continue
  1236  		}
  1237  		if got, want := string(data), test.ExpectXML; got != want {
  1238  			t.Errorf("#%d: MarshalIndent:\nGot:%s\nWant:\n%s", i, got, want)
  1239  		}
  1240  	}
  1241  }
  1242  
  1243  type limitedBytesWriter struct {
  1244  	w      io.Writer
  1245  	remain int // until writes fail
  1246  }
  1247  
  1248  func (lw *limitedBytesWriter) Write(p []byte) (n int, err error) {
  1249  	if lw.remain <= 0 {
  1250  		println("error")
  1251  		return 0, errors.New("write limit hit")
  1252  	}
  1253  	if len(p) > lw.remain {
  1254  		p = p[:lw.remain]
  1255  		n, _ = lw.w.Write(p)
  1256  		lw.remain = 0
  1257  		return n, errors.New("write limit hit")
  1258  	}
  1259  	n, err = lw.w.Write(p)
  1260  	lw.remain -= n
  1261  	return n, err
  1262  }
  1263  
  1264  func TestMarshalWriteErrors(t *testing.T) {
  1265  	var buf bytes.Buffer
  1266  	const writeCap = 1024
  1267  	w := &limitedBytesWriter{&buf, writeCap}
  1268  	enc := NewEncoder(w)
  1269  	var err error
  1270  	var i int
  1271  	const n = 4000
  1272  	for i = 1; i <= n; i++ {
  1273  		err = enc.Encode(&Passenger{
  1274  			Name:   []string{"Alice", "Bob"},
  1275  			Weight: 5,
  1276  		})
  1277  		if err != nil {
  1278  			break
  1279  		}
  1280  	}
  1281  	if err == nil {
  1282  		t.Error("expected an error")
  1283  	}
  1284  	if i == n {
  1285  		t.Errorf("expected to fail before the end")
  1286  	}
  1287  	if buf.Len() != writeCap {
  1288  		t.Errorf("buf.Len() = %d; want %d", buf.Len(), writeCap)
  1289  	}
  1290  }
  1291  
  1292  func TestMarshalWriteIOErrors(t *testing.T) {
  1293  	enc := NewEncoder(errWriter{})
  1294  
  1295  	expectErr := "unwritable"
  1296  	err := enc.Encode(&Passenger{})
  1297  	if err == nil || err.Error() != expectErr {
  1298  		t.Errorf("EscapeTest = [error] %v, want %v", err, expectErr)
  1299  	}
  1300  }
  1301  
  1302  func TestMarshalFlush(t *testing.T) {
  1303  	var buf bytes.Buffer
  1304  	enc := NewEncoder(&buf)
  1305  	if err := enc.EncodeToken(CharData("hello world")); err != nil {
  1306  		t.Fatalf("enc.EncodeToken: %v", err)
  1307  	}
  1308  	if buf.Len() > 0 {
  1309  		t.Fatalf("enc.EncodeToken caused actual write: %q", buf.Bytes())
  1310  	}
  1311  	if err := enc.Flush(); err != nil {
  1312  		t.Fatalf("enc.Flush: %v", err)
  1313  	}
  1314  	if buf.String() != "hello world" {
  1315  		t.Fatalf("after enc.Flush, buf.String() = %q, want %q", buf.String(), "hello world")
  1316  	}
  1317  }
  1318  
  1319  var encodeElementTests = []struct {
  1320  	desc      string
  1321  	value     interface{}
  1322  	start     StartElement
  1323  	expectXML string
  1324  }{{
  1325  	desc:  "simple string",
  1326  	value: "hello",
  1327  	start: StartElement{
  1328  		Name: Name{Local: "a"},
  1329  	},
  1330  	expectXML: `<a>hello</a>`,
  1331  }, {
  1332  	desc:  "string with added attributes",
  1333  	value: "hello",
  1334  	start: StartElement{
  1335  		Name: Name{Local: "a"},
  1336  		Attr: []Attr{{
  1337  			Name:  Name{Local: "x"},
  1338  			Value: "y",
  1339  		}, {
  1340  			Name:  Name{Local: "foo"},
  1341  			Value: "bar",
  1342  		}},
  1343  	},
  1344  	expectXML: `<a x="y" foo="bar">hello</a>`,
  1345  }, {
  1346  	desc: "start element with default name space",
  1347  	value: struct {
  1348  		Foo XMLNameWithNSTag
  1349  	}{
  1350  		Foo: XMLNameWithNSTag{
  1351  			Value: "hello",
  1352  		},
  1353  	},
  1354  	start: StartElement{
  1355  		Name: Name{Space: "ns", Local: "a"},
  1356  		Attr: []Attr{{
  1357  			Name: Name{Local: "xmlns"},
  1358  			// "ns" is the name space defined in XMLNameWithNSTag
  1359  			Value: "ns",
  1360  		}},
  1361  	},
  1362  	expectXML: `<a xmlns="ns"><InXMLNameWithNSTag>hello</InXMLNameWithNSTag></a>`,
  1363  }, {
  1364  	desc: "start element in name space with different default name space",
  1365  	value: struct {
  1366  		Foo XMLNameWithNSTag
  1367  	}{
  1368  		Foo: XMLNameWithNSTag{
  1369  			Value: "hello",
  1370  		},
  1371  	},
  1372  	start: StartElement{
  1373  		Name: Name{Space: "ns2", Local: "a"},
  1374  		Attr: []Attr{{
  1375  			Name: Name{Local: "xmlns"},
  1376  			// "ns" is the name space defined in XMLNameWithNSTag
  1377  			Value: "ns",
  1378  		}},
  1379  	},
  1380  	expectXML: `<ns2:a xmlns:ns2="ns2" xmlns="ns"><InXMLNameWithNSTag>hello</InXMLNameWithNSTag></ns2:a>`,
  1381  }, {
  1382  	desc:  "XMLMarshaler with start element with default name space",
  1383  	value: &MyMarshalerTest{},
  1384  	start: StartElement{
  1385  		Name: Name{Space: "ns2", Local: "a"},
  1386  		Attr: []Attr{{
  1387  			Name: Name{Local: "xmlns"},
  1388  			// "ns" is the name space defined in XMLNameWithNSTag
  1389  			Value: "ns",
  1390  		}},
  1391  	},
  1392  	expectXML: `<ns2:a xmlns:ns2="ns2" xmlns="ns">hello world</ns2:a>`,
  1393  }}
  1394  
  1395  func TestEncodeElement(t *testing.T) {
  1396  	for idx, test := range encodeElementTests {
  1397  		var buf bytes.Buffer
  1398  		enc := NewEncoder(&buf)
  1399  		err := enc.EncodeElement(test.value, test.start)
  1400  		if err != nil {
  1401  			t.Fatalf("enc.EncodeElement: %v", err)
  1402  		}
  1403  		err = enc.Flush()
  1404  		if err != nil {
  1405  			t.Fatalf("enc.Flush: %v", err)
  1406  		}
  1407  		if got, want := buf.String(), test.expectXML; got != want {
  1408  			t.Errorf("#%d(%s): EncodeElement(%#v, %#v):\nhave %#q\nwant %#q", idx, test.desc, test.value, test.start, got, want)
  1409  		}
  1410  	}
  1411  }
  1412  
  1413  func BenchmarkMarshal(b *testing.B) {
  1414  	b.ReportAllocs()
  1415  	for i := 0; i < b.N; i++ {
  1416  		Marshal(atomValue)
  1417  	}
  1418  }
  1419  
  1420  func BenchmarkUnmarshal(b *testing.B) {
  1421  	b.ReportAllocs()
  1422  	xml := []byte(atomXml)
  1423  	for i := 0; i < b.N; i++ {
  1424  		Unmarshal(xml, &Feed{})
  1425  	}
  1426  }
  1427  
  1428  // golang.org/issue/6556
  1429  func TestStructPointerMarshal(t *testing.T) {
  1430  	type A struct {
  1431  		XMLName string `xml:"a"`
  1432  		B       []interface{}
  1433  	}
  1434  	type C struct {
  1435  		XMLName Name
  1436  		Value   string `xml:"value"`
  1437  	}
  1438  
  1439  	a := new(A)
  1440  	a.B = append(a.B, &C{
  1441  		XMLName: Name{Local: "c"},
  1442  		Value:   "x",
  1443  	})
  1444  
  1445  	b, err := Marshal(a)
  1446  	if err != nil {
  1447  		t.Fatal(err)
  1448  	}
  1449  	if x := string(b); x != "<a><c><value>x</value></c></a>" {
  1450  		t.Fatal(x)
  1451  	}
  1452  	var v A
  1453  	err = Unmarshal(b, &v)
  1454  	if err != nil {
  1455  		t.Fatal(err)
  1456  	}
  1457  }
  1458  
  1459  var encodeTokenTests = []struct {
  1460  	desc string
  1461  	toks []Token
  1462  	want string
  1463  	err  string
  1464  }{{
  1465  	desc: "start element with name space",
  1466  	toks: []Token{
  1467  		StartElement{Name{"space", "local"}, nil},
  1468  	},
  1469  	want: `<space:local xmlns:space="space">`,
  1470  }, {
  1471  	desc: "start element with no name",
  1472  	toks: []Token{
  1473  		StartElement{Name{"space", ""}, nil},
  1474  	},
  1475  	err: "xml: start tag with no name",
  1476  }, {
  1477  	desc: "end element with no name",
  1478  	toks: []Token{
  1479  		EndElement{Name{"space", ""}},
  1480  	},
  1481  	err: "xml: end tag with no name",
  1482  }, {
  1483  	desc: "char data",
  1484  	toks: []Token{
  1485  		CharData("foo"),
  1486  	},
  1487  	want: `foo`,
  1488  }, {
  1489  	desc: "char data with escaped chars",
  1490  	toks: []Token{
  1491  		CharData(" \t\n"),
  1492  	},
  1493  	want: " &#x9;\n",
  1494  }, {
  1495  	desc: "comment",
  1496  	toks: []Token{
  1497  		Comment("foo"),
  1498  	},
  1499  	want: `<!--foo-->`,
  1500  }, {
  1501  	desc: "comment with invalid content",
  1502  	toks: []Token{
  1503  		Comment("foo-->"),
  1504  	},
  1505  	err: "xml: EncodeToken of Comment containing --> marker",
  1506  }, {
  1507  	desc: "proc instruction",
  1508  	toks: []Token{
  1509  		ProcInst{"Target", []byte("Instruction")},
  1510  	},
  1511  	want: `<?Target Instruction?>`,
  1512  }, {
  1513  	desc: "proc instruction with empty target",
  1514  	toks: []Token{
  1515  		ProcInst{"", []byte("Instruction")},
  1516  	},
  1517  	err: "xml: EncodeToken of ProcInst with invalid Target",
  1518  }, {
  1519  	desc: "proc instruction with bad content",
  1520  	toks: []Token{
  1521  		ProcInst{"", []byte("Instruction?>")},
  1522  	},
  1523  	err: "xml: EncodeToken of ProcInst with invalid Target",
  1524  }, {
  1525  	desc: "directive",
  1526  	toks: []Token{
  1527  		Directive("foo"),
  1528  	},
  1529  	want: `<!foo>`,
  1530  }, {
  1531  	desc: "more complex directive",
  1532  	toks: []Token{
  1533  		Directive("DOCTYPE doc [ <!ELEMENT doc '>'> <!-- com>ment --> ]"),
  1534  	},
  1535  	want: `<!DOCTYPE doc [ <!ELEMENT doc '>'> <!-- com>ment --> ]>`,
  1536  }, {
  1537  	desc: "directive instruction with bad name",
  1538  	toks: []Token{
  1539  		Directive("foo>"),
  1540  	},
  1541  	err: "xml: EncodeToken of Directive containing wrong < or > markers",
  1542  }, {
  1543  	desc: "end tag without start tag",
  1544  	toks: []Token{
  1545  		EndElement{Name{"foo", "bar"}},
  1546  	},
  1547  	err: "xml: end tag </bar> without start tag",
  1548  }, {
  1549  	desc: "mismatching end tag local name",
  1550  	toks: []Token{
  1551  		StartElement{Name{"", "foo"}, nil},
  1552  		EndElement{Name{"", "bar"}},
  1553  	},
  1554  	err:  "xml: end tag </bar> does not match start tag <foo>",
  1555  	want: `<foo>`,
  1556  }, {
  1557  	desc: "mismatching end tag namespace",
  1558  	toks: []Token{
  1559  		StartElement{Name{"space", "foo"}, nil},
  1560  		EndElement{Name{"another", "foo"}},
  1561  	},
  1562  	err:  "xml: end tag </foo> in namespace another does not match start tag <foo> in namespace space",
  1563  	want: `<space:foo xmlns:space="space">`,
  1564  }, {
  1565  	desc: "start element with explicit namespace",
  1566  	toks: []Token{
  1567  		StartElement{Name{"space", "local"}, []Attr{
  1568  			{Name{"xmlns", "x"}, "space"},
  1569  			{Name{"space", "foo"}, "value"},
  1570  		}},
  1571  	},
  1572  	want: `<x:local xmlns:x="space" x:foo="value">`,
  1573  }, {
  1574  	desc: "start element with explicit namespace and colliding prefix",
  1575  	toks: []Token{
  1576  		StartElement{Name{"space", "local"}, []Attr{
  1577  			{Name{"xmlns", "x"}, "space"},
  1578  			{Name{"space", "foo"}, "value"},
  1579  			{Name{"x", "bar"}, "other"},
  1580  		}},
  1581  	},
  1582  	want: `<x:local xmlns:x_1="x" xmlns:x="space" x:foo="value" x_1:bar="other">`,
  1583  }, {
  1584  	desc: "start element using previously defined namespace",
  1585  	toks: []Token{
  1586  		StartElement{Name{"", "local"}, []Attr{
  1587  			{Name{"xmlns", "x"}, "space"},
  1588  		}},
  1589  		StartElement{Name{"space", "foo"}, []Attr{
  1590  			{Name{"space", "x"}, "y"},
  1591  		}},
  1592  	},
  1593  	want: `<local xmlns:x="space"><x:foo x:x="y">`,
  1594  }, {
  1595  	desc: "nested name space with same prefix",
  1596  	toks: []Token{
  1597  		StartElement{Name{"", "foo"}, []Attr{
  1598  			{Name{"xmlns", "x"}, "space1"},
  1599  		}},
  1600  		StartElement{Name{"", "foo"}, []Attr{
  1601  			{Name{"xmlns", "x"}, "space2"},
  1602  		}},
  1603  		StartElement{Name{"", "foo"}, []Attr{
  1604  			{Name{"space1", "a"}, "space1 value"},
  1605  			{Name{"space2", "b"}, "space2 value"},
  1606  		}},
  1607  		EndElement{Name{"", "foo"}},
  1608  		EndElement{Name{"", "foo"}},
  1609  		StartElement{Name{"", "foo"}, []Attr{
  1610  			{Name{"space1", "a"}, "space1 value"},
  1611  			{Name{"space2", "b"}, "space2 value"},
  1612  		}},
  1613  	},
  1614  	want: `<foo xmlns:x="space1"><foo xmlns:x="space2"><foo xmlns:space1="space1" space1:a="space1 value" x:b="space2 value"></foo></foo><foo xmlns:space2="space2" x:a="space1 value" space2:b="space2 value">`,
  1615  }, {
  1616  	desc: "start element defining several prefixes for the same name space",
  1617  	toks: []Token{
  1618  		StartElement{Name{"space", "foo"}, []Attr{
  1619  			{Name{"xmlns", "a"}, "space"},
  1620  			{Name{"xmlns", "b"}, "space"},
  1621  			{Name{"space", "x"}, "value"},
  1622  		}},
  1623  	},
  1624  	want: `<a:foo xmlns:a="space" a:x="value">`,
  1625  }, {
  1626  	desc: "nested element redefines name space",
  1627  	toks: []Token{
  1628  		StartElement{Name{"", "foo"}, []Attr{
  1629  			{Name{"xmlns", "x"}, "space"},
  1630  		}},
  1631  		StartElement{Name{"space", "foo"}, []Attr{
  1632  			{Name{"xmlns", "y"}, "space"},
  1633  			{Name{"space", "a"}, "value"},
  1634  		}},
  1635  	},
  1636  	want: `<foo xmlns:x="space"><x:foo x:a="value">`,
  1637  }, {
  1638  	desc: "nested element creates alias for default name space",
  1639  	toks: []Token{
  1640  		StartElement{Name{"space", "foo"}, []Attr{
  1641  			{Name{"", "xmlns"}, "space"},
  1642  		}},
  1643  		StartElement{Name{"space", "foo"}, []Attr{
  1644  			{Name{"xmlns", "y"}, "space"},
  1645  			{Name{"space", "a"}, "value"},
  1646  		}},
  1647  	},
  1648  	want: `<foo xmlns="space"><foo xmlns:y="space" y:a="value">`,
  1649  }, {
  1650  	desc: "nested element defines default name space with existing prefix",
  1651  	toks: []Token{
  1652  		StartElement{Name{"", "foo"}, []Attr{
  1653  			{Name{"xmlns", "x"}, "space"},
  1654  		}},
  1655  		StartElement{Name{"space", "foo"}, []Attr{
  1656  			{Name{"", "xmlns"}, "space"},
  1657  			{Name{"space", "a"}, "value"},
  1658  		}},
  1659  	},
  1660  	want: `<foo xmlns:x="space"><foo xmlns="space" x:a="value">`,
  1661  }, {
  1662  	desc: "nested element uses empty attribute name space when default ns defined",
  1663  	toks: []Token{
  1664  		StartElement{Name{"space", "foo"}, []Attr{
  1665  			{Name{"", "xmlns"}, "space"},
  1666  		}},
  1667  		StartElement{Name{"space", "foo"}, []Attr{
  1668  			{Name{"", "attr"}, "value"},
  1669  		}},
  1670  	},
  1671  	want: `<foo xmlns="space"><foo attr="value">`,
  1672  }, {
  1673  	desc: "redefine xmlns",
  1674  	toks: []Token{
  1675  		StartElement{Name{"", "foo"}, []Attr{
  1676  			{Name{"foo", "xmlns"}, "space"},
  1677  		}},
  1678  	},
  1679  	err: `xml: cannot redefine xmlns attribute prefix`,
  1680  }, {
  1681  	desc: "xmlns with explicit name space #1",
  1682  	toks: []Token{
  1683  		StartElement{Name{"space", "foo"}, []Attr{
  1684  			{Name{"xml", "xmlns"}, "space"},
  1685  		}},
  1686  	},
  1687  	want: `<foo xmlns="space">`,
  1688  }, {
  1689  	desc: "xmlns with explicit name space #2",
  1690  	toks: []Token{
  1691  		StartElement{Name{"space", "foo"}, []Attr{
  1692  			{Name{xmlURL, "xmlns"}, "space"},
  1693  		}},
  1694  	},
  1695  	want: `<foo xmlns="space">`,
  1696  }, {
  1697  	desc: "empty name space declaration is ignored",
  1698  	toks: []Token{
  1699  		StartElement{Name{"", "foo"}, []Attr{
  1700  			{Name{"xmlns", "foo"}, ""},
  1701  		}},
  1702  	},
  1703  	want: `<foo>`,
  1704  }, {
  1705  	desc: "attribute with no name is ignored",
  1706  	toks: []Token{
  1707  		StartElement{Name{"", "foo"}, []Attr{
  1708  			{Name{"", ""}, "value"},
  1709  		}},
  1710  	},
  1711  	want: `<foo>`,
  1712  }, {
  1713  	desc: "namespace URL with non-valid name",
  1714  	toks: []Token{
  1715  		StartElement{Name{"/34", "foo"}, []Attr{
  1716  			{Name{"/34", "x"}, "value"},
  1717  		}},
  1718  	},
  1719  	want: `<_:foo xmlns:_="/34" _:x="value">`,
  1720  }, {
  1721  	desc: "nested element resets default namespace to empty",
  1722  	toks: []Token{
  1723  		StartElement{Name{"space", "foo"}, []Attr{
  1724  			{Name{"", "xmlns"}, "space"},
  1725  		}},
  1726  		StartElement{Name{"", "foo"}, []Attr{
  1727  			{Name{"", "xmlns"}, ""},
  1728  			{Name{"", "x"}, "value"},
  1729  			{Name{"space", "x"}, "value"},
  1730  		}},
  1731  	},
  1732  	want: `<foo xmlns="space"><foo xmlns:space="space" xmlns="" x="value" space:x="value">`,
  1733  }, {
  1734  	desc: "nested element requires empty default name space",
  1735  	toks: []Token{
  1736  		StartElement{Name{"space", "foo"}, []Attr{
  1737  			{Name{"", "xmlns"}, "space"},
  1738  		}},
  1739  		StartElement{Name{"", "foo"}, nil},
  1740  	},
  1741  	want: `<foo xmlns="space"><foo xmlns="">`,
  1742  }, {
  1743  	desc: "attribute uses name space from xmlns",
  1744  	toks: []Token{
  1745  		StartElement{Name{"some/space", "foo"}, []Attr{
  1746  			{Name{"", "attr"}, "value"},
  1747  			{Name{"some/space", "other"}, "other value"},
  1748  		}},
  1749  	},
  1750  	want: `<space:foo xmlns:space="some/space" attr="value" space:other="other value">`,
  1751  }, {
  1752  	desc: "default name space should not be used by attributes",
  1753  	toks: []Token{
  1754  		StartElement{Name{"space", "foo"}, []Attr{
  1755  			{Name{"", "xmlns"}, "space"},
  1756  			{Name{"xmlns", "bar"}, "space"},
  1757  			{Name{"space", "baz"}, "foo"},
  1758  		}},
  1759  		StartElement{Name{"space", "baz"}, nil},
  1760  		EndElement{Name{"space", "baz"}},
  1761  		EndElement{Name{"space", "foo"}},
  1762  	},
  1763  	want: `<foo xmlns:bar="space" xmlns="space" bar:baz="foo"><baz></baz></foo>`,
  1764  }, {
  1765  	desc: "default name space not used by attributes, not explicitly defined",
  1766  	toks: []Token{
  1767  		StartElement{Name{"space", "foo"}, []Attr{
  1768  			{Name{"", "xmlns"}, "space"},
  1769  			{Name{"space", "baz"}, "foo"},
  1770  		}},
  1771  		StartElement{Name{"space", "baz"}, nil},
  1772  		EndElement{Name{"space", "baz"}},
  1773  		EndElement{Name{"space", "foo"}},
  1774  	},
  1775  	want: `<foo xmlns:space="space" xmlns="space" space:baz="foo"><baz></baz></foo>`,
  1776  }, {
  1777  	desc: "impossible xmlns declaration",
  1778  	toks: []Token{
  1779  		StartElement{Name{"", "foo"}, []Attr{
  1780  			{Name{"", "xmlns"}, "space"},
  1781  		}},
  1782  		StartElement{Name{"space", "bar"}, []Attr{
  1783  			{Name{"space", "attr"}, "value"},
  1784  		}},
  1785  	},
  1786  	want: `<foo><space:bar xmlns:space="space" space:attr="value">`,
  1787  }}
  1788  
  1789  func TestEncodeToken(t *testing.T) {
  1790  loop:
  1791  	for i, tt := range encodeTokenTests {
  1792  		var buf bytes.Buffer
  1793  		enc := NewEncoder(&buf)
  1794  		var err error
  1795  		for j, tok := range tt.toks {
  1796  			err = enc.EncodeToken(tok)
  1797  			if err != nil && j < len(tt.toks)-1 {
  1798  				t.Errorf("#%d %s token #%d: %v", i, tt.desc, j, err)
  1799  				continue loop
  1800  			}
  1801  		}
  1802  		errorf := func(f string, a ...interface{}) {
  1803  			t.Errorf("#%d %s token #%d:%s", i, tt.desc, len(tt.toks)-1, fmt.Sprintf(f, a...))
  1804  		}
  1805  		switch {
  1806  		case tt.err != "" && err == nil:
  1807  			errorf(" expected error; got none")
  1808  			continue
  1809  		case tt.err == "" && err != nil:
  1810  			errorf(" got error: %v", err)
  1811  			continue
  1812  		case tt.err != "" && err != nil && tt.err != err.Error():
  1813  			errorf(" error mismatch; got %v, want %v", err, tt.err)
  1814  			continue
  1815  		}
  1816  		if err := enc.Flush(); err != nil {
  1817  			errorf(" %v", err)
  1818  			continue
  1819  		}
  1820  		if got := buf.String(); got != tt.want {
  1821  			errorf("\ngot  %v\nwant %v", got, tt.want)
  1822  			continue
  1823  		}
  1824  	}
  1825  }
  1826  
  1827  func TestProcInstEncodeToken(t *testing.T) {
  1828  	var buf bytes.Buffer
  1829  	enc := NewEncoder(&buf)
  1830  
  1831  	if err := enc.EncodeToken(ProcInst{"xml", []byte("Instruction")}); err != nil {
  1832  		t.Fatalf("enc.EncodeToken: expected to be able to encode xml target ProcInst as first token, %s", err)
  1833  	}
  1834  
  1835  	if err := enc.EncodeToken(ProcInst{"Target", []byte("Instruction")}); err != nil {
  1836  		t.Fatalf("enc.EncodeToken: expected to be able to add non-xml target ProcInst")
  1837  	}
  1838  
  1839  	if err := enc.EncodeToken(ProcInst{"xml", []byte("Instruction")}); err == nil {
  1840  		t.Fatalf("enc.EncodeToken: expected to not be allowed to encode xml target ProcInst when not first token")
  1841  	}
  1842  }
  1843  
  1844  func TestDecodeEncode(t *testing.T) {
  1845  	var in, out bytes.Buffer
  1846  	in.WriteString(`<?xml version="1.0" encoding="UTF-8"?>
  1847  <?Target Instruction?>
  1848  <root>
  1849  </root>	
  1850  `)
  1851  	dec := NewDecoder(&in)
  1852  	enc := NewEncoder(&out)
  1853  	for tok, err := dec.Token(); err == nil; tok, err = dec.Token() {
  1854  		err = enc.EncodeToken(tok)
  1855  		if err != nil {
  1856  			t.Fatalf("enc.EncodeToken: Unable to encode token (%#v), %v", tok, err)
  1857  		}
  1858  	}
  1859  }
  1860  
  1861  // Issue 9796. Used to fail with GORACE="halt_on_error=1" -race.
  1862  func TestRace9796(t *testing.T) {
  1863  	type A struct{}
  1864  	type B struct {
  1865  		C []A `xml:"X>Y"`
  1866  	}
  1867  	var wg sync.WaitGroup
  1868  	for i := 0; i < 2; i++ {
  1869  		wg.Add(1)
  1870  		go func() {
  1871  			Marshal(B{[]A{{}}})
  1872  			wg.Done()
  1873  		}()
  1874  	}
  1875  	wg.Wait()
  1876  }
  1877  
  1878  func TestIsValidDirective(t *testing.T) {
  1879  	testOK := []string{
  1880  		"<>",
  1881  		"< < > >",
  1882  		"<!DOCTYPE '<' '>' '>' <!--nothing-->>",
  1883  		"<!DOCTYPE doc [ <!ELEMENT doc ANY> <!ELEMENT doc ANY> ]>",
  1884  		"<!DOCTYPE doc [ <!ELEMENT doc \"ANY> '<' <!E\" LEMENT '>' doc ANY> ]>",
  1885  		"<!DOCTYPE doc <!-- just>>>> a < comment --> [ <!ITEM anything> ] >",
  1886  	}
  1887  	testKO := []string{
  1888  		"<",
  1889  		">",
  1890  		"<!--",
  1891  		"-->",
  1892  		"< > > < < >",
  1893  		"<!dummy <!-- > -->",
  1894  		"<!DOCTYPE doc '>",
  1895  		"<!DOCTYPE doc '>'",
  1896  		"<!DOCTYPE doc <!--comment>",
  1897  	}
  1898  	for _, s := range testOK {
  1899  		if !isValidDirective(Directive(s)) {
  1900  			t.Errorf("Directive %q is expected to be valid", s)
  1901  		}
  1902  	}
  1903  	for _, s := range testKO {
  1904  		if isValidDirective(Directive(s)) {
  1905  			t.Errorf("Directive %q is expected to be invalid", s)
  1906  		}
  1907  	}
  1908  }
  1909  
  1910  // Issue 11719. EncodeToken used to silently eat tokens with an invalid type.
  1911  func TestSimpleUseOfEncodeToken(t *testing.T) {
  1912  	var buf bytes.Buffer
  1913  	enc := NewEncoder(&buf)
  1914  	if err := enc.EncodeToken(&StartElement{Name: Name{"", "object1"}}); err == nil {
  1915  		t.Errorf("enc.EncodeToken: pointer type should be rejected")
  1916  	}
  1917  	if err := enc.EncodeToken(&EndElement{Name: Name{"", "object1"}}); err == nil {
  1918  		t.Errorf("enc.EncodeToken: pointer type should be rejected")
  1919  	}
  1920  	if err := enc.EncodeToken(StartElement{Name: Name{"", "object2"}}); err != nil {
  1921  		t.Errorf("enc.EncodeToken: StartElement %s", err)
  1922  	}
  1923  	if err := enc.EncodeToken(EndElement{Name: Name{"", "object2"}}); err != nil {
  1924  		t.Errorf("enc.EncodeToken: EndElement %s", err)
  1925  	}
  1926  	if err := enc.EncodeToken(Universe{}); err == nil {
  1927  		t.Errorf("enc.EncodeToken: invalid type not caught")
  1928  	}
  1929  	if err := enc.Flush(); err != nil {
  1930  		t.Errorf("enc.Flush: %s", err)
  1931  	}
  1932  	if buf.Len() == 0 {
  1933  		t.Errorf("enc.EncodeToken: empty buffer")
  1934  	}
  1935  	want := "<object2></object2>"
  1936  	if buf.String() != want {
  1937  		t.Errorf("enc.EncodeToken: expected %q; got %q", want, buf.String())
  1938  	}
  1939  }
  1940  

View as plain text