Feature/generic type (#19)

Supports generics and any

sliceUtil/chunk_slice_test.go

@@ -8,39 +8,39 @@ import (
 func TestChunk(t *testing.T) {
 	tests := []struct {
 		name  string
-		slice []interface{}
+		slice []any
 		size  int
-		want  [][]interface{}
+		want  [][]any
 	}{
 		{
 			name:  "empty slice",
-			slice: []interface{}{},
+			slice: []any{},
 			size:  3,
-			want:  [][]interface{}{},
+			want:  [][]any{},
 		},
 		{
 			name:  "slice with less than chunk size",
-			slice: []interface{}{1, 2},
+			slice: []any{1, 2},
 			size:  3,
-			want:  [][]interface{}{{1, 2}},
+			want:  [][]any{{1, 2}},
 		},
 		{
 			name:  "slice with exact chunk size",
-			slice: []interface{}{1, 2, 3, 4, 5, 6},
+			slice: []any{1, 2, 3, 4, 5, 6},
 			size:  3,
-			want:  [][]interface{}{{1, 2, 3}, {4, 5, 6}},
+			want:  [][]any{{1, 2, 3}, {4, 5, 6}},
 		},
 		{
 			name:  "slice with more than chunk size",
-			slice: []interface{}{1, 2, 3, 4, 5, 6, 7},
+			slice: []any{1, 2, 3, 4, 5, 6, 7},
 			size:  3,
-			want:  [][]interface{}{{1, 2, 3}, {4, 5, 6}, {7}},
+			want:  [][]any{{1, 2, 3}, {4, 5, 6}, {7}},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := Chunk(tt.slice, tt.size)
+			got := ChunkSlice(tt.slice, tt.size)
 			if len(got) != len(tt.want) {
 				t.Errorf("Chunk() = %+v, want %+v", got, tt.want)
 				return
@@ -59,7 +59,7 @@ func TestChunkStr(t *testing.T) {
 	slice := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"}
 	size := 3
 	expected := [][]string{{"a", "b", "c"}, {"d", "e", "f"}, {"g", "h", "i"}, {"j", "k"}}
-	result := ChunkStr(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkStr(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}
@@ -69,7 +69,7 @@ func TestChunkInt(t *testing.T) {
 	slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
 	size := 4
 	expected := [][]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11}}
-	result := ChunkInt(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkInt(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}
@@ -79,7 +79,7 @@ func TestChunkInt8(t *testing.T) {
 	slice := []int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
 	size := 4
 	expected := [][]int8{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11}}
-	result := ChunkInt8(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkInt8(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}
@@ -89,7 +89,7 @@ func TestChunkInt32(t *testing.T) {
 	slice := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
 	size := 4
 	expected := [][]int32{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11}}
-	result := ChunkInt32(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkInt32(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}
@@ -99,7 +99,7 @@ func TestChunkInt64(t *testing.T) {
 	slice := []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
 	size := 4
 	expected := [][]int64{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11}}
-	result := ChunkInt64(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkInt64(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}
@@ -109,7 +109,7 @@ func TestChunkUint(t *testing.T) {
 	slice := []uint{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
 	size := 4
 	expected := [][]uint{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11}}
-	result := ChunkUint(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkUint(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}
@@ -119,7 +119,7 @@ func TestChunkUint8(t *testing.T) {
 	slice := []uint8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
 	size := 4
 	expected := [][]uint8{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11}}
-	result := ChunkUint8(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkUint8(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}
@@ -129,7 +129,7 @@ func TestChunkUint16(t *testing.T) {
 	slice := []uint16{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
 	size := 4
 	expected := [][]uint16{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11}}
-	result := ChunkUint16(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkUint16(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}
@@ -139,7 +139,7 @@ func TestChunkUint32(t *testing.T) {
 	slice := []uint32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
 	size := 4
 	expected := [][]uint32{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11}}
-	result := ChunkUint32(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkUint32(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}
@@ -149,7 +149,7 @@ func TestChunkUint64(t *testing.T) {
 	slice := []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
 	size := 4
 	expected := [][]uint64{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11}}
-	result := ChunkUint64(slice, size)
+	result := ChunkSlice(slice, size)
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("ChunkUint64(%v, %d) = %v; expected %v", slice, size, result, expected)
 	}