}
}

var (
	errDecommissionAlreadyRunning = errors.New("decommission is already in progress")
	errDecommissionComplete       = errors.New("decommission is complete, please remove the servers from command-line")
	errDecommissionNotStarted     = errors.New("decommission is not in progress")
)

func (p *poolMeta) Decommission(idx int, pi poolSpaceInfo) error {
	// Return an error when there is decommission on going - the user needs

                message.contains("[WARNING] Deprecated feature used"),
                "Message should contain warning when no errors are present");

        assertTrue(
                !message.contains("(") || !message.contains("error"),
                "Message should not contain error count when there are no errors");
    }

    @Test
    void testExceptionMessageWithEmptyResults() {

		return errFaultyRemoteDisk
	case errFileCorrupt.Error():
		return errFileCorrupt
	case errUnexpected.Error():
		return errUnexpected
	case errDiskFull.Error():
		return errDiskFull
	case errVolumeNotFound.Error():
		return errVolumeNotFound
	case errVolumeExists.Error():
		return errVolumeExists
	case errFileNotFound.Error():
		return errFileNotFound
	case errFileVersionNotFound.Error():

// Check if an API error is properly defined
func TestAPIErrCodeDefinition(t *testing.T) {
	for errAPI := ErrNone + 1; errAPI < apiErrCodeEnd; errAPI++ {
		errCode, ok := errorCodes[errAPI]
		if !ok {
			t.Fatal(errAPI, "error code is not defined in the API error code table")
		}
		if errCode.Code == "" {
			t.Fatal(errAPI, "error code has an empty XML code")
		}
		if errCode.HTTPStatusCode == 0 {

	var cfgInfos []madmin.IDPCfgInfo
	var err error
	switch idpCfgType {
	case madmin.OpenidIDPCfg:
		cfgInfos, err = globalIAMSys.OpenIDConfig.GetConfigInfo(cfg, cfgName)
	case madmin.LDAPIDPCfg:
		cfgInfos, err = globalIAMSys.LDAPConfig.GetConfigInfo(cfg, cfgName)
	}
	if err != nil {
		if errors.Is(err, openid.ErrProviderConfigNotFound) || errors.Is(err, cfgldap.ErrProviderConfigNotFound) {

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

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

	user.Account = Account{Number: "account-has-one-association"}

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

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

	MOVM.DB	[R0-R4], 4(R1)     // ERROR "offset must be zero"
	MOVW	CPSR, FPSR         // ERROR "illegal combination"
	MOVW	FPSR, CPSR         // ERROR "illegal combination"
	MOVW	CPSR, errors(SB)   // ERROR "illegal combination"
	MOVW	errors(SB), CPSR   // ERROR "illegal combination"
	MOVW	FPSR, errors(SB)   // ERROR "illegal combination"
	MOVW	errors(SB), FPSR   // ERROR "illegal combination"

                return Language.GROOVY;
            }
        }
        return Language.UNKNOWN;
    }

    private static void addError(Map<File, List<Error>> errors, File file, Error error) {
        errors.computeIfAbsent(file, f -> new ArrayList<>()).add(error);
    }

    private enum Language { KOTLIN, GROOVY, UNKNOWN }

    private static final class Snippet {

     */
    List<Dependency> getUnresolvedDependencies();

    /**
     * Gets the errors that occurred while building the dependency graph.
     *
     * @return The errors that occurred while building the dependency graph, never {@code null}.
     */
    List<Exception> getCollectionErrors();

    /**
     * Gets the errors that occurred while resolving the specified dependency.
     *

				}
			},
		})
		jt.Wait() // synchronize all the concurrent heal jobs
		if err != nil {
			// Set this such that when we return this function
			// we let the caller retry this disk again for the
			// buckets it failed to list.
			retErr = err
		}

		if retErr != nil {