// Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package xml import ( "bytes" "errors" "io" "reflect" "runtime" "strings" "testing" "time" ) // Stripped down Atom feed data structures. func TestUnmarshalFeed(t *testing.T) { var f Feed if err := Unmarshal([]byte(atomFeedString), &f); err != nil { t.Fatalf("Unmarshal: %s", err) } if !reflect.DeepEqual(f, atomFeed) { t.Fatalf("have %#v\nwant %#v", f, atomFeed) } } // hget http://codereview.appspot.com/rss/mine/rsc const atomFeedString = ` Code Review - My issueshttp://codereview.appspot.com/rietveld<>rietveld: an attempt at pubsubhubbub 2009-10-04T01:35:58+00:00email-address-removedurn:md5:134d9179c41f806be79b3a5f7877d19a An attempt at adding pubsubhubbub support to Rietveld. http://code.google.com/p/pubsubhubbub http://code.google.com/p/rietveld/issues/detail?id=155 The server side of the protocol is trivial: 1. add a &lt;link rel=&quot;hub&quot; href=&quot;hub-server&quot;&gt; tag to all feeds that will be pubsubhubbubbed. 2. every time one of those feeds changes, tell the hub with a simple POST request. I have tested this by adding debug prints to a local hub server and checking that the server got the right publish requests. I can&#39;t quite get the server to work, but I think the bug is not in my code. I think that the server expects to be able to grab the feed and see the feed&#39;s actual URL in the link rel=&quot;self&quot;, but the default value for that drops the :port from the URL, and I cannot for the life of me figure out how to get the Atom generator deep inside django not to do that, or even where it is doing that, or even what code is running to generate the Atom feed. (I thought I knew but I added some assert False statements and it kept running!) Ignoring that particular problem, I would appreciate feedback on the right way to get the two values at the top of feeds.py marked NOTE(rsc). rietveld: correct tab handling 2009-10-03T23:02:17+00:00email-address-removedurn:md5:0a2a4f19bb815101f0ba2904aed7c35a This fixes the buggy tab rendering that can be seen at http://codereview.appspot.com/116075/diff/1/2 The fundamental problem was that the tab code was not being told what column the text began in, so it didn&#39;t know where to put the tab stops. Another problem was that some of the code assumed that string byte offsets were the same as column offsets, which is only true if there are no tabs. In the process of fixing this, I cleaned up the arguments to Fold and ExpandTabs and renamed them Break and _ExpandTabs so that I could be sure that I found all the call sites. I also wanted to verify that ExpandTabs was not being used from outside intra_region_diff.py. ` type Feed struct { XMLName Name `xml:"http://www.w3.org/2005/Atom feed"` Title string `xml:"title"` ID string `xml:"id"` Link []Link `xml:"link"` Updated time.Time `xml:"updated,attr"` Author Person `xml:"author"` Entry []Entry `xml:"entry"` } type Entry struct { Title string `xml:"title"` ID string `xml:"id"` Link []Link `xml:"link"` Updated time.Time `xml:"updated"` Author Person `xml:"author"` Summary Text `xml:"summary"` } type Link struct { Rel string `xml:"rel,attr,omitempty"` Href string `xml:"href,attr"` } type Person struct { Name string `xml:"name"` URI string `xml:"uri"` Email string `xml:"email"` InnerXML string `xml:",innerxml"` } type Text struct { Type string `xml:"type,attr,omitempty"` Body string `xml:",chardata"` } var atomFeed = Feed{ XMLName: Name{"http://www.w3.org/2005/Atom", "feed"}, Title: "Code Review - My issues", Link: []Link{ {Rel: "alternate", Href: "http://codereview.appspot.com/"}, {Rel: "self", Href: "http://codereview.appspot.com/rss/mine/rsc"}, }, ID: "http://codereview.appspot.com/", Updated: ParseTime("2009-10-04T01:35:58+00:00"), Author: Person{ Name: "rietveld<>", InnerXML: "rietveld<>", }, Entry: []Entry{ { Title: "rietveld: an attempt at pubsubhubbub\n", Link: []Link{ {Rel: "alternate", Href: "http://codereview.appspot.com/126085"}, }, Updated: ParseTime("2009-10-04T01:35:58+00:00"), Author: Person{ Name: "email-address-removed", InnerXML: "email-address-removed", }, ID: "urn:md5:134d9179c41f806be79b3a5f7877d19a", Summary: Text{ Type: "html", Body: ` An attempt at adding pubsubhubbub support to Rietveld. http://code.google.com/p/pubsubhubbub http://code.google.com/p/rietveld/issues/detail?id=155 The server side of the protocol is trivial: 1. add a <link rel="hub" href="hub-server"> tag to all feeds that will be pubsubhubbubbed. 2. every time one of those feeds changes, tell the hub with a simple POST request. I have tested this by adding debug prints to a local hub server and checking that the server got the right publish requests. I can't quite get the server to work, but I think the bug is not in my code. I think that the server expects to be able to grab the feed and see the feed's actual URL in the link rel="self", but the default value for that drops the :port from the URL, and I cannot for the life of me figure out how to get the Atom generator deep inside django not to do that, or even where it is doing that, or even what code is running to generate the Atom feed. (I thought I knew but I added some assert False statements and it kept running!) Ignoring that particular problem, I would appreciate feedback on the right way to get the two values at the top of feeds.py marked NOTE(rsc). `, }, }, { Title: "rietveld: correct tab handling\n", Link: []Link{ {Rel: "alternate", Href: "http://codereview.appspot.com/124106"}, }, Updated: ParseTime("2009-10-03T23:02:17+00:00"), Author: Person{ Name: "email-address-removed", InnerXML: "email-address-removed", }, ID: "urn:md5:0a2a4f19bb815101f0ba2904aed7c35a", Summary: Text{ Type: "html", Body: ` This fixes the buggy tab rendering that can be seen at http://codereview.appspot.com/116075/diff/1/2 The fundamental problem was that the tab code was not being told what column the text began in, so it didn't know where to put the tab stops. Another problem was that some of the code assumed that string byte offsets were the same as column offsets, which is only true if there are no tabs. In the process of fixing this, I cleaned up the arguments to Fold and ExpandTabs and renamed them Break and _ExpandTabs so that I could be sure that I found all the call sites. I also wanted to verify that ExpandTabs was not being used from outside intra_region_diff.py. `, }, }, }, } const pathTestString = ` 1 A B C D <_> E 2 ` type PathTestItem struct { Value string } type PathTestA struct { Items []PathTestItem `xml:">Item1"` Before, After string } type PathTestB struct { Other []PathTestItem `xml:"Items>Item1"` Before, After string } type PathTestC struct { Values1 []string `xml:"Items>Item1>Value"` Values2 []string `xml:"Items>Item2>Value"` Before, After string } type PathTestSet struct { Item1 []PathTestItem } type PathTestD struct { Other PathTestSet `xml:"Items"` Before, After string } type PathTestE struct { Underline string `xml:"Items>_>Value"` Before, After string } var pathTests = []any{ &PathTestA{Items: []PathTestItem{{"A"}, {"D"}}, Before: "1", After: "2"}, &PathTestB{Other: []PathTestItem{{"A"}, {"D"}}, Before: "1", After: "2"}, &PathTestC{Values1: []string{"A", "C", "D"}, Values2: []string{"B"}, Before: "1", After: "2"}, &PathTestD{Other: PathTestSet{Item1: []PathTestItem{{"A"}, {"D"}}}, Before: "1", After: "2"}, &PathTestE{Underline: "E", Before: "1", After: "2"}, } func TestUnmarshalPaths(t *testing.T) { for _, pt := range pathTests { v := reflect.New(reflect.TypeOf(pt).Elem()).Interface() if err := Unmarshal([]byte(pathTestString), v); err != nil { t.Fatalf("Unmarshal: %s", err) } if !reflect.DeepEqual(v, pt) { t.Fatalf("have %#v\nwant %#v", v, pt) } } } type BadPathTestA struct { First string `xml:"items>item1"` Other string `xml:"items>item2"` Second string `xml:"items"` } type BadPathTestB struct { Other string `xml:"items>item2>value"` First string `xml:"items>item1"` Second string `xml:"items>item1>value"` } type BadPathTestC struct { First string Second string `xml:"First"` } type BadPathTestD struct { BadPathEmbeddedA BadPathEmbeddedB } type BadPathEmbeddedA struct { First string } type BadPathEmbeddedB struct { Second string `xml:"First"` } var badPathTests = []struct { v, e any }{ {&BadPathTestA{}, &TagPathError{reflect.TypeOf(BadPathTestA{}), "First", "items>item1", "Second", "items"}}, {&BadPathTestB{}, &TagPathError{reflect.TypeOf(BadPathTestB{}), "First", "items>item1", "Second", "items>item1>value"}}, {&BadPathTestC{}, &TagPathError{reflect.TypeOf(BadPathTestC{}), "First", "", "Second", "First"}}, {&BadPathTestD{}, &TagPathError{reflect.TypeOf(BadPathTestD{}), "First", "", "Second", "First"}}, } func TestUnmarshalBadPaths(t *testing.T) { for _, tt := range badPathTests { err := Unmarshal([]byte(pathTestString), tt.v) if !reflect.DeepEqual(err, tt.e) { t.Fatalf("Unmarshal with %#v didn't fail properly:\nhave %#v,\nwant %#v", tt.v, err, tt.e) } } } const OK = "OK" const withoutNameTypeData = ` ` type TestThree struct { XMLName Name `xml:"Test3"` Attr string `xml:",attr"` } func TestUnmarshalWithoutNameType(t *testing.T) { var x TestThree if err := Unmarshal([]byte(withoutNameTypeData), &x); err != nil { t.Fatalf("Unmarshal: %s", err) } if x.Attr != OK { t.Fatalf("have %v\nwant %v", x.Attr, OK) } } func TestUnmarshalAttr(t *testing.T) { type ParamVal struct { Int int `xml:"int,attr"` } type ParamPtr struct { Int *int `xml:"int,attr"` } type ParamStringPtr struct { Int *string `xml:"int,attr"` } x := []byte(``) p1 := &ParamPtr{} if err := Unmarshal(x, p1); err != nil { t.Fatalf("Unmarshal: %s", err) } if p1.Int == nil { t.Fatalf("Unmarshal failed in to *int field") } else if *p1.Int != 1 { t.Fatalf("Unmarshal with %s failed:\nhave %#v,\n want %#v", x, p1.Int, 1) } p2 := &ParamVal{} if err := Unmarshal(x, p2); err != nil { t.Fatalf("Unmarshal: %s", err) } if p2.Int != 1 { t.Fatalf("Unmarshal with %s failed:\nhave %#v,\n want %#v", x, p2.Int, 1) } p3 := &ParamStringPtr{} if err := Unmarshal(x, p3); err != nil { t.Fatalf("Unmarshal: %s", err) } if p3.Int == nil { t.Fatalf("Unmarshal failed in to *string field") } else if *p3.Int != "1" { t.Fatalf("Unmarshal with %s failed:\nhave %#v,\n want %#v", x, p3.Int, 1) } } type Tables struct { HTable string `xml:"http://www.w3.org/TR/html4/ table"` FTable string `xml:"http://www.w3schools.com/furniture table"` } var tables = []struct { xml string tab Tables ns string }{ { xml: `` + `hello
` + `world
` + `
`, tab: Tables{"hello", "world"}, }, { xml: `` + `world
` + `hello
` + `
`, tab: Tables{"hello", "world"}, }, { xml: `` + `world` + `hello` + ``, tab: Tables{"hello", "world"}, }, { xml: `` + `bogus
` + `
`, tab: Tables{}, }, { xml: `` + `only
` + `
`, tab: Tables{HTable: "only"}, ns: "http://www.w3.org/TR/html4/", }, { xml: `` + `only
` + `
`, tab: Tables{FTable: "only"}, ns: "http://www.w3schools.com/furniture", }, { xml: `` + `only
` + `
`, tab: Tables{}, ns: "something else entirely", }, } func TestUnmarshalNS(t *testing.T) { for i, tt := range tables { var dst Tables var err error if tt.ns != "" { d := NewDecoder(strings.NewReader(tt.xml)) d.DefaultSpace = tt.ns err = d.Decode(&dst) } else { err = Unmarshal([]byte(tt.xml), &dst) } if err != nil { t.Errorf("#%d: Unmarshal: %v", i, err) continue } want := tt.tab if dst != want { t.Errorf("#%d: dst=%+v, want %+v", i, dst, want) } } } func TestMarshalNS(t *testing.T) { dst := Tables{"hello", "world"} data, err := Marshal(&dst) if err != nil { t.Fatalf("Marshal: %v", err) } want := `hello
world
` str := string(data) if str != want { t.Errorf("have: %q\nwant: %q\n", str, want) } } type TableAttrs struct { TAttr TAttr } type TAttr struct { HTable string `xml:"http://www.w3.org/TR/html4/ table,attr"` FTable string `xml:"http://www.w3schools.com/furniture table,attr"` Lang string `xml:"http://www.w3.org/XML/1998/namespace lang,attr,omitempty"` Other1 string `xml:"http://golang.org/xml/ other,attr,omitempty"` Other2 string `xml:"http://golang.org/xmlfoo/ other,attr,omitempty"` Other3 string `xml:"http://golang.org/json/ other,attr,omitempty"` Other4 string `xml:"http://golang.org/2/json/ other,attr,omitempty"` } var tableAttrs = []struct { xml string tab TableAttrs ns string }{ { xml: ``, tab: TableAttrs{TAttr{HTable: "hello", FTable: "world"}}, }, { xml: ``, tab: TableAttrs{TAttr{HTable: "hello", FTable: "world"}}, }, { xml: ``, tab: TableAttrs{TAttr{HTable: "hello", FTable: "world"}}, }, { // Default space does not apply to attribute names. xml: ``, tab: TableAttrs{TAttr{HTable: "hello", FTable: ""}}, }, { // Default space does not apply to attribute names. xml: ``, tab: TableAttrs{TAttr{HTable: "", FTable: "world"}}, }, { xml: ``, tab: TableAttrs{}, }, { // Default space does not apply to attribute names. xml: ``, tab: TableAttrs{TAttr{HTable: "hello", FTable: ""}}, ns: "http://www.w3schools.com/furniture", }, { // Default space does not apply to attribute names. xml: ``, tab: TableAttrs{TAttr{HTable: "", FTable: "world"}}, ns: "http://www.w3.org/TR/html4/", }, { xml: ``, tab: TableAttrs{}, ns: "something else entirely", }, } func TestUnmarshalNSAttr(t *testing.T) { for i, tt := range tableAttrs { var dst TableAttrs var err error if tt.ns != "" { d := NewDecoder(strings.NewReader(tt.xml)) d.DefaultSpace = tt.ns err = d.Decode(&dst) } else { err = Unmarshal([]byte(tt.xml), &dst) } if err != nil { t.Errorf("#%d: Unmarshal: %v", i, err) continue } want := tt.tab if dst != want { t.Errorf("#%d: dst=%+v, want %+v", i, dst, want) } } } func TestMarshalNSAttr(t *testing.T) { src := TableAttrs{TAttr{"hello", "world", "en_US", "other1", "other2", "other3", "other4"}} data, err := Marshal(&src) if err != nil { t.Fatalf("Marshal: %v", err) } want := `` str := string(data) if str != want { t.Errorf("Marshal:\nhave: %#q\nwant: %#q\n", str, want) } var dst TableAttrs if err := Unmarshal(data, &dst); err != nil { t.Errorf("Unmarshal: %v", err) } if dst != src { t.Errorf("Unmarshal = %q, want %q", dst, src) } } type MyCharData struct { body string } func (m *MyCharData) UnmarshalXML(d *Decoder, start StartElement) error { for { t, err := d.Token() if err == io.EOF { // found end of element break } if err != nil { return err } if char, ok := t.(CharData); ok { m.body += string(char) } } return nil } var _ Unmarshaler = (*MyCharData)(nil) func (m *MyCharData) UnmarshalXMLAttr(attr Attr) error { panic("must not call") } type MyAttr struct { attr string } func (m *MyAttr) UnmarshalXMLAttr(attr Attr) error { m.attr = attr.Value return nil } var _ UnmarshalerAttr = (*MyAttr)(nil) type MyStruct struct { Data *MyCharData Attr *MyAttr `xml:",attr"` Data2 MyCharData Attr2 MyAttr `xml:",attr"` } func TestUnmarshaler(t *testing.T) { xml := ` hello world howdy world ` var m MyStruct if err := Unmarshal([]byte(xml), &m); err != nil { t.Fatal(err) } if m.Data == nil || m.Attr == nil || m.Data.body != "hello world" || m.Attr.attr != "attr1" || m.Data2.body != "howdy world" || m.Attr2.attr != "attr2" { t.Errorf("m=%#+v\n", m) } } type Pea struct { Cotelydon string } type Pod struct { Pea any `xml:"Pea"` } // https://golang.org/issue/6836 func TestUnmarshalIntoInterface(t *testing.T) { pod := new(Pod) pod.Pea = new(Pea) xml := `Green stuff` err := Unmarshal([]byte(xml), pod) if err != nil { t.Fatalf("failed to unmarshal %q: %v", xml, err) } pea, ok := pod.Pea.(*Pea) if !ok { t.Fatalf("unmarshaled into wrong type: have %T want *Pea", pod.Pea) } have, want := pea.Cotelydon, "Green stuff" if have != want { t.Errorf("failed to unmarshal into interface, have %q want %q", have, want) } } type X struct { D string `xml:",comment"` } // Issue 11112. Unmarshal must reject invalid comments. func TestMalformedComment(t *testing.T) { testData := []string{ "", "", "", "", } for i, test := range testData { data := []byte(test) v := new(X) if err := Unmarshal(data, v); err == nil { t.Errorf("%d: unmarshal should reject invalid comments", i) } } } type IXField struct { Five int `xml:"five"` NotInnerXML []string `xml:",innerxml"` } // Issue 15600. ",innerxml" on a field that can't hold it. func TestInvalidInnerXMLType(t *testing.T) { v := new(IXField) if err := Unmarshal([]byte(`5`), v); err != nil { t.Errorf("Unmarshal failed: got %v", err) } if v.Five != 5 { t.Errorf("Five = %v, want 5", v.Five) } if v.NotInnerXML != nil { t.Errorf("NotInnerXML = %v, want nil", v.NotInnerXML) } } type Child struct { G struct { I int } } type ChildToEmbed struct { X bool } type Parent struct { I int IPtr *int Is []int IPtrs []*int F float32 FPtr *float32 Fs []float32 FPtrs []*float32 B bool BPtr *bool Bs []bool BPtrs []*bool Bytes []byte BytesPtr *[]byte S string SPtr *string Ss []string SPtrs []*string MyI MyInt Child Child Children []Child ChildPtr *Child ChildToEmbed } const ( emptyXML = ` ` ) // golang.org/issues/13417 func TestUnmarshalEmptyValues(t *testing.T) { // Test first with a zero-valued dst. v := new(Parent) if err := Unmarshal([]byte(emptyXML), v); err != nil { t.Fatalf("zero: Unmarshal failed: got %v", err) } zBytes, zInt, zStr, zFloat, zBool := []byte{}, 0, "", float32(0), false want := &Parent{ IPtr: &zInt, Is: []int{zInt}, IPtrs: []*int{&zInt}, FPtr: &zFloat, Fs: []float32{zFloat}, FPtrs: []*float32{&zFloat}, BPtr: &zBool, Bs: []bool{zBool}, BPtrs: []*bool{&zBool}, Bytes: []byte{}, BytesPtr: &zBytes, SPtr: &zStr, Ss: []string{zStr}, SPtrs: []*string{&zStr}, Children: []Child{{}}, ChildPtr: new(Child), ChildToEmbed: ChildToEmbed{}, } if !reflect.DeepEqual(v, want) { t.Fatalf("zero: Unmarshal:\nhave: %#+v\nwant: %#+v", v, want) } // Test with a pre-populated dst. // Multiple addressable copies, as pointer-to fields will replace value during unmarshal. vBytes0, vInt0, vStr0, vFloat0, vBool0 := []byte("x"), 1, "x", float32(1), true vBytes1, vInt1, vStr1, vFloat1, vBool1 := []byte("x"), 1, "x", float32(1), true vInt2, vStr2, vFloat2, vBool2 := 1, "x", float32(1), true v = &Parent{ I: vInt0, IPtr: &vInt1, Is: []int{vInt0}, IPtrs: []*int{&vInt2}, F: vFloat0, FPtr: &vFloat1, Fs: []float32{vFloat0}, FPtrs: []*float32{&vFloat2}, B: vBool0, BPtr: &vBool1, Bs: []bool{vBool0}, BPtrs: []*bool{&vBool2}, Bytes: vBytes0, BytesPtr: &vBytes1, S: vStr0, SPtr: &vStr1, Ss: []string{vStr0}, SPtrs: []*string{&vStr2}, MyI: MyInt(vInt0), Child: Child{G: struct{ I int }{I: vInt0}}, Children: []Child{{G: struct{ I int }{I: vInt0}}}, ChildPtr: &Child{G: struct{ I int }{I: vInt0}}, ChildToEmbed: ChildToEmbed{X: vBool0}, } if err := Unmarshal([]byte(emptyXML), v); err != nil { t.Fatalf("populated: Unmarshal failed: got %v", err) } want = &Parent{ IPtr: &zInt, Is: []int{vInt0, zInt}, IPtrs: []*int{&vInt0, &zInt}, FPtr: &zFloat, Fs: []float32{vFloat0, zFloat}, FPtrs: []*float32{&vFloat0, &zFloat}, BPtr: &zBool, Bs: []bool{vBool0, zBool}, BPtrs: []*bool{&vBool0, &zBool}, Bytes: []byte{}, BytesPtr: &zBytes, SPtr: &zStr, Ss: []string{vStr0, zStr}, SPtrs: []*string{&vStr0, &zStr}, Child: Child{G: struct{ I int }{I: vInt0}}, // I should == zInt0? (zero value) Children: []Child{{G: struct{ I int }{I: vInt0}}, {}}, ChildPtr: &Child{G: struct{ I int }{I: vInt0}}, // I should == zInt0? (zero value) } if !reflect.DeepEqual(v, want) { t.Fatalf("populated: Unmarshal:\nhave: %#+v\nwant: %#+v", v, want) } } type WhitespaceValuesParent struct { BFalse bool BTrue bool I int INeg int I8 int8 I8Neg int8 I16 int16 I16Neg int16 I32 int32 I32Neg int32 I64 int64 I64Neg int64 UI uint UI8 uint8 UI16 uint16 UI32 uint32 UI64 uint64 F32 float32 F32Neg float32 F64 float64 F64Neg float64 } const whitespaceValuesXML = ` false true 266703 -266703 112 -112 6703 -6703 266703 -266703 266703 -266703 266703 112 6703 266703 266703 266.703 -266.703 266.703 -266.703 ` // golang.org/issues/22146 func TestUnmarshalWhitespaceValues(t *testing.T) { v := WhitespaceValuesParent{} if err := Unmarshal([]byte(whitespaceValuesXML), &v); err != nil { t.Fatalf("whitespace values: Unmarshal failed: got %v", err) } want := WhitespaceValuesParent{ BFalse: false, BTrue: true, I: 266703, INeg: -266703, I8: 112, I8Neg: -112, I16: 6703, I16Neg: -6703, I32: 266703, I32Neg: -266703, I64: 266703, I64Neg: -266703, UI: 266703, UI8: 112, UI16: 6703, UI32: 266703, UI64: 266703, F32: 266.703, F32Neg: -266.703, F64: 266.703, F64Neg: -266.703, } if v != want { t.Fatalf("whitespace values: Unmarshal:\nhave: %#+v\nwant: %#+v", v, want) } } type WhitespaceAttrsParent struct { BFalse bool `xml:",attr"` BTrue bool `xml:",attr"` I int `xml:",attr"` INeg int `xml:",attr"` I8 int8 `xml:",attr"` I8Neg int8 `xml:",attr"` I16 int16 `xml:",attr"` I16Neg int16 `xml:",attr"` I32 int32 `xml:",attr"` I32Neg int32 `xml:",attr"` I64 int64 `xml:",attr"` I64Neg int64 `xml:",attr"` UI uint `xml:",attr"` UI8 uint8 `xml:",attr"` UI16 uint16 `xml:",attr"` UI32 uint32 `xml:",attr"` UI64 uint64 `xml:",attr"` F32 float32 `xml:",attr"` F32Neg float32 `xml:",attr"` F64 float64 `xml:",attr"` F64Neg float64 `xml:",attr"` } const whitespaceAttrsXML = ` ` // golang.org/issues/22146 func TestUnmarshalWhitespaceAttrs(t *testing.T) { v := WhitespaceAttrsParent{} if err := Unmarshal([]byte(whitespaceAttrsXML), &v); err != nil { t.Fatalf("whitespace attrs: Unmarshal failed: got %v", err) } want := WhitespaceAttrsParent{ BFalse: false, BTrue: true, I: 266703, INeg: -266703, I8: 112, I8Neg: -112, I16: 6703, I16Neg: -6703, I32: 266703, I32Neg: -266703, I64: 266703, I64Neg: -266703, UI: 266703, UI8: 112, UI16: 6703, UI32: 266703, UI64: 266703, F32: 266.703, F32Neg: -266.703, F64: 266.703, F64Neg: -266.703, } if v != want { t.Fatalf("whitespace attrs: Unmarshal:\nhave: %#+v\nwant: %#+v", v, want) } } // golang.org/issues/53350 func TestUnmarshalIntoNil(t *testing.T) { type T struct { A int `xml:"A"` } var nilPointer *T err := Unmarshal([]byte("1"), nilPointer) if err == nil { t.Fatalf("no error in unmarshalling") } } func TestCVE202228131(t *testing.T) { type nested struct { Parent *nested `xml:",any"` } var n nested err := Unmarshal(bytes.Repeat([]byte(""), maxUnmarshalDepth+1), &n) if err == nil { t.Fatal("Unmarshal did not fail") } else if !errors.Is(err, errUnmarshalDepth) { t.Fatalf("Unmarshal unexpected error: got %q, want %q", err, errUnmarshalDepth) } } func TestCVE202230633(t *testing.T) { if testing.Short() || runtime.GOARCH == "wasm" { t.Skip("test requires significant memory") } defer func() { p := recover() if p != nil { t.Fatal("Unmarshal panicked") } }() var example struct { Things []string } Unmarshal(bytes.Repeat([]byte(""), 17_000_000), &example) }