Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 build.go // Package xmlutil provides XML serialization of AWS requests and responses. package xmlutil import ( "encoding/base64" "encoding/xml" "fmt" "math" "reflect" "sort" "strconv" "strings" "time" "github.com/aws/aws-sdk-go/private/protocol" ) const ( floatNaN = "NaN" floatInf = "Infinity" floatNegInf = "-Infinity" ) // BuildXML will serialize params into an xml.Encoder. Error will be returned // if the serialization of any of the params or nested values fails. func BuildXML(params interface{}, e xml.Encoder) error { return buildXML(params, e, false) } func buildXML(params interface{}, e xml.Encoder, sorted bool) error { b := xmlBuilder{encoder: e, namespaces: map[string]string{}} root := NewXMLElement(xml.Name{}) if err := b.buildValue(reflect.ValueOf(params), root, ""); err != nil { return err } for _, c := range root.Children { for _, v := range c { return StructToXML(e, v, sorted) } } return nil } // Returns the reflection element of a value, if it is a pointer. func elemOf(value reflect.Value) reflect.Value { for value.Kind() == reflect.Ptr { value = value.Elem() } return value } // A xmlBuilder serializes values from Go code to XML type xmlBuilder struct { encoder xml.Encoder namespaces map[string]string } // buildValue generic XMLNode builder for any type. Will build value for their specific type // struct, list, map, scalar. // // Also takes a "type" tag value to set what type a value should be converted to XMLNode as. If // type is not provided reflect will be used to determine the value's type. func (b xmlBuilder) buildValue(value reflect.Value, current XMLNode, tag reflect.StructTag) error { value = elemOf(value) if !value.IsValid() { // no need to handle zero values return nil } else if tag.Get("location") != "" { // don't handle non-body location values return nil } xml := tag.Get("xml") if len(xml) != 0 { name := strings.SplitAfterN(xml, ",", 2)[0] if name == "-" { return nil } } t := tag.Get("type") if t == "" { switch value.Kind() { case reflect.Struct: t = "structure" case reflect.Slice: t = "list" case reflect.Map: t = "map" } } switch t { case "structure": if field, ok := value.Type().FieldByName("_"); ok { tag = tag + reflect.StructTag(" ") + field.Tag } return b.buildStruct(value, current, tag) case "list": return b.buildList(value, current, tag) case "map": return b.buildMap(value, current, tag) default: return b.buildScalar(value, current, tag) } } // buildStruct adds a struct and its fields to the current XMLNode. All fields and any nested // types are converted to XMLNodes also. func (b xmlBuilder) buildStruct(value reflect.Value, current XMLNode, tag reflect.StructTag) error { if !value.IsValid() { return nil } // unwrap payloads if payload := tag.Get("payload"); payload != "" { field, _ := value.Type().FieldByName(payload) tag = field.Tag value = elemOf(value.FieldByName(payload)) if !value.IsValid() { return nil } } child := NewXMLElement(xml.Name{Local: tag.Get("locationName")}) // there is an xmlNamespace associated with this struct if prefix, uri := tag.Get("xmlPrefix"), tag.Get("xmlURI"); uri != "" { ns := xml.Attr{ Name: xml.Name{Local: "xmlns"}, Value: uri, } if prefix != "" { b.namespaces[prefix] = uri // register the namespace ns.Name.Local = "xmlns:" + prefix } child.Attr = append(child.Attr, ns) } var payloadFields, nonPayloadFields int t := value.Type() for i := 0; i < value.NumField(); i++ { member := elemOf(value.Field(i)) field := t.Field(i) if field.PkgPath != "" { continue // ignore unexported fields } if field.Tag.Get("ignore") != "" { continue } mTag := field.Tag if mTag.Get("location") != "" { // skip non-body members nonPayloadFields++ continue } payloadFields++ if protocol.CanSetIdempotencyToken(value.Field(i), field) { token := protocol.GetIdempotencyToken() member = reflect.ValueOf(token) } memberName := mTag.Get("locationName") if memberName == "" { memberName = field.Name mTag = reflect.StructTag(string(mTag) + ` locationName:"` + memberName + `"`) } if err := b.buildValue(member, child, mTag); err != nil { return err } } // Only case where the child shape is not added is if the shape only contains // non-payload fields, e.g headers/query. if !(payloadFields == 0 && nonPayloadFields > 0) { current.AddChild(child) } return nil } // buildList adds the value's list items to the current XMLNode as children nodes. All // nested values in the list are converted to XMLNodes also. func (b xmlBuilder) buildList(value reflect.Value, current XMLNode, tag reflect.StructTag) error { if value.IsNil() { // don't build omitted lists return nil } // check for unflattened list member flattened := tag.Get("flattened") != "" xname := xml.Name{Local: tag.Get("locationName")} if flattened { for i := 0; i < value.Len(); i++ { child := NewXMLElement(xname) current.AddChild(child) if err := b.buildValue(value.Index(i), child, ""); err != nil { return err } } } else { list := NewXMLElement(xname) current.AddChild(list) for i := 0; i < value.Len(); i++ { iname := tag.Get("locationNameList") if iname == "" { iname = "member" } child := NewXMLElement(xml.Name{Local: iname}) list.AddChild(child) if err := b.buildValue(value.Index(i), child, ""); err != nil { return err } } } return nil } // buildMap adds the value's key/value pairs to the current XMLNode as children nodes. All // nested values in the map are converted to XMLNodes also. // // Error will be returned if it is unable to build the map's values into XMLNodes func (b xmlBuilder) buildMap(value reflect.Value, current XMLNode, tag reflect.StructTag) error { if value.IsNil() { // don't build omitted maps return nil } maproot := NewXMLElement(xml.Name{Local: tag.Get("locationName")}) current.AddChild(maproot) current = maproot kname, vname := "key", "value" if n := tag.Get("locationNameKey"); n != "" { kname = n } if n := tag.Get("locationNameValue"); n != "" { vname = n } // sorting is not required for compliance, but it makes testing easier keys := make([]string, value.Len()) for i, k := range value.MapKeys() { keys[i] = k.String() } sort.Strings(keys) for _, k := range keys { v := value.MapIndex(reflect.ValueOf(k)) mapcur := current if tag.Get("flattened") == "" { // add "entry" tag to non-flat maps child := NewXMLElement(xml.Name{Local: "entry"}) mapcur.AddChild(child) mapcur = child } kchild := NewXMLElement(xml.Name{Local: kname}) kchild.Text = k vchild := NewXMLElement(xml.Name{Local: vname}) mapcur.AddChild(kchild) mapcur.AddChild(vchild) if err := b.buildValue(v, vchild, ""); err != nil { return err } } return nil } // buildScalar will convert the value into a string and append it as a attribute or child // of the current XMLNode. // // The value will be added as an attribute if tag contains a "xmlAttribute" attribute value. // // Error will be returned if the value type is unsupported. func (b xmlBuilder) buildScalar(value reflect.Value, current *XMLNode, tag reflect.StructTag) error { var str string switch converted := value.Interface().(type) { case string: str = converted case []byte: if !value.IsNil() { str = base64.StdEncoding.EncodeToString(converted) } case bool: str = strconv.FormatBool(converted) case int64: str = strconv.FormatInt(converted, 10) case int: str = strconv.Itoa(converted) case float64: switch { case math.IsNaN(converted): str = floatNaN case math.IsInf(converted, 1): str = floatInf case math.IsInf(converted, -1): str = floatNegInf default: str = strconv.FormatFloat(converted, 'f', -1, 64) } case float32: // The SDK doesn't render float32 values in types, only float64. This case would never be hit currently. asFloat64 := float64(converted) switch { case math.IsNaN(asFloat64): str = floatNaN case math.IsInf(asFloat64, 1): str = floatInf case math.IsInf(asFloat64, -1): str = floatNegInf default: str = strconv.FormatFloat(asFloat64, 'f', -1, 32) } case time.Time: format := tag.Get("timestampFormat") if len(format) == 0 { format = protocol.ISO8601TimeFormatName } str = protocol.FormatTime(format, converted) default: return fmt.Errorf("unsupported value for param %s: %v (%s)", tag.Get("locationName"), value.Interface(), value.Type().Name()) } xname := xml.Name{Local: tag.Get("locationName")} if tag.Get("xmlAttribute") != "" { // put into current node's attribute list attr := xml.Attr{Name: xname, Value: str} current.Attr = append(current.Attr, attr) } else if len(xname.Local) == 0 { current.Text = str } else { // regular text node current.AddChild(&XMLNode{Name: xname, Text: str}) } return nil }	8.77 KB	2025-05-25 12:27
📄 build_test.go //go:build go1.7 // +build go1.7 package xmlutil import ( "bytes" "encoding/xml" "math" "testing" "github.com/aws/aws-sdk-go/aws" ) type implicitPayload struct { _ struct{} `type:"structure"` StrVal string `type:"string"` FloatVal float64 `type:"double"` Second nestedType `type:"structure"` Third nestedType `type:"structure"` } type namedImplicitPayload struct { _ struct{} `type:"structure" locationName:"namedPayload"` StrVal string `type:"string"` Second nestedType `type:"structure"` Third nestedType `type:"structure"` } type explicitPayload struct { _ struct{} `type:"structure" payload:"Second"` Second nestedType `type:"structure" locationName:"Second"` } type useEmptyNested struct { _ struct{} `type:"structure" locationName:"useEmptyNested"` StrVal string `type:"string"` Empty emptyType `type:"structure"` } type useIgnoreNested struct { _ struct{} `type:"structure" locationName:"useIgnoreNested"` StrVal string `type:"string"` Ignore ignoreNested `type:"structure"` } type skipNonPayload struct { _ struct{} `type:"structure" locationName:"skipNonPayload"` Field string `type:"string" location:"header"` } type namedEmptyPayload struct { _ struct{} `type:"structure" locationName:"namedEmptyPayload"` } type nestedType struct { _ struct{} `type:"structure"` IntVal int64 `type:"integer"` StrVal string `type:"string"` } type emptyType struct { _ struct{} `type:"structure"` } type ignoreNested struct { _ struct{} `type:"structure"` IgnoreMe string `type:"string" ignore:"true"` } func TestBuildXML(t testing.T) { cases := map[string]struct { Input interface{} Expect string }{ "explicit payload": { Input: &explicitPayload{ Second: &nestedType{ IntVal: aws.Int64(1234), StrVal: aws.String("string value"), }, }, Expect: `<Second><IntVal>1234</IntVal><StrVal>string value</StrVal></Second>`, }, "implicit payload": { Input: &implicitPayload{ StrVal: aws.String("string value"), Second: &nestedType{ IntVal: aws.Int64(1111), StrVal: aws.String("second string"), }, Third: &nestedType{ IntVal: aws.Int64(2222), StrVal: aws.String("third string"), }, }, Expect: `<Second><IntVal>1111</IntVal><StrVal>second string</StrVal></Second><StrVal>string value</StrVal><Third><IntVal>2222</IntVal><StrVal>third string</StrVal></Third>`, }, "named implicit payload": { Input: &namedImplicitPayload{ StrVal: aws.String("string value"), Second: &nestedType{ IntVal: aws.Int64(1111), StrVal: aws.String("second string"), }, Third: &nestedType{ IntVal: aws.Int64(2222), StrVal: aws.String("third string"), }, }, Expect: `<namedPayload><Second><IntVal>1111</IntVal><StrVal>second string</StrVal></Second><StrVal>string value</StrVal><Third><IntVal>2222</IntVal><StrVal>third string</StrVal></Third></namedPayload>`, }, "empty with fields nested type": { Input: &namedImplicitPayload{ StrVal: aws.String("string value"), Second: &nestedType{}, Third: &nestedType{ IntVal: aws.Int64(2222), StrVal: aws.String("third string"), }, }, Expect: `<namedPayload><Second></Second><StrVal>string value</StrVal><Third><IntVal>2222</IntVal><StrVal>third string</StrVal></Third></namedPayload>`, }, "empty no fields nested type": { Input: &useEmptyNested{ StrVal: aws.String("string value"), Empty: &emptyType{}, }, Expect: `<useEmptyNested><Empty></Empty><StrVal>string value</StrVal></useEmptyNested>`, }, "ignored nested field": { Input: &useIgnoreNested{ StrVal: aws.String("string value"), Ignore: &ignoreNested{ IgnoreMe: aws.String("abc123"), }, }, Expect: `<useIgnoreNested><Ignore></Ignore><StrVal>string value</StrVal></useIgnoreNested>`, }, "skip non payload root": { Input: &skipNonPayload{ Field: aws.String("value"), }, Expect: "", }, "skip empty root": { Input: &emptyType{}, Expect: "", }, "named empty payload": { Input: &namedEmptyPayload{}, Expect: "<namedEmptyPayload></namedEmptyPayload>", }, "escape line feed and carriage return": { Input: &implicitPayload{ StrVal: aws.String("this\nstring\rhas\r\nescapable\n\rcharacters"), }, Expect: "<StrVal>this string has escapable characters</StrVal>", }, "float value": { Input: &implicitPayload{ FloatVal: aws.Float64(123456789.123), }, Expect: "<FloatVal>123456789.123</FloatVal>", }, "infinity float value": { Input: &implicitPayload{ FloatVal: aws.Float64(math.Inf(1)), }, Expect: "<FloatVal>Infinity</FloatVal>", }, "negative infinity float value": { Input: &implicitPayload{ FloatVal: aws.Float64(math.Inf(-1)), }, Expect: "<FloatVal>-Infinity</FloatVal>", }, "NaN float value": { Input: &implicitPayload{ FloatVal: aws.Float64(math.NaN()), }, Expect: "<FloatVal>NaN</FloatVal>", }, } for name, c := range cases { t.Run(name, func(t testing.T) { var w bytes.Buffer if err := buildXML(c.Input, xml.NewEncoder(&w), true); err != nil { t.Fatalf("expect no error, %v", err) } if e, a := c.Expect, w.String(); e != a { t.Errorf("expect:\n%s\nactual:\n%s\n", e, a) } }) } }	5.23 KB	2025-05-25 12:27
📄 sort.go package xmlutil import ( "encoding/xml" "strings" ) type xmlAttrSlice []xml.Attr func (x xmlAttrSlice) Len() int { return len(x) } func (x xmlAttrSlice) Less(i, j int) bool { spaceI, spaceJ := x[i].Name.Space, x[j].Name.Space localI, localJ := x[i].Name.Local, x[j].Name.Local valueI, valueJ := x[i].Value, x[j].Value spaceCmp := strings.Compare(spaceI, spaceJ) localCmp := strings.Compare(localI, localJ) valueCmp := strings.Compare(valueI, valueJ) if spaceCmp == -1 \|\| (spaceCmp == 0 && (localCmp == -1 \|\| (localCmp == 0 && valueCmp == -1))) { return true } return false } func (x xmlAttrSlice) Swap(i, j int) { x[i], x[j] = x[j], x[i] }	663 B	2025-05-25 12:27
📄 sort_test.go package xmlutil import ( "encoding/xml" "reflect" "sort" "testing" ) func TestXmlAttrSlice(t *testing.T) { tests := []struct { input []xml.Attr expected []xml.Attr }{ { input: []xml.Attr{}, expected: []xml.Attr{}, }, { input: []xml.Attr{ { Name: xml.Name{ Space: "foo", Local: "bar", }, Value: "baz", }, { Name: xml.Name{ Space: "foo", Local: "baz", }, Value: "bar", }, { Name: xml.Name{ Space: "foo", Local: "bar", }, Value: "bar", }, { Name: xml.Name{ Space: "baz", Local: "bar", }, Value: "foo", }, }, expected: []xml.Attr{ { Name: xml.Name{ Space: "baz", Local: "bar", }, Value: "foo", }, { Name: xml.Name{ Space: "foo", Local: "bar", }, Value: "bar", }, { Name: xml.Name{ Space: "foo", Local: "bar", }, Value: "baz", }, { Name: xml.Name{ Space: "foo", Local: "baz", }, Value: "bar", }, }, }, } for i, tt := range tests { sort.Sort(xmlAttrSlice(tt.input)) if e, a := tt.expected, tt.input; !reflect.DeepEqual(e, a) { t.Errorf("case %d expected %v, got %v", i, e, a) } } }	1.28 KB	2025-05-25 12:27
📄 unmarshal.go package xmlutil import ( "bytes" "encoding/base64" "encoding/xml" "fmt" "io" "math" "reflect" "strconv" "strings" "time" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/private/protocol" ) // UnmarshalXMLError unmarshals the XML error from the stream into the value // type specified. The value must be a pointer. If the message fails to // unmarshal, the message content will be included in the returned error as a // awserr.UnmarshalError. func UnmarshalXMLError(v interface{}, stream io.Reader) error { var errBuf bytes.Buffer body := io.TeeReader(stream, &errBuf) err := xml.NewDecoder(body).Decode(v) if err != nil && err != io.EOF { return awserr.NewUnmarshalError(err, "failed to unmarshal error message", errBuf.Bytes()) } return nil } // UnmarshalXML deserializes an xml.Decoder into the container v. V // needs to match the shape of the XML expected to be decoded. // If the shape doesn't match unmarshaling will fail. func UnmarshalXML(v interface{}, d xml.Decoder, wrapper string) error { n, err := XMLToStruct(d, nil) if err != nil { return err } if n.Children != nil { for _, root := range n.Children { for _, c := range root { if wrappedChild, ok := c.Children[wrapper]; ok { c = wrappedChild[0] // pull out wrapped element } err = parse(reflect.ValueOf(v), c, "") if err != nil { if err == io.EOF { return nil } return err } } } return nil } return nil } // parse deserializes any value from the XMLNode. The type tag is used to infer the type, or reflect // will be used to determine the type from r. func parse(r reflect.Value, node XMLNode, tag reflect.StructTag) error { xml := tag.Get("xml") if len(xml) != 0 { name := strings.SplitAfterN(xml, ",", 2)[0] if name == "-" { return nil } } rtype := r.Type() if rtype.Kind() == reflect.Ptr { rtype = rtype.Elem() // check kind of actual element type } t := tag.Get("type") if t == "" { switch rtype.Kind() { case reflect.Struct: // also it can't be a time object if _, ok := r.Interface().(time.Time); !ok { t = "structure" } case reflect.Slice: // also it can't be a byte slice if _, ok := r.Interface().([]byte); !ok { t = "list" } case reflect.Map: t = "map" } } switch t { case "structure": if field, ok := rtype.FieldByName("_"); ok { tag = field.Tag } return parseStruct(r, node, tag) case "list": return parseList(r, node, tag) case "map": return parseMap(r, node, tag) default: return parseScalar(r, node, tag) } } // parseStruct deserializes a structure and its fields from an XMLNode. Any nested // types in the structure will also be deserialized. func parseStruct(r reflect.Value, node XMLNode, tag reflect.StructTag) error { t := r.Type() if r.Kind() == reflect.Ptr { if r.IsNil() { // create the structure if it's nil s := reflect.New(r.Type().Elem()) r.Set(s) r = s } r = r.Elem() t = t.Elem() } // unwrap any payloads if payload := tag.Get("payload"); payload != "" { field, _ := t.FieldByName(payload) return parseStruct(r.FieldByName(payload), node, field.Tag) } for i := 0; i < t.NumField(); i++ { field := t.Field(i) if c := field.Name[0:1]; strings.ToLower(c) == c { continue // ignore unexported fields } // figure out what this field is called name := field.Name if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" { name = field.Tag.Get("locationNameList") } else if locName := field.Tag.Get("locationName"); locName != "" { name = locName } // try to find the field by name in elements elems := node.Children[name] if elems == nil { // try to find the field in attributes if val, ok := node.findElem(name); ok { elems = []XMLNode{{Text: val}} } } member := r.FieldByName(field.Name) for _, elem := range elems { err := parse(member, elem, field.Tag) if err != nil { return err } } } return nil } // parseList deserializes a list of values from an XML node. Each list entry // will also be deserialized. func parseList(r reflect.Value, node XMLNode, tag reflect.StructTag) error { t := r.Type() if tag.Get("flattened") == "" { // look at all item entries mname := "member" if name := tag.Get("locationNameList"); name != "" { mname = name } if Children, ok := node.Children[mname]; ok { if r.IsNil() { r.Set(reflect.MakeSlice(t, len(Children), len(Children))) } for i, c := range Children { err := parse(r.Index(i), c, "") if err != nil { return err } } } } else { // flattened list means this is a single element if r.IsNil() { r.Set(reflect.MakeSlice(t, 0, 0)) } childR := reflect.Zero(t.Elem()) r.Set(reflect.Append(r, childR)) err := parse(r.Index(r.Len()-1), node, "") if err != nil { return err } } return nil } // parseMap deserializes a map from an XMLNode. The direct children of the XMLNode // will also be deserialized as map entries. func parseMap(r reflect.Value, node XMLNode, tag reflect.StructTag) error { if r.IsNil() { r.Set(reflect.MakeMap(r.Type())) } if tag.Get("flattened") == "" { // look at all child entries for _, entry := range node.Children["entry"] { parseMapEntry(r, entry, tag) } } else { // this element is itself an entry parseMapEntry(r, node, tag) } return nil } // parseMapEntry deserializes a map entry from a XML node. func parseMapEntry(r reflect.Value, node XMLNode, tag reflect.StructTag) error { kname, vname := "key", "value" if n := tag.Get("locationNameKey"); n != "" { kname = n } if n := tag.Get("locationNameValue"); n != "" { vname = n } keys, ok := node.Children[kname] values := node.Children[vname] if ok { for i, key := range keys { keyR := reflect.ValueOf(key.Text) value := values[i] valueR := reflect.New(r.Type().Elem()).Elem() parse(valueR, value, "") r.SetMapIndex(keyR, valueR) } } return nil } // parseScaller deserializes an XMLNode value into a concrete type based on the // interface type of r. // // Error is returned if the deserialization fails due to invalid type conversion, // or unsupported interface type. func parseScalar(r reflect.Value, node XMLNode, tag reflect.StructTag) error { switch r.Interface().(type) { case string: r.Set(reflect.ValueOf(&node.Text)) return nil case []byte: b, err := base64.StdEncoding.DecodeString(node.Text) if err != nil { return err } r.Set(reflect.ValueOf(b)) case bool: v, err := strconv.ParseBool(node.Text) if err != nil { return err } r.Set(reflect.ValueOf(&v)) case int64: v, err := strconv.ParseInt(node.Text, 10, 64) if err != nil { return err } r.Set(reflect.ValueOf(&v)) case float64: var v float64 switch { case strings.EqualFold(node.Text, floatNaN): v = math.NaN() case strings.EqualFold(node.Text, floatInf): v = math.Inf(1) case strings.EqualFold(node.Text, floatNegInf): v = math.Inf(-1) default: var err error v, err = strconv.ParseFloat(node.Text, 64) if err != nil { return err } } r.Set(reflect.ValueOf(&v)) case time.Time: format := tag.Get("timestampFormat") if len(format) == 0 { format = protocol.ISO8601TimeFormatName } t, err := protocol.ParseTime(format, node.Text) if err != nil { return err } r.Set(reflect.ValueOf(&t)) default: return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type()) } return nil }	7.35 KB	2025-05-25 12:27
📄 unmarshal_test.go //go:build go1.7 // +build go1.7 package xmlutil import ( "encoding/xml" "fmt" "io" "math" "reflect" "strconv" "strings" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awsutil" ) type mockBody struct { DoneErr error Body io.Reader } func (m mockBody) Read(p []byte) (int, error) { n, err := m.Body.Read(p) if (n == 0 \|\| err == io.EOF) && m.DoneErr != nil { return n, m.DoneErr } return n, err } type mockOutput struct { _ struct{} `type:"structure"` String string `type:"string"` Integer int64 `type:"integer"` Float float64 `type:"double"` Nested mockNestedStruct `type:"structure"` List []mockListElem `locationName:"List" locationNameList:"Elem" type:"list"` Closed mockClosedTags `type:"structure"` } type mockNestedStruct struct { _ struct{} `type:"structure"` NestedString string `type:"string"` NestedInt int64 `type:"integer"` } type mockClosedTags struct { _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` Attr string `locationName:"xsi:attrval" type:"string" xmlAttribute:"true"` } type mockListElem struct { _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` String string `type:"string"` NestedElem mockNestedListElem `type:"structure"` } type mockNestedListElem struct { _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` String string `type:"string"` Type string `locationName:"xsi:type" type:"string" xmlAttribute:"true"` } func TestUnmarshal(t testing.T) { cases := []struct { Body string Expect mockOutput ExpectFn func(t testing.T, actual mockOutput) }{ { Body: `<?xml version="1.0" encoding="UTF-8"?> <MockResponse xmlns="http://xmlns.example.com"> <String>string value</String> <Integer>123</Integer> <Closed xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:attrval="attr value"/> <Nested> <NestedString>nested string value</NestedString> <NestedInt>321</NestedInt> </Nested> <List> <Elem> <NestedElem xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type"> <String>nested elem string value</String> </NestedElem> <String>elem string value</String> </Elem> </List> </MockResponse>`, Expect: mockOutput{ String: aws.String("string value"), Integer: aws.Int64(123), Closed: &mockClosedTags{ Attr: aws.String("attr value"), }, Nested: &mockNestedStruct{ NestedString: aws.String("nested string value"), NestedInt: aws.Int64(321), }, List: []mockListElem{ { String: aws.String("elem string value"), NestedElem: &mockNestedListElem{ String: aws.String("nested elem string value"), Type: aws.String("type"), }, }, }, }, }, { Body: `<?xml version="1.0" encoding="UTF-8"?><MockResponse xmlns="http://xmlns.example.com"><Float>123456789.123</Float></MockResponse>`, Expect: mockOutput{Float: aws.Float64(123456789.123)}, }, { Body: `<?xml version="1.0" encoding="UTF-8"?><MockResponse xmlns="http://xmlns.example.com"><Float>Infinity</Float></MockResponse>`, ExpectFn: func(t testing.T, actual mockOutput) { if a := aws.Float64Value(actual.Float); !math.IsInf(a, 1) { t.Errorf("expect infinity, got %v", a) } }, }, { Body: `<?xml version="1.0" encoding="UTF-8"?><MockResponse xmlns="http://xmlns.example.com"><Float>-Infinity</Float></MockResponse>`, ExpectFn: func(t testing.T, actual mockOutput) { if a := aws.Float64Value(actual.Float); !math.IsInf(a, -1) { t.Errorf("expect -infinity, got %v", a) } }, }, { Body: `<?xml version="1.0" encoding="UTF-8"?><MockResponse xmlns="http://xmlns.example.com"><Float>NaN</Float></MockResponse>`, ExpectFn: func(t testing.T, actual mockOutput) { if a := aws.Float64Value(actual.Float); !math.IsNaN(a) { t.Errorf("expect NaN, got %v", a) } }, }, } for i, tt := range cases { t.Run(strconv.Itoa(i), func(t testing.T) { actual := mockOutput{} decoder := xml.NewDecoder(strings.NewReader(tt.Body)) err := UnmarshalXML(&actual, decoder, "") if err != nil { t.Fatalf("expect no error, got %v", err) } if tt.ExpectFn != nil { tt.ExpectFn(t, actual) return } if !reflect.DeepEqual(tt.Expect, actual) { t.Errorf("expect unmarshal to match\nExpect: %s\nActual: %s", awsutil.Prettify(tt.Expect), awsutil.Prettify(actual)) } }) } } func TestUnmarshal_UnexpectedEOF(t testing.T) { const partialXMLBody = `<?xml version="1.0" encoding="UTF-8"?> <First>first value</First> <Second>Second val` out := struct { First string `locationName:"First" type:"string"` Second string `locationName:"Second" type:"string"` }{} expect := out expect.First = aws.String("first") expect.Second = aws.String("second") expectErr := fmt.Errorf("expected read error") body := &mockBody{ DoneErr: expectErr, Body: strings.NewReader(partialXMLBody), } decoder := xml.NewDecoder(body) err := UnmarshalXML(&out, decoder, "") if err == nil { t.Fatalf("expect error, got none") } if e, a := expectErr, err; e != a { t.Errorf("expect %v error in %v, but was not", e, a) } }	5.28 KB	2025-05-25 12:27
📄 xml_to_struct.go package xmlutil import ( "encoding/xml" "fmt" "io" "sort" ) // A XMLNode contains the values to be encoded or decoded. type XMLNode struct { Name xml.Name `json:",omitempty"` Children map[string][]XMLNode `json:",omitempty"` Text string `json:",omitempty"` Attr []xml.Attr `json:",omitempty"` namespaces map[string]string parent XMLNode } // textEncoder is a string type alias that implemnts the TextMarshaler interface. // This alias type is used to ensure that the line feed (\n) (U+000A) is escaped. type textEncoder string func (t textEncoder) MarshalText() ([]byte, error) { return []byte(t), nil } // NewXMLElement returns a pointer to a new XMLNode initialized to default values. func NewXMLElement(name xml.Name) XMLNode { return &XMLNode{ Name: name, Children: map[string][]XMLNode{}, Attr: []xml.Attr{}, } } // AddChild adds child to the XMLNode. func (n XMLNode) AddChild(child XMLNode) { child.parent = n if _, ok := n.Children[child.Name.Local]; !ok { n.Children[child.Name.Local] = []XMLNode{} } n.Children[child.Name.Local] = append(n.Children[child.Name.Local], child) } // XMLToStruct converts a xml.Decoder stream to XMLNode with nested values. func XMLToStruct(d xml.Decoder, s xml.StartElement) (XMLNode, error) { out := &XMLNode{} for { tok, err := d.Token() if err != nil { if err == io.EOF { break } else { return out, err } } if tok == nil { break } switch typed := tok.(type) { case xml.CharData: out.Text = string(typed.Copy()) case xml.StartElement: el := typed.Copy() out.Attr = el.Attr if out.Children == nil { out.Children = map[string][]XMLNode{} } name := typed.Name.Local slice := out.Children[name] if slice == nil { slice = []XMLNode{} } node, e := XMLToStruct(d, &el) out.findNamespaces() if e != nil { return out, e } node.Name = typed.Name node.findNamespaces() tempOut := out // Save into a temp variable, simply because out gets squashed during // loop iterations node.parent = &tempOut slice = append(slice, node) out.Children[name] = slice case xml.EndElement: if s != nil && s.Name.Local == typed.Name.Local { // matching end token return out, nil } out = &XMLNode{} } } return out, nil } func (n XMLNode) findNamespaces() { ns := map[string]string{} for _, a := range n.Attr { if a.Name.Space == "xmlns" { ns[a.Value] = a.Name.Local } } n.namespaces = ns } func (n XMLNode) findElem(name string) (string, bool) { for node := n; node != nil; node = node.parent { for _, a := range node.Attr { namespace := a.Name.Space if v, ok := node.namespaces[namespace]; ok { namespace = v } if name == fmt.Sprintf("%s:%s", namespace, a.Name.Local) { return a.Value, true } } } return "", false } // StructToXML writes an XMLNode to a xml.Encoder as tokens. func StructToXML(e xml.Encoder, node *XMLNode, sorted bool) error { // Sort Attributes attrs := node.Attr if sorted { sortedAttrs := make([]xml.Attr, len(attrs)) for _, k := range node.Attr { sortedAttrs = append(sortedAttrs, k) } sort.Sort(xmlAttrSlice(sortedAttrs)) attrs = sortedAttrs } startElement := xml.StartElement{Name: node.Name, Attr: attrs} if node.Text != "" { e.EncodeElement(textEncoder(node.Text), startElement) return e.Flush() } e.EncodeToken(startElement) if sorted { sortedNames := []string{} for k := range node.Children { sortedNames = append(sortedNames, k) } sort.Strings(sortedNames) for _, k := range sortedNames { for _, v := range node.Children[k] { StructToXML(e, v, sorted) } } } else { for _, c := range node.Children { for _, v := range c { StructToXML(e, v, sorted) } } } e.EncodeToken(startElement.End()) return e.Flush() }	3.82 KB	2025-05-25 12:27

Terminal