def "uses current JVM toolchain compiler as convention and sets source and target compatibility"() {
        def javaCompile = project.tasks.create('compileJava', JavaCompile)
        javaCompile.destinationDirectory.fileValue(new File('tmp'))
        def javaHome = Jvm.current().javaHome

        when:
        def spec = javaCompile.createSpec()
        def actualCompiler = javaCompile.javaCompiler.get()

        then:

    // Make sure that `baseDir` isn't the same as the base for the resolver.
    def baseDir = tmpDir.testDirectory.createDir("base")
    def baseDirectory = factory.newDirectoryProperty().fileValue(baseDir)

    def "can set value using absolute file"() {
        given:
        def file = tmpDir.file("thing")
        def prop = propertyWithNoValue()
        prop.set(file)

        expect:

    }

    def "fails if custom Java home does not exist"() {
        def javaCompile = project.tasks.create("compileJava", JavaCompile)
        javaCompile.destinationDirectory.fileValue(temporaryFolder.createDir())
        def invalidJavaHome = "invalidJavaHome"

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.javaHome = new File("invalidJavaHome")

            def testRootDir = temporaryFolder.getTestDirectory().getCanonicalFile()
            getBuildDirectory() >> projectDirProperty.fileValue(new File(testRootDir, "build"))
            getProjectDirectory() >> projectDirProperty.fileValue(testRootDir).get()
        }
        getConvention() >> Stub(Convention) {
            findPlugin(_) >> null
        }

    /**
     * {@inheritDoc}
     */
    @Override
    RegularFileProperty value(Provider<? extends RegularFile> provider);

    /**
     * {@inheritDoc}
     */
    @Override
    RegularFileProperty fileValue(@Nullable File file);

    /**
     * {@inheritDoc}
     */
    @Override
    RegularFileProperty fileProvider(Provider<File> provider);

    /**
     * {@inheritDoc}
     */
    @Override

            beforeSettings { settings ->
                def retentionFile = new File(settings.rootDir, '${retentionFileName}')
                def retentionFileProperty = settings.services.get(ObjectFactory).fileProperty().fileValue(retentionFile)
                def retentionTimeStampProvider = settings.providers.fileContents(retentionFileProperty).asText.map { it as long }
                settings.caches {

                .replaceWith("outputLocation")
                .willBeRemovedInGradle9()
                .withDslReference()
                .nagUser();

        getOutputLocation().fileValue(file);
    }
    @Override
    public OutputType getOutputType() {
        return outputType;
    }

    @Override
    public Report configure(Closure configure) {

        }
        Class<?> valueClass = value.getClass();
        if (valueClass.equals(File.class)) {
            // Not subtypes as we don't know whether they are immutable or not
            return visitor.fileValue((File) value);
        }
        if (value instanceof Number) {
            if (value instanceof Integer) {
                return visitor.integerValue((Integer) value);
            }

            }

            if (gradle.parent == null) {
                def collector = gradle.sharedServices.registerIfAbsent("originsCollector", OriginCollector) {
                    parameters.originJson.fileValue(new File("${TextUtil.normaliseFileSeparators(file.absolutePath)}"))
                }
                gradle.services.get(${BuildEventListenerRegistryInternal.name}).onOperationCompletion(collector)
            }
        """

        when:
        writeableProperty(JavaTestSubject, "myProperty2", File.class).setValue(myProperties, new File("fileValue"))

        then:
        readableProperty(JavaTestSubject, String, "myProperty2").getValue(myProperties) == "fileValue"
    }

    def "picks the generic object setter if the typed setter does not match the value type"() {
        when: