github.com/RevenueMonster/sqlike@v1.0.6/reflext/helper_test.go (about)

     1  package reflext
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/require"
     8  )
     9  
    10  func TestInit(t *testing.T) {
    11  
    12  	// init nil pointer
    13  	{
    14  		var ptrStr *string
    15  		v := reflect.ValueOf(&ptrStr)
    16  		v = Init(v)
    17  		require.NotNil(t, v.Interface())
    18  		// init should only initialise first level
    19  		require.Nil(t, v.Elem().Interface())
    20  	}
    21  
    22  	// init slice
    23  	{
    24  		var nilSlice []string
    25  		v := reflect.ValueOf(&nilSlice)
    26  		v = Init(v)
    27  		require.NotNil(t, v.Interface())
    28  	}
    29  
    30  	// init map
    31  	{
    32  		var nilMap map[string]string
    33  		v := reflect.ValueOf(&nilMap)
    34  		v = Init(v)
    35  		require.NotNil(t, v.Interface())
    36  	}
    37  }
    38  
    39  func TestIndirectInit(t *testing.T) {
    40  	// nested pointer should get initialized
    41  	{
    42  		var mulptrStr ***string
    43  		v := reflect.ValueOf(&mulptrStr)
    44  		vi := IndirectInit(v)
    45  
    46  		require.NotNil(t, v.Interface())
    47  		require.NotNil(t, v.Elem().Interface())
    48  		require.NotNil(t, v.Elem().Elem().Interface())
    49  		require.NotNil(t, v.Elem().Elem().Elem().Interface())
    50  
    51  		// IndirectInit should return the deep nested value, not the first level
    52  		require.Equal(t, "", vi.Interface().(string))
    53  	}
    54  }
    55  
    56  func TestTypeOf(t *testing.T) {
    57  	var (
    58  		ptr *string
    59  		// multiptrint *****int
    60  		// nilSlice    []string
    61  		// nilMap      map[string]interface{}
    62  		// v           reflect.Value
    63  	)
    64  
    65  	str := "hello world"
    66  
    67  	{
    68  		rt := reflect.TypeOf(&str)
    69  		require.Equal(t, rt, TypeOf(ptr))
    70  		require.Equal(t, rt, TypeOf(rt))
    71  	}
    72  }
    73  
    74  func TestValueOf(t *testing.T) {
    75  	var (
    76  		ptr         *string
    77  		multiptrint *****int
    78  		nilSlice    []string
    79  		nilMap      map[string]interface{}
    80  		v           reflect.Value
    81  	)
    82  
    83  	{
    84  		require.True(t, IsNull(reflect.ValueOf(ptr)))
    85  		require.True(t, IsNull(reflect.ValueOf(nilSlice)))
    86  		require.True(t, IsNull(reflect.ValueOf(nilMap)))
    87  	}
    88  
    89  	{
    90  		rt := reflect.TypeOf(multiptrint)
    91  		rt = Deref(rt)
    92  		require.Equal(t, reflect.TypeOf(int(1)), rt)
    93  	}
    94  
    95  	{
    96  		v = ValueOf(multiptrint)
    97  		require.Equal(t, reflect.ValueOf(multiptrint), v)
    98  		require.Equal(t, reflect.ValueOf(multiptrint), ValueOf(reflect.ValueOf(multiptrint)))
    99  	}
   100  }
   101  
   102  func TestNull(t *testing.T) {
   103  	var (
   104  		it      interface{}
   105  		pstr    *string
   106  		text    = "hello world"
   107  		integer int
   108  		slice   []string
   109  		arr     = make([]string, 0)
   110  		nilMap  map[string]string
   111  		initMap = make(map[string]string)
   112  		itv     interface{}
   113  	)
   114  
   115  	itv = "testing"
   116  
   117  	require.True(t, IsNull(reflect.ValueOf(it)))
   118  	require.True(t, IsNull(reflect.ValueOf(pstr)))
   119  	require.False(t, IsNull(reflect.ValueOf(text)))
   120  	require.False(t, IsNull(reflect.ValueOf(integer)))
   121  	require.True(t, IsNull(reflect.ValueOf(slice)))
   122  	require.False(t, IsNull(reflect.ValueOf(arr)))
   123  	require.True(t, IsNull(reflect.ValueOf(nilMap)))
   124  	require.False(t, IsNull(reflect.ValueOf(initMap)))
   125  	require.False(t, IsNull(reflect.ValueOf(itv)))
   126  }
   127  
   128  func TestIsNullable(t *testing.T) {
   129  	var (
   130  		it          interface{}
   131  		str         string
   132  		i           int
   133  		i64         int64
   134  		u           uint
   135  		u64         uint64
   136  		f32         float32
   137  		pf32        *float32
   138  		f64         float64
   139  		pf64        *float64
   140  		flag        bool
   141  		b           []byte
   142  		slice       []string
   143  		arr         = make([]*string, 0)
   144  		hashMap     map[string]string
   145  		emptyStruct struct{}
   146  		pStruct     *struct{}
   147  	)
   148  
   149  	require.True(t, IsNullable(reflect.TypeOf(it)))
   150  	require.False(t, IsNullable(reflect.TypeOf(str)))
   151  	require.False(t, IsNullable(reflect.TypeOf(i)))
   152  	require.False(t, IsNullable(reflect.TypeOf(i64)))
   153  	require.False(t, IsNullable(reflect.TypeOf(u)))
   154  	require.False(t, IsNullable(reflect.TypeOf(u64)))
   155  	require.False(t, IsNullable(reflect.TypeOf(flag)))
   156  	require.False(t, IsNullable(reflect.TypeOf(f32)))
   157  	require.True(t, IsNullable(reflect.TypeOf(pf32)))
   158  	require.False(t, IsNullable(reflect.TypeOf(f64)))
   159  	require.True(t, IsNullable(reflect.TypeOf(pf64)))
   160  	require.True(t, IsNullable(reflect.TypeOf(b)))
   161  	require.True(t, IsNullable(reflect.TypeOf(slice)))
   162  	require.True(t, IsNullable(reflect.TypeOf(arr)))
   163  	require.True(t, IsNullable(reflect.TypeOf(hashMap)))
   164  	require.False(t, IsNullable(reflect.TypeOf(emptyStruct)))
   165  	require.True(t, IsNullable(reflect.TypeOf(pStruct)))
   166  }
   167  
   168  func TestZero(t *testing.T) {
   169  
   170  }
   171  
   172  func TestIsKind(t *testing.T) {
   173  	var (
   174  		it          interface{}
   175  		str         string
   176  		i           int
   177  		i8          int8
   178  		i16         int16
   179  		i32         int32
   180  		i64         int64
   181  		u           uint
   182  		u8          uint8
   183  		u16         uint16
   184  		u32         uint32
   185  		biguint     uint64
   186  		f32         float32
   187  		f64         float64
   188  		flag        bool
   189  		b           []byte
   190  		slice       []string
   191  		arr         [2]string
   192  		hashMap     map[string]string
   193  		emptyStruct struct{}
   194  		pStruct     *struct{}
   195  	)
   196  
   197  	require.True(t, IsKind(reflect.TypeOf(it), reflect.Interface))
   198  	require.True(t, IsKind(reflect.TypeOf(str), reflect.String))
   199  	require.True(t, IsKind(reflect.TypeOf(i), reflect.Int))
   200  	require.True(t, IsKind(reflect.TypeOf(i8), reflect.Int8))
   201  	require.True(t, IsKind(reflect.TypeOf(i16), reflect.Int16))
   202  	require.True(t, IsKind(reflect.TypeOf(i32), reflect.Int32))
   203  	require.True(t, IsKind(reflect.TypeOf(i64), reflect.Int64))
   204  	require.True(t, IsKind(reflect.TypeOf(u), reflect.Uint))
   205  	require.True(t, IsKind(reflect.TypeOf(u8), reflect.Uint8))
   206  	require.True(t, IsKind(reflect.TypeOf(u16), reflect.Uint16))
   207  	require.True(t, IsKind(reflect.TypeOf(u32), reflect.Uint32))
   208  	require.True(t, IsKind(reflect.TypeOf(biguint), reflect.Uint64))
   209  	require.True(t, IsKind(reflect.TypeOf(f32), reflect.Float32))
   210  	require.True(t, IsKind(reflect.TypeOf(f64), reflect.Float64))
   211  	require.True(t, IsKind(reflect.TypeOf(flag), reflect.Bool))
   212  	require.True(t, IsKind(reflect.TypeOf(b), reflect.Slice))
   213  	require.True(t, IsKind(reflect.TypeOf(slice), reflect.Slice))
   214  	require.True(t, IsKind(reflect.TypeOf(arr), reflect.Array))
   215  	require.True(t, IsKind(reflect.TypeOf(hashMap), reflect.Map))
   216  	require.True(t, IsKind(reflect.TypeOf(emptyStruct), reflect.Struct))
   217  	require.True(t, IsKind(reflect.TypeOf(pStruct), reflect.Ptr))
   218  }
   219  
   220  type zero struct {
   221  }
   222  
   223  func (z zero) IsZero() bool {
   224  	return true
   225  }
   226  
   227  func TestIsZero(t *testing.T) {
   228  	var (
   229  		it           interface{}
   230  		str          string
   231  		i            int
   232  		i8           int8
   233  		i16          int16
   234  		i32          int32
   235  		i64          int64
   236  		u            uint
   237  		u8           uint8
   238  		u16          uint16
   239  		u32          uint32
   240  		u64          uint64
   241  		f32          float32
   242  		f64          float64
   243  		flag         bool
   244  		b            []byte
   245  		slice        []string
   246  		arr          [1]string
   247  		initSlice    = make([]*string, 0)
   248  		hashMap      map[string]string
   249  		initMap      = make(map[string]bool)
   250  		emptyStruct  struct{}
   251  		uninitStruct struct {
   252  			Str  string
   253  			Bool bool
   254  		}
   255  	)
   256  
   257  	require.True(t, IsZero(reflect.ValueOf(zero{})))
   258  	require.True(t, IsZero(reflect.ValueOf(&zero{})))
   259  	require.True(t, IsZero(reflect.ValueOf(it)))
   260  	require.True(t, IsZero(reflect.ValueOf(str)))
   261  	require.True(t, IsZero(reflect.ValueOf(i)))
   262  	require.True(t, IsZero(reflect.ValueOf(i8)))
   263  	require.True(t, IsZero(reflect.ValueOf(i16)))
   264  	require.True(t, IsZero(reflect.ValueOf(i32)))
   265  	require.True(t, IsZero(reflect.ValueOf(i64)))
   266  	require.True(t, IsZero(reflect.ValueOf(u)))
   267  	require.True(t, IsZero(reflect.ValueOf(u8)))
   268  	require.True(t, IsZero(reflect.ValueOf(u16)))
   269  	require.True(t, IsZero(reflect.ValueOf(u32)))
   270  	require.True(t, IsZero(reflect.ValueOf(u64)))
   271  	require.True(t, IsZero(reflect.ValueOf(f32)))
   272  	require.True(t, IsZero(reflect.ValueOf(f64)))
   273  	require.True(t, IsZero(reflect.ValueOf(flag)))
   274  	require.True(t, IsZero(reflect.ValueOf(b)))
   275  	require.True(t, IsZero(reflect.ValueOf(arr)))
   276  	require.True(t, IsZero(reflect.ValueOf(slice)))
   277  	require.True(t, IsZero(reflect.ValueOf(initSlice)))
   278  	require.True(t, IsZero(reflect.ValueOf(hashMap)))
   279  	require.True(t, IsZero(reflect.ValueOf(initMap)))
   280  	require.True(t, IsZero(reflect.ValueOf(emptyStruct)))
   281  	require.True(t, IsZero(reflect.ValueOf(uninitStruct)))
   282  
   283  	require.False(t, IsZero(reflect.ValueOf([2]string{"a", "b"})))
   284  }