fix(go):adjustments to the list serializer

Author: lzaeh

go/fory/fory.go

@@ -372,22 +372,13 @@ func (f *Fory) writeValue(buffer *ByteBuffer, value reflect.Value, serializer Se
 		value = value.Elem()
 	}
 
-	// For array types, pre-convert the value
-	// so the corresponding slice serializer can be reused
-	if value.Kind() == reflect.Array {
-		length := value.Len()
-		sliceType := reflect.SliceOf(value.Type().Elem())
-		slice := reflect.MakeSlice(sliceType, length, length)
-		reflect.Copy(slice, value)
-		value = slice
-	}
-
 	if serializer != nil {
 		return serializer.Write(f, buffer, value)
 	}
 
 	// Get type information for the value
 	typeInfo, err := f.typeResolver.getTypeInfo(value, true)
+
 	if err != nil {
 		return fmt.Errorf("cannot get typeinfo for value %v: %v", value, err)
 	}

go/fory/fory_test.go

@@ -66,7 +66,7 @@ func commonSlice() []interface{} {
 	return []interface{}{
 		(&[100]bool{})[:],
 		(&[100]byte{})[:],
-		// (&[100]int8{})[:],
+		(&[100]int8{})[:],
 		(&[100]int16{})[:],
 		(&[100]int32{})[:],
 		(&[100]int64{})[:],
@@ -106,13 +106,12 @@ func commonArray() []interface{} {
 	return []interface{}{
 		[100]bool{false, true, true},
 		[100]byte{1, 2, 3},
-		// [100]int8{1, 2, 3},
+		[100]int8{1, 2, 3},
 		[100]int16{1, 2, 3},
 		[100]int32{1, 2, 3},
 		[100]int64{1, 2, 3},
 		[100]float32{1, 2, 3},
 		[100]float64{1, 2, 3},
-		[100]string{"str1", "str1"},
 	}
 }
 
@@ -162,7 +161,7 @@ func TestSerializeSlice(t *testing.T) {
 	for _, referenceTracking := range []bool{false, true} {
 		fory := NewFory(referenceTracking)
 		serde(t, fory, []byte{0, 1, MaxUint8})
-		// serde(t, fory, []int8{MinInt8, -1, 0, 1, MaxInt8})
+		serde(t, fory, []int8{MinInt8, -1, 0, 1, MaxInt8})
 		serde(t, fory, []int16{MinInt16, -1, 0, 1, MaxInt16})
 		serde(t, fory, []int32{MinInt32, -1, 0, 1, MaxInt32})
 		serde(t, fory, []int64{MinInt64, -1, 0, 1, MaxInt64})

go/fory/fory_xlang_test.go

@@ -113,34 +113,27 @@ func TestXLangSerializer(t *testing.T) {
 	require.Nil(t, fory_.Serialize(buffer, set, nil))
 
 	// test primitive arrays
-	require.Nil(t, fory_.Serialize(buffer, []bool{true, false}, nil))
-	require.Nil(t, fory_.Serialize(buffer, []int16{1, fory.MaxInt16}, nil))
-	require.Nil(t, fory_.Serialize(buffer, []int32{1, fory.MaxInt32}, nil))
-	require.Nil(t, fory_.Serialize(buffer, []int64{1, fory.MaxInt64}, nil))
-	require.Nil(t, fory_.Serialize(buffer, []float32{1.0, 2.0}, nil))
-	require.Nil(t, fory_.Serialize(buffer, []float64{1.0, 2.0}, nil))
+	require.Nil(t, fory_.Serialize(buffer, [2]bool{true, false}, nil))
+	require.Nil(t, fory_.Serialize(buffer, [2]int16{1, fory.MaxInt16}, nil))
+	require.Nil(t, fory_.Serialize(buffer, [2]int32{1, fory.MaxInt32}, nil))
+	require.Nil(t, fory_.Serialize(buffer, [2]int64{1, fory.MaxInt64}, nil))
+	require.Nil(t, fory_.Serialize(buffer, [2]float32{1.0, 2.0}, nil))
+	require.Nil(t, fory_.Serialize(buffer, [2]float64{1.0, 2.0}, nil))
 
 	check := func(buf *fory.ByteBuffer) {
 		values := []interface{}{
 			true, false, int64(-1), int8(fory.MaxInt8), int8(fory.MinInt8), int16(fory.MaxInt16), int16(fory.MinInt16),
 			int32(fory.MaxInt32), int32(fory.MinInt32), int64(fory.MaxInt64), int64(fory.MinInt64), float32(-1),
 			float64(-1), "str", day, instant, list, dict, set,
-			[]bool{true, false}, []int16{1, fory.MaxInt16}, []int32{1, fory.MaxInt32},
-			[]int64{1, fory.MaxInt64}, []float32{1.0, 2.0}, []float64{1.0, 2.0},
+			[2]bool{true, false}, [2]int16{1, fory.MaxInt16}, [2]int32{1, fory.MaxInt32},
+			[2]int64{1, fory.MaxInt64}, [2]float32{1.0, 2.0}, [2]float64{1.0, 2.0},
 		}
 		for index, value := range values {
-			var newValue interface{}
-			require.Nil(t, fory_.Deserialize(buf, &newValue, nil))
-			switch reflect.ValueOf(value).Kind() {
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				require.Equal(t, reflect.ValueOf(value).Int(),
-					reflect.ValueOf(newValue).Int(), fmt.Sprintf("index %d", index))
-			case reflect.Float32, reflect.Float64:
-				require.Equal(t, reflect.ValueOf(value).Float(),
-					reflect.ValueOf(newValue).Float(), fmt.Sprintf("index %d", index))
-			default:
-				require.Equal(t, value, newValue, fmt.Sprintf("index %d", index))
-			}
+			typ := reflect.TypeOf(value)
+			holder := reflect.New(typ)
+			require.Nil(t, fory_.Deserialize(buf, holder.Interface(), nil))
+			got := holder.Elem().Interface()
+			require.Equal(t, value, got, fmt.Sprintf("index %d", index))
 		}
 	}
 	check(buffer)
@@ -260,7 +253,6 @@ func TestSerializeComplexStruct(t *testing.T) {
 	obj.F10 = 1 / 3.0
 	obj.F11 = [2]int16{1, 2}
 	obj.F12 = []int16{-1, 4}
-
 	structRoundBack(t, fory_, obj, "test_serialize_complex_struct")
 }