when:
        def result = manager.withIvy(action)

        then:
        result == "result"

        and:
        1 * action.transform({it != null}) >> "result"
        0 * action._
    }

    def "nested actions are executed against the same Ivy instance"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def transformer = Mock(Transformer)

class CredentialsProviderFactoryTest extends Specification {

    def providerFactory = Mock(ProviderFactory)
    def factory = new CredentialsProviderFactory(providerFactory)

    def "does not allow non-letters and non-digits for identity"() {
        when:
        factory.provide(PasswordCredentials, (String) identity)

        then:
        def e = thrown(IllegalArgumentException)

        def dir = tmpDir.file("dir").createDir()

        expect:
        def stat = fs.stat(dir)
        stat.type == FileType.Directory
        stat.lastModified == 0
        stat.length == 0
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "stats symlink"() {
        def file = tmpDir.file("file")
        file.text = "123"
        def link = tmpDir.file("link")

        """
        settingsFile << "include 'sub'"
    }

    def "can run tasks upon Eclipse synchronization"() {
        setup:
        buildFile << "eclipse { synchronizationTasks 'foo' }"

        def projectsLoadedHandler = new IntermediateResultHandlerCollector<Void>()
        def buildFinishedHandler = new IntermediateResultHandlerCollector<EclipseModel>()
        def out = new ByteArrayOutputStream()

        when:

        def target = Mock(ScriptTarget) {
            getClasspathBlockName() >> "buildscript"
        }
        def targetScope = Stub(ClassLoaderScope) {
            createChild(_ as String) >> Stub(ClassLoaderScope)
        }
        def loader = getClass().getClassLoader()
        def transformer = new BuildScriptTransformer(source, target)

    @Rule
    final SetSystemProperties systemProperties = new SetSystemProperties()

    def cleanup() {
        InstrumentedInputs.discardListener()
    }

    def "notifies listener when system property is used"() {
        def listener = withInstrumentedInputsListener()

        System.setProperty("prop", "value")

        when:
        def result = Instrumented.systemProperty("prop", "consumer")

        then:

        def file = tmpDir.file("missing")
        def outFile = tmpDir.file("out")

        expect:
        def resource = new LocalFileStandInExternalResource(file, TestFiles.fileSystem())
        def result = resource.writeToIfPresent(outFile)
        result == null
        !outFile.exists()
    }

    def "can fail on missing file when copying to file"() {
        def file = tmpDir.file("missing")

            }
            def componentFactory = objects.newInstance(PublishServices).softwareComponentFactory
        """
    }

    def newCompilation(String name, CompilationDetails details, String rootComponentName) {
        def runtimeClasspath = "${name}RuntimeClasspath"
        def implementation = "${name}Implementation"
        def runtimeElements = "${name}RuntimeElements"

        expect:
        def original = "abc"
        def isolated = isolatableFactory.isolate(original)
        isolated instanceof StringValueSnapshot
        isolated.isolate().is(original)
    }

    def "can coerce string value"() {
        expect:
        def original = "abc"
        def isolated = isolatableFactory.isolate(original)
        isolated.coerce(String).is(original)

import org.gradle.util.TestUtil

class TestTaskSpec extends AbstractProjectBuilderSpec {
    def testExecuter = Mock(TestExecuter)
    def suiteDescriptor = Mock(TestDescriptorInternal)
    def testDescriptor = Mock(TestDescriptorInternal)

    private Test task

    def setup() {
        task = TestUtil.create(temporaryFolder).task(Test)
        task.testExecuter = testExecuter