@Deprecated
    @Override
    public final Provider<T> forUseAtConfigurationTime() {
        DeprecationLogger.deprecateMethod(Provider.class, "forUseAtConfigurationTime")
            .withAdvice("Simply remove the call.")
            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(7, "for_use_at_configuration_time_deprecation")
            .nagUser();
        return this;
    }

    @Override

        project.getExtensions().add("environments", serverEnvironmentContainer);

        serverEnvironmentContainer.all(serverEnvironment -> {
            String env = serverEnvironment.getName();
            String capitalizedServerEnv = env.substring(0, 1).toUpperCase() + env.substring(1);

dependencies {
    implementation("log4j:log4j:1.2.12")  // <1>
}
// end::compile-dependencies[]

// tag::pom-dependencies[]
dependencies {
    testImplementation("org.codehaus.groovy:groovy-all:2.5.4")
}
// end::pom-dependencies[]

// tag::process-resources[]
tasks {
    processResources {
        expand("version" to version, "buildNumber" to currentBuildNumber)
    }
}
// end::process-resources[]

 * A provider that takes a list of providers of values and provides a list of those values.
 *
 * This effectively converts a {@code List<Provider<T>>} to a {@code Provider<List<T>>}.
 *
 * @param <R> The type of the values that all source providers must share.
 */
public class MergeProvider<R> extends AbstractMinimalProvider<List<R>> {

    private final List<Provider<R>> items;

    public MergeProvider(List<Provider<R>> items) {

    }

    public void named(String name, Closure<? super I> configAction) {
        named(name, new ClosureBackedAction<I>(configAction));
    }

    public void all(Closure<? super I> configAction) {
        all(new ClosureBackedAction<I>(configAction));
    }

    public <S> void withType(Class<S> type, Closure<? super S> configAction) {
        withType(type, new ClosureBackedAction<S>(configAction));
    }

        def ex = thrown(IllegalArgumentException)
        ex.message == "Unable to calculate percentage: 50 of -10. All inputs must be >= 0"

        when:
        percentOf(-1, 100) == 0
        then:
        ex = thrown(IllegalArgumentException)
        ex.message == "Unable to calculate percentage: -1 of 100. All inputs must be >= 0"
    }

 * are resolved to variant-level precision, meaning that if resolved variant
 * is published to different coordinates than the declared component, the
 * variant coordinates are returned.
 *
 * <p>Implementations of this class may fall-back to component-level precision when
 * variant-level precision is not available for a given dependency.</p>
 */
public interface VariantDependencyResolver {

    /**

    implementation("com.google.guava:guava")
    implementation("com.uwyn:jhighlight") {
        exclude(module = "servlet-api")
    }
    implementation("com.vladsch.flexmark:flexmark-all")
    implementation("commons-lang:commons-lang")
    implementation("org.asciidoctor:asciidoctor-gradle-jvm")
    implementation("org.asciidoctor:asciidoctorj")
    implementation("org.asciidoctor:asciidoctorj-pdf")

    override fun asArguments() : Iterable<String> {
        return if (test.javaVersion.isCompatibleWith(JavaVersion.VERSION_1_9)) {
            listOf("--add-opens=java.base/java.lang=ALL-UNNAMED")
        } else {
            emptyList()
        }
    }
}
tasks.withType<Test>().configureEach {
    jvmArgumentProviders.add(AddOpensArgProvider(this))

            useJUnitJupiter('5.7.1')
        }

        integrationTest(JvmTestSuite) {
            dependencies {
                implementation project()
            }

            targets {
                all {
                    testTask.configure {
                        shouldRunAfter(test)
                    }
                }
            }
        }
    }
}