def modifier = TestUtil.objectFactory().newInstance(PlatformDependencyModifiers.PlatformDependencyModifier)
        def dependency = new DefaultExternalModuleDependency("group", "name", "1.0")
        dependency.setAttributesFactory(AttributeTestUtil.attributesFactory())
        when:
        dependency = modifier.modify(dependency)
        then:
        dependency.isEndorsingStrictVersions()

    }

    private void injectServices(DependencyConstraint dependency) {
        if (dependency instanceof DefaultDependencyConstraint) {
            ((DefaultDependencyConstraint) dependency).setAttributesFactory(attributesFactory);
        }
    }

    // region DependencyConstraintFactory methods

    @Override
    public DependencyConstraint create(CharSequence dependencyNotation) {

        prepareProject(projectDependency);
        return projectDependency;
    }

    private void prepareProject(DefaultProjectDependency projectDependency) {
        projectDependency.setAttributesFactory(attributesFactory);
        projectDependency.setCapabilityNotationParser(capabilityNotationParser);
        projectDependency.setObjectFactory(objectFactory);
    }

            // We can only have attributes if we have the factory, then need to copy
            target.setAttributes(attributesFactory.mutable(attributes.asImmutable()));
        }
        target.setAttributesFactory(attributesFactory);
        target.setCapabilityNotationParser(capabilityNotationParser);
        target.setObjectFactory(objectFactory);
        if (moduleDependencyCapabilities != null) {

            this.classifier = classifier;
            this.artifactType = artifactType;
        }

        MinimalExternalModuleDependencyInternal internal = (MinimalExternalModuleDependencyInternal) delegate;
        setAttributesFactory(internal.getAttributesFactory());
        setCapabilityNotationParser(internal.getCapabilityNotationParser());
        setObjectFactory(internal.getObjectFactory());
    }

    private DefaultMinimalDependencyVariant(

        LOG.warn("Cannot set attributes for constraint \"" + this.getGroup() + ":" + this.getName() + ":" + this.getVersion() + "\": it was probably created by a plugin using internal APIs");
    }

    public void setAttributesFactory(ImmutableAttributesFactory attributesFactory) {
        this.attributesFactory = attributesFactory;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {

            if (notation instanceof DependencyVariant) {
                dependencyConstraint.setAttributesFactory(attributesFactory);
                DependencyVariant dependencyVariant = (DependencyVariant) notation;
                dependencyConstraint.attributes(dependencyVariant::mutateAttributes);

        if (dependency instanceof AbstractModuleDependency) {
            AbstractModuleDependency moduleDependency = (AbstractModuleDependency) dependency;
            moduleDependency.setAttributesFactory(attributesFactory);
            moduleDependency.setObjectFactory(objectFactory);
            moduleDependency.setCapabilityNotationParser(capabilityNotationParser);
        }
    }

    @Override

        DefaultMinimalDependency result = new DefaultMinimalDependency(
            DefaultModuleIdentifier.newId(data.getGroup(), data.getName()), new DefaultMutableVersionConstraint(version)
        );
        result.setAttributesFactory(attributesFactory);
        result.setCapabilityNotationParser(capabilityNotationParser);
        result.setObjectFactory(objectFactory);
        return result;
    }

    public static class VersionFactory {