}
		return err
	}

	googleAPIErr, ok := err.(*googleapi.Error)
	if !ok {
		// We don't interpret non MinIO errors. As minio errors will
		// have StatusCode to help to convert to object errors.
		return err
	}

	if len(googleAPIErr.Errors) == 0 {
		return err
	}

	reason := googleAPIErr.Errors[0].Reason
	message := googleAPIErr.Errors[0].Message

	switch reason {
	case "required":

errors.could_not_delete_logged_in_user=로그인한 사용자는 삭제할 수 없습니다.
errors.unauthorized_request=권한이 없는 요청입니다.
errors.failed_to_print_thread_dump=스레드 덤프를 인쇄하지 못했습니다.
errors.file_is_not_supported={0}은(는) 지원되지 않습니다.
errors.plugin_file_is_not_found={0}을(를) 찾을 수 없습니다.
errors.failed_to_install_plugin={0}을(를) 설치하지 못했습니다.
errors.failed_to_find_plugins=사용 가능한 플러그인을 찾을 수 없습니다.
errors.failed_to_process_sso_request=요청을 처리하지 못했습니다: {0}

				t.Errorf("Test case %d: Expected %s but got %s", i+1, tc.expectedErr, err)
			}
			continue
		}

		if tc.keyID != "" && tc.keyID != ssec.KeyID() {
			t.Errorf("Test case %d: Expected bucket encryption KeyID %s but got %s", i+1, tc.keyID, ssec.KeyID())
		}

			t.Errorf("Test %d, Expected %v, got %v", i+1, tt.wantSc, gotSc)
			return
		}
		if tt.expectedError != nil && err.Error() != tt.expectedError.Error() {
			t.Errorf("Test %d, Expected `%v`, got `%v`", i+1, tt.expectedError, err)
		}
	}
}

func TestValidateParity(t *testing.T) {
	tests := []struct {
		rrsParity     int
		ssParity      int
		success       bool
		setDriveCount int
	}{

				t.Errorf("%s: missing error, want %s", fileline, all)
			} else if !strings.Contains(err, mm[0][1]) {
				t.Errorf("%s: wrong error for %s:\n%s", fileline, all, err)
			}
		} else {
			if errors[fileline] != "" {
				t.Errorf("unexpected error on %s: %v", fileline, errors[fileline])
			}
		}
		delete(errors, fileline)
	}
	var extra []string
	for key := range errors {
		extra = append(extra, key)

errors.property_type_double={0} è un numero double.
errors.property_type_date={0} è una data.

errors.storage_file_upload_failure=Caricamento di {0} fallito.
errors.storage_file_not_found=Il file di destinazione non è presente nell'archivio.
errors.storage_file_download_failure=Download di {0} fallito.
errors.storage_access_error=Errore di accesso all'archivio: {0}
errors.storage_no_upload_file=Specificare un file da caricare.

	if err := DB.Create(&data).Error; err != nil {
		t.Errorf("Should got no error when creating data, but got %v", err)
	}

	if err := DB.Model(&data).Update("password", EncryptedData("xnewpass")).Error; err == nil {
		t.Errorf("Should failed to update data with invalid data")
	}

	if err := DB.Model(&data).Update("password", EncryptedData("newpass")).Error; err != nil {

			break
		}

		var err error
		bufs, err = reader.Read(bufs)
		if len(bufs) > 0 {
			// Set only if there are be enough data for reconstruction.
			// and only for expected errors, also set once.
			if errors.Is(err, errFileNotFound) || errors.Is(err, errFileCorrupt) {
				if derr == nil {
					derr = err
				}
			}
		} else if err != nil {

        /** Resource errors (out of memory, disk space, etc.) */
        RESOURCE,
        /** Configuration errors */
        CONFIGURATION,
        /** Transient errors that may succeed on retry */
        TRANSIENT,
        /** Unknown or unclassified errors */
        UNKNOWN
    }

    /**
     * Standard SMB error codes
     */
    public enum ErrorCode {
        // Network errors

func TestUpdateHasManyAssociations(t *testing.T) {
	user := *GetUser("update-has-many", Config{})

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

	user.Pets = []*Pet{{Name: "pet1"}, {Name: "pet2"}}
	if err := DB.Save(&user).Error; err != nil {
		t.Fatalf("errors happened when update: %v", err)
	}

	var user2 User
	DB.Preload("Pets").Find(&user2, "id = ?", user.ID)