yield cls.validate

    @classmethod
    def validate(cls: Type["UploadFile"], v: Any) -> Any:
        if not isinstance(v, StarletteUploadFile):
            raise ValueError(f"Expected UploadFile, received: {type(v)}")
        return v

    @classmethod
    def _validate(cls, __input_value: Any, _: Any) -> "UploadFile":

# TODO: remove when deprecating Pydantic v1
def test_upload_file_invalid():
    with pytest.raises(ValueError):
        UploadFile.validate("not a Starlette UploadFile")


def test_upload_file_invalid_pydantic_v2():
    with pytest.raises(ValueError):
        UploadFile._validate("not a Starlette UploadFile", {})


def test_default_placeholder_equals():
    placeholder_1 = Default("a")
    placeholder_2 = Default("a")

	}
	return ""
}

// Validate - validates the rule element
func (r Rule) Validate(bucket string, sameTarget bool) error {
	if err := r.validateID(); err != nil {
		return err
	}
	if err := r.validateStatus(); err != nil {
		return err
	}
	if err := r.validateFilter(); err != nil {
		return err
	}
	if err := r.DeleteMarkerReplication.Validate(); err != nil {
		return err
	}

// isEmpty returns true if Tags field is null
func (a And) isEmpty() bool {
	return len(a.Tags) == 0 && a.Prefix == ""
}

// Validate - validates the And field
func (a And) Validate() error {
	if a.ContainsDuplicateTag() {
		return errDuplicateTagKey
	}
	for _, t := range a.Tags {
		if err := t.Validate(); err != nil {
			return err
		}
	}
	return nil
}

// isEmpty returns true if Tags field is null
func (a And) isEmpty() bool {
	return len(a.Tags) == 0 && !a.Prefix.set &&
		a.ObjectSizeGreaterThan == 0 && a.ObjectSizeLessThan == 0
}

// Validate - validates the And field
func (a And) Validate() error {
	// > This is used in a Lifecycle Rule Filter to apply a logical AND to two or more predicates.
	// ref: https://docs.aws.amazon.com/AmazonS3/latest/API/API_LifecycleRuleAndOperator.html

	var trw transitionWrapper
	err := d.DecodeElement(&trw, &startElement)
	if err != nil {
		return err
	}
	*t = Transition(trw)
	t.set = true
	return nil
}

// Validate - validates the "Transition" element
func (t Transition) Validate() error {
	if !t.set {
		return nil
	}

	if !t.IsDateNull() && t.Days > 0 {
		return errTransitionInvalid
	}

	if t.StorageClass == "" {

}

// BatchJobReplicateResourceType defines the type of batch jobs
type BatchJobReplicateResourceType string

// Validate validates if the replicate resource type is recognized and supported
func (t BatchJobReplicateResourceType) Validate() error {
	switch t {
	case BatchJobReplicateResourceMinIO:
	case BatchJobReplicateResourceS3:
	default:
		return errInvalidArgument
	}
	return nil
}

	return e.EncodeToken(xml.EndElement{Name: start.Name})
}

// Validate - validates the filter element
func (f Filter) Validate() error {
	// A Filter must have exactly one of Prefix, Tag, or And specified.
	if !f.And.isEmpty() {
		if f.Prefix != "" {
			return errInvalidFilter
		}
		if !f.Tag.IsEmpty() {
			return errInvalidFilter
		}
		if err := f.And.Validate(); err != nil {
			return err
		}
	}
	if f.Prefix != "" {

	var tmp retry
	err := val.Decode(&tmp)
	if err != nil {
		return err
	}

	*r = BatchJobRetry(tmp)
	r.line, r.col = val.Line, val.Column
	return nil
}

// Validate validates input replicate retries.
func (r BatchJobRetry) Validate() error {
	if r.Attempts < 0 {
		return BatchJobYamlErr{
			line: r.line,
			col:  r.col,
			msg:  "Invalid arguments specified",
		}
	}

	if r.Delay < 0 {

	var exp expirationWrapper
	err := d.DecodeElement(&exp, &startElement)
	if err != nil {
		return err
	}
	*e = Expiration(exp)
	e.set = true
	return nil
}

// Validate - validates the "Expiration" element
func (e Expiration) Validate() error {
	if !e.set {
		return nil
	}

	// DeleteMarker cannot be specified if date or dates are specified.
	if (!e.IsDaysNull() || !e.IsDateNull()) && e.DeleteMarker.set {