xml_test.go

Documentation: github.com/clbanning/mxj/v2

     1  package mxj
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io"
     7  	"reflect"
     8  	"testing"
     9  )
    10  
    11  func TestXmlHeader(t *testing.T) {
    12  	fmt.Println("\n----------------  xml_test.go ...")
    13  }
    14  
    15  func TestNewMapXml(t *testing.T) {
    16  	x := []byte(`<root2><newtag newattr="some_attr_value">something more</newtag><list listattr="val"><item>1</item><item>2</item></list></root2>`)
    17  
    18  	mv, merr := NewMapXml(x)
    19  	if merr != nil {
    20  		t.Fatal("merr:", merr.Error())
    21  	}
    22  
    23  	want := Map{"root2":
    24  		map[string]interface{}{
    25  			"newtag":
    26  				map[string]interface{}{"-newattr": "some_attr_value", textK:"something more"},
    27  			"list":
    28  				map[string]interface{}{"-listattr":"val", "item":[]interface{}{"1", "2"}},
    29  		}}
    30  	if !reflect.DeepEqual(mv, want) {
    31  		fmt.Println("NewMapXml, x :", string(x))
    32  		fmt.Printf("NewMapXml, mv  : %#v\n", mv)
    33  		fmt.Printf("NewMapXml, want: %#v\n", want)
    34  		t.Fatal("not DeepEqual")
    35  	}
    36  }
    37  
    38  func TestAttrHyphenFalse(t *testing.T) {
    39  	PrependAttrWithHyphen(false)
    40  	defer PrependAttrWithHyphen(true)
    41  	x := []byte(`<root2><newtag newattr="some_attr_value">something more</newtag><list listattr="val"><item>1</item><item>2</item></list></root2>`)
    42  
    43  	mv, merr := NewMapXml(x)
    44  	if merr != nil {
    45  		t.Fatal("merr:", merr.Error())
    46  	}
    47  
    48  	want := Map{"root2":
    49  		map[string]interface{}{
    50  			"newtag":
    51  				map[string]interface{}{"newattr": "some_attr_value", textK:"something more"},
    52  			"list":
    53  				map[string]interface{}{"listattr":"val", "item":[]interface{}{"1", "2"}},
    54  		}}
    55  	if !reflect.DeepEqual(mv, want) {
    56  		fmt.Println("AttrHyphenFalse, x :", string(x))
    57  		fmt.Printf("AttrHyphenFalse, mv  : %#v\n", mv)
    58  		fmt.Printf("AttrHyphenFalse, want: %#v\n", want)
    59  		t.Fatal("not DeepEqual")
    60  	}
    61  }
    62  
    63  func TestNewMapXmlError(t *testing.T) {
    64  	x := []byte(`<root2><newtag>something more</newtag><list><item>1</item><item>2</item></list>`)
    65  
    66  	m, merr := NewMapJson(x)
    67  	if merr == nil {
    68  		t.Fatal("NewMapXmlError, m:", m)
    69  	}
    70  
    71  	want := `invalid character '<' looking for beginning of value`
    72  	if merr != nil && merr.Error() != want {
    73  		fmt.Println("NewMapXmlError, x   :", string(x))
    74  		fmt.Println("NewMapXmlError, merr:", merr.Error())
    75  		fmt.Println("NewMapXmlError, want:", want)
    76  	}
    77  }
    78  
    79  func TestNewMapXmlReader(t *testing.T) {
    80  	fmt.Println("\n==================== TestNewMapXmlReader ...")
    81  	x := []byte(`<root><this>is a test</this></root><root2><newtag>something more</newtag><list><item>1</item><item>2</item></list></root2>`)
    82  
    83  	r := bytes.NewReader(x)
    84  
    85  	for {
    86  		m, raw, err := NewMapXmlReaderRaw(r)
    87  		if err != nil && err != io.EOF {
    88  			t.Fatal("err:", err.Error())
    89  		}
    90  		if err == io.EOF && len(m) == 0 {
    91  			break
    92  		}
    93  		fmt.Println("NewMapXmlReader, raw:", string(raw))
    94  		fmt.Println("NewMapXmlReader, m  :", m)
    95  	}
    96  }
    97  
    98  // ---------------------  Xml() and XmlWriter() test cases -------------------
    99  
   100  func TestXml_1(t *testing.T) {
   101  	mv := Map{"tag1": "some data", "tag2": "more data", "boolean": true, "float": 3.14159625, "null": nil}
   102  
   103  	x, err := mv.Xml()
   104  	if err != nil {
   105  		t.Fatal("err:", err.Error())
   106  	}
   107  
   108  	fmt.Println("Xml_1, mv:", mv)
   109  	fmt.Println("Xml_1, x :", string(x))
   110  }
   111  
   112  func TestXml_2(t *testing.T) {
   113  	a := []interface{}{"string", true, 36.4}
   114  	mv := Map{"array": a}
   115  
   116  	x, err := mv.Xml()
   117  	if err != nil {
   118  		t.Fatal("err:", err.Error())
   119  	}
   120  
   121  	fmt.Println("Xml_2, mv:", mv)
   122  	fmt.Println("Xml_2, x :", string(x))
   123  }
   124  
   125  func TestXml_3(t *testing.T) {
   126  	a := []interface{}{"string", true, 36.4}
   127  	mv := Map{"array": []interface{}{a, "string2"}}
   128  
   129  	x, err := mv.Xml()
   130  	if err != nil {
   131  		t.Fatal("err:", err.Error())
   132  	}
   133  
   134  	fmt.Println("Xml_3, mv:", mv)
   135  	fmt.Println("Xml_3, x :", string(x))
   136  }
   137  
   138  func TestXml_4(t *testing.T) {
   139  	a := []interface{}{"string", true, 36.4}
   140  	mv := Map{"array": map[string]interface{}{"innerkey": []interface{}{a, "string2"}}}
   141  
   142  	x, err := mv.Xml()
   143  	if err != nil {
   144  		t.Fatal("err:", err.Error())
   145  	}
   146  
   147  	fmt.Println("Xml_4, mv:", mv)
   148  	fmt.Println("Xml_4, x :", string(x))
   149  }
   150  
   151  func TestXml_5(t *testing.T) {
   152  	a := []interface{}{"string", true, 36.4}
   153  	mv := Map{"array": []interface{}{map[string]interface{}{"innerkey": []interface{}{a, "string2"}}, map[string]interface{}{"some": "more"}}}
   154  
   155  	x, err := mv.Xml()
   156  	if err != nil {
   157  		t.Fatal("err:", err.Error())
   158  	}
   159  
   160  	fmt.Println("Xml_5, mv:", mv)
   161  	fmt.Println("Xml_5, x :", string(x))
   162  }
   163  
   164  
   165  func TestXml_Strings(t *testing.T) {
   166  	mv := Map{"sometag": "some data", "strings": []string{"string1", "string2"}}
   167  
   168  	x, err := mv.Xml()
   169  	if err != nil {
   170  		t.Fatal("err:", err.Error())
   171  	}
   172  
   173  	fmt.Println("Xml_strings, mv:", mv)
   174  	fmt.Println("Xml_strings, x :", string(x))
   175  }
   176  
   177  
   178  func TestXmlWriter(t *testing.T) {
   179  	mv := Map{"tag1": "some data", "tag2": "more data", "boolean": true, "float": 3.14159625}
   180  	w := new(bytes.Buffer)
   181  
   182  	err := mv.XmlWriter(w, "myRootTag")
   183  	if err != nil {
   184  		t.Fatal("err:", err.Error())
   185  	}
   186  
   187  	b := make([]byte, w.Len())
   188  	_, err = w.Read(b)
   189  	if err != nil {
   190  		t.Fatal("err:", err.Error())
   191  	}
   192  
   193  	fmt.Println("XmlWriter, b  :", string(b))
   194  }
   195  
   196  
   197  // --------------------------  XML Handler test cases -------------------------
   198  
   199  /* tested in bulk_test.go ...
   200  var xhdata = []byte(`<root><this>is a test</this></root><root2><newtag>something more</newtag><list><item>1</item><item>2</item></list></root2><root3><tag></root3>`)
   201  
   202  func TestHandleXmlReader(t *testing.T) {
   203  	fmt.Println("HandleXmlReader:", string(xhdata))
   204  
   205  	rdr := bytes.NewReader(xhdata)
   206  	err := HandleXmlReader(rdr, xmhandler, xehandler)
   207  	if err != nil {
   208  		t.Fatal("err:", err.Error())
   209  	}
   210  }
   211  
   212  var xt *testing.T
   213  
   214  func xmhandler(m Map, raw []byte) bool {
   215  	x, xerr := m.Xml()
   216  	if xerr != nil {
   217  		xt.Fatal("... xmhandler:", xerr.Error())
   218  		return false
   219  	}
   220  
   221  	fmt.Println("... xmhandler, raw:", string(raw))
   222  	fmt.Println("... xmhandler, x  :", string(x))
   223  	return true
   224  }
   225  
   226  func xehandler(err error, raw []byte) bool {
   227  	if err == nil {
   228  		// shouldn't be here
   229  		xt.Fatal("... xehandler: <nil>")
   230  		return false
   231  	}
   232  	if err == io.EOF {
   233  		return true
   234  	}
   235  
   236  	fmt.Println("... xehandler raw:", string(raw))
   237  	fmt.Println("... xehandler err:", err.Error())
   238  	return true
   239  }
   240  */
   241
View as plain text