errors.Is(err, target error) returns false when the two errors have the same string

This shouldn't fail because the two errors have the same string, but it still fails:

	if !errors.Is(err, testspec.expectErr) {
		t.Errorf("Error mismatch, want %v, get %v", testspec.expectErr, err)
	}

This is the errors Is() function called:

func Is(err, target error) bool {
	if target == nil {
		return err == target
	}
	isComparable := reflectlite.TypeOf(target).Comparable()
	for {
		if isComparable && err == target {
			return true
		}
		if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
			return true
		}
		// TODO: consider supporting target.Is(err). This would allow
		// user-definable predicates, but also may allow for coping with sloppy
		// APIs, thereby making it easier to get away with them.
		if err = Unwrap(err); err == nil {
			return false
		}
	}
}

errors.Is does not check that the error strings are the same. Assuming the errors have been creating using errors.New, this is documented behavior:

From https://pkg.go.dev/errors#New

> func New(text string) error
> New returns an error that formats as the
> given text. Each call to New returns a distinct error value even if the text is identical.

From the additional code you've added to the question, it looks like you think that the two &errorString{"block #11 not found"} values should compare equal. But these are two pointers, and (from the language reference under "comparison operators"):

> Pointer values are comparable. Two pointer values are equal if they
> point to the same variable or if both have value nil. Pointers to
> distinct zero-size variables may or may not be equal.