_ * pathProvider.get() >> { "../other-dir" }
        _ * pathProvider.present >> true
        def otherDir = tmpDir.file("other-dir")

        expect:
        def dirVar = factory.newDirectoryProperty()
        def fileProvider = dirVar.asFile
        !dirVar.present
        dirVar.getOrNull() == null
        !fileProvider.present
        fileProvider.getOrNull() == null

        dirVar.set(otherDir)

 */

package org.gradle.api.internal.file;

import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.file.RegularFileProperty;

public interface FilePropertyFactory {
    DirectoryProperty newDirectoryProperty();

    RegularFileProperty newFileProperty();

                {
                    producer.call()
                }
            )
        }
        getLayout() >> Stub(ProjectLayout) {
            def projectDirProperty = TestFiles.filePropertyFactory().newDirectoryProperty()
            def testRootDir = temporaryFolder.getTestDirectory().getCanonicalFile()
            getBuildDirectory() >> projectDirProperty.fileValue(new File(testRootDir, "build"))

        public <T> T fromState(Class<T> type, Object state) {
            if (!type.isAssignableFrom(PUBLIC_TYPE)) {
                return null;
            }
            return type.cast(filePropertyFactory.newDirectoryProperty().value(Cast.<Provider<Directory>>uncheckedNonnullCast(state)));
        }

        @Override
        public int getId() {
            return FACTORY_ID;
        }
    }

    }

    @Override
    Directory someOtherValue3() {
        return baseDirectory.dir("other3").get()
    }

    @Override
    PropertyInternal<Directory> propertyWithNoValue() {
        return factory.newDirectoryProperty()
    }

    @Override
    ManagedFactory managedFactory() {
        new ManagedFactories.DirectoryPropertyManagedFactory(factory)
    }

    def "can view directory as a file tree"() {
        given:

        this.fileCollectionFactory = fileCollectionFactory;
        this.fileFactory = fileFactory;
        this.projectDir = fileFactory.dir(projectDir);
        this.buildDir = filePropertyFactory.newDirectoryProperty().convention(fileFactory.dir(fileResolver.resolve(Project.DEFAULT_BUILD_DIR_NAME)));
    }

    @Override
    public Directory getProjectDirectory() {
        return projectDir;
    }

    @Override

    // 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:

    }

    @Override
    public DirectoryProperty directoryProperty() {
        return filePropertyFactory.newDirectoryProperty();
    }

    @Override
    public RegularFileProperty fileProperty() {
        return filePropertyFactory.newFileProperty();
    }

    @Override

        this.host = host;
        this.fileResolver = resolver;
        this.fileCollectionFactory = fileCollectionFactory;
    }

    @Override
    public DirectoryProperty newDirectoryProperty() {
        return new DefaultDirectoryVar(host, fileResolver, fileCollectionFactory);
    }

    @Override
    public RegularFileProperty newFileProperty() {

    }

    override suspend fun ReadContext.decode(): DefaultDirectoryVar {
        val provider: Provider<Directory> = providerCodec.run { decodeProvider() }.uncheckedCast()
        return filePropertyFactory.newDirectoryProperty().value(provider) as DefaultDirectoryVar
    }
}


class RegularFilePropertyCodec(
    private val filePropertyFactory: FilePropertyFactory,