when:
        run "copyTask"
        then:
        executedAndNotSkipped(":copyTask")
        !copyOfExcludedFile.exists()

        when:
        excludedFile.text = "changed"
        run "copyTask"
        then:
        skipped(":copyTask")
    }

    def "default excludes are reset if nothing is defined in settings"() {
        settingsFile << addDefaultExclude(EXCLUDED_FILE_NAME)

    }

    Violation maybeViolation(final JApiCompatibility member) {
        if (!(member instanceof JApiClass)) {
            return null
        }

        if (!changed(member)) {
            return null
        }

        Optional<CtClass> oldClass = member.oldClass
        Optional<CtClass> newClass = member.newClass
        if (!oldClass.isPresent() || !newClass.isPresent()) {

        then:
        executedAndNotSkipped ":myTask"

        when:
        withWatchFs().run "myTask"
        then:
        skipped(":myTask")

        when:
        file(fileToChange).text = "changed"
        waitForChangesToBePickedUp()
        withWatchFs().run "myTask"
        then:
        executedAndNotSkipped ":myTask"

        where:

        prop.finalizeValue()

        when:
        prop.set(file)

        then:
        def e = thrown(IllegalStateException)
        e.message == 'The value for this property is final and cannot be changed any further.'
    }

    def "cannot set value using file provider when finalized"() {
        given:
        def file = tmpDir.file("thing")
        def prop = propertyWithNoValue()
        prop.finalizeValue()

        models.values().every { it.size() == 1 }
        models[":"][0].message == "fetch1 It works from project :"

        when:
        settingsFile << """
            println("configuring changed settings")
        """

        executer.withArguments(ENABLE_CLI)
        runBuildAction(new FetchParameterizedCustomModelForEachProject(["fetch1"]))

        then:
        fixture.assertStateStored {

 * limitations under the License.
 */

package org.gradle.internal

import spock.lang.Specification

class ErroringActionTest extends Specification {

    def "checked exceptions are wrapped"() {
        when:
        new ErroringAction() {
            @Override
            void doExecute(Object thing) {
                throw new Exception()
            }
        }.execute("foo")

class MethodsRemovedInInternalSuperClassRule extends AbstractSuperClassChangesRule {

    MethodsRemovedInInternalSuperClassRule(Map<String, Object> params) {
        super(params)
    }

    protected boolean changed(JApiCompatibility member) {
        return member.compatibilityChanges.contains(JApiCompatibilityChange.METHOD_REMOVED_IN_SUPERCLASS)
    }

            assert delegateContext.changes.get() == changes
            return delegateResult
        }
        _ * changes.changeDescriptions >> ImmutableList.of("changed")
        _ * context.nonIncrementalReason >> Optional.empty()
        _ * context.beforeExecutionState >> Optional.of(beforeExecutionState)
        _ * context.previousExecutionState >> Optional.of(previousExecutionState)

                break
        }
    }

    String getExpectedCacheInvalidationMessage() {
        "configuration cache cannot be reused because an input to task ':${projectDir.name}:$invalidatedTaskName' has changed."
    }

    String getInvalidatedTaskName() {
        switch (kind) {
            case Kind.CHANGE_RESOURCE:
            case Kind.ADD_RESOURCE:
                return 'processResources'

        credentials.secretKey == 'secret'
        credentials.accessKey == 'access'
        credentials.sessionToken == 'token'
    }

    def "collects multiple missing credentials failures when presence is checked"() {
        given:
        providerFactory.gradleProperty('cloudServiceAccessKey') >> Providers.notDefined()
        providerFactory.gradleProperty('cloudServiceSecretKey') >> Providers.notDefined()