github.com/wangyougui/gf/v2@v2.6.5/text/gstr/gstr_z_unit_parse_test.go (about)

     1  // Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
     2  //
     3  // This Source Code Form is subject to the terms of the MIT License.
     4  // If a copy of the MIT was not distributed with this file,
     5  // You can obtain one at https://github.com/wangyougui/gf.
     6  
     7  // go test *.go -bench=".*"
     8  
     9  package gstr_test
    10  
    11  import (
    12  	"net/url"
    13  	"testing"
    14  
    15  	"github.com/wangyougui/gf/v2/frame/g"
    16  	"github.com/wangyougui/gf/v2/test/gtest"
    17  	"github.com/wangyougui/gf/v2/text/gstr"
    18  )
    19  
    20  func Test_Parse(t *testing.T) {
    21  	// cover test
    22  	gtest.C(t, func(t *gtest.T) {
    23  		// empty
    24  		m, err := gstr.Parse("")
    25  		t.AssertNil(err)
    26  		t.Assert(m, nil)
    27  		// invalid
    28  		m, err = gstr.Parse("a&b")
    29  		t.AssertNil(err)
    30  		t.Assert(m, make(map[string]interface{}))
    31  		// special key
    32  		m, err = gstr.Parse(" =1& b=2&   c =3")
    33  		t.AssertNil(err)
    34  		t.Assert(m, map[string]interface{}{"b": "2", "c_": "3"})
    35  		m, err = gstr.Parse("c[=3")
    36  		t.AssertNil(err)
    37  		t.Assert(m, map[string]interface{}{"c_": "3"})
    38  		m, err = gstr.Parse("v[a][a]a=m")
    39  		t.AssertNil(err)
    40  		t.Assert(m, g.Map{
    41  			"v": g.Map{
    42  				"a": g.Map{
    43  					"a": "m",
    44  				},
    45  			},
    46  		})
    47  		// v[][a]=m&v[][b]=b => map["v"]:[{"a":"m","b":"b"}]
    48  		m, err = gstr.Parse("v[][a]=m&v[][b]=b")
    49  		t.AssertNil(err)
    50  		t.Assert(m, g.Map{
    51  			"v": g.Slice{
    52  				g.Map{
    53  					"a": "m",
    54  					"b": "b",
    55  				},
    56  			},
    57  		})
    58  		// v[][a]=m&v[][a]=b => map["v"]:[{"a":"m"},{"a":"b"}]
    59  		m, err = gstr.Parse("v[][a]=m&v[][a]=b")
    60  		t.AssertNil(err)
    61  		t.Assert(m, g.Map{
    62  			"v": g.Slice{
    63  				g.Map{
    64  					"a": "m",
    65  				},
    66  				g.Map{
    67  					"a": "b",
    68  				},
    69  			},
    70  		})
    71  		// error
    72  		m, err = gstr.Parse("v=111&v[]=m&v[]=a&v[]=b")
    73  		t.Log(err)
    74  		t.AssertNE(err, nil)
    75  		m, err = gstr.Parse("v=111&v[a]=m&v[a]=a")
    76  		t.Log(err)
    77  		t.AssertNE(err, nil)
    78  		_, err = gstr.Parse("%Q=%Q&b")
    79  		t.Log(err)
    80  		t.AssertNE(err, nil)
    81  		_, err = gstr.Parse("a=%Q&b")
    82  		t.Log(err)
    83  		t.AssertNE(err, nil)
    84  		_, err = gstr.Parse("v[a][a]=m&v[][a]=b")
    85  		t.Log(err)
    86  		t.AssertNE(err, nil)
    87  	})
    88  
    89  	// url
    90  	gtest.C(t, func(t *gtest.T) {
    91  		s := "goframe.org/index?name=john&score=100"
    92  		u, err := url.Parse(s)
    93  		t.AssertNil(err)
    94  		m, err := gstr.Parse(u.RawQuery)
    95  		t.AssertNil(err)
    96  		t.Assert(m["name"], "john")
    97  		t.Assert(m["score"], "100")
    98  
    99  		// name overwrite
   100  		m, err = gstr.Parse("a=1&a=2")
   101  		t.AssertNil(err)
   102  		t.Assert(m, g.Map{
   103  			"a": 2,
   104  		})
   105  		// slice
   106  		m, err = gstr.Parse("a[]=1&a[]=2")
   107  		t.AssertNil(err)
   108  		t.Assert(m, g.Map{
   109  			"a": g.Slice{"1", "2"},
   110  		})
   111  		// map
   112  		m, err = gstr.Parse("a=1&b=2&c=3")
   113  		t.AssertNil(err)
   114  		t.Assert(m, g.Map{
   115  			"a": "1",
   116  			"b": "2",
   117  			"c": "3",
   118  		})
   119  		m, err = gstr.Parse("a=1&a=2&c=3")
   120  		t.AssertNil(err)
   121  		t.Assert(m, g.Map{
   122  			"a": "2",
   123  			"c": "3",
   124  		})
   125  		// map
   126  		m, err = gstr.Parse("m[a]=1&m[b]=2&m[c]=3")
   127  		t.AssertNil(err)
   128  		t.Assert(m, g.Map{
   129  			"m": g.Map{
   130  				"a": "1",
   131  				"b": "2",
   132  				"c": "3",
   133  			},
   134  		})
   135  		m, err = gstr.Parse("m[a]=1&m[a]=2&m[b]=3")
   136  		t.AssertNil(err)
   137  		t.Assert(m, g.Map{
   138  			"m": g.Map{
   139  				"a": "2",
   140  				"b": "3",
   141  			},
   142  		})
   143  		// map - slice
   144  		m, err = gstr.Parse("m[a][]=1&m[a][]=2")
   145  		t.AssertNil(err)
   146  		t.Assert(m, g.Map{
   147  			"m": g.Map{
   148  				"a": g.Slice{"1", "2"},
   149  			},
   150  		})
   151  		m, err = gstr.Parse("m[a][b][]=1&m[a][b][]=2")
   152  		t.AssertNil(err)
   153  		t.Assert(m, g.Map{
   154  			"m": g.Map{
   155  				"a": g.Map{
   156  					"b": g.Slice{"1", "2"},
   157  				},
   158  			},
   159  		})
   160  		// map - complicated
   161  		m, err = gstr.Parse("m[a1][b1][c1][d1]=1&m[a2][b2]=2&m[a3][b3][c3]=3")
   162  		t.AssertNil(err)
   163  		t.Assert(m, g.Map{
   164  			"m": g.Map{
   165  				"a1": g.Map{
   166  					"b1": g.Map{
   167  						"c1": g.Map{
   168  							"d1": "1",
   169  						},
   170  					},
   171  				},
   172  				"a2": g.Map{
   173  					"b2": "2",
   174  				},
   175  				"a3": g.Map{
   176  					"b3": g.Map{
   177  						"c3": "3",
   178  					},
   179  				},
   180  			},
   181  		})
   182  	})
   183  }