✅ test: arr,reflects - add more unit cases

arrutil/collection.go

@@ -104,9 +104,7 @@ func TwowaySearch[T any](data []T, item T, fn Comparer[T]) (int, error) {
 //	returns: the cloned slice.
 func CloneSlice[T any](data []T) []T {
 	nt := make([]T, 0, len(data))
-	for _, v := range data {
-		nt = append(nt, v)
-	}
+	nt = append(nt, data...)
 	return nt
 }
 

cliutil/cmdline/builder.go

@@ -55,13 +55,13 @@ func (b *LineBuilder) WriteString(a string) (int, error) {
 	if pos := strings.IndexByte(a, '"'); pos > -1 {
 		quote = '\''
 		// fix: a = `--pretty=format:"one two three"`
-		if pos > 0 && '"' == a[len(a)-1] {
+		if pos > 0 && a[len(a)-1] == '"' {
 			quote = 0
 		}
 	} else if pos := strings.IndexByte(a, '\''); pos > -1 {
 		quote = '"'
 		// fix: a = "--pretty=format:'one two three'"
-		if pos > 0 && '\'' == a[len(a)-1] {
+		if pos > 0 && a[len(a)-1] == '\'' {
 			quote = 0
 		}
 	} else if a == "" || strings.ContainsRune(a, ' ') {

reflects/type.go

@@ -55,6 +55,8 @@ type Type interface {
 	reflect.Type
 	// BaseKind value
 	BaseKind() BKind
+	// RealType returns a ptr type's real type. otherwise, will return self.
+	RealType() reflect.Type
 	// SafeElem returns a type's element type. otherwise, will return self.
 	SafeElem() reflect.Type
 }
@@ -81,18 +83,10 @@ func (t *xType) BaseKind() BKind {
 
 // RealType returns a ptr type's real type. otherwise, will return self.
 func (t *xType) RealType() reflect.Type {
-	if t.Kind() == reflect.Pointer {
-		return t.Type.Elem()
-	}
-	return t.Type
+	return TypeReal(t.Type)
 }
 
 // SafeElem returns the array, slice, chan, map type's element type. otherwise, will return self.
 func (t *xType) SafeElem() reflect.Type {
-	switch t.Kind() {
-	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
-		return t.Type.Elem()
-	default:
-		return t.Type
-	}
+	return TypeElem(t.Type)
 }

reflects/type_test.go

@@ -22,4 +22,19 @@ func TestTypeOf(t *testing.T) {
 
 	assert.Eq(t, reflect.Int64, rt.Kind())
 	assert.Eq(t, reflects.Int, rt.BaseKind())
+
+	assert.Eq(t, reflect.Int64, rt.RealType().Kind())
+	assert.Eq(t, reflect.Int64, rt.SafeElem().Kind())
+
+	s := new(string)
+	*s = "abc"
+	rt = reflects.TypeOf(s)
+	assert.Eq(t, reflect.Pointer, rt.Kind())
+	assert.Eq(t, reflect.String, rt.RealType().Kind())
+	assert.Eq(t, reflect.Pointer, rt.SafeElem().Kind())
+
+	ss := []string{"abc"}
+	rt = reflects.TypeOf(ss)
+	assert.Eq(t, reflect.Slice, rt.Kind())
+	assert.Eq(t, reflect.String, rt.SafeElem().Kind())
 }

reflects/value.go

@@ -31,7 +31,7 @@ func ValueOf(v any) Value {
 
 // Indirect value. alias of the reflect.Indirect()
 func (v Value) Indirect() Value {
-	if v.Kind() != reflect.Ptr {
+	if v.Kind() != reflect.Pointer {
 		return v
 	}
 
@@ -48,7 +48,6 @@ func (v Value) Indirect() Value {
 func (v Value) Elem() Value {
 	if v.Kind() == reflect.Pointer || v.Kind() == reflect.Interface {
 		elem := v.Value.Elem()
-
 		return Value{
 			Value:    elem,
 			baseKind: ToBKind(elem.Kind()),

reflects/value_test.go

@@ -22,12 +22,19 @@ func TestValueOf(t *testing.T) {
 	assert.Eq(t, int64(23), rv.Int())
 	assert.False(t, rv.HasChild())
 	assert.Eq(t, reflects.Uint, rv.Type().BaseKind())
+	assert.Eq(t, reflects.Uint, rv.Indirect().BaseKind())
 
 	rv = reflects.ValueOf(reflect.ValueOf("abc"))
 	assert.Eq(t, "abc", rv.String())
 	assert.Eq(t, "abc", rv.Elem().String())
 	assert.Eq(t, reflect.String, rv.Type().BaseKind())
 
+	// pointer
+	s := new(string)
+	*s = "abc"
+	rv = reflects.ValueOf(s)
+	assert.Eq(t, reflect.String, rv.Elem().Kind())
+
 	rv = reflects.ValueOf("abc")
 	assert.Panics(t, func() {
 		rv.Int()

testutil/fakeobj/io.go

@@ -6,6 +6,35 @@ import (
 	"github.com/gookit/goutil/byteutil"
 )
 
+// IOWriter only implements the io.Writer
+type IOWriter struct {
+	Buf []byte
+	// ErrOnWrite return error on write, useful for testing
+	ErrOnWrite bool
+}
+
+// NewIOWriter instance
+func NewIOWriter() *IOWriter {
+	return &IOWriter{
+		Buf: make([]byte, 0, 1024),
+	}
+}
+
+// Write implements
+func (w *IOWriter) Write(p []byte) (n int, err error) {
+	if w.ErrOnWrite {
+		return 0, errors.New("fake write error")
+	}
+
+	w.Buf = append(w.Buf, p...)
+	return len(p), nil
+}
+
+// Reset the buffer
+func (w *IOWriter) Reset() {
+	w.Buf = w.Buf[:0]
+}
+
 // Reader implements the io.Reader
 type Reader struct {
 	byteutil.Buffer

testutil/fakeobj/io_test.go

@@ -7,6 +7,20 @@ import (
 	"github.com/gookit/goutil/testutil/fakeobj"
 )
 
+func TestIOWriter(t *testing.T) {
+	w := fakeobj.NewIOWriter()
+
+	m, err := w.Write([]byte("hello"))
+	assert.Eq(t, 5, m)
+	assert.NoErr(t, err)
+	assert.Eq(t, "hello", string(w.Buf))
+
+	w.Reset()
+	w.ErrOnWrite = true
+	_, err = w.Write([]byte("hello"))
+	assert.Err(t, err)
+}
+
 func TestNewReader(t *testing.T) {
 	tr := fakeobj.NewReader()
 	tr.Write([]byte("hello"))