}

    def "required has flexible input"() {
        when:
        signing.required = value

        then:
        signing.required == required

        where:
        value | required
        true  | true
        false | false
        []    | false
        ""    | false
    }

    def "can supply a callable as the required value"() {
        given:
        def flag = false

    }

    def "require empty by default"() {
        expect:
        container.every { !it.required.get() } && container.enabled.empty
    }

    def "can change required"() {
        when:
        container.each { it.required = false }

        then:
        container.enabled.empty

        when:
        container.configure {
            a.required = true
            b.required = true

                    "type": "missing",
                    "loc": ["body", "item"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",
                    "loc": ["body", "user"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",

                    "msg": "Field required",
                    "input": None,
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["body", "password"],
                    "msg": "field required",
                    "type": "value_error.missing",

                    "msg": "Field required",
                    "input": None,
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["body", "password"],
                    "msg": "field required",
                    "type": "value_error.missing",

                    "msg": "Field required",
                    "input": None,
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["body", "password"],
                    "msg": "field required",
                    "type": "value_error.missing",

    installed from options: - source - binary validations: required: true

-   type: input id: tfversion attributes: label: Tensorflow Version description:
    placeholder: ex,. tf 2.8 validations: required: true

-   type: dropdown id: Code attributes: label: Custom Code description:
    options: - "Yes" - "No" validations: required: true

-   type: input id: OS attributes: label: OS Platform and Distribution

        requires.value().each { RequiredFeature feat ->
            required[feat.feature()] = feat.value()
        }
    }

    static Map<String, String> requiredFeatures(Annotation[] testAnnotations) {
        Map<String, String> required = [:]
        getAllAnnotations(testAnnotations, RequiredFeature).each { required[it.feature()] = it.value() }

	module declares its path as: badchain.example.com/c
	        but was required as: example.com/badchain/c
	restoring example.com/badchain/c@v1.0.0
-- update-a-expected --
go: example.com/badchain/a@upgrade (v1.1.0) indirectly requires example.com/badchain/c@v1.1.0: parsing go.mod:
	module declares its path as: badchain.example.com/c
	        but was required as: example.com/badchain/c
-- list-expected --

        and:
        succeeds(task)
        skipped(task)

        when:
        buildFile << """
            createReports.reports.configure {
                file1.required = false
                file2.required = false
                file2.outputLocation.set(file1.outputLocation)
            }
        """

        then:
        succeeds(task)
        executedAndNotSkipped(task)
    }