import org.gradle.internal.HasInternalProtocol;

import java.util.Map;

/**
 * A {@code RepositoryHandler} manages a set of repositories, allowing repositories to be defined and queried.
 */
@HasInternalProtocol
public interface RepositoryHandler extends ArtifactRepositoryContainer {

    /**

Laura Kassovic <******@****.***> 1701107622 -0800

 *
 * @param url the base URL of this repository. This URL is used to find both POMs and artifact files.
 * @return The added repository.
 *
 * @see [RepositoryHandler.maven]
 * @see [MavenArtifactRepository.setUrl]
 */
fun RepositoryHandler.maven(url: Any) =
    maven { setUrl(url) }


/**
 * Adds and configures a Maven repository.
 *

    ) {
        this.sharedServices = gradle.getSharedServices();
        this.repositoryHandler = objectFactory.newInstance(DefaultJavaToolchainRepositoryHandler.class, instantiator, objectFactory, providerFactory, authenticationSchemeRegistry);
    }

    @Override
    public JavaToolchainRepositoryHandlerInternal getRepositories() {
        return repositoryHandler;
    }

    @Override

            }
        }

        verify(repository).name = "repo name"
    }

    private
    inline operator fun RepositoryHandler.invoke(action: RepositoryHandler.() -> Unit) = apply(action)

    private
    fun mavenRepositoryHandlerMockFor(repository: MavenArtifactRepository) = mock<RepositoryHandler> {
        on { maven(any<Action<MavenArtifactRepository>>()) }.then {
            it.configureWithAction(repository)
        }

        RepositoryHandler repositoryHandler = dependencyResolutionServices.getResolveRepositoryHandler();
        for (ArtifactRepository repository : sharedRepositories) {
            // Add a wrapper to the plugin, so that each scope (eg project) can define different exclusive content filters
            repositoryHandler.add(new PluginArtifactRepository(repository));
        }

import org.gradle.api.artifacts.dsl.RepositoryHandler;
import org.gradle.api.publish.PublicationContainer;
import org.gradle.api.publish.PublishingExtension;

public class DefaultPublishingExtension implements PublishingExtension {
    private final RepositoryHandler repositories;
    private final PublicationContainer publications;

    public DefaultPublishingExtension(RepositoryHandler repositories, PublicationContainer publications) {

     * </pre>
     *
     * The {@code repositories} block is backed by a {@link RepositoryHandler}, which is the same DSL as that that is used for declaring repositories to consume dependencies from. However,
     * certain types of repositories that can be created by the repository handler are not valid for publishing, such as {@link org.gradle.api.artifacts.dsl.RepositoryHandler#mavenCentral()}.
     * <p>

        when:
        handler.repositories(configure)

        then:
        1 * depMgmtServices.resolveRepositoryHandler >> repositoryHandler
        1 * repositoryHandler.configure(configure) >> { ConfigureUtil.configureSelf(configure, repositoryHandler) }
        1 * repositoryHandler.mavenCentral()
    }

    def "can configure dependencies"() {
        when:
        handler.dependencies {

        defineConfiguration();
        return dependencyHandler;
    }

    @Override
    public RepositoryHandler getRepositories() {
        if (repositoryHandler == null) {
            repositoryHandler = dependencyResolutionServices.getResolveRepositoryHandler();
        }
        return repositoryHandler;
    }

    @Override
    public void repositories(Closure configureClosure) {