fix(net/ghttp): panic when post empty string parameter to *ghttp.UploadFile

util/gconv/gconv_scan.go

@@ -18,7 +18,7 @@ package gconv
 // TODO: change `paramKeyToAttrMap` to `ScanOption` to be more scalable; add `DeepCopy` option for `ScanOption`.
 func Scan(srcValue any, dstPointer any, paramKeyToAttrMap ...map[string]string) (err error) {
 	option := ScanOption{
-		ContinueOnError: true,
+		ContinueOnError: false,
 	}
 	if len(paramKeyToAttrMap) > 0 {
 		option.ParamKeyToAttrMap = paramKeyToAttrMap[0]

util/gconv/gconv_z_unit_map_test.go

@@ -164,6 +164,7 @@ var mapTests = []struct {
 func TestMap(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		for _, test := range mapTests {
+			// t.Log(test.value, test.expect)
 			t.Assert(gconv.Map(test.value), test.expect)
 		}
 	})

util/gconv/gconv_z_unit_struct_test.go

@@ -225,7 +225,6 @@ func TestStructErr(t *testing.T) {
 		type User struct {
 			Score Score
 		}
-
 		user := new(User)
 		scores := map[string]interface{}{
 			"Score": 1,

util/gconv/internal/converter/converter_convert.go

@@ -395,7 +395,11 @@ func (c *Converter) doConvertForDefault(in doConvertInput, option ConvertOption)
 		}
 
 		// custom converter.
-		dstReflectValue, ok, err := c.callCustomConverterWithRefer(fromReflectValue, referReflectValue)
+		var (
+			ok              bool
+			dstReflectValue reflect.Value
+		)
+		dstReflectValue, ok, err = c.callCustomConverterWithRefer(fromReflectValue, referReflectValue)
 		if err != nil {
 			return nil, err
 		}
@@ -415,7 +419,7 @@ func (c *Converter) doConvertForDefault(in doConvertInput, option ConvertOption)
 		switch referReflectValue.Kind() {
 		case reflect.Ptr:
 			// Type converting for custom type pointers.
-			// Eg:
+			// Example:
 			// type PayMode int
 			// type Req struct{
 			//     Mode *PayMode

util/gconv/internal/converter/converter_float.go

@@ -45,7 +45,11 @@ func (c *Converter) Float32(any any) (float32, error) {
 			}
 			return 0, nil
 		case reflect.String:
-			f, err := strconv.ParseFloat(rv.String(), 32)
+			s := rv.String()
+			if s == "" {
+				return 0, nil
+			}
+			f, err := strconv.ParseFloat(s, 32)
 			if err != nil {
 				return 0, gerror.WrapCodef(
 					gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", any,
@@ -68,6 +72,9 @@ func (c *Converter) Float32(any any) (float32, error) {
 			if err != nil {
 				return 0, err
 			}
+			if s == "" {
+				return 0, nil
+			}
 			v, err := strconv.ParseFloat(s, 32)
 			if err != nil {
 				return 0, gerror.WrapCodef(
@@ -112,7 +119,11 @@ func (c *Converter) Float64(any any) (float64, error) {
 			}
 			return 0, nil
 		case reflect.String:
-			f, err := strconv.ParseFloat(rv.String(), 64)
+			s := rv.String()
+			if s == "" {
+				return 0, nil
+			}
+			f, err := strconv.ParseFloat(s, 64)
 			if err != nil {
 				return 0, gerror.WrapCodef(
 					gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", any,
@@ -135,6 +146,9 @@ func (c *Converter) Float64(any any) (float64, error) {
 			if err != nil {
 				return 0, err
 			}
+			if s == "" {
+				return 0, nil
+			}
 			v, err := strconv.ParseFloat(s, 64)
 			if err != nil {
 				return 0, gerror.WrapCodef(

util/gconv/internal/converter/converter_map.go

@@ -88,6 +88,9 @@ func (c *Converter) doMapConvert(
 	value any, recursive RecursiveType, mustMapReturn bool, option MapOption,
 ) (map[string]any, error) {
 	if value == nil {
+		if mustMapReturn {
+			return map[string]any{}, nil
+		}
 		return nil, nil
 	}
 	// It redirects to its underlying value if it has implemented interface iVal.
@@ -119,6 +122,9 @@ func (c *Converter) doMapConvert(
 				return nil, err
 			}
 		} else {
+			if len(r) == 0 && mustMapReturn {
+				return map[string]any{}, nil
+			}
 			return nil, nil
 		}
 	case []byte:
@@ -128,6 +134,9 @@ func (c *Converter) doMapConvert(
 				return nil, err
 			}
 		} else {
+			if len(r) == 0 && mustMapReturn {
+				return map[string]any{}, nil
+			}
 			return nil, nil
 		}
 	case map[interface{}]interface{}:
@@ -327,8 +336,14 @@ func (c *Converter) doMapConvert(
 			if m, ok := convertedValue.(map[string]interface{}); ok {
 				return m, nil
 			}
+			if mustMapReturn {
+				return map[string]any{}, nil
+			}
 			return nil, nil
 		default:
+			if mustMapReturn {
+				return map[string]any{}, nil
+			}
 			return nil, nil
 		}
 	}

util/gconv/internal/converter/converter_struct.go

@@ -160,10 +160,11 @@ func (c *Converter) Struct(params, pointer any, option ...StructOption) (err err
 			return err
 		}
 		if paramsMap == nil {
+			// fails converting params to map, it so cannot be converted to struct pointer.
 			return gerror.NewCodef(
 				gcode.CodeInvalidParameter,
-				`convert params from "%#v" to "map[string]any" failed`,
-				params,
+				`convert params "%v" to "%s" failed`,
+				params, pointerReflectValue.Type(),
 			)
 		}
 	}
@@ -505,8 +506,7 @@ func (c *Converter) bindVarToReflectValue(structFieldValue reflect.Value, value
 	case reflect.Struct:
 		// Recursively converting for struct attribute.
 		if err = c.Struct(value, structFieldValue, option); err != nil {
-			// Note there's reflect conversion mechanism here.
-			structFieldValue.Set(reflect.ValueOf(value).Convert(structFieldValue.Type()))
+			return err
 		}
 
 	// Note that the slice element might be type of struct,
@@ -637,6 +637,8 @@ func (c *Converter) bindVarToReflectValue(structFieldValue reflect.Value, value
 			elem := item.Elem()
 			if err = c.bindVarToReflectValue(elem, value, option); err == nil {
 				structFieldValue.Set(elem.Addr())
+			} else {
+				return err
 			}
 		} else {
 			// Not empty pointer, it assigns values to it.