Test code with and without xml tags for xmlns QName Input/Output

xmltags_test.go

package xmltags

import (
	"encoding/xml"
	"fmt"
	"testing"
)

// Plain type is used for initialization
type Plain struct {
	XMLName xml.Name `xml:"http://some/basic/namespace/Plain Document"`
	Plain   string   `xml:"plain,attr"`
	Heads   string   `xml:"heads:attr"`
	Addr    string   `xml:"adds:attr"`
	Smthg   string   `xml:"smthg:attr"`
	Header  struct {
		Address struct {
			Name     string
			Location string
		}
		SomethingOther string
		SomethingElse  string
	}
	Body struct {
		Data string
	}
}

// Plain type is used for initialization
type PlainFail struct {
	XMLName xml.Name `xml:"http://some/basic/namespace/Plain Document"`
	Plain   string   `xml:"plain,attr"`
	Heads   string   `xml:"heads:attr"`
	Addr    string   `xml:"adds:attr"`
	Smthg   string   `xml:"smthg:attr"`
	Header  struct {
		Address struct {
			Name     string
			Location string
		}
		SomethingOther string
		SomethingElse  string
	}
	Body struct {
		Data string `xml:",innerxml"`
	}
}

// Body initializes Plain.Body
type Body struct {
	Data string
}

// Address is used to initialize Plain.Header.Address
type Address struct {
	Name     string
	Location string
}

// Header can write to Plain.Header
type Header struct {
	Address struct {
		Name     string
		Location string
	}
	SomethingOther string
	SomethingElse  string
}

// PlainIn is able to read xml input
type PlainIn struct {
	XMLName xml.Name `xml:"http://some/basic/namespace/Plain Document"`
	Plain   string   `xml:"plain,attr"`
	Heads   string   `xml:"heads,attr"`
	Addr    string   `xml:"addr,attr"`
	Smthg   string   `xml:"smthg,attr"`
	Header  struct {
		Address struct {
			Name     string
			Location string
		} `xml:"http://some/namespace/for/addresses Address"`
		SomethingOther string `xml:"http://just/something Other"`
		SomethingElse  string `xml:"http://just/something Else"`
	} `xml:"http://A/namespace/for/Headers Header"`
	Body struct {
		Data string `xml:",innerxml"`
	} `xml:"http://some/basic/namespace/Plain Body"`
}

const (
	XmlnsPlain = "http://some/basic/namespace/Plain"
	XmlnsHeads = "http://A/namespace/for/Headers"
	XmlnsAddr  = "http://some/namespace/for/addresses"
	XmlnsSmthg = "http://just/something"
)

// PlainOut adds xmlns QNames to the elements
type PlainOut struct {
	XMLName xml.Name `xml:"plain:Document"`
	Plain   string   `xml:"xmlns:plain,attr"`
	Heads   string   `xml:"xmlns:heads,attr"`
	Addr    string   `xml:"xmlns:addr,attr"`
	Smthg   string   `xml:"xmlns:smthg,attr"`
	Header  struct {
		Address struct {
			Name     string `xml:"addr:Name"`
			Location string `xml:"addr:Location"`
		} `xml:"addr:Address"`
		SomethingOther string `xml:"smthg:Other"`
		SomethingElse  string `xml:"smthg:Else"`
	} `xml:"heads:Header"`
	Body struct {
		Data string `xml:",innerxml"`
	} `xml:"plain:Body"`
}

func TestXmlInOut(_ *testing.T) {
	dataout := PlainOut(Plain{
		Plain: XmlnsPlain, Heads: XmlnsHeads, Addr: XmlnsAddr, Smthg: XmlnsSmthg, // namespace attributes
		Header: Header{
			Address: Address{
				Name:     "I was",
				Location: "here",
			},
			SomethingOther: "just doing something",
			SomethingElse:  "else",
		},
		Body: Body{
			Data: "<Success/>",
		},
	})

	out, err := xml.MarshalIndent(&dataout, "    ", "    ")
	if err != nil {
		fmt.Printf("Dataout Marshal failed:%s", err.Error())
	}
	fmt.Println(string(out))

	datain := PlainIn{}
	err = xml.Unmarshal(out, &datain)
	if err != nil {
		fmt.Printf("Unmarshal into Datain failed:%s", err.Error())
	}

	out, err = xml.MarshalIndent(&datain, "    ", "    ")
	if err != nil {
		fmt.Printf("Remarshal Datain failed:%s", err.Error())
	}
	fmt.Println(string(out))

	dataout = PlainOut(datain)
	//	dataout.FromInput(datain)
	// Output: XML Fails!
}

See this code fail if you replace Plain with PlainFail on line 118

dataout := PlainOut(PlainFail{