chore: vim25/xml: sync with Go 1.24 encoding/xml

Last sync was with Go 1.15, see commit 81207ea

Move some of the added code from read{_test}.go to extras{_test}.go
to help avoid future merge conflicts.

Patched via:
  % cd ~/go/src/github.com/golang/go
  % git diff go1.15..go1.24.1 src/encoding/xml > encoding-xml.patch
  % cd ~/go/src/github.com/vmware/govmomi/vim25/xml
  % patch -p4 < ~/go/src/github.com/golang/go/encoding-xml.patch

Signed-off-by: Doug MacEachern <[email protected]>

Author: dougm

vim25/xml/extras.go

@@ -85,3 +85,34 @@ func typeToString(typ reflect.Type) string {
 
 	panic("don't know what to do for type: " + typ.String())
 }
+
+// Find reflect.Type for an element's type attribute.
+func (p *Decoder) typeForElement(val reflect.Value, start *StartElement) reflect.Type {
+	t := ""
+	for _, a := range start.Attr {
+		if a.Name == xmlSchemaInstance || a.Name == xsiType {
+			t = a.Value
+			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
+}

vim25/xml/extras_test.go

@@ -208,3 +208,51 @@ func TestUnmarshalInterfaceWithoutTypeAttr(t *testing.T) {
 		}
 	}
 }
+
+// https://github.com/vmware/govmomi/issues/246
+func TestNegativeValuesUnsignedFields(t *testing.T) {
+	type T struct {
+		I   string
+		O   any
+		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 any
+		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)
+		}
+	}
+}