add vendoring with go dep

vendor/github.com/vmware/govmomi/vim25/xml/extras_test.go

@@ -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())
+		}
+	}
+}