pkg os, func OpenInRoot(string, string) (*File, error) #67002
pkg os, func OpenRoot(string) (*Root, error) #67002
pkg os, method (*Root) Close() error #67002
pkg os, method (*Root) Create(string) (*File, error) #67002
pkg os, method (*Root) FS() fs.FS #67002
pkg os, method (*Root) Lstat(string) (fs.FileInfo, error) #67002
pkg os, method (*Root) Mkdir(string, fs.FileMode) error #67002

                                "content": {"application/json": {"schema": {}}},
                            },
                            "422": {
                                "description": "Validation Error",
                                "content": {
                                    "application/json": {
                                        "schema": {

		}

		if err := tx.First(&User{}, "name = ?", user.Name).Error; err != nil {
			t.Fatalf("Should find saved record")
		}

		return errors.New("the error message")
	})

	if err != nil && err.Error() != "the error message" {
		t.Fatalf("Transaction return error will equal the block returns error")
	}

	if err := DB.First(&User{}, "name = ?", "transaction-block").Error; err == nil {

	if err := checkListObjsArgs(ctx, bucket, prefix, keyMarker); err != nil {
		return err
	}
	if uploadIDMarker != "" {
		if HasSuffix(keyMarker, SlashSeparator) {
			return InvalidUploadIDKeyCombination{
				UploadIDMarker: uploadIDMarker,
				KeyMarker:      keyMarker,
			}
		}
		_, err := base64.RawURLEncoding.DecodeString(uploadIDMarker)
		if err != nil {

    @Test
    @DisplayName("getErrorString for name service error with known code")
    void testNameServiceKnown() {
        String expected = "ERR_NAM_SRVC/FMT_ERR: Format ErrorUnknown error code: 1";
        assertEquals(expected, NbtException.getErrorString(NbtException.ERR_NAM_SRVC, NbtException.FMT_ERR));
    }

    @Test
    @DisplayName("getErrorString for name service error with unknown code")
    void testNameServiceUnknown() {

    public void log(Level level, String message, Throwable error) {
        requireNonNull(level, "level");
        requireNonNull(message, "message");
        switch (level) {
            case ERROR -> logger.error(message, error);
            case WARN -> logger.warn(message, error);
            case INFO -> logger.info(message, error);
            case DEBUG -> logger.debug(message, error);

		err = errNoSuchPolicy
	}
	return err
}

func (ies *IAMEtcdStore) deleteMappedPolicy(ctx context.Context, name string, userType IAMUserType, isGroup bool) error {
	err := ies.deleteIAMConfig(ctx, getMappedPolicyPath(name, userType, isGroup))
	if err == errConfigNotFound {
		err = errNoSuchPolicy
	}
	return err
}

func (ies *IAMEtcdStore) deleteUserIdentity(ctx context.Context, name string, userType IAMUserType) error {

 * and localization purposes, as well as detailed error information. The message code
 * can be used by the UI layer to display appropriate error messages to users.
 */
public class SsoMessageException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /** The message code for internationalized error messages. */
    private final transient VaMessenger<FessMessages> messageCode;

	Err       error
}

// Unwrap the error to its underlying error.
func (e GenericError) Unwrap() error {
	return e.Err
}

// InvalidArgument incorrect input argument
type InvalidArgument GenericError

func (e InvalidArgument) Error() string {
	if e.Err != nil {
		return "Invalid arguments provided for " + e.Bucket + "/" + e.Object + ": (" + e.Err.Error() + ")"
	}

func (g execG[T]) First(ctx context.Context) (T, error) {
	var r T
	err := g.g.apply(ctx).First(&r).Error
	return r, err
}

func (g execG[T]) Scan(ctx context.Context, result interface{}) error {
	var r T
	err := g.g.apply(ctx).Model(r).Find(result).Error
	return err
}

func (g execG[T]) Last(ctx context.Context) (T, error) {
	var r T
	err := g.g.apply(ctx).Last(&r).Error
	return r, err
}