def gradle = Mock(GradleInternal)
    def settings = Mock(SettingsInternal)
    def state = Mock(SettingsState)
    def buildLayout = new BuildLayout(null, FileUtils.canonicalize(new File("someDir")), null, Stub(ScriptFileResolver))
    def buildLayoutFactory = Mock(BuildLayoutFactory)
    def settingsScript = Mock(ScriptSource)
    def startParameter = new StartParameterInternal()

                    def input = inputArtifact.get().asFile
                    println "processing \${input.name} using \${parameters.someDir.get().asFile.name}"
                    def output = outputs.file(input.name + ".green")
                    output.text = input.text + parameters.someDir.get().asFile.list().length + ".green"
                }
            }
        """

        when:
        run(":a:resolve")

        when:
        // obtain localhost address ahead of time as the first call in a JVM can take multiple secs in some systems
        def localhost = Inet6Address.getLocalHost()
        def registry = registry("someDir").get(DaemonRegistry)
        5.times { idx ->
            concurrent.start {
                def context = new DefaultDaemonContext(
                    "$idx",
                    new File("$idx"),

        runEclipseTask """
apply plugin: "java"
apply plugin: "eclipse"

repositories {
	flatDir { dirs "${TextUtil.escapeString(repoDir)}" }
}

dependencies {
	implementation "some:lib:1.0"
}
        """
    }

    @Test
    @Issue("GRADLE-1706") // doesn't prove that the issue is fixed because the test also passes with 1.0-milestone-4
    @ToBeFixedForConfigurationCache

                public MyTask() {
                    getInputs().file("somefile");
                    getInputs().files("afile", "anotherfile");
                    getInputs().dir("someDir");
                    getInputs();
                    getOutputs();
                }
            }
        """
        builder.buildJar(pluginJar)

        buildFile << """
            buildscript {

class DefaultProviderFactoryTest extends Specification implements ProviderAssertions {

    static final PROJECT = ProjectBuilder.builder().build()
    static final File TEST_FILE = PROJECT.file('someDir')

    def providerFactory = new DefaultProviderFactory()

    def "cannot create provider for null value"() {
        when:
        providerFactory.provider(null)

        then:

        createDirs("a", "b")
        settingsFile << "include 'a', 'b'"
        buildFile << """
            project(':a') {
                artifacts {
                    compile layout.projectDirectory.dir('someDir')
                }
            }
            project(':b') {
                dependencies {
                    compile project(':a')
                }
            }
        """

        expect:

  bool found = false;
  while (TF_StringStreamNext(tempdirs, &tempdir)) {
    found = true;

    TF_Status* s = TF_NewStatus();

    ::tensorflow::string dirpath =
        ::tensorflow::io::JoinPath(tempdir, "somedir");
    TF_CreateDir(dirpath.c_str(), s);
    ASSERT_TF_OK(s) << "TF_CreateDir failed for " << dirpath << ": "
                    << TF_Message(s);

    ::tensorflow::string filepath =

    }

    @Issue('GRADLE-3511')
    def 'Filename #filename is properly masked when adding it as #antType to an ant task'(String filename, antType) {
        given:
        def dirname = 'somedir$$with'
        def dirAndFile = "${dirname}/${filename}"
        project.file(dirname).mkdir()
        File fileWithDollars = project.file(dirAndFile)
        fileWithDollars << "Some Text"

        e.message == "Could not read <display-name> '$file' as it does not exist." as String
    }

    def hasNoContentWhenFileIsADirectory() {
        when:
        TestFile dir = testDir.file('somedir').createDir()
        UriTextResource resource = new UriTextResource('<display-name>', dir, resolver)

        then:
        resource.exists

        when:
        resource.text

        then: