return implementation;
    }

    @Inject
    protected DependencyHandler getDependencyHandler() {
        throw new UnsupportedOperationException();
    }

    @Override
    public void implementation(Object notation) {
        implementation.getDependencies().add(getDependencyHandler().create(notation));
    }

    @Override

    @Override
    public void api(Object notation) {
        apiDependencies.getDependencies().add(getDependencyHandler().create(notation));
    }

    @Override
    public void api(Object notation, Action<? super ExternalModuleDependency> action) {
        ExternalModuleDependency dependency = (ExternalModuleDependency) getDependencyHandler().create(notation);
        action.execute(dependency);

        return contextId;
    }

    public Provider<CacheInstrumentationDataBuildService> getBuildService() {
        return buildService;
    }

    public DependencyHandler getDependencyHandler() {
        return dependencyHandler;
    }

    // Therefore, we cannot change its signature.
    ConfigurationContainer getConfigurationContainer();

    DependencyHandler getDependencyHandler();

    DependencyLockingHandler getDependencyLockingHandler();

    ImmutableAttributesFactory getAttributesFactory();

    AttributesSchema getAttributesSchema();

    ObjectFactory getObjectFactory();

        implDeps.dependencies >> deps

        dependencies = new DefaultComponentDependencies(configurations, "impl") {
            @Override
            protected DependencyHandler getDependencyHandler() {
                return dependencyFactory
            }
        }
    }

    def "can add implementation dependency"() {
        def dep = Stub(Dependency)

        when:

        apiDeps.dependencies >> deps

        dependencies = new DefaultLibraryDependencies(configurations, "impl", "api") {
            @Override
            protected DependencyHandler getDependencyHandler() {
                return dependencyFactory
            }
        }
    }

    def "can add api dependency"() {
        def dep = Stub(Dependency)

        when:
        dependencies.api("a:b:c")

        DependencyResolutionServices dependencyResolutionServices = dependencyResolutionServicesFactory.create();
        DependencyHandler dependencies = dependencyResolutionServices.getDependencyHandler();
        ConfigurationContainer configurations = dependencyResolutionServices.getConfigurationContainer();

        }
        if (dependencyHandler == null) {
            dependencyHandler = dependencyResolutionServices.getDependencyHandler();
            resolutionContext = buildLogicBuilder.prepareDependencyHandler(dependencyHandler);
        }
        if (classpathConfiguration == null) {

        DependencyHandler dependencyHandler = resolutionContext.getDependencyHandler();
        configuration.getDependencyConstraints().add(dependencyHandler.getConstraints().create(Log4jBannedVersion.LOG4J2_CORE_COORDINATES, constraint -> constraint.version(version -> {

    }

    private void addImportsToResolvableConfiguration(DependencyResolutionServices drs, Configuration cnf, Import imported) {
        Object notation = imported.notation;
        Dependency dependency = drs.getDependencyHandler().create(notation);
        cnf.getDependencies().add(dependency);
    }

    @SuppressWarnings("deprecation")
    private Configuration createResolvableConfiguration(DependencyResolutionServices drs) {