*/
    public boolean isSuccess() {
        return returnCode == ERROR_SUCCESS;
    }

    /**
     * Gets the error message for the current return code.
     *
     * @return a human-readable error message
     */
    public String getErrorMessage() {
        switch (returnCode) {
        case ERROR_SUCCESS:
            return "Success";

		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotArn, err := Parse(tt.args.arnStr)
			if err == nil && tt.wantErr {
				t.Errorf("Parse() error = %v, wantErr %v", err, tt.wantErr)
			}
			if err != nil && !tt.wantErr {
				t.Errorf("Parse() error = %v, wantErr %v", err, tt.wantErr)
			}
			if err == nil {
				if !reflect.DeepEqual(gotArn, tt.wantArn) {

		</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"error"</arg>
			<arg>"error/error.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"errorNotFound"</arg>
			<arg>"error/notFound.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"errorSystem"</arg>
			<arg>"error/system.jsp"</arg>
		</postConstruct>

			if err != nil {
				err = msgp.WrapError(err, "PartNumber")
				return
			}
		case "Algorithm":
			{
				var zb0002 uint
				zb0002, err = dc.ReadUint()
				if err != nil {
					err = msgp.WrapError(err, "Algorithm")
					return
				}
				z.Algorithm = BitrotAlgorithm(zb0002)
			}
		case "Hash":
			z.Hash, err = dc.ReadBytes(z.Hash)
			if err != nil {
				err = msgp.WrapError(err, "Hash")

}

.top30 {
	margin-top: 3.0em;
}

.container .text-muted {
	margin: 20px 0;
}

.notification {
	text-align: center;
}

ul.has-error {
	color: #dd4b39 !important;
	list-style-type: none;
	padding: 0;
}

.form-group .has-error + .form-control {
	border-color: #dd4b39 !important;
	box-shadow: none;
}

.sidebar-mini.sidebar-collapse .sidebar-search {
	display: none !important;
}

                                    },
                                },
                            },
                            "description": "Validation Error",
                        },
                    },
                    "summary": "Read Item",
                },
            },
        },
        "components": {
            "schemas": {

public class ErrorToWarnRewritePolicy implements RewritePolicy {

    /** Array of logger name prefixes to apply the ERROR to WARN conversion */
    private final String[] loggerNames;

    /**
     * Constructs a new ErrorToWarnRewritePolicy with the specified logger names.
     *
     * @param loggerNames array of logger name prefixes to convert ERROR to WARN
     */
    public ErrorToWarnRewritePolicy(final String[] loggerNames) {

func (r Rule) Validate() error {
	if err := r.validateID(); err != nil {
		return err
	}
	if err := r.validateStatus(); err != nil {
		return err
	}
	if err := r.validateExpiration(); err != nil {
		return err
	}
	if err := r.validateNoncurrentExpiration(); err != nil {
		return err
	}
	if err := r.validatePrefixAndFilter(); err != nil {
		return err
	}

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

	var objLayer ObjectLayer
	var disks []string
	var err error
	var opts ObjectOptions

	objLayer, disks, err = prepareErasure16(ctx)
	if err != nil {
		t.Fatal(err)
	}

	// cleaning up of temporary test directories
	defer objLayer.Shutdown(t.Context())
	defer removeRoots(disks)

	err = objLayer.MakeBucket(ctx, "bucket1", MakeBucketOptions{})
	if err != nil {
		t.Fatal(err)
	}