parent
91b873065a
commit
bb27d1d587
@ -1,56 +0,0 @@
|
||||
// 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 "time"
|
||||
|
||||
var atomValue = &Feed{
|
||||
XMLName: Name{"http://www.w3.org/2005/Atom", "feed"},
|
||||
Title: "Example Feed",
|
||||
Link: []Link{{Href: "http://example.org/"}},
|
||||
Updated: ParseTime("2003-12-13T18:30:02Z"),
|
||||
Author: Person{Name: "John Doe"},
|
||||
Id: "urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6",
|
||||
|
||||
Entry: []Entry{
|
||||
{
|
||||
Title: "Atom-Powered Robots Run Amok",
|
||||
Link: []Link{{Href: "http://example.org/2003/12/13/atom03"}},
|
||||
Id: "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a",
|
||||
Updated: ParseTime("2003-12-13T18:30:02Z"),
|
||||
Summary: NewText("Some text."),
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var atomXml = `` +
|
||||
`<feed xmlns="http://www.w3.org/2005/Atom" updated="2003-12-13T18:30:02Z">` +
|
||||
`<title>Example Feed</title>` +
|
||||
`<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>` +
|
||||
`<link href="http://example.org/"></link>` +
|
||||
`<author><name>John Doe</name><uri></uri><email></email></author>` +
|
||||
`<entry>` +
|
||||
`<title>Atom-Powered Robots Run Amok</title>` +
|
||||
`<id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>` +
|
||||
`<link href="http://example.org/2003/12/13/atom03"></link>` +
|
||||
`<updated>2003-12-13T18:30:02Z</updated>` +
|
||||
`<author><name></name><uri></uri><email></email></author>` +
|
||||
`<summary>Some text.</summary>` +
|
||||
`</entry>` +
|
||||
`</feed>`
|
||||
|
||||
func ParseTime(str string) time.Time {
|
||||
t, err := time.Parse(time.RFC3339, str)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
func NewText(text string) Text {
|
||||
return Text{
|
||||
Body: text,
|
||||
}
|
||||
}
|
@ -1,151 +0,0 @@
|
||||
// Copyright 2012 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_test
|
||||
|
||||
import (
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
func ExampleMarshalIndent() {
|
||||
type Address struct {
|
||||
City, State string
|
||||
}
|
||||
type Person struct {
|
||||
XMLName xml.Name `xml:"person"`
|
||||
Id int `xml:"id,attr"`
|
||||
FirstName string `xml:"name>first"`
|
||||
LastName string `xml:"name>last"`
|
||||
Age int `xml:"age"`
|
||||
Height float32 `xml:"height,omitempty"`
|
||||
Married bool
|
||||
Address
|
||||
Comment string `xml:",comment"`
|
||||
}
|
||||
|
||||
v := &Person{Id: 13, FirstName: "John", LastName: "Doe", Age: 42}
|
||||
v.Comment = " Need more details. "
|
||||
v.Address = Address{"Hanga Roa", "Easter Island"}
|
||||
|
||||
output, err := xml.MarshalIndent(v, " ", " ")
|
||||
if err != nil {
|
||||
fmt.Printf("error: %v\n", err)
|
||||
}
|
||||
|
||||
os.Stdout.Write(output)
|
||||
// Output:
|
||||
// <person id="13">
|
||||
// <name>
|
||||
// <first>John</first>
|
||||
// <last>Doe</last>
|
||||
// </name>
|
||||
// <age>42</age>
|
||||
// <Married>false</Married>
|
||||
// <City>Hanga Roa</City>
|
||||
// <State>Easter Island</State>
|
||||
// <!-- Need more details. -->
|
||||
// </person>
|
||||
}
|
||||
|
||||
func ExampleEncoder() {
|
||||
type Address struct {
|
||||
City, State string
|
||||
}
|
||||
type Person struct {
|
||||
XMLName xml.Name `xml:"person"`
|
||||
Id int `xml:"id,attr"`
|
||||
FirstName string `xml:"name>first"`
|
||||
LastName string `xml:"name>last"`
|
||||
Age int `xml:"age"`
|
||||
Height float32 `xml:"height,omitempty"`
|
||||
Married bool
|
||||
Address
|
||||
Comment string `xml:",comment"`
|
||||
}
|
||||
|
||||
v := &Person{Id: 13, FirstName: "John", LastName: "Doe", Age: 42}
|
||||
v.Comment = " Need more details. "
|
||||
v.Address = Address{"Hanga Roa", "Easter Island"}
|
||||
|
||||
enc := xml.NewEncoder(os.Stdout)
|
||||
enc.Indent(" ", " ")
|
||||
if err := enc.Encode(v); err != nil {
|
||||
fmt.Printf("error: %v\n", err)
|
||||
}
|
||||
|
||||
// Output:
|
||||
// <person id="13">
|
||||
// <name>
|
||||
// <first>John</first>
|
||||
// <last>Doe</last>
|
||||
// </name>
|
||||
// <age>42</age>
|
||||
// <Married>false</Married>
|
||||
// <City>Hanga Roa</City>
|
||||
// <State>Easter Island</State>
|
||||
// <!-- Need more details. -->
|
||||
// </person>
|
||||
}
|
||||
|
||||
// This example demonstrates unmarshaling an XML excerpt into a value with
|
||||
// some preset fields. Note that the Phone field isn't modified and that
|
||||
// the XML <Company> element is ignored. Also, the Groups field is assigned
|
||||
// considering the element path provided in its tag.
|
||||
func ExampleUnmarshal() {
|
||||
type Email struct {
|
||||
Where string `xml:"where,attr"`
|
||||
Addr string
|
||||
}
|
||||
type Address struct {
|
||||
City, State string
|
||||
}
|
||||
type Result struct {
|
||||
XMLName xml.Name `xml:"Person"`
|
||||
Name string `xml:"FullName"`
|
||||
Phone string
|
||||
Email []Email
|
||||
Groups []string `xml:"Group>Value"`
|
||||
Address
|
||||
}
|
||||
v := Result{Name: "none", Phone: "none"}
|
||||
|
||||
data := `
|
||||
<Person>
|
||||
<FullName>Grace R. Emlin</FullName>
|
||||
<Company>Example Inc.</Company>
|
||||
<Email where="home">
|
||||
<Addr>gre@example.com</Addr>
|
||||
</Email>
|
||||
<Email where='work'>
|
||||
<Addr>gre@work.com</Addr>
|
||||
</Email>
|
||||
<Group>
|
||||
<Value>Friends</Value>
|
||||
<Value>Squash</Value>
|
||||
</Group>
|
||||
<City>Hanga Roa</City>
|
||||
<State>Easter Island</State>
|
||||
</Person>
|
||||
`
|
||||
err := xml.Unmarshal([]byte(data), &v)
|
||||
if err != nil {
|
||||
fmt.Printf("error: %v", err)
|
||||
return
|
||||
}
|
||||
fmt.Printf("XMLName: %#v\n", v.XMLName)
|
||||
fmt.Printf("Name: %q\n", v.Name)
|
||||
fmt.Printf("Phone: %q\n", v.Phone)
|
||||
fmt.Printf("Email: %v\n", v.Email)
|
||||
fmt.Printf("Groups: %v\n", v.Groups)
|
||||
fmt.Printf("Address: %v\n", v.Address)
|
||||
// Output:
|
||||
// XMLName: xml.Name{Space:"", Local:"Person"}
|
||||
// Name: "Grace R. Emlin"
|
||||
// Phone: "none"
|
||||
// Email: [{home gre@example.com} {work gre@work.com}]
|
||||
// Groups: [Friends Squash]
|
||||
// Address: {Hanga Roa Easter Island}
|
||||
}
|
File diff suppressed because it is too large
Load Diff
@ -1,744 +0,0 @@
|
||||
// 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"
|
||||
"fmt"
|
||||
"io"
|
||||
"reflect"
|
||||
"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 = `
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en-us" updated="2009-10-04T01:35:58+00:00"><title>Code Review - My issues</title><link href="http://codereview.appspot.com/" rel="alternate"></link><link href="http://codereview.appspot.com/rss/mine/rsc" rel="self"></link><id>http://codereview.appspot.com/</id><author><name>rietveld<></name></author><entry><title>rietveld: an attempt at pubsubhubbub
|
||||
</title><link href="http://codereview.appspot.com/126085" rel="alternate"></link><updated>2009-10-04T01:35:58+00:00</updated><author><name>email-address-removed</name></author><id>urn:md5:134d9179c41f806be79b3a5f7877d19a</id><summary type="html">
|
||||
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).
|
||||
|
||||
|
||||
</summary></entry><entry><title>rietveld: correct tab handling
|
||||
</title><link href="http://codereview.appspot.com/124106" rel="alternate"></link><updated>2009-10-03T23:02:17+00:00</updated><author><name>email-address-removed</name></author><id>urn:md5:0a2a4f19bb815101f0ba2904aed7c35a</id><summary type="html">
|
||||
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.
|
||||
|
||||
|
||||
</summary></entry></feed> `
|
||||
|
||||
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: "<name>rietveld<></name>",
|
||||
},
|
||||
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: "<name>email-address-removed</name>",
|
||||
},
|
||||
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: "<name>email-address-removed</name>",
|
||||
},
|
||||
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 = `
|
||||
<Result>
|
||||
<Before>1</Before>
|
||||
<Items>
|
||||
<Item1>
|
||||
<Value>A</Value>
|
||||
</Item1>
|
||||
<Item2>
|
||||
<Value>B</Value>
|
||||
</Item2>
|
||||
<Item1>
|
||||
<Value>C</Value>
|
||||
<Value>D</Value>
|
||||
</Item1>
|
||||
<_>
|
||||
<Value>E</Value>
|
||||
</_>
|
||||
</Items>
|
||||
<After>2</After>
|
||||
</Result>
|
||||
`
|
||||
|
||||
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 = []interface{}{
|
||||
&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 interface{}
|
||||
}{
|
||||
{&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 = `
|
||||
<?xml version="1.0" charset="utf-8"?>
|
||||
<Test3 Attr="OK" />`
|
||||
|
||||
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(`<Param int="1" />`)
|
||||
|
||||
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: `<Tables>` +
|
||||
`<table xmlns="http://www.w3.org/TR/html4/">hello</table>` +
|
||||
`<table xmlns="http://www.w3schools.com/furniture">world</table>` +
|
||||
`</Tables>`,
|
||||
tab: Tables{"hello", "world"},
|
||||
},
|
||||
{
|
||||
xml: `<Tables>` +
|
||||
`<table xmlns="http://www.w3schools.com/furniture">world</table>` +
|
||||
`<table xmlns="http://www.w3.org/TR/html4/">hello</table>` +
|
||||
`</Tables>`,
|
||||
tab: Tables{"hello", "world"},
|
||||
},
|
||||
{
|
||||
xml: `<Tables xmlns:f="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/">` +
|
||||
`<f:table>world</f:table>` +
|
||||
`<h:table>hello</h:table>` +
|
||||
`</Tables>`,
|
||||
tab: Tables{"hello", "world"},
|
||||
},
|
||||
{
|
||||
xml: `<Tables>` +
|
||||
`<table>bogus</table>` +
|
||||
`</Tables>`,
|
||||
tab: Tables{},
|
||||
},
|
||||
{
|
||||
xml: `<Tables>` +
|
||||
`<table>only</table>` +
|
||||
`</Tables>`,
|
||||
tab: Tables{HTable: "only"},
|
||||
ns: "http://www.w3.org/TR/html4/",
|
||||
},
|
||||
{
|
||||
xml: `<Tables>` +
|
||||
`<table>only</table>` +
|
||||
`</Tables>`,
|
||||
tab: Tables{FTable: "only"},
|
||||
ns: "http://www.w3schools.com/furniture",
|
||||
},
|
||||
{
|
||||
xml: `<Tables>` +
|
||||
`<table>only</table>` +
|
||||
`</Tables>`,
|
||||
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 TestRoundTrip(t *testing.T) {
|
||||
// From issue 7535
|
||||
const s = `<ex:element xmlns:ex="http://example.com/schema"></ex:element>`
|
||||
in := bytes.NewBufferString(s)
|
||||
for i := 0; i < 10; i++ {
|
||||
out := &bytes.Buffer{}
|
||||
d := NewDecoder(in)
|
||||
e := NewEncoder(out)
|
||||
|
||||
for {
|
||||
t, err := d.Token()
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
fmt.Println("failed:", err)
|
||||
return
|
||||
}
|
||||
e.EncodeToken(t)
|
||||
}
|
||||
e.Flush()
|
||||
in = out
|
||||
}
|
||||
if got := in.String(); got != s {
|
||||
t.Errorf("have: %q\nwant: %q\n", got, s)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMarshalNS(t *testing.T) {
|
||||
dst := Tables{"hello", "world"}
|
||||
data, err := Marshal(&dst)
|
||||
if err != nil {
|
||||
t.Fatalf("Marshal: %v", err)
|
||||
}
|
||||
want := `<Tables><table xmlns="http://www.w3.org/TR/html4/">hello</table><table xmlns="http://www.w3schools.com/furniture">world</table></Tables>`
|
||||
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: `<TableAttrs xmlns:f="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/"><TAttr ` +
|
||||
`h:table="hello" f:table="world" ` +
|
||||
`/></TableAttrs>`,
|
||||
tab: TableAttrs{TAttr{HTable: "hello", FTable: "world"}},
|
||||
},
|
||||
{
|
||||
xml: `<TableAttrs><TAttr xmlns:f="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/" ` +
|
||||
`h:table="hello" f:table="world" ` +
|
||||
`/></TableAttrs>`,
|
||||
tab: TableAttrs{TAttr{HTable: "hello", FTable: "world"}},
|
||||
},
|
||||
{
|
||||
xml: `<TableAttrs><TAttr ` +
|
||||
`h:table="hello" f:table="world" xmlns:f="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/" ` +
|
||||
`/></TableAttrs>`,
|
||||
tab: TableAttrs{TAttr{HTable: "hello", FTable: "world"}},
|
||||
},
|
||||
{
|
||||
// Default space does not apply to attribute names.
|
||||
xml: `<TableAttrs xmlns="http://www.w3schools.com/furniture" xmlns:h="http://www.w3.org/TR/html4/"><TAttr ` +
|
||||
`h:table="hello" table="world" ` +
|
||||
`/></TableAttrs>`,
|
||||
tab: TableAttrs{TAttr{HTable: "hello", FTable: ""}},
|
||||
},
|
||||
{
|
||||
// Default space does not apply to attribute names.
|
||||
xml: `<TableAttrs xmlns:f="http://www.w3schools.com/furniture"><TAttr xmlns="http://www.w3.org/TR/html4/" ` +
|
||||
`table="hello" f:table="world" ` +
|
||||
`/></TableAttrs>`,
|
||||
tab: TableAttrs{TAttr{HTable: "", FTable: "world"}},
|
||||
},
|
||||
{
|
||||
xml: `<TableAttrs><TAttr ` +
|
||||
`table="bogus" ` +
|
||||
`/></TableAttrs>`,
|
||||
tab: TableAttrs{},
|
||||
},
|
||||
{
|
||||
// Default space does not apply to attribute names.
|
||||
xml: `<TableAttrs xmlns:h="http://www.w3.org/TR/html4/"><TAttr ` +
|
||||
`h:table="hello" table="world" ` +
|
||||
`/></TableAttrs>`,
|
||||
tab: TableAttrs{TAttr{HTable: "hello", FTable: ""}},
|
||||
ns: "http://www.w3schools.com/furniture",
|
||||
},
|
||||
{
|
||||
// Default space does not apply to attribute names.
|
||||
xml: `<TableAttrs xmlns:f="http://www.w3schools.com/furniture"><TAttr ` +
|
||||
`table="hello" f:table="world" ` +
|
||||
`/></TableAttrs>`,
|
||||
tab: TableAttrs{TAttr{HTable: "", FTable: "world"}},
|
||||
ns: "http://www.w3.org/TR/html4/",
|
||||
},
|
||||
{
|
||||
xml: `<TableAttrs><TAttr ` +
|
||||
`table="bogus" ` +
|
||||
`/></TableAttrs>`,
|
||||
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 := `<TableAttrs><TAttr xmlns:json_1="http://golang.org/2/json/" xmlns:json="http://golang.org/json/" xmlns:_xmlfoo="http://golang.org/xmlfoo/" xmlns:_xml="http://golang.org/xml/" xmlns:furniture="http://www.w3schools.com/furniture" xmlns:html4="http://www.w3.org/TR/html4/" html4:table="hello" furniture:table="world" xml:lang="en_US" _xml:other="other1" _xmlfoo:other="other2" json:other="other3" json_1:other="other4"></TAttr></TableAttrs>`
|
||||
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 := `<?xml version="1.0" encoding="utf-8"?>
|
||||
<MyStruct Attr="attr1" Attr2="attr2">
|
||||
<Data>hello <!-- comment -->world</Data>
|
||||
<Data2>howdy <!-- comment -->world</Data2>
|
||||
</MyStruct>
|
||||
`
|
||||
|
||||
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 interface{} `xml:"Pea"`
|
||||
}
|
||||
|
||||
// https://golang.org/issue/6836
|
||||
func TestUnmarshalIntoInterface(t *testing.T) {
|
||||
pod := new(Pod)
|
||||
pod.Pea = new(Pea)
|
||||
xml := `<Pod><Pea><Cotelydon>Green stuff</Cotelydon></Pea></Pod>`
|
||||
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("unmarshalled 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)
|
||||
}
|
||||
}
|
@ -1,752 +0,0 @@
|
||||
// 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"
|
||||
"fmt"
|
||||
"io"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
const testInput = `
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
<body xmlns:foo="ns1" xmlns="ns2" xmlns:tag="ns3" ` +
|
||||
"\r\n\t" + ` >
|
||||
<hello lang="en">World <>'" 白鵬翔</hello>
|
||||
<query>&何; &is-it;</query>
|
||||
<goodbye />
|
||||
<outer foo:attr="value" xmlns:tag="ns4">
|
||||
<inner/>
|
||||
</outer>
|
||||
<tag:name>
|
||||
<![CDATA[Some text here.]]>
|
||||
</tag:name>
|
||||
</body><!-- missing final newline -->`
|
||||
|
||||
var testEntity = map[string]string{"何": "What", "is-it": "is it?"}
|
||||
|
||||
var rawTokens = []Token{
|
||||
CharData("\n"),
|
||||
ProcInst{"xml", []byte(`version="1.0" encoding="UTF-8"`)},
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"`),
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "body"}, []Attr{{Name{"xmlns", "foo"}, "ns1"}, {Name{"", "xmlns"}, "ns2"}, {Name{"xmlns", "tag"}, "ns3"}}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"", "hello"}, []Attr{{Name{"", "lang"}, "en"}}},
|
||||
CharData("World <>'\" 白鵬翔"),
|
||||
EndElement{Name{"", "hello"}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"", "query"}, []Attr{}},
|
||||
CharData("What is it?"),
|
||||
EndElement{Name{"", "query"}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"", "goodbye"}, []Attr{}},
|
||||
EndElement{Name{"", "goodbye"}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"", "outer"}, []Attr{{Name{"foo", "attr"}, "value"}, {Name{"xmlns", "tag"}, "ns4"}}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"", "inner"}, []Attr{}},
|
||||
EndElement{Name{"", "inner"}},
|
||||
CharData("\n "),
|
||||
EndElement{Name{"", "outer"}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"tag", "name"}, []Attr{}},
|
||||
CharData("\n "),
|
||||
CharData("Some text here."),
|
||||
CharData("\n "),
|
||||
EndElement{Name{"tag", "name"}},
|
||||
CharData("\n"),
|
||||
EndElement{Name{"", "body"}},
|
||||
Comment(" missing final newline "),
|
||||
}
|
||||
|
||||
var cookedTokens = []Token{
|
||||
CharData("\n"),
|
||||
ProcInst{"xml", []byte(`version="1.0" encoding="UTF-8"`)},
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"`),
|
||||
CharData("\n"),
|
||||
StartElement{Name{"ns2", "body"}, []Attr{{Name{"xmlns", "foo"}, "ns1"}, {Name{"", "xmlns"}, "ns2"}, {Name{"xmlns", "tag"}, "ns3"}}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"ns2", "hello"}, []Attr{{Name{"", "lang"}, "en"}}},
|
||||
CharData("World <>'\" 白鵬翔"),
|
||||
EndElement{Name{"ns2", "hello"}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"ns2", "query"}, []Attr{}},
|
||||
CharData("What is it?"),
|
||||
EndElement{Name{"ns2", "query"}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"ns2", "goodbye"}, []Attr{}},
|
||||
EndElement{Name{"ns2", "goodbye"}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"ns2", "outer"}, []Attr{{Name{"ns1", "attr"}, "value"}, {Name{"xmlns", "tag"}, "ns4"}}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"ns2", "inner"}, []Attr{}},
|
||||
EndElement{Name{"ns2", "inner"}},
|
||||
CharData("\n "),
|
||||
EndElement{Name{"ns2", "outer"}},
|
||||
CharData("\n "),
|
||||
StartElement{Name{"ns3", "name"}, []Attr{}},
|
||||
CharData("\n "),
|
||||
CharData("Some text here."),
|
||||
CharData("\n "),
|
||||
EndElement{Name{"ns3", "name"}},
|
||||
CharData("\n"),
|
||||
EndElement{Name{"ns2", "body"}},
|
||||
Comment(" missing final newline "),
|
||||
}
|
||||
|
||||
const testInputAltEncoding = `
|
||||
<?xml version="1.0" encoding="x-testing-uppercase"?>
|
||||
<TAG>VALUE</TAG>`
|
||||
|
||||
var rawTokensAltEncoding = []Token{
|
||||
CharData("\n"),
|
||||
ProcInst{"xml", []byte(`version="1.0" encoding="x-testing-uppercase"`)},
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "tag"}, []Attr{}},
|
||||
CharData("value"),
|
||||
EndElement{Name{"", "tag"}},
|
||||
}
|
||||
|
||||
var xmlInput = []string{
|
||||
// unexpected EOF cases
|
||||
"<",
|
||||
"<t",
|
||||
"<t ",
|
||||
"<t/",
|
||||
"<!",
|
||||
"<!-",
|
||||
"<!--",
|
||||
"<!--c-",
|
||||
"<!--c--",
|
||||
"<!d",
|
||||
"<t></",
|
||||
"<t></t",
|
||||
"<?",
|
||||
"<?p",
|
||||
"<t a",
|
||||
"<t a=",
|
||||
"<t a='",
|
||||
"<t a=''",
|
||||
"<t/><![",
|
||||
"<t/><![C",
|
||||
"<t/><![CDATA[d",
|
||||
"<t/><![CDATA[d]",
|
||||
"<t/><![CDATA[d]]",
|
||||
|
||||
// other Syntax errors
|
||||
"<>",
|
||||
"<t/a",
|
||||
"<0 />",
|
||||
"<?0 >",
|
||||
// "<!0 >", // let the Token() caller handle
|
||||
"</0>",
|
||||
"<t 0=''>",
|
||||
"<t a='&'>",
|
||||
"<t a='<'>",
|
||||
"<t> c;</t>",
|
||||
"<t a>",
|
||||
"<t a=>",
|
||||
"<t a=v>",
|
||||
// "<![CDATA[d]]>", // let the Token() caller handle
|
||||
"<t></e>",
|
||||
"<t></>",
|
||||
"<t></t!",
|
||||
"<t>cdata]]></t>",
|
||||
}
|
||||
|
||||
func TestRawToken(t *testing.T) {
|
||||
d := NewDecoder(strings.NewReader(testInput))
|
||||
d.Entity = testEntity
|
||||
testRawToken(t, d, testInput, rawTokens)
|
||||
}
|
||||
|
||||
const nonStrictInput = `
|
||||
<tag>non&entity</tag>
|
||||
<tag>&unknown;entity</tag>
|
||||
<tag>{</tag>
|
||||
<tag>&#zzz;</tag>
|
||||
<tag>&なまえ3;</tag>
|
||||
<tag><-gt;</tag>
|
||||
<tag>&;</tag>
|
||||
<tag>&0a;</tag>
|
||||
`
|
||||
|
||||
var nonStringEntity = map[string]string{"": "oops!", "0a": "oops!"}
|
||||
|
||||
var nonStrictTokens = []Token{
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "tag"}, []Attr{}},
|
||||
CharData("non&entity"),
|
||||
EndElement{Name{"", "tag"}},
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "tag"}, []Attr{}},
|
||||
CharData("&unknown;entity"),
|
||||
EndElement{Name{"", "tag"}},
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "tag"}, []Attr{}},
|
||||
CharData("{"),
|
||||
EndElement{Name{"", "tag"}},
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "tag"}, []Attr{}},
|
||||
CharData("&#zzz;"),
|
||||
EndElement{Name{"", "tag"}},
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "tag"}, []Attr{}},
|
||||
CharData("&なまえ3;"),
|
||||
EndElement{Name{"", "tag"}},
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "tag"}, []Attr{}},
|
||||
CharData("<-gt;"),
|
||||
EndElement{Name{"", "tag"}},
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "tag"}, []Attr{}},
|
||||
CharData("&;"),
|
||||
EndElement{Name{"", "tag"}},
|
||||
CharData("\n"),
|
||||
StartElement{Name{"", "tag"}, []Attr{}},
|
||||
CharData("&0a;"),
|
||||
EndElement{Name{"", "tag"}},
|
||||
CharData("\n"),
|
||||
}
|
||||
|
||||
func TestNonStrictRawToken(t *testing.T) {
|
||||
d := NewDecoder(strings.NewReader(nonStrictInput))
|
||||
d.Strict = false
|
||||
testRawToken(t, d, nonStrictInput, nonStrictTokens)
|
||||
}
|
||||
|
||||
type downCaser struct {
|
||||
t *testing.T
|
||||
r io.ByteReader
|
||||
}
|
||||
|
||||
func (d *downCaser) ReadByte() (c byte, err error) {
|
||||
c, err = d.r.ReadByte()
|
||||
if c >= 'A' && c <= 'Z' {
|
||||
c += 'a' - 'A'
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (d *downCaser) Read(p []byte) (int, error) {
|
||||
d.t.Fatalf("unexpected Read call on downCaser reader")
|
||||
panic("unreachable")
|
||||
}
|
||||
|
||||
func TestRawTokenAltEncoding(t *testing.T) {
|
||||
d := NewDecoder(strings.NewReader(testInputAltEncoding))
|
||||
d.CharsetReader = func(charset string, input io.Reader) (io.Reader, error) {
|
||||
if charset != "x-testing-uppercase" {
|
||||
t.Fatalf("unexpected charset %q", charset)
|
||||
}
|
||||
return &downCaser{t, input.(io.ByteReader)}, nil
|
||||
}
|
||||
testRawToken(t, d, testInputAltEncoding, rawTokensAltEncoding)
|
||||
}
|
||||
|
||||
func TestRawTokenAltEncodingNoConverter(t *testing.T) {
|
||||
d := NewDecoder(strings.NewReader(testInputAltEncoding))
|
||||
token, err := d.RawToken()
|
||||
if token == nil {
|
||||
t.Fatalf("expected a token on first RawToken call")
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
token, err = d.RawToken()
|
||||
if token != nil {
|
||||
t.Errorf("expected a nil token; got %#v", token)
|
||||
}
|
||||
if err == nil {
|
||||
t.Fatalf("expected an error on second RawToken call")
|
||||
}
|
||||
const encoding = "x-testing-uppercase"
|
||||
if !strings.Contains(err.Error(), encoding) {
|
||||
t.Errorf("expected error to contain %q; got error: %v",
|
||||
encoding, err)
|
||||
}
|
||||
}
|
||||
|
||||
func testRawToken(t *testing.T, d *Decoder, raw string, rawTokens []Token) {
|
||||
lastEnd := int64(0)
|
||||
for i, want := range rawTokens {
|
||||
start := d.InputOffset()
|
||||
have, err := d.RawToken()
|
||||
end := d.InputOffset()
|
||||
if err != nil {
|
||||
t.Fatalf("token %d: unexpected error: %s", i, err)
|
||||
}
|
||||
if !reflect.DeepEqual(have, want) {
|
||||
var shave, swant string
|
||||
if _, ok := have.(CharData); ok {
|
||||
shave = fmt.Sprintf("CharData(%q)", have)
|
||||
} else {
|
||||
shave = fmt.Sprintf("%#v", have)
|
||||
}
|
||||
if _, ok := want.(CharData); ok {
|
||||
swant = fmt.Sprintf("CharData(%q)", want)
|
||||
} else {
|
||||
swant = fmt.Sprintf("%#v", want)
|
||||
}
|
||||
t.Errorf("token %d = %s, want %s", i, shave, swant)
|
||||
}
|
||||
|
||||
// Check that InputOffset returned actual token.
|
||||
switch {
|
||||
case start < lastEnd:
|
||||
t.Errorf("token %d: position [%d,%d) for %T is before previous token", i, start, end, have)
|
||||
case start >= end:
|
||||
// Special case: EndElement can be synthesized.
|
||||
if start == end && end == lastEnd {
|
||||
break
|
||||
}
|
||||
t.Errorf("token %d: position [%d,%d) for %T is empty", i, start, end, have)
|
||||
case end > int64(len(raw)):
|
||||
t.Errorf("token %d: position [%d,%d) for %T extends beyond input", i, start, end, have)
|
||||
default:
|
||||
text := raw[start:end]
|
||||
if strings.ContainsAny(text, "<>") && (!strings.HasPrefix(text, "<") || !strings.HasSuffix(text, ">")) {
|
||||
t.Errorf("token %d: misaligned raw token %#q for %T", i, text, have)
|
||||
}
|
||||
}
|
||||
lastEnd = end
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure that directives (specifically !DOCTYPE) include the complete
|
||||
// text of any nested directives, noting that < and > do not change
|
||||
// nesting depth if they are in single or double quotes.
|
||||
|
||||
var nestedDirectivesInput = `
|
||||
<!DOCTYPE [<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]>
|
||||
<!DOCTYPE [<!ENTITY xlt ">">]>
|
||||
<!DOCTYPE [<!ENTITY xlt "<">]>
|
||||
<!DOCTYPE [<!ENTITY xlt '>'>]>
|
||||
<!DOCTYPE [<!ENTITY xlt '<'>]>
|
||||
<!DOCTYPE [<!ENTITY xlt '">'>]>
|
||||
<!DOCTYPE [<!ENTITY xlt "'<">]>
|
||||
`
|
||||
|
||||
var nestedDirectivesTokens = []Token{
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE [<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]`),
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE [<!ENTITY xlt ">">]`),
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE [<!ENTITY xlt "<">]`),
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE [<!ENTITY xlt '>'>]`),
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE [<!ENTITY xlt '<'>]`),
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE [<!ENTITY xlt '">'>]`),
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE [<!ENTITY xlt "'<">]`),
|
||||
CharData("\n"),
|
||||
}
|
||||
|
||||
func TestNestedDirectives(t *testing.T) {
|
||||
d := NewDecoder(strings.NewReader(nestedDirectivesInput))
|
||||
|
||||
for i, want := range nestedDirectivesTokens {
|
||||
have, err := d.Token()
|
||||
if err != nil {
|
||||
t.Fatalf("token %d: unexpected error: %s", i, err)
|
||||
}
|
||||
if !reflect.DeepEqual(have, want) {
|
||||
t.Errorf("token %d = %#v want %#v", i, have, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestToken(t *testing.T) {
|
||||
d := NewDecoder(strings.NewReader(testInput))
|
||||
d.Entity = testEntity
|
||||
|
||||
for i, want := range cookedTokens {
|
||||
have, err := d.Token()
|
||||
if err != nil {
|
||||
t.Fatalf("token %d: unexpected error: %s", i, err)
|
||||
}
|
||||
if !reflect.DeepEqual(have, want) {
|
||||
t.Errorf("token %d = %#v want %#v", i, have, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSyntax(t *testing.T) {
|
||||
for i := range xmlInput {
|
||||
d := NewDecoder(strings.NewReader(xmlInput[i]))
|
||||
var err error
|
||||
for _, err = d.Token(); err == nil; _, err = d.Token() {
|
||||
}
|
||||
if _, ok := err.(*SyntaxError); !ok {
|
||||
t.Fatalf(`xmlInput "%s": expected SyntaxError not received`, xmlInput[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type allScalars struct {
|
||||
True1 bool
|
||||
True2 bool
|
||||
False1 bool
|
||||
False2 bool
|
||||
Int int
|
||||
Int8 int8
|
||||
Int16 int16
|
||||
Int32 int32
|
||||
Int64 int64
|
||||
Uint int
|
||||
Uint8 uint8
|
||||
Uint16 uint16
|
||||
Uint32 uint32
|
||||
Uint64 uint64
|
||||
Uintptr uintptr
|
||||
Float32 float32
|
||||
Float64 float64
|
||||
String string
|
||||
PtrString *string
|
||||
}
|
||||
|
||||
var all = allScalars{
|
||||
True1: true,
|
||||
True2: true,
|
||||
False1: false,
|
||||
False2: false,
|
||||
Int: 1,
|
||||
Int8: -2,
|
||||
Int16: 3,
|
||||
Int32: -4,
|
||||
Int64: 5,
|
||||
Uint: 6,
|
||||
Uint8: 7,
|
||||
Uint16: 8,
|
||||
Uint32: 9,
|
||||
Uint64: 10,
|
||||
Uintptr: 11,
|
||||
Float32: 13.0,
|
||||
Float64: 14.0,
|
||||
String: "15",
|
||||
PtrString: &sixteen,
|
||||
}
|
||||
|
||||
var sixteen = "16"
|
||||
|
||||
const testScalarsInput = `<allscalars>
|
||||
<True1>true</True1>
|
||||
<True2>1</True2>
|
||||
<False1>false</False1>
|
||||
<False2>0</False2>
|
||||
<Int>1</Int>
|
||||
<Int8>-2</Int8>
|
||||
<Int16>3</Int16>
|
||||
<Int32>-4</Int32>
|
||||
<Int64>5</Int64>
|
||||
<Uint>6</Uint>
|
||||
<Uint8>7</Uint8>
|
||||
<Uint16>8</Uint16>
|
||||
<Uint32>9</Uint32>
|
||||
<Uint64>10</Uint64>
|
||||
<Uintptr>11</Uintptr>
|
||||
<Float>12.0</Float>
|
||||
<Float32>13.0</Float32>
|
||||
<Float64>14.0</Float64>
|
||||
<String>15</String>
|
||||
<PtrString>16</PtrString>
|
||||
</allscalars>`
|
||||
|
||||
func TestAllScalars(t *testing.T) {
|
||||
var a allScalars
|
||||
err := Unmarshal([]byte(testScalarsInput), &a)
|
||||
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !reflect.DeepEqual(a, all) {
|
||||
t.Errorf("have %+v want %+v", a, all)
|
||||
}
|
||||
}
|
||||
|
||||
type item struct {
|
||||
Field_a string
|
||||
}
|
||||
|
||||
func TestIssue569(t *testing.T) {
|
||||
data := `<item><Field_a>abcd</Field_a></item>`
|
||||
var i item
|
||||
err := Unmarshal([]byte(data), &i)
|
||||
|
||||
if err != nil || i.Field_a != "abcd" {
|
||||
t.Fatal("Expecting abcd")
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnquotedAttrs(t *testing.T) {
|
||||
data := "<tag attr=azAZ09:-_\t>"
|
||||
d := NewDecoder(strings.NewReader(data))
|
||||
d.Strict = false
|
||||
token, err := d.Token()
|
||||
if _, ok := err.(*SyntaxError); ok {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if token.(StartElement).Name.Local != "tag" {
|
||||
t.Errorf("Unexpected tag name: %v", token.(StartElement).Name.Local)
|
||||
}
|
||||
attr := token.(StartElement).Attr[0]
|
||||
if attr.Value != "azAZ09:-_" {
|
||||
t.Errorf("Unexpected attribute value: %v", attr.Value)
|
||||
}
|
||||
if attr.Name.Local != "attr" {
|
||||
t.Errorf("Unexpected attribute name: %v", attr.Name.Local)
|
||||
}
|
||||
}
|
||||
|
||||
func TestValuelessAttrs(t *testing.T) {
|
||||
tests := [][3]string{
|
||||
{"<p nowrap>", "p", "nowrap"},
|
||||
{"<p nowrap >", "p", "nowrap"},
|
||||
{"<input checked/>", "input", "checked"},
|
||||
{"<input checked />", "input", "checked"},
|
||||
}
|
||||
for _, test := range tests {
|
||||
d := NewDecoder(strings.NewReader(test[0]))
|
||||
d.Strict = false
|
||||
token, err := d.Token()
|
||||
if _, ok := err.(*SyntaxError); ok {
|
||||
t.Errorf("Unexpected error: %v", err)
|
||||
}
|
||||
if token.(StartElement).Name.Local != test[1] {
|
||||
t.Errorf("Unexpected tag name: %v", token.(StartElement).Name.Local)
|
||||
}
|
||||
attr := token.(StartElement).Attr[0]
|
||||
if attr.Value != test[2] {
|
||||
t.Errorf("Unexpected attribute value: %v", attr.Value)
|
||||
}
|
||||
if attr.Name.Local != test[2] {
|
||||
t.Errorf("Unexpected attribute name: %v", attr.Name.Local)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCopyTokenCharData(t *testing.T) {
|
||||
data := []byte("same data")
|
||||
var tok1 Token = CharData(data)
|
||||
tok2 := CopyToken(tok1)
|
||||
if !reflect.DeepEqual(tok1, tok2) {
|
||||
t.Error("CopyToken(CharData) != CharData")
|
||||
}
|
||||
data[1] = 'o'
|
||||
if reflect.DeepEqual(tok1, tok2) {
|
||||
t.Error("CopyToken(CharData) uses same buffer.")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCopyTokenStartElement(t *testing.T) {
|
||||
elt := StartElement{Name{"", "hello"}, []Attr{{Name{"", "lang"}, "en"}}}
|
||||
var tok1 Token = elt
|
||||
tok2 := CopyToken(tok1)
|
||||
if tok1.(StartElement).Attr[0].Value != "en" {
|
||||
t.Error("CopyToken overwrote Attr[0]")
|
||||
}
|
||||
if !reflect.DeepEqual(tok1, tok2) {
|
||||
t.Error("CopyToken(StartElement) != StartElement")
|
||||
}
|
||||
tok1.(StartElement).Attr[0] = Attr{Name{"", "lang"}, "de"}
|
||||
if reflect.DeepEqual(tok1, tok2) {
|
||||
t.Error("CopyToken(CharData) uses same buffer.")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSyntaxErrorLineNum(t *testing.T) {
|
||||
testInput := "<P>Foo<P>\n\n<P>Bar</>\n"
|
||||
d := NewDecoder(strings.NewReader(testInput))
|
||||
var err error
|
||||
for _, err = d.Token(); err == nil; _, err = d.Token() {
|
||||
}
|
||||
synerr, ok := err.(*SyntaxError)
|
||||
if !ok {
|
||||
t.Error("Expected SyntaxError.")
|
||||
}
|
||||
if synerr.Line != 3 {
|
||||
t.Error("SyntaxError didn't have correct line number.")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTrailingRawToken(t *testing.T) {
|
||||
input := `<FOO></FOO> `
|
||||
d := NewDecoder(strings.NewReader(input))
|
||||
var err error
|
||||
for _, err = d.RawToken(); err == nil; _, err = d.RawToken() {
|
||||
}
|
||||
if err != io.EOF {
|
||||
t.Fatalf("d.RawToken() = _, %v, want _, io.EOF", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTrailingToken(t *testing.T) {
|
||||
input := `<FOO></FOO> `
|
||||
d := NewDecoder(strings.NewReader(input))
|
||||
var err error
|
||||
for _, err = d.Token(); err == nil; _, err = d.Token() {
|
||||
}
|
||||
if err != io.EOF {
|
||||
t.Fatalf("d.Token() = _, %v, want _, io.EOF", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEntityInsideCDATA(t *testing.T) {
|
||||
input := `<test><![CDATA[ &val=foo ]]></test>`
|
||||
d := NewDecoder(strings.NewReader(input))
|
||||
var err error
|
||||
for _, err = d.Token(); err == nil; _, err = d.Token() {
|
||||
}
|
||||
if err != io.EOF {
|
||||
t.Fatalf("d.Token() = _, %v, want _, io.EOF", err)
|
||||
}
|
||||
}
|
||||
|
||||
var characterTests = []struct {
|
||||
in string
|
||||
err string
|
||||
}{
|
||||
{"\x12<doc/>", "illegal character code U+0012"},
|
||||
{"<?xml version=\"1.0\"?>\x0b<doc/>", "illegal character code U+000B"},
|
||||
{"\xef\xbf\xbe<doc/>", "illegal character code U+FFFE"},
|
||||
{"<?xml version=\"1.0\"?><doc>\r\n<hiya/>\x07<toots/></doc>", "illegal character code U+0007"},
|
||||
{"<?xml version=\"1.0\"?><doc \x12='value'>what's up</doc>", "expected attribute name in element"},
|
||||
{"<doc>&abc\x01;</doc>", "invalid character entity &abc (no semicolon)"},
|
||||
{"<doc>&\x01;</doc>", "invalid character entity & (no semicolon)"},
|
||||
{"<doc>&\xef\xbf\xbe;</doc>", "invalid character entity &\uFFFE;"},
|
||||
{"<doc>&hello;</doc>", "invalid character entity &hello;"},
|
||||
}
|
||||
|
||||
func TestDisallowedCharacters(t *testing.T) {
|
||||
|
||||
for i, tt := range characterTests {
|
||||
d := NewDecoder(strings.NewReader(tt.in))
|
||||
var err error
|
||||
|
||||
for err == nil {
|
||||
_, err = d.Token()
|
||||
}
|
||||
synerr, ok := err.(*SyntaxError)
|
||||
if !ok {
|
||||
t.Fatalf("input %d d.Token() = _, %v, want _, *SyntaxError", i, err)
|
||||
}
|
||||
if synerr.Msg != tt.err {
|
||||
t.Fatalf("input %d synerr.Msg wrong: want %q, got %q", i, tt.err, synerr.Msg)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type procInstEncodingTest struct {
|
||||
expect, got string
|
||||
}
|
||||
|
||||
var procInstTests = []struct {
|
||||
input string
|
||||
expect [2]string
|
||||
}{
|
||||
{`version="1.0" encoding="utf-8"`, [2]string{"1.0", "utf-8"}},
|
||||
{`version="1.0" encoding='utf-8'`, [2]string{"1.0", "utf-8"}},
|
||||
{`version="1.0" encoding='utf-8' `, [2]string{"1.0", "utf-8"}},
|
||||
{`version="1.0" encoding=utf-8`, [2]string{"1.0", ""}},
|
||||
{`encoding="FOO" `, [2]string{"", "FOO"}},
|
||||
}
|
||||
|
||||
func TestProcInstEncoding(t *testing.T) {
|
||||
for _, test := range procInstTests {
|
||||
if got := procInst("version", test.input); got != test.expect[0] {
|
||||
t.Errorf("procInst(version, %q) = %q; want %q", test.input, got, test.expect[0])
|
||||
}
|
||||
if got := procInst("encoding", test.input); got != test.expect[1] {
|
||||
t.Errorf("procInst(encoding, %q) = %q; want %q", test.input, got, test.expect[1])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure that directives with comments include the complete
|
||||
// text of any nested directives.
|
||||
|
||||
var directivesWithCommentsInput = `
|
||||
<!DOCTYPE [<!-- a comment --><!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]>
|
||||
<!DOCTYPE [<!ENTITY go "Golang"><!-- a comment-->]>
|
||||
<!DOCTYPE <!-> <!> <!----> <!-->--> <!--->--> [<!ENTITY go "Golang"><!-- a comment-->]>
|
||||
`
|
||||
|
||||
var directivesWithCommentsTokens = []Token{
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE [<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">]`),
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE [<!ENTITY go "Golang">]`),
|
||||
CharData("\n"),
|
||||
Directive(`DOCTYPE <!-> <!> [<!ENTITY go "Golang">]`),
|
||||
CharData("\n"),
|
||||
}
|
||||
|
||||
func TestDirectivesWithComments(t *testing.T) {
|
||||
d := NewDecoder(strings.NewReader(directivesWithCommentsInput))
|
||||
|
||||
for i, want := range directivesWithCommentsTokens {
|
||||
have, err := d.Token()
|
||||
if err != nil {
|
||||
t.Fatalf("token %d: unexpected error: %s", i, err)
|
||||
}
|
||||
if !reflect.DeepEqual(have, want) {
|
||||
t.Errorf("token %d = %#v want %#v", i, have, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Writer whose Write method always returns an error.
|
||||
type errWriter struct{}
|
||||
|
||||
func (errWriter) Write(p []byte) (n int, err error) { return 0, fmt.Errorf("unwritable") }
|
||||
|
||||
func TestEscapeTextIOErrors(t *testing.T) {
|
||||
expectErr := "unwritable"
|
||||
err := EscapeText(errWriter{}, []byte{'A'})
|
||||
|
||||
if err == nil || err.Error() != expectErr {
|
||||
t.Errorf("have %v, want %v", err, expectErr)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEscapeTextInvalidChar(t *testing.T) {
|
||||
input := []byte("A \x00 terminated string.")
|
||||
expected := "A \uFFFD terminated string."
|
||||
|
||||
buff := new(bytes.Buffer)
|
||||
if err := EscapeText(buff, input); err != nil {
|
||||
t.Fatalf("have %v, want nil", err)
|
||||
}
|
||||
text := buff.String()
|
||||
|
||||
if text != expected {
|
||||
t.Errorf("have %v, want %v", text, expected)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIssue5880(t *testing.T) {
|
||||
type T []byte
|
||||
data, err := Marshal(T{192, 168, 0, 1})
|
||||
if err != nil {
|
||||
t.Errorf("Marshal error: %v", err)
|
||||
}
|
||||
if !utf8.Valid(data) {
|
||||
t.Errorf("Marshal generated invalid UTF-8: %x", data)
|
||||
}
|
||||
}
|
Loading…
Reference in new issue