return toAPIErrorCode(ctx, err)
}

// wraps export error for more context
func exportError(ctx context.Context, err error, fname, entity string) APIError {
	if entity == "" {
		return toAPIError(ctx, fmt.Errorf("error exporting %s with: %w", fname, err))
	}
	return toAPIError(ctx, fmt.Errorf("error exporting %s from %s with: %w", entity, fname, err))
}

// wraps import error for more context

	user := User{Name: "jinzhu", Account: Account{Number: "1"}}

	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	}

	if err := DB.Model(&user).Association("Languages").Replace(Account{Number: "2"}); err == nil {
		t.Error("expected association error to be not nil")
	}

	allPeerClients []*peerRESTClient // Includes nil client for self
}

// NotificationPeerErr returns error associated for a remote peer.
type NotificationPeerErr struct {
	Host xnet.Host // Remote host on which the rpc call was initiated
	Err  error     // Error returned by the remote peer for an rpc call
}

// A NotificationGroup is a collection of goroutines working on subtasks that are part of

	"testing"

	"gorm.io/gorm"
	"gorm.io/gorm/utils/tests"
)

func TestDialectorWithErrorTranslatorSupport(t *testing.T) {
	// it shouldn't translate error when the TranslateError flag is false
	translatedErr := errors.New("translated error")
	untranslatedErr := errors.New("some random error")
	db, _ := gorm.Open(tests.DummyDialector{TranslatedErr: translatedErr})

	err := db.AddError(untranslatedErr)
	if !errors.Is(err, untranslatedErr) {

    <error-code>403</error-code>
    <location>/WEB-INF/view/error/redirect.jsp?type=logOut</location>
  </error-page>
  <error-page>
    <error-code>404</error-code>
    <location>/WEB-INF/view/error/redirect.jsp?type=notFound</location>
  </error-page>
  <error-page>
    <error-code>408</error-code>
    <location>/WEB-INF/view/error/redirect.jsp?type=logOut</location>
  </error-page>
  <error-page>

    public static final int ERR_SSN_SRVC = 0x02;

    // name service error codes
    /** Format error in the name service */
    public static final int FMT_ERR = 0x1;
    /** Server error in the name service */
    public static final int SRV_ERR = 0x2;
    /** Implementation error in the name service */
    public static final int IMP_ERR = 0x4;
    /** Refused error in the name service */

		t.Fatalf("no error should happen when migrate scanner, valuer struct, got error %v", err)
	}

	data := SerializerStruct{}

	if err := DB.Create(&data).Error; err != nil {
		t.Fatalf("failed to create data, got error %v", err)
	}

	var result SerializerStruct
	if err := DB.First(&result, data.ID).Error; err != nil {
		t.Fatalf("failed to query data, got error %v", err)
	}

        DataStoreException withIOException = new DataStoreException("IO Error", new java.io.IOException("File not found"));
        DataStoreException withNPE = new DataStoreException("NPE Error", new NullPointerException("Null value"));
        DataStoreException withCustom = new DataStoreException("Custom Error", new FessSystemException("System error"));

        assertTrue(withIOException.getCause() instanceof java.io.IOException);

            assertEquals(runtimeException, exception.getCause());
        });

        // Test with error
        Error error = new OutOfMemoryError("Out of memory");
        assertDoesNotThrow(() -> {
            RuntimeCIFSException exception = new RuntimeCIFSException(error);
            assertEquals(error, exception.getCause());
        });
    }

    @Test

	// The real disk
	disk StorageAPI
	// Programmed errors: API call number => error to return
	errors map[int]error
	// The error to return when no error value is programmed
	defaultErr error
	// The current API call number
	callNR int
	// Data protection
	mu sync.Mutex
}

func newNaughtyDisk(d StorageAPI, errs map[int]error, defaultErr error) *naughtyDisk {
	return &naughtyDisk{disk: d, errors: errs, defaultErr: defaultErr}
}