From 80e73da41600215be272202e079b2bfd46c34084 Mon Sep 17 00:00:00 2001
From: John Guo <claymore1986@gmail.com>
Date: Mon, 9 Dec 2024 23:11:56 +0800
Subject: [PATCH] feat(errors/gerror): add `As` support (#4002)

---
 errors/gerror/gerror_api_stack.go   | 17 +++++++
 errors/gerror/gerror_z_unit_test.go | 69 +++++++++++++++++++++++++++++
 os/gcron/gcron_z_unit_test.go       |  2 +-
 3 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/errors/gerror/gerror_api_stack.go b/errors/gerror/gerror_api_stack.go
index b8c5f269c..f77368104 100644
--- a/errors/gerror/gerror_api_stack.go
+++ b/errors/gerror/gerror_api_stack.go
@@ -98,6 +98,23 @@ func Is(err, target error) bool {
 	return errors.Is(err, target)
 }
 
+// As finds the first error in err's chain that matches target, and if so, sets
+// target to that error value and returns true.
+//
+// The chain consists of err itself followed by the sequence of errors obtained by
+// repeatedly calling Unwrap.
+//
+// An error matches target if the error's concrete value is assignable to the value
+// pointed to by target, or if the error has a method As(interface{}) bool such that
+// As(target) returns true. In the latter case, the As method is responsible for
+// setting target.
+//
+// As will panic if target is not a non-nil pointer to either a type that implements
+// error, or to any interface type. As returns false if err is nil.
+func As(err error, target any) bool {
+	return errors.As(err, target)
+}
+
 // HasError performs as Is.
 // This function is designed and implemented early before errors.Is of go stdlib.
 // Deprecated: use Is instead.
diff --git a/errors/gerror/gerror_z_unit_test.go b/errors/gerror/gerror_z_unit_test.go
index 29da03137..83acc1837 100644
--- a/errors/gerror/gerror_z_unit_test.go
+++ b/errors/gerror/gerror_z_unit_test.go
@@ -17,6 +17,22 @@ import (
 	"github.com/gogf/gf/v2/test/gtest"
 )
 
+// customError is used to test As function
+type customError struct {
+	Message string
+}
+
+func (e *customError) Error() string {
+	return e.Message
+}
+
+// anotherError is used to test As function with different error type
+type anotherError struct{}
+
+func (e *anotherError) Error() string {
+	return "another error"
+}
+
 func nilError() error {
 	return nil
 }
@@ -472,3 +488,56 @@ func Test_NewOption(t *testing.T) {
 		}), gerror.New("NewOptionError"))
 	})
 }
+
+func Test_As(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var myerr = &customError{Message: "custom error"}
+
+		// Test with nil error
+		var targetErr *customError
+		t.Assert(gerror.As(nil, &targetErr), false)
+		t.Assert(targetErr, nil)
+
+		// Test with standard error
+		err1 := errors.New("standard error")
+		t.Assert(gerror.As(err1, &targetErr), false)
+		t.Assert(targetErr, nil)
+
+		// Test with custom error type
+		err2 := myerr
+		t.Assert(gerror.As(err2, &targetErr), true)
+		t.Assert(targetErr.Message, "custom error")
+
+		// Test with wrapped error
+		err3 := gerror.Wrap(myerr, "wrapped")
+		targetErr = nil
+		t.Assert(gerror.As(err3, &targetErr), true)
+		t.Assert(targetErr.Message, "custom error")
+
+		// Test with deeply wrapped error
+		err4 := gerror.Wrap(gerror.Wrap(gerror.Wrap(myerr, "wrap3"), "wrap2"), "wrap1")
+		targetErr = nil
+		t.Assert(gerror.As(err4, &targetErr), true)
+		t.Assert(targetErr.Message, "custom error")
+
+		// Test with different error type
+		var otherErr *anotherError
+		t.Assert(gerror.As(err4, &otherErr), false)
+		t.Assert(otherErr, nil)
+
+		// Test with non-pointer target
+		defer func() {
+			t.Assert(recover() != nil, true)
+		}()
+		var nonPtr customError
+		gerror.As(err4, nonPtr)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		// Test with nil target
+		defer func() {
+			t.Assert(recover() != nil, true)
+		}()
+		gerror.As(errors.New("error"), nil)
+	})
+}
diff --git a/os/gcron/gcron_z_unit_test.go b/os/gcron/gcron_z_unit_test.go
index 1f92a3d8e..1f162d560 100644
--- a/os/gcron/gcron_z_unit_test.go
+++ b/os/gcron/gcron_z_unit_test.go
@@ -133,7 +133,7 @@ func doTestCronAddFixedPattern(t *testing.T) {
 			array.Append(1)
 		})
 		t.AssertNil(err)
-		time.Sleep(3000 * time.Millisecond)
+		time.Sleep(3500 * time.Millisecond)
 		g.Log().Debug(ctx, `current time`)
 		t.Assert(array.Len(), 1)
 	})