github.com/gogf/gf@v1.16.9/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/gogf/gf.
     6  
     7  // go test *.go -bench=".*"
     8  
     9  package gstr_test
    10  
    11  import (
    12  	"net/url"
    13  	"testing"
    14  
    15  	"github.com/gogf/gf/frame/g"
    16  	"github.com/gogf/gf/test/gtest"
    17  	"github.com/gogf/gf/text/gstr"
    18  )
    19  
    20  func Test_Parse(t *testing.T) {
    21  	// url
    22  	gtest.C(t, func(t *gtest.T) {
    23  		s := "goframe.org/index?name=john&score=100"
    24  		u, err := url.Parse(s)
    25  		t.Assert(err, nil)
    26  		m, err := gstr.Parse(u.RawQuery)
    27  		t.Assert(err, nil)
    28  		t.Assert(m["name"], "john")
    29  		t.Assert(m["score"], "100")
    30  
    31  		// name overwrite
    32  		m, err = gstr.Parse("a=1&a=2")
    33  		t.Assert(err, nil)
    34  		t.Assert(m, g.Map{
    35  			"a": 2,
    36  		})
    37  		// slice
    38  		m, err = gstr.Parse("a[]=1&a[]=2")
    39  		t.Assert(err, nil)
    40  		t.Assert(m, g.Map{
    41  			"a": g.Slice{"1", "2"},
    42  		})
    43  		// map
    44  		m, err = gstr.Parse("a=1&b=2&c=3")
    45  		t.Assert(err, nil)
    46  		t.Assert(m, g.Map{
    47  			"a": "1",
    48  			"b": "2",
    49  			"c": "3",
    50  		})
    51  		m, err = gstr.Parse("a=1&a=2&c=3")
    52  		t.Assert(err, nil)
    53  		t.Assert(m, g.Map{
    54  			"a": "2",
    55  			"c": "3",
    56  		})
    57  		// map
    58  		m, err = gstr.Parse("m[a]=1&m[b]=2&m[c]=3")
    59  		t.Assert(err, nil)
    60  		t.Assert(m, g.Map{
    61  			"m": g.Map{
    62  				"a": "1",
    63  				"b": "2",
    64  				"c": "3",
    65  			},
    66  		})
    67  		m, err = gstr.Parse("m[a]=1&m[a]=2&m[b]=3")
    68  		t.Assert(err, nil)
    69  		t.Assert(m, g.Map{
    70  			"m": g.Map{
    71  				"a": "2",
    72  				"b": "3",
    73  			},
    74  		})
    75  		// map - slice
    76  		m, err = gstr.Parse("m[a][]=1&m[a][]=2")
    77  		t.Assert(err, nil)
    78  		t.Assert(m, g.Map{
    79  			"m": g.Map{
    80  				"a": g.Slice{"1", "2"},
    81  			},
    82  		})
    83  		m, err = gstr.Parse("m[a][b][]=1&m[a][b][]=2")
    84  		t.Assert(err, nil)
    85  		t.Assert(m, g.Map{
    86  			"m": g.Map{
    87  				"a": g.Map{
    88  					"b": g.Slice{"1", "2"},
    89  				},
    90  			},
    91  		})
    92  		// map - complicated
    93  		m, err = gstr.Parse("m[a1][b1][c1][d1]=1&m[a2][b2]=2&m[a3][b3][c3]=3")
    94  		t.Assert(err, nil)
    95  		t.Assert(m, g.Map{
    96  			"m": g.Map{
    97  				"a1": g.Map{
    98  					"b1": g.Map{
    99  						"c1": g.Map{
   100  							"d1": "1",
   101  						},
   102  					},
   103  				},
   104  				"a2": g.Map{
   105  					"b2": "2",
   106  				},
   107  				"a3": g.Map{
   108  					"b3": g.Map{
   109  						"c3": "3",
   110  					},
   111  				},
   112  			},
   113  		})
   114  	})
   115  }