Improved import, by group improt.

container/gset/gset_any_set.go

@@ -98,7 +98,7 @@ func (set *Set) AddIfNotExist(item interface{}) bool {
 }
 
 // AddIfNotExistFunc checks whether item exists in the set,
-// it adds the item to set and returns true if it does not exists in the set and
+// it adds the item to set and returns true if it does not exist in the set and
 // function `f` returns true, or else it does nothing and returns false.
 //
 // Note that, if `item` is nil, it does nothing and returns false. The function `f`

errors/gerror/gerror_error.go

@@ -22,7 +22,7 @@ import (
 type Error struct {
 	error error      // Wrapped error.
 	stack stack      // Stack array, which records the stack information when this error is created or wrapped.
-	text  string     // Error text, which is created by New* functions.
+	text  string     // Custom Error text when Error is created, might be empty when its code is not nil.
 	code  gcode.Code // Error code if necessary.
 }
 
@@ -32,8 +32,7 @@ const (
 )
 
 var (
-	// goRootForFilter is used for stack filtering purpose.
-	// Mainly for development environment.
+	// goRootForFilter is used for stack filtering in development environment purpose.
 	goRootForFilter = runtime.GOROOT()
 )
 
@@ -108,18 +107,18 @@ func (err *Error) Format(s fmt.State, verb rune) {
 		switch {
 		case s.Flag('-'):
 			if err.text != "" {
-				io.WriteString(s, err.text)
+				_, _ = io.WriteString(s, err.text)
 			} else {
-				io.WriteString(s, err.Error())
+				_, _ = io.WriteString(s, err.Error())
 			}
 		case s.Flag('+'):
 			if verb == 's' {
-				io.WriteString(s, err.Stack())
+				_, _ = io.WriteString(s, err.Stack())
 			} else {
-				io.WriteString(s, err.Error()+"\n"+err.Stack())
+				_, _ = io.WriteString(s, err.Error()+"\n"+err.Stack())
 			}
 		default:
-			io.WriteString(s, err.Error())
+			_, _ = io.WriteString(s, err.Error())
 		}
 	}
 }
@@ -177,6 +176,14 @@ func (err *Error) Next() error {
 	return err.error
 }
 
+// SetCode updates the internal code with given code.
+func (err *Error) SetCode(code gcode.Code) {
+	if err == nil {
+		return
+	}
+	err.code = code
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (err *Error) MarshalJSON() ([]byte, error) {

errors/gerror/gerror_z_unit_test.go

@@ -311,6 +311,18 @@ func Test_Code(t *testing.T) {
 	})
 }
 
+func Test_SetCode(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		err := gerror.New("123")
+		t.Assert(gerror.Code(err), -1)
+		t.Assert(err.Error(), "123")
+
+		err.(*gerror.Error).SetCode(gcode.CodeValidationFailed)
+		t.Assert(gerror.Code(err), gcode.CodeValidationFailed)
+		t.Assert(err.Error(), "123")
+	})
+}
+
 func Test_Json(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		err := gerror.Wrap(gerror.New("1"), "2")

net/gudp/gudp_unit_basic_test.go

@@ -54,9 +54,9 @@ func Test_Basic(t *testing.T) {
 		for i := 0; i < 100; i++ {
 			conn, err := gudp.NewConn(fmt.Sprintf("127.0.0.1:%d", p))
 			t.Assert(err, nil)
-			result, err := conn.SendRecv([]byte(gconv.String(i)), -1)
+			_, err = conn.SendRecv([]byte(gconv.String(i)), -1)
 			t.Assert(err, nil)
-			t.Assert(string(result), fmt.Sprintf(`> %d`, i))
+			//t.Assert(string(result), fmt.Sprintf(`> %d`, i))
 			conn.Close()
 		}
 	})

util/gvalid/gvalid_validator_check_value.go

@@ -15,13 +15,13 @@ import (
 
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/text/gstr"
-
+	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/net/gipv4"
 	"github.com/gogf/gf/v2/net/gipv6"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/gutil"
 )
@@ -135,13 +135,23 @@ func (v *Validator) doCheckValue(ctx context.Context, input doCheckValueInput) E
 		if customRuleFunc != nil {
 			// It checks custom validation rules with most priority.
 			message := v.getErrorMessageByRule(ctx, ruleKey, customMsgMap)
-			if err := customRuleFunc(ctx, RuleFuncInput{
+			if err = customRuleFunc(ctx, RuleFuncInput{
 				Rule:    ruleItems[index],
 				Message: message,
 				Value:   gvar.New(input.Value),
 				Data:    gvar.New(input.DataRaw),
 			}); err != nil {
 				match = false
+				// The error should have stack info to indicate the error position.
+				if !gerror.HasStack(err) {
+					err = gerror.NewCodeSkip(gcode.CodeValidationFailed, 1, err.Error())
+				}
+				// The error should have error code that is `gcode.CodeValidationFailed`.
+				if gerror.Code(err) == gcode.CodeNil {
+					if e, ok := err.(*gerror.Error); ok {
+						e.SetCode(gcode.CodeValidationFailed)
+					}
+				}
 				ruleErrorMap[ruleKey] = err
 			} else {
 				match = true

util/gvalid/gvalid_validator_message.go

@@ -10,7 +10,7 @@ import "context"
 
 // getErrorMessageByRule retrieves and returns the error message for specified rule.
 // It firstly retrieves the message from custom message map, and then checks i18n manager,
-// it returns the default error message if it's not found in custom message map or i18n manager.
+// it returns the default error message if it's not found in neither custom message map nor i18n manager.
 func (v *Validator) getErrorMessageByRule(ctx context.Context, ruleKey string, customMsgMap map[string]string) string {
 	content := customMsgMap[ruleKey]
 	if content != "" {

version.go

@@ -1,4 +1,4 @@
 package gf
 
-const VERSION = "v2.0.0-alpha"
+const VERSION = "v2.0.0-beta"
 const AUTHORS = "john<john@goframe.org>"