add SliceIntE

cvte.go

@@ -457,6 +457,24 @@ func SliceE(val interface{}) (sl []interface{}, err error) {
 	return nil, newErr(val, "slice")
 }
 
+// SliceIntE convert an interface to a []int type
+func SliceIntE(val interface{}) (sl []int, err error) {
+	list, err := SliceE(val)
+	if err != nil {
+		return
+	}
+
+	for _, v := range list {
+		vv, err := IntE(v)
+		if err != nil {
+			return nil, err
+		}
+		sl = append(sl, vv)
+	}
+
+	return
+}
+
 // return the values of struct fields, and deep find the embedded fields
 func deepStructValues(rt reflect.Type, rv reflect.Value) (sl []interface{}) {
 	for j := 0; j < rv.NumField(); j++ {

cvte_test.go

@@ -1413,6 +1413,56 @@ func TestSliceE(t *testing.T) {
 	}
 }
 
+func TestSliceIntE(t *testing.T) {
+	tests := []struct {
+		input  interface{}
+		expect []int
+		isErr  bool
+	}{
+		{[]int{}, nil, false},
+		{[]int{1, 2, 3}, []int{1, 2, 3}, false},
+		{[]string{}, nil, false},
+		{[]interface{}{1, "-1", -1, nil}, []int{1, -1, -1, 0}, false},
+		{[...]string{}, nil, false},
+		{[...]string{"1", "2", "3"}, []int{1, 2, 3}, false},
+
+		// sorted by key asc
+		{map[int]string{}, nil, false},
+		{map[int]string{2: "222", 1: "111"}, []int{111, 222}, false},
+		{map[int]TestStructC{}, nil, false},
+		{map[interface{}]string{
+			1:    "1",
+			0:    "0",
+			-1:   "-1",
+			-0.1: "-0.1",
+		}, []int{0, -1, 0, 1}, false},
+
+		{testing.T{}, nil, false},
+		{&testing.T{}, nil, false},
+
+		// errors
+		{int(123), nil, true},
+		{uint16(123), nil, true},
+		{float64(12.3), nil, true},
+		{func() {}, nil, true},
+		{nil, nil, true},
+		{[]string{"a", "b", "c"}, nil, true},
+	}
+
+	for i, tt := range tests {
+		msg := fmt.Sprintf("i = %d, input[%+v], expect[%+v], isErr[%v]", i, tt.input, tt.expect, tt.isErr)
+
+		v, err := cvt.SliceIntE(tt.input)
+		if tt.isErr {
+			assert.Error(t, err, msg)
+			continue
+		}
+
+		assert.NoError(t, err, msg)
+		assert.Equal(t, tt.expect, v, msg)
+	}
+}
+
 func TestFieldE(t *testing.T) {
 	tests := []struct {
 		input  interface{}