refactor: refactor error handling in withCode and withMessage

Removed redundant struct nesting in `withCode` and streamlined test cases in `TestNew`.
Updated error formatting logic for clearer output and added missing method implementations.
Improved test assertions and optimized error message comparisons.

Author: ace-zhaoy

README.md

@@ -31,7 +31,10 @@ func ReturnNil() error {
 func main() {
 	err := OpenFile()
 	fmt.Printf("%+v\n", err)
-	fmt.Println("------------")
+	fmt.Println("\n------------\n")
+
+	fmt.Printf("%v\n", err)
+	fmt.Println("\n------------\n")
 
 	err = ReturnNil()
 	fmt.Printf("%+v\n", err)
@@ -49,7 +52,13 @@ runtime.main
         /usr/local/go/src/runtime/proc.go:250
 runtime.goexit
         /usr/local/go/src/runtime/asm_amd64.s:1571
+
+------------
+
+open ./test.err: no such file or directory
+
 ------------
+
 <nil>
 
 ```
@@ -66,7 +75,7 @@ import (
 
 func A() error {
 	_, err := os.Open("./test.err")
-	return errors.WithStack(err)
+	return errors.Wrap(err, "failed to open file")
 }
 
 func B() error {
@@ -82,13 +91,17 @@ func C() error {
 func main() {
 	err := C()
 	fmt.Printf("%+v\n", err)
+	fmt.Println("\n------------\n")
+
+	fmt.Printf("%v\n", err)
 }
 
 ```
 
 Output:
 ```
 open ./test.err: no such file or directory
+failed to open file
 main.A
         /go/src/test/err/main.go:11
 main.B
@@ -100,7 +113,11 @@ main.main
 runtime.main
         /usr/local/go/src/runtime/proc.go:250
 runtime.goexit
-        /usr/local/go/src/runtime/asm_amd64.s:157
+        /usr/local/go/src/runtime/asm_amd64.s:1571
+
+------------
+
+failed to open file -> {open ./test.err: no such file or directory}
 ```
 
 ## Error code
@@ -161,11 +178,11 @@ Output:
 ```
 error code: 400102030
 error msg: invalid params
-error err: [400102030: invalid params] -> {param: id: 1 -> {[500201010: user not found] -> {record not found}}}
+error err: [400102030: invalid params] -> {[500201010: user not found] -> {param: id: 1 -> {record not found}}}
 ---------------------
 record not found
-500201010: user not found
 param: id: 1
+500201010: user not found
 main.SqlFirst
         /go/src/test/err/main.go:27
 main.Server

README_CN.md

@@ -140,21 +140,21 @@ func main() {
 // Output:
 // error code: 400102030
 // error msg: invalid params
-// error err: [400102030: invalid params] -> {param: id: 1 -> {[500201010: user not found] -> {record not found}}}
+// error err: [400102030: invalid params] -> {[500201010: user not found] -> {param: id: 1 -> {record not found}}}
 // ---------------------
 // record not found
-// 500201010: user not found
 // param: id: 1
+// 500201010: user not found
 // main.SqlFirst
-//         /go/src/test/err/main.go:27
+// /go/src/test/err/main.go:27
 // main.Server
-//         /go/src/test/err/main.go:31
+// /go/src/test/err/main.go:31
 // main.main
-//         /go/src/test/err/main.go:43
+// /go/src/test/err/main.go:43
 // runtime.main
-//         /usr/local/go/src/runtime/proc.go:250
+// /usr/local/go/src/runtime/proc.go:250
 // runtime.goexit
-//         /usr/local/go/src/runtime/asm_amd64.s:1571
+// /usr/local/go/src/runtime/asm_amd64.s:1571
 // 400102030: invalid params
 ```
 

error.go

@@ -66,14 +66,14 @@ func (w *withMessage) Wrapf(err error, format string, args ...any) error {
 	if err == nil {
 		return nil
 	}
-	wm := &withMessage{
-		message: w.Message(),
+	wm := withMessage{
+		message: fmt.Sprintf(format, args...),
 		cause:   err,
 	}
 	ws := &withStack{
 		error: &withMessage{
-			message: fmt.Sprintf(format, args...),
-			cause:   wm,
+			message: w.message,
+			cause:   &wm,
 		},
 	}
 	if !stackExists(ws) {
@@ -104,26 +104,37 @@ type ErrorCode interface {
 }
 
 type withCode struct {
-	*withMessage
-	code int
+	code    int
+	message string
+	cause   error
 }
 
 func (w *withCode) Code() int {
 	return w.code
 }
 
+func (w *withCode) Message() string {
+	return w.message
+}
+
+func (w *withCode) Cause() error {
+	return w.cause
+}
+
+func (w *withCode) Unwrap() error {
+	return w.cause
+}
+
 // WrapStack If err is nil, WithStack returns nil.
 func (w *withCode) WrapStack(err error) error {
 	if err == nil {
 		return nil
 	}
 	ws := &withStack{
 		error: &withCode{
-			withMessage: &withMessage{
-				message: w.Message(),
-				cause:   err,
-			},
-			code: w.Code(),
+			code:    w.code,
+			message: w.message,
+			cause:   err,
 		},
 	}
 	if !stackExists(ws) {
@@ -137,19 +148,17 @@ func (w *withCode) Wrapf(err error, format string, args ...any) error {
 	if err == nil {
 		return nil
 	}
-	wm := &withMessage{
-		message: w.Message(),
+	wm := withMessage{
+		message: fmt.Sprintf(format, args...),
 		cause:   err,
 	}
-	wc := &withCode{
-		withMessage: wm,
-		code:        w.Code(),
+	wc := withCode{
+		code:    w.code,
+		message: w.message,
+		cause:   &wm,
 	}
 	ws := &withStack{
-		error: &withMessage{
-			message: fmt.Sprintf(format, args...),
-			cause:   wc,
-		},
+		error: &wc,
 	}
 	if !stackExists(ws) {
 		ws.stack = callers()
@@ -158,11 +167,11 @@ func (w *withCode) Wrapf(err error, format string, args ...any) error {
 }
 
 func (w *withCode) Error() string {
-	s := fmt.Sprintf("[%d: %s]", w.Code(), w.Message())
-	if w.Cause() == nil {
+	s := fmt.Sprintf("[%d: %s]", w.code, w.message)
+	if w.cause == nil {
 		return s
 	}
-	return fmt.Sprintf("%s -> {%s}", s, w.Cause())
+	return fmt.Sprintf("%s -> {%s}", s, w.cause)
 }
 
 func (w *withCode) Is(err error) bool {
@@ -176,10 +185,10 @@ func (w *withCode) Format(s fmt.State, verb rune) {
 	switch verb {
 	case 'v':
 		if s.Flag('+') {
-			if w.Cause() != nil {
-				fmt.Fprintf(s, "%+v\n", w.Cause())
+			if w.cause != nil {
+				fmt.Fprintf(s, "%+v\n", w.cause)
 			}
-			fmt.Fprintf(s, "%d: %s", w.Code(), w.Message())
+			fmt.Fprintf(s, "%d: %s", w.code, w.message)
 			return
 		}
 		fallthrough
@@ -273,10 +282,8 @@ func NewWithMessage(format string, args ...any) ErrorMessage {
 // NewWithCode no stack
 func NewWithCode(code int, format string, args ...any) ErrorCode {
 	return &withCode{
-		code: code,
-		withMessage: &withMessage{
-			message: fmt.Sprintf(format, args...),
-		},
+		code:    code,
+		message: fmt.Sprintf(format, args...),
 	}
 }
 

error_test.go

@@ -27,40 +27,31 @@ var (
 )
 
 func TestNew(t *testing.T) {
-	type args struct {
-		format string
-	}
 	tests := []struct {
 		name    string
-		args    args
-		wantErr error
+		input   string
+		wantErr string
 	}{
 		{
-			"new abc - fmt.Errorf",
-			args{
-				format: "abc",
-			},
-			fmt.Errorf("abc"),
-		},
-		{
-			"new abc - errors.New",
-			args{
-				format: "abc",
-			},
-			errors.New("abc"),
+			name:    "new abc",
+			input:   "abc",
+			wantErr: "abc",
 		},
 		{
-			"new abc",
-			args{
-				format: "abc",
-			},
-			New("abc"),
+			name:    "empty string",
+			input:   "",
+			wantErr: "",
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if err := New(tt.args.format); err.Error() != tt.wantErr.Error() {
-				t.Errorf("New() error = %v, wantErr %v", err, tt.wantErr)
+			err := New(tt.input)
+			if err == nil {
+				t.Errorf("New() returned nil, want error")
+				return
+			}
+			if err.Error() != tt.wantErr {
+				t.Errorf("New() error = %v, want %v", err.Error(), tt.wantErr)
 			}
 		})
 	}
@@ -94,10 +85,8 @@ func TestNewWithCode(t *testing.T) {
 				args:   []any{"bbb"},
 			},
 			&withCode{
-				withMessage: &withMessage{
-					message: "aaa: bbb",
-				},
-				code: 100,
+				code:    100,
+				message: "aaa: bbb",
 			},
 		},
 		{
@@ -107,8 +96,8 @@ func TestNewWithCode(t *testing.T) {
 				format: "",
 			},
 			&withCode{
-				withMessage: &withMessage{},
-				code:        200,
+				code:    200,
+				message: "",
 			},
 		},
 	}

example_test.go

@@ -309,8 +309,8 @@ func ExampleLatestMessage() {
 	// Output:
 	//ErrUserNotFound: user not found
 	//ErrInvalidParams: invalid params
-	//latestErr: param <123> -> {invalid params -> {user not found}}
-	//otherErr: service err -> {param <123> -> {invalid params -> {user not found}}}
+	//latestErr: invalid params -> {param <123> -> {user not found}}
+	//otherErr: service err -> {invalid params -> {param <123> -> {user not found}}}
 }
 
 func ExampleIs_code() {