github.com/gogf/gf@v1.16.9/container/gvar/gvar_z_unit_basic_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  package gvar_test
     8  
     9  import (
    10  	"bytes"
    11  	"encoding/binary"
    12  	"github.com/gogf/gf/util/gconv"
    13  	"testing"
    14  	"time"
    15  
    16  	"github.com/gogf/gf/container/gvar"
    17  	"github.com/gogf/gf/test/gtest"
    18  )
    19  
    20  func Test_Set(t *testing.T) {
    21  	gtest.C(t, func(t *gtest.T) {
    22  		var v gvar.Var
    23  		v.Set(123.456)
    24  		t.Assert(v.Val(), 123.456)
    25  	})
    26  	gtest.C(t, func(t *gtest.T) {
    27  		var v gvar.Var
    28  		v.Set(123.456)
    29  		t.Assert(v.Val(), 123.456)
    30  	})
    31  	gtest.C(t, func(t *gtest.T) {
    32  		v := gvar.Create(123.456)
    33  		t.Assert(v.Val(), 123.456)
    34  	})
    35  	gtest.C(t, func(t *gtest.T) {
    36  		objOne := gvar.New("old", true)
    37  		objOneOld, _ := objOne.Set("new").(string)
    38  		t.Assert(objOneOld, "old")
    39  
    40  		objTwo := gvar.New("old", false)
    41  		objTwoOld, _ := objTwo.Set("new").(string)
    42  		t.Assert(objTwoOld, "old")
    43  	})
    44  }
    45  
    46  func Test_Val(t *testing.T) {
    47  	gtest.C(t, func(t *gtest.T) {
    48  		objOne := gvar.New(1, true)
    49  		objOneOld, _ := objOne.Val().(int)
    50  		t.Assert(objOneOld, 1)
    51  
    52  		objTwo := gvar.New(1, false)
    53  		objTwoOld, _ := objTwo.Val().(int)
    54  		t.Assert(objTwoOld, 1)
    55  	})
    56  }
    57  func Test_Interface(t *testing.T) {
    58  	gtest.C(t, func(t *gtest.T) {
    59  		objOne := gvar.New(1, true)
    60  		objOneOld, _ := objOne.Interface().(int)
    61  		t.Assert(objOneOld, 1)
    62  
    63  		objTwo := gvar.New(1, false)
    64  		objTwoOld, _ := objTwo.Interface().(int)
    65  		t.Assert(objTwoOld, 1)
    66  	})
    67  }
    68  func Test_IsNil(t *testing.T) {
    69  	gtest.C(t, func(t *gtest.T) {
    70  		objOne := gvar.New(nil, true)
    71  		t.Assert(objOne.IsNil(), true)
    72  
    73  		objTwo := gvar.New("noNil", false)
    74  		t.Assert(objTwo.IsNil(), false)
    75  
    76  	})
    77  }
    78  
    79  func Test_Bytes(t *testing.T) {
    80  	gtest.C(t, func(t *gtest.T) {
    81  		x := int32(1)
    82  		bytesBuffer := bytes.NewBuffer([]byte{})
    83  		binary.Write(bytesBuffer, binary.BigEndian, x)
    84  
    85  		objOne := gvar.New(bytesBuffer.Bytes(), true)
    86  
    87  		bBuf := bytes.NewBuffer(objOne.Bytes())
    88  		var y int32
    89  		binary.Read(bBuf, binary.BigEndian, &y)
    90  
    91  		t.Assert(x, y)
    92  
    93  	})
    94  }
    95  
    96  func Test_String(t *testing.T) {
    97  	gtest.C(t, func(t *gtest.T) {
    98  		var str string = "hello"
    99  		objOne := gvar.New(str, true)
   100  		t.Assert(objOne.String(), str)
   101  
   102  	})
   103  }
   104  func Test_Bool(t *testing.T) {
   105  	gtest.C(t, func(t *gtest.T) {
   106  		var ok bool = true
   107  		objOne := gvar.New(ok, true)
   108  		t.Assert(objOne.Bool(), ok)
   109  
   110  		ok = false
   111  		objTwo := gvar.New(ok, true)
   112  		t.Assert(objTwo.Bool(), ok)
   113  
   114  	})
   115  }
   116  
   117  func Test_Int(t *testing.T) {
   118  	gtest.C(t, func(t *gtest.T) {
   119  		var num int = 1
   120  		objOne := gvar.New(num, true)
   121  		t.Assert(objOne.Int(), num)
   122  
   123  	})
   124  }
   125  
   126  func Test_Int8(t *testing.T) {
   127  	gtest.C(t, func(t *gtest.T) {
   128  		var num int8 = 1
   129  		objOne := gvar.New(num, true)
   130  		t.Assert(objOne.Int8(), num)
   131  
   132  	})
   133  }
   134  
   135  func Test_Int16(t *testing.T) {
   136  	gtest.C(t, func(t *gtest.T) {
   137  		var num int16 = 1
   138  		objOne := gvar.New(num, true)
   139  		t.Assert(objOne.Int16(), num)
   140  
   141  	})
   142  }
   143  
   144  func Test_Int32(t *testing.T) {
   145  	gtest.C(t, func(t *gtest.T) {
   146  		var num int32 = 1
   147  		objOne := gvar.New(num, true)
   148  		t.Assert(objOne.Int32(), num)
   149  
   150  	})
   151  }
   152  
   153  func Test_Int64(t *testing.T) {
   154  	gtest.C(t, func(t *gtest.T) {
   155  		var num int64 = 1
   156  		objOne := gvar.New(num, true)
   157  		t.Assert(objOne.Int64(), num)
   158  
   159  	})
   160  }
   161  
   162  func Test_Uint(t *testing.T) {
   163  	gtest.C(t, func(t *gtest.T) {
   164  		var num uint = 1
   165  		objOne := gvar.New(num, true)
   166  		t.Assert(objOne.Uint(), num)
   167  
   168  	})
   169  }
   170  
   171  func Test_Uint8(t *testing.T) {
   172  	gtest.C(t, func(t *gtest.T) {
   173  		var num uint8 = 1
   174  		objOne := gvar.New(num, true)
   175  		t.Assert(objOne.Uint8(), num)
   176  
   177  	})
   178  }
   179  
   180  func Test_Uint16(t *testing.T) {
   181  	gtest.C(t, func(t *gtest.T) {
   182  		var num uint16 = 1
   183  		objOne := gvar.New(num, true)
   184  		t.Assert(objOne.Uint16(), num)
   185  
   186  	})
   187  }
   188  
   189  func Test_Uint32(t *testing.T) {
   190  	gtest.C(t, func(t *gtest.T) {
   191  		var num uint32 = 1
   192  		objOne := gvar.New(num, true)
   193  		t.Assert(objOne.Uint32(), num)
   194  
   195  	})
   196  }
   197  
   198  func Test_Uint64(t *testing.T) {
   199  	gtest.C(t, func(t *gtest.T) {
   200  		var num uint64 = 1
   201  		objOne := gvar.New(num, true)
   202  		t.Assert(objOne.Uint64(), num)
   203  
   204  	})
   205  }
   206  func Test_Float32(t *testing.T) {
   207  	gtest.C(t, func(t *gtest.T) {
   208  		var num float32 = 1.1
   209  		objOne := gvar.New(num, true)
   210  		t.Assert(objOne.Float32(), num)
   211  
   212  	})
   213  }
   214  
   215  func Test_Float64(t *testing.T) {
   216  	gtest.C(t, func(t *gtest.T) {
   217  		var num float64 = 1.1
   218  		objOne := gvar.New(num, true)
   219  		t.Assert(objOne.Float64(), num)
   220  
   221  	})
   222  }
   223  
   224  func Test_Time(t *testing.T) {
   225  	gtest.C(t, func(t *gtest.T) {
   226  		var timeUnix int64 = 1556242660
   227  		objOne := gvar.New(timeUnix, true)
   228  		t.Assert(objOne.Time().Unix(), timeUnix)
   229  	})
   230  }
   231  
   232  func Test_GTime(t *testing.T) {
   233  	gtest.C(t, func(t *gtest.T) {
   234  		var timeUnix int64 = 1556242660
   235  		objOne := gvar.New(timeUnix, true)
   236  		t.Assert(objOne.GTime().Unix(), timeUnix)
   237  	})
   238  }
   239  
   240  func Test_Duration(t *testing.T) {
   241  	gtest.C(t, func(t *gtest.T) {
   242  		var timeUnix int64 = 1556242660
   243  		objOne := gvar.New(timeUnix, true)
   244  		t.Assert(objOne.Duration(), time.Duration(timeUnix))
   245  	})
   246  }
   247  
   248  func Test_UnmarshalJson(t *testing.T) {
   249  	gtest.C(t, func(t *gtest.T) {
   250  		type V struct {
   251  			Name string
   252  			Var  *gvar.Var
   253  		}
   254  		var v *V
   255  		err := gconv.Struct(map[string]interface{}{
   256  			"name": "john",
   257  			"var":  "v",
   258  		}, &v)
   259  		t.Assert(err, nil)
   260  		t.Assert(v.Name, "john")
   261  		t.Assert(v.Var.String(), "v")
   262  	})
   263  	gtest.C(t, func(t *gtest.T) {
   264  		type V struct {
   265  			Name string
   266  			Var  gvar.Var
   267  		}
   268  		var v *V
   269  		err := gconv.Struct(map[string]interface{}{
   270  			"name": "john",
   271  			"var":  "v",
   272  		}, &v)
   273  		t.Assert(err, nil)
   274  		t.Assert(v.Name, "john")
   275  		t.Assert(v.Var.String(), "v")
   276  	})
   277  }
   278  
   279  func Test_UnmarshalValue(t *testing.T) {
   280  	gtest.C(t, func(t *gtest.T) {
   281  		type V struct {
   282  			Name string
   283  			Var  *gvar.Var
   284  		}
   285  		var v *V
   286  		err := gconv.Struct(map[string]interface{}{
   287  			"name": "john",
   288  			"var":  "v",
   289  		}, &v)
   290  		t.Assert(err, nil)
   291  		t.Assert(v.Name, "john")
   292  		t.Assert(v.Var.String(), "v")
   293  	})
   294  	gtest.C(t, func(t *gtest.T) {
   295  		type V struct {
   296  			Name string
   297  			Var  gvar.Var
   298  		}
   299  		var v *V
   300  		err := gconv.Struct(map[string]interface{}{
   301  			"name": "john",
   302  			"var":  "v",
   303  		}, &v)
   304  		t.Assert(err, nil)
   305  		t.Assert(v.Name, "john")
   306  		t.Assert(v.Var.String(), "v")
   307  	})
   308  }