gitlab.com/ignitionrobotics/web/ign-go@v1.0.0-rc4/reflect/reflect_test.go (about)

     1  package reflect
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/stretchr/testify/assert"
     6  	"testing"
     7  )
     8  
     9  type Tester interface {
    10  	Value() interface{}
    11  }
    12  
    13  type Test struct {
    14  	value int
    15  }
    16  
    17  func (t *Test) Value() interface{} { return t.value }
    18  
    19  func TestAppendToSliceInt(t *testing.T) {
    20  	slice := make([]int, 0)
    21  	assert.NoError(t, AppendToSlice(&slice, 1, 2, 3))
    22  
    23  	expected := []int{1, 2, 3}
    24  	assert.Equal(t, expected, slice)
    25  }
    26  
    27  func TestAppendToSlicePtr(t *testing.T) {
    28  	slice := make([]*int, 0)
    29  	v1 := 1
    30  	v2 := 2
    31  	v3 := 3
    32  	assert.NoError(t, AppendToSlice(&slice, &v1, &v2, &v3))
    33  
    34  	expected := []*int{&v1, &v2, &v3}
    35  	assert.Equal(t, expected, slice)
    36  }
    37  
    38  func TestAppendToSliceStruct(t *testing.T) {
    39  	type T struct {
    40  		Value string
    41  	}
    42  
    43  	slice := make([]T, 0)
    44  	assert.NoError(t, AppendToSlice(&slice, T{"a"}, T{"b"}, T{"c"}))
    45  
    46  	expected := []T{{"a"}, {"b"}, {"c"}}
    47  	assert.Equal(t, expected, slice)
    48  }
    49  
    50  func TestAppendToSliceNotPointerError(t *testing.T) {
    51  	slice := make([]int, 0)
    52  	assert.Equal(t, ErrNotPointer, AppendToSlice(slice, 1, 2, 3))
    53  }
    54  
    55  func TestAppendToSliceNotSliceError(t *testing.T) {
    56  	value := 0
    57  	assert.Equal(t, ErrNotCollection, AppendToSlice(&value, 1, 2, 3))
    58  }
    59  
    60  func TestAppendToSlicePanicsWithInvalidType(t *testing.T) {
    61  	slice := make([]int, 0)
    62  	assert.Panics(t, func() { _ = AppendToSlice(&slice, "a", "b", "c") })
    63  }
    64  
    65  func TestSetMapValueInt(t *testing.T) {
    66  	m := make(map[string]int, 0)
    67  	assert.NoError(t, SetMapValue(m, "1", 100))
    68  	assert.NoError(t, SetMapValue(m, "2", 2))
    69  	assert.NoError(t, SetMapValue(m, "3", 3))
    70  	// Replace existing value
    71  	assert.NoError(t, SetMapValue(m, "1", 1))
    72  
    73  	expected := map[string]int{
    74  		"1": 1,
    75  		"2": 2,
    76  		"3": 3,
    77  	}
    78  	assert.Equal(t, expected, m)
    79  }
    80  
    81  func TestSetMapValuePtr(t *testing.T) {
    82  	m := make(map[string]*int, 0)
    83  	v1 := 1
    84  	v2 := 2
    85  	v3 := 3
    86  	assert.NoError(t, SetMapValue(m, "1", nil))
    87  	assert.NoError(t, SetMapValue(m, "2", &v2))
    88  	assert.NoError(t, SetMapValue(m, "3", &v3))
    89  	// Replace existing value
    90  	assert.NoError(t, SetMapValue(m, "1", &v1))
    91  
    92  	expected := map[string]*int{
    93  		"1": &v1,
    94  		"2": &v2,
    95  		"3": &v3,
    96  	}
    97  	assert.Equal(t, expected, m)
    98  }
    99  
   100  func TestSetMapValueStruct(t *testing.T) {
   101  	type T struct {
   102  		Value string
   103  	}
   104  
   105  	m := make(map[string]T, 0)
   106  	assert.NoError(t, SetMapValue(m, "1", T{"a"}))
   107  	assert.NoError(t, SetMapValue(m, "2", T{"b"}))
   108  	assert.NoError(t, SetMapValue(m, "3", T{"c"}))
   109  
   110  	expected := map[string]T{
   111  		"1": {"a"},
   112  		"2": {"b"},
   113  		"3": {"c"},
   114  	}
   115  	assert.Equal(t, expected, m)
   116  }
   117  
   118  func TestSetMapValueNotSliceError(t *testing.T) {
   119  	value := 0
   120  	assert.Equal(t, ErrNotCollection, SetMapValue(&value, "1", 1))
   121  }
   122  
   123  func TestSetMapValuePanicsWithInvalidType(t *testing.T) {
   124  	m := make(map[string]int, 0)
   125  	assert.Panics(t, func() { _ = SetMapValue(m, 1, "a") })
   126  }
   127  
   128  func TestNewCollectionValueInstanceIntSlice(t *testing.T) {
   129  	value := make([]int, 0)
   130  
   131  	out, err := NewCollectionValueInstance(value)
   132  	assert.NoError(t, err)
   133  
   134  	var expected int
   135  	assert.Equal(t, expected, out)
   136  }
   137  
   138  func TestNewCollectionValueInstanceIntSlicePtr(t *testing.T) {
   139  	value := make([]*int, 0)
   140  
   141  	out, err := NewCollectionValueInstance(value)
   142  	assert.NoError(t, err)
   143  
   144  	var expected int
   145  	fmt.Println(&expected, out)
   146  	assert.NotSame(t, &expected, out)
   147  }
   148  
   149  func TestNewCollectionValueInstanceStructSlice(t *testing.T) {
   150  	type T struct {
   151  		Value string
   152  	}
   153  
   154  	value := make([]T, 0)
   155  
   156  	out, err := NewCollectionValueInstance(value)
   157  	assert.NoError(t, err)
   158  
   159  	expected := T{}
   160  	assert.Equal(t, expected, out)
   161  
   162  	// Validate that the objects are different instances
   163  	expected.Value = "expected"
   164  	result := out.(T)
   165  	result.Value = "out"
   166  	assert.NotEqual(t, expected, result)
   167  }
   168  
   169  func TestNewCollectionValueInstanceStructSlicePtr(t *testing.T) {
   170  	type T struct {
   171  		Value string
   172  	}
   173  
   174  	value := make([]*T, 0)
   175  
   176  	out, err := NewCollectionValueInstance(value)
   177  	assert.NoError(t, err)
   178  
   179  	expected := &T{}
   180  	assert.Equal(t, expected, out)
   181  
   182  	// Validate that the objects are different instances
   183  	expected.Value = "expected"
   184  	result := out.(*T)
   185  	result.Value = "out"
   186  	assert.NotEqual(t, expected, result)
   187  }
   188  
   189  func TestNewCollectionValueInstanceIntMap(t *testing.T) {
   190  	value := make(map[string]int, 0)
   191  
   192  	out, err := NewCollectionValueInstance(value)
   193  	assert.NoError(t, err)
   194  
   195  	var expected int
   196  	assert.Equal(t, expected, out)
   197  }
   198  
   199  func TestNewCollectionValueInstanceIntMapPtr(t *testing.T) {
   200  	value := make(map[string]*int, 0)
   201  
   202  	out, err := NewCollectionValueInstance(value)
   203  	assert.NoError(t, err)
   204  
   205  	var expected int
   206  	fmt.Println(&expected, out)
   207  	assert.NotSame(t, &expected, out)
   208  }
   209  
   210  func TestNewCollectionValueInstanceStructMap(t *testing.T) {
   211  	type T struct {
   212  		Value string
   213  	}
   214  
   215  	value := make(map[string]T, 0)
   216  
   217  	out, err := NewCollectionValueInstance(value)
   218  	assert.NoError(t, err)
   219  
   220  	expected := T{}
   221  	assert.Equal(t, expected, out)
   222  
   223  	// Validate that the objects are different instances
   224  	expected.Value = "expected"
   225  	result := out.(T)
   226  	result.Value = "out"
   227  	assert.NotEqual(t, expected, result)
   228  }
   229  
   230  func TestNewCollectionValueInstanceStructMapPtr(t *testing.T) {
   231  	type T struct {
   232  		Value string
   233  	}
   234  
   235  	value := make(map[string]*T, 0)
   236  
   237  	out, err := NewCollectionValueInstance(value)
   238  	assert.NoError(t, err)
   239  
   240  	expected := &T{}
   241  	assert.Equal(t, expected, out)
   242  
   243  	// Validate that the objects are different instances
   244  	expected.Value = "expected"
   245  	result := out.(*T)
   246  	result.Value = "out"
   247  	assert.NotEqual(t, expected, result)
   248  }
   249  
   250  func TestNewCollectionValueInstanceNotSliceError(t *testing.T) {
   251  	value := 0
   252  	_, err := NewCollectionValueInstance(value)
   253  	assert.Equal(t, ErrNotCollection, err)
   254  }
   255  
   256  func TestSetValueElementaryValue(t *testing.T) {
   257  	var out int
   258  	expected := 1
   259  	assert.Nil(t, SetValue(&out, 1))
   260  	assert.Equal(t, expected, out)
   261  }
   262  
   263  func TestSetValueStructPointer(t *testing.T) {
   264  	out := Test{}
   265  	expected := 1
   266  	assert.Nil(t, SetValue(&out, Test{expected}))
   267  	assert.Equal(t, expected, out.value)
   268  }
   269  
   270  func TestSetValueInterface(t *testing.T) {
   271  	var out Tester
   272  	expected := 1
   273  	assert.Nil(t, SetValue(&out, &Test{expected}))
   274  	assert.Equal(t, expected, out.Value())
   275  }
   276  
   277  func TestSetValueNotPointerError(t *testing.T) {
   278  	out := 1
   279  	assert.Equal(t, ErrNotPointer, SetValue(out, Test{}))
   280  }
   281  
   282  func TestSetValueInvalidOutValueError(t *testing.T) {
   283  	out := 1
   284  	assert.Equal(t, ErrInvalidOutValue, SetValue(&out, Test{}))
   285  }
   286  
   287  func TestNewInstanceElementaryValue(t *testing.T) {
   288  	expected := 1
   289  	out := NewInstance(expected)
   290  	assert.IsType(t, expected, out)
   291  	assert.Equal(t, 0, out)
   292  }
   293  
   294  func TestNewInstanceElementaryValuePointer(t *testing.T) {
   295  	expected := 1
   296  	out := NewInstance(&expected).(*int)
   297  	assert.IsType(t, &expected, out)
   298  	// Since the new instance will contain the zero value, the values should not match
   299  	assert.NotEqual(t, expected, *out)
   300  	// Verify that the output value contains the zero value
   301  	assert.Equal(t, 0, *out)
   302  }
   303  
   304  func TestNewInstanceStructPointer(t *testing.T) {
   305  	expected := &Test{1}
   306  	out := NewInstance(expected).(*Test)
   307  	// Since the new instance will contain the zero value, the values should not match
   308  	assert.NotEqual(t, expected, out)
   309  	// Verify that the output value contains the zero value
   310  	assert.Equal(t, Test{}, *out)
   311  }
   312  
   313  func TestNewInstanceInterface(t *testing.T) {
   314  	expected := &Test{1}
   315  	out := NewInstance(expected).(Tester)
   316  	assert.IsType(t, expected, out)
   317  	// Since the new instance will contain the zero value, the values should not match
   318  	assert.NotEqual(t, expected, out)
   319  	// Verify that the output value contains the zero value
   320  	assert.Equal(t, Test{}, *out.(*Test))
   321  }