filename rename And unit test cover

sliceUtil/chunk_slice_test.go

@@ -0,0 +1,156 @@
+package sliceUtil
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestChunk(t *testing.T) {
+	tests := []struct {
+		name  string
+		slice []interface{}
+		size  int
+		want  [][]interface{}
+	}{
+		{
+			name:  "empty slice",
+			slice: []interface{}{},
+			size:  3,
+			want:  [][]interface{}{},
+		},
+		{
+			name:  "slice with less than chunk size",
+			slice: []interface{}{1, 2},
+			size:  3,
+			want:  [][]interface{}{{1, 2}},
+		},
+		{
+			name:  "slice with exact chunk size",
+			slice: []interface{}{1, 2, 3, 4, 5, 6},
+			size:  3,
+			want:  [][]interface{}{{1, 2, 3}, {4, 5, 6}},
+		},
+		{
+			name:  "slice with more than chunk size",
+			slice: []interface{}{1, 2, 3, 4, 5, 6, 7},
+			size:  3,
+			want:  [][]interface{}{{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)
+			if len(got) != len(tt.want) {
+				t.Errorf("Chunk() = %+v, want %+v", got, tt.want)
+				return
+			}
+			for i := range got {
+				if !reflect.DeepEqual(got[i], tt.want[i]) {
+					t.Errorf("Chunk() = %+v, want %+v", got, tt.want)
+					break
+				}
+			}
+		})
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkStr(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkInt(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkInt8(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkInt32(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkInt64(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkUint(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkUint8(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkUint16(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkUint32(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}
+
+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)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ChunkUint64(%v, %d) = %v; expected %v", slice, size, result, expected)
+	}
+}

sliceUtil/chunk_test.go

@@ -1,56 +0,0 @@
-package sliceUtil
-
-import (
-	"reflect"
-	"testing"
-)
-
-func TestChunk(t *testing.T) {
-	tests := []struct {
-		name  string
-		slice []interface{}
-		size  int
-		want  [][]interface{}
-	}{
-		{
-			name:  "empty slice",
-			slice: []interface{}{},
-			size:  3,
-			want:  [][]interface{}{},
-		},
-		{
-			name:  "slice with less than chunk size",
-			slice: []interface{}{1, 2},
-			size:  3,
-			want:  [][]interface{}{{1, 2}},
-		},
-		{
-			name:  "slice with exact chunk size",
-			slice: []interface{}{1, 2, 3, 4, 5, 6},
-			size:  3,
-			want:  [][]interface{}{{1, 2, 3}, {4, 5, 6}},
-		},
-		{
-			name:  "slice with more than chunk size",
-			slice: []interface{}{1, 2, 3, 4, 5, 6, 7},
-			size:  3,
-			want:  [][]interface{}{{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)
-			if len(got) != len(tt.want) {
-				t.Errorf("Chunk() = %+v, want %+v", got, tt.want)
-				return
-			}
-			for i := range got {
-				if !reflect.DeepEqual(got[i], tt.want[i]) {
-					t.Errorf("Chunk() = %+v, want %+v", got, tt.want)
-					break
-				}
-			}
-		})
-	}
-}

sliceUtil/in_slice_test.go

@@ -0,0 +1,141 @@
+package sliceUtil
+
+import (
+	"testing"
+)
+
+func TestInSlices(t *testing.T) {
+	slices := []interface{}{1, "hello", 3.14}
+	if !InSlices(1, slices) {
+		t.Errorf("1 should be in slices %v", slices)
+	}
+	if !InSlices("hello", slices) {
+		t.Errorf("hello should be in slices %v", slices)
+	}
+	if InSlices(2, slices) {
+		t.Errorf("2 should not be in slices %v", slices)
+	}
+}
+
+func TestInStrSlices(t *testing.T) {
+	slices := []string{"apple", "banana", "cherry"}
+	if !InStrSlices("apple", slices) {
+		t.Errorf("apple should be in slices %v", slices)
+	}
+	if !InStrSlices("banana", slices) {
+		t.Errorf("banana should be in slices %v", slices)
+	}
+	if InStrSlices("orange", slices) {
+		t.Errorf("orange should not be in slices %v", slices)
+	}
+}
+
+func TestInIntSlices(t *testing.T) {
+	slices := []int{1, 2, 3, 4, 5}
+	if !InIntSlices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InIntSlices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}
+
+func TestInInt8Slices(t *testing.T) {
+	slices := []int8{1, 2, 3, 4, 5}
+	if !InInt8Slices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InInt8Slices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}
+
+func TestInInt16Slices(t *testing.T) {
+	slices := []int16{1, 2, 3, 4, 5}
+	if !InInt16Slices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InInt16Slices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}
+
+func TestInInt32Slices(t *testing.T) {
+	slices := []int32{1, 2, 3, 4, 5}
+	if !InInt32Slices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InInt32Slices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}
+
+func TestInInt64Slices(t *testing.T) {
+	slices := []int64{1, 2, 3, 4, 5}
+	if !InInt64Slices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InInt64Slices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}
+
+func TestInUintSlices(t *testing.T) {
+	slices := []uint{1, 2, 3, 4, 5}
+	if !InUintSlices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InUintSlices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}
+
+func TestInUint8Slices(t *testing.T) {
+	slices := []uint8{1, 2, 3, 4, 5}
+	if !InUint8Slices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InUint8Slices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}
+
+func TestInUint16Slices(t *testing.T) {
+	slices := []uint16{1, 2, 3, 4, 5}
+	if !InUint16Slices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InUint16Slices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}
+
+func TestInUint32Slices(t *testing.T) {
+	slices := []uint32{1, 2, 3, 4, 5}
+	if !InUint32Slices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InUint32Slices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}
+
+func TestInUint64Slices(t *testing.T) {
+	slices := []uint64{1, 2, 3, 4, 5}
+	if !InUint64Slices(3, slices) {
+		t.Errorf("Expected true, but got false")
+	}
+
+	if InUint64Slices(6, slices) {
+		t.Errorf("Expected false, but got true")
+	}
+}

sliceUtil/in_test.go

@@ -1,31 +0,0 @@
-package sliceUtil
-
-import (
-	"testing"
-)
-
-func TestInSlices(t *testing.T) {
-	slices := []interface{}{1, "hello", 3.14}
-	if !InSlices(1, slices) {
-		t.Errorf("1 should be in slices %v", slices)
-	}
-	if !InSlices("hello", slices) {
-		t.Errorf("hello should be in slices %v", slices)
-	}
-	if InSlices(2, slices) {
-		t.Errorf("2 should not be in slices %v", slices)
-	}
-}
-
-func TestInStrSlices(t *testing.T) {
-	slices := []string{"apple", "banana", "cherry"}
-	if !InStrSlices("apple", slices) {
-		t.Errorf("apple should be in slices %v", slices)
-	}
-	if !InStrSlices("banana", slices) {
-		t.Errorf("banana should be in slices %v", slices)
-	}
-	if InStrSlices("orange", slices) {
-		t.Errorf("orange should not be in slices %v", slices)
-	}
-}

sliceUtil/merge_slice_test.go

@@ -0,0 +1,160 @@
+package sliceUtil
+
+import (
+	"reflect"
+	"testing"
+)
+
+// 测试MergeSlices
+func TestMergeSlices(t *testing.T) {
+	slice1 := []interface{}{1, 2, 3}
+	slice2 := []interface{}{4, 5, 6}
+	slice3 := []interface{}{7, 8, 9}
+	expected := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	result := MergeSlices(slice1, slice2, slice3)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v, but got %v", expected, result)
+	}
+}
+
+// 测试MergeStrSlices
+func TestMergeStrSlices(t *testing.T) {
+	slice1 := []string{"a", "b", "c"}
+	slice2 := []string{"d", "e", "f"}
+	slice3 := []string{"g", "h", "i"}
+	expected := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i"}
+	result := MergeStrSlices(slice1, slice2, slice3)
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v, but got %v", expected, result)
+	}
+}
+
+func TestMergeIntSlices(t *testing.T) {
+	slice1 := []int{1, 2, 3}
+	slice2 := []int{4, 5, 6}
+	slice3 := []int{7, 8, 9}
+	expected := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeIntSlices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestMergeInt8Slices(t *testing.T) {
+	slice1 := []int8{1, 2, 3}
+	slice2 := []int8{4, 5, 6}
+	slice3 := []int8{7, 8, 9}
+	expected := []int8{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeInt8Slices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestMergeInt16Slices(t *testing.T) {
+	slice1 := []int16{1, 2, 3}
+	slice2 := []int16{4, 5, 6}
+	slice3 := []int16{7, 8, 9}
+	expected := []int16{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeInt16Slices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestMergeInt32Slices(t *testing.T) {
+	slice1 := []int32{1, 2, 3}
+	slice2 := []int32{4, 5, 6}
+	slice3 := []int32{7, 8, 9}
+	expected := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeInt32Slices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestMergeInt64Slices(t *testing.T) {
+	slice1 := []int64{1, 2, 3}
+	slice2 := []int64{4, 5, 6}
+	slice3 := []int64{7, 8, 9}
+	expected := []int64{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeInt64Slices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestMergeUintSlices(t *testing.T) {
+	slice1 := []uint{1, 2, 3}
+	slice2 := []uint{4, 5, 6}
+	slice3 := []uint{7, 8, 9}
+	expected := []uint{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeUintSlices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestMergeUint8Slices(t *testing.T) {
+	slice1 := []uint8{1, 2, 3}
+	slice2 := []uint8{4, 5, 6}
+	slice3 := []uint8{7, 8, 9}
+	expected := []uint8{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeUint8Slices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestMergeUint16Slices(t *testing.T) {
+	slice1 := []uint16{1, 2, 3}
+	slice2 := []uint16{4, 5, 6}
+	slice3 := []uint16{7, 8, 9}
+	expected := []uint16{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeUint16Slices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestMergeUint32Slices(t *testing.T) {
+	slice1 := []uint32{1, 2, 3}
+	slice2 := []uint32{4, 5, 6}
+	slice3 := []uint32{7, 8, 9}
+	expected := []uint32{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeUint32Slices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestMergeUint64Slices(t *testing.T) {
+	slice1 := []uint64{1, 2, 3}
+	slice2 := []uint64{4, 5, 6}
+	slice3 := []uint64{7, 8, 9}
+	expected := []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	result := MergeUint64Slices(slice1, slice2, slice3)
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}

sliceUtil/merge_test.go

@@ -1,30 +0,0 @@
-package sliceUtil
-
-import (
-	"reflect"
-	"testing"
-)
-
-// 测试MergeSlices
-func TestMergeSlices(t *testing.T) {
-	slice1 := []interface{}{1, 2, 3}
-	slice2 := []interface{}{4, 5, 6}
-	slice3 := []interface{}{7, 8, 9}
-	expected := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9}
-	result := MergeSlices(slice1, slice2, slice3)
-	if !reflect.DeepEqual(result, expected) {
-		t.Errorf("Expected %v, but got %v", expected, result)
-	}
-}
-
-// 测试MergeStrSlices
-func TestMergeStrSlices(t *testing.T) {
-	slice1 := []string{"a", "b", "c"}
-	slice2 := []string{"d", "e", "f"}
-	slice3 := []string{"g", "h", "i"}
-	expected := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i"}
-	result := MergeStrSlices(slice1, slice2, slice3)
-	if !reflect.DeepEqual(result, expected) {
-		t.Errorf("Expected %v, but got %v", expected, result)
-	}
-}

sliceUtil/not_int.go

@@ -1 +0,0 @@
-package sliceUtil

sliceUtil/not_int_test.go

@@ -1 +0,0 @@
-package sliceUtil

sliceUtil/sum_slice_test.go

@@ -0,0 +1,179 @@
+package sliceUtil
+
+import "testing"
+
+func TestSumIntSlice(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{
+			name:     "Empty Slice",
+			input:    []int{},
+			expected: 0,
+		},
+		{
+			name:     "One Element Slice",
+			input:    []int{1},
+			expected: 1,
+		},
+		{
+			name:     "Multiple Elements Slice",
+			input:    []int{1, 2, 3, 4, 5},
+			expected: 15,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := SumIntSlice(tc.input)
+			if result != tc.expected {
+				t.Errorf("Expected %d but got %d", tc.expected, result)
+			}
+		})
+	}
+}
+
+func TestSumInt8Slice(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    []int8
+		expected int8
+	}{
+		{
+			name:     "Empty Slice",
+			input:    []int8{},
+			expected: 0,
+		},
+		{
+			name:     "One Element Slice",
+			input:    []int8{1},
+			expected: 1,
+		},
+		{
+			name:     "Multiple Elements Slice",
+			input:    []int8{1, 2, 3, 4, 5},
+			expected: 15,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := SumInt8Slice(tc.input)
+			if result != tc.expected {
+				t.Errorf("Expected %d but got %d", tc.expected, result)
+			}
+		})
+	}
+}
+
+// 测试SumInt16Slice函数
+func TestSumInt16Slice(t *testing.T) {
+	tests := []struct {
+		name  string
+		slice []int16
+		want  int16
+	}{
+		{"empty slice", []int16{}, 0},
+		{"one element slice", []int16{1}, 1},
+		{"multiple element slice", []int16{1, 2, 3}, 6},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := SumInt16Slice(tt.slice)
+			if got != tt.want {
+				t.Errorf("SumInt16Slice(%v) = %v, want %v", tt.slice, got, tt.want)
+			}
+		})
+	}
+}
+
+// 测试SumInt32Slice函数
+func TestSumInt32Slice(t *testing.T) {
+	tests := []struct {
+		name  string
+		slice []int32
+		want  int32
+	}{
+		{"empty slice", []int32{}, 0},
+		{"one element slice", []int32{1}, 1},
+		{"multiple element slice", []int32{1, 2, 3}, 6},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := SumInt32Slice(tt.slice)
+			if got != tt.want {
+				t.Errorf("SumInt32Slice(%v) = %v, want %v", tt.slice, got, tt.want)
+			}
+		})
+	}
+}
+
+// 测试SumInt64Slice函数
+func TestSumInt64Slice(t *testing.T) {
+	tests := []struct {
+		name  string
+		slice []int64
+		want  int64
+	}{
+		{"empty slice", []int64{}, 0},
+		{"one element slice", []int64{1}, 1},
+		{"multiple element slice", []int64{1, 2, 3}, 6},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := SumInt64Slice(tt.slice)
+			if got != tt.want {
+				t.Errorf("SumInt64Slice(%v) = %v, want %v", tt.slice, got, tt.want)
+			}
+		})
+	}
+}
+
+// 测试SumFloat32Slice函数
+func TestSumFloat32Slice(t *testing.T) {
+	tests := []struct {
+		name  string
+		slice []float32
+		want  float32
+	}{
+		{"empty slice", []float32{}, 0},
+		{"one element slice", []float32{1.0}, 1.0},
+		{"multiple element slice", []float32{1.0, 2.0, 3.0}, 6.0},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := SumFloat32Slice(tt.slice)
+			if got != tt.want {
+				t.Errorf("SumFloat32Slice(%v) = %v, want %v", tt.slice, got, tt.want)
+			}
+		})
+	}
+}
+
+// 测试SumFloat64Slice函数
+func TestSumFloat64Slice(t *testing.T) {
+	tests := []struct {
+		name  string
+		slice []float64
+		want  float64
+	}{
+		{"empty slice", []float64{}, 0},
+		{"one element slice", []float64{1.0}, 1.0},
+		{"multiple element slice", []float64{1.0, 2.0, 3.0}, 6.0},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := SumFloat64Slice(tt.slice)
+			if got != tt.want {
+				t.Errorf("SumFloat64Slice(%v) = %v, want %v", tt.slice, got, tt.want)
+			}
+		})
+	}
+}

sliceUtil/sum_test.go

@@ -1,69 +0,0 @@
-package sliceUtil
-
-import "testing"
-
-func TestSumIntSlice(t *testing.T) {
-	testCases := []struct {
-		name     string
-		input    []int
-		expected int
-	}{
-		{
-			name:     "Empty Slice",
-			input:    []int{},
-			expected: 0,
-		},
-		{
-			name:     "One Element Slice",
-			input:    []int{1},
-			expected: 1,
-		},
-		{
-			name:     "Multiple Elements Slice",
-			input:    []int{1, 2, 3, 4, 5},
-			expected: 15,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result := SumIntSlice(tc.input)
-			if result != tc.expected {
-				t.Errorf("Expected %d but got %d", tc.expected, result)
-			}
-		})
-	}
-}
-
-func TestSumInt8Slice(t *testing.T) {
-	testCases := []struct {
-		name     string
-		input    []int8
-		expected int8
-	}{
-		{
-			name:     "Empty Slice",
-			input:    []int8{},
-			expected: 0,
-		},
-		{
-			name:     "One Element Slice",
-			input:    []int8{1},
-			expected: 1,
-		},
-		{
-			name:     "Multiple Elements Slice",
-			input:    []int8{1, 2, 3, 4, 5},
-			expected: 15,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result := SumInt8Slice(tc.input)
-			if result != tc.expected {
-				t.Errorf("Expected %d but got %d", tc.expected, result)
-			}
-		})
-	}
-}