List<ExcludeSpec> exclusions = []
    boolean endorseStrictVersions
    String reason
    Map<String, Object> attributes
    List<CapabilitySpec> requestedCapabilities = []
    ArtifactSelectorSpec artifactSelector

                                }
                                rejects d.rejects
                            }
                            if (d.endorseStrictVersions) {
                                endorseStrictVersions d.endorseStrictVersions
                            }
                            if (d.reason) {
                                reason d.reason
                            }

        final boolean endorseStrictVersions;
        final String reason;
        final ArtifactSelector artifactSelector;

        public Dependency(
            DependencyCoordinates coordinates,
            Set<ExcludeRule> excludeRules,
            List<Attribute> attributes,
            List<Capability> requestedCapabilities,
            boolean endorseStrictVersions,
            String reason,

        when:
        metadata.endorseStrictVersions()

        then:
        metadata.endorsingStrictVersions
    }

    def "can reset endoreStrictVersion"() {
        given:
        def metadata = new DirectDependencyMetadataImpl("g", "a", "v")

        when:
        metadata.endorseStrictVersions()
        metadata.doNotEndorseStrictVersions()

        then:

        delegate.exclude(excludeProperties)

    override fun getReason(): String? =
        delegate.reason

    override fun endorseStrictVersions() =
        delegate.endorseStrictVersions()

    override fun doNotEndorseStrictVersions() =
        delegate.doNotEndorseStrictVersions()

    override fun isEndorsingStrictVersions() =

    }

    @Override
    public List<Capability> getRequestedCapabilities() {
        return delegate.getRequestedCapabilities();
    }

    @Override
    public void endorseStrictVersions() {
        delegate.endorseStrictVersions();
    }

    @Override
    public void doNotEndorseStrictVersions() {
        delegate.doNotEndorseStrictVersions();
    }

    @Override

    private boolean endorsing = false;

    public DirectDependencyMetadataImpl(String group, String name, String version) {
        super(group, name, version);
    }

    @Override
    public void endorseStrictVersions() {
        endorsing = true;
    }

    @Override
    public void doNotEndorseStrictVersions() {
        endorsing = false;
    }

    @Override
    public boolean isEndorsingStrictVersions() {

     * resolution as if they were defined by the endorsing module itself.
     *
     * @since 6.0
     */
    void endorseStrictVersions();

    /**
     * Resets the {@link #isEndorsingStrictVersions()} state of this dependency.
     *
     * @since 6.0
     */
    void doNotEndorseStrictVersions();

    /**

    public DirectDependencyMetadataAdapter(ImmutableAttributesFactory attributesFactory, ModuleDependencyMetadata metadata) {
        super(attributesFactory, metadata);
    }

    @Override
    public void endorseStrictVersions() {
        updateMetadata(getMetadata().withEndorseStrictVersions(true));
    }

    @Override
    public void doNotEndorseStrictVersions() {
        updateMetadata(getMetadata().withEndorseStrictVersions(false));

    def "add via string id with action is propagate to the underlying dependency list"() {
        when:
        adapter.add("org.gradle.test:module1") {
            it.version { it.require '1.0' }
            it.endorseStrictVersions()
        }

        then:
        dependenciesMetadata.size() == 1
        dependenciesMetadata[0].selector.group == "org.gradle.test"
        dependenciesMetadata[0].selector.module == "module1"