*
 * @param <T> the type of the property value
 */
public class DefaultProperty<T> extends AbstractProperty<T, ProviderInternal<? extends T>> implements Property<T> {
    private final Class<T> type;
    private final ValueSanitizer<T> sanitizer;
    private final static ProviderInternal<?> NOT_DEFINED = Providers.notDefined();

    public DefaultProperty(PropertyHost propertyHost, Class<T> type) {
        super(propertyHost);

    def "equals should return true for 2 containers with different provider instances that return the same value"() {
        Property<String> testProperty1 = new DefaultProperty<>(Mock(PropertyHost), String).convention("value")
        Property<String> testProperty2 = new DefaultProperty<>(Mock(PropertyHost), String).convention("value")
        def testAttribute = Attribute.of("test", String)

        TestFile manifestFile = tmpDir.file('manifest')
        fileResolver.resolve('manifest') >> manifestFile
        def mainValue = new DefaultProperty<>(Mock(PropertyHost), String)
        mainValue.set('hello')
        Map mainAttributes = [mainKey: mainValue]
        def sectionValue = new DefaultProperty<>(Mock(PropertyHost), String)
        sectionValue.set('world')
        Map sectionAttributes = [sectionKey: sectionValue]

    public DefaultPropertyFactory(PropertyHost propertyHost) {
        this.propertyHost = propertyHost;
    }

    @Override
    public <T> DefaultProperty<T> property(Class<T> type) {
        return new DefaultProperty<>(propertyHost, type);
    }

    @Override
    public <T> DefaultListProperty<T> listProperty(Class<T> elementType) {
        return new DefaultListProperty<>(propertyHost, elementType);

 */

package org.gradle.api.services.internal;

import org.gradle.api.artifacts.component.BuildIdentifier;
import org.gradle.api.internal.provider.AbstractMinimalProvider;
import org.gradle.api.internal.provider.DefaultProperty;
import org.gradle.api.internal.provider.ProviderInternal;
import org.gradle.api.provider.Provider;
import org.gradle.api.services.BuildService;
import org.gradle.api.services.BuildServiceParameters;

import org.gradle.api.file.RegularFileProperty;
import org.gradle.api.file.SourceDirectorySet;
import org.gradle.api.internal.provider.DefaultListProperty;
import org.gradle.api.internal.provider.DefaultProperty;
import org.gradle.api.internal.provider.PropertyHost;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.ListProperty;
import org.gradle.api.provider.MapProperty;

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface PropertyFactory {
    <T> DefaultProperty<T> property(Class<T> type);

    <T> DefaultListProperty<T> listProperty(Class<T> elementType);

    <T> DefaultSetProperty<T> setProperty(Class<T> elementType);

) : Codec<DefaultProperty<*>> {

    override suspend fun WriteContext.encode(value: DefaultProperty<*>) {
        encodePreservingIdentityOf(value) {
            writeClass(value.type as Class<*>)
            providerCodec.run { encodeProvider(value.provider) }
        }
    }

    override suspend fun ReadContext.decode(): DefaultProperty<*> {
        return decodePreservingIdentity { id ->

import org.gradle.util.TestUtil

class DefaultPropertyTest extends AbstractPropertySpec<String> {
    DefaultProperty<String> property() {
        return propertyWithDefaultValue(String)
    }

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

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

    @Override

     * Intended for tests of providers which aren't properties.
     */
    trait UsesStringProperty {
        DefaultProperty<String> property() {
            return TestUtil.objectFactory().property(String) as DefaultProperty<String>
        }
    }

    static class ProducerDiscardingProvider<T> extends AbstractMinimalProvider<T> {
        private final ProviderInternal<T> provider