/**
     * Configures a configuration with reasonable defaults to be resolved as a runtime classpath.
     *
     * @param configuration the configuration to be configured
     */
    void configureAsRuntimeClasspath(HasConfigurableAttributes<?> configuration);

            additionalAuxDepsConfiguration.setVisible(false);
        });
        getJvmPluginServices().configureAsRuntimeClasspath(auxClasspath);
    }

    @Override
    protected void configureConfiguration(Configuration configuration) {
        configureDefaultDependencies(configuration);
    }

    @Override

            dependencies.create("org.apache.maven.resolver:maven-resolver-transport-wagon:" + MAVEN_RESOLVER_VERSION)
        );
        jvmPluginServices.configureAsRuntimeClasspath(config);
        detachedResolver.getRepositories().mavenCentral();
        mavenClasspath = config;
    }

    @Override
    public void generate(InitSettings initSettings) {

        configureAttributes(
            configuration,
            details -> details.library().apiUsage().withExternalDependencies().preferStandardJVM()
        );
    }

    @Override
    public void configureAsRuntimeClasspath(HasConfigurableAttributes<?> configuration) {
        configureAttributes(
            configuration,
            details -> details.library().runtimeUsage().asJar().withExternalDependencies().preferStandardJVM()

        configuration.setVisible(false);
        configuration.setTransitive(true);
        configuration.setDescription("The " + getToolName() + " libraries to be used for this project.");
        getJvmPluginServices().configureAsRuntimeClasspath(configuration);

        // Don't need these things, they're provided by the runtime
        configuration.exclude(excludeProperties("ant", "ant"));

        project.getPlugins().withType(JavaBasePlugin.class, plugin -> {
            // If the current project is jvm-based, aggregate dependent projects as jvm-based as well.
            getJvmPluginServices().configureAsRuntimeClasspath(testAggregation);
        });

        // convention for synthesizing reports based on existing test suites in "this" project
        project.getPlugins().withId("jvm-test-suite", plugin -> {

        project.getPlugins().withType(JavaBasePlugin.class, plugin -> {
            // If the current project is jvm-based, aggregate dependent projects as jvm-based as well.
            getEcosystemUtilities().configureAsRuntimeClasspath(codeCoverageResultsConf);
        });

        ObjectFactory objects = project.getObjects();

        ArtifactView sourceDirectories = codeCoverageResultsConf.getIncoming().artifactView(view -> {

        RoleBasedConfigurationContainerInternal configurations = project.getConfigurations();

        // Once these configurations become non-consumable, we can use
        // 'jvmPluginServices.configureAsRuntimeClasspath()' to configure the configurations.
        Configuration deployConfiguration = configurations.migratingUnlocked(DEPLOY_CONFIGURATION_NAME, ConfigurationRolesForMigration.LEGACY_TO_RESOLVABLE_DEPENDENCY_SCOPE);

                Configuration classpath = project.getConfigurations().detachedConfiguration(dependencies);
                getJvmPluginServices().configureAsRuntimeClasspath(classpath);
                return classpath;
            }

            // let's override this so that delegate isn't created at autowiring time (which would mean on every build)
            @Override

                  project.getConfigurations().detachedConfiguration(getScalaCompilerDependency(scalaVersion), compilerBridgeJar, compilerInterfaceJar);
                jvmPluginServices.configureAsRuntimeClasspath(scalaRuntimeClasspath);
                return scalaRuntimeClasspath;
            }

            // let's override this so that delegate isn't created at autowiring time (which would mean on every build)