d8dfun/virtual-kubelet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Fix the dependency issue (#231)

Browse Source
This commit is contained in:
Robbie Zhang
2018-06-21 12:09:42 -07:00
committed by GitHub
parent 027b76651d
commit 6ec1098bb8
16629 changed files with 74837 additions and 4975021 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
vendor/github.com/vmware/govmomi/vim25/client_test.go generated vendored
View File

@@ -1,97 +0,0 @@
/*
Copyright (c) 2015 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 vim25
import (
"context"
"encoding/json"
"net/url"
"os"
"testing"
"github.com/vmware/govmomi/vim25/methods"
"github.com/vmware/govmomi/vim25/mo"
"github.com/vmware/govmomi/vim25/soap"
"github.com/vmware/govmomi/vim25/types"
)
// Duplicated to prevent cyclic dependency...
func testURL(t *testing.T) *url.URL {
s := os.Getenv("GOVMOMI_TEST_URL")
if s == "" {
t.SkipNow()
}
u, err := soap.ParseURL(s)
if err != nil {
panic(err)
}
return u
}
func sessionLogin(t *testing.T, c *Client) {
req := types.Login{
This: *c.ServiceContent.SessionManager,
}
u := testURL(t).User
req.UserName = u.Username()
if pw, ok := u.Password(); ok {
req.Password = pw
}
_, err := methods.Login(context.Background(), c, &req)
if err != nil {
t.Fatal(err)
}
}
func sessionCheck(t *testing.T, c *Client) {
var mgr mo.SessionManager
err := mo.RetrieveProperties(context.Background(), c, c.ServiceContent.PropertyCollector, *c.ServiceContent.SessionManager, &mgr)
if err != nil {
t.Fatal(err)
}
}
func TestClientSerialization(t *testing.T) {
var c1, c2 *Client
soapClient := soap.NewClient(testURL(t), true)
c1, err := NewClient(context.Background(), soapClient)
if err != nil {
t.Fatal(err)
}
// Login
sessionLogin(t, c1)
sessionCheck(t, c1)
// Serialize/deserialize
b, err := json.Marshal(c1)
if err != nil {
t.Fatal(err)
}
c2 = &Client{}
err = json.Unmarshal(b, c2)
if err != nil {
t.Fatal(err)
}
// Check the session is still valid
sessionCheck(t, c2)
}

62
vendor/github.com/vmware/govmomi/vim25/methods/fault_test.go generated vendored
View File

@@ -1,62 +0,0 @@
/*
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 methods
import (
"bytes"
"testing"
"github.com/vmware/govmomi/vim25/soap"
"github.com/vmware/govmomi/vim25/types"
"github.com/vmware/govmomi/vim25/xml"
)
var invalidLoginFault = `
<?xml version="1.0" encoding="UTF-8"?>
<soapenv:Envelope xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<soapenv:Body>
<soapenv:Fault><faultcode>ServerFaultCode</faultcode><faultstring>Cannot complete login due to an incorrect user name or password.</faultstring><detail><InvalidLoginFault xmlns="urn:vim25" xsi:type="InvalidLogin"></InvalidLoginFault></detail></soapenv:Fault>
</soapenv:Body>
</soapenv:Envelope>`
type TestBody struct {
Fault *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"`
}
func TestFaultDetail(t *testing.T) {
body := TestBody{}
env := soap.Envelope{Body: &body}
dec := xml.NewDecoder(bytes.NewReader([]byte(invalidLoginFault)))
dec.TypeFunc = types.TypeFunc()
err := dec.Decode(&env)
if err != nil {
t.Fatalf("Decode: %s", err)
}
if body.Fault == nil {
t.Fatal("Expected fault")
}
if _, ok := body.Fault.Detail.Fault.(types.InvalidLogin); !ok {
t.Fatalf("Expected InvalidLogin, got: %#v", body.Fault.Detail.Fault)
}
}

15
vendor/github.com/vmware/govmomi/vim25/mo/fixtures/cluster_host_property.xml generated vendored
View File

@@ -1,15 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<returnval>
<obj type="ClusterComputeResource">domain-c7</obj>
<propSet>
<name>host</name>
<val xsi:type="ArrayOfManagedObjectReference">
<ManagedObjectReference type="HostSystem" xsi:type="ManagedObjectReference">host-14</ManagedObjectReference>
<ManagedObjectReference type="HostSystem" xsi:type="ManagedObjectReference">host-17</ManagedObjectReference>
<ManagedObjectReference type="HostSystem" xsi:type="ManagedObjectReference">host-19</ManagedObjectReference>
<ManagedObjectReference type="HostSystem" xsi:type="ManagedObjectReference">host-52</ManagedObjectReference>
</val>
</propSet>
</returnval>
</RetrievePropertiesResponse>

17
vendor/github.com/vmware/govmomi/vim25/mo/fixtures/hostsystem_list_name_property.xml generated vendored
View File

@@ -1,17 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<returnval>
<obj type="HostSystem">host-10</obj>
<propSet>
<name>name</name>
<val xsi:type="xsd:string">host-01.example.com</val>
</propSet>
</returnval>
<returnval>
<obj type="HostSystem">host-30</obj>
<propSet>
<name>name</name>
<val xsi:type="xsd:string">host-02.example.com</val>
</propSet>
</returnval>
</RetrievePropertiesResponse>

14
vendor/github.com/vmware/govmomi/vim25/mo/fixtures/nested_property.xml generated vendored
View File

@@ -1,14 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<returnval>
<obj type="VirtualMachine">vm-411</obj>
<propSet>
<name>config.name</name>
<val xsi:type="xsd:string">kubernetes-master</val>
</propSet>
<propSet>
<name>config.uuid</name>
<val xsi:type="xsd:string">422ec880-ab06-06b4-23f3-beb7a052a4c9</val>
</propSet>
</returnval>
</RetrievePropertiesResponse>

42
vendor/github.com/vmware/govmomi/vim25/mo/fixtures/not_authenticated_fault.xml generated vendored
View File

@@ -1,42 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<returnval>
<obj type="SessionManager">SessionManager</obj>
<propSet>
<name>defaultLocale</name>
<val xsi:type="xsd:string">en</val>
</propSet>
<propSet>
<name>messageLocaleList</name>
<val xsi:type="ArrayOfString">
<string xsi:type="xsd:string">ja</string>
<string xsi:type="xsd:string">zh_CN</string>
<string xsi:type="xsd:string">en</string>
<string xsi:type="xsd:string">de</string>
<string xsi:type="xsd:string">zh_TW</string>
<string xsi:type="xsd:string">ko</string>
<string xsi:type="xsd:string">fr</string>
</val>
</propSet>
<missingSet>
<path>message</path>
<fault>
<fault xsi:type="NotAuthenticated">
<object type="Folder">group-d1</object>
<privilegeId>System.View</privilegeId>
</fault>
<localizedMessage/>
</fault>
</missingSet>
<missingSet>
<path>sessionList</path>
<fault>
<fault xsi:type="NotAuthenticated">
<object type="Folder">group-d1</object>
<privilegeId>Sessions.TerminateSession</privilegeId>
</fault>
<localizedMessage/>
</fault>
</missingSet>
</returnval>
</RetrievePropertiesResponse>

15
vendor/github.com/vmware/govmomi/vim25/mo/fixtures/pointer_property.xml generated vendored
View File

@@ -1,15 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<RetrievePropertiesResponse xmlns="urn:vim25" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<returnval>
<obj type="VirtualMachine">vm-411</obj>
<propSet>
<name>config.bootOptions</name>
<val xsi:type="VirtualMachineBootOptions">
<bootDelay>0</bootDelay>
<enterBIOSSetup>false</enterBIOSSetup>
<bootRetryEnabled>false</bootRetryEnabled>
<bootRetryDelay>10000</bootRetryDelay>
</val>
</propSet>
</returnval>
</RetrievePropertiesResponse>

144
vendor/github.com/vmware/govmomi/vim25/mo/retrieve_test.go generated vendored
View File

@@ -1,144 +0,0 @@
/*
Copyright (c) 2014-2015 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 mo
import (
"os"
"testing"
"github.com/vmware/govmomi/vim25/soap"
"github.com/vmware/govmomi/vim25/types"
"github.com/vmware/govmomi/vim25/xml"
)
func load(name string) *types.RetrievePropertiesResponse {
f, err := os.Open(name)
if err != nil {
panic(err)
}
defer f.Close()
var b types.RetrievePropertiesResponse
dec := xml.NewDecoder(f)
dec.TypeFunc = types.TypeFunc()
if err := dec.Decode(&b); err != nil {
panic(err)
}
return &b
}
func TestNotAuthenticatedFault(t *testing.T) {
var s SessionManager
err := LoadRetrievePropertiesResponse(load("fixtures/not_authenticated_fault.xml"), &s)
if !soap.IsVimFault(err) {
t.Errorf("Expected IsVimFault")
}
fault := soap.ToVimFault(err).(*types.NotAuthenticated)
if fault.PrivilegeId != "System.View" {
t.Errorf("Expected first fault to be returned")
}
}
func TestNestedProperty(t *testing.T) {
var vm VirtualMachine
err := LoadRetrievePropertiesResponse(load("fixtures/nested_property.xml"), &vm)
if err != nil {
t.Fatalf("Expected no error, got: %s", err)
}
self := types.ManagedObjectReference{
Type: "VirtualMachine",
Value: "vm-411",
}
if vm.Self != self {
t.Fatalf("Expected vm.Self to be set")
}
if vm.Config == nil {
t.Fatalf("Expected vm.Config to be set")
}
if vm.Config.Name != "kubernetes-master" {
t.Errorf("Got: %s", vm.Config.Name)
}
if vm.Config.Uuid != "422ec880-ab06-06b4-23f3-beb7a052a4c9" {
t.Errorf("Got: %s", vm.Config.Uuid)
}
}
func TestPointerProperty(t *testing.T) {
var vm VirtualMachine
err := LoadRetrievePropertiesResponse(load("fixtures/pointer_property.xml"), &vm)
if err != nil {
t.Fatalf("Expected no error, got: %s", err)
}
if vm.Config == nil {
t.Fatalf("Expected vm.Config to be set")
}
if vm.Config.BootOptions == nil {
t.Fatalf("Expected vm.Config.BootOptions to be set")
}
}
func TestEmbeddedTypeProperty(t *testing.T) {
// Test that we avoid in this case:
// panic: reflect.Set: value of type mo.ClusterComputeResource is not assignable to type mo.ComputeResource
var cr ComputeResource
err := LoadRetrievePropertiesResponse(load("fixtures/cluster_host_property.xml"), &cr)
if err != nil {
t.Fatalf("Expected no error, got: %s", err)
}
if len(cr.Host) != 4 {
t.Fatalf("Expected cr.Host to be set")
}
}
func TestEmbeddedTypePropertySlice(t *testing.T) {
var me []ManagedEntity
err := LoadRetrievePropertiesResponse(load("fixtures/hostsystem_list_name_property.xml"), &me)
if err != nil {
t.Fatalf("Expected no error, got: %s", err)
}
if len(me) != 2 {
t.Fatalf("Expected 2 elements")
}
for _, m := range me {
if m.Name == "" {
t.Fatal("Expected Name field to be set")
}
}
if me[0].Name == me[1].Name {
t.Fatal("Name fields should not be the same")
}
}

37
vendor/github.com/vmware/govmomi/vim25/mo/type_info_test.go generated vendored
View File

@@ -1,37 +0,0 @@
/*
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 mo
import (
"reflect"
"testing"
)
func TestLoadAll(*testing.T) {
for _, typ := range t {
newTypeInfo(typ)
}
}
// The virtual machine managed object has about 500 nested properties.
// It's likely to be indicative of the function's performance in general.
func BenchmarkLoadVirtualMachine(b *testing.B) {
vmtyp := reflect.TypeOf((*VirtualMachine)(nil)).Elem()
for i := 0; i < b.N; i++ {
newTypeInfo(vmtyp)
}
}

81
vendor/github.com/vmware/govmomi/vim25/progress/aggregator_test.go generated vendored
View File

@@ -1,81 +0,0 @@
/*
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 progress
import (
"testing"
"time"
)
func TestAggregatorNoSinks(t *testing.T) {
ch := make(chan Report)
a := NewAggregator(dummySinker{ch})
a.Done()
_, ok := <-ch
if ok {
t.Errorf("Expected channel to be closed")
}
}
func TestAggregatorMultipleSinks(t *testing.T) {
ch := make(chan Report)
a := NewAggregator(dummySinker{ch})
for i := 0; i < 5; i++ {
go func(ch chan<- Report) {
ch <- dummyReport{}
ch <- dummyReport{}
close(ch)
}(a.Sink())
<-ch
<-ch
}
a.Done()
_, ok := <-ch
if ok {
t.Errorf("Expected channel to be closed")
}
}
func TestAggregatorSinkInFlightOnDone(t *testing.T) {
ch := make(chan Report)
a := NewAggregator(dummySinker{ch})
// Simulate upstream
go func(ch chan<- Report) {
time.Sleep(1 * time.Millisecond)
ch <- dummyReport{}
close(ch)
}(a.Sink())
// Drain downstream
go func(ch <-chan Report) {
<-ch
}(ch)
// This should wait for upstream to complete
a.Done()
_, ok := <-ch
if ok {
t.Errorf("Expected channel to be closed")
}
}

43
vendor/github.com/vmware/govmomi/vim25/progress/common_test.go generated vendored
View File

@@ -1,43 +0,0 @@
/*
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 progress
type dummySinker struct {
ch chan Report
}
func (d dummySinker) Sink() chan<- Report {
return d.ch
}
type dummyReport struct {
p float32
d string
e error
}
func (p dummyReport) Percentage() float32 {
return p.p
}
func (p dummyReport) Detail() string {
return p.d
}
func (p dummyReport) Error() error {
return p.e
}

40
vendor/github.com/vmware/govmomi/vim25/progress/prefix_test.go generated vendored
View File

@@ -1,40 +0,0 @@
/*
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 progress
import "testing"
func TestPrefix(t *testing.T) {
var r Report
ch := make(chan Report, 1)
s := Prefix(dummySinker{ch}, "prefix").Sink()
// No detail
s <- dummyReport{d: ""}
r = <-ch
if r.Detail() != "prefix" {
t.Errorf("Expected detail to be prefixed")
}
// With detail
s <- dummyReport{d: "something"}
r = <-ch
if r.Detail() != "prefix: something" {
t.Errorf("Expected detail to be prefixed")
}
}

92
vendor/github.com/vmware/govmomi/vim25/progress/reader_test.go generated vendored
View File

@@ -1,92 +0,0 @@
/*
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 progress
import (
"context"
"io"
"strings"
"testing"
)
func TestReader(t *testing.T) {
s := "helloworld"
ch := make(chan Report, 1)
pr := NewReader(context.Background(), &dummySinker{ch}, strings.NewReader(s), int64(len(s)))
var buf [10]byte
var q Report
var n int
var err error
// Read first byte
n, err = pr.Read(buf[0:1])
if n != 1 {
t.Errorf("Expected n=1, but got: %d", n)
}
if err != nil {
t.Errorf("Error: %s", err)
}
q = <-ch
if q.Error() != nil {
t.Errorf("Error: %s", err)
}
if f := q.Percentage(); f != 10.0 {
t.Errorf("Expected percentage after 1 byte to be 10%%, but got: %.0f%%", f)
}
// Read remaining bytes
n, err = pr.Read(buf[:])
if n != 9 {
t.Errorf("Expected n=1, but got: %d", n)
}
if err != nil {
t.Errorf("Error: %s", err)
}
q = <-ch
if q.Error() != nil {
t.Errorf("Error: %s", err)
}
if f := q.Percentage(); f != 100.0 {
t.Errorf("Expected percentage after 10 bytes to be 100%%, but got: %.0f%%", f)
}
// Read EOF
_, err = pr.Read(buf[:])
q = <-ch
if err != io.EOF {
t.Errorf("Expected io.EOF, but got: %s", err)
}
// Mark progress reader as done
pr.Done(io.EOF)
q = <-ch
if err != io.EOF {
t.Errorf("Expected io.EOF, but got: %s", err)
}
// Progress channel should be closed after progress reader is marked done
_, ok := <-ch
if ok {
t.Errorf("Expected channel to be closed")
}
}

45
vendor/github.com/vmware/govmomi/vim25/progress/scale_test.go generated vendored
View File

@@ -1,45 +0,0 @@
/*
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 progress
import "testing"
func TestScaleMany(t *testing.T) {
ch := make(chan Report)
a := NewAggregator(dummySinker{ch})
defer a.Done()
s := Scale(a, 5)
go func() {
for i := 0; i < 5; i++ {
go func(ch chan<- Report) {
ch <- dummyReport{p: 0.0}
ch <- dummyReport{p: 50.0}
close(ch)
}(s.Sink())
}
}()
// Expect percentages to be scaled across sinks
for p := float32(0.0); p < 100.0; p += 10.0 {
r := <-ch
if r.Percentage() != p {
t.Errorf("Expected percentage to be: %.0f%%", p)
}
}
}

46
vendor/github.com/vmware/govmomi/vim25/progress/tee_test.go generated vendored
View File

@@ -1,46 +0,0 @@
/*
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 progress
import "testing"
func TestTee(t *testing.T) {
var ok bool
ch1 := make(chan Report)
ch2 := make(chan Report)
s := Tee(&dummySinker{ch: ch1}, &dummySinker{ch: ch2})
in := s.Sink()
in <- dummyReport{}
close(in)
// Receive dummy on both sinks
<-ch1
<-ch2
_, ok = <-ch1
if ok {
t.Errorf("Expected channel to be closed")
}
_, ok = <-ch2
if ok {
t.Errorf("Expected channel to be closed")
}
}

86
vendor/github.com/vmware/govmomi/vim25/retry_test.go generated vendored
View File

@@ -1,86 +0,0 @@
/*
Copyright (c) 2015 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 vim25
import (
"context"
"testing"
"github.com/vmware/govmomi/vim25/soap"
)
type tempError struct{}
func (tempError) Error() string { return "tempError" }
func (tempError) Timeout() bool { return true }
func (tempError) Temporary() bool { return true }
type nonTempError struct{}
func (nonTempError) Error() string { return "nonTempError" }
func (nonTempError) Timeout() bool { return false }
func (nonTempError) Temporary() bool { return false }
type fakeRoundTripper struct {
errs []error
}
func (f *fakeRoundTripper) RoundTrip(ctx context.Context, req, res soap.HasFault) error {
err := f.errs[0]
f.errs = f.errs[1:]
return err
}
func TestRetry(t *testing.T) {
var tcs = []struct {
errs []error
expected error
}{
{
errs: []error{nil},
expected: nil,
},
{
errs: []error{tempError{}, nil},
expected: nil,
},
{
errs: []error{tempError{}, tempError{}},
expected: tempError{},
},
{
errs: []error{nonTempError{}},
expected: nonTempError{},
},
{
errs: []error{tempError{}, nonTempError{}},
expected: nonTempError{},
},
}
for _, tc := range tcs {
var rt soap.RoundTripper
rt = &fakeRoundTripper{errs: tc.errs}
rt = Retry(rt, TemporaryNetworkError(2))
err := rt.RoundTrip(nil, nil, nil)
if err != tc.expected {
t.Errorf("Expected: %s, got: %s", tc.expected, err)
}
}
}

43
vendor/github.com/vmware/govmomi/vim25/soap/client_test.go generated vendored
View File

@@ -1,43 +0,0 @@
/*
Copyright (c) 2015 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 soap
import "testing"
func TestSplitHostPort(t *testing.T) {
tests := []struct {
url string
host string
port string
}{
{"127.0.0.1", "127.0.0.1", ""},
{"*:1234", "*", "1234"},
{"127.0.0.1:80", "127.0.0.1", "80"},
{"[::1]:6767", "[::1]", "6767"},
{"[::1]", "[::1]", ""},
}
for _, test := range tests {
host, port := splitHostPort(test.url)
if host != test.host {
t.Errorf("(%s) %s != %s", test.url, host, test.host)
}
if port != test.port {
t.Errorf("(%s) %s != %s", test.url, port, test.port)
}
}
}

59
vendor/github.com/vmware/govmomi/vim25/soap/soap_test.go generated vendored
View File

@@ -1,59 +0,0 @@
/*
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 soap
import (
"testing"
"github.com/vmware/govmomi/vim25/xml"
)
func TestEmptyEnvelope(t *testing.T) {
env := Envelope{}
b, err := xml.Marshal(env)
if err != nil {
t.Errorf("error: %s", err)
return
}
expected := `<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"></Envelope>`
actual := string(b)
if expected != actual {
t.Fatalf("expected: %s, actual: %s", expected, actual)
}
}
func TestNonEmptyHeader(t *testing.T) {
env := Envelope{
Header: struct {
Foo string
}{"bar"},
}
b, err := xml.Marshal(env)
if err != nil {
t.Errorf("error: %s", err)
return
}
env = Envelope{}
err = xml.Unmarshal(b, &env)
if err != nil {
t.Errorf("error: %s", err)
}
}

65
vendor/github.com/vmware/govmomi/vim25/types/base_test.go generated vendored
View File

@@ -1,65 +0,0 @@
/*
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 types
import (
"bytes"
"reflect"
"testing"
"github.com/vmware/govmomi/vim25/xml"
)
func TestAnyType(t *testing.T) {
x := func(s string) []byte {
s = `<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">` + s
s += `</root>`
return []byte(s)
}
tests := []struct {
Input []byte
Value interface{}
}{
{
Input: x(`<name xsi:type="xsd:string">test</name>`),
Value: "test",
},
{
Input: x(`<name xsi:type="ArrayOfString"><string>AA</string><string>BB</string></name>`),
Value: ArrayOfString{String: []string{"AA", "BB"}},
},
}
for _, test := range tests {
var r struct {
A interface{} `xml:"name,typeattr"`
}
dec := xml.NewDecoder(bytes.NewReader(test.Input))
dec.TypeFunc = TypeFunc()
err := dec.Decode(&r)
if err != nil {
t.Fatalf("Decode: %s", err)
}
if !reflect.DeepEqual(r.A, test.Value) {
t.Errorf("Expected: %#v, actual: %#v", r.A, test.Value)
}
}
}

43
vendor/github.com/vmware/govmomi/vim25/types/registry_test.go generated vendored
View File

@@ -1,43 +0,0 @@
/*
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 types
import (
"reflect"
"testing"
)
func TestTypeFunc(t *testing.T) {
var ok bool
fn := TypeFunc()
_, ok = fn("unknown")
if ok {
t.Errorf("Expected ok==false")
}
actual, ok := fn("UserProfile")
if !ok {
t.Errorf("Expected ok==true")
}
expected := reflect.TypeOf(UserProfile{})
if !reflect.DeepEqual(expected, actual) {
t.Errorf("Expected: %#v, actual: %#v", expected, actual)
}
}

116
vendor/github.com/vmware/govmomi/vim25/types/types_test.go generated vendored
View File

@@ -1,116 +0,0 @@
/*
Copyright (c) 2014-2015 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 types
import (
"reflect"
"testing"
"github.com/vmware/govmomi/vim25/xml"
)
func TestVirtualMachineConfigSpec(t *testing.T) {
spec := VirtualMachineConfigSpec{
Name: "vm-001",
GuestId: "otherGuest",
Files: &VirtualMachineFileInfo{VmPathName: "[datastore1]"},
NumCPUs: 1,
MemoryMB: 128,
DeviceChange: []BaseVirtualDeviceConfigSpec{
&VirtualDeviceConfigSpec{
Operation: VirtualDeviceConfigSpecOperationAdd,
Device: &VirtualLsiLogicController{VirtualSCSIController{
SharedBus: VirtualSCSISharingNoSharing,
VirtualController: VirtualController{
BusNumber: 0,
VirtualDevice: VirtualDevice{
Key: 1000,
},
},
}},
},
&VirtualDeviceConfigSpec{
Operation: VirtualDeviceConfigSpecOperationAdd,
FileOperation: VirtualDeviceConfigSpecFileOperationCreate,
Device: &VirtualDisk{
VirtualDevice: VirtualDevice{
Key: 0,
ControllerKey: 1000,
UnitNumber: new(int32), // zero default value
Backing: &VirtualDiskFlatVer2BackingInfo{
DiskMode: string(VirtualDiskModePersistent),
ThinProvisioned: NewBool(true),
VirtualDeviceFileBackingInfo: VirtualDeviceFileBackingInfo{
FileName: "[datastore1]",
},
},
},
CapacityInKB: 4000000,
},
},
&VirtualDeviceConfigSpec{
Operation: VirtualDeviceConfigSpecOperationAdd,
Device: &VirtualE1000{VirtualEthernetCard{
VirtualDevice: VirtualDevice{
Key: 0,
DeviceInfo: &Description{
Label: "Network Adapter 1",
Summary: "VM Network",
},
Backing: &VirtualEthernetCardNetworkBackingInfo{
VirtualDeviceDeviceBackingInfo: VirtualDeviceDeviceBackingInfo{
DeviceName: "VM Network",
},
},
},
AddressType: string(VirtualEthernetCardMacTypeGenerated),
}},
},
},
ExtraConfig: []BaseOptionValue{
&OptionValue{Key: "bios.bootOrder", Value: "ethernet0"},
},
}
_, err := xml.MarshalIndent(spec, "", " ")
if err != nil {
t.Fatal(err)
}
}
func TestVirtualMachineAffinityInfo(t *testing.T) {
// See https://github.com/vmware/govmomi/issues/1008
in := VirtualMachineAffinityInfo{
AffinitySet: []int32{0, 1, 2, 3},
}
b, err := xml.Marshal(in)
if err != nil {
t.Fatal(err)
}
var out VirtualMachineAffinityInfo
err = xml.Unmarshal(b, &out)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(in, out) {
t.Errorf("%#v vs %#v", in, out)
}
}

56
vendor/github.com/vmware/govmomi/vim25/xml/atom_test.go generated vendored
View File

@@ -1,56 +0,0 @@
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xml
import "time"
var atomValue = &Feed{
XMLName: Name{"http://www.w3.org/2005/Atom", "feed"},
Title: "Example Feed",
Link: []Link{{Href: "http://example.org/"}},
Updated: ParseTime("2003-12-13T18:30:02Z"),
Author: Person{Name: "John Doe"},
Id: "urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6",
Entry: []Entry{
{
Title: "Atom-Powered Robots Run Amok",
Link: []Link{{Href: "http://example.org/2003/12/13/atom03"}},
Id: "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a",
Updated: ParseTime("2003-12-13T18:30:02Z"),
Summary: NewText("Some text."),
},
},
}
var atomXml = `` +
`<feed xmlns="http://www.w3.org/2005/Atom" updated="2003-12-13T18:30:02Z">` +
`<title>Example Feed</title>` +
`<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>` +
`<link href="http://example.org/"></link>` +
`<author><name>John Doe</name><uri></uri><email></email></author>` +
`<entry>` +
`<title>Atom-Powered Robots Run Amok</title>` +
`<id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>` +
`<link href="http://example.org/2003/12/13/atom03"></link>` +
`<updated>2003-12-13T18:30:02Z</updated>` +
`<author><name></name><uri></uri><email></email></author>` +
`<summary>Some text.</summary>` +
`</entry>` +
`</feed>`
func ParseTime(str string) time.Time {
t, err := time.Parse(time.RFC3339, str)
if err != nil {
panic(err)
}
return t
}
func NewText(text string) Text {
return Text{
Body: text,
}
}

151
vendor/github.com/vmware/govmomi/vim25/xml/example_test.go generated vendored
View File

@@ -1,151 +0,0 @@
// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xml_test
import (
"encoding/xml"
"fmt"
"os"
)
func ExampleMarshalIndent() {
type Address struct {
City, State string
}
type Person struct {
XMLName xml.Name `xml:"person"`
Id int `xml:"id,attr"`
FirstName string `xml:"name>first"`
LastName string `xml:"name>last"`
Age int `xml:"age"`
Height float32 `xml:"height,omitempty"`
Married bool
Address
Comment string `xml:",comment"`
}
v := &Person{Id: 13, FirstName: "John", LastName: "Doe", Age: 42}
v.Comment = " Need more details. "
v.Address = Address{"Hanga Roa", "Easter Island"}
output, err := xml.MarshalIndent(v, " ", " ")
if err != nil {
fmt.Printf("error: %v\n", err)
}
os.Stdout.Write(output)
// Output:
// <person id="13">
// <name>
// <first>John</first>
// <last>Doe</last>
// </name>
// <age>42</age>
// <Married>false</Married>
// <City>Hanga Roa</City>
// <State>Easter Island</State>
// <!-- Need more details. -->
// </person>
}
func ExampleEncoder() {
type Address struct {
City, State string
}
type Person struct {
XMLName xml.Name `xml:"person"`
Id int `xml:"id,attr"`
FirstName string `xml:"name>first"`
LastName string `xml:"name>last"`
Age int `xml:"age"`
Height float32 `xml:"height,omitempty"`
Married bool
Address
Comment string `xml:",comment"`
}
v := &Person{Id: 13, FirstName: "John", LastName: "Doe", Age: 42}
v.Comment = " Need more details. "
v.Address = Address{"Hanga Roa", "Easter Island"}
enc := xml.NewEncoder(os.Stdout)
enc.Indent(" ", " ")
if err := enc.Encode(v); err != nil {
fmt.Printf("error: %v\n", err)
}
// Output:
// <person id="13">
// <name>
// <first>John</first>
// <last>Doe</last>
// </name>
// <age>42</age>
// <Married>false</Married>
// <City>Hanga Roa</City>
// <State>Easter Island</State>
// <!-- Need more details. -->
// </person>
}
// This example demonstrates unmarshaling an XML excerpt into a value with
// some preset fields. Note that the Phone field isn't modified and that
// the XML <Company> element is ignored. Also, the Groups field is assigned
// considering the element path provided in its tag.
func ExampleUnmarshal() {
type Email struct {
Where string `xml:"where,attr"`
Addr string
}
type Address struct {
City, State string
}
type Result struct {
XMLName xml.Name `xml:"Person"`
Name string `xml:"FullName"`
Phone string
Email []Email
Groups []string `xml:"Group>Value"`
Address
}
v := Result{Name: "none", Phone: "none"}
data := `
<Person>
<FullName>Grace R. Emlin</FullName>
<Company>Example Inc.</Company>
<Email where="home">
<Addr>gre@example.com</Addr>
</Email>
<Email where='work'>
<Addr>gre@work.com</Addr>
</Email>
<Group>
<Value>Friends</Value>
<Value>Squash</Value>
</Group>
<City>Hanga Roa</City>
<State>Easter Island</State>
</Person>
`
err := xml.Unmarshal([]byte(data), &v)
if err != nil {
fmt.Printf("error: %v", err)
return
}
fmt.Printf("XMLName: %#v\n", v.XMLName)
fmt.Printf("Name: %q\n", v.Name)
fmt.Printf("Phone: %q\n", v.Phone)
fmt.Printf("Email: %v\n", v.Email)
fmt.Printf("Groups: %v\n", v.Groups)
fmt.Printf("Address: %v\n", v.Address)
// Output:
// XMLName: xml.Name{Space:"", Local:"Person"}
// Name: "Grace R. Emlin"
// Phone: "none"
// Email: [{home gre@example.com} {work gre@work.com}]
// Groups: [Friends Squash]
// Address: {Hanga Roa Easter Island}
}

222
vendor/github.com/vmware/govmomi/vim25/xml/extras_test.go generated vendored
View File

@@ -1,222 +0,0 @@
/*
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())
}
}
}

1266
vendor/github.com/vmware/govmomi/vim25/xml/marshal_test.go generated vendored
View File

File diff suppressed because it is too large Load Diff

762
vendor/github.com/vmware/govmomi/vim25/xml/read_test.go generated vendored
View File

@@ -1,762 +0,0 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xml
import (
"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&lt;&gt;</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 &amp;lt;link rel=&amp;quot;hub&amp;quot; href=&amp;quot;hub-server&amp;quot;&amp;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&amp;#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&amp;#39;s actual URL in
the link rel=&amp;quot;self&amp;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&amp;#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&lt;&gt;</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 &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).
`,
},
},
{
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&#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.
`,
},
},
},
}
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)
}
}
}

726
vendor/github.com/vmware/govmomi/vim25/xml/xml_test.go generated vendored
View File

@@ -1,726 +0,0 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xml
import (
"bytes"
"fmt"
"io"
"reflect"
"strings"
"testing"
"unicode/utf8"
)
const testInput = `
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<body xmlns:foo="ns1" xmlns="ns2" xmlns:tag="ns3" ` +
"\r\n\t" + ` >
<hello lang="en">World &lt;&gt;&apos;&quot; &#x767d;&#40300;翔</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>&nbspc;</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>&#123</tag>
<tag>&#zzz;</tag>
<tag>&なまえ3;</tag>
<tag>&lt-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("&#123"),
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("&lt-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)
}
}