given:
        def file = tmpDir.file("thing")
        def prop = propertyWithNoValue()
        prop.set(file)

        expect:
        prop.get().asFile == file
    }

    def "can set value using relative file"() {
        given:
        def file = new File("thing")
        def prop = propertyWithNoValue()
        prop.set(file)

        expect:
        prop.get().asFile == tmpDir.file("thing")

    @Override
    PropertyInternal<T> providerWithValue(T value) {
        return propertyWithNoValue().value(value)
    }

    @Override
    PropertyInternal<T> providerWithNoValue() {
        return propertyWithNoValue()
    }

    /**
     * Returns a property with _no_ value.
     */
    abstract PropertyInternal<T> propertyWithNoValue()

    @Override
    String getDisplayName() {
        return "this property"

    AbstractProperty<T, ? extends ValueSupplier> providerWithValue(T value) {
        return propertyWithNoValue().value(value)
    }

    @Override
    AbstractProperty<T, ? extends ValueSupplier> providerWithNoValue() {
        return propertyWithNoValue()
    }

    @Override
    abstract AbstractProperty<T, ? extends ValueSupplier> propertyWithNoValue()

    AbstractProperty<T, ? extends ValueSupplier> propertyWithValue(T value) {

    }

    @Override
    RegularFile someOtherValue3() {
        return baseDirectory.file("other3").get()
    }

    @Override
    PropertyInternal<RegularFile> propertyWithNoValue() {
        return factory.newFileProperty()
    }

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

    }

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

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

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

    }

    DefaultProperty propertyWithDefaultValue(Class type) {
        return new DefaultProperty(host, type)
    }

    @Override
    DefaultProperty<String> propertyWithNoValue() {
        return property()
    }

    @Override
    Class<String> type() {
        return String
    }

    @Override
    String someValue() {
        return "value1"
    }

    AbstractCollectionProperty<String, C> propertyWithDefaultValue() {
        return property()
    }

    @Override
    AbstractCollectionProperty<String, C> propertyWithNoValue() {
        def p = property()
        p.set((List) null)
        return p
    }

    @Override
    C someValue() {
        return toMutable(["s1", "s2"])
    }

    @Override

    DefaultMapProperty<String, String> property() {
        new DefaultMapProperty<String, String>(host, String, String)
    }

    @Override
    DefaultMapProperty<String, String> propertyWithNoValue() {
        def p = property()
        p.set((Map) null)
        return p
    }

    @Override
    Class<Map<String, String>> type() {
        return Map
    }

    @Override