github.com/yaoapp/kun@v0.9.0/any/any_test.go (about)

     1  package any
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/yaoapp/kun/day"
    10  	"github.com/yaoapp/kun/maps"
    11  	"github.com/yaoapp/kun/num"
    12  )
    13  
    14  func TestMake(t *testing.T) {
    15  	v := Make()
    16  	assert.Empty(t, v.String())
    17  }
    18  
    19  func TestOf(t *testing.T) {
    20  	v := Of("hello")
    21  	assert.Equal(t, "hello", v.String())
    22  }
    23  
    24  func TestSet(t *testing.T) {
    25  	v := Of("hello")
    26  	assert.Equal(t, "hello", v.Get())
    27  	assert.Equal(t, "hello", v.Val())
    28  	assert.Equal(t, "hello", v.Interface())
    29  
    30  	v.Set(1)
    31  	assert.Equal(t, "1", v.CString())
    32  }
    33  
    34  func TestGet(t *testing.T) {
    35  	v := Of("hello")
    36  	v.Set(1)
    37  	assert.Equal(t, 1, v.Get())
    38  	assert.Equal(t, 1, v.Val())
    39  	assert.Equal(t, 1, v.Interface())
    40  }
    41  
    42  func TestInterfaces(t *testing.T) {
    43  	v := Of([]interface{}{"hello", 1, true})
    44  	assert.Equal(t, []interface{}{"hello", 1, true}, v.Interfaces())
    45  
    46  	v.Set(nil)
    47  	assert.Equal(t, []interface{}{}, v.Interfaces())
    48  
    49  	v.Set([]string{"hello", "world"})
    50  	assert.Equal(t, []interface{}{"hello", "world"}, v.Interfaces())
    51  
    52  	v.Set("hello")
    53  	assert.Equal(t, []interface{}{"hello"}, v.Interfaces())
    54  }
    55  
    56  func TestString(t *testing.T) {
    57  	v := Of("hello")
    58  	assert.Equal(t, "hello", v.String())
    59  
    60  	v.Set(nil)
    61  	assert.Equal(t, "", v.String())
    62  
    63  	v.Set(1)
    64  	assert.Panics(t, func() {
    65  		fmt.Println(v.String())
    66  	})
    67  }
    68  
    69  func TestCString(t *testing.T) {
    70  	v := Of("hello")
    71  	assert.Equal(t, "hello", v.CString())
    72  
    73  	v.Set(nil)
    74  	assert.Equal(t, "", v.String())
    75  
    76  	v.Set(1)
    77  	assert.Equal(t, "1", v.CString())
    78  }
    79  
    80  func TestStrings(t *testing.T) {
    81  	v := Of([]string{"hello", "world"})
    82  	assert.Equal(t, []string{"hello", "world"}, v.Strings())
    83  
    84  	v.Set(nil)
    85  	assert.Equal(t, []string{}, v.Strings())
    86  
    87  	v.Set("hello")
    88  	assert.Panics(t, func() {
    89  		fmt.Println(v.Strings())
    90  	})
    91  }
    92  
    93  func TestCStrings(t *testing.T) {
    94  	v := Of([]interface{}{"hello", 1, true})
    95  	assert.Equal(t, []string{"hello", "1", "true"}, v.CStrings())
    96  
    97  	v.Set(nil)
    98  	assert.Equal(t, []string{}, v.CStrings())
    99  
   100  	v.Set([]string{"hello", "world"})
   101  	assert.Equal(t, []string{"hello", "world"}, v.CStrings())
   102  
   103  	v.Set("hello")
   104  	assert.Equal(t, []string{"hello"}, v.CStrings())
   105  }
   106  
   107  func TestInt(t *testing.T) {
   108  	v := Of(10)
   109  	assert.Equal(t, 10, v.Int())
   110  
   111  	v.Set(nil)
   112  	assert.Equal(t, 0, v.Int())
   113  
   114  	v.Set("hello")
   115  	assert.Panics(t, func() {
   116  		fmt.Println(v.Int())
   117  	})
   118  }
   119  
   120  func TestCInt(t *testing.T) {
   121  	v := Of(10)
   122  	assert.Equal(t, 10, v.CInt())
   123  
   124  	v.Set(nil)
   125  	assert.Equal(t, 0, v.CInt())
   126  
   127  	v.Set("20")
   128  	assert.Equal(t, 20, v.CInt())
   129  
   130  	v.Set("error")
   131  	assert.Panics(t, func() {
   132  		fmt.Println(v.CInt())
   133  	})
   134  }
   135  
   136  func TestInts(t *testing.T) {
   137  	v := Of([]int{1, 2})
   138  	assert.Equal(t, []int{1, 2}, v.Ints())
   139  
   140  	v.Set(nil)
   141  	assert.Equal(t, []int{}, v.Ints())
   142  
   143  	v.Set("hello")
   144  	assert.Panics(t, func() {
   145  		fmt.Println(v.Ints())
   146  	})
   147  }
   148  
   149  func TestCInts(t *testing.T) {
   150  	v := Of([]interface{}{1, 2, "3"})
   151  	assert.Equal(t, []int{1, 2, 3}, v.CInts())
   152  
   153  	v.Set(nil)
   154  	assert.Equal(t, []int{}, v.CInts())
   155  
   156  	v.Set([]string{"5", "6"})
   157  	assert.Equal(t, []int{5, 6}, v.CInts())
   158  
   159  	v.Set(7)
   160  	assert.Equal(t, []int{7}, v.CInts())
   161  }
   162  
   163  func TestFloat(t *testing.T) {
   164  	v := Of(10.056)
   165  	assert.Equal(t, 10.056, v.Float())
   166  
   167  	v.Set(nil)
   168  	assert.Equal(t, 0.0, v.Float())
   169  
   170  	v.Set("hello")
   171  	assert.Panics(t, func() {
   172  		fmt.Println(v.Float())
   173  	})
   174  }
   175  
   176  func TestCFloat(t *testing.T) {
   177  	v := Of(10.056)
   178  	assert.Equal(t, 10.056, v.CFloat())
   179  
   180  	v.Set(nil)
   181  	assert.Equal(t, 0.0, v.CFloat())
   182  
   183  	v.Set("20.018")
   184  	assert.Equal(t, 20.018, v.CFloat())
   185  
   186  	v.Set("error")
   187  	assert.Panics(t, func() {
   188  		fmt.Println(v.CFloat())
   189  	})
   190  }
   191  
   192  func TestFloats(t *testing.T) {
   193  	v := Of([]float64{1.618, 2.154})
   194  	assert.Equal(t, []float64{1.618, 2.154}, v.Floats())
   195  
   196  	v.Set(nil)
   197  	assert.Equal(t, []float64{}, v.Floats())
   198  
   199  	v.Set("hello")
   200  	assert.Panics(t, func() {
   201  		fmt.Println(v.Floats())
   202  	})
   203  }
   204  
   205  func TestCFloats(t *testing.T) {
   206  	v := Of([]interface{}{1.618, 2.154, "3.617"})
   207  	assert.Equal(t, []float64{1.618, 2.154, 3.617}, v.CFloats())
   208  
   209  	v.Set(nil)
   210  	assert.Equal(t, []float64{}, v.CFloats())
   211  
   212  	v.Set([]string{"5.10", "6.18"})
   213  	assert.Equal(t, []float64{5.10, 6.18}, v.CFloats())
   214  
   215  	v.Set(7.46)
   216  	assert.Equal(t, []float64{7.46}, v.CFloats())
   217  }
   218  
   219  func TestBool(t *testing.T) {
   220  	v := Of(false)
   221  	assert.Equal(t, false, v.Bool())
   222  
   223  	v.Set(true)
   224  	assert.Equal(t, true, v.Bool())
   225  
   226  	v.Set(nil)
   227  	assert.Equal(t, false, v.Bool())
   228  
   229  	v.Set("hello")
   230  	assert.Panics(t, func() {
   231  		fmt.Println(v.Bool())
   232  	})
   233  }
   234  
   235  func TestCBool(t *testing.T) {
   236  	v := Of(false)
   237  	assert.Equal(t, false, v.CBool())
   238  
   239  	v.Set(true)
   240  	assert.Equal(t, true, v.CBool())
   241  
   242  	v.Set(nil)
   243  	assert.Equal(t, false, v.CBool())
   244  	v.Set("true")
   245  	assert.Equal(t, true, v.CBool())
   246  
   247  	v.Set("T")
   248  	assert.Equal(t, true, v.CBool())
   249  
   250  	v.Set("TRUE")
   251  	assert.Equal(t, true, v.CBool())
   252  
   253  	v.Set("1")
   254  	assert.Equal(t, true, v.CBool())
   255  
   256  	v.Set(1)
   257  	assert.Equal(t, true, v.CBool())
   258  
   259  	v.Set("false")
   260  	assert.Equal(t, false, v.CBool())
   261  
   262  	v.Set("FALSE")
   263  	assert.Equal(t, false, v.CBool())
   264  
   265  	v.Set("F")
   266  	assert.Equal(t, false, v.CBool())
   267  
   268  	v.Set("0")
   269  	assert.Equal(t, false, v.CBool())
   270  
   271  	v.Set(0)
   272  	assert.Equal(t, false, v.CBool())
   273  
   274  	v.Set("-10")
   275  	assert.Panics(t, func() {
   276  		fmt.Println(v.CBool())
   277  	})
   278  }
   279  
   280  func TestArray(t *testing.T) {
   281  	v := Of([]interface{}{"hello", "world"})
   282  	assert.Equal(t, []interface{}{"hello", "world"}, v.Array())
   283  
   284  	v.Set(nil)
   285  	assert.Equal(t, []interface{}{}, v.Array())
   286  
   287  	v.Set("hello")
   288  	assert.Panics(t, func() {
   289  		fmt.Println(v.Strings())
   290  	})
   291  }
   292  
   293  func TestCArray(t *testing.T) {
   294  	v := Of([]string{"hello", "world"})
   295  	assert.Equal(t, []interface{}{"hello", "world"}, v.CArray())
   296  
   297  	v.Set(nil)
   298  	assert.Equal(t, []interface{}{}, v.CArray())
   299  
   300  	v.Set("hello")
   301  	assert.Panics(t, func() {
   302  		fmt.Println(v.CArray())
   303  	})
   304  }
   305  
   306  func TestNumber(t *testing.T) {
   307  	num1 := Of(0.618).Number()
   308  	assert.Equal(t, 0.618, num1.Float())
   309  
   310  	num2 := Of(1.618 + 0.532i).Number()
   311  	assert.Equal(t, 1.618+0.532i, num2.Complex())
   312  
   313  	num3 := Of(num.Of(0.618)).Number()
   314  	assert.Equal(t, 1, num3.Int())
   315  
   316  	num4 := Of(*num.Of(0.618)).Number()
   317  	assert.Equal(t, 1, num4.Int())
   318  }
   319  
   320  func TestDatetime(t *testing.T) {
   321  	day.Timezone("Beijing", 8*60*60)
   322  	assert.Equal(t, 31, Of("2019-12-31 08:20:55").Datetime().Day())
   323  	assert.Equal(t, 31, Of(day.Of("2019-12-31 08:20:55")).Datetime().Day())
   324  	assert.Equal(t, 31, Of(*day.Of("2019-12-31 08:20:55")).Datetime().Day())
   325  
   326  	name, offset := Of("2019-12-31 08:20:55").Datetime().Zone()
   327  	assert.Equal(t, "Beijing", name)
   328  	assert.Equal(t, 8*60*60, offset)
   329  }
   330  
   331  func TestMap(t *testing.T) {
   332  	map1 := Of(map[string]interface{}{
   333  		"hello": "world",
   334  		"foo":   1,
   335  		"array": []string{"one", "two", "three"},
   336  		"name": map[string]interface{}{
   337  			"first":  "Join",
   338  			"second": "Cool",
   339  		}}).Map()
   340  	assert.Equal(t, "world", map1.Get("hello"))
   341  	assert.Equal(t, "world", map1.Any("hello").String())
   342  	assert.Equal(t, "Join", map1.Dot().Get("name.first"))
   343  	assert.Equal(t, "Join", map1.Dot().Any("name.first").String())
   344  	assert.Equal(t, nil, map1.Dot().Get("name.notexist"))
   345  	assert.Equal(t, nil, map1.Dot().Any("name.notexist").Interface())
   346  	assert.Equal(t, true, map1.Flatten().Any("name.notexist").IsNil())
   347  	assert.Equal(t, "two", map1.Flatten().Any("array.1").String())
   348  
   349  	map1.Set("title", "CEO")
   350  	map2 := Of(map1).Map()
   351  	assert.Equal(t, "CEO", map2.Get("title"))
   352  	assert.Equal(t, "CEO", map2.Any("title").String())
   353  
   354  	map3 := Of(map[int]string{0: "0", 1: "1"}).Map()
   355  	assert.Equal(t, "0", map3.Get("0"))
   356  	assert.Equal(t, "0", map3.Any("0").String())
   357  	assert.Equal(t, "1", map3.Get("1"))
   358  	assert.Equal(t, "1", map3.Any("1").String())
   359  
   360  	map4 := Of(maps.Of(map[string]interface{}{"a": "b"})).Map()
   361  	assert.Equal(t, "b", map4.Get("a"))
   362  
   363  	map5 := Of(MakeMap()).Map()
   364  	assert.Equal(t, nil, map5.Any("notexist").Get())
   365  
   366  	assert.Panics(t, func() {
   367  		Of([]string{"hello", "world"}).Map()
   368  	})
   369  }
   370  
   371  func TestIsDatetime(t *testing.T) {
   372  	assert.Equal(t, true, Of(day.Of("2000-01-01")).IsDatetime())
   373  	assert.Equal(t, true, Of(time.Now()).IsDatetime())
   374  	assert.Equal(t, false, Of(1).IsDatetime())
   375  }
   376  
   377  func TestIsNumber(t *testing.T) {
   378  	assert.Equal(t, true, Of(1).IsNumber())
   379  	assert.Equal(t, true, Of(0.618).IsNumber())
   380  	assert.Equal(t, true, Of(1+0.618i).IsNumber())
   381  	assert.Equal(t, false, Of([]string{"hello", "world"}).IsNumber())
   382  }
   383  
   384  func TestIsMap(t *testing.T) {
   385  	assert.Equal(t, true, Of(map[string]interface{}{"hello": "world"}).IsMap())
   386  	assert.Equal(t, true, Of(map[int]string{0: "0", 1: "1"}).IsMap())
   387  	assert.Equal(t, true, Of(MapOf(map[int]string{0: "0", 1: "1"})).IsMap())
   388  	assert.Equal(t, true, Of(MapOf(nil)).IsMap())
   389  	assert.Equal(t, false, Of([]string{"hello", "world"}).IsMap())
   390  }
   391  
   392  func TestIsBool(t *testing.T) {
   393  	assert.Equal(t, true, Of(true).IsBool())
   394  	assert.Equal(t, true, Of(false).IsBool())
   395  	assert.Equal(t, false, Of(0).IsBool())
   396  	assert.Equal(t, false, Of(1).IsBool())
   397  }
   398  
   399  func TestIsInt(t *testing.T) {
   400  	assert.Equal(t, true, Of(1).IsInt())
   401  	assert.Equal(t, true, Of(int8(1)).IsInt())
   402  	assert.Equal(t, false, Of(true).IsInt())
   403  }
   404  
   405  func TestIsFloat(t *testing.T) {
   406  	assert.Equal(t, true, Of(1.618).IsFloat())
   407  	assert.Equal(t, true, Of(float32(1.382)).IsFloat())
   408  	assert.Equal(t, false, Of(5).IsFloat())
   409  }
   410  
   411  func TestIsSlice(t *testing.T) {
   412  	assert.Equal(t, true, Of([]string{"hello", "world"}).IsSlice())
   413  	assert.Equal(t, false, Of([2]string{"hello", "world"}).IsSlice())
   414  	assert.Equal(t, false, Of(5).IsSlice())
   415  }
   416  
   417  func TestIsArray(t *testing.T) {
   418  	assert.Equal(t, true, Of([2]string{"hello", "world"}).IsArray())
   419  	assert.Equal(t, false, Of([]string{"hello", "world"}).IsArray())
   420  	assert.Equal(t, false, Of(5).IsArray())
   421  }
   422  
   423  func TestIsCollection(t *testing.T) {
   424  	assert.Equal(t, true, Of([2]string{"hello", "world"}).IsCollection())
   425  	assert.Equal(t, true, Of([]string{"hello", "world"}).IsCollection())
   426  	assert.Equal(t, false, Of(5).IsCollection())
   427  }
   428  
   429  func TestIsNotNil(t *testing.T) {
   430  	assert.Equal(t, true, Of(1).IsNotNil())
   431  	assert.Equal(t, false, Of(nil).IsNotNil())
   432  }
   433  
   434  func TestIsNil(t *testing.T) {
   435  	assert.Equal(t, false, Of(1).IsNil())
   436  	assert.Equal(t, true, Of(nil).IsNil())
   437  }
   438  
   439  func TestIsEmpty(t *testing.T) {
   440  	assert.Equal(t, true, Of(nil).IsEmpty())
   441  	assert.Equal(t, true, Of("0").IsEmpty())
   442  	assert.Equal(t, true, Of("F").IsEmpty())
   443  	assert.Equal(t, true, Of("false").IsEmpty())
   444  	assert.Equal(t, true, Of("").IsEmpty())
   445  	assert.Equal(t, true, Of(0).IsEmpty())
   446  	assert.Equal(t, true, Of(0.0).IsEmpty())
   447  	assert.Equal(t, true, Of(false).IsEmpty())
   448  	assert.Equal(t, true, Of([]string{}).IsEmpty())
   449  	assert.Equal(t, true, Of([0]string{}).IsEmpty())
   450  	assert.Equal(t, false, Of(true).IsEmpty())
   451  }