mirror of
https://github.com/nikdoof/vsphere-influxdb-go.git
synced 2025-12-20 05:59:21 +00:00
add vendoring with go dep
This commit is contained in:
Adrian Todorov
27
vendor/github.com/vmware/govmomi/vim25/xml/LICENSE
generated
vendored
Normal file
27
vendor/github.com/vmware/govmomi/vim25/xml/LICENSE
generated
vendored
Normal file
@@ -0,0 +1,27 @@
|
||||
Copyright (c) 2012 The Go Authors. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following disclaimer
|
||||
in the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
* Neither the name of Google Inc. nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
56
vendor/github.com/vmware/govmomi/vim25/xml/atom_test.go
generated
vendored
Normal file
56
vendor/github.com/vmware/govmomi/vim25/xml/atom_test.go
generated
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
// 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,
|
||||
}
|
||||
}
|
||||
151
vendor/github.com/vmware/govmomi/vim25/xml/example_test.go
generated
vendored
Normal file
151
vendor/github.com/vmware/govmomi/vim25/xml/example_test.go
generated
vendored
Normal file
@@ -0,0 +1,151 @@
|
||||
// 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}
|
||||
}
|
||||
99
vendor/github.com/vmware/govmomi/vim25/xml/extras.go
generated
vendored
Normal file
99
vendor/github.com/vmware/govmomi/vim25/xml/extras.go
generated
vendored
Normal file
@@ -0,0 +1,99 @@
|
||||
/*
|
||||
Copyright (c) 2014 VMware, Inc. All Rights Reserved.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
|
||||
package xml
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"time"
|
||||
)
|
||||
|
||||
var xmlSchemaInstance = Name{Space: "http://www.w3.org/2001/XMLSchema-instance", Local: "type"}
|
||||
|
||||
var xsiType = Name{Space: "xsi", Local: "type"}
|
||||
|
||||
var stringToTypeMap = map[string]reflect.Type{
|
||||
"xsd:boolean": reflect.TypeOf((*bool)(nil)).Elem(),
|
||||
"xsd:byte": reflect.TypeOf((*int8)(nil)).Elem(),
|
||||
"xsd:short": reflect.TypeOf((*int16)(nil)).Elem(),
|
||||
"xsd:int": reflect.TypeOf((*int32)(nil)).Elem(),
|
||||
"xsd:long": reflect.TypeOf((*int64)(nil)).Elem(),
|
||||
"xsd:unsignedByte": reflect.TypeOf((*uint8)(nil)).Elem(),
|
||||
"xsd:unsignedShort": reflect.TypeOf((*uint16)(nil)).Elem(),
|
||||
"xsd:unsignedInt": reflect.TypeOf((*uint32)(nil)).Elem(),
|
||||
"xsd:unsignedLong": reflect.TypeOf((*uint64)(nil)).Elem(),
|
||||
"xsd:float": reflect.TypeOf((*float32)(nil)).Elem(),
|
||||
"xsd:double": reflect.TypeOf((*float64)(nil)).Elem(),
|
||||
"xsd:string": reflect.TypeOf((*string)(nil)).Elem(),
|
||||
"xsd:dateTime": reflect.TypeOf((*time.Time)(nil)).Elem(),
|
||||
"xsd:base64Binary": reflect.TypeOf((*[]byte)(nil)).Elem(),
|
||||
}
|
||||
|
||||
// Return a reflect.Type for the specified type. Nil if unknown.
|
||||
func stringToType(s string) reflect.Type {
|
||||
return stringToTypeMap[s]
|
||||
}
|
||||
|
||||
// Return a string for the specified reflect.Type. Panic if unknown.
|
||||
func typeToString(typ reflect.Type) string {
|
||||
switch typ.Kind() {
|
||||
case reflect.Bool:
|
||||
return "xsd:boolean"
|
||||
case reflect.Int8:
|
||||
return "xsd:byte"
|
||||
case reflect.Int16:
|
||||
return "xsd:short"
|
||||
case reflect.Int32:
|
||||
return "xsd:int"
|
||||
case reflect.Int, reflect.Int64:
|
||||
return "xsd:long"
|
||||
case reflect.Uint8:
|
||||
return "xsd:unsignedByte"
|
||||
case reflect.Uint16:
|
||||
return "xsd:unsignedShort"
|
||||
case reflect.Uint32:
|
||||
return "xsd:unsignedInt"
|
||||
case reflect.Uint, reflect.Uint64:
|
||||
return "xsd:unsignedLong"
|
||||
case reflect.Float32:
|
||||
return "xsd:float"
|
||||
case reflect.Float64:
|
||||
return "xsd:double"
|
||||
case reflect.String:
|
||||
name := typ.Name()
|
||||
if name == "string" {
|
||||
return "xsd:string"
|
||||
}
|
||||
return name
|
||||
case reflect.Struct:
|
||||
if typ == stringToTypeMap["xsd:dateTime"] {
|
||||
return "xsd:dateTime"
|
||||
}
|
||||
|
||||
// Expect any other struct to be handled...
|
||||
return typ.Name()
|
||||
case reflect.Slice:
|
||||
if typ.Elem().Kind() == reflect.Uint8 {
|
||||
return "xsd:base64Binary"
|
||||
}
|
||||
case reflect.Array:
|
||||
if typ.Elem().Kind() == reflect.Uint8 {
|
||||
return "xsd:base64Binary"
|
||||
}
|
||||
}
|
||||
|
||||
panic("don't know what to do for type: " + typ.String())
|
||||
}
|
||||
222
vendor/github.com/vmware/govmomi/vim25/xml/extras_test.go
generated
vendored
Normal file
222
vendor/github.com/vmware/govmomi/vim25/xml/extras_test.go
generated
vendored
Normal file
@@ -0,0 +1,222 @@
|
||||
/*
|
||||
Copyright (c) 2014 VMware, Inc. All Rights Reserved.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
|
||||
package xml
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
type MyType struct {
|
||||
Value string
|
||||
}
|
||||
|
||||
var myTypes = map[string]reflect.Type{
|
||||
"MyType": reflect.TypeOf(MyType{}),
|
||||
"ValueType": reflect.TypeOf(ValueType{}),
|
||||
"PointerType": reflect.TypeOf(PointerType{}),
|
||||
}
|
||||
|
||||
func MyTypes(name string) (reflect.Type, bool) {
|
||||
t, ok := myTypes[name]
|
||||
return t, ok
|
||||
}
|
||||
|
||||
func TestMarshalWithEmptyInterface(t *testing.T) {
|
||||
var r1, r2 struct {
|
||||
XMLName Name `xml:"root"`
|
||||
Values []interface{} `xml:"value,typeattr"`
|
||||
}
|
||||
|
||||
var tests = []struct {
|
||||
Value interface{}
|
||||
}{
|
||||
{Value: bool(true)},
|
||||
{Value: int8(-8)},
|
||||
{Value: int16(-16)},
|
||||
{Value: int32(-32)},
|
||||
{Value: int64(-64)},
|
||||
{Value: uint8(8)},
|
||||
{Value: uint16(16)},
|
||||
{Value: uint32(32)},
|
||||
{Value: uint64(64)},
|
||||
{Value: float32(32.0)},
|
||||
{Value: float64(64.0)},
|
||||
{Value: string("string")},
|
||||
{Value: time.Now()},
|
||||
{Value: ParseTime("2009-10-04T01:35:58+00:00")},
|
||||
{Value: []byte("bytes")},
|
||||
{Value: MyType{Value: "v"}},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
r1.XMLName.Local = "root"
|
||||
r1.Values = []interface{}{test.Value}
|
||||
r2.XMLName = Name{}
|
||||
r2.Values = nil
|
||||
|
||||
b, err := Marshal(r1)
|
||||
if err != nil {
|
||||
t.Fatalf("Marshal: %s", err)
|
||||
}
|
||||
|
||||
dec := NewDecoder(bytes.NewReader(b))
|
||||
dec.TypeFunc = MyTypes
|
||||
err = dec.Decode(&r2)
|
||||
if err != nil {
|
||||
t.Fatalf("Unmarshal: %s", err)
|
||||
}
|
||||
|
||||
switch r1.Values[0].(type) {
|
||||
case time.Time:
|
||||
if !r1.Values[0].(time.Time).Equal(r2.Values[0].(time.Time)) {
|
||||
t.Errorf("Expected: %#v, actual: %#v", r1, r2)
|
||||
}
|
||||
default:
|
||||
if !reflect.DeepEqual(r1, r2) {
|
||||
t.Errorf("Expected: %#v, actual: %#v", r1, r2)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type VIntf interface {
|
||||
V() string
|
||||
}
|
||||
|
||||
type ValueType struct {
|
||||
Value string `xml:",chardata"`
|
||||
}
|
||||
|
||||
type PointerType struct {
|
||||
Value string `xml:",chardata"`
|
||||
}
|
||||
|
||||
func (t ValueType) V() string {
|
||||
return t.Value
|
||||
}
|
||||
|
||||
func (t *PointerType) V() string {
|
||||
return t.Value
|
||||
}
|
||||
|
||||
func TestMarshalWithInterface(t *testing.T) {
|
||||
var r1, r2 struct {
|
||||
XMLName Name `xml:"root"`
|
||||
Values []VIntf `xml:"value,typeattr"`
|
||||
}
|
||||
|
||||
r1.XMLName.Local = "root"
|
||||
r1.Values = []VIntf{
|
||||
ValueType{"v1"},
|
||||
&PointerType{"v2"},
|
||||
}
|
||||
|
||||
b, err := Marshal(r1)
|
||||
if err != nil {
|
||||
t.Fatalf("Marshal: %s", err)
|
||||
}
|
||||
|
||||
dec := NewDecoder(bytes.NewReader(b))
|
||||
dec.TypeFunc = MyTypes
|
||||
err = dec.Decode(&r2)
|
||||
if err != nil {
|
||||
t.Fatalf("Unmarshal: %s", err)
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(r1, r2) {
|
||||
t.Errorf("expected: %#v, actual: %#v", r1, r2)
|
||||
}
|
||||
}
|
||||
|
||||
type test3iface interface {
|
||||
Value() string
|
||||
}
|
||||
|
||||
type test3a struct {
|
||||
V string `xml:",chardata"`
|
||||
}
|
||||
|
||||
func (t test3a) Value() string { return t.V }
|
||||
|
||||
type test3b struct {
|
||||
V string `xml:",chardata"`
|
||||
}
|
||||
|
||||
func (t test3b) Value() string { return t.V }
|
||||
|
||||
func TestUnmarshalInterfaceWithoutTypeAttr(t *testing.T) {
|
||||
var r struct {
|
||||
XMLName Name `xml:"root"`
|
||||
Values []test3iface `xml:"value,typeattr"`
|
||||
}
|
||||
|
||||
b := `
|
||||
<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
|
||||
<value xsi:type="test3a">A</value>
|
||||
<value>B</value>
|
||||
</root>
|
||||
`
|
||||
|
||||
fn := func(name string) (reflect.Type, bool) {
|
||||
switch name {
|
||||
case "test3a":
|
||||
return reflect.TypeOf(test3a{}), true
|
||||
case "test3iface":
|
||||
return reflect.TypeOf(test3b{}), true
|
||||
default:
|
||||
return nil, false
|
||||
}
|
||||
}
|
||||
|
||||
dec := NewDecoder(bytes.NewReader([]byte(b)))
|
||||
dec.TypeFunc = fn
|
||||
err := dec.Decode(&r)
|
||||
if err != nil {
|
||||
t.Fatalf("Unmarshal: %s", err)
|
||||
}
|
||||
|
||||
if len(r.Values) != 2 {
|
||||
t.Errorf("Expected 2 values")
|
||||
}
|
||||
|
||||
exps := []struct {
|
||||
Typ reflect.Type
|
||||
Val string
|
||||
}{
|
||||
{
|
||||
Typ: reflect.TypeOf(test3a{}),
|
||||
Val: "A",
|
||||
},
|
||||
{
|
||||
Typ: reflect.TypeOf(test3b{}),
|
||||
Val: "B",
|
||||
},
|
||||
}
|
||||
|
||||
for i, e := range exps {
|
||||
if val := r.Values[i].Value(); val != e.Val {
|
||||
t.Errorf("Expected: %s, got: %s", e.Val, val)
|
||||
}
|
||||
|
||||
if typ := reflect.TypeOf(r.Values[i]); typ.Name() != e.Typ.Name() {
|
||||
t.Errorf("Expected: %s, got: %s", e.Typ.Name(), typ.Name())
|
||||
}
|
||||
}
|
||||
}
|
||||
949
vendor/github.com/vmware/govmomi/vim25/xml/marshal.go
generated
vendored
Normal file
949
vendor/github.com/vmware/govmomi/vim25/xml/marshal.go
generated
vendored
Normal file
@@ -0,0 +1,949 @@
|
||||
// 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 (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"encoding"
|
||||
"fmt"
|
||||
"io"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
// A generic XML header suitable for use with the output of Marshal.
|
||||
// This is not automatically added to any output of this package,
|
||||
// it is provided as a convenience.
|
||||
Header = `<?xml version="1.0" encoding="UTF-8"?>` + "\n"
|
||||
)
|
||||
|
||||
// Marshal returns the XML encoding of v.
|
||||
//
|
||||
// Marshal handles an array or slice by marshalling each of the elements.
|
||||
// Marshal handles a pointer by marshalling the value it points at or, if the
|
||||
// pointer is nil, by writing nothing. Marshal handles an interface value by
|
||||
// marshalling the value it contains or, if the interface value is nil, by
|
||||
// writing nothing. Marshal handles all other data by writing one or more XML
|
||||
// elements containing the data.
|
||||
//
|
||||
// The name for the XML elements is taken from, in order of preference:
|
||||
// - the tag on the XMLName field, if the data is a struct
|
||||
// - the value of the XMLName field of type xml.Name
|
||||
// - the tag of the struct field used to obtain the data
|
||||
// - the name of the struct field used to obtain the data
|
||||
// - the name of the marshalled type
|
||||
//
|
||||
// The XML element for a struct contains marshalled elements for each of the
|
||||
// exported fields of the struct, with these exceptions:
|
||||
// - the XMLName field, described above, is omitted.
|
||||
// - a field with tag "-" is omitted.
|
||||
// - a field with tag "name,attr" becomes an attribute with
|
||||
// the given name in the XML element.
|
||||
// - a field with tag ",attr" becomes an attribute with the
|
||||
// field name in the XML element.
|
||||
// - a field with tag ",chardata" is written as character data,
|
||||
// not as an XML element.
|
||||
// - a field with tag ",innerxml" is written verbatim, not subject
|
||||
// to the usual marshalling procedure.
|
||||
// - a field with tag ",comment" is written as an XML comment, not
|
||||
// subject to the usual marshalling procedure. It must not contain
|
||||
// the "--" string within it.
|
||||
// - a field with a tag including the "omitempty" option is omitted
|
||||
// if the field value is empty. The empty values are false, 0, any
|
||||
// nil pointer or interface value, and any array, slice, map, or
|
||||
// string of length zero.
|
||||
// - an anonymous struct field is handled as if the fields of its
|
||||
// value were part of the outer struct.
|
||||
//
|
||||
// If a field uses a tag "a>b>c", then the element c will be nested inside
|
||||
// parent elements a and b. Fields that appear next to each other that name
|
||||
// the same parent will be enclosed in one XML element.
|
||||
//
|
||||
// See MarshalIndent for an example.
|
||||
//
|
||||
// Marshal will return an error if asked to marshal a channel, function, or map.
|
||||
func Marshal(v interface{}) ([]byte, error) {
|
||||
var b bytes.Buffer
|
||||
if err := NewEncoder(&b).Encode(v); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return b.Bytes(), nil
|
||||
}
|
||||
|
||||
// Marshaler is the interface implemented by objects that can marshal
|
||||
// themselves into valid XML elements.
|
||||
//
|
||||
// MarshalXML encodes the receiver as zero or more XML elements.
|
||||
// By convention, arrays or slices are typically encoded as a sequence
|
||||
// of elements, one per entry.
|
||||
// Using start as the element tag is not required, but doing so
|
||||
// will enable Unmarshal to match the XML elements to the correct
|
||||
// struct field.
|
||||
// One common implementation strategy is to construct a separate
|
||||
// value with a layout corresponding to the desired XML and then
|
||||
// to encode it using e.EncodeElement.
|
||||
// Another common strategy is to use repeated calls to e.EncodeToken
|
||||
// to generate the XML output one token at a time.
|
||||
// The sequence of encoded tokens must make up zero or more valid
|
||||
// XML elements.
|
||||
type Marshaler interface {
|
||||
MarshalXML(e *Encoder, start StartElement) error
|
||||
}
|
||||
|
||||
// MarshalerAttr is the interface implemented by objects that can marshal
|
||||
// themselves into valid XML attributes.
|
||||
//
|
||||
// MarshalXMLAttr returns an XML attribute with the encoded value of the receiver.
|
||||
// Using name as the attribute name is not required, but doing so
|
||||
// will enable Unmarshal to match the attribute to the correct
|
||||
// struct field.
|
||||
// If MarshalXMLAttr returns the zero attribute Attr{}, no attribute
|
||||
// will be generated in the output.
|
||||
// MarshalXMLAttr is used only for struct fields with the
|
||||
// "attr" option in the field tag.
|
||||
type MarshalerAttr interface {
|
||||
MarshalXMLAttr(name Name) (Attr, error)
|
||||
}
|
||||
|
||||
// MarshalIndent works like Marshal, but each XML element begins on a new
|
||||
// indented line that starts with prefix and is followed by one or more
|
||||
// copies of indent according to the nesting depth.
|
||||
func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
|
||||
var b bytes.Buffer
|
||||
enc := NewEncoder(&b)
|
||||
enc.Indent(prefix, indent)
|
||||
if err := enc.Encode(v); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return b.Bytes(), nil
|
||||
}
|
||||
|
||||
// An Encoder writes XML data to an output stream.
|
||||
type Encoder struct {
|
||||
p printer
|
||||
}
|
||||
|
||||
// NewEncoder returns a new encoder that writes to w.
|
||||
func NewEncoder(w io.Writer) *Encoder {
|
||||
e := &Encoder{printer{Writer: bufio.NewWriter(w)}}
|
||||
e.p.encoder = e
|
||||
return e
|
||||
}
|
||||
|
||||
// Indent sets the encoder to generate XML in which each element
|
||||
// begins on a new indented line that starts with prefix and is followed by
|
||||
// one or more copies of indent according to the nesting depth.
|
||||
func (enc *Encoder) Indent(prefix, indent string) {
|
||||
enc.p.prefix = prefix
|
||||
enc.p.indent = indent
|
||||
}
|
||||
|
||||
// Encode writes the XML encoding of v to the stream.
|
||||
//
|
||||
// See the documentation for Marshal for details about the conversion
|
||||
// of Go values to XML.
|
||||
//
|
||||
// Encode calls Flush before returning.
|
||||
func (enc *Encoder) Encode(v interface{}) error {
|
||||
err := enc.p.marshalValue(reflect.ValueOf(v), nil, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return enc.p.Flush()
|
||||
}
|
||||
|
||||
// EncodeElement writes the XML encoding of v to the stream,
|
||||
// using start as the outermost tag in the encoding.
|
||||
//
|
||||
// See the documentation for Marshal for details about the conversion
|
||||
// of Go values to XML.
|
||||
//
|
||||
// EncodeElement calls Flush before returning.
|
||||
func (enc *Encoder) EncodeElement(v interface{}, start StartElement) error {
|
||||
err := enc.p.marshalValue(reflect.ValueOf(v), nil, &start)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return enc.p.Flush()
|
||||
}
|
||||
|
||||
var (
|
||||
endComment = []byte("-->")
|
||||
endProcInst = []byte("?>")
|
||||
endDirective = []byte(">")
|
||||
)
|
||||
|
||||
// EncodeToken writes the given XML token to the stream.
|
||||
// It returns an error if StartElement and EndElement tokens are not properly matched.
|
||||
//
|
||||
// EncodeToken does not call Flush, because usually it is part of a larger operation
|
||||
// such as Encode or EncodeElement (or a custom Marshaler's MarshalXML invoked
|
||||
// during those), and those will call Flush when finished.
|
||||
// Callers that create an Encoder and then invoke EncodeToken directly, without
|
||||
// using Encode or EncodeElement, need to call Flush when finished to ensure
|
||||
// that the XML is written to the underlying writer.
|
||||
//
|
||||
// EncodeToken allows writing a ProcInst with Target set to "xml" only as the first token
|
||||
// in the stream.
|
||||
func (enc *Encoder) EncodeToken(t Token) error {
|
||||
p := &enc.p
|
||||
switch t := t.(type) {
|
||||
case StartElement:
|
||||
if err := p.writeStart(&t); err != nil {
|
||||
return err
|
||||
}
|
||||
case EndElement:
|
||||
if err := p.writeEnd(t.Name); err != nil {
|
||||
return err
|
||||
}
|
||||
case CharData:
|
||||
EscapeText(p, t)
|
||||
case Comment:
|
||||
if bytes.Contains(t, endComment) {
|
||||
return fmt.Errorf("xml: EncodeToken of Comment containing --> marker")
|
||||
}
|
||||
p.WriteString("<!--")
|
||||
p.Write(t)
|
||||
p.WriteString("-->")
|
||||
return p.cachedWriteError()
|
||||
case ProcInst:
|
||||
// First token to be encoded which is also a ProcInst with target of xml
|
||||
// is the xml declaration. The only ProcInst where target of xml is allowed.
|
||||
if t.Target == "xml" && p.Buffered() != 0 {
|
||||
return fmt.Errorf("xml: EncodeToken of ProcInst xml target only valid for xml declaration, first token encoded")
|
||||
}
|
||||
if !isNameString(t.Target) {
|
||||
return fmt.Errorf("xml: EncodeToken of ProcInst with invalid Target")
|
||||
}
|
||||
if bytes.Contains(t.Inst, endProcInst) {
|
||||
return fmt.Errorf("xml: EncodeToken of ProcInst containing ?> marker")
|
||||
}
|
||||
p.WriteString("<?")
|
||||
p.WriteString(t.Target)
|
||||
if len(t.Inst) > 0 {
|
||||
p.WriteByte(' ')
|
||||
p.Write(t.Inst)
|
||||
}
|
||||
p.WriteString("?>")
|
||||
case Directive:
|
||||
if bytes.Contains(t, endDirective) {
|
||||
return fmt.Errorf("xml: EncodeToken of Directive containing > marker")
|
||||
}
|
||||
p.WriteString("<!")
|
||||
p.Write(t)
|
||||
p.WriteString(">")
|
||||
}
|
||||
return p.cachedWriteError()
|
||||
}
|
||||
|
||||
// Flush flushes any buffered XML to the underlying writer.
|
||||
// See the EncodeToken documentation for details about when it is necessary.
|
||||
func (enc *Encoder) Flush() error {
|
||||
return enc.p.Flush()
|
||||
}
|
||||
|
||||
type printer struct {
|
||||
*bufio.Writer
|
||||
encoder *Encoder
|
||||
seq int
|
||||
indent string
|
||||
prefix string
|
||||
depth int
|
||||
indentedIn bool
|
||||
putNewline bool
|
||||
attrNS map[string]string // map prefix -> name space
|
||||
attrPrefix map[string]string // map name space -> prefix
|
||||
prefixes []string
|
||||
tags []Name
|
||||
}
|
||||
|
||||
// createAttrPrefix finds the name space prefix attribute to use for the given name space,
|
||||
// defining a new prefix if necessary. It returns the prefix.
|
||||
func (p *printer) createAttrPrefix(url string) string {
|
||||
if prefix := p.attrPrefix[url]; prefix != "" {
|
||||
return prefix
|
||||
}
|
||||
|
||||
// The "http://www.w3.org/XML/1998/namespace" name space is predefined as "xml"
|
||||
// and must be referred to that way.
|
||||
// (The "http://www.w3.org/2000/xmlns/" name space is also predefined as "xmlns",
|
||||
// but users should not be trying to use that one directly - that's our job.)
|
||||
if url == xmlURL {
|
||||
return "xml"
|
||||
}
|
||||
|
||||
// Need to define a new name space.
|
||||
if p.attrPrefix == nil {
|
||||
p.attrPrefix = make(map[string]string)
|
||||
p.attrNS = make(map[string]string)
|
||||
}
|
||||
|
||||
// Pick a name. We try to use the final element of the path
|
||||
// but fall back to _.
|
||||
prefix := strings.TrimRight(url, "/")
|
||||
if i := strings.LastIndex(prefix, "/"); i >= 0 {
|
||||
prefix = prefix[i+1:]
|
||||
}
|
||||
if prefix == "" || !isName([]byte(prefix)) || strings.Contains(prefix, ":") {
|
||||
prefix = "_"
|
||||
}
|
||||
if strings.HasPrefix(prefix, "xml") {
|
||||
// xmlanything is reserved.
|
||||
prefix = "_" + prefix
|
||||
}
|
||||
if p.attrNS[prefix] != "" {
|
||||
// Name is taken. Find a better one.
|
||||
for p.seq++; ; p.seq++ {
|
||||
if id := prefix + "_" + strconv.Itoa(p.seq); p.attrNS[id] == "" {
|
||||
prefix = id
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
p.attrPrefix[url] = prefix
|
||||
p.attrNS[prefix] = url
|
||||
|
||||
p.WriteString(`xmlns:`)
|
||||
p.WriteString(prefix)
|
||||
p.WriteString(`="`)
|
||||
EscapeText(p, []byte(url))
|
||||
p.WriteString(`" `)
|
||||
|
||||
p.prefixes = append(p.prefixes, prefix)
|
||||
|
||||
return prefix
|
||||
}
|
||||
|
||||
// deleteAttrPrefix removes an attribute name space prefix.
|
||||
func (p *printer) deleteAttrPrefix(prefix string) {
|
||||
delete(p.attrPrefix, p.attrNS[prefix])
|
||||
delete(p.attrNS, prefix)
|
||||
}
|
||||
|
||||
func (p *printer) markPrefix() {
|
||||
p.prefixes = append(p.prefixes, "")
|
||||
}
|
||||
|
||||
func (p *printer) popPrefix() {
|
||||
for len(p.prefixes) > 0 {
|
||||
prefix := p.prefixes[len(p.prefixes)-1]
|
||||
p.prefixes = p.prefixes[:len(p.prefixes)-1]
|
||||
if prefix == "" {
|
||||
break
|
||||
}
|
||||
p.deleteAttrPrefix(prefix)
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
|
||||
marshalerAttrType = reflect.TypeOf((*MarshalerAttr)(nil)).Elem()
|
||||
textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
|
||||
)
|
||||
|
||||
// marshalValue writes one or more XML elements representing val.
|
||||
// If val was obtained from a struct field, finfo must have its details.
|
||||
func (p *printer) marshalValue(val reflect.Value, finfo *fieldInfo, startTemplate *StartElement) error {
|
||||
if startTemplate != nil && startTemplate.Name.Local == "" {
|
||||
return fmt.Errorf("xml: EncodeElement of StartElement with missing name")
|
||||
}
|
||||
|
||||
if !val.IsValid() {
|
||||
return nil
|
||||
}
|
||||
if finfo != nil && finfo.flags&fOmitEmpty != 0 && isEmptyValue(val) {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Drill into interfaces and pointers.
|
||||
// This can turn into an infinite loop given a cyclic chain,
|
||||
// but it matches the Go 1 behavior.
|
||||
for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
|
||||
if val.IsNil() {
|
||||
return nil
|
||||
}
|
||||
val = val.Elem()
|
||||
}
|
||||
|
||||
kind := val.Kind()
|
||||
typ := val.Type()
|
||||
|
||||
// Check for marshaler.
|
||||
if val.CanInterface() && typ.Implements(marshalerType) {
|
||||
return p.marshalInterface(val.Interface().(Marshaler), defaultStart(typ, finfo, startTemplate))
|
||||
}
|
||||
if val.CanAddr() {
|
||||
pv := val.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(marshalerType) {
|
||||
return p.marshalInterface(pv.Interface().(Marshaler), defaultStart(pv.Type(), finfo, startTemplate))
|
||||
}
|
||||
}
|
||||
|
||||
// Check for text marshaler.
|
||||
if val.CanInterface() && typ.Implements(textMarshalerType) {
|
||||
return p.marshalTextInterface(val.Interface().(encoding.TextMarshaler), defaultStart(typ, finfo, startTemplate))
|
||||
}
|
||||
if val.CanAddr() {
|
||||
pv := val.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
|
||||
return p.marshalTextInterface(pv.Interface().(encoding.TextMarshaler), defaultStart(pv.Type(), finfo, startTemplate))
|
||||
}
|
||||
}
|
||||
|
||||
// Slices and arrays iterate over the elements. They do not have an enclosing tag.
|
||||
if (kind == reflect.Slice || kind == reflect.Array) && typ.Elem().Kind() != reflect.Uint8 {
|
||||
for i, n := 0, val.Len(); i < n; i++ {
|
||||
if err := p.marshalValue(val.Index(i), finfo, startTemplate); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
tinfo, err := getTypeInfo(typ)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Create start element.
|
||||
// Precedence for the XML element name is:
|
||||
// 0. startTemplate
|
||||
// 1. XMLName field in underlying struct;
|
||||
// 2. field name/tag in the struct field; and
|
||||
// 3. type name
|
||||
var start StartElement
|
||||
|
||||
if startTemplate != nil {
|
||||
start.Name = startTemplate.Name
|
||||
start.Attr = append(start.Attr, startTemplate.Attr...)
|
||||
} else if tinfo.xmlname != nil {
|
||||
xmlname := tinfo.xmlname
|
||||
if xmlname.name != "" {
|
||||
start.Name.Space, start.Name.Local = xmlname.xmlns, xmlname.name
|
||||
} else if v, ok := xmlname.value(val).Interface().(Name); ok && v.Local != "" {
|
||||
start.Name = v
|
||||
}
|
||||
}
|
||||
if start.Name.Local == "" && finfo != nil {
|
||||
start.Name.Space, start.Name.Local = finfo.xmlns, finfo.name
|
||||
}
|
||||
if start.Name.Local == "" {
|
||||
name := typ.Name()
|
||||
if name == "" {
|
||||
return &UnsupportedTypeError{typ}
|
||||
}
|
||||
start.Name.Local = name
|
||||
}
|
||||
|
||||
// Add type attribute if necessary
|
||||
if finfo != nil && finfo.flags&fTypeAttr != 0 {
|
||||
start.Attr = append(start.Attr, Attr{xmlSchemaInstance, typeToString(typ)})
|
||||
}
|
||||
|
||||
// Attributes
|
||||
for i := range tinfo.fields {
|
||||
finfo := &tinfo.fields[i]
|
||||
if finfo.flags&fAttr == 0 {
|
||||
continue
|
||||
}
|
||||
fv := finfo.value(val)
|
||||
name := Name{Space: finfo.xmlns, Local: finfo.name}
|
||||
|
||||
if finfo.flags&fOmitEmpty != 0 && isEmptyValue(fv) {
|
||||
continue
|
||||
}
|
||||
|
||||
if fv.Kind() == reflect.Interface && fv.IsNil() {
|
||||
continue
|
||||
}
|
||||
|
||||
if fv.CanInterface() && fv.Type().Implements(marshalerAttrType) {
|
||||
attr, err := fv.Interface().(MarshalerAttr).MarshalXMLAttr(name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if attr.Name.Local != "" {
|
||||
start.Attr = append(start.Attr, attr)
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if fv.CanAddr() {
|
||||
pv := fv.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(marshalerAttrType) {
|
||||
attr, err := pv.Interface().(MarshalerAttr).MarshalXMLAttr(name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if attr.Name.Local != "" {
|
||||
start.Attr = append(start.Attr, attr)
|
||||
}
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
if fv.CanInterface() && fv.Type().Implements(textMarshalerType) {
|
||||
text, err := fv.Interface().(encoding.TextMarshaler).MarshalText()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
start.Attr = append(start.Attr, Attr{name, string(text)})
|
||||
continue
|
||||
}
|
||||
|
||||
if fv.CanAddr() {
|
||||
pv := fv.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
|
||||
text, err := pv.Interface().(encoding.TextMarshaler).MarshalText()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
start.Attr = append(start.Attr, Attr{name, string(text)})
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
// Dereference or skip nil pointer, interface values.
|
||||
switch fv.Kind() {
|
||||
case reflect.Ptr, reflect.Interface:
|
||||
if fv.IsNil() {
|
||||
continue
|
||||
}
|
||||
fv = fv.Elem()
|
||||
}
|
||||
|
||||
s, b, err := p.marshalSimple(fv.Type(), fv)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if b != nil {
|
||||
s = string(b)
|
||||
}
|
||||
start.Attr = append(start.Attr, Attr{name, s})
|
||||
}
|
||||
|
||||
if err := p.writeStart(&start); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if val.Kind() == reflect.Struct {
|
||||
err = p.marshalStruct(tinfo, val)
|
||||
} else {
|
||||
s, b, err1 := p.marshalSimple(typ, val)
|
||||
if err1 != nil {
|
||||
err = err1
|
||||
} else if b != nil {
|
||||
EscapeText(p, b)
|
||||
} else {
|
||||
p.EscapeString(s)
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := p.writeEnd(start.Name); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return p.cachedWriteError()
|
||||
}
|
||||
|
||||
// defaultStart returns the default start element to use,
|
||||
// given the reflect type, field info, and start template.
|
||||
func defaultStart(typ reflect.Type, finfo *fieldInfo, startTemplate *StartElement) StartElement {
|
||||
var start StartElement
|
||||
// Precedence for the XML element name is as above,
|
||||
// except that we do not look inside structs for the first field.
|
||||
if startTemplate != nil {
|
||||
start.Name = startTemplate.Name
|
||||
start.Attr = append(start.Attr, startTemplate.Attr...)
|
||||
} else if finfo != nil && finfo.name != "" {
|
||||
start.Name.Local = finfo.name
|
||||
start.Name.Space = finfo.xmlns
|
||||
} else if typ.Name() != "" {
|
||||
start.Name.Local = typ.Name()
|
||||
} else {
|
||||
// Must be a pointer to a named type,
|
||||
// since it has the Marshaler methods.
|
||||
start.Name.Local = typ.Elem().Name()
|
||||
}
|
||||
|
||||
// Add type attribute if necessary
|
||||
if finfo != nil && finfo.flags&fTypeAttr != 0 {
|
||||
start.Attr = append(start.Attr, Attr{xmlSchemaInstance, typeToString(typ)})
|
||||
}
|
||||
|
||||
return start
|
||||
}
|
||||
|
||||
// marshalInterface marshals a Marshaler interface value.
|
||||
func (p *printer) marshalInterface(val Marshaler, start StartElement) error {
|
||||
// Push a marker onto the tag stack so that MarshalXML
|
||||
// cannot close the XML tags that it did not open.
|
||||
p.tags = append(p.tags, Name{})
|
||||
n := len(p.tags)
|
||||
|
||||
err := val.MarshalXML(p.encoder, start)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Make sure MarshalXML closed all its tags. p.tags[n-1] is the mark.
|
||||
if len(p.tags) > n {
|
||||
return fmt.Errorf("xml: %s.MarshalXML wrote invalid XML: <%s> not closed", receiverType(val), p.tags[len(p.tags)-1].Local)
|
||||
}
|
||||
p.tags = p.tags[:n-1]
|
||||
return nil
|
||||
}
|
||||
|
||||
// marshalTextInterface marshals a TextMarshaler interface value.
|
||||
func (p *printer) marshalTextInterface(val encoding.TextMarshaler, start StartElement) error {
|
||||
if err := p.writeStart(&start); err != nil {
|
||||
return err
|
||||
}
|
||||
text, err := val.MarshalText()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
EscapeText(p, text)
|
||||
return p.writeEnd(start.Name)
|
||||
}
|
||||
|
||||
// writeStart writes the given start element.
|
||||
func (p *printer) writeStart(start *StartElement) error {
|
||||
if start.Name.Local == "" {
|
||||
return fmt.Errorf("xml: start tag with no name")
|
||||
}
|
||||
|
||||
p.tags = append(p.tags, start.Name)
|
||||
p.markPrefix()
|
||||
|
||||
p.writeIndent(1)
|
||||
p.WriteByte('<')
|
||||
p.WriteString(start.Name.Local)
|
||||
|
||||
if start.Name.Space != "" {
|
||||
p.WriteString(` xmlns="`)
|
||||
p.EscapeString(start.Name.Space)
|
||||
p.WriteByte('"')
|
||||
}
|
||||
|
||||
// Attributes
|
||||
for _, attr := range start.Attr {
|
||||
name := attr.Name
|
||||
if name.Local == "" {
|
||||
continue
|
||||
}
|
||||
p.WriteByte(' ')
|
||||
if name.Space != "" {
|
||||
p.WriteString(p.createAttrPrefix(name.Space))
|
||||
p.WriteByte(':')
|
||||
}
|
||||
p.WriteString(name.Local)
|
||||
p.WriteString(`="`)
|
||||
p.EscapeString(attr.Value)
|
||||
p.WriteByte('"')
|
||||
}
|
||||
p.WriteByte('>')
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *printer) writeEnd(name Name) error {
|
||||
if name.Local == "" {
|
||||
return fmt.Errorf("xml: end tag with no name")
|
||||
}
|
||||
if len(p.tags) == 0 || p.tags[len(p.tags)-1].Local == "" {
|
||||
return fmt.Errorf("xml: end tag </%s> without start tag", name.Local)
|
||||
}
|
||||
if top := p.tags[len(p.tags)-1]; top != name {
|
||||
if top.Local != name.Local {
|
||||
return fmt.Errorf("xml: end tag </%s> does not match start tag <%s>", name.Local, top.Local)
|
||||
}
|
||||
return fmt.Errorf("xml: end tag </%s> in namespace %s does not match start tag <%s> in namespace %s", name.Local, name.Space, top.Local, top.Space)
|
||||
}
|
||||
p.tags = p.tags[:len(p.tags)-1]
|
||||
|
||||
p.writeIndent(-1)
|
||||
p.WriteByte('<')
|
||||
p.WriteByte('/')
|
||||
p.WriteString(name.Local)
|
||||
p.WriteByte('>')
|
||||
p.popPrefix()
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
|
||||
switch val.Kind() {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
return strconv.FormatInt(val.Int(), 10), nil, nil
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
||||
return strconv.FormatUint(val.Uint(), 10), nil, nil
|
||||
case reflect.Float32, reflect.Float64:
|
||||
return strconv.FormatFloat(val.Float(), 'g', -1, val.Type().Bits()), nil, nil
|
||||
case reflect.String:
|
||||
return val.String(), nil, nil
|
||||
case reflect.Bool:
|
||||
return strconv.FormatBool(val.Bool()), nil, nil
|
||||
case reflect.Array:
|
||||
if typ.Elem().Kind() != reflect.Uint8 {
|
||||
break
|
||||
}
|
||||
// [...]byte
|
||||
var bytes []byte
|
||||
if val.CanAddr() {
|
||||
bytes = val.Slice(0, val.Len()).Bytes()
|
||||
} else {
|
||||
bytes = make([]byte, val.Len())
|
||||
reflect.Copy(reflect.ValueOf(bytes), val)
|
||||
}
|
||||
return "", bytes, nil
|
||||
case reflect.Slice:
|
||||
if typ.Elem().Kind() != reflect.Uint8 {
|
||||
break
|
||||
}
|
||||
// []byte
|
||||
return "", val.Bytes(), nil
|
||||
}
|
||||
return "", nil, &UnsupportedTypeError{typ}
|
||||
}
|
||||
|
||||
var ddBytes = []byte("--")
|
||||
|
||||
func (p *printer) marshalStruct(tinfo *typeInfo, val reflect.Value) error {
|
||||
s := parentStack{p: p}
|
||||
for i := range tinfo.fields {
|
||||
finfo := &tinfo.fields[i]
|
||||
if finfo.flags&fAttr != 0 {
|
||||
continue
|
||||
}
|
||||
vf := finfo.value(val)
|
||||
|
||||
// Dereference or skip nil pointer, interface values.
|
||||
switch vf.Kind() {
|
||||
case reflect.Ptr, reflect.Interface:
|
||||
if !vf.IsNil() {
|
||||
vf = vf.Elem()
|
||||
}
|
||||
}
|
||||
|
||||
switch finfo.flags & fMode {
|
||||
case fCharData:
|
||||
if vf.CanInterface() && vf.Type().Implements(textMarshalerType) {
|
||||
data, err := vf.Interface().(encoding.TextMarshaler).MarshalText()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
Escape(p, data)
|
||||
continue
|
||||
}
|
||||
if vf.CanAddr() {
|
||||
pv := vf.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
|
||||
data, err := pv.Interface().(encoding.TextMarshaler).MarshalText()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
Escape(p, data)
|
||||
continue
|
||||
}
|
||||
}
|
||||
var scratch [64]byte
|
||||
switch vf.Kind() {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
Escape(p, strconv.AppendInt(scratch[:0], vf.Int(), 10))
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
||||
Escape(p, strconv.AppendUint(scratch[:0], vf.Uint(), 10))
|
||||
case reflect.Float32, reflect.Float64:
|
||||
Escape(p, strconv.AppendFloat(scratch[:0], vf.Float(), 'g', -1, vf.Type().Bits()))
|
||||
case reflect.Bool:
|
||||
Escape(p, strconv.AppendBool(scratch[:0], vf.Bool()))
|
||||
case reflect.String:
|
||||
if err := EscapeText(p, []byte(vf.String())); err != nil {
|
||||
return err
|
||||
}
|
||||
case reflect.Slice:
|
||||
if elem, ok := vf.Interface().([]byte); ok {
|
||||
if err := EscapeText(p, elem); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
continue
|
||||
|
||||
case fComment:
|
||||
k := vf.Kind()
|
||||
if !(k == reflect.String || k == reflect.Slice && vf.Type().Elem().Kind() == reflect.Uint8) {
|
||||
return fmt.Errorf("xml: bad type for comment field of %s", val.Type())
|
||||
}
|
||||
if vf.Len() == 0 {
|
||||
continue
|
||||
}
|
||||
p.writeIndent(0)
|
||||
p.WriteString("<!--")
|
||||
dashDash := false
|
||||
dashLast := false
|
||||
switch k {
|
||||
case reflect.String:
|
||||
s := vf.String()
|
||||
dashDash = strings.Index(s, "--") >= 0
|
||||
dashLast = s[len(s)-1] == '-'
|
||||
if !dashDash {
|
||||
p.WriteString(s)
|
||||
}
|
||||
case reflect.Slice:
|
||||
b := vf.Bytes()
|
||||
dashDash = bytes.Index(b, ddBytes) >= 0
|
||||
dashLast = b[len(b)-1] == '-'
|
||||
if !dashDash {
|
||||
p.Write(b)
|
||||
}
|
||||
default:
|
||||
panic("can't happen")
|
||||
}
|
||||
if dashDash {
|
||||
return fmt.Errorf(`xml: comments must not contain "--"`)
|
||||
}
|
||||
if dashLast {
|
||||
// "--->" is invalid grammar. Make it "- -->"
|
||||
p.WriteByte(' ')
|
||||
}
|
||||
p.WriteString("-->")
|
||||
continue
|
||||
|
||||
case fInnerXml:
|
||||
iface := vf.Interface()
|
||||
switch raw := iface.(type) {
|
||||
case []byte:
|
||||
p.Write(raw)
|
||||
continue
|
||||
case string:
|
||||
p.WriteString(raw)
|
||||
continue
|
||||
}
|
||||
|
||||
case fElement, fElement | fAny:
|
||||
if err := s.trim(finfo.parents); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(finfo.parents) > len(s.stack) {
|
||||
if vf.Kind() != reflect.Ptr && vf.Kind() != reflect.Interface || !vf.IsNil() {
|
||||
if err := s.push(finfo.parents[len(s.stack):]); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if err := p.marshalValue(vf, finfo, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
s.trim(nil)
|
||||
return p.cachedWriteError()
|
||||
}
|
||||
|
||||
// return the bufio Writer's cached write error
|
||||
func (p *printer) cachedWriteError() error {
|
||||
_, err := p.Write(nil)
|
||||
return err
|
||||
}
|
||||
|
||||
func (p *printer) writeIndent(depthDelta int) {
|
||||
if len(p.prefix) == 0 && len(p.indent) == 0 {
|
||||
return
|
||||
}
|
||||
if depthDelta < 0 {
|
||||
p.depth--
|
||||
if p.indentedIn {
|
||||
p.indentedIn = false
|
||||
return
|
||||
}
|
||||
p.indentedIn = false
|
||||
}
|
||||
if p.putNewline {
|
||||
p.WriteByte('\n')
|
||||
} else {
|
||||
p.putNewline = true
|
||||
}
|
||||
if len(p.prefix) > 0 {
|
||||
p.WriteString(p.prefix)
|
||||
}
|
||||
if len(p.indent) > 0 {
|
||||
for i := 0; i < p.depth; i++ {
|
||||
p.WriteString(p.indent)
|
||||
}
|
||||
}
|
||||
if depthDelta > 0 {
|
||||
p.depth++
|
||||
p.indentedIn = true
|
||||
}
|
||||
}
|
||||
|
||||
type parentStack struct {
|
||||
p *printer
|
||||
stack []string
|
||||
}
|
||||
|
||||
// trim updates the XML context to match the longest common prefix of the stack
|
||||
// and the given parents. A closing tag will be written for every parent
|
||||
// popped. Passing a zero slice or nil will close all the elements.
|
||||
func (s *parentStack) trim(parents []string) error {
|
||||
split := 0
|
||||
for ; split < len(parents) && split < len(s.stack); split++ {
|
||||
if parents[split] != s.stack[split] {
|
||||
break
|
||||
}
|
||||
}
|
||||
for i := len(s.stack) - 1; i >= split; i-- {
|
||||
if err := s.p.writeEnd(Name{Local: s.stack[i]}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
s.stack = parents[:split]
|
||||
return nil
|
||||
}
|
||||
|
||||
// push adds parent elements to the stack and writes open tags.
|
||||
func (s *parentStack) push(parents []string) error {
|
||||
for i := 0; i < len(parents); i++ {
|
||||
if err := s.p.writeStart(&StartElement{Name: Name{Local: parents[i]}}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
s.stack = append(s.stack, parents...)
|
||||
return nil
|
||||
}
|
||||
|
||||
// A MarshalXMLError is returned when Marshal encounters a type
|
||||
// that cannot be converted into XML.
|
||||
type UnsupportedTypeError struct {
|
||||
Type reflect.Type
|
||||
}
|
||||
|
||||
func (e *UnsupportedTypeError) Error() string {
|
||||
return "xml: unsupported type: " + e.Type.String()
|
||||
}
|
||||
|
||||
func isEmptyValue(v reflect.Value) bool {
|
||||
switch v.Kind() {
|
||||
case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
|
||||
return v.Len() == 0
|
||||
case reflect.Bool:
|
||||
return !v.Bool()
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
return v.Int() == 0
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
||||
return v.Uint() == 0
|
||||
case reflect.Float32, reflect.Float64:
|
||||
return v.Float() == 0
|
||||
case reflect.Interface, reflect.Ptr:
|
||||
return v.IsNil()
|
||||
}
|
||||
return false
|
||||
}
|
||||
1266
vendor/github.com/vmware/govmomi/vim25/xml/marshal_test.go
generated
vendored
Normal file
1266
vendor/github.com/vmware/govmomi/vim25/xml/marshal_test.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
781
vendor/github.com/vmware/govmomi/vim25/xml/read.go
generated
vendored
Normal file
781
vendor/github.com/vmware/govmomi/vim25/xml/read.go
generated
vendored
Normal file
@@ -0,0 +1,781 @@
|
||||
// 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"
|
||||
"encoding"
|
||||
"errors"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// BUG(rsc): Mapping between XML elements and data structures is inherently flawed:
|
||||
// an XML element is an order-dependent collection of anonymous
|
||||
// values, while a data structure is an order-independent collection
|
||||
// of named values.
|
||||
// See package json for a textual representation more suitable
|
||||
// to data structures.
|
||||
|
||||
// Unmarshal parses the XML-encoded data and stores the result in
|
||||
// the value pointed to by v, which must be an arbitrary struct,
|
||||
// slice, or string. Well-formed data that does not fit into v is
|
||||
// discarded.
|
||||
//
|
||||
// Because Unmarshal uses the reflect package, it can only assign
|
||||
// to exported (upper case) fields. Unmarshal uses a case-sensitive
|
||||
// comparison to match XML element names to tag values and struct
|
||||
// field names.
|
||||
//
|
||||
// Unmarshal maps an XML element to a struct using the following rules.
|
||||
// In the rules, the tag of a field refers to the value associated with the
|
||||
// key 'xml' in the struct field's tag (see the example above).
|
||||
//
|
||||
// * If the struct has a field of type []byte or string with tag
|
||||
// ",innerxml", Unmarshal accumulates the raw XML nested inside the
|
||||
// element in that field. The rest of the rules still apply.
|
||||
//
|
||||
// * If the struct has a field named XMLName of type xml.Name,
|
||||
// Unmarshal records the element name in that field.
|
||||
//
|
||||
// * If the XMLName field has an associated tag of the form
|
||||
// "name" or "namespace-URL name", the XML element must have
|
||||
// the given name (and, optionally, name space) or else Unmarshal
|
||||
// returns an error.
|
||||
//
|
||||
// * If the XML element has an attribute whose name matches a
|
||||
// struct field name with an associated tag containing ",attr" or
|
||||
// the explicit name in a struct field tag of the form "name,attr",
|
||||
// Unmarshal records the attribute value in that field.
|
||||
//
|
||||
// * If the XML element contains character data, that data is
|
||||
// accumulated in the first struct field that has tag ",chardata".
|
||||
// The struct field may have type []byte or string.
|
||||
// If there is no such field, the character data is discarded.
|
||||
//
|
||||
// * If the XML element contains comments, they are accumulated in
|
||||
// the first struct field that has tag ",comment". The struct
|
||||
// field may have type []byte or string. If there is no such
|
||||
// field, the comments are discarded.
|
||||
//
|
||||
// * If the XML element contains a sub-element whose name matches
|
||||
// the prefix of a tag formatted as "a" or "a>b>c", unmarshal
|
||||
// will descend into the XML structure looking for elements with the
|
||||
// given names, and will map the innermost elements to that struct
|
||||
// field. A tag starting with ">" is equivalent to one starting
|
||||
// with the field name followed by ">".
|
||||
//
|
||||
// * If the XML element contains a sub-element whose name matches
|
||||
// a struct field's XMLName tag and the struct field has no
|
||||
// explicit name tag as per the previous rule, unmarshal maps
|
||||
// the sub-element to that struct field.
|
||||
//
|
||||
// * If the XML element contains a sub-element whose name matches a
|
||||
// field without any mode flags (",attr", ",chardata", etc), Unmarshal
|
||||
// maps the sub-element to that struct field.
|
||||
//
|
||||
// * If the XML element contains a sub-element that hasn't matched any
|
||||
// of the above rules and the struct has a field with tag ",any",
|
||||
// unmarshal maps the sub-element to that struct field.
|
||||
//
|
||||
// * An anonymous struct field is handled as if the fields of its
|
||||
// value were part of the outer struct.
|
||||
//
|
||||
// * A struct field with tag "-" is never unmarshalled into.
|
||||
//
|
||||
// Unmarshal maps an XML element to a string or []byte by saving the
|
||||
// concatenation of that element's character data in the string or
|
||||
// []byte. The saved []byte is never nil.
|
||||
//
|
||||
// Unmarshal maps an attribute value to a string or []byte by saving
|
||||
// the value in the string or slice.
|
||||
//
|
||||
// Unmarshal maps an XML element to a slice by extending the length of
|
||||
// the slice and mapping the element to the newly created value.
|
||||
//
|
||||
// Unmarshal maps an XML element or attribute value to a bool by
|
||||
// setting it to the boolean value represented by the string.
|
||||
//
|
||||
// Unmarshal maps an XML element or attribute value to an integer or
|
||||
// floating-point field by setting the field to the result of
|
||||
// interpreting the string value in decimal. There is no check for
|
||||
// overflow.
|
||||
//
|
||||
// Unmarshal maps an XML element to an xml.Name by recording the
|
||||
// element name.
|
||||
//
|
||||
// Unmarshal maps an XML element to a pointer by setting the pointer
|
||||
// to a freshly allocated value and then mapping the element to that value.
|
||||
//
|
||||
func Unmarshal(data []byte, v interface{}) error {
|
||||
return NewDecoder(bytes.NewReader(data)).Decode(v)
|
||||
}
|
||||
|
||||
// Decode works like xml.Unmarshal, except it reads the decoder
|
||||
// stream to find the start element.
|
||||
func (d *Decoder) Decode(v interface{}) error {
|
||||
return d.DecodeElement(v, nil)
|
||||
}
|
||||
|
||||
// DecodeElement works like xml.Unmarshal except that it takes
|
||||
// a pointer to the start XML element to decode into v.
|
||||
// It is useful when a client reads some raw XML tokens itself
|
||||
// but also wants to defer to Unmarshal for some elements.
|
||||
func (d *Decoder) DecodeElement(v interface{}, start *StartElement) error {
|
||||
val := reflect.ValueOf(v)
|
||||
if val.Kind() != reflect.Ptr {
|
||||
return errors.New("non-pointer passed to Unmarshal")
|
||||
}
|
||||
return d.unmarshal(val.Elem(), start)
|
||||
}
|
||||
|
||||
// An UnmarshalError represents an error in the unmarshalling process.
|
||||
type UnmarshalError string
|
||||
|
||||
func (e UnmarshalError) Error() string { return string(e) }
|
||||
|
||||
// Unmarshaler is the interface implemented by objects that can unmarshal
|
||||
// an XML element description of themselves.
|
||||
//
|
||||
// UnmarshalXML decodes a single XML element
|
||||
// beginning with the given start element.
|
||||
// If it returns an error, the outer call to Unmarshal stops and
|
||||
// returns that error.
|
||||
// UnmarshalXML must consume exactly one XML element.
|
||||
// One common implementation strategy is to unmarshal into
|
||||
// a separate value with a layout matching the expected XML
|
||||
// using d.DecodeElement, and then to copy the data from
|
||||
// that value into the receiver.
|
||||
// Another common strategy is to use d.Token to process the
|
||||
// XML object one token at a time.
|
||||
// UnmarshalXML may not use d.RawToken.
|
||||
type Unmarshaler interface {
|
||||
UnmarshalXML(d *Decoder, start StartElement) error
|
||||
}
|
||||
|
||||
// UnmarshalerAttr is the interface implemented by objects that can unmarshal
|
||||
// an XML attribute description of themselves.
|
||||
//
|
||||
// UnmarshalXMLAttr decodes a single XML attribute.
|
||||
// If it returns an error, the outer call to Unmarshal stops and
|
||||
// returns that error.
|
||||
// UnmarshalXMLAttr is used only for struct fields with the
|
||||
// "attr" option in the field tag.
|
||||
type UnmarshalerAttr interface {
|
||||
UnmarshalXMLAttr(attr Attr) error
|
||||
}
|
||||
|
||||
// receiverType returns the receiver type to use in an expression like "%s.MethodName".
|
||||
func receiverType(val interface{}) string {
|
||||
t := reflect.TypeOf(val)
|
||||
if t.Name() != "" {
|
||||
return t.String()
|
||||
}
|
||||
return "(" + t.String() + ")"
|
||||
}
|
||||
|
||||
// unmarshalInterface unmarshals a single XML element into val.
|
||||
// start is the opening tag of the element.
|
||||
func (p *Decoder) unmarshalInterface(val Unmarshaler, start *StartElement) error {
|
||||
// Record that decoder must stop at end tag corresponding to start.
|
||||
p.pushEOF()
|
||||
|
||||
p.unmarshalDepth++
|
||||
err := val.UnmarshalXML(p, *start)
|
||||
p.unmarshalDepth--
|
||||
if err != nil {
|
||||
p.popEOF()
|
||||
return err
|
||||
}
|
||||
|
||||
if !p.popEOF() {
|
||||
return fmt.Errorf("xml: %s.UnmarshalXML did not consume entire <%s> element", receiverType(val), start.Name.Local)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// unmarshalTextInterface unmarshals a single XML element into val.
|
||||
// The chardata contained in the element (but not its children)
|
||||
// is passed to the text unmarshaler.
|
||||
func (p *Decoder) unmarshalTextInterface(val encoding.TextUnmarshaler, start *StartElement) error {
|
||||
var buf []byte
|
||||
depth := 1
|
||||
for depth > 0 {
|
||||
t, err := p.Token()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
switch t := t.(type) {
|
||||
case CharData:
|
||||
if depth == 1 {
|
||||
buf = append(buf, t...)
|
||||
}
|
||||
case StartElement:
|
||||
depth++
|
||||
case EndElement:
|
||||
depth--
|
||||
}
|
||||
}
|
||||
return val.UnmarshalText(buf)
|
||||
}
|
||||
|
||||
// unmarshalAttr unmarshals a single XML attribute into val.
|
||||
func (p *Decoder) unmarshalAttr(val reflect.Value, attr Attr) error {
|
||||
if val.Kind() == reflect.Ptr {
|
||||
if val.IsNil() {
|
||||
val.Set(reflect.New(val.Type().Elem()))
|
||||
}
|
||||
val = val.Elem()
|
||||
}
|
||||
|
||||
if val.CanInterface() && val.Type().Implements(unmarshalerAttrType) {
|
||||
// This is an unmarshaler with a non-pointer receiver,
|
||||
// so it's likely to be incorrect, but we do what we're told.
|
||||
return val.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
|
||||
}
|
||||
if val.CanAddr() {
|
||||
pv := val.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(unmarshalerAttrType) {
|
||||
return pv.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
|
||||
}
|
||||
}
|
||||
|
||||
// Not an UnmarshalerAttr; try encoding.TextUnmarshaler.
|
||||
if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
|
||||
// This is an unmarshaler with a non-pointer receiver,
|
||||
// so it's likely to be incorrect, but we do what we're told.
|
||||
return val.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
|
||||
}
|
||||
if val.CanAddr() {
|
||||
pv := val.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
|
||||
return pv.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
|
||||
}
|
||||
}
|
||||
|
||||
copyValue(val, []byte(attr.Value))
|
||||
return nil
|
||||
}
|
||||
|
||||
var (
|
||||
unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
|
||||
unmarshalerAttrType = reflect.TypeOf((*UnmarshalerAttr)(nil)).Elem()
|
||||
textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
|
||||
)
|
||||
|
||||
// Find reflect.Type for an element's type attribute.
|
||||
func (p *Decoder) typeForElement(val reflect.Value, start *StartElement) reflect.Type {
|
||||
t := ""
|
||||
for i, a := range start.Attr {
|
||||
if a.Name == xmlSchemaInstance || a.Name == xsiType {
|
||||
t = a.Value
|
||||
// HACK: ensure xsi:type is last in the list to avoid using that value for
|
||||
// a "type" attribute, such as ManagedObjectReference.Type for example.
|
||||
// Note that xsi:type is already the last attribute in VC/ESX responses.
|
||||
// This is only an issue with govmomi simulator generated responses.
|
||||
// Proper fix will require finding a few needles in this xml package haystack.
|
||||
// Note: govmomi uses xmlSchemaInstance, other clients (e.g. rbvmomi) use xsiType.
|
||||
// They are the same thing to XML parsers, but not to this hack here.
|
||||
x := len(start.Attr) - 1
|
||||
if i != x {
|
||||
start.Attr[i] = start.Attr[x]
|
||||
start.Attr[x] = a
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if t == "" {
|
||||
// No type attribute; fall back to looking up type by interface name.
|
||||
t = val.Type().Name()
|
||||
}
|
||||
|
||||
// Maybe the type is a basic xsd:* type.
|
||||
typ := stringToType(t)
|
||||
if typ != nil {
|
||||
return typ
|
||||
}
|
||||
|
||||
// Maybe the type is a custom type.
|
||||
if p.TypeFunc != nil {
|
||||
if typ, ok := p.TypeFunc(t); ok {
|
||||
return typ
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Unmarshal a single XML element into val.
|
||||
func (p *Decoder) unmarshal(val reflect.Value, start *StartElement) error {
|
||||
// Find start element if we need it.
|
||||
if start == nil {
|
||||
for {
|
||||
tok, err := p.Token()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if t, ok := tok.(StartElement); ok {
|
||||
start = &t
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Try to figure out type for empty interface values.
|
||||
if val.Kind() == reflect.Interface && val.IsNil() {
|
||||
typ := p.typeForElement(val, start)
|
||||
if typ != nil {
|
||||
pval := reflect.New(typ).Elem()
|
||||
err := p.unmarshal(pval, start)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for i := 0; i < 2; i++ {
|
||||
if typ.Implements(val.Type()) {
|
||||
val.Set(pval)
|
||||
return nil
|
||||
}
|
||||
|
||||
typ = reflect.PtrTo(typ)
|
||||
pval = pval.Addr()
|
||||
}
|
||||
|
||||
val.Set(pval)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// Load value from interface, but only if the result will be
|
||||
// usefully addressable.
|
||||
if val.Kind() == reflect.Interface && !val.IsNil() {
|
||||
e := val.Elem()
|
||||
if e.Kind() == reflect.Ptr && !e.IsNil() {
|
||||
val = e
|
||||
}
|
||||
}
|
||||
|
||||
if val.Kind() == reflect.Ptr {
|
||||
if val.IsNil() {
|
||||
val.Set(reflect.New(val.Type().Elem()))
|
||||
}
|
||||
val = val.Elem()
|
||||
}
|
||||
|
||||
if val.CanInterface() && val.Type().Implements(unmarshalerType) {
|
||||
// This is an unmarshaler with a non-pointer receiver,
|
||||
// so it's likely to be incorrect, but we do what we're told.
|
||||
return p.unmarshalInterface(val.Interface().(Unmarshaler), start)
|
||||
}
|
||||
|
||||
if val.CanAddr() {
|
||||
pv := val.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(unmarshalerType) {
|
||||
return p.unmarshalInterface(pv.Interface().(Unmarshaler), start)
|
||||
}
|
||||
}
|
||||
|
||||
if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
|
||||
return p.unmarshalTextInterface(val.Interface().(encoding.TextUnmarshaler), start)
|
||||
}
|
||||
|
||||
if val.CanAddr() {
|
||||
pv := val.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
|
||||
return p.unmarshalTextInterface(pv.Interface().(encoding.TextUnmarshaler), start)
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
data []byte
|
||||
saveData reflect.Value
|
||||
comment []byte
|
||||
saveComment reflect.Value
|
||||
saveXML reflect.Value
|
||||
saveXMLIndex int
|
||||
saveXMLData []byte
|
||||
saveAny reflect.Value
|
||||
sv reflect.Value
|
||||
tinfo *typeInfo
|
||||
err error
|
||||
)
|
||||
|
||||
switch v := val; v.Kind() {
|
||||
default:
|
||||
return errors.New("unknown type " + v.Type().String())
|
||||
|
||||
case reflect.Interface:
|
||||
// TODO: For now, simply ignore the field. In the near
|
||||
// future we may choose to unmarshal the start
|
||||
// element on it, if not nil.
|
||||
return p.Skip()
|
||||
|
||||
case reflect.Slice:
|
||||
typ := v.Type()
|
||||
if typ.Elem().Kind() == reflect.Uint8 {
|
||||
// []byte
|
||||
saveData = v
|
||||
break
|
||||
}
|
||||
|
||||
// Slice of element values.
|
||||
// Grow slice.
|
||||
n := v.Len()
|
||||
if n >= v.Cap() {
|
||||
ncap := 2 * n
|
||||
if ncap < 4 {
|
||||
ncap = 4
|
||||
}
|
||||
new := reflect.MakeSlice(typ, n, ncap)
|
||||
reflect.Copy(new, v)
|
||||
v.Set(new)
|
||||
}
|
||||
v.SetLen(n + 1)
|
||||
|
||||
// Recur to read element into slice.
|
||||
if err := p.unmarshal(v.Index(n), start); err != nil {
|
||||
v.SetLen(n)
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
|
||||
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.String:
|
||||
saveData = v
|
||||
|
||||
case reflect.Struct:
|
||||
typ := v.Type()
|
||||
if typ == nameType {
|
||||
v.Set(reflect.ValueOf(start.Name))
|
||||
break
|
||||
}
|
||||
|
||||
sv = v
|
||||
tinfo, err = getTypeInfo(typ)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Validate and assign element name.
|
||||
if tinfo.xmlname != nil {
|
||||
finfo := tinfo.xmlname
|
||||
if finfo.name != "" && finfo.name != start.Name.Local {
|
||||
return UnmarshalError("expected element type <" + finfo.name + "> but have <" + start.Name.Local + ">")
|
||||
}
|
||||
if finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
|
||||
e := "expected element <" + finfo.name + "> in name space " + finfo.xmlns + " but have "
|
||||
if start.Name.Space == "" {
|
||||
e += "no name space"
|
||||
} else {
|
||||
e += start.Name.Space
|
||||
}
|
||||
return UnmarshalError(e)
|
||||
}
|
||||
fv := finfo.value(sv)
|
||||
if _, ok := fv.Interface().(Name); ok {
|
||||
fv.Set(reflect.ValueOf(start.Name))
|
||||
}
|
||||
}
|
||||
|
||||
// Assign attributes.
|
||||
// Also, determine whether we need to save character data or comments.
|
||||
for i := range tinfo.fields {
|
||||
finfo := &tinfo.fields[i]
|
||||
switch finfo.flags & fMode {
|
||||
case fAttr:
|
||||
strv := finfo.value(sv)
|
||||
// Look for attribute.
|
||||
for _, a := range start.Attr {
|
||||
if a.Name.Local == finfo.name && (finfo.xmlns == "" || finfo.xmlns == a.Name.Space) {
|
||||
if err := p.unmarshalAttr(strv, a); err != nil {
|
||||
return err
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
case fCharData:
|
||||
if !saveData.IsValid() {
|
||||
saveData = finfo.value(sv)
|
||||
}
|
||||
|
||||
case fComment:
|
||||
if !saveComment.IsValid() {
|
||||
saveComment = finfo.value(sv)
|
||||
}
|
||||
|
||||
case fAny, fAny | fElement:
|
||||
if !saveAny.IsValid() {
|
||||
saveAny = finfo.value(sv)
|
||||
}
|
||||
|
||||
case fInnerXml:
|
||||
if !saveXML.IsValid() {
|
||||
saveXML = finfo.value(sv)
|
||||
if p.saved == nil {
|
||||
saveXMLIndex = 0
|
||||
p.saved = new(bytes.Buffer)
|
||||
} else {
|
||||
saveXMLIndex = p.savedOffset()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Find end element.
|
||||
// Process sub-elements along the way.
|
||||
Loop:
|
||||
for {
|
||||
var savedOffset int
|
||||
if saveXML.IsValid() {
|
||||
savedOffset = p.savedOffset()
|
||||
}
|
||||
tok, err := p.Token()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
switch t := tok.(type) {
|
||||
case StartElement:
|
||||
consumed := false
|
||||
if sv.IsValid() {
|
||||
consumed, err = p.unmarshalPath(tinfo, sv, nil, &t)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !consumed && saveAny.IsValid() {
|
||||
consumed = true
|
||||
if err := p.unmarshal(saveAny, &t); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
if !consumed {
|
||||
if err := p.Skip(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
case EndElement:
|
||||
if saveXML.IsValid() {
|
||||
saveXMLData = p.saved.Bytes()[saveXMLIndex:savedOffset]
|
||||
if saveXMLIndex == 0 {
|
||||
p.saved = nil
|
||||
}
|
||||
}
|
||||
break Loop
|
||||
|
||||
case CharData:
|
||||
if saveData.IsValid() {
|
||||
data = append(data, t...)
|
||||
}
|
||||
|
||||
case Comment:
|
||||
if saveComment.IsValid() {
|
||||
comment = append(comment, t...)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if saveData.IsValid() && saveData.CanInterface() && saveData.Type().Implements(textUnmarshalerType) {
|
||||
if err := saveData.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
|
||||
return err
|
||||
}
|
||||
saveData = reflect.Value{}
|
||||
}
|
||||
|
||||
if saveData.IsValid() && saveData.CanAddr() {
|
||||
pv := saveData.Addr()
|
||||
if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
|
||||
if err := pv.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
|
||||
return err
|
||||
}
|
||||
saveData = reflect.Value{}
|
||||
}
|
||||
}
|
||||
|
||||
if err := copyValue(saveData, data); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
switch t := saveComment; t.Kind() {
|
||||
case reflect.String:
|
||||
t.SetString(string(comment))
|
||||
case reflect.Slice:
|
||||
t.Set(reflect.ValueOf(comment))
|
||||
}
|
||||
|
||||
switch t := saveXML; t.Kind() {
|
||||
case reflect.String:
|
||||
t.SetString(string(saveXMLData))
|
||||
case reflect.Slice:
|
||||
t.Set(reflect.ValueOf(saveXMLData))
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func copyValue(dst reflect.Value, src []byte) (err error) {
|
||||
dst0 := dst
|
||||
|
||||
if dst.Kind() == reflect.Ptr {
|
||||
if dst.IsNil() {
|
||||
dst.Set(reflect.New(dst.Type().Elem()))
|
||||
}
|
||||
dst = dst.Elem()
|
||||
}
|
||||
|
||||
// Save accumulated data.
|
||||
switch dst.Kind() {
|
||||
case reflect.Invalid:
|
||||
// Probably a comment.
|
||||
default:
|
||||
return errors.New("cannot unmarshal into " + dst0.Type().String())
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
itmp, err := strconv.ParseInt(string(src), 10, dst.Type().Bits())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
dst.SetInt(itmp)
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
||||
var utmp uint64
|
||||
if len(src) > 0 && src[0] == '-' {
|
||||
// Negative value for unsigned field.
|
||||
// Assume it was serialized following two's complement.
|
||||
itmp, err := strconv.ParseInt(string(src), 10, dst.Type().Bits())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Reinterpret value based on type width.
|
||||
switch dst.Type().Bits() {
|
||||
case 8:
|
||||
utmp = uint64(uint8(itmp))
|
||||
case 16:
|
||||
utmp = uint64(uint16(itmp))
|
||||
case 32:
|
||||
utmp = uint64(uint32(itmp))
|
||||
case 64:
|
||||
utmp = uint64(uint64(itmp))
|
||||
}
|
||||
} else {
|
||||
utmp, err = strconv.ParseUint(string(src), 10, dst.Type().Bits())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
dst.SetUint(utmp)
|
||||
case reflect.Float32, reflect.Float64:
|
||||
ftmp, err := strconv.ParseFloat(string(src), dst.Type().Bits())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
dst.SetFloat(ftmp)
|
||||
case reflect.Bool:
|
||||
value, err := strconv.ParseBool(strings.TrimSpace(string(src)))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
dst.SetBool(value)
|
||||
case reflect.String:
|
||||
dst.SetString(string(src))
|
||||
case reflect.Slice:
|
||||
if len(src) == 0 {
|
||||
// non-nil to flag presence
|
||||
src = []byte{}
|
||||
}
|
||||
dst.SetBytes(src)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// unmarshalPath walks down an XML structure looking for wanted
|
||||
// paths, and calls unmarshal on them.
|
||||
// The consumed result tells whether XML elements have been consumed
|
||||
// from the Decoder until start's matching end element, or if it's
|
||||
// still untouched because start is uninteresting for sv's fields.
|
||||
func (p *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement) (consumed bool, err error) {
|
||||
recurse := false
|
||||
Loop:
|
||||
for i := range tinfo.fields {
|
||||
finfo := &tinfo.fields[i]
|
||||
if finfo.flags&fElement == 0 || len(finfo.parents) < len(parents) || finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
|
||||
continue
|
||||
}
|
||||
for j := range parents {
|
||||
if parents[j] != finfo.parents[j] {
|
||||
continue Loop
|
||||
}
|
||||
}
|
||||
if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local {
|
||||
// It's a perfect match, unmarshal the field.
|
||||
return true, p.unmarshal(finfo.value(sv), start)
|
||||
}
|
||||
if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local {
|
||||
// It's a prefix for the field. Break and recurse
|
||||
// since it's not ok for one field path to be itself
|
||||
// the prefix for another field path.
|
||||
recurse = true
|
||||
|
||||
// We can reuse the same slice as long as we
|
||||
// don't try to append to it.
|
||||
parents = finfo.parents[:len(parents)+1]
|
||||
break
|
||||
}
|
||||
}
|
||||
if !recurse {
|
||||
// We have no business with this element.
|
||||
return false, nil
|
||||
}
|
||||
// The element is not a perfect match for any field, but one
|
||||
// or more fields have the path to this element as a parent
|
||||
// prefix. Recurse and attempt to match these.
|
||||
for {
|
||||
var tok Token
|
||||
tok, err = p.Token()
|
||||
if err != nil {
|
||||
return true, err
|
||||
}
|
||||
switch t := tok.(type) {
|
||||
case StartElement:
|
||||
consumed2, err := p.unmarshalPath(tinfo, sv, parents, &t)
|
||||
if err != nil {
|
||||
return true, err
|
||||
}
|
||||
if !consumed2 {
|
||||
if err := p.Skip(); err != nil {
|
||||
return true, err
|
||||
}
|
||||
}
|
||||
case EndElement:
|
||||
return true, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Skip reads tokens until it has consumed the end element
|
||||
// matching the most recent start element already consumed.
|
||||
// It recurs if it encounters a start element, so it can be used to
|
||||
// skip nested structures.
|
||||
// It returns nil if it finds an end element matching the start
|
||||
// element; otherwise it returns an error describing the problem.
|
||||
func (d *Decoder) Skip() error {
|
||||
for {
|
||||
tok, err := d.Token()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
switch tok.(type) {
|
||||
case StartElement:
|
||||
if err := d.Skip(); err != nil {
|
||||
return err
|
||||
}
|
||||
case EndElement:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
762
vendor/github.com/vmware/govmomi/vim25/xml/read_test.go
generated
vendored
Normal file
762
vendor/github.com/vmware/govmomi/vim25/xml/read_test.go
generated
vendored
Normal file
@@ -0,0 +1,762 @@
|
||||
// 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 (
|
||||
"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 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:html4="http://www.w3.org/TR/html4/" html4:table="hello" xmlns:furniture="http://www.w3schools.com/furniture" furniture:table="world" xml:lang="en_US" xmlns:_xml="http://golang.org/xml/" _xml:other="other1" xmlns:_xmlfoo="http://golang.org/xmlfoo/" _xmlfoo:other="other2" xmlns:json="http://golang.org/json/" json:other="other3" xmlns:json_1="http://golang.org/2/json/" 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://code.google.com/p/go/issues/detail?id=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)
|
||||
}
|
||||
}
|
||||
|
||||
// https://github.com/vmware/govmomi/issues/246
|
||||
func TestNegativeValuesUnsignedFields(t *testing.T) {
|
||||
type T struct {
|
||||
I string
|
||||
O interface{}
|
||||
U8 uint8 `xml:"u8"`
|
||||
U16 uint16 `xml:"u16"`
|
||||
U32 uint32 `xml:"u32"`
|
||||
U64 uint64 `xml:"u64"`
|
||||
}
|
||||
|
||||
var tests = []T{
|
||||
{I: "<T><u8>-128</u8></T>", O: uint8(0x80)},
|
||||
{I: "<T><u8>-1</u8></T>", O: uint8(0xff)},
|
||||
{I: "<T><u16>-32768</u16></T>", O: uint16(0x8000)},
|
||||
{I: "<T><u16>-1</u16></T>", O: uint16(0xffff)},
|
||||
{I: "<T><u32>-2147483648</u32></T>", O: uint32(0x80000000)},
|
||||
{I: "<T><u32>-1</u32></T>", O: uint32(0xffffffff)},
|
||||
{I: "<T><u64>-9223372036854775808</u64></T>", O: uint64(0x8000000000000000)},
|
||||
{I: "<T><u64>-1</u64></T>", O: uint64(0xffffffffffffffff)},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
err := Unmarshal([]byte(test.I), &test)
|
||||
if err != nil {
|
||||
t.Errorf("Unmarshal error: %v", err)
|
||||
continue
|
||||
}
|
||||
|
||||
var expected = test.O
|
||||
var actual interface{}
|
||||
switch reflect.ValueOf(test.O).Type().Kind() {
|
||||
case reflect.Uint8:
|
||||
actual = test.U8
|
||||
case reflect.Uint16:
|
||||
actual = test.U16
|
||||
case reflect.Uint32:
|
||||
actual = test.U32
|
||||
case reflect.Uint64:
|
||||
actual = test.U64
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(actual, expected) {
|
||||
t.Errorf("Actual: %v, expected: %v", actual, expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
366
vendor/github.com/vmware/govmomi/vim25/xml/typeinfo.go
generated
vendored
Normal file
366
vendor/github.com/vmware/govmomi/vim25/xml/typeinfo.go
generated
vendored
Normal file
@@ -0,0 +1,366 @@
|
||||
// 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 (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// typeInfo holds details for the xml representation of a type.
|
||||
type typeInfo struct {
|
||||
xmlname *fieldInfo
|
||||
fields []fieldInfo
|
||||
}
|
||||
|
||||
// fieldInfo holds details for the xml representation of a single field.
|
||||
type fieldInfo struct {
|
||||
idx []int
|
||||
name string
|
||||
xmlns string
|
||||
flags fieldFlags
|
||||
parents []string
|
||||
}
|
||||
|
||||
type fieldFlags int
|
||||
|
||||
const (
|
||||
fElement fieldFlags = 1 << iota
|
||||
fAttr
|
||||
fCharData
|
||||
fInnerXml
|
||||
fComment
|
||||
fAny
|
||||
|
||||
fOmitEmpty
|
||||
fTypeAttr
|
||||
|
||||
fMode = fElement | fAttr | fCharData | fInnerXml | fComment | fAny
|
||||
)
|
||||
|
||||
var tinfoMap = make(map[reflect.Type]*typeInfo)
|
||||
var tinfoLock sync.RWMutex
|
||||
|
||||
var nameType = reflect.TypeOf(Name{})
|
||||
|
||||
// getTypeInfo returns the typeInfo structure with details necessary
|
||||
// for marshalling and unmarshalling typ.
|
||||
func getTypeInfo(typ reflect.Type) (*typeInfo, error) {
|
||||
tinfoLock.RLock()
|
||||
tinfo, ok := tinfoMap[typ]
|
||||
tinfoLock.RUnlock()
|
||||
if ok {
|
||||
return tinfo, nil
|
||||
}
|
||||
tinfo = &typeInfo{}
|
||||
if typ.Kind() == reflect.Struct && typ != nameType {
|
||||
n := typ.NumField()
|
||||
for i := 0; i < n; i++ {
|
||||
f := typ.Field(i)
|
||||
if f.PkgPath != "" || f.Tag.Get("xml") == "-" {
|
||||
continue // Private field
|
||||
}
|
||||
|
||||
// For embedded structs, embed its fields.
|
||||
if f.Anonymous {
|
||||
t := f.Type
|
||||
if t.Kind() == reflect.Ptr {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t.Kind() == reflect.Struct {
|
||||
inner, err := getTypeInfo(t)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if tinfo.xmlname == nil {
|
||||
tinfo.xmlname = inner.xmlname
|
||||
}
|
||||
for _, finfo := range inner.fields {
|
||||
finfo.idx = append([]int{i}, finfo.idx...)
|
||||
if err := addFieldInfo(typ, tinfo, &finfo); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
finfo, err := structFieldInfo(typ, &f)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if f.Name == "XMLName" {
|
||||
tinfo.xmlname = finfo
|
||||
continue
|
||||
}
|
||||
|
||||
// Add the field if it doesn't conflict with other fields.
|
||||
if err := addFieldInfo(typ, tinfo, finfo); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
tinfoLock.Lock()
|
||||
tinfoMap[typ] = tinfo
|
||||
tinfoLock.Unlock()
|
||||
return tinfo, nil
|
||||
}
|
||||
|
||||
// structFieldInfo builds and returns a fieldInfo for f.
|
||||
func structFieldInfo(typ reflect.Type, f *reflect.StructField) (*fieldInfo, error) {
|
||||
finfo := &fieldInfo{idx: f.Index}
|
||||
|
||||
// Split the tag from the xml namespace if necessary.
|
||||
tag := f.Tag.Get("xml")
|
||||
if i := strings.Index(tag, " "); i >= 0 {
|
||||
finfo.xmlns, tag = tag[:i], tag[i+1:]
|
||||
}
|
||||
|
||||
// Parse flags.
|
||||
tokens := strings.Split(tag, ",")
|
||||
if len(tokens) == 1 {
|
||||
finfo.flags = fElement
|
||||
} else {
|
||||
tag = tokens[0]
|
||||
for _, flag := range tokens[1:] {
|
||||
switch flag {
|
||||
case "attr":
|
||||
finfo.flags |= fAttr
|
||||
case "chardata":
|
||||
finfo.flags |= fCharData
|
||||
case "innerxml":
|
||||
finfo.flags |= fInnerXml
|
||||
case "comment":
|
||||
finfo.flags |= fComment
|
||||
case "any":
|
||||
finfo.flags |= fAny
|
||||
case "omitempty":
|
||||
finfo.flags |= fOmitEmpty
|
||||
case "typeattr":
|
||||
finfo.flags |= fTypeAttr
|
||||
}
|
||||
}
|
||||
|
||||
// Validate the flags used.
|
||||
valid := true
|
||||
switch mode := finfo.flags & fMode; mode {
|
||||
case 0:
|
||||
finfo.flags |= fElement
|
||||
case fAttr, fCharData, fInnerXml, fComment, fAny:
|
||||
if f.Name == "XMLName" || tag != "" && mode != fAttr {
|
||||
valid = false
|
||||
}
|
||||
default:
|
||||
// This will also catch multiple modes in a single field.
|
||||
valid = false
|
||||
}
|
||||
if finfo.flags&fMode == fAny {
|
||||
finfo.flags |= fElement
|
||||
}
|
||||
if finfo.flags&fOmitEmpty != 0 && finfo.flags&(fElement|fAttr) == 0 {
|
||||
valid = false
|
||||
}
|
||||
if !valid {
|
||||
return nil, fmt.Errorf("xml: invalid tag in field %s of type %s: %q",
|
||||
f.Name, typ, f.Tag.Get("xml"))
|
||||
}
|
||||
}
|
||||
|
||||
// Use of xmlns without a name is not allowed.
|
||||
if finfo.xmlns != "" && tag == "" {
|
||||
return nil, fmt.Errorf("xml: namespace without name in field %s of type %s: %q",
|
||||
f.Name, typ, f.Tag.Get("xml"))
|
||||
}
|
||||
|
||||
if f.Name == "XMLName" {
|
||||
// The XMLName field records the XML element name. Don't
|
||||
// process it as usual because its name should default to
|
||||
// empty rather than to the field name.
|
||||
finfo.name = tag
|
||||
return finfo, nil
|
||||
}
|
||||
|
||||
if tag == "" {
|
||||
// If the name part of the tag is completely empty, get
|
||||
// default from XMLName of underlying struct if feasible,
|
||||
// or field name otherwise.
|
||||
if xmlname := lookupXMLName(f.Type); xmlname != nil {
|
||||
finfo.xmlns, finfo.name = xmlname.xmlns, xmlname.name
|
||||
} else {
|
||||
finfo.name = f.Name
|
||||
}
|
||||
return finfo, nil
|
||||
}
|
||||
|
||||
// Prepare field name and parents.
|
||||
parents := strings.Split(tag, ">")
|
||||
if parents[0] == "" {
|
||||
parents[0] = f.Name
|
||||
}
|
||||
if parents[len(parents)-1] == "" {
|
||||
return nil, fmt.Errorf("xml: trailing '>' in field %s of type %s", f.Name, typ)
|
||||
}
|
||||
finfo.name = parents[len(parents)-1]
|
||||
if len(parents) > 1 {
|
||||
if (finfo.flags & fElement) == 0 {
|
||||
return nil, fmt.Errorf("xml: %s chain not valid with %s flag", tag, strings.Join(tokens[1:], ","))
|
||||
}
|
||||
finfo.parents = parents[:len(parents)-1]
|
||||
}
|
||||
|
||||
// If the field type has an XMLName field, the names must match
|
||||
// so that the behavior of both marshalling and unmarshalling
|
||||
// is straightforward and unambiguous.
|
||||
if finfo.flags&fElement != 0 {
|
||||
ftyp := f.Type
|
||||
xmlname := lookupXMLName(ftyp)
|
||||
if xmlname != nil && xmlname.name != finfo.name {
|
||||
return nil, fmt.Errorf("xml: name %q in tag of %s.%s conflicts with name %q in %s.XMLName",
|
||||
finfo.name, typ, f.Name, xmlname.name, ftyp)
|
||||
}
|
||||
}
|
||||
return finfo, nil
|
||||
}
|
||||
|
||||
// lookupXMLName returns the fieldInfo for typ's XMLName field
|
||||
// in case it exists and has a valid xml field tag, otherwise
|
||||
// it returns nil.
|
||||
func lookupXMLName(typ reflect.Type) (xmlname *fieldInfo) {
|
||||
for typ.Kind() == reflect.Ptr {
|
||||
typ = typ.Elem()
|
||||
}
|
||||
if typ.Kind() != reflect.Struct {
|
||||
return nil
|
||||
}
|
||||
for i, n := 0, typ.NumField(); i < n; i++ {
|
||||
f := typ.Field(i)
|
||||
if f.Name != "XMLName" {
|
||||
continue
|
||||
}
|
||||
finfo, err := structFieldInfo(typ, &f)
|
||||
if finfo.name != "" && err == nil {
|
||||
return finfo
|
||||
}
|
||||
// Also consider errors as a non-existent field tag
|
||||
// and let getTypeInfo itself report the error.
|
||||
break
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func min(a, b int) int {
|
||||
if a <= b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// addFieldInfo adds finfo to tinfo.fields if there are no
|
||||
// conflicts, or if conflicts arise from previous fields that were
|
||||
// obtained from deeper embedded structures than finfo. In the latter
|
||||
// case, the conflicting entries are dropped.
|
||||
// A conflict occurs when the path (parent + name) to a field is
|
||||
// itself a prefix of another path, or when two paths match exactly.
|
||||
// It is okay for field paths to share a common, shorter prefix.
|
||||
func addFieldInfo(typ reflect.Type, tinfo *typeInfo, newf *fieldInfo) error {
|
||||
var conflicts []int
|
||||
Loop:
|
||||
// First, figure all conflicts. Most working code will have none.
|
||||
for i := range tinfo.fields {
|
||||
oldf := &tinfo.fields[i]
|
||||
if oldf.flags&fMode != newf.flags&fMode {
|
||||
continue
|
||||
}
|
||||
if oldf.xmlns != "" && newf.xmlns != "" && oldf.xmlns != newf.xmlns {
|
||||
continue
|
||||
}
|
||||
minl := min(len(newf.parents), len(oldf.parents))
|
||||
for p := 0; p < minl; p++ {
|
||||
if oldf.parents[p] != newf.parents[p] {
|
||||
continue Loop
|
||||
}
|
||||
}
|
||||
if len(oldf.parents) > len(newf.parents) {
|
||||
if oldf.parents[len(newf.parents)] == newf.name {
|
||||
conflicts = append(conflicts, i)
|
||||
}
|
||||
} else if len(oldf.parents) < len(newf.parents) {
|
||||
if newf.parents[len(oldf.parents)] == oldf.name {
|
||||
conflicts = append(conflicts, i)
|
||||
}
|
||||
} else {
|
||||
if newf.name == oldf.name {
|
||||
conflicts = append(conflicts, i)
|
||||
}
|
||||
}
|
||||
}
|
||||
// Without conflicts, add the new field and return.
|
||||
if conflicts == nil {
|
||||
tinfo.fields = append(tinfo.fields, *newf)
|
||||
return nil
|
||||
}
|
||||
|
||||
// If any conflict is shallower, ignore the new field.
|
||||
// This matches the Go field resolution on embedding.
|
||||
for _, i := range conflicts {
|
||||
if len(tinfo.fields[i].idx) < len(newf.idx) {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// Otherwise, if any of them is at the same depth level, it's an error.
|
||||
for _, i := range conflicts {
|
||||
oldf := &tinfo.fields[i]
|
||||
if len(oldf.idx) == len(newf.idx) {
|
||||
f1 := typ.FieldByIndex(oldf.idx)
|
||||
f2 := typ.FieldByIndex(newf.idx)
|
||||
return &TagPathError{typ, f1.Name, f1.Tag.Get("xml"), f2.Name, f2.Tag.Get("xml")}
|
||||
}
|
||||
}
|
||||
|
||||
// Otherwise, the new field is shallower, and thus takes precedence,
|
||||
// so drop the conflicting fields from tinfo and append the new one.
|
||||
for c := len(conflicts) - 1; c >= 0; c-- {
|
||||
i := conflicts[c]
|
||||
copy(tinfo.fields[i:], tinfo.fields[i+1:])
|
||||
tinfo.fields = tinfo.fields[:len(tinfo.fields)-1]
|
||||
}
|
||||
tinfo.fields = append(tinfo.fields, *newf)
|
||||
return nil
|
||||
}
|
||||
|
||||
// A TagPathError represents an error in the unmarshalling process
|
||||
// caused by the use of field tags with conflicting paths.
|
||||
type TagPathError struct {
|
||||
Struct reflect.Type
|
||||
Field1, Tag1 string
|
||||
Field2, Tag2 string
|
||||
}
|
||||
|
||||
func (e *TagPathError) Error() string {
|
||||
return fmt.Sprintf("%s field %q with tag %q conflicts with field %q with tag %q", e.Struct, e.Field1, e.Tag1, e.Field2, e.Tag2)
|
||||
}
|
||||
|
||||
// value returns v's field value corresponding to finfo.
|
||||
// It's equivalent to v.FieldByIndex(finfo.idx), but initializes
|
||||
// and dereferences pointers as necessary.
|
||||
func (finfo *fieldInfo) value(v reflect.Value) reflect.Value {
|
||||
for i, x := range finfo.idx {
|
||||
if i > 0 {
|
||||
t := v.Type()
|
||||
if t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct {
|
||||
if v.IsNil() {
|
||||
v.Set(reflect.New(v.Type().Elem()))
|
||||
}
|
||||
v = v.Elem()
|
||||
}
|
||||
}
|
||||
v = v.Field(x)
|
||||
}
|
||||
return v
|
||||
}
|
||||
1939
vendor/github.com/vmware/govmomi/vim25/xml/xml.go
generated
vendored
Normal file
1939
vendor/github.com/vmware/govmomi/vim25/xml/xml.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
726
vendor/github.com/vmware/govmomi/vim25/xml/xml_test.go
generated
vendored
Normal file
726
vendor/github.com/vmware/govmomi/vim25/xml/xml_test.go
generated
vendored
Normal file
@@ -0,0 +1,726 @@
|
||||
// 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, 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, 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, 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, rawTokens []Token) {
|
||||
for i, want := range rawTokens {
|
||||
have, err := d.RawToken()
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 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, expect string
|
||||
}{
|
||||
{`version="1.0" encoding="utf-8"`, "utf-8"},
|
||||
{`version="1.0" encoding='utf-8'`, "utf-8"},
|
||||
{`version="1.0" encoding='utf-8' `, "utf-8"},
|
||||
{`version="1.0" encoding=utf-8`, ""},
|
||||
{`encoding="FOO" `, "FOO"},
|
||||
}
|
||||
|
||||
func TestProcInstEncoding(t *testing.T) {
|
||||
for _, test := range procInstTests {
|
||||
got := procInstEncoding(test.input)
|
||||
if got != test.expect {
|
||||
t.Errorf("procInstEncoding(%q) = %q; want %q", test.input, got, test.expect)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user