}

        buildFile << """
            dependencies {
                conf('org:platform-a:1.0') {
                    endorseStrictVersions()
                }
                conf('org:platform-b:1.0') {
                    endorseStrictVersions()
                }
                conf('org:foo')
            }
        """

        when:
        repositoryInteractions {

    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:

            .withVariant('api') {
                dependsOn('jack', 'bom', '1.0') {
                    endorseStrictVersions = true
                    attribute(Category.CATEGORY_ATTRIBUTE.name, Category.REGULAR_PLATFORM)
                }
                dependsOn('spring', 'bom', '2.0') {
                    endorseStrictVersions = true
                    attribute(Category.CATEGORY_ATTRIBUTE.name, Category.REGULAR_PLATFORM)

        final List<Capability> requestedCapabilities
        final boolean endorseStrictVersions
        final ArtifactSelectorSpec artifactSelector

        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() {