remove cycle dependency issue

Author: acabarbaye

utils/field/fields.go

@@ -9,7 +9,7 @@ package field
 import (
 	"time"
 
-	"github.com/ARM-software/golang-utils/utils/reflection"
+	"github.com/ARM-software/golang-utils/utils/value"
 )
 
 // ToOptionalInt returns a pointer to an int
@@ -216,7 +216,7 @@ func ToOptional[T any](v T) *T {
 
 // ToOptionalOrNilIfEmpty returns a pointer to the given field value unless it is empty and in that case returns nil.
 func ToOptionalOrNilIfEmpty[T any](v T) *T {
-	if reflection.IsEmpty(v) {
+	if value.IsEmpty(v) {
 		return nil
 	}
 	return ToOptional[T](v)

utils/reflection/reflection.go

@@ -7,10 +7,10 @@ package reflection
 import (
 	"fmt"
 	"reflect"
-	"strings"
 	"unsafe"
 
 	"github.com/ARM-software/golang-utils/utils/commonerrors"
+	valueUtils "github.com/ARM-software/golang-utils/utils/value"
 )
 
 func GetUnexportedStructureField(structure interface{}, fieldName string) interface{} {
@@ -22,8 +22,8 @@ func GetStructureField(field reflect.Value) interface{} {
 		return nil
 	}
 	return reflect.NewAt(field.Type(), unsafe.Pointer(field.UnsafeAddr())). //nolint:gosec // this conversion is between types recommended by Go https://cs.opensource.google/go/go/+/master:src/reflect/value.go;l=2445
-										Elem().
-										Interface()
+		Elem().
+		Interface()
 }
 func SetUnexportedStructureField(structure interface{}, fieldName string, value interface{}) {
 	SetStructureField(fetchStructureField(structure, fieldName), value)
@@ -33,8 +33,8 @@ func SetStructureField(field reflect.Value, value interface{}) {
 		return
 	}
 	reflect.NewAt(field.Type(), unsafe.Pointer(field.UnsafeAddr())). //nolint:gosec // this conversion is between types recommended by Go https://cs.opensource.google/go/go/+/master:src/reflect/value.go;l=2445
-										Elem().
-										Set(reflect.ValueOf(value))
+		Elem().
+		Set(reflect.ValueOf(value))
 }
 
 func fetchStructureField(structure interface{}, fieldName string) reflect.Value {
@@ -198,36 +198,7 @@ func InheritsFrom(object interface{}, parentType reflect.Type) bool {
 // IsEmpty checks whether a value is empty i.e. "", nil, 0, [], {}, false, etc.
 // For Strings, a string is considered empty if it is "" or if it only contains whitespaces
 func IsEmpty(value any) bool {
-	if value == nil {
-		return true
-	}
-	if valueStr, ok := value.(string); ok {
-		return len(strings.TrimSpace(valueStr)) == 0
-	}
-	if valueStrPtr, ok := value.(*string); ok {
-		if valueStrPtr == nil {
-			return true
-		}
-		return len(strings.TrimSpace(*valueStrPtr)) == 0
-	}
-	if valueBool, ok := value.(bool); ok {
-		// if set to true, then value is not empty
-		return !valueBool
-	}
-	objValue := reflect.ValueOf(value)
-	switch objValue.Kind() {
-	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
-		return objValue.Len() == 0
-	case reflect.Ptr:
-		if objValue.IsNil() {
-			return true
-		}
-		deref := objValue.Elem().Interface()
-		return IsEmpty(deref)
-	default:
-		zero := reflect.Zero(objValue.Type())
-		return reflect.DeepEqual(value, zero.Interface())
-	}
+	return valueUtils.IsEmpty(value)
 }
 
 // ToStructPtr returns an instance of the pointer (interface) to the object obj.

utils/value/empty.go

@@ -0,0 +1,41 @@
+package value
+
+import (
+	"reflect"
+	"strings"
+)
+
+// IsEmpty checks whether a value is empty i.e. "", nil, 0, [], {}, false, etc.
+// For Strings, a string is considered empty if it is "" or if it only contains whitespaces
+func IsEmpty(value any) bool {
+	if value == nil {
+		return true
+	}
+	if valueStr, ok := value.(string); ok {
+		return len(strings.TrimSpace(valueStr)) == 0
+	}
+	if valueStrPtr, ok := value.(*string); ok {
+		if valueStrPtr == nil {
+			return true
+		}
+		return len(strings.TrimSpace(*valueStrPtr)) == 0
+	}
+	if valueBool, ok := value.(bool); ok {
+		// if set to true, then value is not empty
+		return !valueBool
+	}
+	objValue := reflect.ValueOf(value)
+	switch objValue.Kind() {
+	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
+		return objValue.Len() == 0
+	case reflect.Ptr:
+		if objValue.IsNil() {
+			return true
+		}
+		deref := objValue.Elem().Interface()
+		return IsEmpty(deref)
+	default:
+		zero := reflect.Zero(objValue.Type())
+		return reflect.DeepEqual(value, zero.Interface())
+	}
+}

utils/value/empty_test.go

@@ -0,0 +1,136 @@
+package value
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsEmpty(t *testing.T) {
+	type testInterface interface {
+	}
+	var testEmptyPtr testInterface
+	emptyStr := ""
+	whiteSpace := "                  "
+
+	aFilledChannel := make(chan struct{}, 1)
+	aFilledChannel <- struct{}{}
+	tests := []struct {
+		value                  interface{}
+		isEmpty                bool
+		differsFromAssertEmpty bool
+	}{
+		{
+			value:   nil,
+			isEmpty: true,
+		},
+		{
+			value:   0,
+			isEmpty: true,
+		},
+		{
+			value:   uint(0),
+			isEmpty: true,
+		},
+		{
+			value:   float64(0),
+			isEmpty: true,
+		},
+		{
+			value:   "",
+			isEmpty: true,
+		},
+		{
+			value:                  "                                   ",
+			isEmpty:                true,
+			differsFromAssertEmpty: true,
+		},
+		{
+			value:   (*string)(nil),
+			isEmpty: true,
+		},
+		{
+			value:   &emptyStr,
+			isEmpty: true,
+		},
+		{
+			value:                  &whiteSpace,
+			isEmpty:                true,
+			differsFromAssertEmpty: true,
+		},
+		{
+			value:   false,
+			isEmpty: true,
+		},
+		{
+			value:   []string{},
+			isEmpty: true,
+		},
+		{
+			value:   []int64{},
+			isEmpty: true,
+		},
+		{
+			value:   []int64{int64(0)},
+			isEmpty: false,
+		},
+		{
+			value:   "blah",
+			isEmpty: false,
+		},
+		{
+			value:   1,
+			isEmpty: false,
+		},
+		{
+			value:   true,
+			isEmpty: false,
+		},
+		{
+			value:   testEmptyPtr,
+			isEmpty: true,
+		},
+		{
+			value:   map[string]string{},
+			isEmpty: true,
+		},
+		{
+			value:   map[string]interface{}{},
+			isEmpty: true,
+		},
+		{
+			value:   map[string]interface{}{"foo": "bar"},
+			isEmpty: false,
+		},
+		{
+			value:   time.Time{},
+			isEmpty: true,
+		},
+		{
+			value:   time.Now(),
+			isEmpty: false,
+		},
+		{
+			value:   make(chan struct{}),
+			isEmpty: true,
+		},
+		{
+			value:   aFilledChannel,
+			isEmpty: false,
+		},
+	}
+
+	for i := range tests {
+		test := tests[i]
+		t.Run(fmt.Sprintf("subtest #%v (%v)", i, test.value), func(t *testing.T) {
+			assert.Equal(t, test.isEmpty, IsEmpty(test.value))
+			if test.isEmpty && !test.differsFromAssertEmpty {
+				assert.Empty(t, test.value)
+			} else {
+				assert.NotEmpty(t, test.value)
+			}
+		})
+	}
+}